@openmrs/esm-dispensing-app/src/utils.test.ts

Medication dispensing application

import {
  type Coding,
  type DosageInstruction,
  type Medication,
  type MedicationDispense,
  MedicationDispenseStatus,
  type MedicationReferenceOrCodeableConcept,
  type MedicationRequest,
  type MedicationRequestBundle,
  MedicationRequestCombinedStatus,
  MedicationRequestFulfillerStatus,
  MedicationRequestStatus,
} from './types';
import {
  computeMedicationRequestCombinedStatus,
  computeMedicationRequestStatus,
  computeNewFulfillerStatusAfterDelete,
  computeNewFulfillerStatusAfterDispenseEvent,
  computePrescriptionStatus,
  computeQuantityRemaining,
  computeTotalQuantityDispensed,
  computeTotalQuantityOrdered,
  getAssociatedMedicationDispenses,
  getAssociatedMedicationRequest,
  getConceptCoding,
  getConceptCodingDisplay,
  getConceptCodingUuid,
  getDosageInstruction,
  getMedicationDisplay,
  getMedicationReferenceOrCodeableConcept,
  getMedicationsByConceptEndpoint,
  getMostRecentMedicationDispenseStatus,
  getNextMostRecentMedicationDispenseStatus,
  getOpenMRSMedicineDrugName,
  getPrescriptionDetailsEndpoint,
  getPrescriptionTableActiveMedicationRequestsEndpoint,
  getPrescriptionTableAllMedicationRequestsEndpoint,
  getQuantity,
  getQuantityUnitsMatch,
  getRefillsAllowed,
  isMostRecentMedicationDispense,
} from './utils';
import dayjs from 'dayjs';

