test/unit/services.language.v3.js

import test from 'ava';
import nock from 'nock';
import { client, Language, languageService } from '../../src';

test.before('start server', () => {
  client.apiBaseUrl = 'https://somelanguage.Clinical6.com';
});

test.after('server shut down', () => {});

test.beforeEach((t) => {
  client.cache = 'never';
  client.authToken = 'valid_token';
  languageService.cacheMode = 'networkOnly';
  nock(client.apiBaseUrl).get(`/api/languages/en`).reply(200, { translations: {} });
  nock(client.apiBaseUrl).get(`/api/languages/`).reply(200, [
    {
      name: 'English',
      icon: {
        original: '/assets/default/default-4832093.png',
        thumb: '/assets/default/thumb_default-5238439.png'
      },
      iso: 'en'
    },
    {
      name: 'non',
      icon: {
        original: '/assets/default/default-4832093.png',
        thumb: '/assets/default/thumb_default-5238439.png'
      },
      iso: 'dummy_752'
    },
    {
      name: 'non',
      icon: {
        original: '/assets/default/default-4832093.png',
        thumb: '/assets/default/thumb_default-5238439.png'
      },
      iso: 'dummy_753'
    }
  ]);

  nock(client.apiBaseUrl).delete(/\/v3\/languages\/(\d*)$/).reply(200, { status: 'ok' });

  nock(client.apiBaseUrl).get(`/v3/languages`).reply(200, {
    data: [
      {
        id: '155',
        type: 'languages',
        attributes: {
          iso: 'en',
          name: 'English',
          is_default: true
        }
      },
      {
        id: '156',
        type: 'languages',
        attributes: {
          iso: 'dummy_1359',
          name: 'molestias',
          is_default: false
        }
      },
      {
        id: '157',
        type: 'languages',
        attributes: {
          iso: 'dummy_1360',
          name: 'molestias',
          is_default: false
        }
      },
      {
        id: '158',
        type: 'languages',
        attributes: {
          iso: 'dummy_1361',
          name: 'molestias',
          is_default: false
        }
      }
    ]
  });

  nock(client.apiBaseUrl).get(/\/v3\/languages\/(\d*)$/).reply(200, {
    data:
        {
          id: '175',
          type: 'languages',
          attributes: {
            iso: 'en',
            name: 'English',
            is_default: true
          }
        }
  });

  nock(client.apiBaseUrl).patch(/\/v3\/languages\/(\d*)$/).reply(200, {
    data: {
      id: '154',
      type: 'languages',
      attributes: {
        iso: 'dummy_1356',
        name: 'molestias',
        is_default: false
      }
    }
  });

  nock(client.apiBaseUrl).get(`/v3/languages`).reply(200, {
    data: [
      {
        id: '155',
        type: 'languages',
        attributes: {
          iso: 'en',
          name: 'English',
          is_default: true
        }
      },
      {
        id: '156',
        type: 'languages',
        attributes: {
          iso: 'dummy_1359',
          name: 'molestias',
          is_default: false
        }
      },
      {
        id: '157',
        type: 'languages',
        attributes: {
          iso: 'dummy_1360',
          name: 'molestias',
          is_default: false
        }
      },
      {
        id: '158',
        type: 'languages',
        attributes: {
          iso: 'dummy_1361',
          name: 'molestias',
          is_default: false
        }
      }
    ]
  });

  t.context.storage = client.storageUtility;
  client.language = new Language({});
  t.context.languageJsonApi = {
    data: {
      id: 155,
      type: 'languages',
      attributes: {
        iso: 'en',
        name: 'English',
        is_default: true
      }
    }
  };
  t.context.language = new Language(t.context.languageJsonApi);
});

// test.afterEach(t => t.context.server.restore());

// LanguageService.delete method
/**
 * @test {LanguageService.delete}
 */
test('[unit] LanguageService.delete should throw errors for invalid parameters', async (t) => {
  const title = `LanguageService.delete error`;
  await t.throwsAsync(languageService.delete({}), `${title}: language does not have id and language does not have type`);
  await t.throwsAsync(languageService.delete({ id: 5 }), `${title}: language does not have type`);
  await t.throwsAsync(languageService.delete({ type: 'languages' }), `${title}: language does not have id`);
});

