HDPI-6501-Caseworker-Review-Dates-Automation

src/e2eTest/data/page-data-figma/page-data-caseManagement-figma/addReviewDates.page.data.ts

@@ -0,0 +1,46 @@
+export const addReviewDates = {
+  mainHeader: `Review dates`,
+  addReviewDateHintText: `Add review date`,
+  reviewDateSubHeader: `Review date`,
+  addNewButton:`Add new`,
+  dateOfReviewHiddenLabel: `Date of review`,
+  dayHiddenTextLabel: `Day`,
+  monthHiddenTextLabel: `Month`,
+  yearHiddenTextLabel: `Year`,
+  reasonHiddenLabel: `Reason`,
+  unlessOrderHiddenRadioOption:`Unless order`,
+  StayCaseHiddenRadioOption: `Stay a case`,
+  liftStayHiddenRadioOption: `Lift a stay`,
+  dismissCaseHiddenRadioOption: `Dismiss case`,
+  generalOrderHiddenRadioOption: `General order`,
+  OtherHiddenRadioOption: `Other`,
+  descriptionHiddenTextLabel: `Description of review`,
+  youCanEnterUpToHiddenHintText: `You can enter up to 500 characters`,
+  removeHiddenButton:`Remove`,
+  continueButton: `Continue`,
+  previousButton: `Previous`,
+  cancelLink: `Cancel`,
+  dayInputText :`20`,
+  monthInputText :`12`,
+  yearInputText :`2030`,
+  descriptionTextInput:`50`,
+  errorValidation: `YES`,
+  eventCouldNotBeCreatedErrorMessageHeader: `The event could not be created`,
+  thereIsProbErrorMessageHeader: `There is a problem`,
+  errorValidationType: { one: `textField`, two: `radioOptions`, three: `checkBox`, four: `dropDown`, five: `dateField`, six: `dateRadioOption` },
+  errorValidationField: {
+    errorDateField: [
+      { type: `empty`, input: `empty`, errMessage: `Date of review is required`,errInlineMessage: `Date of review is required`},
+      { type: `invalid`, input: `invalid`, errMessage: `Date of review is not valid`, errInlineMessage: `The data entered is not valid for Date of review`},
+    ],
+    errorRadioOption: [
+      { type: `none`, input: ``, errMessage: `Reason is required`,errInlineMessage: `Reason is required` }
+    ],
+    errorTextField: [
+      { type: `none`, input: ``, errMessage: `Description of review is required` },
+      ],
+    errorDateRadioOption: [
+      {type: `Max`, input: `510`, errMessage: `In ‘Description of review’, you have entered more than the maximum number of characters (500)`}
+    ]
+  },
+};

src/e2eTest/data/page-data-figma/page-data-caseManagement-figma/checkYourAnswersAddReviewDates.page.data.ts

@@ -0,0 +1,7 @@
+export const checkYourAnswersAddReviewDates = {
+  mainHeader: `Add review date`,
+  cyaHeader: `Check your answers`,
+  submitButton: `Submit`,
+  previousButton: `Previous`,
+  cancelLink: `Cancel`,
+};

src/e2eTest/data/page-data-figma/page-data-caseManagement-figma/confirmReviewDatesAdded.page.data.ts

@@ -0,0 +1,7 @@
+export const confirmReviewDatesAdded = {
+  mainHeader: `Add review date`,
+  reviewDatesAdded: `Review dates added`,
+  whatHappensNextHeader: `What happens next`,
+  theCaseWillParagraph: `Work allocation tasks will be created for court staff to complete on the review dates.`,
+  closeAndReturnToCaseOverviewButton: `Close and Return to case details`,
+};

src/e2eTest/data/page-data-figma/page-data-caseManagement-figma/index.ts

@@ -1,5 +1,8 @@
 export * from './selectDocument.page.data';
 export * from './amendDocumentDetails.page.data';
+export * from './addReviewDates.page.data';
+export * from './checkYourAnswersAddReviewDates.page.data'
+export * from './confirmReviewDatesAdded.page.data'
 export * from './changeCaseState.page.data';
 export * from './checkYourAnswersChangeState.page.data';
-export * from './confirmCaseStateChange.page.data';
+export * from './confirmCaseStateChange.page.data';

