expand the test coverage of the orchestration script a bit

Author: wildjames

packages/postDatedLambda/src/orchestration.ts

@@ -5,7 +5,7 @@ import {enrichMessagesWithExistingRecords} from "./databaseClient"
 import {receivePostDatedSQSMessages, reportQueueStatus, handleProcessedMessages} from "./sqs"
 import {BatchProcessingResult, PostDatedSQSMessage} from "./types"
 
-const MAX_QUEUE_RUNTIME = 14 * 60 * 1000 // 14 minutes, to avoid Lambda timeout issues (timeout is 15 minutes)
+export const MAX_QUEUE_RUNTIME = 14 * 60 * 1000 // 14 minutes, to avoid Lambda timeout issues (timeout is 15 minutes)
 const MIN_RECEIVED_THRESHOLD = 3 // If fewer than this number of messages are received, consider the queue empty
 
 /**

packages/postDatedLambda/tests/testOrchestration.test.ts

@@ -34,10 +34,10 @@ jest.unstable_mockModule("../src/sqs", () => {
 import {Logger} from "@aws-lambda-powertools/logger"
 
 import {createMockPostModifiedDataItem} from "./testUtils"
-import {PostDatedSQSMessage} from "../src/types"
+import {BatchProcessingResult, PostDatedSQSMessage} from "../src/types"
 
 // Import the orchestration module after mocking dependencies
-const {processMessages} = await import("../src/orchestration")
+const {processMessages, processPostDatedQueue} = await import("../src/orchestration")
 
 const logger = new Logger({serviceName: "postDatedLambdaTEST"})
 
@@ -71,4 +71,72 @@ describe("orchestration", () => {
       expect(result.immaturePrescriptionUpdates).toHaveLength(0)
     })
   })
+
+  describe("processPostDatedQueue", () => {
+    beforeEach(() => {
+      jest.clearAllMocks()
+    })
+
+    it("should process the SQS queue correctly", async () => {
+      const mockMessages: Array<PostDatedSQSMessage> = [
+        {MessageId: "1", Body: "Message 1", prescriptionData: createMockPostModifiedDataItem({})},
+        {MessageId: "2", Body: "Message 2", prescriptionData: createMockPostModifiedDataItem({})}
+      ]
+
+      const mockEnrichedMessages = mockMessages.map((message) => ({
+        ...message,
+        existingRecords: []
+      }))
+
+      mockReceivePostDatedSQSMessages.mockReturnValueOnce(mockMessages)
+      mockEnrichMessagesWithExistingRecords.mockReturnValueOnce(mockEnrichedMessages)
+      mockProcessMessage.mockReturnValue(true)
+
+      await processPostDatedQueue(logger)
+
+      expect(mockReceivePostDatedSQSMessages).toHaveBeenCalledWith(logger)
+      expect(mockReportQueueStatus).not.toHaveBeenCalled()
+      expect(mockHandleProcessedMessages).toHaveBeenCalled()
+      const [res, lg] =
+        mockHandleProcessedMessages.mock.calls[0] as [BatchProcessingResult, Logger]
+      expect(lg).toBe(logger)
+      expect(res.maturedPrescriptionUpdates).toHaveLength(mockMessages.length)
+      expect(res.immaturePrescriptionUpdates).toHaveLength(0)
+      expect(res.maturedPrescriptionUpdates.map((message) => message.MessageId)).toEqual(
+        mockMessages.map((message) => message.MessageId)
+      )
+      expect(mockProcessMessage).toHaveBeenCalledTimes(mockMessages.length)
+    })
+
+    it("Should stop processing if the max runtime is exceeded", async () => {
+      jest.useFakeTimers()
+      const mockMessages: Array<PostDatedSQSMessage> = [
+        {MessageId: "1", Body: "Message 1", prescriptionData: createMockPostModifiedDataItem({})},
+        {MessageId: "2", Body: "Message 2", prescriptionData: createMockPostModifiedDataItem({})},
+        {MessageId: "3", Body: "Message 3", prescriptionData: createMockPostModifiedDataItem({})},
+        {MessageId: "4", Body: "Message 4", prescriptionData: createMockPostModifiedDataItem({})},
+        {MessageId: "5", Body: "Message 5", prescriptionData: createMockPostModifiedDataItem({})},
+        {MessageId: "6", Body: "Message 6", prescriptionData: createMockPostModifiedDataItem({})}
+      ]
+
+      mockReceivePostDatedSQSMessages.mockReturnValue(mockMessages)
+      mockEnrichMessagesWithExistingRecords.mockReturnValue(
+        mockMessages.map((message) => ({
+          ...message,
+          existingRecords: []
+        }))
+      )
+      const {MAX_QUEUE_RUNTIME} = await import("../src/orchestration")
+      mockProcessMessage.mockImplementation(async () => {
+        // Overrun by a second
+        jest.advanceTimersByTime(MAX_QUEUE_RUNTIME + 1000)
+        return true
+      })
+
+      await processPostDatedQueue(logger)
+
+      expect(mockReportQueueStatus).toHaveBeenCalled()
+      jest.useRealTimers()
+    })
+  })
 })