Add tf and tests

Author: francisco-videira-nhs

infrastructure/terraform/components/api/module_lambda_get_letter_data.tf

@@ -69,4 +69,16 @@ data "aws_iam_policy_document" "get_letter_data_lambda" {
       "${aws_dynamodb_table.letters.arn}/index/supplierStatus-index"
     ]
   }
+
+  statement {
+    sid       = "S3GetObjectForPresign"
+    actions   = ["s3:GetObject"]
+    resources = ["${module.s3bucket_test_letters.arn}/*"]
+  }
+
+  statement {
+    sid       = "KmsForS3Objects"
+    actions   = ["kms:Decrypt", "kms:Encrypt", "kms:GenerateDataKey"]
+    resources = [module.s3bucket_test_letters.kms_key_arn]
+  }
 }

lambdas/api-handler/src/handlers/__tests__/get-letter-data.test.ts

@@ -0,0 +1,97 @@
+import type { APIGatewayProxyResult, Context } from 'aws-lambda';
+import { mockDeep } from 'jest-mock-extended';
+import { makeApiGwEvent } from './utils/test-utils';
+import * as letterService from '../../services/letter-operations';
+import { mapErrorToResponse } from '../../mappers/error-mapper';
+import { ValidationError } from '../../errors';
+import * as errors from '../../contracts/errors';
+import { getLetterData } from '../get-letter-data';
+
+jest.mock('../../mappers/error-mapper');
+const mockedMapErrorToResponse = jest.mocked(mapErrorToResponse);
+const expectedErrorResponse: APIGatewayProxyResult = {
+  statusCode: 400,
+  body: 'Error'
+};
+mockedMapErrorToResponse.mockReturnValue(expectedErrorResponse);
+
+jest.mock('../../services/letter-operations');
+
+jest.mock('../../config/lambda-config', () => ({
+  lambdaConfig: {
+    SUPPLIER_ID_HEADER: 'nhsd-supplier-id',
+    APIM_CORRELATION_HEADER: 'nhsd-correlation-id'
+  }
+}));
+
+describe('API Lambda handler', () => {
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetModules();
+  });
+
+  it('returns 302 Found with a pre signed url', async () => {
+
+    const mockedGetLetterDataUrlService = letterService.getLetterDataUrl as jest.Mock;
+    mockedGetLetterDataUrlService.mockResolvedValue('https://somePreSignedUrl.com');
+
+    const event = makeApiGwEvent({path: '/letters/letter1/data',
+      headers: {'nhsd-supplier-id': 'supplier1', 'nhsd-correlation-id': 'correlationId'},
+      pathParameters: {id: 'id1'}
+    });
+    const context = mockDeep<Context>();
+    const callback = jest.fn();
+
+    const result = await getLetterData(event, context, callback);
+
+    expect(result).toEqual({
+      statusCode: 302,
+      Location: 'https://somePreSignedUrl.com',
+      body: ''
+    });
+  });
+
+  it('returns 400 for missing supplier ID (empty headers)', async () => {
+    const event = makeApiGwEvent({ path: '/letters/letter1/data', headers: {},
+      pathParameters: {id: 'id1'}
+    });
+    const context = mockDeep<Context>();
+    const callback = jest.fn();
+
+    const result = await getLetterData(event, context, callback);
+
+    expect(mockedMapErrorToResponse).toHaveBeenCalledWith(new Error('The request headers are empty'), undefined);
+    expect(result).toEqual(expectedErrorResponse);
+  });
+
+  it('returns 500 if correlation id not provided in request', async () => {
+    const event = makeApiGwEvent({
+      path: '/letters/letter1/data',
+      queryStringParameters: { limit: '2000' },
+      headers: {'nhsd-supplier-id': 'supplier1'},
+      pathParameters: {id: 'id1'}
+    });
+    const context = mockDeep<Context>();
+    const callback = jest.fn();
+
+    const result = await getLetterData(event, context, callback);
+
+    expect(mockedMapErrorToResponse).toHaveBeenCalledWith(new Error("The request headers don't contain the APIM correlation id"), undefined);
+    expect(result).toEqual(expectedErrorResponse);
+  });
+
+  it('returns error response when path parameter letterId is not found', async () => {
+    const event = makeApiGwEvent({
+      path: '/letters/',
+      headers: {'nhsd-supplier-id': 'supplier1', 'nhsd-correlation-id': 'correlationId'}
+    });
+    const context = mockDeep<Context>();
+    const callback = jest.fn();
+
+    const result = await getLetterData(event, context, callback);
+
+    expect(mockedMapErrorToResponse).toHaveBeenCalledWith(new ValidationError(errors.ApiErrorDetail.InvalidRequestMissingLetterIdPathParameter), 'correlationId');
+    expect(result).toEqual(expectedErrorResponse);
+  });
+});

