chore: add pdf-parse for obligation invoice

Author: shon-button

bciers/apps/compliance-e2e/poms/manage-obligation/obligation-invoice.ts

@@ -0,0 +1,58 @@
+import { expect } from "@playwright/test";
+import { PDFParse } from "pdf-parse";
+import {
+  INVOICE_VOID_WATERMARK_REGEX,
+  FEES_AND_ADJUSTMENTS_TEXT,
+  INVOICE_NUMBER_LABEL_REGEX,
+  DEFAULT_ADJUSTMENT_REGEX,
+} from "@/compliance-e2e/utils/constants";
+
+export class ObligationInvoicePOM {
+  private constructor(
+    private readonly parsed: any,
+    private readonly text: string,
+  ) {}
+
+  static async fromBuffer(buffer: Buffer): Promise<ObligationInvoicePOM> {
+    const parser = new PDFParse({ data: buffer });
+    const parsed = await parser.getText();
+
+    const normalizedText = String(parsed?.text ?? "")
+      .replace(/\s+/g, " ")
+      .trim();
+
+    return new ObligationInvoicePOM(parsed, normalizedText);
+  }
+
+  // -----------------------
+  // Assertions (Chainable)
+  // -----------------------
+
+  assertNotVoid(): this {
+    expect(this.text).not.toMatch(INVOICE_VOID_WATERMARK_REGEX);
+    return this;
+  }
+
+  assertHasFeesAndAdjustments(): this {
+    expect(this.text).toContain(FEES_AND_ADJUSTMENTS_TEXT);
+    return this;
+  }
+
+  assertHasAdjustmentLine(matcher: RegExp = DEFAULT_ADJUSTMENT_REGEX): this {
+    expect(this.text).toMatch(matcher);
+    return this;
+  }
+
+  assertHasInvoiceNumber(): this {
+    expect(this.text).toMatch(INVOICE_NUMBER_LABEL_REGEX);
+    return this;
+  }
+
+  // -----------------------
+  // Getters
+  // -----------------------
+
+  getText(): string {
+    return this.text;
+  }
+}

bciers/apps/compliance-e2e/tests/workflows/manage-obligation/supplementary/decrease.spec.ts

@@ -10,6 +10,8 @@ import { ComplianceSummariesPOM } from "@/compliance-e2e/poms/compliance-summari
 import { ComplianceSetupPOM } from "@/compliance-e2e/poms/compliance-setup";
 import { ReportSetUpPOM } from "@/reporting-e2e/poms/report-setup";
 import { REVIEW_OBLIGATION_URL_PATTERN } from "@/compliance-e2e/utils/constants";
+import { ReviewComplianceObligationPOM } from "@/compliance-e2e/poms/manage-obligation/review-compliance-obligation";
+import { ObligationInvoicePOM } from "@/compliance-e2e/poms/manage-obligation/obligation-invoice";
 
 // 👤 run test using the storageState for role UserRole.INDUSTRY_USER_ADMIN
 const test = setupBeforeEachTest(UserRole.INDUSTRY_USER_ADMIN);
@@ -43,26 +45,26 @@ test.describe("Test supplementary compliance report version flow", () => {
     });
 
     // Assert BEFORE generate invoice
+    const reviewObligationPOM = new ReviewComplianceObligationPOM(page);
     // Open summary and generate invoice
     await gridComplianceSummaries.openActionForOperation({
       operationName: ComplianceOperations.OBLIGATION_NOT_MET,
       linkName: GridActionText.MANAGE_OBLIGATION,
       urlPattern: REVIEW_OBLIGATION_URL_PATTERN,
     });
-    // const reviewObligationPOM = new ReviewComplianceObligationPOM(page);
     // Capture invoice pdf as buffer
