Add unit tests for the database client

Author: wildjames

packages/postDatedLambda/src/databaseClient.ts

@@ -13,7 +13,7 @@ const client = new DynamoDBClient()
 const tableName = process.env.TABLE_NAME ?? "PrescriptionStatusUpdates"
 const pharmacyPrescriptionIndexName = "PharmacyODSCodePrescriptionIDIndex"
 
-function createPrescriptionLookupKey(prescriptionID: string, pharmacyODSCode: string): string {
+export function createPrescriptionLookupKey(prescriptionID: string, pharmacyODSCode: string): string {
   return `${prescriptionID.toUpperCase()}#${pharmacyODSCode.toUpperCase()}`
 }
 

packages/postDatedLambda/tests/testDatabaseClient.test.ts

@@ -0,0 +1,255 @@
+import {
+  expect,
+  describe,
+  it,
+  jest
+} from "@jest/globals"
+
+import * as dynamo from "@aws-sdk/client-dynamodb"
+
+import {Logger} from "@aws-lambda-powertools/logger"
+
+import {createMockPostModifiedDataItem} from "./testUtils"
+
+// Uses unstable jest method to enable mocking while using ESM. To be replaced in future.
+export function mockDynamoDBClient() {
+  const mockSend = jest.fn()
+  jest.unstable_mockModule("@aws-sdk/client-dynamodb", () => {
+    return {
+      ...dynamo,
+      DynamoDBClient: jest.fn().mockImplementation(() => ({
+        send: mockSend
+      }))
+    }
+  })
+  return {mockSend}
+}
+
+const {mockSend} = mockDynamoDBClient()
+const {
+  createPrescriptionLookupKey,
+  getExistingRecordsByPrescriptionID,
+  fetchExistingRecordsForPrescriptions,
+  enrichMessagesWithExistingRecords
+} = await import("../src/databaseClient")
+
+const logger = new Logger({serviceName: "postDatedLambdaTEST"})
+
+describe("databaseClient", () => {
+  describe("createPrescriptionLookupKey", () => {
+    it("should create the correct lookup key", () => {
+      const prescriptionID = "abc123"
+      const pharmacyODSCode = "pharm001"
+      const expectedKey = "ABC123#PHARM001"
+
+      const result = createPrescriptionLookupKey(prescriptionID, pharmacyODSCode)
+      expect(result).toBe(expectedKey)
+    })
+  })
+
+  describe("getExistingRecordsByPrescriptionID", () => {
+    it("should return existing records from DynamoDB", async () => {
+      const prescriptionID = "testPrescID"
+      const pharmacyODSCode = "testPharmODS"
+
+      // Mock DynamoDB response
+      const mockItems = [
+        {
+          PrescriptionID: {S: prescriptionID},
+          PharmacyODSCode: {S: pharmacyODSCode},
+          Status: {S: "Dispensed"},
+          LastModified: {S: "2024-01-01T12:00:00Z"}
+        },
+        {
+          PrescriptionID: {S: prescriptionID},
+          PharmacyODSCode: {S: pharmacyODSCode},
+          Status: {S: "ReadyForCollection"},
+          LastModified: {S: "2023-12-31T12:00:00Z"}
+        }
+      ]
+
+      mockSend.mockReturnValueOnce({
+        Items: mockItems,
+        LastEvaluatedKey: undefined
+      })
+
+      const records = await getExistingRecordsByPrescriptionID(
+        prescriptionID,
+        pharmacyODSCode,
+        logger
+      )
+
+      expect(records).toHaveLength(2)
+      expect(records[0].Status).toBe("Dispensed")
+      expect(records[1].Status).toBe("ReadyForCollection")
+    })
+
+    it("Should log and throw an error if the DynamoDB query fails", async () => {
+      const prescriptionID = "errorPrescID"
+      const pharmacyODSCode = "errorPharmODS"
+
+      // Mock DynamoDB to throw an error
+      const mockError = new Error("DynamoDB query failed")
+      mockSend.mockImplementationOnce(() => {
+        throw mockError
+      })
+
+      await expect(
+        getExistingRecordsByPrescriptionID(
+          prescriptionID,
+          pharmacyODSCode,
+          logger
+        )
+      ).rejects.toThrow("DynamoDB query failed")
+    })
+  })
+
+  describe("fetchExistingRecordsForPrescriptions", () => {
+    it("should fetch existing records for multiple prescriptions", async () => {
+      const prescriptions = [
+        createMockPostModifiedDataItem({PrescriptionID: "presc1", PharmacyODSCode: "pharmA"}),
+        createMockPostModifiedDataItem({PrescriptionID: "presc2", PharmacyODSCode: "pharmB"})
+      ]
+
+      // Mock DynamoDB responses
+      const mockItemsPresc1 = [
+        {
+          PrescriptionID: {S: "presc1"},
+          PharmacyODSCode: {S: "pharmA"},
+          Status: {S: "Dispensed"},
+          LastModified: {S: "2024-01-01T12:00:00Z"}
+        }
+      ]
+
+      const mockItemsPresc2 = [
+        {
+          PrescriptionID: {S: "presc2"},
+          PharmacyODSCode: {S: "pharmB"},
+          Status: {S: "ReadyForCollection"},
+          LastModified: {S: "2024-01-02T12:00:00Z"}
+        }
+      ]
+
+      mockSend
+        .mockReturnValueOnce({
+          Items: mockItemsPresc1,
+          LastEvaluatedKey: undefined
+        })
+        .mockReturnValueOnce({
+          Items: mockItemsPresc2,
+          LastEvaluatedKey: undefined
+        })
+
+      const result = await fetchExistingRecordsForPrescriptions(
+        prescriptions,
+        logger
+      )
+
+      expect(result.length).toBe(2)
+      expect(result[0].existingRecords.length).toBe(1)
+      expect(result[0].existingRecords[0].Status).toBe("Dispensed")
+      expect(result[1].existingRecords.length).toBe(1)
+      expect(result[1].existingRecords[0].Status).toBe("ReadyForCollection")
+    })
+
+    it(
+      "Should log an error if the fetch fails for one prescription, and set the existingRecords to empty array",
+      async () => {
+        const prescriptions = [
+          createMockPostModifiedDataItem({PrescriptionID: "presc1", PharmacyODSCode: "pharmA"}),
+          createMockPostModifiedDataItem({PrescriptionID: "errorPresc", PharmacyODSCode: "errorPharm"})
+        ]
+
+        // Mock DynamoDB responses
+        const mockItemsPresc1 = [
+          {
+            PrescriptionID: {S: "presc1"},
+            PharmacyODSCode: {S: "pharmA"},
+            Status: {S: "Dispensed"},
+            LastModified: {S: "2024-01-01T12:00:00Z"}
+          }
+        ]
+
+        mockSend
+          .mockReturnValueOnce({
+            Items: mockItemsPresc1,
+            LastEvaluatedKey: undefined
+          })
+          .mockImplementationOnce(() => {
+            throw new Error("DynamoDB query failed")
+          })
+
+        const result = await fetchExistingRecordsForPrescriptions(
+          prescriptions,
+          logger
+        )
+
+        expect(result.length).toBe(2)
+        expect(result[0].existingRecords.length).toBe(1)
+        expect(result[0].existingRecords[0].Status).toBe("Dispensed")
+        expect(result[1].existingRecords.length).toBe(0)
+      })
+  })
+
+  describe("enrichMessagesWithExistingRecords", () => {
+    it("should enrich messages with existing records", async () => {
+      const prescriptions = [
+        createMockPostModifiedDataItem({PrescriptionID: "presc1", PharmacyODSCode: "pharmA"}),
+        createMockPostModifiedDataItem({PrescriptionID: "presc2", PharmacyODSCode: "pharmB"})
+      ]
+
+      // Mock DynamoDB responses
+      const mockItemsPresc1 = [
+        {
+          PrescriptionID: {S: "presc1"},
+          PharmacyODSCode: {S: "pharmA"},
+          Status: {S: "Dispensed"},
+          LastModified: {S: "2024-01-01T12:00:00Z"}
+        }
+      ]
+
+      const mockItemsPresc2 = [
+        {
+          PrescriptionID: {S: "presc2"},
+          PharmacyODSCode: {S: "pharmB"},
+          Status: {S: "ReadyForCollection"},
+          LastModified: {S: "2024-01-02T12:00:00Z"}
+        }
+      ]
+
+      mockSend
+        .mockReturnValueOnce({
+          Items: mockItemsPresc1,
+          LastEvaluatedKey: undefined
+        })
+        .mockReturnValueOnce({
+          Items: mockItemsPresc2,
+          LastEvaluatedKey: undefined
+        })
+
+      const messages = prescriptions.map((presc) => ({
+        prescriptionData: presc
+      }))
+
+      const enrichedMessages = await enrichMessagesWithExistingRecords(
+        messages,
+        logger
+      )
+
+      expect(enrichedMessages.length).toBe(2)
+      expect(enrichedMessages[0].existingRecords.length).toBe(1)
+      expect(enrichedMessages[0].existingRecords[0].Status).toBe("Dispensed")
+      expect(enrichedMessages[1].existingRecords.length).toBe(1)
+      expect(enrichedMessages[1].existingRecords[0].Status).toBe("ReadyForCollection")
+    })
+  })
+
+  it("Should return empty array when no messages are provided", async () => {
+    const enrichedMessages = await enrichMessagesWithExistingRecords(
+      [],
+      logger
+    )
+
+    expect(enrichedMessages).toEqual([])
+  })
+})

…kages/postDatedLambda/tests/main.test.ts …s/postDatedLambda/tests/testMain.test.tspackages/postDatedLambda/tests/main.test.ts renamed to packages/postDatedLambda/tests/testMain.test.ts packages/postDatedLambda/tests/main.test.ts renamed to packages/postDatedLambda/tests/testMain.test.ts

@@ -0,0 +1,33 @@
+import {PSUDataItem, PostDatedNotifyDataItem} from "packages/common/commonTypes/lib/src"
+
+export function createMockDataItem(overrides: Partial<PSUDataItem>): PSUDataItem {
+  return {
+    LastModified: "2023-01-02T00:00:00Z",
+    LineItemID: "spamandeggs",
+    PatientNHSNumber: "0123456789",
+    PharmacyODSCode: "ABC123",
+    PrescriptionID: "abcdef-ghijkl-mnopqr",
+    RequestID: "x-request-id",
+    Status: "ready to collect",
+    TaskID: "mnopqr-ghijkl-abcdef",
+    TerminalStatus: "ready to collect",
+    ApplicationName: "Internal Test System",
+    ExpiryTime: 123,
+    ...overrides
+  }
+}
+
+export function createMockPostModifiedDataItem(overrides: Partial<PostDatedNotifyDataItem>): PostDatedNotifyDataItem {
+  return {
+    LastModified: "2023-01-02T00:00:00Z",
+    LineItemID: "spamandeggs",
+    PatientNHSNumber: "0123456789",
+    PharmacyODSCode: "ABC123",
+    PrescriptionID: "abcdef-ghijkl-mnopqr",
+    RequestID: "x-request-id",
+    Status: "ready to collect",
+    TaskID: "mnopqr-ghijkl-abcdef",
+    PostDatedLastModifiedSetAt: "Changed dosage instructions",
+    ...overrides
+  }
+}