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, [
          medicationDispense1,
          medicationDispenseNoQuantity,
          medicationDispense2,
        ])
      ).toThrow(Error);
    });*/
  });

  describe("test computeTotalQuantityDispensed", () => {
    const medicationDispense1: MedicationDispense = {
      dosageInstruction: undefined,
      id: "",
      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: "",
      location: { display: "", reference: "", type: "" },
      medicationReference: { display: "", reference: "", type: "" },
      meta: { lastUpdated: "" },
      quantity: {
        value: 15,
        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: "",
      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 medicationDispenseDifferentUnits: MedicationDispense = {
      dosageInstruction: undefined,
      id: "",
      location: { display: "", reference: "", type: "" },
      medicationReference: { display: "", reference: "", type: "" },
      meta: { lastUpdated: "" },
      quantity: {
        value: 1,
        unit: "kg",
        code: "456ddef",
      },
      performer: undefined,
      resourceType: "MedicationDispense",
      status: MedicationDispenseStatus.completed,
      subject: { display: "", reference: "", type: "" },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: "",
      whenPrepared: "",
    };

    test("should return 0 for null input", () => {
      expect(computeTotalQuantityDispensed(null)).toBe(0);
    });
    test("should return 0 if no dispense events have quantity", () =>
      expect(
        computeTotalQuantityDispensed([medicationDispenseNoQuantity])
      ).toBe(0));
    test("should return total quantity dispensed", () => {
      expect(
        computeTotalQuantityDispensed([
          medicationDispense1,
          medicationDispenseNoQuantity,
          medicationDispense2,
        ])
      ).toBe(20);
    });
    // TODO: figure out how to get this to work
    /*test("should throw Error if unit mismatch", () => {
      expect(
        computeTotalQuantityDispensed([
          medicationDispense1,
          medicationDispenseNoQuantity,
          medicationDispense2,
          medicationDispenseDifferentUnits,
        ])
      ).toThrow("Can't calculate quantity dispensed if units don't match");
    });*/
  });

  describe("test computeTotalQuantityOrdered", () => {
    test("should calculate total quantity ordered when refills set", () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 3,
          quantity: {
            value: 30,
            unit: "mg",
            code: "123abc",
          },
          validityPeriod: { start: "" },
        },
        dosageInstruction: undefined,
        encounter: { reference: "", type: "" },
        id: "",
        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,
          },
        ],
      };
      expect(computeTotalQuantityOrdered(medicationRequest)).toBe(120);
    });
    test("should calculate total quantity ordered when refills not set", () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: undefined,
          quantity: {
            value: 30,
            unit: "mg",
            code: "123abc",
          },
          validityPeriod: { start: "" },
        },
        dosageInstruction: undefined,
        encounter: { reference: "", type: "" },
        id: "",
        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,
          },
        ],
      };
      expect(computeTotalQuantityOrdered(medicationRequest)).toBe(30);
    });
    test("should return null when no quantity", () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: undefined,
          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: "MedicationRequest",
        status: MedicationRequestStatus.completed,
        subject: { display: "", reference: "", type: "" },
        extension: [
          {
            url: "http://fhir.openmrs.org/ext/medicationrequest/fullfillerstatus",
            valueCode: MedicationRequestFulfillerStatus.completed,
          },
        ],
      };
      expect(computeTotalQuantityOrdered(medicationRequest)).toBe(null);
    });
  });

  describe("test getAssociatedMedicationDispense", () => {
    test("should return medication dispenses associated with request", () => {
      const medicationRequest: MedicationRequest = {
        id: "1c1ad91e-8653-453a-9f59-8d5c36249aff",
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: "" },
        },
        dosageInstruction: undefined,
        encounter: { reference: "", type: "" },
        intent: "",
        medicationReference: { display: "", reference: "", type: "" },
        meta: { lastUpdated: "" },
        priority: "",
        requester: {
          display: "",
          identifier: { value: "" },
          reference: "",
          type: "",
        },
        resourceType: "",
        status: null,
        subject: { display: "", reference: "", type: "" },
      };

      const medicationDispenses: Array<MedicationDispense> = [
        {
          dosageInstruction: undefined,
          id: "e74e74a1-6b70-40fd-8c44-485178c71721",
          authorizingPrescription: [
            {
              reference:
                "MedicationRequest/075318da-ce26-4de5-9700-e49820f9d974",
              type: "MedicationRequest",
            },
          ],
          location: { display: "", reference: "", type: "" },
          medicationReference: { display: "", reference: "", type: "" },
          meta: { lastUpdated: "" },
          quantity: {
            value: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.completed,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
        {
          dosageInstruction: undefined,
          id: "f7b5585d-6867-4f3a-8151-da9ee1f70fab",
          authorizingPrescription: [
            {
              reference:
                "MedicationRequest/1c1ad91e-8653-453a-9f59-8d5c36249aff",
              type: "MedicationRequest",
            },
          ],
          location: { display: "", reference: "", type: "" },
          medicationReference: { display: "", reference: "", type: "" },
          meta: { lastUpdated: "" },
          quantity: {
            value: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.completed,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
        {
          dosageInstruction: undefined,
          id: "a2121f8e-1bcc-4cf9-b1e8-1edace155e7f",
          authorizingPrescription: [
            {
              reference:
                "MedicationRequest/075318da-ce26-4de5-9700-e49820f9d974",
              type: "MedicationRequest",
            },
          ],
          location: { display: "", reference: "", type: "" },
          medicationReference: { display: "", reference: "", type: "" },
          meta: { lastUpdated: "" },
          quantity: {
            value: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.completed,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
        {
          dosageInstruction: undefined,
          id: "b59a6c54-c178-4972-a33b-dfe9f968e71a",
          authorizingPrescription: [
            {
              reference:
                "MedicationRequest/1c1ad91e-8653-453a-9f59-8d5c36249aff",
              type: "MedicationRequest",
            },
          ],
          location: { display: "", reference: "", type: "" },
          medicationReference: { display: "", reference: "", type: "" },
          meta: { lastUpdated: "" },
          quantity: {
            value: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.completed,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
      ];
      const results: Array<MedicationDispense> =
        getAssociatedMedicationDispenses(
          medicationRequest,
          medicationDispenses
        );
      expect(results.length).toBe(2);
      expect(results).toContain(medicationDispenses[1]);
      expect(results).toContain(medicationDispenses[3]);
    });
    test("should return empty list if no associated requests", () => {
      const medicationRequest: MedicationRequest = {
        id: "1c1ad91e-8653-453a-9f59-8d5c36249aff",
        dispenseRequest: {
          numberOfRepeatsAllowed: 0,
          quantity: undefined,
          validityPeriod: { start: "" },
        },
        dosageInstruction: undefined,
        encounter: { reference: "", type: "" },
        intent: "",
        medicationReference: { display: "", reference: "", type: "" },
        meta: { lastUpdated: "" },
        priority: "",
        requester: {
          display: "",
          identifier: { value: "" },
          reference: "",
          type: "",
        },
        resourceType: "",
        status: null,
        subject: { display: "", reference: "", type: "" },
      };

      const medicationDispenses: Array<MedicationDispense> = [
        {
          dosageInstruction: undefined,
          id: "e74e74a1-6b70-40fd-8c44-485178c71721",
          authorizingPrescription: [
            {
              reference:
                "MedicationRequest/075318da-ce26-4de5-9700-e49820f9d974",
              type: "MedicationRequest",
            },
          ],
          location: { display: "", reference: "", type: "" },
          medicationReference: { display: "", reference: "", type: "" },
          meta: { lastUpdated: "" },
          quantity: {
            value: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.completed,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
      ];
      const results: Array<MedicationDispense> =
        getAssociatedMedicationDispenses(
          medicationRequest,
          medicationDispenses
        );
      expect(results.length).toBe(0);
    });
  });

  describe("test getAssociatedRequest", () => {
    test("should return medication request associated with dispense", () => {
      const medicationRequest1: MedicationRequest = {
        id: "0c26097a-e856-4c01-a6b4-7c8e6c636618",
        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 medicationRequest2: 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 medicationDispense: MedicationDispense = {
        dosageInstruction: undefined,
        id: "998f4111-96e8-4cd6-aebd-7f55716621a0",
        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: "",
      };

      expect(
        getAssociatedMedicationRequest(medicationDispense, [
          medicationRequest1,
          medicationRequest2,
        ])
      ).toBe(medicationRequest2);
    });
  });

  describe("test getConceptCoding", () => {
    test("should find the concept coding without a system", () => {
      const codings: Array<Coding> = [
        {
          system: "SNOMED",
          code: "123456",
          display: "Weight",
        },
        {
          code: "123abc",
          display: "Weight",
        },
        {
          system: "CIEL",
          code: "abcdef",
          display: "Weight",
        },
      ];

      expect(getConceptCoding(codings).code).toBe("123abc");
    });
    test("should find the concept coding undefined system", () => {
      const codings: Array<Coding> = [
        {
          system: "SNOMED",
          code: "123456",
          display: "Weight",
        },
        {
          system: undefined,
          code: "123abc",
          display: "Weight",
        },
        {
          system: "CIEL",
          code: "abcdef",
          display: "Weight",
        },
      ];

      expect(getConceptCoding(codings).code).toBe("123abc");
    });
  });

  describe("test getConceptCodingUuid", () => {
    test("should find the concept coding uuid without a system", () => {
      const codings: Array<Coding> = [
        {
          system: "SNOMED",
          code: "123456",
          display: "Weight",
        },
        {
          code: "123abc",
          display: "Weight",
        },
        {
          system: "CIEL",
          code: "abcdef",
          display: "Weight",
        },
      ];

      expect(getConceptCodingUuid(codings)).toBe("123abc");
    });
    test("should find the concept coding uuid without a system", () => {
      const codings: Array<Coding> = [
        {
          system: "SNOMED",
          code: "123456",
          display: "Weight",
        },
        {
          code: "123abc",
          display: "Weight",
        },
        {
          system: "CIEL",
          code: "abcdef",
          display: "Weight",
        },
      ];
      expect(getConceptCodingDisplay(codings)).toBe("Weight");
    });
  });

  describe("test getDosageInstructions", () => {
    test("should return first element of dosage instructions array", () => {
      const dosageInstructions: Array<DosageInstruction> = [
        {
          asNeededBoolean: false,
          doseAndRate: undefined,
          route: { coding: undefined },
          text: "first",
          timing: {
            code: { coding: undefined },
            repeat: { duration: 0, durationUnit: "" },
          },
        },
        {
          asNeededBoolean: false,
          doseAndRate: undefined,
          route: { coding: undefined },
          text: "second",
          timing: {
            code: { coding: undefined },
            repeat: { duration: 0, durationUnit: "" },
          },
        },
      ];

      expect(getDosageInstruction(dosageInstructions).text).toBe("first");
    });
  });

  describe("test getMedicationsByConceptEndpoint", () => {
    test("should return medications by concept endpoint", () => {
      expect(getMedicationsByConceptEndpoint("123abc")).toBe(
        "/ws/fhir2/R4/Medication?code=123abc"
      );
    });
  });

  describe("test getMedicationDisplay", () => {
    test("should return medication reference display when present", () => {
      const medication: MedicationReferenceOrCodeableConcept = {
        medicationReference: {
          reference: "Medication/123abc",
          display: "Aspirin",
        },
        medicationCodeableConcept: {
          coding: [
            {
              code: "def687",
              display: "Aspirin",
            },
          ],
          text: "Aspirin",
        },
      };
      expect(getMedicationDisplay(medication)).toBe("Aspirin");
    });
    test("should return medication codeable concept when reference not present", () => {
      const medication: MedicationReferenceOrCodeableConcept = {
        medicationCodeableConcept: {
          coding: [
            {
              code: "def687",
              display: "Aspirin",
            },
          ],
          text: "Aspirin",
        },
      };
      expect(getMedicationDisplay(medication)).toBe("Aspirin: Aspirin");
    });
  });

  describe("test getMedicationReferenceOrCodeableConcept", () => {
    test("should return medication reference or codeable concept from Medication Request", () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 3,
          quantity: {
            value: 5,
            unit: "mg",
            code: "123abc",
          },
          validityPeriod: { start: "" },
        },
        dosageInstruction: undefined,
        encounter: { reference: "", type: "" },
        id: "",
        intent: "",
        medicationReference: {
          display: "",
          reference: "Medication/123abc",
          type: "",
        },
        medicationCodeableConcept: {
          coding: undefined,
          text: "Some concept",
        },
        meta: { lastUpdated: "" },
        priority: "",
        requester: {
          display: "",
          identifier: { value: "" },
          reference: "",
          type: "",
        },
        resourceType: "MedicationRequest",
        status: null,
        subject: { display: "", reference: "", type: "" },
      };
      expect(
        getMedicationReferenceOrCodeableConcept(medicationRequest)
          .medicationReference.reference
      ).toBe("Medication/123abc");
      expect(
        getMedicationReferenceOrCodeableConcept(medicationRequest)
          .medicationCodeableConcept.text
      ).toBe("Some concept");
    });
    test("should return medication reference or codeable concept from Medication Dispense", () => {
      const medicationDispense: MedicationDispense = {
        dosageInstruction: undefined,
        id: "",
        location: { display: "", reference: "", type: "" },
        medicationReference: {
          display: "",
          reference: "Medication/123abc",
          type: "",
        },
        medicationCodeableConcept: {
          coding: undefined,
          text: "Some concept",
        },
        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: "",
      };
      expect(
        getMedicationReferenceOrCodeableConcept(medicationDispense)
          .medicationReference.reference
      ).toBe("Medication/123abc");
      expect(
        getMedicationReferenceOrCodeableConcept(medicationDispense)
          .medicationCodeableConcept.text
      ).toBe("Some concept");
    });
  });

  describe("test getMostRecentMedicationDispenseStatus", () => {
    test("should return most recent status", () => {
      const medicationDispenses: Array<MedicationDispense> = [
        {
          dosageInstruction: undefined,
          id: "e74e74a1-6b70-40fd-8c44-485178c71721",
          extension: [
            {
              url: "http://fhir.openmrs.org/ext/medicationdispense/recorded",
              valueDateTime: "2023-01-05T14:00:00-05:00",
            },
          ],
          authorizingPrescription: [
            {
              reference:
                "MedicationRequest/075318da-ce26-4de5-9700-e49820f9d974",
              type: "MedicationRequest",
            },
          ],
          location: { display: "", reference: "", type: "" },
          medicationReference: { display: "", reference: "", type: "" },
          meta: { lastUpdated: "" },
          quantity: {
            value: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.on_hold,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
        {
          dosageInstruction: undefined,
          id: "f7b5585d-6867-4f3a-8151-da9ee1f70fab",
          extension: [
            {
              url: "http://fhir.openmrs.org/ext/medicationdispense/recorded",
              valueDateTime: "2023-01-05T20: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: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.completed,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
        {
          dosageInstruction: undefined,
          id: "a2121f8e-1bcc-4cf9-b1e8-1edace155e7f",
          extension: [
            {
              url: "http://fhir.openmrs.org/ext/medicationdispense/recorded",
              valueDateTime: "2023-01-05T17:00:00-05:00",
            },
          ],
          authorizingPrescription: [
            {
              reference:
                "MedicationRequest/075318da-ce26-4de5-9700-e49820f9d974",
              type: "MedicationRequest",
            },
          ],
          location: { display: "", reference: "", type: "" },
          medicationReference: { display: "", reference: "", type: "" },
          meta: { lastUpdated: "" },
          quantity: {
            value: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.declined,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
      ];

      expect(getMostRecentMedicationDispenseStatus(medicationDispenses)).toBe(
        MedicationDispenseStatus.completed
      );
    });
    test("should return null for null input", () => {
      expect(getMostRecentMedicationDispenseStatus(null)).toBeNull();
    });
    test("should return null for empty list", () => {
      expect(getMostRecentMedicationDispenseStatus([])).toBeNull();
    });
  });

  describe("test getNextMostRecentMedicationDispenseStatus", () => {
    test("should return next most recent status", () => {
      const medicationDispenses: Array<MedicationDispense> = [
        {
          dosageInstruction: undefined,
          id: "e74e74a1-6b70-40fd-8c44-485178c71721",
          extension: [
            {
              url: "http://fhir.openmrs.org/ext/medicationdispense/recorded",
              valueDateTime: "2023-01-05T14:00:00-05:00",
            },
          ],
          authorizingPrescription: [
            {
              reference:
                "MedicationRequest/075318da-ce26-4de5-9700-e49820f9d974",
              type: "MedicationRequest",
            },
          ],
          location: { display: "", reference: "", type: "" },
          medicationReference: { display: "", reference: "", type: "" },
          meta: { lastUpdated: "" },
          quantity: {
            value: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.on_hold,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
        {
          dosageInstruction: undefined,
          id: "f7b5585d-6867-4f3a-8151-da9ee1f70fab",
          extension: [
            {
              url: "http://fhir.openmrs.org/ext/medicationdispense/recorded",
              valueDateTime: "2023-01-05T20: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: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.completed,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
        {
          dosageInstruction: undefined,
          id: "a2121f8e-1bcc-4cf9-b1e8-1edace155e7f",
          extension: [
            {
              url: "http://fhir.openmrs.org/ext/medicationdispense/recorded",
              valueDateTime: "2023-01-05T17:00:00-05:00",
            },
          ],
          authorizingPrescription: [
            {
              reference:
                "MedicationRequest/075318da-ce26-4de5-9700-e49820f9d974",
              type: "MedicationRequest",
            },
          ],
          location: { display: "", reference: "", type: "" },
          medicationReference: { display: "", reference: "", type: "" },
          meta: { lastUpdated: "" },
          quantity: {
            value: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.declined,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
      ];

      expect(
        getNextMostRecentMedicationDispenseStatus(medicationDispenses)
      ).toBe(MedicationDispenseStatus.declined);
    });
    test("should return null if only one dispense", () => {
      const medicationDispenses: Array<MedicationDispense> = [
        {
          dosageInstruction: undefined,
          id: "e74e74a1-6b70-40fd-8c44-485178c71721",
          extension: [
            {
              url: "http://fhir.openmrs.org/ext/medicationdispense/recorded",
              valueDateTime: "2023-01-05T14:00:00-05:00",
            },
          ],
          authorizingPrescription: [
            {
              reference:
                "MedicationRequest/075318da-ce26-4de5-9700-e49820f9d974",
              type: "MedicationRequest",
            },
          ],
          location: { display: "", reference: "", type: "" },
          medicationReference: { display: "", reference: "", type: "" },
          meta: { lastUpdated: "" },
          quantity: {
            value: 1,
            unit: "",
            code: "",
          },
          performer: undefined,
          resourceType: "MedicationDispense",
          status: MedicationDispenseStatus.on_hold,
          subject: { display: "", reference: "", type: "" },
          substitution: { reason: [], type: undefined, wasSubstituted: false },
          type: undefined,
          whenHandedOver: "",
          whenPrepared: "",
        },
      ];
      expect(
        getNextMostRecentMedicationDispenseStatus(medicationDispenses)
      ).toBeNull();
    });
    test("should return null for null input", () => {
      expect(getNextMostRecentMedicationDispenseStatus(null)).toBeNull();
    });
    test("should return null for empty list", () => {
      expect(getMostRecentMedicationDispenseStatus([])).toBeNull();
    });
  });

  describe("test getOpenMRSMedicineDrugName", () => {
    test("getOpenMRSMedicineDrugName should get drug name stored in FHIR extension", () => {
      const medication: Medication = {
        code: { coding: [], text: "" },
        extension: [
          {
            extension: [
              {
                url: "http://fhir.openmrs.org/ext/medicine#drugName",
                valueString: "Aspirin",
              },
            ],
            url: "http://fhir.openmrs.org/ext/medicine",
          },
        ],
        id: "",
        meta: { lastUpdated: "" },
        resourceType: "Medication",
        status: "",
      };

      expect(getOpenMRSMedicineDrugName(medication)).toBe("Aspirin");
    });
  });

  describe("test getPrescriptionTableActiveMedicationRequestsEndpoint", () => {
    test("should return endpoint with date parameter", () => {
      expect(
        getPrescriptionTableActiveMedicationRequestsEndpoint(
          1,
          10,
          "2020-01-01",
          null,
          null
        )
      ).toBe(
        "/ws/fhir2/R4/Encounter?_query=encountersWithMedicationRequests&_getpagesoffset=1&_count=10&date=ge2020-01-01&status=active"
      );
    });
    test("should return endpoint with date and search term parameters", () => {
      expect(
        getPrescriptionTableActiveMedicationRequestsEndpoint(
          1,
          10,
          "2020-01-01",
          "bob",
          null
        )
      ).toBe(
        "/ws/fhir2/R4/Encounter?_query=encountersWithMedicationRequests&_getpagesoffset=1&_count=10&date=ge2020-01-01&status=active&patientSearchTerm=bob"
      );
    });
    test("should return endpoint with date and location parameters", () => {
      expect(
        getPrescriptionTableActiveMedicationRequestsEndpoint(
          1,
          10,
          "2020-01-01",
          null,
          "123abc"
        )
      ).toBe(
        "/ws/fhir2/R4/Encounter?_query=encountersWithMedicationRequests&_getpagesoffset=1&_count=10&date=ge2020-01-01&status=active&location=123abc"
      );
    });
    test("should return endpoint with date, location, and search term parameters", () => {
      expect(
        getPrescriptionTableActiveMedicationRequestsEndpoint(
          1,
          10,
          "2020-01-01",
          "bob",
          "123abc"
        )
      ).toBe(
        "/ws/fhir2/R4/Encounter?_query=encountersWithMedicationRequests&_getpagesoffset=1&_count=10&date=ge2020-01-01&status=active&patientSearchTerm=bob&location=123abc"
      );
    });
  });

  describe("test getPrescriptionTableAllMedicationRequestsEndpoint", () => {
    test("should return endpoint", () => {
      expect(
        getPrescriptionTableAllMedicationRequestsEndpoint(1, 10, null, null)
      ).toBe(
        "/ws/fhir2/R4/Encounter?_query=encountersWithMedicationRequests&_getpagesoffset=1&_count=10"
      );
    });
    test("should return endpoint with search term parameter", () => {
      expect(
        getPrescriptionTableAllMedicationRequestsEndpoint(1, 10, "bob", null)
      ).toBe(
        "/ws/fhir2/R4/Encounter?_query=encountersWithMedicationRequests&_getpagesoffset=1&_count=10&patientSearchTerm=bob"
      );
    });
    test("should return endpoint with location parameter", () => {
      expect(
        getPrescriptionTableAllMedicationRequestsEndpoint(1, 10, null, "123abc")
      ).toBe(
        "/ws/fhir2/R4/Encounter?_query=encountersWithMedicationRequests&_getpagesoffset=1&_count=10&location=123abc"
      );
    });
    test("should return endpoint with search term and location parameters", () => {
      expect(
        getPrescriptionTableAllMedicationRequestsEndpoint(
          1,
          10,
          "bob",
          "123abc"
        )
      ).toBe(
        "/ws/fhir2/R4/Encounter?_query=encountersWithMedicationRequests&_getpagesoffset=1&_count=10&patientSearchTerm=bob&location=123abc"
      );
    });
  });

  describe("test getPrescriptionDetailsEndpoint", () => {
    test("should return endpoint with encounter uuid", () => {
      expect(getPrescriptionDetailsEndpoint("123abc")).toBe(
        "/ws/fhir2/R4/MedicationRequest?encounter=123abc&_revinclude=MedicationDispense:prescription&_include=MedicationRequest:encounter"
      );
    });
  });

  describe("test getQuantity", () => {
    test("should return quantity from Medication Request", () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 3,
          quantity: {
            value: 5,
            unit: "mg",
            code: "123abc",
          },
          validityPeriod: { start: "" },
        },
        dosageInstruction: undefined,
        encounter: { reference: "", type: "" },
        id: "",
        intent: "",
        medicationReference: { display: "", reference: "", type: "" },
        meta: { lastUpdated: "" },
        priority: "",
        requester: {
          display: "",
          identifier: { value: "" },
          reference: "",
          type: "",
        },
        resourceType: "MedicationRequest",
        status: null,
        subject: { display: "", reference: "", type: "" },
      };
      expect(getQuantity(medicationRequest).value).toBe(5);
    });
    test("should return quantity from Medication Dispense", () => {
      const medicationDispense: MedicationDispense = {
        dosageInstruction: undefined,
        id: "",
        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: "",
      };
      expect(getQuantity(medicationDispense).value).toBe(5);
    });
  });

  describe("test getQuantityUnitsMatch", () => {
    const medicationRequest: MedicationRequest = {
      dispenseRequest: {
        numberOfRepeatsAllowed: undefined,
        quantity: {
          value: 30,
          unit: "mg",
          code: "123abc",
        },
        validityPeriod: { start: "" },
      },
      dosageInstruction: undefined,
      encounter: { reference: "", type: "" },
      id: "",
      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 medicationDispense: MedicationDispense = {
      dosageInstruction: undefined,
      id: "",
      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 medicationDispenseNoQuantity: MedicationDispense = {
      dosageInstruction: undefined,
      id: "",
      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 medicationDispenseDifferentUnits: MedicationDispense = {
      dosageInstruction: undefined,
      id: "",
      location: { display: "", reference: "", type: "" },
      medicationReference: { display: "", reference: "", type: "" },
      meta: { lastUpdated: "" },
      quantity: {
        value: 1,
        unit: "kg",
        code: "456ddef",
      },
      performer: undefined,
      resourceType: "MedicationDispense",
      status: MedicationDispenseStatus.completed,
      subject: { display: "", reference: "", type: "" },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: "",
      whenPrepared: "",
    };
    test("should return true if all quantity units match or are undefined", () => {
      expect(
        getQuantityUnitsMatch([
          medicationDispense,
          medicationRequest,
          medicationDispenseNoQuantity,
        ])
      ).toBe(true);
    });
    test("should return false if all quantity units don't match", () => {
      expect(
        getQuantityUnitsMatch([
          medicationDispense,
          medicationRequest,
          medicationDispenseNoQuantity,
          medicationDispenseDifferentUnits,
        ])
      ).toBe(false);
    });
    test("should return true for null input", () => {
      expect(getQuantityUnitsMatch(null)).toBe(true);
    });
    test("should return true for empty input", () => {
      expect(getQuantityUnitsMatch([])).toBe(true);
    });
    test("should return true if all quantity units undefined", () => {
      expect(getQuantityUnitsMatch([medicationDispenseNoQuantity])).toBe(true);
    });
  });

  describe("test getRefillsAllowed", () => {
    test("should return refills allowed from Medication Request", () => {
      const medicationRequest: MedicationRequest = {
        dispenseRequest: {
          numberOfRepeatsAllowed: 3,
          quantity: {
            value: 5,
            unit: "mg",
            code: "123abc",
          },
          validityPeriod: { start: "" },
        },
        dosageInstruction: undefined,
        encounter: { reference: "", type: "" },
        id: "",
        intent: "",
        medicationReference: { display: "", reference: "", type: "" },
        meta: { lastUpdated: "" },
        priority: "",
        requester: {
          display: "",
          identifier: { value: "" },
          reference: "",
          type: "",
        },
        resourceType: "MedicationRequest",
        status: null,
        subject: { display: "", reference: "", type: "" },
      };
      expect(getRefillsAllowed(medicationRequest)).toBe(3);
    });
    test("should return null from Medication Dispense", () => {
      const medicationDispense: MedicationDispense = {
        dosageInstruction: undefined,
        id: "",
        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: "",
      };
      expect(getRefillsAllowed(medicationDispense)).toBeNull();
    });
  });

  describe("test isMostRecentMedicationDispenseStatus", () => {
    const medicationDispense1: MedicationDispense = {
      dosageInstruction: undefined,
      id: "e74e74a1-6b70-40fd-8c44-485178c71721",
      extension: [
        {
          url: "http://fhir.openmrs.org/ext/medicationdispense/recorded",
          valueDateTime: "2023-01-05T14:00:00-05:00",
        },
      ],
      authorizingPrescription: [
        {
          reference: "MedicationRequest/075318da-ce26-4de5-9700-e49820f9d974",
          type: "MedicationRequest",
        },
      ],
      location: { display: "", reference: "", type: "" },
      medicationReference: { display: "", reference: "", type: "" },
      meta: { lastUpdated: "" },
      quantity: {
        value: 1,
        unit: "",
        code: "",
      },
      performer: undefined,
      resourceType: "MedicationDispense",
      status: MedicationDispenseStatus.on_hold,
      subject: { display: "", reference: "", type: "" },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: "",
      whenPrepared: "",
    };

    const medicationDispense2: MedicationDispense = {
      dosageInstruction: undefined,
      id: "f7b5585d-6867-4f3a-8151-da9ee1f70fab",
      extension: [
        {
          url: "http://fhir.openmrs.org/ext/medicationdispense/recorded",
          valueDateTime: "2023-01-05T20: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: 1,
        unit: "",
        code: "",
      },
      performer: undefined,
      resourceType: "MedicationDispense",
      status: MedicationDispenseStatus.completed,
      subject: { display: "", reference: "", type: "" },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: "",
      whenPrepared: "",
    };

    const medicationDispense3: MedicationDispense = {
      dosageInstruction: undefined,
      id: "a2121f8e-1bcc-4cf9-b1e8-1edace155e7f",
      extension: [
        {
          url: "http://fhir.openmrs.org/ext/medicationdispense/recorded",
          valueDateTime: "2023-01-05T17:00:00-05:00",
        },
      ],
      authorizingPrescription: [
        {
          reference: "MedicationRequest/075318da-ce26-4de5-9700-e49820f9d974",
          type: "MedicationRequest",
        },
      ],
      location: { display: "", reference: "", type: "" },
      medicationReference: { display: "", reference: "", type: "" },
      meta: { lastUpdated: "" },
      quantity: {
        value: 1,
        unit: "",
        code: "",
      },
      performer: undefined,
      resourceType: "MedicationDispense",
      status: MedicationDispenseStatus.declined,
      subject: { display: "", reference: "", type: "" },
      substitution: { reason: [], type: undefined, wasSubstituted: false },
      type: undefined,
      whenHandedOver: "",
      whenPrepared: "",
    };

    const medicationDispenses: Array<MedicationDispense> = [
      medicationDispense1,
      medicationDispense2,
      medicationDispense3,
    ];

    test("should return true if most recent medication request", () => {
      expect(
        isMostRecentMedicationDispense(medicationDispense2, medicationDispenses)
      ).toBe(true);
    });
    test("should return false if not most recent medication requst", () => {
      expect(
        isMostRecentMedicationDispense(medicationDispense1, medicationDispenses)
      ).toBe(false);
    });
    test("should return false if null", () => {
      expect(isMostRecentMedicationDispense(null, medicationDispenses)).toBe(
        false
      );
    });
  });
});