Merge pull request #702 from companieshouse/feature/ecct-848-fix-task…

…-count

Adjust expected task count if REA is not included [ECCT-848]

src/controllers/task.list.controller.ts

@@ -27,18 +27,16 @@ export const get = async (req: Request, res: Response, next: NextFunction) => {
     const companyHasExistingRea: boolean = await doesCompanyHaveEmailAddress(companyNumber);
     const confirmationStatement: ConfirmationStatementSubmission = await getConfirmationStatement(session, transactionId, submissionId);
 
-    const taskList: TaskList = initTaskList(company.companyNumber, transactionId, submissionId, confirmationStatement, companyHasExistingRea);
-    taskList.recordDate = calculateFilingDate(taskList.recordDate, company);
-
     const statementDate: Date = new Date(company.confirmationStatement?.nextMadeUpTo as string);
     const registeredEmailAddressOptionEnabled: boolean = ecctDayOneEnabled(statementDate);
+    const taskList: TaskList = initTaskList(company.companyNumber, transactionId, submissionId, confirmationStatement, registeredEmailAddressOptionEnabled, companyHasExistingRea);
+    taskList.recordDate = calculateFilingDate(taskList.recordDate, company);
 
     return res.render(Templates.TASK_LIST, {
       backLinkUrl,
       company,
       taskList,
       reviewUrl,
-      registeredEmailAddressOptionEnabled,
       templateName: Templates.TASK_LIST
     });
   } catch (e) {

src/services/task.list.service.ts

@@ -26,6 +26,7 @@ export const initTaskList = (companyNumber: string,
                              transactionId: string,
                              submissionId: string,
                              csSubmission: ConfirmationStatementSubmission,
+                             registeredEmailAddressOptionEnabled: boolean,
                              companyHasExistingRea: boolean): TaskList => {
 
   const allTasks = {
@@ -41,10 +42,10 @@ export const initTaskList = (companyNumber: string,
       state: toTaskState(csSubmission.data?.registerLocationsData?.sectionStatus),
       url: urlUtils.getUrlWithCompanyNumberTransactionIdAndSubmissionId(REGISTER_LOCATIONS_PATH, companyNumber, transactionId, submissionId)
     },
-    registeredEmailAddress: {
+    registeredEmailAddress: registeredEmailAddressOptionEnabled ? {
       state: toTaskState(csSubmission.data?.registeredEmailAddressData?.sectionStatus),
       url: urlUtils.getUrlWithCompanyNumberTransactionIdAndSubmissionId(getRegisteredEmailAddressSectionUrl(companyHasExistingRea), companyNumber, transactionId, submissionId)
-    },
+    } : undefined,
     registeredOfficeAddress: {
       state: toTaskState(csSubmission.data?.registeredOfficeAddressData?.sectionStatus),
       url: urlUtils.getUrlWithCompanyNumberTransactionIdAndSubmissionId(REGISTERED_OFFICE_ADDRESS_PATH, companyNumber, transactionId, submissionId)
@@ -62,13 +63,15 @@ export const initTaskList = (companyNumber: string,
       url: urlUtils.getUrlWithCompanyNumberTransactionIdAndSubmissionId(STATEMENT_OF_CAPITAL_PATH, companyNumber, transactionId, submissionId)
     }
   };
-  const completedtasks = getTaskCompletedCount(csSubmission);
-  const isTasksCompleted = Object.keys(allTasks).length === completedtasks;
+  const completedTasks = getTaskCompletedCount(csSubmission);
+  const expectedTasks =  Object.keys(allTasks).filter(key => allTasks[key] !== undefined).length;
+  const isTasksCompleted = expectedTasks === completedTasks;
 
   return {
     tasks: allTasks,
     recordDate: toReadableFormat(csSubmission.data?.confirmationStatementMadeUpToDate),
-    tasksCompletedCount: completedtasks,
+    tasksExpectedCount: expectedTasks,
+    tasksCompletedCount: completedTasks,
     allTasksCompleted: isTasksCompleted,
     csDue: false
   };

src/types/task.list.ts

@@ -32,7 +32,7 @@ export interface TaskList {
       state: TaskState;
       url: string;
     };
-    registeredEmailAddress: {
+    registeredEmailAddress?: {
       state: TaskState;
       url: string;
     };
@@ -46,6 +46,7 @@ export interface TaskList {
     };
   },
   recordDate: string;
+  tasksExpectedCount: number;
   tasksCompletedCount: number;
   allTasksCompleted: boolean;
   csDue: boolean;

test/controllers/task.list.controller.unit.ts

@@ -18,7 +18,7 @@ import { DateTime } from "luxon";
 import { createAndLogError } from "../../src/utils/logger";
 import { getConfirmationStatement } from "../../src/services/confirmation.statement.service";
 import { mockConfirmationStatementSubmission } from "../mocks/confirmation.statement.submission.mock";
-import { mockTaskList } from "../mocks/task.list.mock";
+import { mockTaskListWithEmail, mockTaskListNoEmail } from "../mocks/task.list.mock";
 import { urlUtils } from "../../src/utils/url";
 import { doesCompanyHaveEmailAddress } from "../../src/services/registered.email.address.service";
 
@@ -38,7 +38,7 @@ const mockGetConfirmationStatement = getConfirmationStatement as jest.Mock;
 mockGetConfirmationStatement.mockResolvedValue(mockConfirmationStatementSubmission);
 
 const mockInitTaskList = initTaskList as jest.Mock;
-mockInitTaskList.mockReturnValue(mockTaskList);
+mockInitTaskList.mockReturnValue(mockTaskListNoEmail);
 
 const mockDoesCompanyHaveEmailAddress = doesCompanyHaveEmailAddress as jest.Mock;
 mockDoesCompanyHaveEmailAddress.mockReturnValue(true);
@@ -69,7 +69,7 @@ describe("Task list controller tests", () => {
 
       const response = await request(app).get(URL);
 
-      expect(mockInitTaskList).toBeCalledWith(validCompanyProfile.companyNumber, TRANSACTION_ID, SUBMISSION_ID, mockConfirmationStatementSubmission, true);
+      expect(mockInitTaskList).toBeCalledWith(validCompanyProfile.companyNumber, TRANSACTION_ID, SUBMISSION_ID, mockConfirmationStatementSubmission, false, true);
       expect(response.text).toContain("Check and confirm that the company information we have on record is correct");
       expect(response.text).toContain("Submit");
       expect(response.text).toContain("Cannot start yet");
@@ -126,7 +126,6 @@ describe("Task list controller tests", () => {
       const response = await request(app).get(URL);
 
       expect(response.text).toContain(ERROR_TEXT);
-      expect(response.text).not.toContain("Registered email address");
     });
 
     it("Should return an error page if error is thrown when Company Profile is missing confirmation statement", async () => {
@@ -141,40 +140,49 @@ describe("Task list controller tests", () => {
 
     it("Should enable Registered email address option when confirmation statement date is the same as ECCT start date", async () => {
       mockGetCompanyProfile.mockResolvedValueOnce(validCompanyProfile);
+      mockInitTaskList.mockReturnValueOnce(mockTaskListWithEmail);
       PropertiesMock.FEATURE_FLAG_ECCT_START_DATE_14082023 = "2020-03-15";
       const response = await request(app).get(URL);
 
+      expect(mockInitTaskList).toBeCalledWith(validCompanyProfile.companyNumber, TRANSACTION_ID, SUBMISSION_ID, mockConfirmationStatementSubmission, true, true);
       expect(response.text).toContain("Registered email address");
     });
 
     it("Should enable Registered email address option when confirmation statement date is after ECCT start date", async () => {
       mockGetCompanyProfile.mockResolvedValueOnce(validCompanyProfile);
+      mockInitTaskList.mockReturnValueOnce(mockTaskListWithEmail);
       PropertiesMock.FEATURE_FLAG_ECCT_START_DATE_14082023 = "2020-03-14";
       const response = await request(app).get(URL);
 
+      expect(mockInitTaskList).toBeCalledWith(validCompanyProfile.companyNumber, TRANSACTION_ID, SUBMISSION_ID, mockConfirmationStatementSubmission, true, true);
       expect(response.text).toContain("Registered email address");
     });
 
     it("Should disable Registered email address option when confirmation statement date is before ECCT start date", async () => {
       mockGetCompanyProfile.mockResolvedValueOnce(validCompanyProfile);
+      mockInitTaskList.mockReturnValueOnce(mockTaskListNoEmail);
       PropertiesMock.FEATURE_FLAG_ECCT_START_DATE_14082023 = '2020-03-16';
       const response = await request(app).get(URL);
 
+      expect(mockInitTaskList).toBeCalledWith(validCompanyProfile.companyNumber, TRANSACTION_ID, SUBMISSION_ID, mockConfirmationStatementSubmission, false, true);
       expect(response.text).not.toContain("Registered email address");
     });
 
     it("Should disable Registered email address option when ECCT Feature flag environment variable is invalid format", async () => {
       mockGetCompanyProfile.mockResolvedValueOnce(validCompanyProfile);
+      mockInitTaskList.mockReturnValueOnce(mockTaskListNoEmail);
       PropertiesMock.FEATURE_FLAG_ECCT_START_DATE_14082023 = '2020-03-99';
       const response = await request(app).get(URL);
-
+      expect(mockInitTaskList).toBeCalledWith(validCompanyProfile.companyNumber, TRANSACTION_ID, SUBMISSION_ID, mockConfirmationStatementSubmission, false, true);
       expect(response.text).not.toContain("Registered email address");
     });
 
     it("Should disable Registered email address option when ECCT Feature flag environment variable not supplied", async () => {
       mockGetCompanyProfile.mockResolvedValueOnce(validCompanyProfile);
+      mockInitTaskList.mockReturnValueOnce(mockTaskListNoEmail);
       const response = await request(app).get(URL);
 
+      expect(mockInitTaskList).toBeCalledWith(validCompanyProfile.companyNumber, TRANSACTION_ID, SUBMISSION_ID, mockConfirmationStatementSubmission, false, true);
       expect(response.text).not.toContain("Registered email address");
     });
   });

test/mocks/task.list.mock.ts

@@ -1,6 +1,6 @@
 import { TaskList, TaskState } from "../../src/types/task.list";
 
-export const mockTaskList: TaskList = {
+export const mockTaskListWithEmail: TaskList = {
   tasks: {
     sicCodes: {
       state: TaskState.CHECKED,
@@ -37,6 +37,46 @@ export const mockTaskList: TaskList = {
   },
   recordDate: "16 Jun 2021",
   tasksCompletedCount: 2,
+  tasksExpectedCount: 8,
+  allTasksCompleted: false,
+  csDue: true,
+};
+
+export const mockTaskListNoEmail: TaskList = {
+  tasks: {
+    sicCodes: {
+      state: TaskState.CHECKED,
+      url: "/sic-code",
+    },
+    statementOfCapital: {
+      state: TaskState.NOT_CHECKED,
+      url: "/soc"
+    },
+    officers: {
+      state: TaskState.IN_PROGRESS,
+      url: "/officers"
+    },
+    peopleSignificantControl: {
+      state: TaskState.CHECKED,
+      url: "/psc"
+    },
+    shareholders: {
+      state: TaskState.IN_PROGRESS,
+      url: "/shr",
+    },
+    registeredEmailAddress: undefined,
+    registeredOfficeAddress: {
+      state: TaskState.NOT_CHECKED,
+      url: "/regaddr"
+    },
+    registerLocations: {
+      state: TaskState.NOT_CHECKED,
+      url: "/regloc"
+    },
+  },
+  recordDate: "16 Jun 2021",
+  tasksCompletedCount: 2,
+  tasksExpectedCount: 7,
   allTasksCompleted: false,
   csDue: true,
 };

test/services/task.list.service.unit.ts

@@ -59,7 +59,7 @@ describe("Task List Service tests", () => {
 
   describe("initTaskList tests", () => {
     it("Should return a populated task list", () => {
-      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true);
+      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true, true);
 
       expect(taskList.tasks.officers.state).toBe(TASK_STATE);
       expect(taskList.tasks.officers.url).toBe(TASK_URL);
@@ -73,8 +73,8 @@ describe("Task List Service tests", () => {
       expect(taskList.tasks.registerLocations.url).toBe(TASK_URL);
       expect(mockGetUrlWithCompanyNumberTransactionIdAndSubmissionId.mock.calls[2][0]).toBe(REGISTER_LOCATIONS_PATH);
 
-      expect(taskList.tasks.registeredEmailAddress.state).toBe(TASK_STATE);
-      expect(taskList.tasks.registeredEmailAddress.url).toBe(TASK_URL);
+      expect(taskList.tasks.registeredEmailAddress?.state).toBe(TASK_STATE);
+      expect(taskList.tasks.registeredEmailAddress?.url).toBe(TASK_URL);
       expect(mockGetUrlWithCompanyNumberTransactionIdAndSubmissionId.mock.calls[3][0]).toBe(CHECK_EMAIL_ADDRESS_PATH);
 
       expect(taskList.tasks.registeredOfficeAddress.state).toBe(TASK_STATE);
@@ -102,7 +102,7 @@ describe("Task List Service tests", () => {
     it("Should populate soc state if data is undefined", () => {
       const clonedSubmission: ConfirmationStatementSubmission = clone(mockConfirmationStatementSubmission);
       clonedSubmission.data = undefined as unknown as ConfirmationStatementSubmissionData;
-      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, clone(clonedSubmission), true);
+      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, clone(clonedSubmission), true, true);
       expect(taskList.tasks.statementOfCapital.state).toBe(TASK_STATE);
     });
 
@@ -111,44 +111,58 @@ describe("Task List Service tests", () => {
       clonedSubmission.data = {
         confirmationStatementMadeUpToDate: "2021-03-11"
       };
-      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, clone(clonedSubmission), true);
+      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, clone(clonedSubmission), true, true);
       expect(taskList.tasks.statementOfCapital.state).toBe(TASK_STATE);
     });
 
     it("Should populate set all tasks completed to TRUE.", () => {
       const ALL_TASK_COMPLETED_COUNT = 8;
       mockGetTaskCompletedCount.mockReturnValueOnce(ALL_TASK_COMPLETED_COUNT);
-      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true);
+      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true, true);
 
       expect(taskList.tasksCompletedCount).toBe(ALL_TASK_COMPLETED_COUNT);
       expect(taskList.allTasksCompleted).toBe(true);
     });
 
     it("Should return single psc page when five or more feature flag is false", () => {
       mockIsActiveFeature.mockReturnValueOnce(false);
-      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true);
+      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true, true);
       expect(taskList.tasks.peopleSignificantControl.state).toBe(TaskState.CHECKED);
       expect(taskList.tasks.peopleSignificantControl.url).toBe(TASK_URL);
       expect(mockGetUrlWithCompanyNumberTransactionIdAndSubmissionId.mock.calls[1][0]).toBe(PEOPLE_WITH_SIGNIFICANT_CONTROL_PATH);
     });
 
     it("Should return multiple psc page when five or more feature flag is true", () => {
       mockIsActiveFeature.mockReturnValueOnce(true);
-      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true);
+      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true, true);
       expect(taskList.tasks.peopleSignificantControl.state).toBe(TaskState.CHECKED);
       expect(taskList.tasks.peopleSignificantControl.url).toBe(TASK_URL);
       expect(mockGetUrlWithCompanyNumberTransactionIdAndSubmissionId.mock.calls[1][0]).toBe(ACTIVE_PSC_DETAILS_PATH);
     });
 
     it("Should use provide-email-address for Registered email address option when company does not have an existing email address", () => {
-      initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, false);
+      initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true, false);
       expect(mockGetUrlWithCompanyNumberTransactionIdAndSubmissionId.mock.calls[3][0]).toBe(PROVIDE_EMAIL_ADDRESS_PATH);
     });
 
     it("Should use check-email-address for Registered email address option when company has an existing email address", () => {
-      initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true);
+      initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true, true);
       expect(mockGetUrlWithCompanyNumberTransactionIdAndSubmissionId.mock.calls[3][0]).toBe(CHECK_EMAIL_ADDRESS_PATH);
     });
+
+    it("Should have an expected task count of 7 when rea feature is not active", () => {
+      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, false, true);
+      expect(taskList.tasks.registeredEmailAddress).toBeUndefined();
+      expect(taskList.tasks.registeredEmailAddress).toBeUndefined();
+      expect(taskList.tasksExpectedCount).toBe(7);
+    });
+
+    it("Should have an expected task count of 8 when rea feature is active", () => {
+      const taskList: TaskList = initTaskList(COMPANY_NUMBER, TRANSACTION_ID, CS_SUBMISSION_ID, mockConfirmationStatementSubmission, true, true);
+      expect(taskList.tasks.registeredEmailAddress?.state).toBe(TASK_STATE);
+      expect(taskList.tasks.registeredEmailAddress?.url).toBe(TASK_URL);
+      expect(taskList.tasksExpectedCount).toBe(8);
+    });
   });
 });
 

views/includes/task-list/addresses.html

@@ -2,7 +2,7 @@ <h2 class="app-task-list__section">
     Addresses
 </h2>
 <ul class="app-task-list__items">
-    {% if registeredEmailAddressOptionEnabled %}
+    {% if taskList.tasks.registeredEmailAddress %}
         <li class="app-task-list__item">
             <span class="app-task-list__task-name">
                 <a href="{{taskList.tasks.registeredEmailAddress.url}}" data-event-id="registered-email-address-company-information-section">

views/task-list.html

@@ -28,7 +28,7 @@ <h1 class="govuk-heading-l">
             {{ taskList.recordDate }}.
         </p>
         <p class="govuk-body govuk-!-margin-bottom-7">
-            You have checked {{ taskList.tasksCompletedCount }} of 7 sections
+            You have checked {{ taskList.tasksCompletedCount }} of {{ taskList.tasksExpectedCount }} sections
         </p>
         <ol class="app-task-list">
             <li>