#5203 - Modified Independent appeal: New "other" appeal to update profile - E2E tests (#5307)

## Unit tests

- StudentAppealActionsProcessor-processActions
- Should execute actions uniquely when multiple requests with the same
actions are part of the same appeal.
- Should execute multiple actions and pass the parameters as expected
when multiple requests with different actions are part of the same
appeal.
- Should throw an error when the appeal request has an unknown action.
- Should execute the default action when an appeal request has no
actions defined. 🤖
- StudentAppealAction-getActionRequests
- Should return only the requests that include the matching action type.
🤖
- Should include requests without actions only when the action type is
the DEFAULT one (CreateStudentAppealAssessment). 🤖
- StudentAppealAction-hasApprovedAction
- Should throw an error when there are no associated requests for the
action. 🤖
- Should return true when at least one associated request is approved. 🤖
- Should return false when there are associated requests but none is
approved. 🤖

_Note:_ The 🤖 indicates AI-generated-ish tests 😉 

## E2E tests

- StudentAppealAESTController(e2e)-approveStudentAppealRequests
- Should approve student appeal requests and add note when the appeal
with appeal requests submitted for approval are in pending status. 🆙
  - Modified independent appeal
- Should update the student profile modified independent status as
Approved when a valid modified independent appeal is assessed. 🆕
- Should update the student profile modified independent status as
Declined when a valid modified independent appeal is assessed. 🆕

- StudentAppealStudentsController(e2e)-submitStudentAppeal 🆕 
- Should create a student-only appeal and a Ministry notification for
modified independent when the submission is valid.
- Should throw an unprocessable entity error for a student-only appeal
submission when the same appeal request type is pending review from the
Ministry.
- Should throw a bad request error for a student-only appeal submission
when the form data is invalid.
- Should throw a bad request error for a student-only appeal submission
when the form path name is invalid.

## Fixes

- Adjusted the note type to be saved as "General" for a student-only
appeal.
- Fixed the wrong appeal request used to update the student profile. It
was using the student appeal ID instead of the appeal request ID.

Author: andrewsignori-aot

sims.code-workspace

@@ -205,6 +205,7 @@
       "postalcode",
       "PPDA",
       "PSFS",
+      "PSTPDT",
       "PTSSR",
       "PTWTHD",
       "roomandboardcostsappeal",

sources/packages/backend/apps/api/src/route-controllers/index.ts

@@ -30,6 +30,7 @@ export * from "./institution/institution.controller.service";
 export * from "./student/student.controller.service";
 export * from "./student/student.aest.controller";
 export * from "./student/student.students.controller";
+export * from "./student-appeal/models/student-appeal.dto";
 export * from "./student-appeal/student-appeal.students.controller";
 export * from "./student-appeal/student-appeal.aest.controller";
 export * from "./assessment/assessment.aest.controller";

sources/packages/backend/apps/api/src/route-controllers/student-appeal/_tests_/e2e/student-appeal.aest.controller.approveStudentAppealRequests.e2e-spec.ts

@@ -13,20 +13,34 @@ import {
   createFakeStudentAppeal,
   createFakeStudentAppealRequest,
   saveFakeApplicationDisbursements,
+  saveFakeStudent,
 } from "@sims/test-utils";
