CCM 12179: Add Component Tests

Makefile

@@ -98,6 +98,8 @@ config:: _install-dependencies version # Configure development environment (main
 	npm install
 	(cd docs && make install && cd ..)
 
+test-component:
+	(cd tests && npm install && npm run test:component)
 
 version:
 	rm -f .version

package.json

@@ -1,12 +1,18 @@
 {
   "dependencies": {
+    "@aws-sdk/client-api-gateway": "^3.906.0",
+    "@playwright/test": "^1.55.1",
+    "ajv": "^8.17.1",
+    "js-yaml": "^4.1.0",
+    "openapi-response-validator": "^12.1.3",
     "serve": "^14.2.4"
   },
   "devDependencies": {
     "@openapitools/openapi-generator-cli": "^2.21.4",
     "@redocly/cli": "^1.34.5",
     "@tsconfig/node22": "^22.0.2",
     "@types/jest": "^29.5.14",
+    "@types/js-yaml": "^4.0.9",
     "@typescript-eslint/eslint-plugin": "^8.27.0",
     "@typescript-eslint/parser": "^8.27.0",
     "esbuild": "^0.24.0",

tests/.gitignore

@@ -7,3 +7,5 @@ node_modules/
 /playwright/.cache/
 /allure-results
 /target
+/playwright/.auth/
+/allure-report

tests/component-tests/apiGateway-tests/getLetters.spec.ts

@@ -0,0 +1,94 @@
+import { test, expect } from '@playwright/test';
+import { SUPPLIER_LETTERS } from '../../constants/api_constants';
+import { createHeaderWithNoCorrelationId, createInvalidRequestHeaders, createValidRequestHeaders } from '../../constants/request_headers';
+import { getRestApiGatewayBaseUrl } from '../../helpers/awsGatewayHelper';
+import { validateApiResponse } from '../../helpers/validateJsonSchema';
+import { link } from 'fs';
+
+let baseUrl: string;
+
+test.beforeAll(async () => {
+  baseUrl = await getRestApiGatewayBaseUrl();
+});
+
+test.describe('API Gateway Tests To Get List Of Pending Letters', () =>
+{
+  test('GET /letters should return 200 and list items', async ({ request }) =>
+  {
+    const header = createValidRequestHeaders();
+    const response = await request.get(`${baseUrl}/${SUPPLIER_LETTERS}` ,{
+      headers: header,
+      params: {
+        limit:'2'},
+      },
+    );
+
+    expect(response.status()).toBe(200);
+    const responseBody = await response.json();
+    expect(responseBody.data.length.toString()).toEqual('2');
+
+    const validationResult = validateApiResponse("get", "/letters", response.status(), responseBody);
+    if (validationResult) {
+      console.error("API response validation failed:", validationResult);
+    }
+    expect(validationResult).toBeUndefined();
+  });
+
+  test('GET /letters with invalid authentication should return 403', async ({ request }) => {
+    const header = createInvalidRequestHeaders();
+    const response = await request.get(`${baseUrl}/${SUPPLIER_LETTERS}` ,{
+      headers: header,
+      params:{
+        limit:'2'
+        },
+      },
+    );
+    expect(response.status()).toBe(403);
+    const responseBody = await response.json();
+    expect(responseBody).toMatchObject({
+      Message : 'User is not authorized to access this resource with an explicit deny in an identity-based policy' }
+    );
+  });
+
+  test('GET /letters with empty correlationId should return 500', async ({ request }) => {
+    const header = createHeaderWithNoCorrelationId();
+    const response = await request.get(`${baseUrl}/${SUPPLIER_LETTERS}` ,{
+      headers: header,
+      params:{
+        limit:'2'
+        },
+      },
+    );
+    expect(response.status()).toBe(500);
+    const responseBody = await response.json();
+    expect(responseBody.errors[0].code).toBe('NOTIFY_INTERNAL_SERVER_ERROR');
+    expect(responseBody.errors[0].detail).toBe("The request headers don't contain the APIM correlation id");
+
+  });
+
+  test('GET /letters with invalid query param return 400', async ({ request }) => {
+    const header = createValidRequestHeaders();
+    const response = await request.get(`${baseUrl}/${SUPPLIER_LETTERS}` ,{
+        headers: header,
+        params:{
+          limit:'?'
+        },
+      });
+    expect(response.status()).toBe(400);
+    const responseBody = await response.json();
+    expect(responseBody).toMatchObject({
+      errors: [
+        {
+          id: '12345',
+          code: 'NOTIFY_INVALID_REQUEST',
+          links: {
+              about: 'https://digital.nhs.uk/developer/api-catalogue/nhs-notify-supplier'
+            },
+          status: '400',
+          title: 'Invalid request',
+          detail: 'The limit parameter is not a number'
+        }
+      ]
+    });
+  });
+});

tests/component-tests/apiGateway-tests/testCases/UpdateLetterStatus.ts

@@ -0,0 +1,114 @@
+
+import { RequestHeaders } from '../../../constants/request_headers';
+import { supplierId } from '../../../constants/api_constants';
+import { ErrorMessageBody } from '../../../helpers/commonTypes';
+
+export type PatchMessageRequestBody = {
+  data: {
+    type: string;
+    id: string;
+    attributes: {
+      reasonCode?: string | number;
+      reasonText?: string;
+      status: string;
+    };
+  };
+};
+
+export type PatchMessageResponseBody = {
+  data: {
+    type: string;
+    id: string;
+    attributes: {
+      reasonCode?: number;
+      reasonText?: string;
+      status: string;
+      specificationId:string;
+      groupId?:string;
+    };
+  };
+};
+
+export function patchRequestHeaders(): RequestHeaders {
+  let requestHeaders: RequestHeaders;
+    requestHeaders = {
+        headerauth1: process.env.HEADERAUTH || '',
+        'NHSD-Supplier-ID': supplierId,
+        'NHSD-Correlation-ID': '12344',
+        'X-Request-ID': 'requestId1'
+    };
+  return requestHeaders;
+};
+
+
+export function patchValidRequestBody (id: string, status: string) : PatchMessageRequestBody{
+  let requestBody: PatchMessageRequestBody;
+
+  requestBody = {
+    data: {
+       attributes: {
+          status: status,
+      },
+      type: 'Letter',
+      id: id
+    }
+
+  };
+  return requestBody;
+}
+
+export function patchFailureRequestBody (id: string, status: string) : PatchMessageRequestBody{
+  let requestBody: PatchMessageRequestBody;
+
+  requestBody = {
+    data: {
+        attributes: {
+          status: status,
+          reasonCode: 123,
+          reasonText: 'Test Reason'
+      },
+      type: 'Letter',
+      id: id
+    }
+
+  };
+  return requestBody;
+}
+
+export function patch400ErrorResponseBody () : ErrorMessageBody{
+  let responseBody: ErrorMessageBody;
+  responseBody = {
+    errors: [
+      {
+        id : '12344',
+        code : 'NOTIFY_INVALID_REQUEST',
+        "links": {
+                "about": "https://digital.nhs.uk/developer/api-catalogue/nhs-notify-supplier"
+            },
+            "status": "400",
+            "title": "Invalid request",
+            "detail": "The request body is invalid"
+      }
+    ]
+  };
+  return responseBody;
+};
+
+export function patch500ErrorResponseBody (id: string) : ErrorMessageBody{
+  let responseBody: ErrorMessageBody;
+  responseBody = {
+    errors: [
+        {
+            id: "12344",
+            code: "NOTIFY_INTERNAL_SERVER_ERROR",
+            links: {
+                "about": "https://digital.nhs.uk/developer/api-catalogue/nhs-notify-supplier"
+            },
+            status: "500",
+            title: "Internal server error",
+            detail: `Letter with id ${id} not found for supplier ${supplierId}`
+        }
+    ]
+  };
+  return responseBody;
+}

tests/component-tests/apiGateway-tests/updateLetterStatus.spec.ts

@@ -0,0 +1,131 @@
+import { test, expect } from '@playwright/test';
+import { SUPPLIER_LETTERS, supplierId } from '../../constants/api_constants';
+import { getRestApiGatewayBaseUrl } from '../../helpers/awsGatewayHelper';
+import { patch400ErrorResponseBody, patch500ErrorResponseBody, patchFailureRequestBody, patchRequestHeaders, patchValidRequestBody } from './testCases/UpdateLetterStatus';
+import { createTestData, deleteLettersBySupplier, getLettersBySupplier } from '../../helpers/generate_fetch_testData';
+import { randomUUID } from 'crypto';
+import { createInvalidRequestHeaders } from '../../constants/request_headers';
+
+let baseUrl: string;
+
+test.beforeAll(async () => {
+  baseUrl = await getRestApiGatewayBaseUrl();
+});
+
+test.describe('API Gateway Tests to Verify Patch Status Endpoint', () => {
+    test(`Patch /letters returns 200 and status is updated to ACCEPTED`, async ({ request }) => {
+
+      await createTestData(supplierId);
+      const letters = await getLettersBySupplier(supplierId, 'PENDING', 1);
+
+      if (!letters?.length) {
+        test.fail(true, `No PENDING letters found for supplier ${supplierId}`);
+        return;
+      }
+      const letter = letters[0];
+      const headers = patchRequestHeaders();
+      const body = patchValidRequestBody(letter.id, 'ACCEPTED');
+
+      const response = await request.patch(`${baseUrl}/${SUPPLIER_LETTERS}/${letter.id}`, {
+          headers: headers,
+          data: body
+      });
+
+    const res = await response.json();
+    expect(response.status()).toBe(200);
+    expect(res).toMatchObject({
+      data:{
+        attributes: {
+            status: 'ACCEPTED',
+            specificationId: letter.specificationId,
+            groupId: letter.groupId,
+        },
+        id: letter.id,
+        type: 'Letter'
+      }
+    });
+
+    await deleteLettersBySupplier(letter.id);
+  });
+
+  test(`Patch /letters returns 200 and status is updated to REJECTED`, async ({ request }) => {
+
+      await createTestData(supplierId);
+      const letters = await getLettersBySupplier(supplierId, 'PENDING', 1);
+
+      if (!letters?.length) {
+        test.fail(true, `No PENDING letters found for supplier ${supplierId}`);
+        return;
+      }
+      const letter = letters[0];
+      const headers = patchRequestHeaders();
+      const body = patchFailureRequestBody(letter.id, 'REJECTED');
+
+      const response = await request.patch(`${baseUrl}/${SUPPLIER_LETTERS}/${letter.id}`, {
+          headers: headers,
+          data: body
+      });
+
+    const res = await response.json();
+    expect(response.status()).toBe(200);
+    expect(res).toMatchObject({
+      data:{
+        attributes: {
+            status: 'REJECTED',
+            specificationId: letter.specificationId,
+            groupId: letter.groupId,
+        },
+        id: letter.id,
+        type: 'Letter'
+      }
+    });
+
+    await deleteLettersBySupplier(letter.id);
+  });
+
+  test(`Patch /letters returns 400 if request Body is invalid`, async ({ request }) => {
+
+      const id = randomUUID()
+      const headers = patchRequestHeaders();
+      const body = patchValidRequestBody(id, '');
+
+      const response = await request.patch(`${baseUrl}/${SUPPLIER_LETTERS}/${id}`, {
+          headers: headers,
+          data: body
+      });
+
+    const res = await response.json();
+
+    expect(response.status()).toBe(400);
+    expect(res).toMatchObject(patch400ErrorResponseBody());
+  });
+
+    test(`Patch /letters returns 500 if Id doesn't exist for SupplierId`, async ({ request }) => {
+        const headers = patchRequestHeaders();
+        const id = randomUUID()
+        const body = patchValidRequestBody(id, 'PENDING');
+
+        const response = await request.patch(`${baseUrl}/${SUPPLIER_LETTERS}/${id}`, {
+        headers: headers,
+        data: body
+        });
+
+      const res = await response.json();
+      expect(response.status()).toBe(500);
+      expect(res).toMatchObject(patch500ErrorResponseBody(id));
+    });
+
+    test(`Patch /letters returns 403 for invalid headers`, async ({ request }) => {
+        const headers = await createInvalidRequestHeaders();
+        const id = randomUUID()
+        const body = patchValidRequestBody(id, 'PENDING');
+
+        const response = await request.patch(`${baseUrl}/${SUPPLIER_LETTERS}/${id}`, {
+            headers: headers,
+            data: body
+        });
+
+      const res = await response.json();
+      expect(response.status()).toBe(403);
+    });
+});