@camunda/e2e-test-suite 0.0.1

package/dist/utils/loggingUtils.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logWithElapsed = exports.defaultStopwatch = exports.Stopwatch = exports.logWithStopwatch = exports.logWithTime = exports.withLogging = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// ---------------------------
+// Config & runtime state
+// ---------------------------
+const SLOW_CALL_THRESHOLD_MS = Number.parseInt(process.env.LOG_SLOW_THRESHOLD_MS ?? '500', 10);
+const slowCalls = [];
+process.once('exit', () => {
+    if (slowCalls.length === 0)
+        return;
+    console.log('\n\x1b[35m───── Slowest Calls (≥ ' +
+        SLOW_CALL_THRESHOLD_MS +
+        ' ms) ─────\x1b[0m');
+    const top = slowCalls.sort((a, b) => b.duration - a.duration).slice(0, 10);
+    for (const { name, duration, callsite } of top) {
+        // Do NOT wrap the path itself in colour codes – that breaks link detection in
+        // most terminals/IDEs.  We still colour the leading arrow, but leave the path
+        // as plain text so it stays clickable.
+        const site = callsite ? `  @ ${callsite}` : '';
+        console.log(`  ${colorLap(duration)} ${name}${site}`);
+    }
+    console.log('\x1b[35m───────────────────────────────────────────────────────\x1b[0m');
+});
+// Some Playwright classes rely on their exact identity for instanceof / type checks
+// (e.g., Locator) which break when wrapped in a Proxy. Detect these objects and
+// skip proxying them.
+function shouldSkipProxying(value) {
+    if (!value || typeof value !== 'object') {
+        return true;
+    }
+    // Best-effort detection based on constructor name to avoid importing Playwright types.
+    const ctorName = value.constructor?.name;
+    return (ctorName === 'Locator' ||
+        ctorName === 'FrameLocator' ||
+        ctorName === 'ElementHandle');
+}
+// Cache to avoid wrapping the same object multiple times (which can lead to duplicate logs)
+const proxyCache = new WeakMap();
+// ---------------------------
+// Patch Playwright prototypes that we cannot safely proxy (e.g., Locator)
+// ---------------------------
+// Track prototypes we have already patched so we only wrap once
+const patchedPrototypes = new WeakSet();
+// Identify the current worker (Playwright sets PLAYWRIGHT_WORKER_INDEX; fall back to pid)
+const WORKER_ID = process.env.PLAYWRIGHT_WORKER_INDEX ??
+    process.env.JEST_WORKER_ID ??
+    String(process.pid);
+function workerPrefix() {
+    return `\x1b[90m[W${WORKER_ID}]\x1b[0m `; // dim grey
+}
+// Helper to draw tree-style indentation (│└) so depth is obvious even when groups
+// are not rendered (e.g. CI terminals that ignore console.group)
+function treeIndent(depth) {
+    if (depth === 0)
+        return '';
+    // Use │ for intermediate levels and └ for the leaf
+    return Array(depth).fill('│ ').join('').replace(/│ $/, '└ ');
+}
+function patchPrototypeForLogging(proto, className) {
+    if (patchedPrototypes.has(proto))
+        return;
+    patchedPrototypes.add(proto);
+    for (const key of Object.getOwnPropertyNames(proto)) {
+        if (key === 'constructor')
+            continue;
+        const desc = Object.getOwnPropertyDescriptor(proto, key);
+        if (!desc?.value || typeof desc.value !== 'function')
+            continue;
+        const originalFn = desc.value;
+        if (originalFn.__LOG_WRAPPED__)
+            continue; // already wrapped
+        const wrapped = function (...args) {
+            const callerInfo = getCallerInfo();
+            const name = `${className}.${String(key)}`;
+            // Prepare argument preview once so we can reuse it across logs
+            const argsPreview = args.map((a) => stringify(a)).join(', ');
+            // No tree-indent available here – these are leaf calls
+            console.groupCollapsed(`${workerPrefix()}\x1b[36m➡️  ${name}(${argsPreview})\x1b[0m ${callerInfo}`);
+            const start = Date.now();
+            let result;
+            try {
+                result = originalFn.apply(this, args);
+                if (result instanceof Promise) {
+                    return result
+                        .then((r) => {
+                        logSuccess('', name, argsPreview, stringify(r), Date.now() - start);
+                        return r;
+                    })
+                        .catch((e) => {
+                        logError('', name, argsPreview, e, Date.now() - start);
+                        throw e;
+                    });
+                }
+                else {
+                    logSuccess('', name, argsPreview, stringify(result), Date.now() - start);
+                    return result;
+                }
+            }
+            catch (err) {
+                const duration = Date.now() - start;
+                console.error(`${workerPrefix()}\x1b[31m❌ ${name} threw ${colorLap(duration)}\x1b[0m`);
+                console.error(err);
+                throw err;
+            }
+            finally {
+                console.groupEnd();
+            }
+        };
+        wrapped.__LOG_WRAPPED__ = true;
+        Object.defineProperty(proto, key, { ...desc, value: wrapped });
+    }
+}
+function createLoggedInstance(instance, label = '', depth = 0) {
+    // If we've already created a proxy for this exact object, reuse it
+    const cached = proxyCache.get(instance);
+    if (cached) {
+        return cached;
+    }
+    const proxy = new Proxy(instance, {
+        get(target, prop, receiver) {
+            const original = Reflect.get(target, prop, receiver);
+            if (typeof original === 'object' && original !== null) {
+                if (!shouldSkipProxying(original)) {
+                    return createLoggedInstance(original, `${label}.${String(prop)}`, depth + 1);
+                }
+                else {
+                    // For Locator / FrameLocator / ElementHandle – patch their prototype so
+                    // that method calls are still logged even though we cannot proxy them.
+                    const ctorName = original.constructor?.name ?? 'Object';
+                    patchPrototypeForLogging(Object.getPrototypeOf(original), ctorName);
+                    return original;
+                }
+            }
+            if (typeof original === 'function') {
+                // Helper to safely stringify and truncate large values for readability
+                return async function (...args) {
+                    const indent = treeIndent(depth);
+                    const name = `${label}.${String(prop)}`.replace(/^\./, '');
+                    const argsPreview = args.map((a) => stringify(a)).join(', ');
+                    // Add file-line info for easier navigation (feature #10)
+                    const callerInfo = getCallerInfo();
+                    // Start group – light blue arrow (feature #2)
+                    console.groupCollapsed(`${workerPrefix()}${indent}\x1b[36m➡️  ${name}(${argsPreview})\x1b[0m ${callerInfo}`);
+                    const start = Date.now();
+                    try {
+                        // Use the actual target object as the `this` context so that
+                        // methods relying on private fields (like Playwright internals)
+                        // work correctly. Using the proxy here breaks access to these
+                        // private members and can throw at runtime.
+                        const result = await original.apply(target, args);
+                        const duration = Date.now() - start;
+                        const resultPreview = stringify(result);
+                        // Success log – green check mark with coloured duration
+                        logSuccess(indent, name, argsPreview, resultPreview, duration);
+                        // Slow-call tracking (feature #4)
+                        if (duration >= SLOW_CALL_THRESHOLD_MS) {
+                            slowCalls.push({ name, duration, callsite: callerInfo });
+                        }
+                        return result;
+                    }
+                    catch (err) {
+                        const duration = Date.now() - start;
+                        // Error log – red cross with coloured duration
+                        logError(indent, name, argsPreview, err, duration);
+                        throw err;
+                    }
+                    finally {
+                        // Close the group (feature #2)
+                        console.groupEnd();
+                    }
+                };
+            }
+            return original;
+        },
+    });
+    // Store in cache before returning so that recursive/nested look-ups also reuse it
+    proxyCache.set(instance, proxy);
+    return proxy;
+}
+const stringify = (value, maxLength = 240) => {
+    try {
+        const str = typeof value === 'string' ? value : JSON.stringify(value);
+        return str.length > maxLength ? str.slice(0, maxLength) + '…' : str;
+    }
+    catch {
+        return String(value);
+    }
+};
+const formatError = (error, maxLength = 10000) => {
+    if (error instanceof Error) {
+        // Preserve full stack; limit length to avoid gigantic dumps
+        const basic = `${error.name}: ${error.message}`;
+        const stack = error.stack ? '\n' + error.stack : '';
+        const combined = basic + stack;
+        return combined.length > maxLength
+            ? combined.slice(0, maxLength) + '…'
+            : combined;
+    }
+    // Fallback to util.inspect to get colours & depth
+    try {
+        // Dynamically import util to avoid extra bundle weight when not needed
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const util = require('util');
+        return util.inspect(error, { colors: true, depth: 5, maxArrayLength: 10 });
+    }
+    catch {
+        return stringify(error);
+    }
+};
+const logSuccess = (indent, name, argsPreview, resultPreview, duration) => {
+    // Green check mark, show args in dim colour, result in default colour, lap coloured.
+    console.log(`${workerPrefix()}${indent}\x1b[32m✅ ${name}(\x1b[90m${argsPreview}\x1b[32m) → ${resultPreview} ${colorLap(duration)}\x1b[0m`);
+};
+const logError = (indent, name, argsPreview, error, duration) => {
+    // Red cross, show args in dim colour to differentiate from the error text.
+    console.error(`${workerPrefix()}${indent}\x1b[31m❌ ${name}(\x1b[90m${argsPreview}\x1b[31m) threw ${colorLap(duration)}\x1b[0m`);
+    console.error(formatError(error));
+};
+function withLogging(instance, label) {
+    if (process.env.DISABLE_LOGGING_PROXY === 'true') {
+        // When the environment variable is set, skip wrapping with Proxy to avoid the runtime overhead.
+        return instance;
+    }
+    return createLoggedInstance(instance, label);
+}
+exports.withLogging = withLogging;
+function colorElapsed(ms) {
+    const seconds = ms / 1000;
+    if (seconds < 45) {
+        return `\x1b[32m+${ms}ms\x1b[0m`; // green
+    }
+    else if (seconds < 60) {
+        return `\x1b[33m+${ms}ms\x1b[0m`; // yellow
+    }
+    else {
+        return `\x1b[31m+${ms}ms\x1b[0m`; // red
+    }
+}
+function colorLap(ms) {
+    if (ms < 1000) {
+        return `\x1b[32mlap +${ms}ms\x1b[0m`; // green
+    }
+    else if (ms < 2000) {
+        return `\x1b[33mlap +${ms}ms\x1b[0m`; // yellow
+    }
+    else {
+        return `\x1b[31mlap +${ms}ms\x1b[0m`; // red
+    }
+}
+function getCallerInfo() {
+    const err = new Error();
+    if (!err.stack)
+        return '';
+    const stackLines = err.stack.split('\n');
+    const workspaceRoot = process.cwd();
+    // IntelliJ detects links when absolute paths are used. Return absolute by default.
+    // If you really want relative paths, set LOG_CALLER_RELATIVE_PATH=true.
+    const useRelative = process.env.LOG_CALLER_RELATIVE_PATH === 'true';
+    for (const line of stackLines) {
+        if (!line.includes('loggingUtils.ts') && line.includes('at')) {
+            const match = line.match(/\(([^)]+)\)/) || line.match(/at ([^ ]+)/);
+            if (match) {
+                let filePath = match[1];
+                if (useRelative && filePath.startsWith(workspaceRoot)) {
+                    filePath = filePath.slice(workspaceRoot.length);
+                    if (filePath.startsWith('/'))
+                        filePath = filePath.slice(1);
+                }
+                return filePath;
+            }
+        }
+    }
+    return '';
+}
+const logWithTime = (msg, startTime) => {
+    const now = new Date();
+    const elapsed = Date.now() - startTime;
+    const caller = getCallerInfo();
+    // Keep the file path plain (no surrounding brackets) to preserve clickability
+    console.log(`[${now.toISOString()}] (${colorElapsed(elapsed)}) ${msg}  ${caller}`);
+};
+exports.logWithTime = logWithTime;
+const logWithStopwatch = (msg, stopwatch) => {
+    const now = new Date();
+    const elapsed = stopwatch.elapsed();
+    const lap = stopwatch.lap();
+    const caller = getCallerInfo();
+    // Keep the file path plain (no surrounding brackets) to preserve clickability
+    console.log(`[${now.toISOString()}] (${colorElapsed(elapsed)}, ${colorLap(lap)}) ${msg}  ${caller}`);
+    stopwatch._updateLap();
+};
+exports.logWithStopwatch = logWithStopwatch;
+// Stopwatch class for timing durations
+class Stopwatch {
+    _startTime = null;
+    _elapsed = 0;
+    _running = false;
+    _lastLap = 0;
+    start() {
+        if (!this._running) {
+            this._startTime = Date.now();
+            this._running = true;
+            this._lastLap = 0;
+        }
+    }
+    stop() {
+        if (this._running && this._startTime !== null) {
+            this._elapsed += Date.now() - this._startTime;
+            this._startTime = null;
+            this._running = false;
+        }
+    }
+    reset() {
+        this._elapsed = 0;
+        this._startTime = this._running ? Date.now() : null;
+        this._lastLap = 0;
+    }
+    elapsed() {
+        if (this._running && this._startTime !== null) {
+            return this._elapsed + (Date.now() - this._startTime);
+        }
+        return this._elapsed;
+    }
+    lap() {
+        const nowElapsed = this.elapsed();
+        return nowElapsed - this._lastLap;
+    }
+    _updateLap() {
+        this._lastLap = this.elapsed();
+    }
+    log(msg) {
+        (0, exports.logWithStopwatch)(msg, this);
+    }
+}
+exports.Stopwatch = Stopwatch;
+// Default/global stopwatch for convenience
+exports.defaultStopwatch = new Stopwatch();
+const logWithElapsed = (msg) => {
+    if (!exports.defaultStopwatch['_running']) {
+        exports.defaultStopwatch.start();
+    }
+    (0, exports.logWithStopwatch)(msg, exports.defaultStopwatch);
+};
+exports.logWithElapsed = logWithElapsed;