lambdas/api-handler/src/handlers/get-letter-data.ts

@@ -22,7 +22,7 @@ export const getLetterData: APIGatewayProxyHandler = async (event) => {
 
     return {
       statusCode: 302,
-      Location: getLetterDataUrl(supplierId, letterId, letterRepo),
+      Location: await getLetterDataUrl(supplierId, letterId, letterRepo),
       body: ''
     };
   }

lambdas/api-handler/src/services/__tests__/letter-operations.test.ts

@@ -1,7 +1,22 @@
 import { Letter } from '../../../../../internal/datastore/src';
-import { LetterDto, LetterStatus } from '../../contracts/letters';
-import { getLettersForSupplier, patchLetterStatus } from '../letter-operations';
+import { LetterDto } from '../../contracts/letters';
+import { getLetterDataUrl, getLettersForSupplier, patchLetterStatus } from '../letter-operations';
 
+jest.mock('@aws-sdk/s3-request-presigner', () => ({
+  getSignedUrl: jest.fn(),
+}));
+
+jest.mock('@aws-sdk/client-s3', () => {
+  return {
+    S3Client: jest.fn().mockImplementation(() => ({})),
+    GetObjectCommand: jest.fn().mockImplementation((input) => ({ input })),
+  };
+});
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
+
+const mockedGetSignedUrl = getSignedUrl as jest.MockedFunction<typeof getSignedUrl>;
+const MockedGetObjectCommand = GetObjectCommand as unknown as jest.Mock;
 
 function makeLetter(id: string, status: Letter['status']) : Letter {
   return {
@@ -10,7 +25,7 @@ function makeLetter(id: string, status: Letter['status']) : Letter {
       supplierId: 'supplier1',
       specificationId: 'spec123',
       groupId: 'group123',
-      url: 'https://example.com/letter/abc123',
+      url: `s3://letterDataBucket/${id}.pdf`,
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
       supplierStatus: `supplier1#${status}`,
@@ -104,3 +119,43 @@ describe('patchLetterStatus function', () => {
     await expect(patchLetterStatus(updatedLetterDto, 'letter1', mockRepo as any)).rejects.toThrow("unexpected error");
   });
 });
+
+describe('getLetterDataUrl function', () => {
+
+  const updatedLetter = makeLetter("letter1", "REJECTED");
+
+  it('should return pre signed url successfully', async () => {
+    const mockRepo = {
+      getLetterById: jest.fn().mockResolvedValue(updatedLetter)
+    };
+
+    mockedGetSignedUrl.mockResolvedValue('http://somePreSignedUrl.com');
+
+    const result = await getLetterDataUrl('supplier1', 'letter1', mockRepo as any);
+
+    expect(mockedGetSignedUrl).toHaveBeenCalled();
+    expect(MockedGetObjectCommand).toHaveBeenCalledWith({
+        Bucket: 'letterDataBucket',
+        Key: 'letter1.pdf'
+    });
+
+    expect(result).toEqual('http://somePreSignedUrl.com');
+  });
+
+  it('should throw notFoundError when letter does not exist', async () => {
+    const mockRepo = {
+      getLetterById: jest.fn().mockRejectedValue(new Error('Letter with id l1 not found for supplier s1'))
+    };
+
+    await expect(getLetterDataUrl('supplier1', 'letter42', mockRepo as any)).rejects.toThrow("No resource found with that ID");
+  });
+
+  it('should throw unexpected error', async () => {
+
+    const mockRepo = {
+      getLetterById: jest.fn().mockRejectedValue(new Error('unexpected error'))
+    };
+
+    await expect(getLetterDataUrl('supplier1', 'letter1', mockRepo as any)).rejects.toThrow("unexpected error");
+  });
+});

lambdas/api-handler/src/services/letter-operations.ts

@@ -3,8 +3,8 @@ import { NotFoundError, ValidationError } from '../errors';
 import { LetterDto, PatchLetterResponse } from '../contracts/letters';
 import { mapToPatchLetterResponse } from '../mappers/letter-mapper';
 import { ApiErrorDetail } from '../contracts/errors';
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
 
 
 export const getLettersForSupplier = async (supplierId: string, status: string, limit: number, letterRepo: LetterRepository): Promise<LetterBase[]> => {
@@ -38,14 +38,13 @@ export const getLetterDataUrl = async (supplierId: string, letterId: string, let
 
   try {
     letter = await letterRepo.getLetterById(supplierId, letterId);
+    return await getPresignedUrl(letter.url);
   } catch (error) {
     if (error instanceof Error && /^Letter with id \w+ not found for supplier \w+$/.test(error.message)) {
       throw new NotFoundError(ApiErrorDetail.NotFoundLetterId);
     }
     throw error;
   }
-
-  return getPresignedUrl(letter.url);
 }
 
 async function getPresignedUrl(s3Uri: string) {