src/e2eTest/data/page-data-figma/page-data-caseManagement-figma/urlToFileMappingCM.ts

@@ -1,5 +1,8 @@
 export default {
   'amendDocumentsselectDocument': 'selectDocument',
+  'addCaseReviewDateaddCaseReviewDate': 'addReviewDates',
+  'addCaseReviewDate/submit' : 'checkYourAnswersAddReviewDates',
+  'addCaseReviewDate/confirm': 'confirmReviewDatesAdded',
   'changeCaseStatechangeCaseStatePage': 'changeCaseState',
   'changeCaseState/confirm': 'confirmCaseStateChange'
-};
+};

src/e2eTest/data/page-data/caseSummary.page.data.ts

@@ -16,5 +16,6 @@ export const caseSummary = {
   manageDocuments:{
     amend : 'Manage documents: Amend'
   },
+  addReviewDates: 'Add review date',
   changeCaseState: 'Change case state'
 }

src/e2eTest/tests/test-caseManagement/caseManagement.addReviewDates.spec.ts

@@ -0,0 +1,56 @@
+import { createCaseApiData, submitCaseApiData } from '@data/api-data';
+import {initializeExecutor, performValidation} from '@utils/controller';
+import test from '@playwright/test';
+import { caseInfo } from '@utils/actions/custom-actions';
+import { PageContentValidation } from '@utils/validations/element-validations/pageContent.validation';
+import { caseSummary, user } from '@data/page-data';
+import { dismissCookieBanner } from '@config/cookie-banner';
+import { initializeCMExecutor, performAction } from '@utils/controller-caseManagement';
+import {addReviewDates, checkYourAnswersAddReviewDates} from "@data/page-data-figma/page-data-caseManagement-figma";
+
+
+test.use({ storageState: undefined })
+
+test.beforeEach(async ({ page, context }) => {
+  await context.clearCookies();
+  initializeExecutor(page);
+  initializeCMExecutor(page);
+  await performAction('createCaseAPI', { data: createCaseApiData.createCasePayload });
+  await performAction('submitCaseAPI', { data: submitCaseApiData.submitCasePayloadCaseFileView });
+  console.log(`Case created with case number: ${process.env.CASE_NUMBER}`);
+  await performAction('updatePaymentAPI');
+  await performAction('getCaseAPI', 'Link Solicitor');
+  await performAction('navigateToUrl', process.env.MANAGE_CASE_BASE_URL);
+  await dismissCookieBanner(page, 'additional');
+  await performAction('login', user.staffAdmin);
+  await dismissCookieBanner(page, 'analytics');
+  await performAction('navigateToSummaryPage');
+});
+
+test.afterEach(async () => {
+  if (caseInfo.id) {
+    await performAction('deleteCaseRole', '[CLAIMANTSOLICITOR]');
+  }
+  PageContentValidation.finaliseTest();
+
+});
+
+test.describe('Case management - Case Worker Add Review date @nightly', async () => {
+  test('Case management - Case Worker Add Review Date @CM @regression', async () => {
+    await performAction('selectAnEvent', { eventType: caseSummary.addReviewDates });
+    await performValidation('mainHeader', addReviewDates.mainHeader);
+    await performAction('clickButton', addReviewDates.addNewButton);
+    await performAction('errorValidationAddReviewDatesPage', addReviewDates.errorValidation);
+    await performAction('addReviewDates', {
+      day: addReviewDates.dayHiddenTextLabel,
+      month: addReviewDates.monthHiddenTextLabel,
+      year: addReviewDates.yearHiddenTextLabel,
+      question: addReviewDates.reasonHiddenLabel, option: addReviewDates.dismissCaseHiddenRadioOption,
+      label: addReviewDates.descriptionHiddenTextLabel, userInput: addReviewDates.descriptionTextInput,
+      nextPage: checkYourAnswersAddReviewDates.mainHeader
+    });
+    await performAction('clickButton', checkYourAnswersAddReviewDates.submitButton);
+    await performAction('confirmReviewDatesAdded');
+    await performValidation('bannerAlert', 'Case #.* has been updated with event: Add review date');
+  });
+});