package/dist/utils/randomName.d.ts

@@ -0,0 +1 @@
+export declare function randomNameAgregator(name: string): Promise<string>;

package/dist/utils/randomName.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomNameAgregator = void 0;
+const _setup_1 = require("../test-setup.js");
+async function randomNameAgregator(name) {
+    const randomString = await (0, _setup_1.generateRandomStringAsync)(3);
+    return name + '_' + randomString;
+}
+exports.randomNameAgregator = randomNameAgregator;

package/dist/utils/randomSleep.d.ts

@@ -0,0 +1 @@
+export declare function randomSleep(min: number, max: number): Promise<void>;

package/dist/utils/randomSleep.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomSleep = void 0;
+const sleep_1 = require("./sleep");
+async function randomSleep(min, max) {
+    const randomMs = Math.floor(Math.random() * (max - min + 1000)) + min;
+    return (0, sleep_1.sleep)(randomMs);
+}
+exports.randomSleep = randomSleep;

package/dist/utils/resetSession.d.ts

@@ -0,0 +1,3 @@
+import type { Browser } from 'playwright-core';
+import { Page } from '@playwright/test';
+export declare function resetSession(browser: Browser, page: Page): Promise<void>;

package/dist/utils/resetSession.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetSession = void 0;
+const sleep_1 = require("./sleep");
+async function resetSession(browser, page) {
+    const context = browser.contexts()[0];
+    await context.clearCookies();
+    await (0, sleep_1.sleep)(15000);
+    await page.reload();
+    await page.goto('/');
+}
+exports.resetSession = resetSession;

