CCM-13378: Handle No Supplier Available

Author: nhsd-david-wass

lambdas/supplier-allocator/src/handler/__tests__/allocate-handler.test.ts

@@ -253,12 +253,15 @@ describe("createSupplierAllocatorHandler", () => {
 
     const messageBody = JSON.parse(sendCall.input.MessageBody);
     expect(messageBody.letterEvent).toEqual(preparedEvent);
-    expect(messageBody.supplierSpec).toEqual({
+    expect(messageBody.allocationDetails.supplierSpec).toEqual({
       supplierId: "supplier1",
       specId: "spec1",
       priority: 1,
       billingId: "billing1",
     });
+    expect(messageBody.allocationDetails.allocationStatus).toEqual({
+      status: "PENDING",
+    });
   });
 
   test("parses SNS notification and sends message to SQS queue for v1 event", async () => {
@@ -281,12 +284,15 @@ describe("createSupplierAllocatorHandler", () => {
     expect(mockSqsClient.send).toHaveBeenCalledTimes(1);
     const sendCall = (mockSqsClient.send as jest.Mock).mock.calls[0][0];
     const messageBody = JSON.parse(sendCall.input.MessageBody);
-    expect(messageBody.supplierSpec).toEqual({
+    expect(messageBody.allocationDetails.supplierSpec).toEqual({
       supplierId: "supplier1",
       specId: "spec1",
       priority: 1,
       billingId: "billing1",
     });
+    expect(messageBody.allocationDetails.allocationStatus).toEqual({
+      status: "PENDING",
+    });
   });
 
   test("returns batch failure for Update event", async () => {
@@ -486,74 +492,105 @@ describe("createSupplierAllocatorHandler", () => {
     const handler = createSupplierAllocatorHandler(mockedDeps);
     const result = await handler(evt, {} as any, {} as any);
     if (!result) throw new Error("expected BatchResponse, got void");
-    expect(result.batchItemFailures).toHaveLength(1);
-    expect((mockedDeps.logger.error as jest.Mock).mock.calls).toHaveLength(2);
+    expect((mockedDeps.logger.error as jest.Mock).mock.calls).toHaveLength(1);
     expect((mockedDeps.logger.error as jest.Mock).mock.calls[0][0]).toEqual(
       expect.objectContaining({
         description: "Error fetching supplier from config",
         err: configError,
         variantId: "lv1",
       }),
     );
+    expect(mockSqsClient.send).toHaveBeenCalledTimes(1);
+    const sendCall = (mockSqsClient.send as jest.Mock).mock.calls[0][0];
+    expect(sendCall).toBeInstanceOf(SendMessageCommand);
+
+    const messageBody = JSON.parse(sendCall.input.MessageBody);
+    expect(messageBody.letterEvent).toEqual(preparedEvent);
+    expect(messageBody.allocationDetails.supplierSpec).toEqual({
+      supplierId: "unknown",
+      specId: "unknown",
+      priority: 0,
+      billingId: "unknown",
+    });
+    expect(messageBody.allocationDetails.allocationStatus).toEqual({
+      status: "REJECTED",
+      reasonCode: "NO_SUPPLIERS_AVAILABLE",
+      reasonText: "Failed to retrieve supplier config",
+    });
   });
 
-  const rejectWith = (mock: jest.Mock, error: Error) =>
-    mock.mockRejectedValueOnce(error);
+  const rejectWith = (mock: jest.Mock, errorMessage: string) =>
+    mock.mockRejectedValueOnce(new Error(errorMessage));
+
+  const throwAny = (mock: jest.Mock) =>
+    mock.mockRejectedValueOnce("anything that is not an Error");
 
   const supplierConfigErrorCases = [
     {
       name: "getVolumeGroupDetails",
+      errorMessage: "Volume group retrieval failed",
       setup: () =>
         rejectWith(
           supplierConfig.getVolumeGroupDetails as jest.Mock,
-          new Error("Volume group retrieval failed"),
+          "Volume group retrieval failed",
         ),
     },
     {
       name: "eligibleSuppliers",
+      errorMessage: "Eligible suppliers retrieval failed",
       setup: () =>
         rejectWith(
           allocationConfig.eligibleSuppliers as jest.Mock,
-          new Error("Eligible suppliers retrieval failed"),
+          "Eligible suppliers retrieval failed",
         ),
     },
     {
       name: "preferredSupplierPack",
+      errorMessage: "Preferred supplier pack retrieval failed",
       setup: () =>
         rejectWith(
           allocationConfig.preferredSupplierPack as jest.Mock,
-          new Error("Preferred supplier pack retrieval failed"),
+          "Preferred supplier pack retrieval failed",
         ),
     },
     {
       name: "suppliersWithValidPack",
+      errorMessage: "Suppliers with valid pack retrieval failed",
       setup: () =>
         rejectWith(
           allocationConfig.suppliersWithValidPack as jest.Mock,
-          new Error("Suppliers with valid pack retrieval failed"),
+          "Suppliers with valid pack retrieval failed",
         ),
     },
     {
       name: "filterSuppliersWithCapacity",
+      errorMessage: "Filter suppliers with capacity failed",
       setup: () =>
         rejectWith(
           allocationConfig.filterSuppliersWithCapacity as jest.Mock,
-          new Error("Filter suppliers with capacity failed"),
+          "Filter suppliers with capacity failed",
         ),
     },
     {
       name: "selectSupplierByFactor",
+      errorMessage: "Select supplier by factor failed",
       setup: () =>
         rejectWith(
           allocationConfig.selectSupplierByFactor as jest.Mock,
-          new Error("Select supplier by factor failed"),
+          "Select supplier by factor failed",
         ),
     },
+    {
+      name: "unexpectedError",
+      errorMessage: "Unknown error",
+      setup: () =>
+        throwAny(allocationConfig.selectSupplierByFactor as jest.Mock),
+    },
   ];
 
   test.each(supplierConfigErrorCases)(
     "logs error when %s rejects during supplier config resolution",
-    async ({ setup }) => {
+    async ({ errorMessage, setup }) => {
       const preparedEvent = createPreparedV2Event();
       const evt: SQSEvent = createSQSEvent([
         createSqsRecord("msg1", JSON.stringify(preparedEvent)),
@@ -566,14 +603,30 @@ describe("createSupplierAllocatorHandler", () => {
       const result = await handler(evt, {} as any, {} as any);
       if (!result) throw new Error("expected BatchResponse, got void");
 
-      expect(result.batchItemFailures).toHaveLength(1);
-      expect((mockedDeps.logger.error as jest.Mock).mock.calls).toHaveLength(2);
+      expect((mockedDeps.logger.error as jest.Mock).mock.calls).toHaveLength(1);
       expect((mockedDeps.logger.error as jest.Mock).mock.calls[0][0]).toEqual(
         expect.objectContaining({
           description: "Error fetching supplier from config",
           variantId: "lv1",
         }),
       );
+      expect(mockSqsClient.send).toHaveBeenCalledTimes(1);
+      const sendCall = (mockSqsClient.send as jest.Mock).mock.calls[0][0];
+      expect(sendCall).toBeInstanceOf(SendMessageCommand);
+
+      const messageBody = JSON.parse(sendCall.input.MessageBody);
+      expect(messageBody.letterEvent).toEqual(preparedEvent);
+      expect(messageBody.allocationDetails.supplierSpec).toEqual({
+        supplierId: "unknown",
+        specId: "unknown",
+        priority: 0,
+        billingId: "unknown",
+      });
+      expect(messageBody.allocationDetails.allocationStatus).toEqual({
+        status: "REJECTED",
+        reasonCode: "NO_SUPPLIERS_AVAILABLE",
+        reasonText: errorMessage,
+      });
     },
   );
 

lambdas/supplier-allocator/src/handler/allocate-handler.ts

@@ -112,11 +112,16 @@ async function getSupplierFromConfig(
     });
 
     const supplierDetails: SupplierDetails = {
-      supplierSpec: {
-        supplierId: selectedSupplierId,
-        specId: preferredPack.id,
-        priority: letterVariant.priority,
-        billingId: preferredPack.billingId,
+      allocationDetails: {
+        supplierSpec: {
+          supplierId: selectedSupplierId,
+          specId: preferredPack.id,
+          priority: letterVariant.priority,
+          billingId: preferredPack.billingId,
+        },
+        allocationStatus: {
+          status: "PENDING",
+        },
       },
       volumeGroupId: volumeGroup.id,
     };
@@ -127,7 +132,23 @@ async function getSupplierFromConfig(
       err: error,
       variantId: letterEvent.data.letterVariantId,
     });
-    throw error;
+    const supplierDetails: SupplierDetails = {
+      allocationDetails: {
+        supplierSpec: {
+          supplierId: "unknown",
+          specId: "unknown",
+          priority: 0,
+          billingId: "unknown",
+        },
+        allocationStatus: {
+          status: "REJECTED",
+          reasonCode: "NO_SUPPLIERS_AVAILABLE",
+          reasonText: error instanceof Error ? error.message : "Unknown error",
+        },
+      },
+      volumeGroupId: "unknown",
+    };
+    return supplierDetails;
   }
 }
 
@@ -224,28 +245,32 @@ export default function createSupplierAllocatorHandler(deps: Deps): SQSHandler {
           letterEvent as PreparedEvents,
           deps,
         );
-        const supplierSpec = supplierDetails?.supplierSpec;
 
         deps.logger.info({
           description: "Resolved supplier details from config",
           supplierDetails,
         });
-
-        incrementAllocation(
-          volumeGroupAllocations,
-          supplierDetails.volumeGroupId,
-          supplierDetails?.supplierSpec.supplierId,
-          1,
-          deps,
-        );
+        const supplierSpec = supplierDetails?.allocationDetails?.supplierSpec;
 
         supplier = supplierSpec.supplierId;
         priority = String(supplierSpec.priority);
 
-        deps.logger.info({
-          description: "Resolved supplier spec",
-          supplierSpec,
-        });
+        if (
+          supplierDetails.allocationDetails.allocationStatus.status ===
+          "PENDING"
+        ) {
+          incrementMetric(perAllocationSuccess, supplier, priority);
+
+          incrementAllocation(
+            volumeGroupAllocations,
+            supplierDetails.volumeGroupId,
+            supplier,
+            1,
+            deps,
+          );
+        } else {
+          incrementMetric(perAllocationFailure, supplier, priority);
+        }
 
         // Send to allocated letters queue
         const queueUrl = process.env.UPSERT_LETTERS_QUEUE_URL;
@@ -255,7 +280,7 @@ export default function createSupplierAllocatorHandler(deps: Deps): SQSHandler {
 
         const queueMessage = {
           letterEvent,
-          supplierSpec,
+          allocationDetails: supplierDetails.allocationDetails,
         };
 
         deps.logger.info({
@@ -270,8 +295,6 @@ export default function createSupplierAllocatorHandler(deps: Deps): SQSHandler {
             MessageBody: JSON.stringify(queueMessage),
           }),
         );
-
-        incrementMetric(perAllocationSuccess, supplier, priority);
       } catch (error) {
         deps.logger.error({
           description: "Error processing allocation of record",

lambdas/supplier-allocator/src/handler/types.ts

@@ -8,8 +8,19 @@ export type SupplierSpec = {
   billingId: string;
 };
 
-export type SupplierDetails = {
+export type AllocationStatus = {
+  status: string;
+  reasonCode?: string;
+  reasonText?: string;
+};
+
+export type AllocationDetails = {
   supplierSpec: SupplierSpec;
+  allocationStatus: AllocationStatus;
+};
+
+export type SupplierDetails = {
+  allocationDetails: AllocationDetails;
   volumeGroupId: string;
 };