feat: inject error logs on all test

tests/govtool-frontend/playwright/lib/constants/staticWallets.ts

@@ -25,6 +25,7 @@ export const proposal05Wallet: StaticWallet = staticWallets[14];
 export const proposal06Wallet: StaticWallet = staticWallets[15];
 export const proposal07Wallet: StaticWallet = staticWallets[16];
 export const proposal08Wallet: StaticWallet = staticWallets[17];
+export const proposal09Wallet: StaticWallet = staticWallets[18];
 
 export const adaHolderWallets = [
   adaHolder01Wallet,
@@ -48,6 +49,7 @@ export const proposalWallets = [
   proposal06Wallet,
   proposal07Wallet,
   proposal08Wallet,
+  proposal09Wallet,
 ];
 
 export const allStaticWallets = [

tests/govtool-frontend/playwright/lib/fixtures/walletExtension.ts

@@ -2,6 +2,7 @@ import { test as base } from "@playwright/test";
 import { StaticWallet } from "@types";
 import { importWallet } from "./importWallet";
 import loadDemosExtension from "./loadExtension";
+import { injectLogger } from "@helpers/page";
 
 type WalletExtensionTestOptions = {
   wallet?: StaticWallet;
@@ -25,6 +26,7 @@ export const test = base.extend<WalletExtensionTestOptions>({
     if (wallet) {
       await importWallet(page, wallet);
     }
+    injectLogger(page);
 
     await use(page);
   },

tests/govtool-frontend/playwright/lib/helpers/adaFormat.ts

@@ -20,3 +20,12 @@ export const correctVoteAdaFormat = (
   }
   return "0";
 };
+
+export const correctDelegatedVoteAdaFormat = (ada: number | undefined) => {
+  if (ada) {
+    return ada.toLocaleString("en-us", {
+      maximumFractionDigits: 3,
+    });
+  }
+  return "0";
+};

tests/govtool-frontend/playwright/lib/helpers/auth.ts

@@ -3,11 +3,17 @@ import { valid as mockValid } from "@mock/index";
 import LoginPage from "@pages/loginPage";
 import ProposalDiscussionPage from "@pages/proposalDiscussionPage";
 import { BrowserContext, Page } from "@playwright/test";
-import { StaticWallet } from "@types";
+import { ProposalType, StaticWallet } from "@types";
 import { ShelleyWallet } from "./crypto";
 import convertBufferToHex from "./convertBufferToHex";
 import { updateWalletConfig } from "@fixtures/createWallet";
-import { adaHolder05Wallet } from "@constants/staticWallets";
+import {
+  adaHolder05Wallet,
+  proposal05Wallet,
+  proposal07Wallet,
+  proposal08Wallet,
+  proposal09Wallet,
+} from "@constants/staticWallets";
 
 interface CreateUserProps {
   page: Page;
@@ -80,3 +86,28 @@ export async function createAuthWithMultipleStake({
 
   await context.storageState({ path: auth });
 }
+
+export const getDraftProposalWalletAndState = (proposalType: string) => {
+  switch (proposalType) {
+    case ProposalType.info:
+      return {
+        storageState: ".auth/proposal05.json",
+        wallet: proposal05Wallet,
+      };
+    case ProposalType.treasury:
+      return {
+        storageState: ".auth/proposal07.json",
+        wallet: proposal07Wallet,
+      };
+    case ProposalType.updatesToTheConstitution:
+      return {
+        storageState: ".auth/proposal08.json",
+        wallet: proposal08Wallet,
+      };
+    case ProposalType.motionOfNoConfedence:
+      return {
+        storageState: ".auth/proposal09.json",
+        wallet: proposal09Wallet,
+      };
+  }
+};

tests/govtool-frontend/playwright/lib/helpers/exceptionHandler.ts

@@ -11,20 +11,3 @@ export async function expectWithInfo(
     throw new Error(errorMessage);
   }
 }
-
-export async function failureWithConsoleMessages(page: Page, fn: Function) {
-  const consoleMessages: string[] = [];
-  page.on("console", (msg) => {
-    if (msg.type() === "error") {
-      consoleMessages.push(msg.text());
-    }
-  });
-  try {
-    await fn();
-  } catch (error) {
-    Logger.fail(
-      `Failed: ${error.message}\nConsole messages: ${consoleMessages.join("\n")}`
-    );
-    throw error;
-  }
-}

tests/govtool-frontend/playwright/lib/helpers/page.ts

@@ -1,8 +1,8 @@
-import { CardanoTestWallet } from "@cardanoapi/cardano-test-wallet/types";
 import { importWallet } from "@fixtures/importWallet";
 import loadDemosExtension from "@fixtures/loadExtension";
-import { Browser, Page } from "@playwright/test";
+import { Browser, ConsoleMessage, Page } from "@playwright/test";
 import { StaticWallet } from "@types";
+import { Logger } from "./logger";
 
 interface NewPageConfig {
   storageState?: string;
@@ -29,5 +29,20 @@ export async function createNewPageWithWallet(
   );
   await importWallet(newPage, wallet);
 
+  injectLogger(newPage);
+
   return newPage;
 }
+
+export function injectLogger(page: Page) {
+  // @ts-ignore
+  if (!page.isLoggerInjected) {
+    page.on("console", (msg: ConsoleMessage) => {
+      if (msg.type() === "error") {
+        Logger.fail(msg.text());
+      }
+    });
+    // @ts-ignore
+    page.isLoggerInjected = true;
+  }
+}

tests/govtool-frontend/playwright/lib/helpers/transaction.ts

@@ -7,6 +7,7 @@ import { ShelleyWallet } from "./crypto";
 import { uploadMetadataAndGetJsonHash } from "./metadata";
 import { WalletAndAnchorType } from "@types";
 import { Logger } from "@helpers/logger";
+import { functionWaitedAssert } from "./waitedLoop";
 
 /**
  * Polls the transaction status until it's resolved or times out.
@@ -16,43 +17,48 @@ export async function pollTransaction(
   txHash: string,
   lockInfo?: LockInterceptorInfo
 ) {
-  try {
-    Logger.info(`Waiting for tx completion: ${txHash}`);
-    await expect
-      .poll(
-        async () => {
-          const response = await kuberService.getTransactionDetails(txHash);
-          const data = await response.json();
-          return data.length;
-        },
-        {
-          timeout: environments.txTimeOut,
-        }
-      )
-      .toBeGreaterThan(0);
+  await functionWaitedAssert(
+    async () => {
+      try {
+        Logger.info(`Waiting for tx completion: ${txHash}`);
+        await expect
+          .poll(
+            async () => {
+              const response = await kuberService.getTransactionDetails(txHash);
+              const data = await response.json();
+              return data.length;
+            },
+            {
+              timeout: environments.txTimeOut,
+            }
+          )
+          .toBeGreaterThan(0);
 
-    Logger.success("Tx completed");
+        Logger.success("Tx completed");
 
-    if (!lockInfo) return;
+        if (!lockInfo) return;
 
-    await LockInterceptor.releaseLock(
-      lockInfo.initiator,
-      lockInfo.lockId,
-      `Task completed for:${lockInfo.lockId}`
-    );
-  } catch (err) {
-    if (lockInfo) {
-      const errorMessage = { lockInfo, error: JSON.stringify(err) };
-
-      await LockInterceptor.releaseLock(
-        lockInfo.initiator,
-        lockInfo.lockId,
-        `Task failure: \n${JSON.stringify(errorMessage)}`
-      );
-    }
+        await LockInterceptor.releaseLock(
+          lockInfo.initiator,
+          lockInfo.lockId,
+          `Task completed for:${lockInfo.lockId}`
+        );
+      } catch (err) {
+        if (lockInfo) {
+          const errorMessage = { lockInfo, error: JSON.stringify(err) };
 
-    throw err;
-  }
+          await LockInterceptor.releaseLock(
+            lockInfo.initiator,
+            lockInfo.lockId,
+            `Task failure: \n${JSON.stringify(errorMessage)}`
+          );
+        }
+        Logger.fail(`Failed due to ${err}`);
+        throw err;
+      }
+    },
+    { timeout: environments.txTimeOut + 60_000, name: "pollTransaction" }
+  );
 }
 
 export async function waitForTxConfirmation(

tests/govtool-frontend/playwright/lib/helpers/waitedLoop.ts

@@ -1,3 +1,6 @@
+import { expect } from "@playwright/test";
+import { Logger } from "./logger";
+
 export async function waitedLoop(
   conditionFn,
   timeout = 60000,
@@ -6,31 +9,36 @@ export async function waitedLoop(
   const startTime = Date.now();
   while (Date.now() - startTime < timeout) {
     if (await conditionFn()) return true;
+    Logger.info("Retring the function");
     await new Promise((resolve) => setTimeout(resolve, interval));
   }
   return false;
 }
 
 export async function functionWaitedAssert(
   fn,
-  options: { timeout?: number; interval?: number; message?: string } = {
-    timeout: 6000,
-    interval: 2000,
-    message: null,
-  }
+  options: {
+    timeout?: number;
+    interval?: number;
+    message?: string;
+    name?: string;
+  } = {}
 ) {
-  const { timeout, interval, message } = options;
   const startTime = Date.now();
+  const timeout = options.timeout || 60000;
+  const interval = options.interval || 2000;
+  const name = options.name || "";
 
   while (true) {
     try {
       await fn();
       return true;
     } catch (error) {
       if (Date.now() - startTime >= timeout) {
-        const errorMessage = message || error.message;
-        throw new Error(errorMessage);
+        const errorMessage = options.message || error.message;
+        expect(false, { message: errorMessage }).toBe(true);
       }
+      Logger.info(`Retring the function ${name}`);
       await new Promise((resolve) => setTimeout(resolve, interval));
     }
   }

tests/govtool-frontend/playwright/lib/pages/dRepDirectoryPage.ts

@@ -68,6 +68,9 @@ export default class DRepDirectoryPage {
   async filterDReps(filterOptions: string[]) {
     for (const option of filterOptions) {
       await this.page.getByTestId(`${option}-checkbox`).click();
+      if (option !== "Active" && filterOptions.length === 1) {
+        await this.page.getByTestId(`Active-checkbox`).click();
+      }
     }
   }
 
@@ -78,35 +81,31 @@ export default class DRepDirectoryPage {
   }
 
   async validateFilters(filters: string[], filterOptions: string[]) {
-    let errorMessage = "";
-    await functionWaitedAssert(
-      async () => {
-        const excludedFilters = filterOptions.filter(
-          (filter) => !filters.includes(filter)
-        );
-
-        const dRepList = await this.getAllListedDReps();
+    await functionWaitedAssert(async () => {
+      const excludedFilters = filterOptions.filter(
+        (filter) => !filters.includes(filter)
+      );
 
-        for (const filter of excludedFilters) {
-          await expect(this.page.getByTestId(`${filter}-checkbox`)).toHaveCount(
-            1
-          );
-        }
+      const dRepList = await this.getAllListedDReps();
 
-        for (const dRep of dRepList) {
-          const hasFilter = await this._validateTypeFiltersInDRep(
-            dRep,
-            filters
-          );
-          const actualFilter = await dRep
-            .locator('[data-testid$="-pill"]')
-            .textContent();
-          errorMessage = `${actualFilter} does not match any of the ${filters}`;
-          expect(hasFilter).toBe(true);
+      for (const filter of excludedFilters) {
+        await expect(this.page.getByTestId(`${filter}-checkbox`)).toHaveCount(
+          1
+        );
+      }
+
+      for (const dRep of dRepList) {
+        const hasFilter = await this._validateTypeFiltersInDRep(dRep, filters);
+        const actualFilter = await dRep
+          .locator('[data-testid$="-pill"]')
+          .textContent();
+        if (!hasFilter) {
+          const errorMessage = `${actualFilter} pill does not match with any of the ${filters}`;
+          throw new Error(errorMessage);
         }
-      },
-      { message: errorMessage }
-    );
+        expect(hasFilter).toBe(true);
+      }
+    });
   }
 
   async _validateTypeFiltersInDRep(

tests/govtool-frontend/playwright/lib/pages/proposalDiscussionPage.ts

@@ -127,22 +127,21 @@ export default class ProposalDiscussionPage {
     filters: string[],
     validateFunction: (proposalCard: any, filters: string[]) => Promise<boolean>
   ) {
-    let errorMessage = "";
-    await functionWaitedAssert(
-      async () => {
-        const proposalCards = await this.getAllProposals();
-
-        for (const proposalCard of proposalCards) {
-          const type = await proposalCard
-            .getByTestId("governance-action-type")
-            .textContent();
-          const hasFilter = await validateFunction(proposalCard, filters);
-          errorMessage = `A governance action type ${type} does not contain on ${filters}`;
-          expect(hasFilter).toBe(true);
+    await functionWaitedAssert(async () => {
+      const proposalCards = await this.getAllProposals();
+
+      for (const proposalCard of proposalCards) {
+        const type = await proposalCard
+          .getByTestId("governance-action-type")
+          .textContent();
+        const hasFilter = await validateFunction(proposalCard, filters);
+        if (!hasFilter) {
+          const errorMessage = `A governance action type ${type} does not contain on ${filters}`;
+          throw errorMessage;
         }
-      },
-      { message: errorMessage }
-    );
+        expect(hasFilter).toBe(true);
+      }
+    });
   }
 
   async sortAndValidate(