Merge branch 'main' into feat/FN-3611

Author: Zain Kassam

dtfs-central-api/api-tests/v1/utilisation-reports/fee-record-corrections/put-fee-record-correction-transient-form-data.api-test.ts

@@ -24,7 +24,7 @@ import { CustomErrorResponse } from '../../../helpers/custom-error-response';
 console.error = jest.fn();
 
 interface PutFeeRecordCorrectionTransientFormDataResponse extends Response {
-  body: RecordCorrectionFormValueValidationErrors | string | undefined;
+  body: { validationErrors?: RecordCorrectionFormValueValidationErrors } | string;
 }
 
 const BASE_URL = '/v1/bank/:bankId/fee-record-corrections/:correctionId/transient-form-data';
@@ -166,30 +166,40 @@ describe(`PUT ${BASE_URL}`, () => {
         .to(replaceUrlParameterPlaceholders(BASE_URL, { bankId, correctionId }))) as PutFeeRecordCorrectionTransientFormDataResponse;
 
       // Assert
-      const expectedBody: RecordCorrectionFormValueValidationErrors = {
+      const validationErrors: RecordCorrectionFormValueValidationErrors = {
         facilityIdErrorMessage: 'You must enter a facility ID between 8 and 10 digits using the numbers 0-9 only',
         reportedCurrencyErrorMessage: 'You must select a currency',
         reportedFeeErrorMessage: 'You must enter the reported fee in a valid format',
         utilisationErrorMessage: 'You must enter the utilisation in a valid format',
         additionalCommentsErrorMessage: 'You must enter a comment',
       };
 
+      const expectedBody = {
+        validationErrors,
+      };
+
       expect(status).toEqual(HttpStatusCode.Ok);
 
       expect(body).toEqual(expectedBody);
     });
   });
 
   describe('when there are no validation errors', () => {
-    it(`should return '${HttpStatusCode.Ok}' if the correction exists`, async () => {
+    it(`should return '${HttpStatusCode.Ok}' if the correction exists with an empty response body`, async () => {
       // Arrange
       const requestBody = aValidRequestBody();
 
       // Act
-      const { status } = await testApi.put(requestBody).to(replaceUrlParameterPlaceholders(BASE_URL, { bankId, correctionId }));
+      const { status, body } = (await testApi
+        .put(requestBody)
+        .to(replaceUrlParameterPlaceholders(BASE_URL, { bankId, correctionId }))) as PutFeeRecordCorrectionTransientFormDataResponse;
 
       // Assert
+      const expectedBody = {};
+
       expect(status).toEqual(HttpStatusCode.Ok);
+
+      expect(body).toEqual(expectedBody);
     });
   });
 });

dtfs-central-api/src/v1/controllers/utilisation-report-service/fee-record-correction/put-fee-record-correction-transient-form-data.controller/index.test.ts