-import { ApplicationStatus, StudentAppealStatus } from "@sims/sims-db";
-import { StudentAppealApprovalAPIInDTO } from "apps/api/src/route-controllers/student-appeal/models/student-appeal.dto";
+import {
+  ApplicationStatus,
+  AssessmentTriggerType,
+  ModifiedIndependentStatus,
+  NoteType,
+  StudentAppealActionType,
+  StudentAppealStatus,
+} from "@sims/sims-db";
+import { StudentAppealApprovalAPIInDTO } from "../../../../route-controllers";
+import MockDate from "mockdate";
 
 describe("StudentAppealAESTController(e2e)-approveStudentAppealRequests", () => {
   let app: INestApplication;
   let db: E2EDataSources;
+  const MODIFIED_INDEPENDENT_APPEAL = "modifiedindependentappeal";
 
   beforeAll(async () => {
     const { nestApplication, dataSource } = await createTestingAppModule();
     app = nestApplication;
     db = createE2EDataSources(dataSource);
   });
 
+  beforeEach(async () => {
+    MockDate.reset();
+  });
+
   it("Should approve student appeal requests and add note when the appeal with appeal requests submitted for approval are in pending status.", async () => {
     // Arrange
     // Create a completed application to request change.
@@ -45,60 +59,197 @@ describe("StudentAppealAESTController(e2e)-approveStudentAppealRequests", () =>
       appealRequests: [appealRequest],
     });
     await db.studentAppeal.save(appeal);
-    const [savedAppealRequest] = appeal.appealRequests;
 
     const endpoint = `/aest/appeal/${appeal.id}/requests`;
     const token = await getAESTToken(AESTGroups.BusinessAdministrators);
     const payload: StudentAppealApprovalAPIInDTO = {
       requests: [
         {
-          id: savedAppealRequest.id,
+          id: appealRequest.id,
           appealStatus: StudentAppealStatus.Approved,
           noteDescription: "Approved",
         },
       ],
     };
+    const now = new Date();
+    MockDate.set(now);
 
     // Act/Assert
     await request(app.getHttpServer())
       .patch(endpoint)
       .send(payload)
       .auth(token, BEARER_AUTH_TYPE)
-      .expect(HttpStatus.OK)
-      .expect({});
+      .expect(HttpStatus.OK);
     // Check for the appeal and appeal requests in the database.
     const updatedAppeal = await db.studentAppeal.findOne({
       select: {
         id: true,
         appealRequests: {
           id: true,
           appealStatus: true,
+          assessedDate: true,
           assessedBy: { id: true },
-          note: { description: true },
+          note: { description: true, noteType: true },
         },
+        studentAssessment: { id: true, triggerType: true },
+      },
+      relations: {
+        appealRequests: { assessedBy: true, note: true },
+        studentAssessment: true,
       },
-      relations: { appealRequests: { assessedBy: true, note: true } },
       where: { id: appeal.id },
     });
     // Approving ministry user.
     const ministryUser = await getAESTUser(
       db.dataSource,
       AESTGroups.BusinessAdministrators,
     );
-    // Asset updated appeal and appeal request.
+    // Assert updated appeal and appeal request.
     expect(updatedAppeal).toEqual({
       id: appeal.id,
+      studentAssessment: {
+        id: expect.any(Number),
+        triggerType: AssessmentTriggerType.StudentAppeal,
+      },
       appealRequests: [
         {
-          id: savedAppealRequest.id,
+          id: appealRequest.id,
           appealStatus: StudentAppealStatus.Approved,
+          assessedDate: now,
           assessedBy: { id: ministryUser.id },
-          note: { description: "Approved" },
+          note: { description: "Approved", noteType: NoteType.Application },
         },
       ],
     });
   });
 
+  describe("Modified independent appeal", () => {
+    for (const modifiedIndependentStatus of [
+      ModifiedIndependentStatus.Approved,
+      ModifiedIndependentStatus.Declined,
+    ]) {
+      it(`Should update the student profile modified independent status as ${modifiedIndependentStatus} when a valid modified independent appeal is assessed.`, async () => {
+        // Arrange
+        // Create a completed application to request change.
+        const student = await saveFakeStudent(db.dataSource);
+        // Create pending student appeal.
+        const appealRequest = createFakeStudentAppealRequest(undefined, {
+          initialValues: {
+            appealStatus: StudentAppealStatus.Pending,
+            submittedFormName: MODIFIED_INDEPENDENT_APPEAL,
+            submittedData: {
+              actions: [StudentAppealActionType.UpdateModifiedIndependent],
+            },
+          },
+        });
+        const appeal = createFakeStudentAppeal({
+          student,
+          appealRequests: [appealRequest],
+        });
+        await db.studentAppeal.save(appeal);
+        const endpoint = `/aest/appeal/${appeal.id}/requests`;
+        const token = await getAESTToken(AESTGroups.BusinessAdministrators);
+        const appealStatus =
+          modifiedIndependentStatus === ModifiedIndependentStatus.Approved
+            ? StudentAppealStatus.Approved
+            : StudentAppealStatus.Declined;
+        const noteDescription = `Assessed as ${modifiedIndependentStatus}`;
+        const payload: StudentAppealApprovalAPIInDTO = {
+          requests: [
+            {
+              id: appealRequest.id,
+              appealStatus,
+              noteDescription,
+            },
+          ],
+        };
+        const now = new Date();
+        MockDate.set(now);
+
+        // Act/Assert
+        await request(app.getHttpServer())
+          .patch(endpoint)
+          .send(payload)
+          .auth(token, BEARER_AUTH_TYPE)
+          .expect(HttpStatus.OK);
+        // Check for the appeal and appeal requests in the database.
+        const updatedAppeal = await db.studentAppeal.findOne({
+          select: {
+            id: true,
+            student: {
+              id: true,
+              modifiedIndependentStatus: true,
+              modifiedIndependentAppealRequest: { id: true },
+              modifiedIndependentStatusUpdatedBy: { id: true },
+              modifiedIndependentStatusUpdatedOn: true,
+              modifier: { id: true },
+              updatedAt: true,
+            },
+            appealRequests: {
+              id: true,
+              appealStatus: true,
+              assessedBy: { id: true },
+              assessedDate: true,
+              modifier: { id: true },
+              updatedAt: true,
+              note: { id: true, description: true, noteType: true },
+            },
+            application: { id: true },
+            studentAssessment: { id: true },
+          },
+          relations: {
+            student: {
+              modifiedIndependentAppealRequest: true,
+              modifiedIndependentStatusUpdatedBy: true,
+              modifier: true,
+            },
+            appealRequests: { assessedBy: true, note: true, modifier: true },
+            application: true,
+            studentAssessment: true,
+          },
+          where: { id: appeal.id },
+          loadEagerRelations: false,
+        });
+        // Approving ministry user.
+        const ministryUser = await getAESTUser(
+          db.dataSource,
+          AESTGroups.BusinessAdministrators,
+        );
+        // Assert updated appeal, appeal request, and student profile.
+        const auditUser = { id: ministryUser.id };
+        expect(updatedAppeal).toEqual({
+          id: appeal.id,
+          application: null,
+          studentAssessment: null,
+          student: {
+            id: student.id,
+            modifiedIndependentStatus,
+            modifiedIndependentAppealRequest: { id: appealRequest.id },
+            modifiedIndependentStatusUpdatedBy: auditUser,
+            modifiedIndependentStatusUpdatedOn: now,
+            modifier: auditUser,
+            updatedAt: now,
+          },
+          appealRequests: [
+            {
+              id: appealRequest.id,
+              appealStatus,
+              assessedDate: now,
+              assessedBy: auditUser,
+              modifier: auditUser,
+              updatedAt: now,
+              note: {
+                id: expect.any(Number),
+                description: noteDescription,
+                noteType: NoteType.General,
+              },
+            },
+          ],
+        });
+      });
+    }
+  });
+
   afterAll(async () => {
     await app?.close();
   });