@capillarytech/cap-ui-utils 3.1.1 → 3.1.2

package/e2e/utils/expectUtil.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+class AssertionUtil {
+    async assertValue(element, textToBeValidated) {
+        assert.strictEqual(await element.getText(), textToBeValidated);
+    }
+    async assertElementExistence(element) {
+        try {
+            assert.strictEqual(await element.isDisplayed(), true);
+        }
+        catch (error) {
+            throw new Error(error);
+        }
+    }
+}
+exports.default = new AssertionUtil();

package/e2e/utils/featureFlagUtil.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Reads feature flags from window.capAuth.accessibleFeatures — the same source
+ * that Auth.hasFeatureAccess() uses in the app (cap-ui-utils/auth/hasFeatureAccess.js).
+ *
+ * Call loadFeatureFlags() once after the app has loaded (e.g. after openAudiencePage),
+ * then use hasFeatureAccess() anywhere in the test run.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+let _accessibleFeatures = [];
+async function loadFeatureFlags() {
+    // window.capAuth.accessibleFeatures is populated async after the app boots.
+    // Wait until it's array-shaped (up to 30s) before caching — an empty array
+    // is a valid "no features enabled" state, not a sign it's still loading.
+    await browser.waitUntil(async () => {
+        const features = await browser.execute(() => { var _a; return (_a = window.capAuth) === null || _a === void 0 ? void 0 : _a.accessibleFeatures; });
+        return Array.isArray(features);
+    }, { timeout: 30000, interval: 1000, timeoutMsg: '[featureFlags] window.capAuth.accessibleFeatures never populated' });
+    _accessibleFeatures = await browser.execute(() => { var _a; return ((_a = window.capAuth) === null || _a === void 0 ? void 0 : _a.accessibleFeatures) || []; });
+    console.log(`[featureFlags] loaded ${_accessibleFeatures.length} features`);
+}
+function hasFeatureAccess(feature) {
+    return _accessibleFeatures.includes(feature);
+}
+exports.default = { loadFeatureFlags, hasFeatureAccess };

package/e2e/utils/garudaDropdownUtil.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class GarudaDropdownUtil {
+    treeOptionByText(text, index = 1, altText) {
+        const textMatch = altText
+            ? `normalize-space()="${text}" or normalize-space()="${altText}"`
+            : `normalize-space()="${text}"`;
+        const position = index === 'last' ? 'last()' : index;
+        return $(`(//span[contains(@class,"ant-select-tree-node-content-wrapper")][.//div[${textMatch}]])[${position}]`);
+    }
+    unifiedOptionByText(text) {
+        return $(`//div[contains(@class,"cap-unified-select-popup")]//div[.//div[text()="${text}"] and @role="treeitem"]`);
+    }
+    listOptionByLabel(label, index = 1) {
+        return $(`(//ul[@role="listbox"]//li[@role="option" and @label="${label}"])[${index}]`);
+    }
+    selectOptionByText(text, index = 1) {
+        return $(`(//div[contains(@class,"ant-select-item-option")][.//div[contains(@class,"ant-select-item-option-content")][normalize-space()="${text}"]])[${index}]`);
+    }
+    treeOption(index = 1) {
+        const position = index === 'last' ? 'last()' : index;
+        return $(`(//span[contains(@class,"ant-select-tree-node-content-wrapper")][normalize-space(.)])[${position}]`);
+    }
+    listOptionByLabelInPopup(ariaControlId, label) {
+        return $(`//div[contains(@id,"${ariaControlId}")]//ul//li[@role="option" and @label="${label}"]`);
+    }
+    menuItemByText(text, index = 1) {
+        return $(`(//li[contains(@class,"ant-dropdown-menu-item")][.//span[normalize-space()="${text}"]])[${index}]`);
+    }
+    unifiedSelectConfirmButton() {
+        return $(`//button[contains(@class,"cap-unified-select-confirm-button")]`);
+    }
+}
+exports.default = new GarudaDropdownUtil();

