#1724 - E2E/Units Tests - Review Queue Consumers E2E Tests

sources/packages/backend/apps/api/src/testHelpers/index.ts

@@ -3,8 +3,6 @@ export * from "./moked-http-contexts/http-context-mock";
 export * from "./moked-http-contexts/reflector-mock";
 export * from "./auth/token-helpers";
 export * from "./mocked-providers/jwt-service-mock";
-export * from "./mocked-providers/queue-module-mock";
-export * from "./mocked-providers/zeebe-client-mock";
 export * from "./testing-modules/testing-modules-helper";
 export * from "./auth";
 export * from "./fake-entities";

sources/packages/backend/apps/api/src/testHelpers/testing-modules/testing-modules-helper.ts

@@ -4,8 +4,13 @@ import { DataSource } from "typeorm";
 import { AppModule } from "../../app.module";
 import { KeycloakConfig } from "../../auth";
 import { setGlobalPipes } from "../../utilities";
-import { MockedQueueModule } from "../mocked-providers/queue-module-mock";
-import { createMockedZeebeModule } from "../mocked-providers/zeebe-client-mock";
+import {
+  QueueModuleMock,
+  createZeebeModuleMock,
+  overrideImportsMetadata,
+} from "@sims/test-utils";
+import { QueueModule } from "@sims/services/queue";
+import { ZeebeModule } from "@sims/services";
 
 /**
  * Result from a createTestingModule to support E2E tests creation.
@@ -21,9 +26,20 @@ export class CreateTestingModuleResult {
  * @returns creation results with objects to support E2E tests.
  */
 export async function createTestingAppModule(): Promise<CreateTestingModuleResult> {
+  overrideImportsMetadata(
+    AppModule,
+    {
+      replace: QueueModule,
+      by: QueueModuleMock,
+    },
+    {
+      replace: ZeebeModule,
+      by: createZeebeModuleMock(),
+    },
+  );
   await KeycloakConfig.load();
   const module: TestingModule = await Test.createTestingModule({
-    imports: [AppModule, createMockedZeebeModule(), MockedQueueModule],
+    imports: [AppModule],
   }).compile();
   const nestApplication = module.createNestApplication();
   setGlobalPipes(nestApplication);

sources/packages/backend/apps/api/test/auth.e2e-spec.ts

@@ -9,7 +9,7 @@ import {
 } from "../src/utilities/certificate-utils";
 import { AuthTestController } from "../src/testHelpers/controllers/auth-test/auth-test.controller";
 import { KeycloakService } from "../src/services/auth/keycloak/keycloak.service";
-import { createMockedZeebeModule } from "../src/testHelpers/mocked-providers/zeebe-client-mock";
+import { createZeebeModuleMock } from "@sims/test-utils";
 
 describe("Authentication (e2e)", () => {
   // Nest application to be shared for all e2e tests
@@ -41,7 +41,7 @@ describe("Authentication (e2e)", () => {
     aestAccessToken = aestToken.access_token;
 
     const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [AppModule, createMockedZeebeModule()],
+      imports: [AppModule, createZeebeModuleMock()],
       // AuthTestController is used only for e2e tests and could be
       // changed as needed to implement more test scenarios.
       controllers: [AuthTestController],

sources/packages/backend/apps/queue-consumers/src/processors/assessment/_tests_/cancel-application-assessment.processor.e2e-spec.ts

@@ -0,0 +1,195 @@
+import { ZBClient } from "zeebe-node";
+import { Job } from "bull";
+import { createMock } from "@golevelup/ts-jest";
+import { INestApplication } from "@nestjs/common";
+import { CancelAssessmentQueueInDTO } from "@sims/services/queue";
+import { QueueNames } from "@sims/utilities";
+import {
+  createTestingAppModule,
+  describeProcessorRootTest,
+} from "../../../../test/helpers";
+import { CancelApplicationAssessmentProcessor } from "../cancel-application-assessment.processor";
+import { DataSource, Repository } from "typeorm";
+import {
+  createFakeDisbursementOveraward,
+  saveFakeApplicationDisbursements,
+} from "@sims/test-utils";
+import {
+  ApplicationStatus,
+  DisbursementOveraward,
+  DisbursementSchedule,
+  DisbursementScheduleStatus,
+  StudentAssessment,
+} from "@sims/sims-db";
+import * as faker from "faker";
+
+describe(
+  describeProcessorRootTest(QueueNames.CancelApplicationAssessment),
+  () => {
+    let app: INestApplication;
+    let processor: CancelApplicationAssessmentProcessor;
+    let zbClientMock: ZBClient;
+    let appDataSource: DataSource;
+    let studentAssessmentRepo: Repository<StudentAssessment>;
+    let disbursementOverawardRepo: Repository<DisbursementOveraward>;
+    let disbursementScheduleRepo: Repository<DisbursementSchedule>;
+
+    beforeAll(async () => {
+      const { nestApplication, dataSource, zbClient } =
+        await createTestingAppModule();
+      app = nestApplication;
+      zbClientMock = zbClient;
+      appDataSource = dataSource;
+      studentAssessmentRepo = dataSource.getRepository(StudentAssessment);
+      disbursementOverawardRepo = dataSource.getRepository(
+        DisbursementOveraward,
+      );
+      disbursementScheduleRepo = dataSource.getRepository(DisbursementSchedule);
+      // Processor under test.
+      processor = app.get(CancelApplicationAssessmentProcessor);
+    });
+
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it("Should cancel the assessment pending disbursements and rollback overawards when the cancelled application has overawards and also one sent and one pending disbursements.", async () => {
+      // Arrange
+      const workflowInstanceId = faker.random
+        .number({
+          min: 1000000000,
+          max: 9999999999,
+        })
+        .toString();
+      // Application and disbursements.
+      const application = await saveFakeApplicationDisbursements(
+        appDataSource,
+        null,
+        {
+          applicationStatus: ApplicationStatus.Cancelled,
+          createSecondDisbursement: true,
+        },
+      );
+      // Adjust assessment.
+      const studentAssessment = application.currentAssessment;
+      studentAssessment.assessmentWorkflowId = workflowInstanceId;
+      await studentAssessmentRepo.save(application.currentAssessment);
+      // Adjust disbursements.
+      const [firstDisbursement, secondDisbursement] =
+        studentAssessment.disbursementSchedules;
+      firstDisbursement.disbursementScheduleStatus =
+        DisbursementScheduleStatus.Sent;
+      await disbursementScheduleRepo.save(firstDisbursement);
+      // Add a student overaward.
+      const overaward = createFakeDisbursementOveraward({
+        student: application.student,
+        studentAssessment,
+      });
+      await disbursementOverawardRepo.save(overaward);
+      // Queued job.
+      const job = createMock<Job<CancelAssessmentQueueInDTO>>({
+        data: { assessmentId: studentAssessment.id },
+      });
+
+      // Act
+      const result = await processor.cancelAssessment(job);
+
+      // Assert
+      expect(zbClientMock.cancelProcessInstance).toBeCalledWith(
+        workflowInstanceId,
+      );
+      expect(result.summary).toStrictEqual([
+        `Cancelling application assessment id ${studentAssessment.id}`,
+        `Found workflow id ${workflowInstanceId}.`,
+        "Workflow instance successfully cancelled.",
+        "Rolling back overawards, if any.",
+        "Assessment cancelled with success.",
+      ]);
+
+      // Assert that overawards were soft deleted.
+      const updatedOveraward = await disbursementOverawardRepo.findOne({
+        where: { id: overaward.id },
+        withDeleted: true,
+      });
+      expect(updatedOveraward.deletedAt).toBeDefined();
+
+      // Assert sent disbursement was not affected.
+      const firstDisbursementUpdated = await disbursementScheduleRepo.findOneBy(
+        { id: firstDisbursement.id },
+      );
+      expect(firstDisbursementUpdated.disbursementScheduleStatus).toBe(
+        DisbursementScheduleStatus.Sent,
+      );
+
+      // Assert pending disbursement was cancelled.
+      const secondDisbursementUpdated =
+        await disbursementScheduleRepo.findOneBy({ id: secondDisbursement.id });
+      expect(secondDisbursementUpdated.disbursementScheduleStatus).toBe(
+        DisbursementScheduleStatus.Cancelled,
+      );
+    });
+
+    it("Should cancel the assessment and log a warning when the workflowInstanceId is not present.", async () => {
+      // Arrange
+      const application = await saveFakeApplicationDisbursements(
+        appDataSource,
+        null,
+        { applicationStatus: ApplicationStatus.Overwritten },
+      );
+      const studentAssessment = application.currentAssessment;
+      // Queued job.
+      const job = createMock<Job<CancelAssessmentQueueInDTO>>({
+        data: { assessmentId: studentAssessment.id },
+      });
+
+      // Act
+      const result = await processor.cancelAssessment(job);
+
+      // Assert
+      expect(zbClientMock.cancelProcessInstance).not.toHaveBeenCalled();
+      expect(result.warnings).toContain(
+        "Assessment was queued to be cancelled but there is no workflow id associated with.",
+      );
+      expect(result.summary).toContain("Assessment cancelled with success.");
+    });
+
+    it("Should throw an error and call job.discard when the application is not in the expected status.", async () => {
+      // Arrange
+      const errorMessage = `Application must be in the ${ApplicationStatus.Cancelled} or ${ApplicationStatus.Overwritten} state to have the assessment cancelled.`;
+      const expectedError = new Error(errorMessage);
+      const application = await saveFakeApplicationDisbursements(
+        appDataSource,
+        null,
+        { applicationStatus: ApplicationStatus.Completed },
+      );
+      const studentAssessment = application.currentAssessment;
+      // Queued job.
+      const job = createMock<Job<CancelAssessmentQueueInDTO>>({
+        data: { assessmentId: studentAssessment.id },
+      });
+
+      // Act and Assert
+      await expect(processor.cancelAssessment(job)).rejects.toStrictEqual(
+        expectedError,
+      );
+      expect(job.discard).toBeCalled();
+    });
+
+    it("Should throw an error and call job.discard when the assessment id was not found.", async () => {
+      // Arrange
+      const assessmentId = 9999;
+      const errorMessage = `Assessment id ${assessmentId} was not found.`;
+      const error = new Error(errorMessage);
+      // Queued job.
+      const job = createMock<Job<CancelAssessmentQueueInDTO>>({
+        data: { assessmentId },
+      });
+
+      // Act and Assert
+      await expect(processor.cancelAssessment(job)).rejects.toStrictEqual(
+        error,
+      );
+      expect(job.discard).toBeCalled();
+    });
+  },
+);

sources/packages/backend/apps/queue-consumers/src/processors/assessment/_tests_/start-application-assessment.processor.e2e-spec.ts

@@ -0,0 +1,67 @@
+import { ZBClient } from "zeebe-node";
+import { Job } from "bull";
+import { createMock } from "@golevelup/ts-jest";
+import { INestApplication } from "@nestjs/common";
+import { StartApplicationAssessmentProcessor } from "../start-application-assessment.processor";
+import { StartAssessmentQueueInDTO } from "@sims/services/queue";
+import { QueueNames } from "@sims/utilities";
+import {
+  createTestingAppModule,
+  describeProcessorRootTest,
+} from "../../../../test/helpers";
+
+describe(
+  describeProcessorRootTest(QueueNames.StartApplicationAssessment),
+  () => {
+    let app: INestApplication;
+    let processor: StartApplicationAssessmentProcessor;
+    let zbClientMock: ZBClient;
+
+    beforeAll(async () => {
+      const { nestApplication, zbClient } = await createTestingAppModule();
+      app = nestApplication;
+      zbClientMock = zbClient;
+      // Processor under test.
+      processor = app.get(StartApplicationAssessmentProcessor);
+    });
+
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it("Should throw an error when the workflow createProcessInstance method throws an error.", async () => {
+      // Arrange
+      const dummyException = new Error("Dummy error");
+      const job = createMock<Job<StartAssessmentQueueInDTO>>();
+      zbClientMock.createProcessInstance = jest.fn().mockImplementation(() => {
+        throw dummyException;
+      });
+
+      // Act and Assert.
+      await expect(processor.startAssessment(job)).rejects.toBe(dummyException);
+    });
+
+    it("Should invoke the workflow create instance method with the received job parameters.", async () => {
+      // Arrange
+      const workflowName = "dummy workflow name";
+      const assessmentId = 999;
+      const variables = { assessmentId };
+      // Queued job.
+      const job = createMock<Job<StartAssessmentQueueInDTO>>({
+        data: {
+          workflowName,
+          assessmentId,
+        },
+      });
+
+      // Act
+      await processor.startAssessment(job);
+
+      // Assert
+      expect(zbClientMock.createProcessInstance).toHaveBeenCalledWith(
+        workflowName,
+        variables,
+      );
+    });
+  },
+);