// /**
//  * @test {LanguageService.delete}
//  */
// test('[unit] LanguageService.delete should make a properly formatted delete request', async (t) => {
//   const { language } = t.context;
//   language.id = 5;
//   await languageService.delete(language);
//   const request = t.context.server.requests[0];
//   t.is(request.method, 'DELETE');
//   t.is(request.url, `${client.apiBaseUrl}/v3/languages/${language.id}`);
//   t.is(request.requestHeaders.Accept, 'application/json');
//   t.is(request.requestHeaders['Content-Type'], 'application/json;charset=utf-8');
//   t.is(request.requestHeaders.Authorization, 'Token token=valid_token');
// });

/**
 * @test {LanguageService.delete}
 */
test('[unit] LanguageService.delete should receive a valid response for a delete request', async (t) => {
  const { language } = t.context;
  language.id = 5;
  const response = await languageService.delete(language);
  // const request = t.context.server.requests[0];
  // t.is(request.requestHeaders.Authorization, 'Token token=valid_token');

  t.truthy(response);
});

/**
 * @test {LanguageService.delete}
 */
test('[unit] LanguageService.delete should remove the element from local storage', async (t) => {
  const { language, storage } = t.context;
  language.id = 5;
  await storage.set('languages', language.toJSON(), { id: language.id });
  await languageService.delete(language);
  t.is(storage.has('languages', { id: language.id }), false);
});

// LanguageService.get
// /**
//  * @test {LanguageService.get}
//  */
// test('[unit] LanguageService.get should make a properly formatted get request', async (t) => {
//   await languageService.get();
//   const request = t.context.server.requests[0];
//   t.is(request.method, 'GET');
//   t.is(request.url, `${client.apiBaseUrl}/v3/languages`);
//   t.is(request.requestHeaders.Accept, 'application/json');
//   t.is(request.requestHeaders['Content-Type'], 'application/json;charset=utf-8');
//   t.is(request.requestHeaders.Authorization, 'Token token=valid_token');
// });

/**
 * @test {LanguageService.get}
 */
test('[unit] LanguageService.get should receive a valid response for a get request', async (t) => {
  const response = await languageService.get();
  t.truthy(response);
  t.is(response.length, 4);
  t.is(response[0].constructor.name, 'Language');
  t.is(response[0].id, 155);
  t.is(response[0].iso, 'en');
  t.is(response[0].name, 'English');
  t.is(response[1].constructor.name, 'Language');
  t.is(response[1].id, 156);
  t.is(response[1].iso, 'dummy_1359');
  t.is(response[1].name, 'molestias');
  t.is(response[2].constructor.name, 'Language');
  t.is(response[2].id, 157);
  t.is(response[2].iso, 'dummy_1360');
  t.is(response[2].name, 'molestias');
  t.is(response[3].constructor.name, 'Language');
  t.is(response[3].id, 158);
  t.is(response[3].iso, 'dummy_1361');
  t.is(response[3].name, 'molestias');
});

test.serial('[unit] LanguageService.get should receive a valid response for a get request that is cached', async (t) => {
  await languageService.get();
  languageService.cacheMode = 'cacheFirst';
  const response = await languageService.get();
  t.truthy(response);
  t.is(response.length, 4);
  t.is(response[0].constructor.name, 'Language');
  t.is(response[0].id, 155);
  t.is(response[0].iso, 'en');
  t.is(response[0].name, 'English');
  t.is(response[1].constructor.name, 'Language');
  t.is(response[1].id, 156);
  t.is(response[1].iso, 'dummy_1359');
  t.is(response[1].name, 'molestias');
  t.is(response[2].constructor.name, 'Language');
  t.is(response[2].id, 157);
  t.is(response[2].iso, 'dummy_1360');
  t.is(response[2].name, 'molestias');
  t.is(response[3].constructor.name, 'Language');
  t.is(response[3].id, 158);
  t.is(response[3].iso, 'dummy_1361');
  t.is(response[3].name, 'molestias');
});

