@sword-health/ui-http-mapper/test/Decoder.test.js

UI clients tool for consumption of easy to read/config endpoint maps

import EndpointDecoder from '../src/scripts/Decoder';
import endpoints from './mocks/endpoints.js';
import * as dymmyConfigs from './mocks/dummy-configs.js';
import { getRandomItemFromArray } from './tooling/helpers.js';

const decoderInstance = new EndpointDecoder(endpoints);

// at start of test you want to suppress
console.log = console.warn = console.error = jest.fn();

test('Endpoint decoder is defined', () => {
  expect(decoderInstance).toBeDefined();
});

// Do not accept invalid namespaces
describe('Name space is protected for any given malformed input', () => {
  dymmyConfigs.invalidNamespaces.forEach((namespace, index) => {
    //const foundConfig = decoderInstance.$http(namespace, { 'dosent': 'matter' });
    //expect(foundConfig).toBeDefined();
    test(`Testing malformed namespace ${index + 1}/${dymmyConfigs.invalidNamespaces.length}`, () => {
      const foundConfig = decoderInstance.$http(namespace, { 'dosent': 'matter' });
      expect(foundConfig).toBeUndefined();
    });
  });
});

describe('Can find configurations for any method type (obs. Ensure possible configs are defined)', () => {

  const oneNamespacePerMethodType = [
    {
      method: 'GET',
      namespace: getRandomItemFromArray(dymmyConfigs.dumbNamespacesByType.get),
    }, {
      method: 'POST',
      namespace: getRandomItemFromArray(dymmyConfigs.dumbNamespacesByType.post),
    }, {
      method: 'PUT',
      namespace: getRandomItemFromArray(dymmyConfigs.dumbNamespacesByType.put),
    }, {
      method: 'DELETE',
      namespace: getRandomItemFromArray(dymmyConfigs.dumbNamespacesByType.delete),
    },
  ];


  oneNamespacePerMethodType.forEach(({ method, namespace }) => {
    test(`Finding config for random ${method} method`, () => {
      const foundConfig = decoderInstance.$http(namespace, { 'dosent': 'matter' });
      expect(foundConfig).toBeDefined();
    });
  });

});

test('Could find N level deep endpoint configuration', () => {
  const deepEndpointConfig = decoderInstance.$http('patient/assessments/justAnotherLevelDeep/anodaOne', { 'dosent': 'matter' });
  expect(deepEndpointConfig).toBeDefined();
});

// Correctly forms url based on config and urlData passed on each call
test('Correctly forms URLs based on configs provided through urlData param on each call', () => {
  const urlData = {
    patientId: 451,
    formId: 669,
  };

  const expectURL = `clinical-forms/api/v1/451/669`;
  const endpointConfig = decoderInstance.$http('patient/assessments/deleteForm', urlData);

  expect(endpointConfig.url).toBe(expectURL);
});

// Could handle values modules
test('Could find configs on the various modules provided', () => {
});


// Only returns suitable configurations
test('Only returns suitable configurations', () => {
  const urlData = {
    patientId: 451,
    formId: 669,
  };
  const endpointConfig = decoderInstance.$http('patient/assessments', urlData);
  expect(endpointConfig).toBeUndefined();
});

// Correctly returns endpoint metadata when available
test('Correctly returns endpoint metadata populated when available', () => {
  const urlData = {
    patientId: 451,
  };

  const expectedMeta = { mockDir: '/some/mocked/data/path' };
  const endpointConfig = decoderInstance.$http('patient/assessments/getForms', urlData);
  expect(endpointConfig.meta).toMatchObject(expectedMeta);
});

// Merges configs giving prioprity to adhhoc ones
test('Merges default request configs with adhoc ones, giving priority to adhoc ones', () => {
  const urlData = {
    patientId: 451,
  };
  const requestConfigs = {
    config: {
      headers: 'Boda',
    },
  };
  //TODO SEE CAST HERE
  const expectedConfigs = {
    timeout: '5000',
    headers: 'Boda',
  };
  const endpointConfig = decoderInstance.$http('patient/assessments/getForms', urlData, requestConfigs);
  expect(endpointConfig.requestArgs).toStrictEqual([expectedConfigs]);
});

// drops request payload on get requests
test('Drops request payload if found method ends up being \'get\' type', () => {
  const urlData = {
    patientId: 451,
  };
  const requestConfigs = {
    body: {
      will: 'drop',
    },
    config: {
      headers: 'Boda',
    },
  };
  //TODO SEE CAST HERE
  const expectedConfigs = {
    timeout: '5000',
    headers: 'Boda',
  };
  const endpointConfig = decoderInstance.$http('patient/assessments/getForms', urlData, requestConfigs);
  expect(endpointConfig.requestArgs).toStrictEqual([expectedConfigs]);
});

test('Keeps request payload if request is POST, PUT, PATCH or DELETE', () => {
  const urlData = {
    patientId: 451,
  };
  const requestConfigs = {
    body: {
      will: 'drop',
    },
    config: {
      headers: 'Boda',
    },
  };

  const expectedPayload = {
    will: 'drop',
  };

  //TODO SEE CAST HERE
  const expectedConfigs = {
    headers: 'Boda',
  };

  const namespacessThatRequirePayload = [
    'patient/assessments/generateForm',
    'patient/assessments/reactivateForm',
    'patient/assessments/patchForm',
    'patient/assessments/deleteForm',
  ];

  namespacessThatRequirePayload.forEach(namespace => {
    const endpointConfig = decoderInstance.$http(namespace, urlData, requestConfigs);
    expect(endpointConfig.requestArgs).toStrictEqual([expectedPayload, expectedConfigs]);
  });
});

// Do nit explocde if theren't modules available
test('Does not explode is user does not provide any module to spec structure', () => {
  const urlData = {
    patientId: 451,
  };
  const decoderInstanceWithoutModules = new EndpointDecoder({});
  const endpointConfig = decoderInstanceWithoutModules.$http('patient/assessments/getForms', urlData);
  expect(endpointConfig).toBeUndefined();
});