Use update letter sqs queue for duplicate checking

Author: nhsd-david-wass

tests/component-tests/allocation-tests/supplier-allocation.spec.ts

@@ -14,7 +14,7 @@ import { sendSnsBatchEvent } from "tests/helpers/send-sns-event";
 test.describe("Supplier Allocation Tests", () => {
   test("Verify that supplier allocations are correctly updated for a volume group", async () => {
     test.setTimeout(180_000);
-    const volumeGroupId = "volumeGroup-test3";
+    const volumeGroupId = "volumeGroup-test1";
     const originalTotalAllocation =
       await getTotalAllocationForVolumeGroup(volumeGroupId);
     logger.info(
@@ -34,8 +34,14 @@ test.describe("Supplier Allocation Tests", () => {
     // Create 2 messages with same domain id
     const domainId = randomUUID();
 
-    const message1 = createPreparedV1Event({ domainId });
-    const message2 = createPreparedV1Event({ domainId });
+    const message1 = createPreparedV1Event({
+      domainId,
+      letterVariantId: "notify-standard-test1",
+    });
+    const message2 = createPreparedV1Event({
+      domainId,
+      letterVariantId: "notify-standard-test1",
+    });
 
     const eventBatch = [message1, message2];
     const response = await sendSnsBatchEvent(

tests/component-tests/events-tests/event-subscription.spec.ts

@@ -1,6 +1,10 @@
 import { expect, test } from "@playwright/test";
 import { sendSnsEvent } from "tests/helpers/send-sns-event";
-import { createPreparedV1Event } from "tests/helpers/event-fixtures";
+import { sendSqsEvent } from "tests/helpers/send-sqs-event";
+import {
+  createPendingAllocatedEvent,
+  createPreparedV1Event,
+} from "tests/helpers/event-fixtures";
 import { randomUUID } from "node:crypto";
 import { logger } from "tests/helpers/pino-logger";
 import { createValidRequestHeaders } from "tests/constants/request-headers";
@@ -91,35 +95,14 @@ test.describe("Event Subscription SNS Tests", () => {
     );
     expect(getLetterResponse.status()).toBe(404);
   });
-
-  test("Verify that an error is logged for a duplicate letter id", async () => {
+  test("Verify that an error is logged for duplicates sent on the sqs queue", async () => {
     const domainId = randomUUID();
     logger.info(`Testing event subscription with domainId: ${domainId}`);
-    const preparedEvent1 = createPreparedV1Event({ domainId });
-    const response1 = await sendSnsEvent(preparedEvent1);
-
-    expect(response1.MessageId).toBeTruthy();
-
-    // poll supplier allocator to check if supplier has been allocated
-    const message = await pollSupplierAllocatorLogForResolvedSpec(domainId);
-    const supplierAllocatorLog = JSON.parse(message) as {
-      msg?: { allocationDetails?: { supplierSpec?: { supplierId?: string } } };
-    };
-    const supplierId =
-      supplierAllocatorLog.msg?.allocationDetails?.supplierSpec?.supplierId;
-
-    logger.info(
-      `Supplier ${supplierId} allocated for domainId ${domainId} in supplier allocator lambda`,
-    );
-    if (!supplierId) {
-      throw new Error("supplierId was not found in supplier allocator log");
-    }
-
-    const preparedEvent2 = createPreparedV1Event({ domainId });
-    const response2 = await sendSnsEvent(preparedEvent2);
-    expect(response2.MessageId).toBeTruthy();
+    const pendingEvent = createPendingAllocatedEvent({ domainId });
+    await sendSqsEvent(JSON.stringify(pendingEvent));
+    const pendingEventDuplicate = createPendingAllocatedEvent({ domainId });
+    await sendSqsEvent(JSON.stringify(pendingEventDuplicate));
 
-    // poll supplier upsert to check if duplicate letter id was processed
     await pollUpsertLetterLogForWarning("Letter already exists", domainId);
   });
 });

tests/component-tests/letterQueue-tests/queue-operations.spec.ts

@@ -1,11 +1,12 @@
 import { expect, test } from "@playwright/test";
 import { randomUUID } from "node:crypto";
 import {
-  createPreparedEventBatchWithSameDomainId,
+  createPendingEventBatchWithSameDomainId,
   createPreparedV1Event,
 } from "tests/helpers/event-fixtures";
 import { logger } from "tests/helpers/pino-logger";
-import { sendSnsBatchEvent, sendSnsEvent } from "tests/helpers/send-sns-event";
+import { sendSnsEvent } from "tests/helpers/send-sns-event";
+import { sendSqsEventBatch } from "tests/helpers/send-sqs-event";
 import {
   pollUpsertLetterLogForWarning,
   supplierIdFromSupplierAllocatorLog,
@@ -80,27 +81,19 @@ test.describe("Letter Queue Tests", () => {
 
   test("Verify if the only one entry is inserted in the letter queue table for a batch of events with the same letterId", async () => {
     const letterId = randomUUID();
-    const eventBatch = createPreparedEventBatchWithSameDomainId({
+    const eventBatch = createPendingEventBatchWithSameDomainId({
       domainId: letterId,
     });
     logger.info(
       `Sending batch event with ${eventBatch.length} events ${letterId}`,
     );
-    const response = await sendSnsBatchEvent(
-      eventBatch.map((event) => ({
-        id: event.id,
-        message: event,
-      })),
-    );
-    expect(response.Successful).toHaveLength(eventBatch.length);
-
-    const supplierId = await supplierIdFromSupplierAllocatorLog(letterId);
+    await sendSqsEventBatch(eventBatch.map((event) => JSON.stringify(event)));
 
     logger.info(
       `Verifying duplicate queue inserts are ignored for the batch of events with same letterId ${letterId}`,
     );
     const [letterExists, itemCount] = await checkLetterQueueTable(
-      supplierId,
+      "supplier1",
       letterId,
     );
     expect(letterExists).toBe(true);

tests/constants/api-constants.ts

@@ -17,3 +17,4 @@ export const EVENT_SUBSCRIPTION_TOPIC_ARN =
   `arn:aws:sns:${AWS_REGION}:${AWS_ACCOUNT_ID}:${EVENT_SUBSCRIPTION_TOPIC_NAME}`;
 export const LETTERQUEUE_TABLENAME = `nhs-${envName}-supapi-letter-queue`;
 export const SUPPLIER_QUOTAS_TABLENAME = `nhs-${envName}-supapi-supplier-quotas`;
+export const UPSERT_LETTERS_QUEUE_URL = `https://sqs.${AWS_REGION}.amazonaws.com/${AWS_ACCOUNT_ID}/nhs-${envName}-supapi-letter-updates-queue`;

tests/helpers/event-fixtures.ts

@@ -39,12 +39,34 @@ export function createPreparedV1Event(overrides: Record<string, unknown> = {}) {
   };
 }
 
-export function createPreparedEventBatchWithSameDomainId(
+export function createPendingEventBatchWithSameDomainId(
   overrides: Record<string, unknown> = {},
 ) {
   return [
-    createPreparedV1Event(overrides),
-    createPreparedV1Event(overrides),
-    createPreparedV1Event(overrides),
+    createPendingAllocatedEvent(overrides),
+    createPendingAllocatedEvent(overrides),
+    createPendingAllocatedEvent(overrides),
   ];
 }
+
+export function createPendingAllocatedEvent(
+  overrides: Record<string, unknown> = {},
+) {
+  const letterEvent = createPreparedV1Event(overrides);
+  const allocationDetails = {
+    supplierSpec: {
+      supplierId: "supplier1",
+      specId: "spec1",
+      priority: 1,
+      billingId: "billing1",
+    },
+    allocationStatus: {
+      status: "PENDING",
+    },
+  };
+
+  return {
+    letterEvent,
+    allocationDetails,
+  };
+}

tests/helpers/send-sqs-event.ts

@@ -0,0 +1,33 @@
+import {
+  SQSClient,
+  SendMessageBatchCommand,
+  SendMessageCommand,
+} from "@aws-sdk/client-sqs";
+import { UPSERT_LETTERS_QUEUE_URL } from "tests/constants/api-constants";
+import { logger } from "tests/helpers/pino-logger";
+
+const sqsClient = new SQSClient({});
+
+export async function sendSqsEvent(messageBody: string): Promise<void> {
+  logger.info(
+    `Sending message to SQS queue ${UPSERT_LETTERS_QUEUE_URL}: ${messageBody}`,
+  );
+  await sqsClient.send(
+    new SendMessageCommand({
+      QueueUrl: UPSERT_LETTERS_QUEUE_URL,
+      MessageBody: messageBody,
+    }),
+  );
+}
+
+export async function sendSqsEventBatch(messages: string[]): Promise<void> {
+  await sqsClient.send(
+    new SendMessageBatchCommand({
+      QueueUrl: UPSERT_LETTERS_QUEUE_URL,
+      Entries: messages.map((message, index) => ({
+        Id: `message-${index}`,
+        MessageBody: message,
+      })),
+    }),
+  );
+}