test.serial('[unit] LanguageService.get should receive a valid response for a get request that is cached with id', async (t) => {
  await languageService.get();
  languageService.cacheMode = 'cacheFirst';
  const response = await languageService.get({ id: 155 });
  t.truthy(response);
  t.is(response.constructor.name, 'Language');
  t.is(response.id, 155);
  t.is(response.iso, 'en');
  t.is(response.name, 'English');
});

test.serial('[unit] LanguageService.get should receive a valid response for a get request where the id isnt yet cached', async (t) => {
  const { storage } = t.context;
  storage.clear('languages');
  languageService.cacheMode = 'cacheFirst';
  const response = await languageService.get({ id: 175 });
  // const request = t.context.server.requests[0];
  t.truthy(response);
  t.is(response.constructor.name, 'Language');
  t.is(response.id, 175);
  t.is(response.iso, 'en');
  t.is(response.name, 'English');
});

// LanguageService.getTranslations
/**
 * @test {LanguageService.getTranslations}
 */
test('[unit] LanguageService.getTranslations should throw an error when there is no authToken and iso', (t) => {
  const expectedError = 'Clinical6 getTranslations error: iso is not defined';
  t.throws(() => languageService.getTranslations(), expectedError);
});

/**
 * @test {LanguageService.getTranslations}
 */
test('[unit] LanguageService.getTranslations should throw an error when there is no iso value', (t) => {
  const expectedError = 'Clinical6 getTranslations error: iso is not defined';
  t.throws(() => languageService.getTranslations(), expectedError);
});

// /**
//  * @test {LanguageService.getTranslations}
//  */
// test('[unit] LanguageService.getTranslations should make a properly formatted get request', async (t) => {
//   await languageService.getTranslations('en');
//   const request = t.context.server.requests[0];
//   t.is(request.method, 'GET');
//   t.is(request.url, `${client.apiBaseUrl}/api/languages/en`);
//   t.is(request.requestHeaders.Accept, 'application/json');
//   t.is(request.requestHeaders['Content-Type'], 'application/json;charset=utf-8');
//   t.is(request.requestHeaders.Authorization, 'Token token=valid_token');
// });

/**
 * @test {LanguageService.getTranslations}
 */
test('[unit] LanguageService.getTranslations should receive a valid response for a get request', async (t) => {
  const response = await languageService.getTranslations('en');
  t.truthy(response);
  t.deepEqual(response, {});
});

// LanguageService.getLanguages
// /**
//  * @test {LanguageService.getLanguages}
//  */
// test('[unit] LanguageService.getLanguages should make a properly formatted get request', async (t) => {
//   await languageService.getLanguages();
//   const request = t.context.server.requests[0];
//   t.is(request.method, 'GET');
//   t.is(request.url, `${client.apiBaseUrl}/api/languages/`);
//   t.is(request.requestHeaders.Accept, 'application/json');
//   t.is(request.requestHeaders['Content-Type'], 'application/json;charset=utf-8');
//   t.is(request.requestHeaders.Authorization, 'Token token=valid_token');
// });

/**
 * @test {LanguageService.getLanguages}
 */
test.serial('[unit] LanguageService.getLanguages should receive a valid response for a get request', async (t) => {
  await languageService.getLanguages();
  languageService.cacheMode = 'cacheFirst';
  const response = await languageService.getLanguages();
  t.truthy(response);
  t.is(Object.keys(response).length, 3);
  t.is(response.en.constructor.name, 'Language');
  t.is(response.en.iso, 'en');
  t.is(response.en.name, 'English');
  t.is(response.dummy_752.constructor.name, 'Language');
  t.is(response.dummy_752.iso, 'dummy_752');
  t.is(response.dummy_752.name, 'non');
  t.is(response.dummy_753.constructor.name, 'Language');
  t.is(response.dummy_753.iso, 'dummy_753');
  t.is(response.dummy_753.name, 'non');
});

// LanguageService.insert method
/**
 * @test {LanguageService.insert}
 */
