@capillarytech/cap-ui-utils 3.2.0-beta.2 → 3.2.0-beta.4

package/e2e/README.md

@@ -64,9 +64,18 @@ import { waitForApi } from '@capillarytech/cap-ui-utils/e2e/playwright/waits';
 - **`playwright/logCollector`** — per-test POST to `http://127.0.0.1:4000/logger`
   with the exact WDIO payload (`status` / `time` / `validataionMessage` / `total`,
   keyed runId → suite → test). Non-fatal on any failure; honours `skipLogCollector`.
+- **`playwright/apiFailureLogger`** — logs every same-origin API response outside
+  2xx (response + request headers) and network-level request failures, with the
+  same wording as the WDIO CDP interceptor (`API <url> errored with status: ...`,
+  `Following request headers were sent for failed request`). Auto-attached by
+  `doLogin()`; also exported standalone as `attachApiFailureLogger(page, {baseUrl})`.
 - **`playwright/config`** — `createPlaywrightConfig()` wires the reporter, selects the
   suite via `SUITE` → `@<suite>` grep (mirrors `wdio --suite`), and sets pod-friendly
-  defaults (headless chromium, trace/screenshot on failure, retries).
+  defaults (headless chromium, trace/screenshot on failure, retries). Workers are
+  resolvable PER SUITE: `workersBySuite: { smoke: 2, sanity: 1, regression: 1 }`
+  (smoke is parallel-safe; sanity/regression builders are stateful on a shared org).
+  Default parallelism matches the WDIO module configs (`maxInstances: MAX_INSTANCES || 2`).
+  Precedence: `PW_WORKERS_<SUITE>` > `workersBySuite` > `PW_WORKERS` > `MAX_INSTANCES` > `workers` > 2.
 - **`playwright/login`** — Playwright port of `pages/common/login.page` (intouch V2/V1).
 - **`playwright/waits`** — network-driven wait helpers (no fixed sleeps).
 

package/e2e/playwright/apiFailureLogger.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Failed-API logger — Playwright port of the WDIO base-conf network interceptor
+ * (test/wdio.conf.ts `Network.responseReceived` block): every SAME-ORIGIN API
+ * response outside 2xx is logged with its response + request headers, and
+ * network-level request failures (refused/aborted/DNS) are logged too.
+ *
+ * The lines go to stdout, which supervisor.py captures and ships to Apitester —
+ * and they use the SAME wording as the WDIO interceptor so existing debugging
+ * habits and log greps keep working:
+ *
+ *   API <url> errored with status: <status> with following response headers:
+ *   { ...response headers... }
+ *   Following request headers were sent for failed request { ...request headers... }
+ *
+ * Auto-attached by doLogin() for every consumer (mirrors WDIO's always-on base
+ * conf). Idempotent per page. Logging must never fail the run.
+ */
+
+const attached = new WeakSet();
+
+function attachApiFailureLogger(page, opts = {}) {
+    if (!page || typeof page.on !== "function" || attached.has(page)) return;
+    attached.add(page);
+
+    // Same-origin filter — WDIO used cons['url'] (the intouch base URL).
+    const base = String(opts.baseUrl || process.env.INTOUCH_URL || "");
+
+    page.on("response", (response) => {
+        Promise.resolve()
+            .then(async () => {
+                const url = response.url();
+                if (base && !url.startsWith(base)) return;
+                const status = response.status();
+                if (status >= 200 && status <= 299) return;
+                const respHeaders = await response.allHeaders().catch(() => response.headers());
+                console.log(`API ${url} errored with status: ${status} with following response headers:`);
+                console.log(respHeaders);
+                console.log("Following request headers were sent for failed request", response.request().headers());
+            })
+            .catch(() => { /* logging must never fail the run */ });
+    });
+
+    page.on("requestfailed", (request) => {
+        try {
+            const url = request.url();
+            if (base && !url.startsWith(base)) return;
+            const failure = request.failure();
+            console.log(`API ${url} FAILED at network level: ${(failure && failure.errorText) || "unknown"} (method ${request.method()})`);
+            console.log("Following request headers were sent for failed request", request.headers());
+        } catch (e) { /* ignore */ }
+    });
+
+    console.log("----DONE SETTING UP NETWORK INTERCEPTOR TO LOG FAILED APIS----");
+}
+
+module.exports = { attachApiFailureLogger };
+module.exports.default = { attachApiFailureLogger };

package/e2e/playwright/config.js

@@ -22,6 +22,30 @@ function num(v, dflt) {
     return Number.isFinite(n) ? n : dflt;
 }
 
