CCM-12858: code coverage and updated README

nhsd-angel-pastor · nhsd-angel-pastor · commit ee655634d095 · 2025-12-16T11:14:37.000Z
diff --git a/lambdas/core-notifier-lambda/src/__tests__/apis/sqs-handler.test.ts b/lambdas/core-notifier-lambda/src/__tests__/apis/sqs-handler.test.ts
@@ -220,6 +220,49 @@ describe('createHandler', () => {
         mockEventPublisherFacade.publishMessageRequestRejected,
       ).not.toHaveBeenCalled();
     });
+
+    it('publishes rejected event when error has messageReference property', async () => {
+      const sqsEvent = createSqsEvent(1);
+      const handler = createHandler(dependencies);
+      const messageId = sqsEvent.Records[0].messageId;
+      const errorCode = 'VALIDATION_ERROR';
+      const correlationId = 'corr-123';
+      const error = new RequestNotifyError(
+        new Error('Validation failed'),
+        correlationId,
+        errorCode,
+      );
+      // Add messageReference property dynamically to trigger the terminal error path
+      (error as any).messageReference = messageReference;
+
+      mockParseSqsRecord.mockReturnValueOnce(mockPdmEvent);
+      mockSenderManagement.getSender.mockReturnValueOnce(mockSender);
+      mockNotifyMessageProcessor.process.mockRejectedValueOnce(error);
+
+      const result = await handler(sqsEvent);
+
+      // With messageReference property, it's treated as terminal error and not retried
+      expect(result).toEqual({ batchItemFailures: [] });
+      expect(mockLogger.warn).toHaveBeenCalledWith({
+        error: error.message,
+        description: 'Failed processing message',
+        messageId,
+      });
+      expect(
+        mockEventPublisherFacade.publishMessageRequestRejected,
+      ).toHaveBeenCalledTimes(1);
+      expect(
+        mockEventPublisherFacade.publishMessageRequestRejected,
+      ).toHaveBeenCalledWith(
+        expect.objectContaining({
+          data: expect.objectContaining({
+            senderId,
+            messageReference,
+            failureCode: errorCode,
+          }),
+        }),
+      );
+    });
   });
 
   describe('when processing throws a generic error', () => {
diff --git a/lambdas/core-notifier-lambda/src/__tests__/container.test.ts b/lambdas/core-notifier-lambda/src/__tests__/container.test.ts
@@ -0,0 +1,150 @@
+import { mock } from 'jest-mock-extended';
+import { ParameterStoreCache, logger } from 'utils';
+import { NotifyClient } from 'app/notify-api-client';
+import { NotifyMessageProcessor } from 'app/notify-message-processor';
+import { SenderManagement } from 'sender-management';
+import { createContainer } from 'container';
+import { loadConfig } from 'infra/config';
+
+jest.mock('utils', () => ({
+  ParameterStoreCache: jest.fn(),
+  createGetApimAccessToken: jest.fn(() => jest.fn()),
+  logger: {
+    info: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+    debug: jest.fn(),
+  },
+}));
+
+jest.mock('app/notify-api-client');
+jest.mock('app/notify-message-processor');
+jest.mock('sender-management');
+jest.mock('infra/config');
+
+describe('createContainer', () => {
+  const mockParameterStore = mock<ParameterStoreCache>();
+  const mockConfig = {
+    eventPublisherEventBusArn:
+      'arn:aws:events:eu-west-2:123456789012:event-bus/test-bus',
+    eventPublisherDlqUrl:
+      'https://sqs.eu-west-2.amazonaws.com/123456789012/test-dlq',
+    apimAccessTokenSsmParameterName: '/test/apim/access-token',
+    apimBaseUrl: 'https://api.test.nhs.uk',
+    environment: 'test',
+  };
+
+  const mockSenderManagement = mock<SenderManagement>();
+  const mockNotifyClient = mock<NotifyClient>();
+  const mockNotifyMessageProcessor = mock<NotifyMessageProcessor>();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    (ParameterStoreCache as jest.Mock).mockImplementation(
+      () => mockParameterStore,
+    );
+    (loadConfig as jest.Mock).mockReturnValue(mockConfig);
+    (SenderManagement as jest.Mock).mockImplementation(
+      () => mockSenderManagement,
+    );
+    (NotifyClient as jest.Mock).mockImplementation(() => mockNotifyClient);
+    (NotifyMessageProcessor as jest.Mock).mockImplementation(
+      () => mockNotifyMessageProcessor,
+    );
+  });
+
+  it('creates and returns a container with all dependencies', async () => {
+    const container = await createContainer();
+
+    expect(container).toEqual({
+      notifyMessageProcessor: mockNotifyMessageProcessor,
+      logger,
+      senderManagement: mockSenderManagement,
+    });
+  });
+
+  it('initializes ParameterStoreCache', async () => {
+    await createContainer();
+
+    expect(ParameterStoreCache).toHaveBeenCalledTimes(1);
+    expect(ParameterStoreCache).toHaveBeenCalledWith();
+  });
+
+  it('loads configuration', async () => {
+    await createContainer();
+
+    expect(loadConfig).toHaveBeenCalledTimes(1);
+  });
+
+  it('creates SenderManagement with parameter store', async () => {
+    await createContainer();
+
+    expect(SenderManagement).toHaveBeenCalledTimes(1);
+    expect(SenderManagement).toHaveBeenCalledWith({
+      parameterStore: mockParameterStore,
+    });
+  });
+
+  it('creates NotifyClient with config and dependencies', async () => {
+    await createContainer();
+
+    expect(NotifyClient).toHaveBeenCalledTimes(1);
+    expect(NotifyClient).toHaveBeenCalledWith(
+      mockConfig.apimBaseUrl,
+      expect.objectContaining({
+        getAccessToken: expect.any(Function),
+      }),
+      logger,
+    );
+  });
+
+  it('creates NotifyMessageProcessor with client and logger', async () => {
+    await createContainer();
+
+    expect(NotifyMessageProcessor).toHaveBeenCalledTimes(1);
+    expect(NotifyMessageProcessor).toHaveBeenCalledWith({
+      nhsNotifyClient: mockNotifyClient,
+      logger,
+    });
+  });
+
+  it('creates all dependencies in the correct order', async () => {
+    const callOrder: string[] = [];
+
+    (ParameterStoreCache as jest.Mock).mockImplementation(() => {
+      callOrder.push('ParameterStoreCache');
+      return mockParameterStore;
+    });
+
+    (loadConfig as jest.Mock).mockImplementation(() => {
+      callOrder.push('loadConfig');
+      return mockConfig;
+    });
+
+    (SenderManagement as jest.Mock).mockImplementation(() => {
+      callOrder.push('SenderManagement');
+      return mockSenderManagement;
+    });
+
+    (NotifyClient as jest.Mock).mockImplementation(() => {
+      callOrder.push('NotifyClient');
+      return mockNotifyClient;
+    });
+
+    (NotifyMessageProcessor as jest.Mock).mockImplementation(() => {
+      callOrder.push('NotifyMessageProcessor');
+      return mockNotifyMessageProcessor;
+    });
+
+    await createContainer();
+
+    expect(callOrder).toEqual([
+      'ParameterStoreCache',
+      'loadConfig',
+      'SenderManagement',
+      'NotifyClient',
+      'NotifyMessageProcessor',
+    ]);
+  });
+});
diff --git a/lambdas/core-notifier-lambda/src/__tests__/index.test.ts b/lambdas/core-notifier-lambda/src/__tests__/index.test.ts
@@ -0,0 +1,120 @@
+import type { SQSEvent, SQSRecord } from 'aws-lambda';
+import { handler } from 'index';
+import { createContainer } from 'container';
+import { createHandler as createSqsHandler } from 'apis/sqs-handler';
+import type { SqsHandlerDependencies } from 'apis/sqs-handler';
+import { mock } from 'jest-mock-extended';
+
+jest.mock('container');
+jest.mock('apis/sqs-handler');
+
+describe('Lambda handler', () => {
+  const mockContainer = mock<SqsHandlerDependencies>();
+  const mockSqsHandler = jest.fn();
+  const mockCreateContainer = jest.mocked(createContainer);
+  const mockCreateSqsHandler = jest.mocked(createSqsHandler);
+
+  const createSqsEvent = (recordCount: number): SQSEvent => ({
+    Records: Array.from(
+      { length: recordCount },
+      (_, i): SQSRecord => ({
+        messageId: `message-id-${i + 1}`,
+        receiptHandle: `receipt-handle-${i + 1}`,
+        body: JSON.stringify({
+          detail: {
+            id: `event-id-${i + 1}`,
+            source: 'test',
+            specversion: '1.0',
+            type: 'test.event',
+            time: '2025-12-16T10:00:00Z',
+            datacontenttype: 'application/json',
+            data: {},
+          },
+        }),
+        attributes: {
+          ApproximateReceiveCount: '1',
+          SentTimestamp: '1234567890',
+          SenderId: 'sender-id',
+          ApproximateFirstReceiveTimestamp: '1234567890',
+        },
+        messageAttributes: {},
+        md5OfBody: 'md5',
+        eventSource: 'aws:sqs',
+        eventSourceARN: 'arn:aws:sqs:region:account:queue',
+        awsRegion: 'eu-west-2',
+      }),
+    ),
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockCreateContainer.mockResolvedValue(mockContainer);
+    mockCreateSqsHandler.mockReturnValue(mockSqsHandler);
+    mockSqsHandler.mockResolvedValue({ batchItemFailures: [] });
+  });
+
+  it('creates a container', async () => {
+    const sqsEvent = createSqsEvent(1);
+
+    await handler(sqsEvent);
+
+    expect(mockCreateContainer).toHaveBeenCalledTimes(1);
+  });
+
+  it('creates an SQS handler with the container dependencies', async () => {
+    const sqsEvent = createSqsEvent(1);
+
+    await handler(sqsEvent);
+
+    expect(mockCreateSqsHandler).toHaveBeenCalledTimes(1);
+    expect(mockCreateSqsHandler).toHaveBeenCalledWith(mockContainer);
+  });
+
+  it('invokes the SQS handler with the event', async () => {
+    const sqsEvent = createSqsEvent(2);
+
+    await handler(sqsEvent);
+
+    expect(mockSqsHandler).toHaveBeenCalledTimes(1);
+    expect(mockSqsHandler).toHaveBeenCalledWith(sqsEvent);
+  });
+
+  it('returns the result from the SQS handler', async () => {
+    const sqsEvent = createSqsEvent(1);
+    const expectedResult = {
+      batchItemFailures: [{ itemIdentifier: 'message-id-1' }],
+    };
+    mockSqsHandler.mockResolvedValue(expectedResult);
+
+    const result = await handler(sqsEvent);
+
+    expect(result).toEqual(expectedResult);
+  });
+
+  it('handles multiple records in the event', async () => {
+    const sqsEvent = createSqsEvent(5);
+
+    await handler(sqsEvent);
+
+    expect(mockSqsHandler).toHaveBeenCalledWith(sqsEvent);
+    expect(sqsEvent.Records).toHaveLength(5);
+  });
+
+  it('propagates errors from createContainer', async () => {
+    const sqsEvent = createSqsEvent(1);
+    const error = new Error('Failed to create container');
+    mockCreateContainer.mockRejectedValue(error);
+
+    await expect(handler(sqsEvent)).rejects.toThrow(
+      'Failed to create container',
+    );
+  });
+
+  it('propagates errors from the SQS handler', async () => {
+    const sqsEvent = createSqsEvent(1);
+    const error = new Error('Handler failed');
+    mockSqsHandler.mockRejectedValue(error);
+
+    await expect(handler(sqsEvent)).rejects.toThrow('Handler failed');
+  });
+});
diff --git a/lambdas/core-notifier-lambda/src/__tests__/infra/config.test.ts b/lambdas/core-notifier-lambda/src/__tests__/infra/config.test.ts
@@ -0,0 +1,71 @@
+import { loadConfig, NotifySendMessageConfig } from 'infra/config';
+import { defaultConfigReader } from 'utils';
+
+jest.mock('utils', () => ({
+  defaultConfigReader: {
+    getValue: jest.fn(),
+  },
+}));
+
+describe('loadConfig', () => {
+  const mockGetValue = jest.mocked(defaultConfigReader.getValue);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('loads all configuration values from environment', () => {
+    const mockConfig = {
+      eventPublisherEventBusArn:
+        'arn:aws:events:eu-west-2:123456789012:event-bus/test-bus',
+      eventPublisherDlqUrl:
+        'https://sqs.eu-west-2.amazonaws.com/123456789012/test-dlq',
+      apimAccessTokenSsmParameterName: '/test/apim/access-token',
+      apimBaseUrl: 'https://api.test.nhs.uk',
+      environment: 'test',
+    };
+
+    mockGetValue
+      .mockReturnValueOnce(mockConfig.eventPublisherEventBusArn)
+      .mockReturnValueOnce(mockConfig.eventPublisherDlqUrl)
+      .mockReturnValueOnce(mockConfig.apimAccessTokenSsmParameterName)
+      .mockReturnValueOnce(mockConfig.apimBaseUrl)
+      .mockReturnValueOnce(mockConfig.environment);
+
+    const result = loadConfig();
+
+    expect(result).toEqual(mockConfig);
+    expect(mockGetValue).toHaveBeenCalledTimes(5);
+    expect(mockGetValue).toHaveBeenNthCalledWith(
+      1,
+      'EVENT_PUBLISHER_EVENT_BUS_ARN',
+    );
+    expect(mockGetValue).toHaveBeenNthCalledWith(
+      2,
+      'EVENT_PUBLISHER_DLQ_URL',
+    );
+    expect(mockGetValue).toHaveBeenNthCalledWith(
+      3,
+      'APIM_ACCESS_TOKEN_SSM_PARAMETER_NAME',
+    );
+    expect(mockGetValue).toHaveBeenNthCalledWith(4, 'APIM_BASE_URL');
+    expect(mockGetValue).toHaveBeenNthCalledWith(5, 'ENVIRONMENT');
+  });
+
+  it('returns config with correct types', () => {
+    mockGetValue
+      .mockReturnValueOnce('arn:test')
+      .mockReturnValueOnce('https://dlq')
+      .mockReturnValueOnce('/param')
+      .mockReturnValueOnce('https://api')
+      .mockReturnValueOnce('prod');
+
+    const result: NotifySendMessageConfig = loadConfig();
+
+    expect(typeof result.eventPublisherEventBusArn).toBe('string');
+    expect(typeof result.eventPublisherDlqUrl).toBe('string');
+    expect(typeof result.apimAccessTokenSsmParameterName).toBe('string');
+    expect(typeof result.apimBaseUrl).toBe('string');
+    expect(typeof result.environment).toBe('string');
+  });
+});
diff --git a/lambdas/core-notifier-lambda/src/container.ts b/lambdas/core-notifier-lambda/src/container.ts
diff --git a/utils/sender-management/README.md b/utils/sender-management/README.md