describe('Util Tests', () => {
  describe('test computeMedicationRequestCombinedStatus', () => {
    test('should return on-hold if status active and fulfiller status on-hold', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.active,
        subject: { display: '', reference: '', type: '' },
        extension: [
          {
            url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
            valueCode: MedicationRequestFulfillerStatus.on_hold,
          },
        ],
      };
      expect(computeMedicationRequestCombinedStatus(medicationRequest, 90)).toBe(
        MedicationRequestCombinedStatus.on_hold,
      );
    });
    test('should return declined if status active and fulfiller status declined', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.active,
        subject: { display: '', reference: '', type: '' },
        extension: [
          {
            url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
            valueCode: MedicationRequestFulfillerStatus.declined,
          },
        ],
      };
      expect(computeMedicationRequestCombinedStatus(medicationRequest, 90)).toBe(
        MedicationRequestCombinedStatus.declined,
      );
    });
    test('should return completed if status completed and fulfiller status completed', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.completed,
        subject: { display: '', reference: '', type: '' },
        extension: [
          {
            url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
            valueCode: MedicationRequestFulfillerStatus.completed,
          },
        ],
      };
      expect(computeMedicationRequestCombinedStatus(medicationRequest, 90)).toBe(
        MedicationRequestCombinedStatus.completed,
      );
    });
    test('should return cancelled if status cancelled and no fulfiller status', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.cancelled,
        subject: { display: '', reference: '', type: '' },
      };
      expect(computeMedicationRequestCombinedStatus(medicationRequest, 90)).toBe(
        MedicationRequestCombinedStatus.cancelled,
      );
    });
    test('should return cancelled if status cancelled and fulfiller on-hold', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.cancelled,
        subject: { display: '', reference: '', type: '' },
        extension: [
          {
            url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
            valueCode: MedicationRequestFulfillerStatus.on_hold,
          },
        ],
      };
      expect(computeMedicationRequestCombinedStatus(medicationRequest, 90)).toBe(
        MedicationRequestCombinedStatus.cancelled,
      );
    });
    test('should return cancelled if status cancelled and fulfiller declined', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.cancelled,
        subject: { display: '', reference: '', type: '' },
        extension: [
          {
            url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
            valueCode: MedicationRequestFulfillerStatus.declined,
          },
        ],
      };
      expect(computeMedicationRequestCombinedStatus(medicationRequest, 90)).toBe(
        MedicationRequestCombinedStatus.cancelled,
      );
    });
    test('should return expired if validity period over 90 days ago and no fulfiller status', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '2020-04-04' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.active,
        subject: { display: '', reference: '', type: '' },
      };
      expect(computeMedicationRequestCombinedStatus(medicationRequest, 90)).toBe(
        MedicationRequestCombinedStatus.expired,
      );
    });
    test('should return expired if validity period over 90 days and fulfiller status on-hold', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '2020-04-04' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.active,
        subject: { display: '', reference: '', type: '' },
        extension: [
          {
            url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
            valueCode: MedicationRequestFulfillerStatus.on_hold,
          },
        ],
      };
      expect(computeMedicationRequestCombinedStatus(medicationRequest, 90)).toBe(
        MedicationRequestCombinedStatus.expired,
      );
    });
    test('should return expired if validity period over 90 days and fulfiller status declined', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '2020-04-04' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.active,
        subject: { display: '', reference: '', type: '' },
        extension: [
          {
            url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
            valueCode: MedicationRequestFulfillerStatus.declined,
          },
        ],
      };
      expect(computeMedicationRequestCombinedStatus(medicationRequest, 90)).toBe(
        MedicationRequestCombinedStatus.expired,
      );
    });
  });

  describe('test computeMedicationRequestStatus', () => {
    test('should return Cancelled if Medication Request has status cancelled', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.cancelled,
        subject: { display: '', reference: '', type: '' },
      };
      expect(computeMedicationRequestStatus(medicationRequest, 0)).toBe(MedicationRequestStatus.cancelled);
    });
    test('should return Completed if Medication Request has status completed', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.completed,
        subject: { display: '', reference: '', type: '' },
      };
      expect(computeMedicationRequestStatus(medicationRequest, 0)).toBe(MedicationRequestStatus.completed);
    });
    test('should return Expired if Medication Request older than expired timeframe', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: dayjs().subtract(91, 'days').toString() },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: null,
        subject: { display: '', reference: '', type: '' },
      };
      expect(computeMedicationRequestStatus(medicationRequest, 90)).toBe(MedicationRequestStatus.expired);
    });
    test('should return Expired if Medication Request age is passed expired timeframe', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: dayjs().subtract(91, 'days').toString() },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: null,
        subject: { display: '', reference: '', type: '' },
      };
      expect(computeMedicationRequestStatus(medicationRequest, 90)).toBe(MedicationRequestStatus.expired);
    });
    test('should return Active if Medication Request age is equal to expired timeframe (even if status is expired)', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: {
            start: dayjs().startOf('day').subtract(90, 'days').toString(),
          },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.expired,
        subject: { display: '', reference: '', type: '' },
      };
      expect(computeMedicationRequestStatus(medicationRequest, 90)).toBe(MedicationRequestStatus.active);
    });
    test('should return Active if Medication Request is age is less than expired timeframe (even if status is expired)', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: {
            start: dayjs().startOf('day').subtract(90, 'days').toString(),
          },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: MedicationRequestStatus.expired,
        subject: { display: '', reference: '', type: '' },
      };
      expect(computeMedicationRequestStatus(medicationRequest, 90)).toBe(MedicationRequestStatus.active);
    });
    test('should return Active as default', () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: '' },
        },
        dosageInstruction: undefined,
        encounter: { reference: '', type: '' },
        id: '',
        intent: '',
        medicationReference: { display: '', reference: '', type: '' },
        meta: { lastUpdated: '' },
        priority: '',
        requester: {
          display: '',
          identifier: { value: '' },
          reference: '',
          type: '',
        },
        resourceType: '',
        status: null,
        subject: { display: '', reference: '', type: '' },
      };
      expect(computeMedicationRequestStatus(medicationRequest, 90)).toBe(MedicationRequestStatus.active);
    });
  });

  describe('test computeNewFulfillerStatusAfterDelete', () => {
    const medicationRequest: MedicationRequest = {
      id: '1c1ad91e-8653-453a-9f59-8d5c36249aff',
      dispenseRequest: {
        numberOfRepeatsAllowed: undefined,
        quantity: {
          value: 30,
          unit: 'mg',
          code: '123abc',
        },
        validityPeriod: { start: '' },
      },
      dosageInstruction: undefined,
      encounter: { reference: '', type: '' },
      intent: '',
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      priority: '',
      requester: {
        display: '',
        identifier: { value: '' },
        reference: '',
        type: '',
      },
      resourceType: 'MedicationRequest',
      status: MedicationRequestStatus.completed,
      subject: { display: '', reference: '', type: '' },
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
          valueCode: MedicationRequestFulfillerStatus.declined,
        },
      ],
    };

    const medicationDispenseCompleteMostRecent: MedicationDispense = {
      dosageInstruction: undefined,
      id: 'ab663520-8b5f-4afe-a333-5196f69ccea7',
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationdispense/recorded',
          valueDateTime: '2023-01-05T14:00:00-05:00',
        },
      ],
      authorizingPrescription: [
        {
          reference: 'MedicationRequest/',
          type: 'MedicationRequest',
        },
      ],
      location: { display: '', reference: '', type: '' },
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      quantity: {
        value: 5,
        unit: 'mg',
        code: '123abc',
      },
      performer: undefined,
      resourceType: 'MedicationDispense',
      status: MedicationDispenseStatus.completed,
      subject: { display: '', reference: '', type: '' },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: '2023-01-05T14:00:00-05:00',
      whenPrepared: '2023-01-05T14:00:00-05:00',
    };

    const medicationDispenseDeclined: MedicationDispense = {
      dosageInstruction: undefined,
      id: '9f7987e8-95c6-42f3-96e6-fd2eaa3134a5',
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationdispense/recorded',
          valueDateTime: '2023-01-04T14:00:00-05:00',
        },
      ],
      authorizingPrescription: [
        {
          reference: 'MedicationRequest/1c1ad91e-8653-453a-9f59-8d5c36249aff',
          type: 'MedicationRequest',
        },
      ],
      location: { display: '', reference: '', type: '' },
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      quantity: {
        value: 5,
        unit: 'mg',
        code: '123abc',
      },
      performer: undefined,
      resourceType: 'MedicationDispense',
      status: MedicationDispenseStatus.declined,
      subject: { display: '', reference: '', type: '' },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: '2023-01-04T14:00:00-05:00',
      whenPrepared: '2023-01-04T14:00:00-05:00',
    };

    const medicationDispenseOnHold: MedicationDispense = {
      dosageInstruction: undefined,
      id: 'e2bf7117-aa87-4a92-9e61-f985f29a82aa',
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationdispense/recorded',
          valueDateTime: '2023-01-03T14:00:00-05:00',
        },
      ],
      authorizingPrescription: [
        {
          reference: 'MedicationRequest/1c1ad91e-8653-453a-9f59-8d5c36249aff',
          type: 'MedicationRequest',
        },
      ],
      location: { display: '', reference: '', type: '' },
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      quantity: {
        value: 5,
        unit: 'mg',
        code: '123abc',
      },
      performer: undefined,
      resourceType: 'MedicationDispense',
      status: MedicationDispenseStatus.on_hold,
      subject: { display: '', reference: '', type: '' },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: '2023-01-03T14:00:00-05:00',
      whenPrepared: '2023-01-03T14:00:00-05:00',
    };

    const medicationDispenseCompleteOldest: MedicationDispense = {
      dosageInstruction: undefined,
      id: '7fd2dcd2-6621-444d-9054-fe1d36acf498',
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationdispense/recorded',
          valueDateTime: '2023-01-01T14:00:00-05:00',
        },
      ],
      authorizingPrescription: [
        {
          reference: 'MedicationRequest/',
          type: 'MedicationRequest',
        },
      ],
      location: { display: '', reference: '', type: '' },
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      quantity: {
        value: 5,
        unit: 'mg',
        code: '123abc',
      },
      performer: undefined,
      resourceType: 'MedicationDispense',
      status: MedicationDispenseStatus.completed,
      subject: { display: '', reference: '', type: '' },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: '2023-01-01T14:00:00-05:00',
      whenPrepared: '2023-01-01T14:00:00-05:00',
    };

    test('should return declined if deleting most recent medication dispense and next most recent status declined', () => {
      const medicationRequestBundle: MedicationRequestBundle = {
        request: medicationRequest,
        dispenses: [
          medicationDispenseCompleteMostRecent,
          medicationDispenseDeclined,
          medicationDispenseOnHold,
          medicationDispenseCompleteOldest,
        ],
      };

      expect(
        computeNewFulfillerStatusAfterDelete(medicationDispenseCompleteMostRecent, medicationRequestBundle, false),
      ).toBe(MedicationRequestFulfillerStatus.declined);
    }),
      test('should return on-hold if deleting most recent medication dispense next most recent status on-hold', () => {
        const medicationRequestBundle: MedicationRequestBundle = {
          request: medicationRequest,
          dispenses: [medicationDispenseCompleteMostRecent, medicationDispenseOnHold, medicationDispenseCompleteOldest],
        };

        expect(
          computeNewFulfillerStatusAfterDelete(medicationDispenseCompleteMostRecent, medicationRequestBundle, false),
        ).toBe(MedicationRequestFulfillerStatus.on_hold);
      }),
      test('should return null if deleting only medication dispense', () => {
        const medicationRequestBundle: MedicationRequestBundle = {
          request: medicationRequest,
          dispenses: [medicationDispenseCompleteMostRecent],
        };

        expect(
          computeNewFulfillerStatusAfterDelete(medicationDispenseCompleteMostRecent, medicationRequestBundle, false),
        ).toBeNull();
      }),
      test('should return current fulfiller status if not most recent medication dispense and deleted dispense does not have status of completed', () => {
        const medicationRequestBundle: MedicationRequestBundle = {
          request: medicationRequest,
          dispenses: [medicationDispenseDeclined, medicationDispenseOnHold],
        };

        expect(computeNewFulfillerStatusAfterDelete(medicationDispenseOnHold, medicationRequestBundle, false)).toBe(
          MedicationRequestFulfillerStatus.declined,
        );
      });
  });

  describe('test computeNewFulfillerStatusAfterDispenseEvent', () => {
    const medicationRequest: MedicationRequest = {
      id: '1c1ad91e-8653-453a-9f59-8d5c36249aff',
      dispenseRequest: {
        numberOfRepeatsAllowed: undefined,
        quantity: {
          value: 30,
          unit: 'mg',
          code: '123abc',
        },
        validityPeriod: { start: '' },
      },
      dosageInstruction: undefined,
      encounter: { reference: '', type: '' },
      intent: '',
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      priority: '',
      requester: {
        display: '',
        identifier: { value: '' },
        reference: '',
        type: '',
      },
      resourceType: 'MedicationRequest',
      status: null,
      subject: { display: '', reference: '', type: '' },
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
          valueCode: MedicationRequestFulfillerStatus.completed,
        },
      ],
    };

    const newMedicationDispense: MedicationDispense = {
      // ie quantity dispense = quantity ordered
      dosageInstruction: undefined,
      id: '',
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationdispense/recorded',
          valueDateTime: '',
        },
      ],
      authorizingPrescription: [
        {
          reference: 'MedicationRequest/',
          type: 'MedicationRequest',
        },
      ],
      location: { display: '', reference: '', type: '' },
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      quantity: {
        value: null,
        unit: 'mg',
        code: '123abc',
      },
      performer: undefined,
      resourceType: 'MedicationDispense',
      status: null,
      subject: { display: '', reference: '', type: '' },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: '',
      whenPrepared: '',
    };

    const existingMedicationDispense: MedicationDispense = {
      // ie quantity dispense = quantity ordered
      dosageInstruction: undefined,
      id: 'ab663520-8b5f-4afe-a333-5196f69ccea7',
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationdispense/recorded',
          valueDateTime: '',
        },
      ],
      authorizingPrescription: [
        {
          reference: 'MedicationRequest/',
          type: 'MedicationRequest',
        },
      ],
      location: { display: '', reference: '', type: '' },
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      quantity: {
        value: null,
        unit: 'mg',
        code: '123abc',
      },
      performer: undefined,
      resourceType: 'MedicationDispense',
      status: null,
      subject: { display: '', reference: '', type: '' },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: '',
      whenPrepared: '',
    };

    test('when adding new dispense should return null even if dispense meets or exceeds quantity if restrict total quantity dispensed config is false', () => {
      newMedicationDispense.extension[0].valueDateTime = '2023-01-03T14:00:00-05:00';
      newMedicationDispense.whenHandedOver = '2023-01-03T14:00:00-05:00';
      newMedicationDispense.whenPrepared = '2023-01-03T14:00:00-05:00';
      newMedicationDispense.status = MedicationDispenseStatus.completed;
      newMedicationDispense.quantity.value = 30;
      expect(
        computeNewFulfillerStatusAfterDispenseEvent(
          newMedicationDispense,
          { request: medicationRequest, dispenses: [] },
          false,
        ),
      ).toBeNull();
    });

    test('when adding new dispense should return on-hold if status of new dispense is on-hold and if restrict total quantity dispensed config is false', () => {
      newMedicationDispense.extension[0].valueDateTime = '2023-01-03T14:00:00-05:00';
      newMedicationDispense.status = MedicationDispenseStatus.on_hold;
      newMedicationDispense.quantity.value = 0;
      expect(
        computeNewFulfillerStatusAfterDispenseEvent(
          newMedicationDispense,
          { request: medicationRequest, dispenses: [] },
          false,
        ),
      ).toBe(MedicationRequestFulfillerStatus.on_hold);
    });

    test('when adding new dispense should return complete if total dispensed equals total ordered and restrict total quantity dispensed config is true', () => {
      newMedicationDispense.extension[0].valueDateTime = '2023-01-03T14:00:00-05:00';
      newMedicationDispense.status = MedicationDispenseStatus.completed;
      newMedicationDispense.quantity.value = 30;
      expect(
        computeNewFulfillerStatusAfterDispenseEvent(
          newMedicationDispense,
          { request: medicationRequest, dispenses: [] },
          true,
        ),
      ).toBe(MedicationRequestFulfillerStatus.completed);
    });

    test('when adding new dispense should return null if total dispensed less than total ordered and restrict total quantity dispensed config is true', () => {
      newMedicationDispense.extension[0].valueDateTime = '2023-01-03T14:00:00-05:00';
      newMedicationDispense.status = MedicationDispenseStatus.completed;
      newMedicationDispense.quantity.value = 20;
      expect(
        computeNewFulfillerStatusAfterDispenseEvent(
          newMedicationDispense,
          { request: medicationRequest, dispenses: [] },
          true,
        ),
      ).toBeNull();
    });

    test('when adding new on-hold dispense should return on-hold if restrict total quantity dispensed config is true', () => {
      newMedicationDispense.extension[0].valueDateTime = '2023-01-03T14:00:00-05:00';
      newMedicationDispense.status = MedicationDispenseStatus.on_hold;
      newMedicationDispense.quantity.value = 0;
      expect(
        computeNewFulfillerStatusAfterDispenseEvent(
          newMedicationDispense,
          { request: medicationRequest, dispenses: [] },
          true,
        ),
      ).toBe(MedicationRequestFulfillerStatus.on_hold);
    });

    test('when adding new dispense to request with existing dispense should return complete if meets total quantity ordered and restrict total quantity dispensed config is true', () => {
      newMedicationDispense.extension[0].valueDateTime = '2023-01-03T14:00:00-05:00';
      newMedicationDispense.status = MedicationDispenseStatus.on_hold;
      newMedicationDispense.quantity.value = 20;
      existingMedicationDispense.extension[0].valueDateTime = '2023-01-03T14:00:00-05:00';
      existingMedicationDispense.status = MedicationDispenseStatus.on_hold;
      existingMedicationDispense.quantity.value = 10;
      expect(
        computeNewFulfillerStatusAfterDispenseEvent(
          newMedicationDispense,
          {
            request: medicationRequest,
            dispenses: [existingMedicationDispense],
          },
          true,
        ),
      ).toBe(MedicationRequestFulfillerStatus.completed);
    });

    test('when adding new dispense to request with existing dispense should return null if does not meet total quantiy order and  restrict total quantity dispensed config is true', () => {
      newMedicationDispense.extension[0].valueDateTime = '2023-01-03T14:00:00-05:00';
      newMedicationDispense.status = MedicationDispenseStatus.completed;
      newMedicationDispense.quantity.value = 10;
      existingMedicationDispense.extension[0].valueDateTime = '2023-01-03T14:00:00-05:00';
      existingMedicationDispense.status = MedicationDispenseStatus.completed;
      existingMedicationDispense.quantity.value = 10;
      expect(
        computeNewFulfillerStatusAfterDispenseEvent(
          newMedicationDispense,
          {
            request: medicationRequest,
            dispenses: [existingMedicationDispense],
          },
          true,
        ),
      ).toBeNull();
    });

    test('when editing existing dispense should return null if does not meet total quantity order and  restrict total quantity dispensed config is true', () => {
      existingMedicationDispense.extension[0].valueDateTime = '2023-01-03T14:00:00-05:00';
      existingMedicationDispense.status = MedicationDispenseStatus.completed;
      existingMedicationDispense.quantity.value = 30;
      const editedExistingMedicationDispense = {
        ...existingMedicationDispense,
      };
      editedExistingMedicationDispense.quantity.value = 20;
      expect(
        computeNewFulfillerStatusAfterDispenseEvent(
          editedExistingMedicationDispense,
          {
            request: medicationRequest,
            dispenses: [existingMedicationDispense],
          },
          true,
        ),
      ).toBeNull();
    });

    test('when editing existing dispense should return complete if meets total quantity order and  restrict total quantity dispensed config is true', () => {
      existingMedicationDispense.extension[0].valueDateTime = '2023-01-03T14:00:00-05:00';
      existingMedicationDispense.status = MedicationDispenseStatus.completed;
      existingMedicationDispense.quantity.value = 20;
      const editedExistingMedicationDispense = {
        ...existingMedicationDispense,
      };
      editedExistingMedicationDispense.quantity.value = 30;
      expect(
        computeNewFulfillerStatusAfterDispenseEvent(
          editedExistingMedicationDispense,
          {
            request: medicationRequest,
            dispenses: [existingMedicationDispense],
          },
          true,
        ),
      ).toBe(MedicationRequestFulfillerStatus.completed);
    });
  });

  describe('test computePrescriptionStatus', () => {
    const activeMedicationRequest = {
      dispenseRequest: {
        numberOfRepeatsAllowed: 0,
        quantity: undefined,
        validityPeriod: { start: '' },
      },
      dosageInstruction: undefined,
      encounter: { reference: '', type: '' },
      id: '',
      intent: '',
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      priority: '',
      requester: {
        display: '',
        identifier: { value: '' },
        reference: '',
        type: '',
      },
      resourceType: '',
      status: MedicationRequestStatus.active,
      subject: { display: '', reference: '', type: '' },
    };
    // sanity check
    expect(computeMedicationRequestCombinedStatus(activeMedicationRequest, 90)).toBe(
      MedicationRequestCombinedStatus.active,
    );
    const cancelledMedicationRequest = {
      dispenseRequest: {
        numberOfRepeatsAllowed: 0,
        quantity: undefined,
        validityPeriod: { start: '' },
      },
      dosageInstruction: undefined,
      encounter: { reference: '', type: '' },
      id: '',
      intent: '',
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      priority: '',
      requester: {
        display: '',
        identifier: { value: '' },
        reference: '',
        type: '',
      },
      resourceType: '',
      status: MedicationRequestStatus.cancelled,
      subject: { display: '', reference: '', type: '' },
    };
    // sanity check
    expect(computeMedicationRequestCombinedStatus(cancelledMedicationRequest, 90)).toBe(
      MedicationRequestCombinedStatus.cancelled,
    );
    const expiredMedicationRequest = {
      dispenseRequest: {
        numberOfRepeatsAllowed: 0,
        quantity: undefined,
        validityPeriod: { start: '2020-04-04' },
      },
      dosageInstruction: undefined,
      encounter: { reference: '', type: '' },
      id: '',
      intent: '',
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      priority: '',
      requester: {
        display: '',
        identifier: { value: '' },
        reference: '',
        type: '',
      },
      resourceType: '',
      status: MedicationRequestStatus.active,
      subject: { display: '', reference: '', type: '' },
    };
    // sanity check
    expect(computeMedicationRequestCombinedStatus(expiredMedicationRequest, 90)).toBe(
      MedicationRequestCombinedStatus.expired,
    );
    const onHoldMedicationRequest = {
      dispenseRequest: {
        numberOfRepeatsAllowed: 0,
        quantity: undefined,
        validityPeriod: { start: '' },
      },
      dosageInstruction: undefined,
      encounter: { reference: '', type: '' },
      id: '',
      intent: '',
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      priority: '',
      requester: {
        display: '',
        identifier: { value: '' },
        reference: '',
        type: '',
      },
      resourceType: '',
      status: MedicationRequestStatus.active,
      subject: { display: '', reference: '', type: '' },
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
          valueCode: MedicationRequestFulfillerStatus.on_hold,
        },
      ],
    };
    // sanity check
    expect(computeMedicationRequestCombinedStatus(onHoldMedicationRequest, 90)).toBe(
      MedicationRequestCombinedStatus.on_hold,
    );
    const declinedMedicationRequest = {
      dispenseRequest: {
        numberOfRepeatsAllowed: 0,
        quantity: undefined,
        validityPeriod: { start: '' },
      },
      dosageInstruction: undefined,
      encounter: { reference: '', type: '' },
      id: '',
      intent: '',
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      priority: '',
      requester: {
        display: '',
        identifier: { value: '' },
        reference: '',
        type: '',
      },
      resourceType: '',
      status: MedicationRequestStatus.active,
      subject: { display: '', reference: '', type: '' },
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
          valueCode: MedicationRequestFulfillerStatus.declined,
        },
      ],
    };
    // santity check
    expect(computeMedicationRequestCombinedStatus(declinedMedicationRequest, 90)).toBe(
      MedicationRequestCombinedStatus.declined,
    );
    const completedMedicationRequest = {
      dispenseRequest: {
        numberOfRepeatsAllowed: 0,
        quantity: undefined,
        validityPeriod: { start: '' },
      },
      dosageInstruction: undefined,
      encounter: { reference: '', type: '' },
      id: '',
      intent: '',
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      priority: '',
      requester: {
        display: '',
        identifier: { value: '' },
        reference: '',
        type: '',
      },
      resourceType: '',
      status: MedicationRequestStatus.completed,
      subject: { display: '', reference: '', type: '' },
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
          valueCode: MedicationRequestFulfillerStatus.completed,
        },
      ],
    };
    // santiy-check
    expect(computeMedicationRequestCombinedStatus(completedMedicationRequest, 90)).toBe(
      MedicationRequestCombinedStatus.completed,
    );
    test('should return active if any medication request combined status active', () => {
      expect(
        computePrescriptionStatus(
          [
            activeMedicationRequest,
            cancelledMedicationRequest,
            expiredMedicationRequest,
            onHoldMedicationRequest,
            declinedMedicationRequest,
            completedMedicationRequest,
          ],
          90,
        ),
      ).toBe(MedicationRequestCombinedStatus.active);
    });
    test('should return on-hold if any medication request combined status on-hold, and none active', () => {
      expect(
        computePrescriptionStatus(
          [
            cancelledMedicationRequest,
            expiredMedicationRequest,
            onHoldMedicationRequest,
            declinedMedicationRequest,
            completedMedicationRequest,
          ],
          90,
        ),
      ).toBe(MedicationRequestCombinedStatus.on_hold);
    });
    test('should return completed if any medication request combined status completed, and none active or on hold', () => {
      expect(
        computePrescriptionStatus(
          [cancelledMedicationRequest, expiredMedicationRequest, declinedMedicationRequest, completedMedicationRequest],
          90,
        ),
      ).toBe(MedicationRequestCombinedStatus.completed);
    });
    test('should return declined if any medication request combined status declined, and none active or on hold or completed', () => {
      expect(
        computePrescriptionStatus(
          [cancelledMedicationRequest, expiredMedicationRequest, declinedMedicationRequest],
          90,
        ),
      ).toBe(MedicationRequestCombinedStatus.declined);
    });
    test('should return cancelled if any medication request combined status cancelled, and none active or on hold or completed or declined', () => {
      expect(computePrescriptionStatus([cancelledMedicationRequest, expiredMedicationRequest], 90)).toBe(
        MedicationRequestCombinedStatus.cancelled,
      );
    });
    test('should return expired if any medication request combined status expired, and none active or on hold or completed or declined or cancelled', () => {
      expect(computePrescriptionStatus([expiredMedicationRequest], 90)).toBe(MedicationRequestCombinedStatus.expired);
    });
    test('should return null for empty array', () => {
      expect(computePrescriptionStatus([], 90)).toBe(null);
    });
    test('should return null for null input', () => {
      expect(computePrescriptionStatus(null, 90)).toBe(null);
    });
  });

  describe('test computeRemainingQuantity', () => {
    const medicationRequest: MedicationRequest = {
      id: '1c1ad91e-8653-453a-9f59-8d5c36249aff',
      dispenseRequest: {
        numberOfRepeatsAllowed: undefined,
        quantity: {
          value: 30,
          unit: 'mg',
          code: '123abc',
        },
        validityPeriod: { start: '' },
      },
      dosageInstruction: undefined,
      encounter: { reference: '', type: '' },
      intent: '',
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      priority: '',
      requester: {
        display: '',
        identifier: { value: '' },
        reference: '',
        type: '',
      },
      resourceType: 'MedicationRequest',
      status: MedicationRequestStatus.completed,
      subject: { display: '', reference: '', type: '' },
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
          valueCode: MedicationRequestFulfillerStatus.completed,
        },
      ],
    };
    const medicationDispense1: MedicationDispense = {
      dosageInstruction: undefined,
      id: '',
      authorizingPrescription: [
        {
          reference: 'MedicationRequest/1c1ad91e-8653-453a-9f59-8d5c36249aff',
          type: 'MedicationRequest',
        },
      ],
      location: { display: '', reference: '', type: '' },
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      quantity: {
        value: 5,
        unit: 'mg',
        code: '123abc',
      },
      performer: undefined,
      resourceType: 'MedicationDispense',
      status: MedicationDispenseStatus.completed,
      subject: { display: '', reference: '', type: '' },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: '',
      whenPrepared: '',
    };
    const medicationDispense2: MedicationDispense = {
      dosageInstruction: undefined,
      id: '',
      authorizingPrescription: [
        {
          reference: 'MedicationRequest/1c1ad91e-8653-453a-9f59-8d5c36249aff',
          type: 'MedicationRequest',
        },
      ],
      location: { display: '', reference: '', type: '' },
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      quantity: {
        value: 10,
        unit: 'mg',
        code: '123abc',
      },
      performer: undefined,
      resourceType: 'MedicationDispense',
      status: MedicationDispenseStatus.completed,
      subject: { display: '', reference: '', type: '' },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: '',
      whenPrepared: '',
    };
    const medicationDispenseNoQuantity: MedicationDispense = {
      dosageInstruction: undefined,
      id: '',
      authorizingPrescription: [
        {
          reference: 'MedicationRequest/1c1ad91e-8653-453a-9f59-8d5c36249aff',
          type: 'MedicationRequest',
        },
      ],
      location: { display: '', reference: '', type: '' },
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      quantity: undefined,
      performer: undefined,
      resourceType: 'MedicationDispense',
      status: MedicationDispenseStatus.completed,
      subject: { display: '', reference: '', type: '' },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: '',
      whenPrepared: '',
    };
    const medicationRequestDifferentUnits: MedicationRequest = {
      id: '1c1ad91e-8653-453a-9f59-8d5c36249aff',
      dispenseRequest: {
        numberOfRepeatsAllowed: undefined,
        quantity: {
          value: 30,
          unit: 'kg',
          code: '456def',
        },
        validityPeriod: { start: '' },
      },
      dosageInstruction: undefined,
      encounter: { reference: '', type: '' },
      intent: '',
      medicationReference: { display: '', reference: '', type: '' },
      meta: { lastUpdated: '' },
      priority: '',
      requester: {
        display: '',
        identifier: { value: '' },
        reference: '',
        type: '',
      },
      resourceType: 'MedicationRequest',
      status: MedicationRequestStatus.completed,
      subject: { display: '', reference: '', type: '' },
      extension: [
        {
          url: 'http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus',
          valueCode: MedicationRequestFulfillerStatus.completed,
        },
      ],
    };

    test('should return quantity remaining', () => {
      expect(
        computeQuantityRemaining({
          request: medicationRequest,
          dispenses: [medicationDispense1, medicationDispense2, medicationDispenseNoQuantity],
        }),
      ).toBe(15);
    });
    test('should return quantity ordered if no dispense has happened', () => {
      expect(
        computeQuantityRemaining({
          request: medicationRequest,
          dispenses: [medicationDispenseNoQuantity],
        }),
      ).toBe(30);
    });
    test('should return amount orders if no dispenses', () => {
      expect(computeQuantityRemaining({ request: medicationRequest, dispenses: [] })).toBe(30);
    });
    test('should return zero for null input', () => {
      expect(computeQuantityRemaining(null)).toBe(0);
    });
    /*  // TODO: figure out how to get this to work
    test("should throw Error if unit mismatch", () => {
      expect(
        computeQuantityRemaining(medicationRequestDifferentUnits, [
          medicationDispense1,
          medicationDispenseNoQuantity,
          medicationDispense2,
        ])
      ).toThrow(Error);
    });*/
  });

  describe('test computeTotalQuantityDispensed', () => {
    const medicationDispense1: Medication