add component tests for get mi

Author: RossFaulds171

tests/component-tests/apiGateway-tests/create-mi.spec.ts

@@ -25,7 +25,7 @@ test.beforeAll(async () => {
   baseUrl = await getRestApiGatewayBaseUrl();
 });
 
-test.describe("API Gateway Tests to Verify Mi Endpoint", () => {
+test.describe("API Gateway Tests to Verify create MI Endpoint", () => {
   test(`Post /mi returns 200 when a valid request is passed`, async ({
     request,
   }) => {

tests/component-tests/apiGateway-tests/get-mi.spec.ts

@@ -0,0 +1,94 @@
+import { expect, test } from "@playwright/test";
+import {
+  createHeaderWithNoCorrelationId,
+  createInvalidRequestHeaders,
+  createValidRequestHeaders,
+} from "../../constants/request-headers";
+import getRestApiGatewayBaseUrl from "../../helpers/aws-gateway-helper";
+import {
+  getMI,
+  isErrorResponse,
+  isGetMIResponse,
+} from "../../helpers/generate-fetch-test-data";
+import { miValidRequest } from "./testCases/create-mi";
+import { MI_ENDPOINT } from "tests/constants/api-constants";
+
+let baseUrl: string;
+let insertedId: string;
+let insertedTimestamp: string;
+
+test.beforeAll(async ( { request }) => {
+    baseUrl = await getRestApiGatewayBaseUrl();
+    const headers = createValidRequestHeaders();
+    const body = miValidRequest();
+
+    const response = await request.post(`${baseUrl}/${MI_ENDPOINT}`, {
+        headers,
+        data: body,
+    });
+
+    const miResponseBody = await response.json();
+    insertedId = miResponseBody.data.id;
+    insertedTimestamp = miResponseBody.data.attributes.timestamp;
+});
+
+test.describe("API Gateway Tests To Get MI data", () => {
+  test("GET /mi should return 200 and MI data for specified id", async ({ request }) => {
+    const headers = createValidRequestHeaders();
+    const { responseBody, statusCode } = await getMI(
+      insertedId,
+      request,
+      baseUrl,
+      headers,
+    );
+
+    expect(statusCode).toBe(200);
+    if (!isGetMIResponse(responseBody)) {
+      throw new Error("Expected GetMIResponse body for 200 status");
+    }
+    expect(responseBody.data.attributes).toMatchObject({
+      groupId: "group123",
+      lineItem: "envelope-business-standard",
+      quantity: 10,
+      specificationId: "Test-Spec-Id",
+      stockRemaining: 100,
+      timestamp: insertedTimestamp,
+    });
+    expect(responseBody.data.type).toBe("ManagementInformation");
+});
+
+  test("GET /mi with invalid authentication should return 403", async ({
+    request,
+  }) => {
+    const headers = createInvalidRequestHeaders();
+    const { responseBody, statusCode } = await getMI(
+      insertedId,
+      request,
+      baseUrl,
+      headers,
+    );
+    expect(statusCode).toBe(403);
+    expect(responseBody).toMatchObject({
+      Message:
+        "User is not authorized to access this resource with an explicit deny in an identity-based policy",
+    });
+  });
+
+  test("GET /mi with empty correlationId should return 500", async ({
+    request,
+  }) => {
+    const headers = createHeaderWithNoCorrelationId();
+    const { responseBody, statusCode } = await getMI(
+      insertedId,
+      request,
+      baseUrl,
+      headers,
+    );
+    expect(statusCode).toBe(500);
+    if (!isErrorResponse(responseBody)) {
+      throw new Error("Expected ErrorResponse body for 500 status");
+    }
+    expect(responseBody.errors[0].code).toBe("NOTIFY_INTERNAL_SERVER_ERROR");
+    expect(responseBody.errors[0].detail).toBe("Unexpected error");
+  });
+});

tests/helpers/generate-fetch-test-data.ts

@@ -12,6 +12,7 @@ import {
   GET_LETTERS_MAX_RETRIES,
   LETTERQUEUE_TABLENAME,
   LETTERSTABLENAME,
+  MI_ENDPOINT,
   SUPPLIERTABLENAME,
   SUPPLIER_LETTERS,
   VISIBILITY_TIMEOUT_SECONDS,
@@ -23,6 +24,7 @@ import {
   GetLettersResponse,
   GetLettersResponseSchema,
 } from "../../lambdas/api-handler/src/contracts/letters";
+import { GetMIResponse, GetMIResponseSchema } from "../../lambdas/api-handler/src/contracts/mi";
 import { ErrorResponse } from "../../lambdas/api-handler/src/contracts/errors";
 
 const ddb = new DynamoDBClient({});
@@ -117,12 +119,28 @@ type FetchLettersWithRetryResult = {
   responseBody: GetLettersResponseBody;
 };
 
+type GetMIResponseBody =
+  | GetMIResponse
+  | ErrorResponse
+  | Record<string, unknown>;
+
+type FetchMiResult = {
+  statusCode: number;
+  responseBody: GetMIResponseBody;
+};
+
 export function isGetLettersResponse(
   responseBody: GetLettersResponseBody,
 ): responseBody is GetLettersResponse {
   return GetLettersResponseSchema.safeParse(responseBody).success;
 }
 
+export function isGetMIResponse(
+  responseBody: GetMIResponseBody,
+): responseBody is GetMIResponse {
+  return GetMIResponseSchema.safeParse(responseBody).success;
+}
+
 export function isErrorResponse(
   responseBody: GetLettersResponseBody,
 ): responseBody is ErrorResponse {
@@ -148,6 +166,22 @@ function parseGetLettersResponseBody(
   return parsedBody as Record<string, unknown>;
 }
 
+function parseGetMIResponseBody(
+  parsedBody: unknown,
+): GetMIResponseBody {
+  const parsedGetMIResponse =
+    GetMIResponseSchema.safeParse(parsedBody);
+  if (parsedGetMIResponse.success) {
+    return parsedGetMIResponse.data;
+  }
+
+  if (isErrorResponse(parsedBody as GetMIResponseBody)) {
+    return parsedBody as ErrorResponse;
+  }
+
+  return parsedBody as Record<string, unknown>;
+}
+
 function shouldRetryGetLettersRequest(
   waitForVisibilityTimeout: boolean,
   statusCode: number,
@@ -207,6 +241,31 @@ export async function getLettersWithRetry(
   throw new Error("Unexpectedly exhausted GET /letters retries");
 }
 
+export async function getMI(
+  miId:    string,
+  request: APIRequestContext,
+  baseUrl: string,
+  headers: Record<string, string>,
+): Promise<FetchMiResult> { // change retrun type to FetchMiResult and create new type if the response body shape is different to the get letters response, currently reusing as the response shapes are the same and to avoid code duplication
+
+  const executeGetMiRequest =
+    () =>
+          request.get(`${baseUrl}/${MI_ENDPOINT}`, {
+            headers,
+            params: {
+              miId,
+            },
+          });
+
+  const response = await executeGetMiRequest();
+  const statusCode = response.status();
+
+  const parsedBody = (await response.json()) as unknown;
+  const responseBody = parseGetMIResponseBody(parsedBody);
+  return { statusCode, responseBody };
+}
+
+
 export async function waitForLetterStatus(
   supplierId: string,
   id: string,