+/**
+ * Per-suite worker resolution — parallelism DEFAULT matches the WDIO module
+ * configs: `maxInstances: Number(process.env.MAX_INSTANCES) || 2` (2 browser
+ * instances is the pod-proven ceiling — 3 pushed the container over its 4Gi
+ * limit). Additionally declarable PER SUITE, which WDIO couldn't do: stateful
+ * sanity/regression builders on a shared org can be pinned serial while smoke
+ * stays parallel. Precedence:
+ *   1. env PW_WORKERS_<SUITE>   (ops override for one suite, no code change)
+ *   2. overrides.workersBySuite (the module's checked-in per-suite intent,
+ *      e.g. { smoke: 2, sanity: 1, regression: 1 })
+ *   3. env PW_WORKERS           (global override — deliberately BELOW
+ *      workersBySuite so it can't parallelize a suite the module marked serial)
+ *   4. env MAX_INSTANCES        (the WDIO-era knob, honoured for continuity)
+ *   5. overrides.workers, then 2 (== WDIO maxInstances default)
+ */
+function resolveWorkers(overrides, suite) {
+    const suiteEnv = suite ? process.env["PW_WORKERS_" + suite.toUpperCase()] : undefined;
+    const bySuite = overrides.workersBySuite || {};
+    const fromCode = bySuite[suite] !== undefined ? bySuite[suite]
+        : num(process.env.PW_WORKERS,
+            num(process.env.MAX_INSTANCES, overrides.workers !== undefined ? overrides.workers : 2));
+    return num(suiteEnv, fromCode);
+}
+
 function createPlaywrightConfig(overrides = {}) {
     const suite = process.env.SUITE || process.env.suite || "";
     const reporterPath = require.resolve("./reporter");
@@ -32,7 +56,7 @@ function createPlaywrightConfig(overrides = {}) {
         fullyParallel: overrides.fullyParallel !== undefined ? overrides.fullyParallel : true,
         forbidOnly: !!process.env.CI,
         retries: num(process.env.PW_RETRIES, overrides.retries !== undefined ? overrides.retries : 1),
-        workers: num(process.env.PW_WORKERS, overrides.workers !== undefined ? overrides.workers : 1),
+        workers: resolveWorkers(overrides, suite),
         timeout: num(process.env.PW_TIMEOUT, overrides.timeout || 90000),
         expect: { timeout: num(process.env.PW_EXPECT_TIMEOUT, 15000) },
         // Only the migrated suite runs — same behaviour as `wdio --suite <suite>`.

package/e2e/playwright/index.js

@@ -10,6 +10,7 @@ const config_1 = require("./config");
 const login_1 = require("./login");
 const waits_1 = require("./waits");
 const logCollector_1 = require("./logCollector");
+const apiFailureLogger_1 = require("./apiFailureLogger");
 
 exports.createPlaywrightConfig = config_1.createPlaywrightConfig;
 exports.doLogin = login_1.doLogin;
@@ -17,4 +18,5 @@ exports.waitForApi = waits_1.waitForApi;
 exports.clickAndWaitForApi = waits_1.clickAndWaitForApi;
 exports.waitForApiIdle = waits_1.waitForApiIdle;
 exports.collectLogs = logCollector_1.collectLogs;
+exports.attachApiFailureLogger = apiFailureLogger_1.attachApiFailureLogger;
 exports.reporterPath = require.resolve("./reporter");

package/e2e/playwright/login.js

@@ -10,6 +10,8 @@
  *   import { doLogin } from '@capillarytech/cap-ui-utils/e2e/playwright/login';
  *   await doLogin(page, { url, username, password });
  */
+const { attachApiFailureLogger } = require("./apiFailureLogger");
+
 const MAX_LOGIN_ATTEMPTS = 3;
 
 function sel(page) {
@@ -28,6 +30,9 @@ function sel(page) {
 
 async function doLogin(page, opts, attempt = 0) {
     const { url, username, password } = opts;
+    // WDIO's base conf always logged failed same-origin API calls (CDP interceptor);
+    // wire the PW equivalent here so every consumer inherits it. Idempotent per page.
+    attachApiFailureLogger(page, { baseUrl: url });
     const s = sel(page);
     try {
         await page.goto(url, { waitUntil: "domcontentloaded" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capillarytech/cap-ui-utils",
-  "version": "3.2.0-beta.2",
+  "version": "3.2.0-beta.4",
   "publishConfig": {
     "access": "public"
   },