package/e2e/utils/htmlEditorUtil.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Helpers for the antd v6 contenteditable HTML editor.
+ * After bulk HTML injection, the caret remains outside the `<body>` tag, causing label
+ * insertions at the wrong position. `placeCaretInsideBody` locates the `<body>` position
+ * across text nodes and updates the Selection range correctly.
+ *
+ * Caller passes the WDIO editor element (defined as a page selector), so this util
+ * does not own selector strings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.placeCaretInsideBody = void 0;
+async function placeCaretInsideBody(editor) {
+    return browser.execute((node) => {
+        if (!node)
+            return false;
+        const walker = document.createTreeWalker(node, NodeFilter.SHOW_TEXT);
+        const nodes = [];
+        const starts = [];
+        let combined = '';
+        for (let n = walker.nextNode(); n; n = walker.nextNode()) {
+            const t = n;
+            starts.push(combined.length);
+            combined += t.nodeValue || '';
+            nodes.push(t);
+        }
+        if (!nodes.length)
+            return false;
+        const open = combined.match(/<\s*body\b[^>]*>/i);
+        if (!open || open.index === undefined)
+            return false;
+        let idx = open.index + open[0].length;
+        while (idx < combined.length && /\s/.test(combined.charAt(idx)))
+            idx++;
+        let nodeIdx = 0;
+        for (let i = 0; i < nodes.length; i++) {
+            const end = starts[i] + (nodes[i].nodeValue || '').length;
+            if (idx <= end) {
+                nodeIdx = i;
+                break;
+            }
+            nodeIdx = i;
+        }
+        const target = nodes[nodeIdx];
+        const offset = Math.max(0, Math.min(idx - starts[nodeIdx], (target.nodeValue || '').length));
+        node.focus();
+        const range = document.createRange();
+        range.setStart(target, offset);
+        range.collapse(true);
+        const selection = window.getSelection();
+        if (!selection)
+            return false;
+        selection.removeAllRanges();
+        selection.addRange(range);
+        return true;
+    }, editor);
+}
+exports.placeCaretInsideBody = placeCaretInsideBody;
+exports.default = { placeCaretInsideBody };

package/e2e/utils/logCollectorUtil.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const supertest_1 = __importDefault(require("supertest"));
+const wdio_commands_1 = __importDefault(require("@rpii/wdio-commands"));
+class LogCollectorUtil {
+    constructor() {
+        this.callCount = 0;
+    }
+    async collectLogs(runId, test, error, duration, passed, skipped = false) {
+        this.callCount += 1;
+        let validationMessage;
+        let status;
+        if (passed) {
+            status = 'passed';
+            validationMessage = '';
+        }
+        else if (skipped) {
+            status = 'skipped';
+            validationMessage = '';
+        }
+        else {
+            wdio_commands_1.default.logScreenshot("Exception logged: " + error);
+            status = 'failed';
+            if (error === undefined) {
+                validationMessage = 'cannot capture error';
+            }
+            else {
+                validationMessage = error.toString().replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+            }
+        }
+        // this.recordBrowserLogs()
+        const baseUrl = 'http://127.0.0.1:4000';
+        const request = (0, supertest_1.default)(baseUrl);
+        let exeTime = duration / 1000;
+        let message = { [runId]: { [test.parent]: { [test.title]: { "status": status,
+                        "time": exeTime.toString(), "validataionMessage": validationMessage,
+                        "total": this.callCount } } } };
+        const messagePayload = { "result": message };
+        try {
+            const response = await request
+                .post('/logger')
+                .timeout({ deadline: 10000 })
+                .send(messagePayload);
+            console.log('API Response', response.body);
+        }
+        catch (err) {
+            // The in-pod log collector can be slow or absent (e.g. skipLogCollector);
+            // a logging failure must never fail the test itself.
+            console.log('logCollector POST failed (non-fatal):', err.message);
+        }
+        console.log('Message', message);
+    }
+    async recordBrowserLogs() {
+        const logTypes = Promise.resolve(browser.getLogs('browser')).then(function (data) { return data; });
+        logTypes.then(data => (JSON.stringify(data.filter(function getObj(logs) {
+            if (logs['level'] === 'SEVERE' || logs['level'] === 'ERROR') {
+                wdio_commands_1.default.logMessage((logs['level'] + ": " + JSON.stringify(logs)));
+            }
+        }))));
+    }
+}
+exports.default = new LogCollectorUtil();

package/e2e/utils/{mockResponse.ts → mockResponse.js}

