Fix unit tests

Author: wildjames

packages/postDatedLambda/tests/testOrchestration.test.ts

@@ -34,13 +34,29 @@ jest.unstable_mockModule("../src/sqs", () => {
 import {Logger} from "@aws-lambda-powertools/logger"
 
 import {createMockPostModifiedDataItem} from "./testUtils"
-import {BatchProcessingResult, PostDatedSQSMessage} from "../src/types"
+import {BatchProcessingResult, PostDatedProcessingResult, PostDatedSQSMessage} from "../src/types"
 
 // Import the orchestration module after mocking dependencies
 const {processMessages, processPostDatedQueue} = await import("../src/orchestration")
 
 const logger = new Logger({serviceName: "postDatedLambdaTEST"})
 
+// I needed to move these functions out of the describe block since it was too deeply nested.
+function createBatch(ids: Array<string>): Array<PostDatedSQSMessage> {
+  return ids.map((id) => ({
+    MessageId: id,
+    Body: `Message ${id}`,
+    prescriptionData: createMockPostModifiedDataItem({})
+  }))
+}
+
+function enrich(messages: Array<PostDatedSQSMessage>) {
+  return messages.map((message) => ({
+    ...message,
+    existingRecords: []
+  }))
+}
+
 describe("orchestration", () => {
   describe("processMessages", () => {
     beforeEach(() => {
@@ -50,30 +66,36 @@ describe("orchestration", () => {
     it("should process messages and categorize them correctly", async () => {
       const mockMessages: Array<PostDatedSQSMessage> = [
         {MessageId: "1", Body: "Message 1", prescriptionData: createMockPostModifiedDataItem({})},
-        {MessageId: "2", Body: "Message 2", prescriptionData: createMockPostModifiedDataItem({})}
+        {MessageId: "2", Body: "Message 2", prescriptionData: createMockPostModifiedDataItem({})},
+        {MessageId: "3", Body: "Message 3", prescriptionData: createMockPostModifiedDataItem({})}
       ]
 
       // Mock the enrichment function to return the same messages
       mockEnrichMessagesWithExistingRecords.mockReturnValueOnce(mockMessages)
 
       // Mock processMessage to return true for first message and false for second
-      mockProcessMessage.mockReturnValueOnce(true)
-      mockProcessMessage.mockReturnValueOnce(false)
+      mockProcessMessage
+        .mockReturnValueOnce(PostDatedProcessingResult.MATURED)
+        .mockReturnValueOnce(PostDatedProcessingResult.IMMATURE)
+        .mockReturnValueOnce(PostDatedProcessingResult.IGNORE)
 
       const result = await processMessages(mockMessages, logger)
 
       expect(result.maturedPrescriptionUpdates).toHaveLength(1)
       expect(result.maturedPrescriptionUpdates[0].MessageId).toBe("1")
       expect(result.immaturePrescriptionUpdates).toHaveLength(1)
       expect(result.immaturePrescriptionUpdates[0].MessageId).toBe("2")
+      expect(result.ignoredPrescriptionUpdates).toHaveLength(1)
+      expect(result.ignoredPrescriptionUpdates[0].MessageId).toBe("3")
     })
 
     it("should handle empty message array", async () => {
+      mockEnrichMessagesWithExistingRecords.mockReturnValueOnce([])
       const result = await processMessages([], logger)
 
       expect(result.maturedPrescriptionUpdates).toHaveLength(0)
       expect(result.immaturePrescriptionUpdates).toHaveLength(0)
-      expect(mockEnrichMessagesWithExistingRecords).not.toHaveBeenCalled()
+      expect(result.ignoredPrescriptionUpdates).toHaveLength(0)
     })
 
     it("should log errors and mark messages immature when processing throws", async () => {
@@ -84,8 +106,8 @@ describe("orchestration", () => {
 
       mockEnrichMessagesWithExistingRecords.mockReturnValueOnce(mockMessages)
       mockProcessMessage
-        .mockReturnValueOnce(true)
-        .mockImplementationOnce(async () => {
+        .mockReturnValueOnce(PostDatedProcessingResult.MATURED)
+        .mockImplementationOnce(() => {
           throw new Error("processing failed")
         })
 
@@ -94,6 +116,7 @@ describe("orchestration", () => {
 
       expect(result.maturedPrescriptionUpdates).toHaveLength(1)
       expect(result.immaturePrescriptionUpdates).toHaveLength(1)
+      expect(result.ignoredPrescriptionUpdates).toHaveLength(0)
       expect(result.immaturePrescriptionUpdates[0].MessageId).toBe("2")
       expect(errorSpy).toHaveBeenCalledWith(
         "Error processing message",
@@ -113,7 +136,7 @@ describe("orchestration", () => {
       }
 
       mockEnrichMessagesWithExistingRecords.mockReturnValueOnce([enrichedMessage])
-      mockProcessMessage.mockReturnValue(true)
+      mockProcessMessage.mockReturnValue(PostDatedProcessingResult.MATURED)
 
       await processMessages(mockMessages, logger)
 
@@ -139,7 +162,7 @@ describe("orchestration", () => {
 
       mockReceivePostDatedSQSMessages.mockReturnValueOnce(mockMessages)
       mockEnrichMessagesWithExistingRecords.mockReturnValueOnce(mockEnrichedMessages)
-      mockProcessMessage.mockReturnValue(true)
+      mockProcessMessage.mockReturnValue(PostDatedProcessingResult.MATURED)
 
       await processPostDatedQueue(logger)
 
@@ -179,7 +202,7 @@ describe("orchestration", () => {
       mockProcessMessage.mockImplementation(async () => {
         // Overrun by a second
         jest.advanceTimersByTime(MAX_QUEUE_RUNTIME + 1000)
-        return true
+        return PostDatedProcessingResult.MATURED
       })
 
       await processPostDatedQueue(logger)
@@ -189,23 +212,10 @@ describe("orchestration", () => {
     })
 
     it("should continue processing batches until message count drops below threshold", async () => {
-      const createBatch = (ids: Array<string>) =>
-        ids.map((id) => ({
-          MessageId: id,
-          Body: `Message ${id}`,
-          prescriptionData: createMockPostModifiedDataItem({})
-        }))
-
       const batch1 = createBatch(["1", "2", "3"])
       const batch2 = createBatch(["4", "5", "6"])
       const batch3 = createBatch(["7"])
 
-      const enrich = (messages: Array<PostDatedSQSMessage>) =>
-        messages.map((message) => ({
-          ...message,
-          existingRecords: []
-        }))
-
       mockReceivePostDatedSQSMessages
         .mockReturnValueOnce(batch1)
         .mockReturnValueOnce(batch2)
@@ -214,7 +224,7 @@ describe("orchestration", () => {
         .mockReturnValueOnce(enrich(batch1))
         .mockReturnValueOnce(enrich(batch2))
         .mockReturnValueOnce(enrich(batch3))
-      mockProcessMessage.mockReturnValue(true)
+      mockProcessMessage.mockReturnValue(PostDatedProcessingResult.MATURED)
 
       await processPostDatedQueue(logger)
 
@@ -227,16 +237,14 @@ describe("orchestration", () => {
 
     it("should treat empty receives as drained batches", async () => {
       mockReceivePostDatedSQSMessages.mockReturnValueOnce([])
+      mockEnrichMessagesWithExistingRecords.mockReturnValueOnce([])
 
       await processPostDatedQueue(logger)
 
-      expect(mockEnrichMessagesWithExistingRecords).not.toHaveBeenCalled()
-      expect(mockProcessMessage).not.toHaveBeenCalled()
       expect(mockHandleProcessedMessages).toHaveBeenCalledTimes(1)
       const [result] = mockHandleProcessedMessages.mock.calls[0] as [BatchProcessingResult]
       expect(result.maturedPrescriptionUpdates).toHaveLength(0)
       expect(result.immaturePrescriptionUpdates).toHaveLength(0)
-      expect(mockReportQueueStatus).not.toHaveBeenCalled()
     })
   })
 })

packages/postDatedLambda/tests/testSqs.test.ts

@@ -373,7 +373,8 @@ describe("sqs", () => {
 
       const batchResult: BatchProcessingResult = {
         maturedPrescriptionUpdates: maturedMessages,
-        immaturePrescriptionUpdates: immatureMessages
+        immaturePrescriptionUpdates: immatureMessages,
+        ignoredPrescriptionUpdates: []
       }
 
       // Mock SQS responses
@@ -403,7 +404,8 @@ describe("sqs", () => {
     it("should handle empty matured and immature message arrays gracefully", async () => {
       const batchResult: BatchProcessingResult = {
         maturedPrescriptionUpdates: [],
-        immaturePrescriptionUpdates: []
+        immaturePrescriptionUpdates: [],
+        ignoredPrescriptionUpdates: []
       }
 
       await handleProcessedMessages(batchResult, logger)
@@ -412,5 +414,40 @@ describe("sqs", () => {
       expect(infoSpy).not.toHaveBeenCalledWith("Successfully removed")
       expect(infoSpy).not.toHaveBeenCalledWith("Returning messages to queue with timeouts", expect.anything())
     })
+
+    it("should remove ignored messages from the queue so they are not reprocessed", async () => {
+      const testUrl = "https://sqs.us-east-1.amazonaws.com/123456789012/test-queue"
+      process.env.POST_DATED_PRESCRIPTIONS_SQS_QUEUE_URL = testUrl
+
+      const ignoredMessages: Array<PostDatedSQSMessage> = [
+        {
+          MessageId: "ignored-1",
+          ReceiptHandle: "ignored-handle-1",
+          prescriptionData: createMockPostModifiedDataItem({}),
+          Attributes: {MessageDeduplicationId: "dedup-ignored", MessageGroupId: "group-ignored"}
+        }
+      ]
+
+      const batchResult: BatchProcessingResult = {
+        maturedPrescriptionUpdates: [],
+        immaturePrescriptionUpdates: [],
+        ignoredPrescriptionUpdates: ignoredMessages
+      }
+
+      mockSend.mockReturnValueOnce({
+        Successful: ignoredMessages.map((msg) => ({Id: msg.MessageId})),
+        Failed: []
+      })
+
+      await handleProcessedMessages(batchResult, logger)
+
+      expect(mockSend).toHaveBeenCalledTimes(1)
+
+      const deleteCommand = mockSend.mock.calls[0][0] as {input: {Entries: Array<{Id: string; ReceiptHandle: string}>}}
+      expect(deleteCommand.input.Entries).toEqual([
+        {Id: "ignored-1", ReceiptHandle: "ignored-handle-1"}
+      ])
+      expect(infoSpy).toHaveBeenCalledWith("Successfully removed 1 messages from SQS")
+    })
   })
 })