@@ -122,7 +122,11 @@ describe('put-fee-record-correction-transient-form-data.controller', () => {
           additionalCommentsErrorMessage: 'You must enter a comment',
         };
 
-        expect(res._getData()).toEqual(expectedValidationErrors);
+        const expectedResponse = {
+          validationErrors: expectedValidationErrors,
+        };
+
+        expect(res._getData()).toEqual(expectedResponse);
       });
 
       it('should not call the correction repo to save the form data', async () => {
@@ -168,6 +172,21 @@ describe('put-fee-record-correction-transient-form-data.controller', () => {
         expect(mockSaveTransientFormData).toHaveBeenCalledTimes(1);
         expect(mockSaveTransientFormData).toHaveBeenCalledWith(expectedTransientFormDataEntity);
       });
+
+      it(`should respond with no validation errors in the response body`, async () => {
+        // Arrange
+        const correctionReasons = [RECORD_CORRECTION_REASON.OTHER];
+
+        mockFindCorrection.mockResolvedValue(FeeRecordCorrectionEntityMockBuilder.forIsCompleted(false).withReasons(correctionReasons).build());
+
+        req.body.formData = { additionalComments };
+
+        // Act
+        await putFeeRecordCorrectionTransientFormData(req, res);
+
+        // Assert
+        expect(res._getData()).toEqual({});
+      });
     });
 
     it("should respond with the specific error status if an 'ApiError' is thrown", async () => {

dtfs-central-api/src/v1/controllers/utilisation-report-service/fee-record-correction/put-fee-record-correction-transient-form-data.controller/index.ts

@@ -1,4 +1,4 @@
-import { ApiError, FeeRecordCorrectionTransientFormDataEntity, REQUEST_PLATFORM_TYPE } from '@ukef/dtfs2-common';
+import { ApiError, FeeRecordCorrectionTransientFormDataEntity, RecordCorrectionFormValueValidationErrors, REQUEST_PLATFORM_TYPE } from '@ukef/dtfs2-common';
 import { HttpStatusCode } from 'axios';
 import { Response } from 'express';
 import { CustomExpressRequest } from '../../../../../types/custom-express-request';
@@ -16,6 +16,12 @@ export type PutFeeRecordCorrectionTransientFormDataRequest = CustomExpressReques
   reqBody: PutFeeRecordCorrectionTransientFormDataPayload;
 }>;
 
+type PutFeeRecordCorrectionTransientFormDataResponseBody = {
+  validationErrors?: RecordCorrectionFormValueValidationErrors;
+};
+
+type PutFeeRecordCorrectionTransientFormDataResponse = Response<PutFeeRecordCorrectionTransientFormDataResponseBody | string>;
+
 /**
  * Controller for the PUT fee record correction transient form data route.
  *
@@ -26,9 +32,12 @@ export type PutFeeRecordCorrectionTransientFormDataRequest = CustomExpressReques
  * If there are no validation errors, creates a new fee record correction transient
  * form data entity with the correction id, user id and form data, and saves it.
  * @param req - The {@link PutFeeRecordCorrectionTransientFormDataRequest} request object
- * @param res - The response object
+ * @param res - The {@link PutFeeRecordCorrectionTransientFormDataResponse} response object
  */
-export const putFeeRecordCorrectionTransientFormData = async (req: PutFeeRecordCorrectionTransientFormDataRequest, res: Response) => {
+export const putFeeRecordCorrectionTransientFormData = async (
+  req: PutFeeRecordCorrectionTransientFormDataRequest,
+  res: PutFeeRecordCorrectionTransientFormDataResponse,
+) => {
   try {
     const { correctionId: correctionIdString, bankId } = req.params;
     const { user, formData } = req.body;
@@ -42,10 +51,10 @@ export const putFeeRecordCorrectionTransientFormData = async (req: PutFeeRecordC
       throw new NotFoundError(`Failed to find a correction with id '${correctionId}' for bank id '${bankId}'`);
     }
 
-    const { formHasErrors, errors } = await validateRecordCorrectionTransientFormValues(formData, correction.reasons);
+    const { formHasErrors, errors: validationErrors } = await validateRecordCorrectionTransientFormValues(formData, correction.reasons);
 
     if (formHasErrors) {
-      return res.status(HttpStatusCode.Ok).send(errors);
+      return res.status(HttpStatusCode.Ok).send({ validationErrors });
     }
 
     const parsedFormData = parseValidatedRecordCorrectionTransientFormValues(formData);
@@ -62,7 +71,7 @@ export const putFeeRecordCorrectionTransientFormData = async (req: PutFeeRecordC
 
     await FeeRecordCorrectionTransientFormDataRepo.save(newTransientFormData);
 
-    return res.sendStatus(HttpStatusCode.Ok);
+    return res.status(HttpStatusCode.Ok).send({});
   } catch (error) {
     const errorMessage = 'Failed to put fee record correction transient form data';
     console.error('%s %o', errorMessage, error);

e2e-tests/gef/cypress/e2e/pages/amendments/do-you-have-a-facility-end-date.js

@@ -0,0 +1,10 @@
+const doYouHaveAFacilityEndDate = {
+  yesRadioButton: () => cy.get('[data-cy="is-using-facility-end-date-yes"]'),
+  noRadioButton: () => cy.get('[data-cy="is-using-facility-end-date-no"]'),
+  errorSummary: () => cy.get('[data-cy="error-summary"]'),
+  inlineError: () => cy.get('[data-cy="is-using-facility-end-date-error"]'),
+  pageHeading: () => cy.get('[data-cy="page-heading"]'),
+  backLink: () => cy.get('[data-cy="back-link"]'),
+};
+
+module.exports = doYouHaveAFacilityEndDate;

e2e-tests/gef/cypress/e2e/pages/amendments/facility-end-date.js

@@ -0,0 +1,12 @@
+const facilityEndDate = {
+  facilityEndDateDay: () => cy.get('[data-cy="facility-end-date-day"]'),
+  facilityEndDateMonth: () => cy.get('[data-cy="facility-end-date-month"]'),
+  facilityEndDateYear: () => cy.get('[data-cy="facility-end-date-year"]'),
+  errorSummary: () => cy.get('[data-cy="error-summary"]'),
+  facilityEndDateInlineError: () => cy.get('[data-cy="facility-end-date-inline-error"]'),
+  pageHeading: () => cy.get('[data-cy="page-heading"]'),
+  backLink: () => cy.get('[data-cy="back-link"]'),
+  cancelLink: () => cy.get('[data-cy="cancel-link"]'),
+};
+
+module.exports = facilityEndDate;

e2e-tests/portal/cypress/e2e/journeys/payment-report-officer/record-corrections/feature-flag-enabled/check-the-information.spec.js

@@ -0,0 +1,117 @@
+import {
+  UtilisationReportEntityMockBuilder,
+  FeeRecordCorrectionEntityMockBuilder,
+  PENDING_RECONCILIATION,
+  FeeRecordEntityMockBuilder,
+  FEE_RECORD_STATUS,
+  RECORD_CORRECTION_REASON,
+  CURRENCY,
+  mapReasonsToDisplayValues,
+} from '@ukef/dtfs2-common';
+import { NODE_TASKS, BANK1_PAYMENT_REPORT_OFFICER1 } from '../../../../../../../e2e-fixtures';
+import relative from '../../../../relativeURL';
+import { provideCorrection, pendingCorrections, reviewCorrection } from '../../../../pages';
+
+context('Check the information page - Fee record correction feature flag enabled', () => {
+  context('When a correction has been provided', () => {
+    const reportPeriod = { start: { month: 1, year: 2021 }, end: { month: 1, year: 2021 } };
+
+    const reasons = [
+      RECORD_CORRECTION_REASON.UTILISATION_INCORRECT,
+      RECORD_CORRECTION_REASON.REPORTED_CURRENCY_INCORRECT,
+      RECORD_CORRECTION_REASON.REPORTED_FEE_INCORRECT,
+    ];
+    const pdcErrorSummary = 'Some PDC error summary';
+
+    const exporter = 'An exporter';
+    const oldUtilisation = 987.65;
+    const oldReportedFees = {
+      currency: CURRENCY.GBP,
+      amount: 123.45,
+    };
+
+    const newUtilisation = 100.23;
+    const newReportedFees = {
+      currency: CURRENCY.USD,
+      amount: 543.21,
+    };
+    const bankAdditionalComments = 'Some additional bank comments';
+
+    beforeEach(() => {
+      cy.task(NODE_TASKS.DELETE_ALL_FROM_SQL_DB);
+
+      cy.task('getUserFromDbByEmail', BANK1_PAYMENT_REPORT_OFFICER1.email).then((user) => {
+        const { _id, bank } = user;
+        const bankId = bank.id;
+
+        const report = UtilisationReportEntityMockBuilder.forStatus(PENDING_RECONCILIATION)
+          .withUploadedByUserId(_id.toString())
+          .withBankId(bankId)
+          .withReportPeriod(reportPeriod)
+          .build();
+
+        const feeRecord = FeeRecordEntityMockBuilder.forReport(report)
+          .withStatus(FEE_RECORD_STATUS.PENDING_CORRECTION)
+          .withExporter(exporter)
+          .withFacilityUtilisation(oldUtilisation)
+          .withFeesPaidToUkefForThePeriod(oldReportedFees.amount)
+          .withFeesPaidToUkefForThePeriodCurrency(oldReportedFees.currency)
+          .build();
+
+        const pendingCorrection = FeeRecordCorrectionEntityMockBuilder.forFeeRecordAndIsCompleted(feeRecord, false)
+          .withId(3)
+          .withReasons(reasons)
+          .withAdditionalInfo(pdcErrorSummary)
+          .build();
+
+        cy.task(NODE_TASKS.INSERT_UTILISATION_REPORTS_INTO_DB, [report]);
+        cy.task(NODE_TASKS.INSERT_FEE_RECORDS_INTO_DB, [feeRecord]);
+        cy.task(NODE_TASKS.INSERT_FEE_RECORD_CORRECTIONS_INTO_DB, [pendingCorrection]);
+      });
+
+      cy.login(BANK1_PAYMENT_REPORT_OFFICER1);
+      cy.visit(relative(`/utilisation-report-upload`));
+
+      pendingCorrections.row(1).correctionLink().click();
+
+      provideCorrection.reportedCurrency.radioInput(newReportedFees.currency).click();
+      cy.keyboardInput(provideCorrection.reportedFeeInput(), newReportedFees.amount);
+      cy.keyboardInput(provideCorrection.utilisationInput(), newUtilisation);
+      cy.keyboardInput(provideCorrection.additionalComments.input(), bankAdditionalComments);
+
+      cy.clickContinueButton();
+    });
+
+    after(() => {
+      cy.task(NODE_TASKS.DELETE_ALL_FROM_SQL_DB);
+    });
+
+    it('should be able to view the form values and other details of correction request', () => {
+      reviewCorrection.originalValuesSummaryList().should('exist');
+      reviewCorrection.originalValuesSummaryList().should('contain', exporter);
+      reviewCorrection.originalValuesSummaryList().should('contain', oldReportedFees.currency);
+      reviewCorrection.originalValuesSummaryList().should('contain', oldReportedFees.amount);
+
+      const expectedCorrectionReasons = mapReasonsToDisplayValues(reasons).join(', ');
+      const expectedOldValues = `${oldUtilisation}, ${oldReportedFees.currency}, ${oldReportedFees.amount}`;
+      const expectedNewValues = `${newUtilisation}, ${newReportedFees.currency}, ${newReportedFees.amount}`;
+
+      reviewCorrection.recordCorrectionDetailsSummaryList().should('exist');
+      reviewCorrection.recordCorrectionDetailsSummaryList().should('contain', expectedCorrectionReasons);
+      reviewCorrection.recordCorrectionDetailsSummaryList().should('contain', pdcErrorSummary);
+      reviewCorrection.recordCorrectionDetailsSummaryList().should('contain', expectedOldValues);
+      reviewCorrection.recordCorrectionDetailsSummaryList().should('contain', expectedNewValues);
+      reviewCorrection.recordCorrectionDetailsSummaryList().should('contain', bankAdditionalComments);
+    });
+
+    context('and when the user clicks cancel', () => {
+      beforeEach(() => {
+        cy.clickCancelButton();
+      });
+
+      it('should redirect to the "Report GEF utilisation and fees paid" page', () => {
+        cy.url().should('eq', relative('/utilisation-report-upload'));
+      });
+    });
+  });
+});

e2e-tests/portal/cypress/e2e/journeys/payment-report-officer/record-corrections/feature-flag-enabled/provide-correction.spec.js

@@ -105,7 +105,54 @@ context('Provide correction - Fee record correction feature flag enabled', () =>
           provideCorrection.additionalComments.input().should('exist');
         });
 
-        context('and when the user has entered values and clicked save and review changes', () => {
+        context('and when the user has entered invalid values and clicked "save and review changes"', () => {
+          const newFacilityId = 'abc';
+          const newReportedFee = 'INVALID';
+          const additionalComments = ' ';
+
+          beforeEach(() => {
+            cy.keyboardInput(provideCorrection.facilityIdInput(), newFacilityId);
+            cy.keyboardInput(provideCorrection.reportedFeeInput(), newReportedFee);
+            cy.keyboardInput(provideCorrection.additionalComments.input(), additionalComments);
+
+            cy.clickContinueButton();
+          });
+
+          it('should display the validation errors', () => {
+            const expectedFacilityIdInputError = 'Error: You must enter a facility ID between 8 and 10 digits using the numbers 0-9 only';
+            const expectedReportedCurrencyError = 'Error: You must select a currency';
+            const expectedReportedFeeInputError = 'Error: You must enter the reported fee in a valid format';
+            const expectedAdditionalCommentsError = 'Error: You must enter a comment';
+
+            provideCorrection.errorSummaryItems().should('have.length', 4);
+
+            provideCorrection.facilityIdError().should('exist');
+            cy.assertText(provideCorrection.facilityIdError(), expectedFacilityIdInputError);
+
+            provideCorrection.reportedCurrency.error().should('exist');
+            cy.assertText(provideCorrection.reportedCurrency.error(), expectedReportedCurrencyError);
+
+            provideCorrection.reportedFeeError().should('exist');
+            cy.assertText(provideCorrection.reportedFeeError(), expectedReportedFeeInputError);
+
+            provideCorrection.utilisationError().should('not.exist');
+
+            provideCorrection.additionalComments.error().should('exist');
+            cy.assertText(provideCorrection.additionalComments.error(), expectedAdditionalCommentsError);
+          });
+
+          it('should retain the values entered by the user', () => {
+            provideCorrection.facilityIdInput().should('have.value', newFacilityId);
+            provideCorrection.reportedFeeInput().should('have.value', newReportedFee);
+            provideCorrection.additionalComments.input().should('have.value', additionalComments);
+
+            Object.values(CURRENCY).forEach((currency) => {
+              provideCorrection.reportedCurrency.radioInput(currency).should('not.be.checked');
+            });
+          });
+        });
+
+        context('and when the user has entered valid values and clicked "save and review changes"', () => {
           const newFacilityId = '77777777';
           const newReportedFee = '12345.67';
           const newReportedCurrency = CURRENCY.JPY;
@@ -130,6 +177,10 @@ context('Provide correction - Fee record correction feature flag enabled', () =>
             cy.clickContinueButton();
           });
 
+          it('should redirect to the review page', () => {
+            cy.url().should('eq', relative(`/utilisation-reports/provide-correction/${pendingCorrectionDetails.id}/check-the-information`));
+          });
+
           it('should retain the values entered by the user when they return to the page via the review page back link', () => {
             cy.clickBackLink();
 
@@ -170,6 +221,16 @@ context('Provide correction - Fee record correction feature flag enabled', () =>
             provideCorrection.additionalComments.input().should('have.value', '');
           });
         });
+
+        context('and when the user clicks cancel', () => {
+          beforeEach(() => {
+            cy.clickCancelButton();
+          });
+
+          it('should redirect to the "Report GEF utilisation and fees paid" page', () => {
+            cy.url().should('eq', relative('/utilisation-report-upload'));
+          });
+        });
       });
     });
   });