test.serial('[unit] LanguageService.insert should throw an error when there is no authToken', async (t) => {
  client.authToken = undefined;
  const language = new Language({
    type: 'languages',
    iso: 'en',
    name: 'English'
  });
  const title = 'LanguageService.insert error';
  await t.throwsAsync(languageService.insert(language), `${title}: requires authToken`);
});

/**
 * @test {LanguageService.insert}
 */
test('[unit] LanguageService.insert should successfully insert a language with a language object', async (t) => {
  nock(client.apiBaseUrl).post(`/v3/languages`).reply(201, {
    data: {
      id: 155,
      type: 'languages',
      attributes: {
        name: 'ut',
        iso: 'dummy_1431',
        is_default: false
      }
    }
  });

  const requestJsonApi = {
    data: {
      id: 155,
      type: 'languages',
      attributes: {
        iso: 'en',
        name: 'English',
        is_default: true
      }
    }
  };

  const language = new Language(requestJsonApi);
  const response = await languageService.insert(language);

  // const request = t.context.server.requests[0];
  // t.is(request.method, 'POST');
  // t.is(request.url, `${client.apiBaseUrl}/v3/languages`);
  // t.is(request.requestHeaders.Accept, 'application/json');
  // t.deepEqual(JSON.parse(request.requestBody), requestJsonApi);
  // t.is(request.requestHeaders['Content-Type'], 'application/json;charset=utf-8');
  // t.is(request.requestHeaders.Authorization, 'Token token=valid_token');
  t.is(response.id, 155);
  t.is(response.type, 'languages');
  t.is(response.iso, 'dummy_1431');
  t.is(response.name, 'ut');
  t.is(response.isDefault, false);
});

/**
 * @test {LanguageService.insert}
 */
test('[unit] LanguageService.insert should throw an error with an invalid token', async (t) => {
  languageService.cacheMode = 'networkOnly';
  nock(client.apiBaseUrl).post(`/v3/languages`).reply(422, {
    errors: [
      {
        source: {
          pointer: '/data/attributes/name'
        },
        detail: 'can\'t be blank'
      }
    ]
  });

  const requestJsonApi = {
    data: {
      id: 155,
      type: 'languages',
      attributes: {
        iso: 'en',
        name: 'English',
        is_default: true
      }
    }
  };

  const language = new Language(requestJsonApi);
  const response = await languageService.insert(language).catch(err => err);

  // const request = t.context.server.requests[0];
  // t.is(request.method, 'POST');
  // t.is(request.url, `${client.apiBaseUrl}/v3/languages`);
  // t.is(request.requestHeaders.Accept, 'application/json');
  // t.is(request.requestBody, JSON.stringify(requestJsonApi));
  // t.is(request.requestHeaders['Content-Type'], 'application/json;charset=utf-8');
  // t.is(request.requestHeaders.Authorization, 'Token token=valid_token');
  t.is(response.message, `"/data/attributes/name": can't be blank`);
});


// LanguageService.update method
/**
 * @test {LanguageService.update}
 */
test('[unit] LanguageService.update should throw errors for invalid parameters', async (t) => {
  const title = 'LanguageService.update error';
  await t.throwsAsync(languageService.update(), `${title}: language is not defined`);
});


/**
 * @test {LanguageService.update}
 */
test('[unit] LanguageService.update should successfully update a language with a language object', async (t) => {
  const { language } = t.context; // languageJsonApi
  const response = await languageService.update(language);

  // const request = t.context.server.requests[0];
  // t.is(request.method, 'PATCH');
  // t.is(request.url, `${client.apiBaseUrl}/v3/languages/${language.id}`);
  // t.is(request.requestHeaders.Accept, 'application/json');
  // t.deepEqual(JSON.parse(request.requestBody), languageJsonApi);
  // t.is(request.requestHeaders['Content-Type'], 'application/json;charset=utf-8');
  // t.is(request.requestHeaders.Authorization, 'Token token=valid_token');
  t.is(response.id, 154);
  t.is(response.type, 'languages');
});