package/dist/utils/sleep.d.ts

@@ -0,0 +1,2 @@
+declare function sleep(ms: number): Promise<void>;
+export { sleep };

package/dist/utils/sleep.js

@@ -0,0 +1,14 @@
+"use strict";
+/*
+ * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH under
+ * one or more contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright ownership.
+ * Licensed under the Camunda License 1.0. You may not use this file
+ * except in compliance with the Camunda License 1.0.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.sleep = sleep;

package/dist/utils/zeebeClient.d.ts

@@ -0,0 +1,5 @@
+import { ZBClient, IProcessVariables, JSONDoc } from 'zeebe-node';
+declare const zbc: ZBClient;
+declare const deploy: typeof zbc.deployProcess;
+declare const createInstances: <Variables extends JSONDoc = IProcessVariables>(bpmnProcessId: string, version: number, numberOfInstances: number, variables?: Variables | undefined) => Promise<import("zeebe-node").CreateProcessInstanceResponse[]>;
+export { deploy, createInstances };

package/dist/utils/zeebeClient.js

@@ -0,0 +1,33 @@
+"use strict";
+/*
+ * Copyright Camunda Services GmbH
+ *
+ * BY INSTALLING, DOWNLOADING, ACCESSING, USING, OR DISTRIBUTING THE SOFTWARE ("USE"), YOU INDICATE YOUR ACCEPTANCE TO AND ARE ENTERING INTO A CONTRACT WITH, THE LICENSOR ON THE TERMS SET OUT IN THIS AGREEMENT. IF YOU DO NOT AGREE TO THESE TERMS, YOU MUST NOT USE THE SOFTWARE. IF YOU ARE RECEIVING THE SOFTWARE ON BEHALF OF A LEGAL ENTITY, YOU REPRESENT AND WARRANT THAT YOU HAVE THE ACTUAL AUTHORITY TO AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT ON BEHALF OF SUCH ENTITY.
+ * "Licensee" means you, an individual, or the entity on whose behalf you receive the Software.
+ *
+ * Permission is hereby granted, free of charge, to the Licensee obtaining a copy of this Software and associated documentation files to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject in each case to the following conditions:
+ * Condition 1: If the Licensee distributes the Software or any derivative works of the Software, the Licensee must attach this Agreement.
+ * Condition 2: Without limiting other conditions in this Agreement, the grant of rights is solely for non-production use as defined below.
+ * "Non-production use" means any use of the Software that is not directly related to creating products, services, or systems that generate revenue or other direct or indirect economic benefits.  Examples of permitted non-production use include personal use, educational use, research, and development. Examples of prohibited production use include, without limitation, use for commercial, for-profit, or publicly accessible systems or use for commercial or revenue-generating purposes.
+ *
+ * If the Licensee is in breach of the Conditions, this Agreement, including the rights granted under it, will automatically terminate with immediate effect.
+ *
+ * SUBJECT AS SET OUT BELOW, THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * NOTHING IN THIS AGREEMENT EXCLUDES OR RESTRICTS A PARTY’S LIABILITY FOR (A) DEATH OR PERSONAL INJURY CAUSED BY THAT PARTY’S NEGLIGENCE, (B) FRAUD, OR (C) ANY OTHER LIABILITY TO THE EXTENT THAT IT CANNOT BE LAWFULLY EXCLUDED OR RESTRICTED.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInstances = exports.deploy = void 0;
+const zeebe_node_1 = require("zeebe-node");
+const zbc = new zeebe_node_1.ZBClient(); // localhost:26500 || ZEEBE_GATEWAY_ADDRESS
+const deploy = (processNames) => {
+    return zbc.deployProcess(processNames);
+};
+exports.deploy = deploy;
+const createInstances = (bpmnProcessId, version, numberOfInstances, variables) => {
+    return Promise.all([...new Array(numberOfInstances)].map(() => zbc.createProcessInstance({
+        bpmnProcessId,
+        version,
+        variables: variables || {},
+    })));
+};
+exports.createInstances = createInstances;

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@camunda/e2e-test-suite",
+  "version": "0.0.1",
+  "description": "End-to-end test helpers for Camunda 8",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/camunda/c8-cross-component-e2e-tests.git"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "playwright test",
+    "test:local": "node --env-file=.env ./runTest.js",
+    "lint": "tsc && eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "clean": "rimraf dist",
+    "prepack": "npm run clean && npm run build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@inquirer/prompts": "^3.2.0",
+    "@playwright/test": "^1.49.0",
+    "@types/axios": "^0.14.0",
+    "@types/node": "20.9.0",
+    "@typescript-eslint/eslint-plugin": "6.10.0",
+    "@typescript-eslint/parser": "6.10.0",
+    "eslint": "8.53.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "5.0.1",
+    "husky": "^8.0.3",
+    "lint-staged": "^15.2.10",
+    "playwright-slack-report": "^1.1.72",
+    "prettier": "3.0.3",
+    "rimraf": "^5.0.1",
+    "tsc-alias": "^1.8.16",
+    "typescript": "5.2.2",
+    "valibot": "0.20.1",
+    "zeebe-node": "^8.3.2"
+  },
+  "peerDependencies": {
+    "@playwright/test": "^1.49.0"
+  },
+  "lint-staged": {
+    "*": [
+      "prettier --write"
+    ]
+  },
+  "dependencies": {
+    "@axe-core/playwright": "^4.7.3",
+    "axios": "^1.5.0",
+    "dotenv": "^16.3.1",
+    "mailslurp-client": "^15.20.2"
+  }
+}