@@ -1,4 +1,7 @@
-export const beamerApiResp =  {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beamerApiResp = void 0;
+exports.beamerApiResp = {
     "activateAutoRefresh": true,
     "autoRefreshTimeout": 12000000,
     "defaultSelectorColor": "#50ac44",
@@ -21,4 +24,4 @@ export const beamerApiResp =  {
     "showLinkInSnippet": false,
     "topDomain": "capillarytech.com",
     "updatesDelay": 300000
-}
+};

package/e2e/utils/{reportUploader.ts → reportUploader.js}

@@ -1,12 +1,34 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { execFile, execFileSync } from 'child_process';
-import { promisify } from 'util';
-import { Uploader } from './uploaders/uploader';
-import { FileServiceUploader } from './uploaders/fileServiceUploader';
-
-const execFileAsync = promisify(execFile);
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fileServiceUploader_1 = require("./uploaders/fileServiceUploader");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 /**
  * Zips the recorded debug artifacts (request payloads + screenshots) into a
  * single .zip and uploads it via a pluggable Uploader (Capillary File Service
@@ -16,95 +38,86 @@ const execFileAsync = promisify(execFile);
  * registered when FULL_DEBUG_MODE is enabled).
  */
 class ReportUploader {
-    private debugDir = path.join(process.cwd(), 'reports', 'debug');
-    // Upper bound for the whole upload step; on expiry we log and let the run end.
-    private uploadTimeoutMs = Number(process.env.UPLOAD_TIMEOUT_MS) || 90000;
-
-    private getUploader(): Uploader {
-        return new FileServiceUploader();
+    constructor() {
+        this.debugDir = path.join(process.cwd(), 'reports', 'debug');
+        // Upper bound for the whole upload step; on expiry we log and let the run end.
+        this.uploadTimeoutMs = Number(process.env.UPLOAD_TIMEOUT_MS) || 90000;
+    }
+    getUploader() {
+        return new fileServiceUploader_1.FileServiceUploader();
     }
-
     /** Remove prior-run artifacts so each archive contains only the current run. */
-    clearPreviousArtifacts(): void {
+    clearPreviousArtifacts() {
         try {
             if (fs.existsSync(this.debugDir)) {
                 fs.rmSync(this.debugDir, { recursive: true, force: true });
                 console.log('[reportUploader] cleared previous debug artifacts');
             }
-        } catch (err) {
+        }
+        catch (err) {
             console.log(`[reportUploader] failed to clear previous artifacts: ${err}`);
         }
     }
-
-    async archiveAndUpload(): Promise<void> {
+    async archiveAndUpload() {
         try {
             if (!fs.existsSync(this.debugDir) || fs.readdirSync(this.debugDir).length === 0) {
                 console.log('[reportUploader] no debug artifacts recorded — nothing to upload');
                 return;
             }
-
             // Bundle run metadata + a snapshot of the automation code so a later
             // diff can tell whether a payload change came from the lib upgrade or
             // from the tests themselves.
             this.writeMetaAndCode();
-
             const archivePath = await this.createArchive();
             console.log(`[reportUploader] created archive ${archivePath}`);
-
             const uploader = this.getUploader();
             if (!uploader.isConfigured()) {
                 console.log(`[reportUploader] upload skipped — missing config: ${uploader.missingConfigMessage()}. Archive kept locally at ${archivePath}`);
                 return;
             }
-
             // Belt-and-suspenders: even with the uploader's own network timeout,
             // never let the upload block the run's onComplete hook (a hung upload
             // would keep the pod alive forever). On timeout we log and move on so
             // the pod terminates exactly as it did before this feature existed.
-            const location = await this.withTimeout(
-                uploader.upload(archivePath, path.basename(archivePath)),
-                this.uploadTimeoutMs,
-                'upload',
-            );
+            const location = await this.withTimeout(uploader.upload(archivePath, path.basename(archivePath)), this.uploadTimeoutMs, 'upload');
             console.log(`[reportUploader] uploaded request payloads to ${uploader.name}: ${location}`);
-        } catch (err) {
+        }
+        catch (err) {
             console.log(`[reportUploader] archive/upload failed (continuing so the run can exit): ${err}`);
         }
     }
-
     /** Reject after ms so a stuck upload can never block process shutdown. */
-    private withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {
-        let timer: NodeJS.Timeout;
-        const timeout = new Promise<never>((_, reject) => {
+    withTimeout(promise, ms, label) {
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            var _a;
             timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
             // Don't let this timer itself keep the event loop alive.
-            timer.unref?.();
+            (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
         });
-        return Promise.race([promise, timeout]).finally(() => clearTimeout(timer)) as Promise<T>;
+        return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
     }
-
     /** Run a git command and return its trimmed stdout, or '' on failure. */
-    private git(args: string[]): string {
+    git(args) {
         try {
-            return execFileSync('git', args, { cwd: process.cwd() }).toString().trim();
-        } catch {
+            return (0, child_process_1.execFileSync)('git', args, { cwd: process.cwd() }).toString().trim();
+        }
+        catch {
             return '';
         }
     }
-
     /**
      * Write debug/meta.json (run identity + git state) and copy the automation
      * code for this module into debug/code/. The compare tool reads these to
      * flag when two archives were produced from different code, so payload diffs
      * aren't misattributed to the UI library upgrade.
      */
-    private writeMetaAndCode(): void {
+    writeMetaAndCode() {
         try {
             const moduleName = process.env.module || 'all';
             const commit = this.git(['rev-parse', 'HEAD']);
             const branch = this.git(['rev-parse', '--abbrev-ref', 'HEAD']);
             const dirty = this.git(['status', '--porcelain']).length > 0;
-
             const meta = {
                 cluster: process.env.cluster || 'unknown-cluster',
                 module: moduleName,
@@ -112,11 +125,7 @@ class ReportUploader {
                 recordedAt: new Date().toISOString(),
                 git: { commit, branch, dirty },
             };
-            fs.writeFileSync(
-                path.join(this.debugDir, 'meta.json'),
-                JSON.stringify(meta, null, 2),
-            );
-
+            fs.writeFileSync(path.join(this.debugDir, 'meta.json'), JSON.stringify(meta, null, 2));
             // Snapshot only this module's automation code (small); never the whole
             // src/ tree (~110M). Page objects + specs are enough to explain a diff.
             const codeDir = path.join(this.debugDir, 'code');
@@ -126,47 +135,41 @@ class ReportUploader {
             ];
             for (const rel of sources) {
                 const abs = path.join(process.cwd(), rel);
-                if (!fs.existsSync(abs)) continue;
+                if (!fs.existsSync(abs))
+                    continue;
                 const dest = path.join(codeDir, rel);
                 fs.mkdirSync(path.dirname(dest), { recursive: true });
                 fs.cpSync(abs, dest, { recursive: true });
             }
-        } catch (err) {
+        }
+        catch (err) {
             console.log(`[reportUploader] failed to write meta/code snapshot: ${err}`);
         }
     }
-
     /** Resolve the test type (suite) from the `--suite <name>` CLI flag. */
-    private getTestType(): string {
+    getTestType() {
         const argv = process.argv;
         const idx = argv.findIndex((a) => a === '--suite');
-        if (idx !== -1 && argv[idx + 1]) return argv[idx + 1];
+        if (idx !== -1 && argv[idx + 1])
+            return argv[idx + 1];
         const inline = argv.find((a) => a.startsWith('--suite='));
-        if (inline) return inline.split('=')[1];
+        if (inline)
+            return inline.split('=')[1];
         return 'all';
     }
-
-    private async createArchive(): Promise<string> {
+    async createArchive() {
         const cluster = process.env.cluster || 'unknown-cluster';
         const moduleName = process.env.module || 'all';
         const testType = this.getTestType();
-
         // date = YYYY-MM-DD, time = HH-MM-SS (UTC, from ISO timestamp)
         const [datePart, timePartRaw] = new Date().toISOString().split('T');
         const timePart = timePartRaw.split('.')[0].replace(/:/g, '-');
-
         const archiveName = `wdio-ui-${cluster}_${moduleName}_${testType}_${datePart}_${timePart}.zip`;
         const archivePath = path.join(process.cwd(), 'reports', archiveName);
-
         // Run zip from the parent dir so the archive contains the debug/ folder
         // with relative paths, not absolute ones.
-        await execFileAsync(
-            'zip',
-            ['-r', '-q', archivePath, path.basename(this.debugDir)],
-            { cwd: path.dirname(this.debugDir) },
-        );
+        await execFileAsync('zip', ['-r', '-q', archivePath, path.basename(this.debugDir)], { cwd: path.dirname(this.debugDir) });
         return archivePath;
     }
 }
-
-export default new ReportUploader();
+exports.default = new ReportUploader();