e2e-tests/portal/cypress/e2e/pages/utilisation-report-service/record-corrections/provideCorrection.js

@@ -1,16 +1,23 @@
 const page = {
   facilityIdInput: () => cy.get('input[data-cy="FACILITY_ID_INCORRECT-input"]'),
+  facilityIdError: () => cy.get('[data-cy="FACILITY_ID_INCORRECT-error"]'),
   reportedCurrency: {
     container: () => cy.get('[data-cy="REPORTED_CURRENCY_INCORRECT-input"]'),
     radioInput: (currency) => cy.get(`input[data-cy="currency-${currency}"]`),
+    error: () => cy.get('[data-cy="REPORTED_CURRENCY_INCORRECT-error"]'),
   },
   reportedFeeInput: () => cy.get('input[data-cy="REPORTED_FEE_INCORRECT-input"]'),
+  reportedFeeError: () => cy.get('[data-cy="REPORTED_FEE_INCORRECT-error"]'),
   utilisationInput: () => cy.get('input[data-cy="UTILISATION_INCORRECT-input"]'),
+  utilisationError: () => cy.get('[data-cy="UTILISATION_INCORRECT-error"]'),
   additionalComments: {
     input: () => cy.get(`textarea[data-cy="additional-comments-input"]`),
     label: () => cy.get(`[data-cy="additional-comments-label"]`),
     hint: () => cy.get(`[data-cy="additional-comments-hint"]`),
+    error: () => cy.get('[data-cy="additional-comments-error"]'),
   },
+  errorSummary: () => cy.get('[data-cy="error-summary"]'),
+  errorSummaryItems: () => cy.get('[data-cy="error-summary"] li'),
 };
 
 module.exports = page;