src/e2eTest/utils/actions/custom-actions/custom-actions-caseManagement/caseManagement.action.ts

@@ -6,7 +6,18 @@ import { getCaseTypeId } from '@utils/common/caseType.utils';
 import { performAction, performValidation } from '@utils/controller-caseManagement';
 import { VERY_LONG_TIMEOUT } from 'playwright.config';
 import { caseSummary, home } from '@data/page-data';
-import { changeCaseState, confirmCaseStateChange, selectDocument } from '@data/page-data-figma/page-data-caseManagement-figma';
+import {generateRandomString} from "@utils/common/string.utils";
+import {performActions} from "@utils/controller";
+import {
+  CaseManagementCommonUtils
+} from "@utils/actions/custom-actions/custom-actions-caseManagement/caseManagementUtils.action";
+import {
+  addReviewDates,
+  confirmReviewDatesAdded,
+  selectDocument,
+  changeCaseState,
+  confirmCaseStateChange
+} from '@data/page-data-figma/page-data-caseManagement-figma';
 import { caseInfo } from '../createCaseAPI.action';
 
 
@@ -25,6 +36,8 @@ export class CaseManagementAction implements IAction {
       ['navigateToSummaryPage', () => this.navigateToSummaryPage(page)],
       ['selectAnEvent', () => this.selectAnEvent(fieldName as actionRecord)],
       ['selectDocumentToAmend', () => this.selectDocumentToAmend(fieldName as actionRecord)],
+      ['addReviewDates', () => this.addReviewDates(fieldName as actionRecord)],
+      ['confirmReviewDatesAdded', () => this.confirmReviewDatesAdded()],
       ['changeCaseState', () => this.changeCaseState(fieldName as actionRecord)],
       ['confirmCaseStateChange', () => this.confirmCaseStateChange()],
       ['inputErrorValidation', () => this.inputErrorValidation(page, fieldName as actionRecord)],
@@ -85,33 +98,69 @@ export class CaseManagementAction implements IAction {
     await performAction('clickButton', confirmCaseStateChange.closeAndReturnToCaseOverviewButton);
   }
 
+  private async addReviewDates(reviewDateData: actionRecord){
+    await performValidation('text', { elementType: 'paragraph', text: 'Case number: ' + caseInfo.fid });
+    await performValidation('text', {
+      elementType: 'paragraph',
+      text: `Property address: ${addressInfo.buildingStreet}, ${addressInfo.townCity}, ${addressInfo.engOrWalPostcode}`
+    });
+    const userInput =
+      typeof reviewDateData.input === 'number'
+        ? generateRandomString(reviewDateData.input)
+        : (reviewDateData.input as string);
+    let date = CaseManagementCommonUtils.getRandomDate(reviewDateData.dateType as string);
+    await performActions('Date of Review',
+      ['inputText', reviewDateData.day, date.split('/')[0]],
+      ['inputText', reviewDateData.month, date.split('/')[1]],
+      ['inputText', reviewDateData.year, date.split('/')[2]]);
+    await performAction('clickRadioButton', { question: reviewDateData.question, option: reviewDateData.option });
+    await performAction('inputText', reviewDateData.label, reviewDateData.userInput);
+    await performAction('reTryOnCallBackError', addReviewDates.continueButton, reviewDateData.nextPage as string);
+  }
+
+  private async confirmReviewDatesAdded(): Promise<void> {
+    await performValidation('text', { elementType: 'paragraph', text: 'Case number: ' + caseInfo.fid });
+    await performValidation('text', {
+      elementType: 'paragraph',
+      text: `Property address: ${addressInfo.buildingStreet}, ${addressInfo.townCity}, ${addressInfo.engOrWalPostcode}`
+    });
+    await performValidation('text', { elementType: 'inlineText', text: confirmReviewDatesAdded.reviewDatesAdded});
+    await performValidation('text', { elementType: 'inlineText', text: 'Case number #' + caseInfo.fid });
+    await performValidation('text', {
+      elementType: 'inlineText',
+      text: `${addressInfo.buildingStreet}, ${addressInfo.addressLine2}, ${addressInfo.townCity}, ${addressInfo.engOrWalPostcode}`
+    });
+    await performValidation('mainHeader', confirmReviewDatesAdded.mainHeader);
+    await performAction('clickButton', confirmReviewDatesAdded.closeAndReturnToCaseOverviewButton);
+  }
+
+
   private async inputErrorValidation(page: Page, validationArr: actionRecord) {
-
-
         if (Array.isArray(validationArr.inputArray)) {
           for (const item of validationArr.inputArray) {
+
             switch (validationArr.validationType) {
-                
-              case 'radioOptions':
+
+                case 'radioOptions':
                 await performAction('clickButton', validationArr.button);
                 await performValidation('inputError', !validationArr?.label ? validationArr.question : validationArr.label, item.errInlineMessage);
                 await performValidation('errorMessage', !validationArr?.header ? validationArr.header = 'There is a problem' : validationArr.header, item.errMessage);
-                await performAction('clickRadioButton', { question: validationArr.question, option: validationArr.option });
+                await performAction('clickRadioButton', {question: validationArr.question, option: validationArr.option});
                 break;
-  
+
               case 'checkBox':
                 await performAction('clickButton', validationArr.button);
                 await performValidation('inputError', !validationArr?.label ? validationArr.question : validationArr.label, item.errMessage);
                 await performValidation('errorMessage', !validationArr?.header ? validationArr.header = 'There is a problem' : validationArr.header, item.errMessage);
                 await performAction('check', validationArr.checkBox);
                 break;
-  
+
               case 'checkBoxPageLevel':
                 await performAction('clickButton', validationArr.button);
                 await performValidation('errorMessage', !validationArr?.header ? validationArr.header = 'There is a problem' : validationArr.header, item.errMessage);
                 await performAction('check', validationArr.checkBox);
                 break;
-  
+
               case 'dropDown':
                 await performAction('clickButton', validationArr.button);
                 await expect(async () => {
@@ -122,10 +171,72 @@ export class CaseManagementAction implements IAction {
                 });
                 await performAction('select', validationArr.dropQn, validationArr.option);
                 break;
-
+
+              case 'textField':
+                await performAction('inputText', validationArr.label, CaseManagementCommonUtils.generateRandomString(item.input));
+                await expect(async () => {
+                  await performAction('clickButton', validationArr.button);
+                  if (item.type === 'moreThanMax') {
+                    await performValidation('errorMessage', { header: validationArr.header, message: item.errMessage });
+                  } else {
+                    await performValidation('inputError', validationArr.label, item.errMessage);
+                    await performValidation('errorMessage', validationArr.label, item.errMessage);
+                  }
+                }).toPass({
+                  timeout: VERY_LONG_TIMEOUT,
+                });
+                break;
+
+              case 'dateField':
+                let date: string = CaseManagementCommonUtils.getRandomDate(item.type as string);
+                const enterDate = () =>
+                  performActions(
+                    'Enter Date',
+                    ['inputText', validationArr.label1, date.split('/')[0]],
+                    ['inputText', validationArr.label2, date.split('/')[1]],
+                    ['inputText', validationArr.label3, date.split('/')[2]]
+                  );
+
+                if (item.type === 'empty') {
+                  await performAction('clickButton', validationArr.button);
+                  await performValidation('inputError', !validationArr?.label ? validationArr.question : validationArr.label, item.errInlineMessage);
+                  await performValidation('errorMessage', validationArr.header1, item.errMessage);
+                } else if (item.type === 'past') {
+                  await enterDate();
+                } else if (item.type === 'invalid') {
+                  await enterDate();
+                  await performAction('clickButton', validationArr.button);
+                  await performValidation('errorMessage', validationArr.header1, item.errMessage);
+                }
+                else {
+                  await enterDate();
+                  await performAction('clickButton', validationArr.button);
+                  await performValidation('errorMessage', { header: validationArr.header, message: item.errMessage });
+                }
+                break;
+
+              case 'dateRadioOption' :
+                let dateOfReview: string = CaseManagementCommonUtils.getRandomDate(item.type as string);
+                const enterDateOfReview = () =>
+                  performActions(
+                    'Enter Date',
+                    ['inputText', validationArr.label1, dateOfReview.split('/')[0]],
+                    ['inputText', validationArr.label2, dateOfReview.split('/')[1]],
+                    ['inputText', validationArr.label3, dateOfReview.split('/')[2]]
+                  );
+                await enterDateOfReview();
+                await performAction('clickRadioButton', {
+                  question: validationArr.question,
+                  option: validationArr.option
+                });
+                await performAction('inputText', validationArr.label, generateRandomString(Number(item.input)));
+                await performAction('clickButton', validationArr.button);
+                await performValidation('errorMessage', { header: validationArr.header, message: item.errMessage });
+                break;
+
               default:
                 throw new Error(`Validation type :"${validationArr.validationType}" is not valid`);
-            };
+            }
           }
         }
       if (validationArr.buttonRemove) {

src/e2eTest/utils/actions/custom-actions/custom-actions-caseManagement/caseManagementErrorValidation.action.ts

@@ -1,12 +1,13 @@
 import { Page } from '@playwright/test';
 import { performAction } from '@utils/controller-caseManagement';
 import { IAction, actionData, actionRecord } from '@utils/interfaces/action.interface';
-import { changeCaseState, selectDocument } from '@data/page-data-figma/page-data-caseManagement-figma';
+import { addReviewDates,changeCaseState, selectDocument } from '@data/page-data-figma/page-data-caseManagement-figma';
 
 export class ErrorValidationAction implements IAction {
   async execute(page: Page, action: string, errorFlag: string | actionRecord, roles?: actionData): Promise<void> {
     const actionsMap = new Map<string, () => Promise<void>>([
       ['errorValidationSelectDocumentPage', () => this.errorValidationSelectDocumentPage(errorFlag as string)],
+      ['errorValidationAddReviewDatesPage', () => this.errorValidationAddReviewDatesPage(errorFlag as string)],
       ['errorValidationChangeCaseStatePage', () => this.errorValidationChangeCaseStatePage(errorFlag as string)],
 
     ]);
@@ -34,6 +35,49 @@ export class ErrorValidationAction implements IAction {
     }
   }
 
+  private async errorValidationAddReviewDatesPage(validationReq: string) {
+    if (validationReq === 'YES') {
+      await performAction('inputErrorValidation',{
+        validationType: addReviewDates.errorValidationType.five,
+        inputArray: addReviewDates.errorValidationField.errorDateField,
+        question: addReviewDates.dateOfReviewHiddenLabel,
+        header1: addReviewDates.thereIsProbErrorMessageHeader,
+        label1: addReviewDates.dayHiddenTextLabel,
+        label2: addReviewDates.monthHiddenTextLabel,
+        label3: addReviewDates.yearHiddenTextLabel,
+        button: addReviewDates.continueButton
+      });
+
+      await performAction('inputErrorValidation',{
+        validationType: addReviewDates.errorValidationType.two,
+        inputArray: addReviewDates.errorValidationField.errorRadioOption,
+        question: addReviewDates.reasonHiddenLabel,
+        option: addReviewDates.unlessOrderHiddenRadioOption,
+        button: addReviewDates.continueButton
+      });
+
+      await performAction('inputErrorValidation', {
+        validationType: addReviewDates.errorValidationType.one,
+        inputArray: addReviewDates.errorValidationField.errorTextField,
+        header: addReviewDates.eventCouldNotBeCreatedErrorMessageHeader,
+        label: addReviewDates.descriptionHiddenTextLabel,
+        button: addReviewDates.continueButton
+      });
+
+      await performAction('inputErrorValidation', {
+        validationType: addReviewDates.errorValidationType.six,
+        inputArray: addReviewDates.errorValidationField.errorDateRadioOption,
+        header: addReviewDates.eventCouldNotBeCreatedErrorMessageHeader,
+        label1: addReviewDates.dayHiddenTextLabel,
+        label2: addReviewDates.monthHiddenTextLabel,
+        label3: addReviewDates.yearHiddenTextLabel,
+        label: addReviewDates.descriptionHiddenTextLabel,
+        question: addReviewDates.reasonHiddenLabel,
+        option: addReviewDates.OtherHiddenRadioOption,
+        button: addReviewDates.continueButton
+      });
+    }
+  }
   private async errorValidationChangeCaseStatePage(validationReq: string) {
     if (validationReq === 'YES') {
       await performAction('inputErrorValidation', {