test/unit/services.agreement-template-field.v3.js

import test from 'ava';
import nock from 'nock';
import {
  client,
  clinical6,
  AgreementTemplateField,
} from '../../src';

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

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

test.beforeEach((t) => {
  client.cache = 'never';
  client.authToken = 'valid_token';

  nock(client.apiBaseUrl)
    .delete(/\/v3\/agreement\/template_fields\/([0-9]*)$/)
    .reply(200, '');

  t.context.storage = client.storageUtility;
  t.context.fieldJsonApi = {
    data: {
      type: 'agreement__template_fields',
      attributes: {
        label: 'Label for field 1',
        field_name: 'template_field_1',
        required: false,
        default_value: 'DEFAULT_VALUE',
        attribute_name: 'template_field_1_attribute',
        signer_index: 1,
        source_type: 'mobile_user'
      },
      relationships: {
        agreement_template: {
          data: {
            type: 'agreement__templates',
            id: 1
          }
        }
      }
    }
  };
  t.context.field = new AgreementTemplateField(t.context.fieldJsonApi);
});

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


// AgreementTemplateFieldService.delete method
/**
 * @test {Clinical6.delete}
 */
test('[unit] AgreementTemplateFieldService.delete should throw errors for invalid parameters', async (t) => {
  const title = `AgreementTemplateFieldService.delete error`;
  await t.throwsAsync(clinical6.delete(new AgreementTemplateField()), `${title}: template_field does not have id`);
});

/**
 * @test {Clinical6.delete}
 */
test('[unit] AgreementTemplateFieldService.delete should make a properly formatted delete request', async (t) => {
  const { field } = t.context;
  field.id = 5;
  const response = await clinical6.delete(field);
  // const request = t.context.server.requests[0];
  // t.is(request.method, 'DELETE');
  // t.is(request.url, `${client.apiBaseUrl}/v3/agreement/template_fields/${field.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');
  t.falsy(response);
});

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

  t.falsy(response);
});

/**
 * @test {Clinical6.delete}
 */
test.serial('[unit] AgreementTemplateFieldService.delete should remove the element from local storage', async (t) => {
  const { field, storage } = t.context;
  field.id = 5;
  await storage.set(field.type, field.toJSON(), { id: field.id });
  await clinical6.delete(field);
  t.is(storage.has(field.type, { id: field.id }), false);
});


// AgreementTemplateFieldService.get method
/**
 * @test {Clinical6.get}
 */
test.serial('[unit] AgreementTemplateFieldService.get should throw an error when there is no authToken', async (t) => {
  client.authToken = undefined;
  const title = 'AgreementTemplateFieldService.get error';
  await t.throwsAsync(clinical6.get(AgreementTemplateField), `${title}: requires authToken`);
});

// AgreementTemplateFieldService.insert method
/**
 * @test {Clinical6.insert}
 */
test.serial('[unit] AgreementTemplateFieldService.insert should throw an error when there is no authToken', async (t) => {
  client.authToken = undefined;
  const title = 'AgreementTemplateFieldService.insert error';
  await t.throwsAsync(clinical6.insert(new AgreementTemplateField()), `${title}: requires authToken`);
});

/**
 * @test {Clinical6.insert}
 */
test('[unit] AgreementTemplateFieldService.insert should successfully insert an agreement template field with an agreement template object', async (t) => {
  const requestJsonApi = {
    data: {
      type: 'agreement__template_fields',
      attributes: {
        label: 'Label for field 1',
        field_name: 'template_field_1',
        required: false,
        default_value: 'DEFAULT_VALUE',
        attribute_name: 'template_field_1_attribute',
        signer_index: 1,
        source_type: 'mobile_user'
      },
      relationships: {
        agreement_template: {
          data: {
            type: 'agreement__templates',
            id: 1
          }
        }
      }
    }
  };

  let requestBody = {};
  const server = nock(client.apiBaseUrl)
    .post('/v3/agreement/template_fields', (body) => {
      requestBody = body;
      return requestJsonApi;
    })
    .reply(201, {
      data: {
        id: 1,
        type: 'agreement__template_fields',
        attributes: {
          source_type: 'mobile_user'
        }
      }
    });

  const agreementTemplateField = new AgreementTemplateField(requestJsonApi);
  const response = await clinical6.insert(agreementTemplateField);
  t.deepEqual(requestBody, requestJsonApi);
  server.done();

  t.true(response instanceof AgreementTemplateField);
  t.is(response.id, 1);
  t.is(response.type, 'agreement__template_fields');
  t.is(response.sourceType, 'mobile_user');
});

/**
 * @test {Clinical6.insert}
 */
test('[unit] AgreementTemplateFieldService.insert should throw an error without the necessary attributes', async (t) => {
  const requestJsonApi = {
    data: {
      type: 'agreement__template_fields',
      attributes: {
        label: 'Label for field 1',
        required: false,
        default_value: 'DEFAULT_VALUE',
        attribute_name: 'template_field_1_attribute',
        signer_index: 1,
        source_type: 'mobile_user'
      },
      relationships: {
        agreement_template: {
          data: {
            type: 'agreement__templates',
            id: 1
          }
        }
      }
    }
  };

  let requestBody = {};
  const server = nock(client.apiBaseUrl)
    .post('/v3/agreement/template_fields', (body) => {
      requestBody = body;
      return requestJsonApi;
    })
    .reply(422, {
      errors: [
        {
          source: {
            pointer: '/data/attributes/field_name'
          },
          detail: 'can\'t be blank'
        }
      ]
    });

  const agreementTemplateField = new AgreementTemplateField(requestJsonApi);
  const response = await clinical6.insert(agreementTemplateField).catch(err => err);
  t.deepEqual(requestBody, requestJsonApi);
  server.done();

  t.is(response.message, `"/data/attributes/field_name": can't be blank`);
});

// AgreementTemplateFieldService.update method