feat: improving test speed and maintainability

.gitignore

@@ -118,3 +118,4 @@ application/CohortManager/src/Functions/*.json
 !**/playwright-tests/src/tests/e2e/testFiles/**/*.json
 
 
+tests/.vscode/settings.json

tests/playwright-tests/src/api/RetryCore/Retry.ts

@@ -0,0 +1,136 @@
+import { APIResponse, expect } from "@playwright/test";
+import { config } from "../../config/env";
+import { fetchApiResponse, findMatchingObject, validateFields } from "../apiHelper";
+import { ApiResponse } from "../core/types";
+
+const NHS_NUMBER_KEY = config.nhsNumberKey;
+const NHS_NUMBER_KEY_EXCEPTION_DEMOGRAPHIC = config.nhsNumberKeyExceptionDemographic;
+
+export async function validateApiResponse(validationJson: any, request: any): Promise<{ status: boolean; errorTrace?: any }> {
+    let status = false;
+    let endpoint = "";
+    let errorTrace: any = undefined;
+
+    try {
+        for (const apiValidation of validationJson) {
+            endpoint = apiValidation.validations.apiEndpoint;
+            var response = await pollAPI(endpoint, apiValidation, request);
+                console.info(response);
+                switch(response.status()) {
+                    case 204:
+                        console.info("now handling no content response");
+                        const expectedCount = apiValidation.validations.expectedCount;
+                        status = await HandleNoContentResponse(expectedCount, apiValidation, endpoint);
+                        break;
+                    case 200: 
+                        console.info("now handling OK response");
+                        status = await handleOKResponse(apiValidation, endpoint, response);
+                    default: 
+                        console.error("there was an error when handling response from ");
+                        break;
+                }
+
+        }
+    } 
+    catch (error) {
+        const errorMsg = `Endpoint: ${endpoint}, Error: ${error instanceof Error ? error.stack || error.message : error}`;
+        errorTrace = errorMsg;
+        console.error(errorMsg);
+    }
+    return { status, errorTrace };
+}
+
+async function handleOKResponse(apiValidation: any, endpoint: string, response: any ) : Promise<boolean>{
+    const responseBody = await response.json();
+    expect(Array.isArray(responseBody)).toBeTruthy();
+
+    const { matchingObject, nhsNumber, matchingObjects } = await findMatchingObject(endpoint, responseBody, apiValidation);
+
+    console.info(`Validating fields using 🅰️\t🅿️\tℹ️\t ${endpoint}`);
+    console.info(`From Response ${JSON.stringify(matchingObject, null, 2)}`);
+    return await validateFields(apiValidation, matchingObject, nhsNumber, matchingObjects);
+}
+
+
+async function HandleNoContentResponse(expectedCount: number, apiValidation: any, endpoint: string): Promise<boolean> {
+    if (expectedCount !== undefined && Number(expectedCount) === 0) {
+        console.info(`✅ Status 204: Expected 0 records for endpoint ${endpoint}`);
+
+        // Get NHS number for validation
+        const nhsNumber = apiValidation.validations.NHSNumber ||
+                        apiValidation.validations.NhsNumber ||
+                        apiValidation.validations[NHS_NUMBER_KEY] ||
+                        apiValidation.validations[NHS_NUMBER_KEY_EXCEPTION_DEMOGRAPHIC];
+
+        console.info(`Validating fields using 🅰️\t🅿️\tℹ️\t ${endpoint}`);
+        console.info(`From Response: null (204 No Content - 0 records as expected)`);
+        return await validateFields(apiValidation, null, nhsNumber, []);
+    } else {
+        // 204 is unexpected, throw error to trigger retry
+        throw new Error(`Status 204: No data found in the table using endpoint ${endpoint}`);
+    }
+}
+
+
+async function pollAPI(endpoint: string, apiValidation: any, request: any): Promise<APIResponse> {
+    let apiResponse: APIResponse | null = null;
+    let i = 0;
+
+    let maxNumberOfRetries = config.maxNumberOfRetries;
+    let maxTimeBetweenRequests = config.maxTimeBetweenRequests;
+
+    console.info(`now trying request for ${maxNumberOfRetries} retries`);
+       while (i < maxNumberOfRetries) {
+            try {
+                apiResponse =  await fetchApiResponse(endpoint, request);
+                if (apiResponse.status() == 200) {
+                    console.info("200 response found") 
+                    break;
+                }
+            }
+            catch(exception) {
+                console.error("Error reading request body:", exception);
+            }
+            i++;
+
+            console.info(`http response  completed ${i}/${maxNumberOfRetries} of number of reties`);
+            await new Promise(res => setTimeout(res, maxTimeBetweenRequests));
+        }
+
+    if (!apiResponse) {
+        throw new Error("apiResponse was never assigned");
+    }
+
+    return apiResponse;
+}
+
+
+export async function pollApiForOKResponse(httpRequest: () => Promise<ApiResponse>): Promise<ApiResponse>{
+    let apiResponse: ApiResponse | null = null;
+    let i = 0;
+    let maxNumberOfRetries = config.maxNumberOfRetries;
+    let maxTimeBetweenRequests = config.maxTimeBetweenRequests;
+
+    console.info(`now trying request for ${maxNumberOfRetries} retries`);
+    while (i < maxNumberOfRetries) {
+        try {
+            apiResponse =  await httpRequest();
+            if (apiResponse.status == 200) {
+                console.info("200 response found") 
+                break;
+            }
+        }
+        catch(exception) {
+            console.error("Error reading request body:", exception);
+        }
+        i++;
+
+        console.info(`http response  completed ${i}/${maxNumberOfRetries} of number of reties`);
+        await new Promise(res => setTimeout(res, maxTimeBetweenRequests));
+    }
+
+    if (!apiResponse) {
+        throw new Error("apiResponse was never assigned");
+    }
+    return apiResponse;
+};