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

Medication dispensing application

import {
  Coding,
  DosageInstruction,
  Medication,
  MedicationDispense,
  MedicationDispenseStatus,
  MedicationReferenceOrCodeableConcept,
  MedicationRequest,
  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: "",
      whenPrepared: "",
    };

    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: "",
      whenPrepared: "",
    };

    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: "",
      whenPrepared: "",
    };

    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: "",
      whenPrepared: "",
    };

    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 quantitiy if restrict total quantity dispensed config is false", () => {
      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: [] },
          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, [
          medicationDispen