-    // const pdfBuffer = await reviewObligationPOM.generateInvoiceAndGetPdfBuffer(
-    //   2,
-    //   "obligation",
-    // );
-    // // create invoice object from buffer
-    // const invoice = await ObligationInvoicePOM.fromBuffer(pdfBuffer);
+    const pdfBuffer = await reviewObligationPOM.generateInvoiceAndGetPdfBuffer(
+      2,
+      "obligation",
+    );
+    // create invoice object from buffer
+    const invoice = await ObligationInvoicePOM.fromBuffer(pdfBuffer);
 
-    // invoice
-    //   .assertHasInvoiceNumber()
-    //   .assertHasFeesAndAdjustments()
-    //   .assertHasAdjustmentLine()
-    //   .assertNotVoid();
+    invoice
+      .assertHasInvoiceNumber()
+      .assertHasFeesAndAdjustments()
+      .assertHasAdjustmentLine()
+      .assertNotVoid();
 
     // Submit supplementary decrease
     await gridReportingReports.route();

bciers/libs/e2e/src/utils/helpers.ts

@@ -8,7 +8,7 @@ import {
   webkit,
   Browser,
 } from "@playwright/test";
-import { baseUrlSetup } from "@bciers/e2e/utils/constants";
+import { baseUrlSetup, GRID_ROOT } from "@bciers/e2e/utils/constants";
 import { DataTestID, MessageTextResponse } from "@bciers/e2e/utils/enums";
 import AxeBuilder from "@axe-core/playwright";
 import path from "node:path";
@@ -33,14 +33,21 @@ export async function analyzeAccessibility(
   expect(accessibilityScanResults.violations).toEqual([]);
 }
 
