CCM-15259 - Improve client subscription management script

infrastructure/terraform/components/callbacks/module_mock_webhook_lambda.tf

@@ -95,17 +95,17 @@ resource "aws_lambda_function_url" "mock_webhook" {
 
 resource "aws_lambda_permission" "mock_webhook_function_url" {
   count                  = var.deploy_mock_webhook ? 1 : 0
-  statement_id           = "FunctionURLAllowPublicAccess"
+  statement_id_prefix    = "FunctionURLAllowPublicAccess"
   action                 = "lambda:InvokeFunctionUrl"
   function_name          = module.mock_webhook_lambda[0].function_name
   principal              = "*"
   function_url_auth_type = "NONE"
 }
 
 resource "aws_lambda_permission" "mock_webhook_function_invoke" {
-  count         = var.deploy_mock_webhook ? 1 : 0
-  statement_id  = "FunctionURLAllowInvokeAction"
-  action        = "lambda:InvokeFunction"
-  function_name = module.mock_webhook_lambda[0].function_name
-  principal     = "*"
+  count               = var.deploy_mock_webhook ? 1 : 0
+  statement_id_prefix = "FunctionURLAllowInvokeAction"
+  action              = "lambda:InvokeFunction"
+  function_name       = module.mock_webhook_lambda[0].function_name
+  principal           = "*"
 }

jest.config.base.ts

@@ -3,6 +3,7 @@ import type { Config } from "jest";
 export const baseJestConfig: Config = {
   preset: "ts-jest",
   clearMocks: true,
+  silent: true,
   collectCoverage: true,
   coverageDirectory: "./.reports/unit/coverage",
   coverageProvider: "v8",

lambdas/client-transform-filter-lambda/src/__tests__/helpers/client-subscription-fixtures.ts

@@ -0,0 +1,94 @@
+import type {
+  CallbackTarget,
+  Channel,
+  ChannelStatus,
+  ChannelStatusSubscriptionConfiguration,
+  ClientSubscriptionConfiguration,
+  MessageStatus,
+  MessageStatusSubscriptionConfiguration,
+  SupplierStatus,
+} from "@nhs-notify-client-callbacks/models";
+
+export const DEFAULT_TARGET_ID = "00000000-0000-4000-8000-000000000001";
+
+type TargetOverrides = Partial<CallbackTarget> & {
+  apiKey?: Partial<CallbackTarget["apiKey"]>;
+};
+
+export const createTarget = (
+  overrides: TargetOverrides = {},
+): CallbackTarget => ({
+  targetId: DEFAULT_TARGET_ID,
+  type: "API",
+  invocationEndpoint: "https://example.com",
+  invocationMethod: "POST",
+  invocationRateLimit: 10,
+  apiKey: {
+    headerName: "x-api-key",
+    headerValue: "secret",
+    ...overrides.apiKey,
+  },
+  ...overrides,
+});
+
+export const createMessageStatusSubscription = (
+  statuses: MessageStatus[] = ["DELIVERED"],
+  overrides: Partial<MessageStatusSubscriptionConfiguration> = {},
+): MessageStatusSubscriptionConfiguration => ({
+  subscriptionId: "00000000-0000-0000-0000-000000000001",
+  subscriptionType: "MessageStatus",
+  messageStatuses: statuses,
+  targetIds: [DEFAULT_TARGET_ID],
+  ...overrides,
+});
+
+export const createChannelStatusSubscription = (
+  channelStatuses: ChannelStatus[] = ["DELIVERED"],
+  supplierStatuses: SupplierStatus[] = ["delivered"],
+  channelType: Channel = "EMAIL",
+  overrides: Partial<ChannelStatusSubscriptionConfiguration> = {},
+): ChannelStatusSubscriptionConfiguration => ({
+  subscriptionId: "00000000-0000-0000-0000-000000000002",
+  subscriptionType: "ChannelStatus",
+  channelType,
+  channelStatuses,
+  supplierStatuses,
+  targetIds: [DEFAULT_TARGET_ID],
+  ...overrides,
+});
+
+export const createClientSubscriptionConfig = (
+  clientId = "client-1",
+  overrides: Partial<ClientSubscriptionConfiguration> = {},
+): ClientSubscriptionConfiguration => ({
+  clientId,
+  subscriptions: [],
+  targets: [],
+  ...overrides,
+});
+
+export const createMessageStatusConfig = (
+  statuses: MessageStatus[] = ["DELIVERED"],
+  clientId = "client-1",
+): ClientSubscriptionConfiguration =>
+  createClientSubscriptionConfig(clientId, {
+    subscriptions: [createMessageStatusSubscription(statuses)],
+    targets: [createTarget()],
+  });
+
+export const createChannelStatusConfig = (
+  channelStatuses: ChannelStatus[] = ["DELIVERED"],
+  supplierStatuses: SupplierStatus[] = ["delivered"],
+  clientId = "client-1",
+  channelType: Channel = "EMAIL",
+): ClientSubscriptionConfiguration =>
+  createClientSubscriptionConfig(clientId, {
+    subscriptions: [
+      createChannelStatusSubscription(
+        channelStatuses,
+        supplierStatuses,
+        channelType,
+      ),
+    ],
+    targets: [createTarget()],
+  });

lambdas/client-transform-filter-lambda/src/__tests__/index.component.test.ts

@@ -53,6 +53,7 @@ import { GetObjectCommand, NoSuchKey } from "@aws-sdk/client-s3";
 import { GetParameterCommand } from "@aws-sdk/client-ssm";
 import type { SQSRecord } from "aws-lambda";
 import { EventTypes } from "@nhs-notify-client-callbacks/models";
+import { createMessageStatusConfig } from "__tests__/helpers/client-subscription-fixtures";
 import { createS3Client } from "services/config-loader-service";
 import { applicationsMapService, configLoaderService, handler } from "..";
 
@@ -73,27 +74,8 @@ const makeSqsRecord = (body: object): SQSRecord => ({
   awsRegion: "eu-west-2",
 });
 
-const createValidConfig = (clientId: string) => [
-  {
-    SubscriptionId: "00000000-0000-0000-0000-000000000001",
-    ClientId: clientId,
-    Targets: [
-      {
-        Type: "API",
-        TargetId: "00000000-0000-4000-8000-000000000001",
-        InvocationEndpoint: "https://example.com/webhook",
-        InvocationMethod: "POST",
-        InvocationRateLimit: 10,
-        APIKey: {
-          HeaderName: "x-api-key",
-          HeaderValue: "secret",
-        },
-      },
-    ],
-    SubscriptionType: "MessageStatus",
-    MessageStatuses: ["DELIVERED", "FAILED"],
-  },
-];
+const createValidConfig = (clientId: string) =>
+  createMessageStatusConfig(["DELIVERED", "FAILED"], clientId);
 
 const validMessageStatusEvent = (clientId: string, messageStatus: string) => ({
   specversion: "1.0",

lambdas/client-transform-filter-lambda/src/__tests__/index.test.ts

@@ -13,63 +13,57 @@ import type { ConfigLoader } from "services/config-loader";
 import type { ApplicationsMapService } from "services/ssm-applications-map";
 import { ObservabilityService } from "services/observability";
 import { ConfigLoaderService } from "services/config-loader-service";
+import {
+  DEFAULT_TARGET_ID,
+  createChannelStatusSubscription,
+  createClientSubscriptionConfig,
+  createMessageStatusSubscription,
+  createTarget,
+} from "__tests__/helpers/client-subscription-fixtures";
 import { createHandler } from "..";
 
 jest.mock("aws-embedded-metrics");
 
-const stubTarget = {
-  Type: "API",
-  TargetId: "00000000-0000-4000-8000-000000000001",
-  InvocationEndpoint: "https://example.com/webhook",
-  InvocationMethod: "POST",
-  InvocationRateLimit: 10,
-  APIKey: { HeaderName: "x-api-key", HeaderValue: "test-api-key" },
-};
-
 const createPassthroughConfigLoader = (): ConfigLoader =>
   ({
-    loadClientConfig: jest.fn().mockImplementation(async (clientId: string) => [
-      {
-        SubscriptionType: "MessageStatus",
-        SubscriptionId: "00000000-0000-0000-0000-000000000001",
-        ClientId: clientId,
-        Targets: [stubTarget],
-        MessageStatuses: [
-          "DELIVERED",
-          "FAILED",
-          "PENDING",
-          "SENDING",
-          "TECHNICAL_FAILURE",
-          "PERMANENT_FAILURE",
-        ],
-      },
-      {
-        SubscriptionType: "ChannelStatus",
-        SubscriptionId: "00000000-0000-0000-0000-000000000002",
-        ClientId: clientId,
-        Targets: [stubTarget],
-        ChannelType: "NHSAPP",
-        ChannelStatuses: ["DELIVERED", "FAILED", "TECHNICAL_FAILURE"],
-        SupplierStatuses: [
-          "delivered",
-          "permanent_failure",
-          "temporary_failure",
+    loadClientConfig: jest
+      .fn()
+      .mockImplementation(async (clientId: string) => ({
+        ...createClientSubscriptionConfig(clientId),
+        subscriptions: [
+          createMessageStatusSubscription(["DELIVERED"], {
+            subscriptionId: "00000000-0000-0000-0000-000000000001",
+            targetIds: [DEFAULT_TARGET_ID],
+          }),
+          createChannelStatusSubscription(
+            ["DELIVERED"],
+            ["delivered"],
+            "NHSAPP",
+            {
+              subscriptionId: "00000000-0000-0000-0000-000000000002",
+              targetIds: [DEFAULT_TARGET_ID],
+            },
+          ),
+          createChannelStatusSubscription(
+            ["FAILED"],
+            ["permanent_failure"],
+            "SMS",
+            {
+              subscriptionId: "00000000-0000-0000-0000-000000000003",
+              targetIds: [DEFAULT_TARGET_ID],
+            },
+          ),
         ],
-      },
-      {
-        SubscriptionType: "ChannelStatus",
-        SubscriptionId: "00000000-0000-0000-0000-000000000003",
-        ClientId: clientId,
-        Targets: [stubTarget],
-        ChannelType: "SMS",
-        ChannelStatuses: ["DELIVERED", "FAILED", "TECHNICAL_FAILURE"],
-        SupplierStatuses: [
-          "delivered",
-          "permanent_failure",
-          "temporary_failure",
+        targets: [
+          createTarget({
+            invocationEndpoint: "https://example.com/webhook",
+            apiKey: {
+              headerName: "x-api-key",
+              headerValue: "test-api-key",
+            },
+          }),
         ],
-      },
-    ]),
+      })),
   }) as unknown as ConfigLoader;
 
 const makeStubConfigLoaderService = (): ConfigLoaderService => {
@@ -185,6 +179,59 @@ describe("Lambda handler", () => {
     );
   });
 
+  it("should record filtering-matched with matched subscription target IDs only", async () => {
+    const customConfigLoader = {
+      loadClientConfig: jest.fn().mockResolvedValue(
+        createClientSubscriptionConfig("client-abc-123", {
+          subscriptions: [
+            createMessageStatusSubscription(["DELIVERED"], {
+              targetIds: ["target-match"],
+            }),
+          ],
+          targets: [
+            createTarget({ targetId: "target-match" }),
+            createTarget({ targetId: "target-other" }),
+          ],
+        }),
+      ),
+    } as unknown as ConfigLoader;
+
+    const handlerWithMultipleTargets = createHandler({
+      createObservabilityService: () =>
+        new ObservabilityService(mockLogger, mockMetrics, mockMetricsLogger),
+      createConfigLoaderService: () =>
+        ({ getLoader: () => customConfigLoader }) as ConfigLoaderService,
+      createApplicationsMapService: makeStubApplicationsMapService,
+    });
+
+    const sqsMessage: SQSRecord = {
+      messageId: "sqs-msg-id-targets",
+      receiptHandle: "receipt-handle-targets",
+      body: JSON.stringify(validMessageStatusEvent),
+      attributes: {
+        ApproximateReceiveCount: "1",
+        SentTimestamp: "1519211230",
+        SenderId: "ABCDEFGHIJ",
+        ApproximateFirstReceiveTimestamp: "1519211230",
+      },
+      messageAttributes: {},
+      md5OfBody: "mock-md5",
+      eventSource: "aws:sqs",
+      eventSourceARN: "arn:aws:sqs:eu-west-2:123456789:mock-queue",
+      awsRegion: "eu-west-2",
+    };
+
+    await handlerWithMultipleTargets([sqsMessage]);
+
+    expect(mockLogger.info).toHaveBeenCalledWith(
+      "Callback lifecycle: filtering-matched",
+      expect.objectContaining({
+        subscriptionType: "MessageStatus",
+        targetIds: ["target-match"],
+      }),
+    );
+  });
+
   it("should handle batch of SQS messages from EventBridge Pipes", async () => {
     const sqsMessages: SQSRecord[] = [
       {