+/**
+ * Clicks a button by accessible name and optionally waits for navigation.
+ * @param page - Playwright Page instance
+ * @param buttonText - Button accessible name or RegExp
+ * @param opts.inForm - Scope the button search to a <form> (default: false)
+ * @param opts.waitForUrl - RegExp to wait for after clicking (optional)
+ */
 export async function clickButton(
   page: Page,
   buttonText: string | RegExp,
   opts?: {
     inForm?: boolean; // default false
     waitForUrl?: RegExp;
   },
-) {
+): Promise<void> {
   const { inForm = false, waitForUrl } = opts ?? {};
 
   const name =
@@ -49,8 +56,18 @@ export async function clickButton(
   const root = inForm ? page.locator("form") : page;
   const button = root.getByRole("button", { name });
 
+  await expect(button).toBeVisible({ timeout: 30_000 });
+  await expect(button).toBeEnabled({ timeout: 30_000 });
+
   if (waitForUrl) {
-    await Promise.all([page.waitForURL(waitForUrl), button.click()]);
+    // Use a lighter wait for SPA navigation
+    await Promise.all([
+      page.waitForURL((u) => waitForUrl.test(u.toString()), {
+        timeout: 30_000,
+        waitUntil: "domcontentloaded",
+      }),
+      button.click(),
+    ]);
   } else {
     await button.click();
   }
@@ -83,6 +100,55 @@ export async function fillDropdownByLabel(
   await input.fill(value);
 }
 
+export async function fillInputValueByLabel(
+  page: Page,
+  label: string | RegExp,
+  value: string | number,
+  opts?: {
+    blur?: "tab" | "enter" | "none"; // default "tab"
+  },
+): Promise<void> {
+  const { blur = "tab" } = opts ?? {};
+
+  const name = label instanceof RegExp ? label : new RegExp(label, "i");
+  const field = page.getByLabel(name);
+
+  await expect(field).toBeVisible({ timeout: 30_000 });
+  await expect(field).toBeEnabled({ timeout: 30_000 });
+
+  await field.click();
+  await field.press("Control+A");
+  await field.press("Backspace");
+
+  await field.fill(String(value));
+
+  if (blur === "tab") await field.press("Tab");
+  if (blur === "enter") await field.press("Enter");
+}
+
+export async function fillInputValueByLocator(
+  field: Locator,
+  value: string | number,
+  opts?: {
+    blur?: "tab" | "enter" | "none"; // default "tab"
+  },
+): Promise<void> {
+  const { blur = "tab" } = opts ?? {};
+
+  await expect(field).toBeVisible({ timeout: 30_000 });
+  await expect(field).toBeEnabled({ timeout: 30_000 });
+
+  // focus and clear field
+  await field.click();
+  await field.press("Control+A");
+  await field.press("Backspace");
+
+  await field.fill(String(value));
+
+  if (blur === "tab") await field.press("Tab");
+  if (blur === "enter") await field.press("Enter");
+}
+
 export async function checkAllRadioButtons(page: Page) {
   const radioButtons = page.getByRole("radio", { name: "Yes" });
   // Wait for at least one radio button to be visible before counting.
@@ -100,6 +166,24 @@ export async function checkAllRadioButtons(page: Page) {
   }
 }
 
+export async function checkCheckboxByLabel(
+  page: Page,
+  label: string | RegExp,
+): Promise<void> {
+  const name = label instanceof RegExp ? label : new RegExp(label, "i");
+
+  const checkbox = page.getByRole("checkbox", { name });
+
+  await expect(checkbox).toBeVisible({ timeout: 30_000 });
+  await expect(checkbox).toBeEnabled({ timeout: 30_000 });
+
+  if (!(await checkbox.isChecked())) {
+    await checkbox.check();
+  }
+
+  await expect(checkbox).toBeChecked();
+}
+
 // 🛠️ Function: checks expected alert message
 export async function checkAlertMessage(
   page: Page,
@@ -231,7 +315,7 @@ export async function tableColumnNamesAreCorrect(
   expectedColumnNames: string[],
 ) {
   const columnHeaders = page.locator(".MuiDataGrid-columnHeaderTitle");
-  const actualColumnNames = await columnHeaders.allTextContents();
+  const actualColumnNames = await columnHeaders.getByText();
   expect(actualColumnNames).toEqual(expectedColumnNames);
 }
 
@@ -525,3 +609,60 @@ export function getCrvIdFromUrl({ url }: { url: string }): number {
   if (!match) throw new Error(`Could not extract crvId from URL: ${url}`);
   return Number(match[1]);
 }
+
+/**
+ * Wait until the grid is actually "ready":
+ * - GRID_ROOT exists
+ * - root + role=grid visible
+ * - (optional) progressbar/spinner is gone
+ * - at least one gridcell exists
+ *
+ * Tolerates re-mounts (e.g. HMR) with re-check of counts on every attempt
+ */
+export async function waitForGridReady(
+  page: Page,
+  options?: { timeout?: number },
+): Promise<void> {
+  const timeout = options?.timeout ?? 30_000;
+
+  await expect(async () => {
+    const rootCount = await page.locator(GRID_ROOT).count();
+    expect(rootCount).toBeGreaterThan(0);
+
+    const grid = page.locator(GRID_ROOT);
+    await expect(grid).toBeVisible();
+
+    const progressbar = grid.locator('[role="progressbar"]');
+    const anyCell = grid.locator('[role="gridcell"]').first();
+
+    if ((await progressbar.count()) > 0) {
+      await expect(progressbar).toBeHidden();
+    }
+
+    await expect(anyCell).toBeVisible();
+  }).toPass({ timeout });
+}
+
+export async function getGridRowByText(
+  page: Page,
+  rowText: string | RegExp,
+): Promise<Locator> {
+  await waitForGridReady(page, { timeout: 30_000 });
+
+  const grid = page.locator(GRID_ROOT).first().locator('[role="grid"]').first();
+  const row = grid.getByRole("row").filter({ hasText: rowText }).first();
+
+  await expect(async () => {
+    const matchingRowCount = await row.count();
+    const totalRowCount = await grid.getByRole("row").count();
+
+    expect(totalRowCount).toBeGreaterThan(0);
+    expect(matchingRowCount).toBeGreaterThan(0);
+    await expect(row).toBeVisible();
+
+    const cellCount = await row.locator('[role="gridcell"]').count();
+    expect(cellCount).toBeGreaterThan(0);
+  }).toPass({ timeout: 30_000 });
+
+  return row;
+}