@camunda/e2e-test-suite 0.0.162 → 0.0.164

package/dist/gremlin/bin/gremlin

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../dist/cli.js');

package/dist/gremlin/dist/cli.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const node_path_1 = __importDefault(require("node:path"));
+const generateNegativeTestsFile_1 = require("./generate/generateNegativeTestsFile");
+const program = new commander_1.Command();
+program
+    .name('gremlin')
+    .description('Generate additional (negative) Playwright tests using pluggable strategies')
+    .argument('<testFile>', 'Path to an input Playwright .spec.ts file')
+    .option('-o, --output <dir>', 'Output directory (relative to input test file directory when relative)')
+    .option('--project <tsconfig>', 'Path to tsconfig.json to use for type-aware analysis (defaults to nearest tsconfig.json above the input file)')
+    .action(async (testFile, options) => {
+    const inputPath = node_path_1.default.resolve(process.cwd(), testFile);
+    const result = await (0, generateNegativeTestsFile_1.generateNegativeTestsFile)({
+        inputTestFilePath: inputPath,
+        outputDir: options.output,
+        tsConfigPath: options.project,
+    });
+    // eslint-disable-next-line no-console
+    console.log(result.outputFilePath);
+});
+program.parseAsync(process.argv).catch((error) => {
+    // eslint-disable-next-line no-console
+    console.error(error);
+    process.exitCode = 1;
+});

package/dist/gremlin/dist/format/fixWithEslint.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixWithEslint = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+async function fixWithEslint(args) {
+    const cwd = findNearestPackageJsonDir(args.startSearchFrom);
+    if (!cwd) {
+        throw new Error(`Unable to find a package.json to run eslint from (started at: ${args.startSearchFrom})`);
+    }
+    const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    await new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(npxCmd, ['eslint', '--fix', args.filePath], { cwd, env: process.env }, (error, stdout, stderr) => {
+            if (error) {
+                reject(new Error(`eslint --fix failed for ${args.filePath}\n\n${stdout}\n${stderr}`));
+                return;
+            }
+            resolve();
+        });
+    });
+}
+exports.fixWithEslint = fixWithEslint;
+function findNearestPackageJsonDir(start) {
+    let current = node_path_1.default.resolve(start);
+    // If start is a file, search from its directory.
+    if (node_path_1.default.extname(current)) {
+        current = node_path_1.default.dirname(current);
+    }
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const candidate = node_path_1.default.join(current, 'package.json');
+        if ((0, node_fs_1.existsSync)(candidate))
+            return current;
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}

package/dist/gremlin/dist/format/formatWithPrettier.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatWithPrettier = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+async function formatWithPrettier(args) {
+    const cwd = findNearestPackageJsonDir(args.startSearchFrom);
+    if (!cwd) {
+        throw new Error(`Unable to find a package.json to run prettier from (started at: ${args.startSearchFrom})`);
+    }
+    const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    await new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(npxCmd, ['prettier', '--write', args.filePath], { cwd, env: process.env }, (error, stdout, stderr) => {
+            if (error) {
+                reject(new Error(`prettier failed for ${args.filePath}\n\n${stdout}\n${stderr}`));
+                return;
+            }
+            resolve();
+        });
+    });
+}
+exports.formatWithPrettier = formatWithPrettier;
+function findNearestPackageJsonDir(start) {
+    let current = node_path_1.default.resolve(start);
+    // If start is a file, search from its directory.
+    if (node_path_1.default.extname(current)) {
+        current = node_path_1.default.dirname(current);
+    }
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const candidate = node_path_1.default.join(current, 'package.json');
+        if ((0, node_fs_1.existsSync)(candidate))
+            return current;
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}

package/dist/gremlin/dist/generate/generateNegativeTestsFile.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNegativeTestsFile = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const ts_morph_1 = require("ts-morph");
+const fixWithEslint_1 = require("../format/fixWithEslint");
+const collectInvalidInputTestCases_1 = require("../strategies/invalidInput/collectInvalidInputTestCases");
+const formatWithPrettier_1 = require("../format/formatWithPrettier");
+const renderGeneratedSpecFile_1 = require("./renderGeneratedSpecFile");
+const INVALID_INPUT_STRATEGY_SLUG = 'invalid-input';
+async function generateNegativeTestsFile(args) {
+    const inputDir = node_path_1.default.dirname(args.inputTestFilePath);
+    const resolvedOutputDir = args.outputDir
+        ? node_path_1.default.isAbsolute(args.outputDir)
+            ? args.outputDir
+            : node_path_1.default.resolve(inputDir, args.outputDir)
+        : inputDir;
+    await promises_1.default.mkdir(resolvedOutputDir, { recursive: true });
+    const baseName = deriveBaseName(args.inputTestFilePath);
+    const outputFilePath = await resolveIncrementingOutputPath(resolvedOutputDir, `${baseName}-${INVALID_INPUT_STRATEGY_SLUG}-generated.spec.ts`);
+    const tsConfigPath = args.tsConfigPath ?? (await findNearestTsConfig(args.inputTestFilePath));
+    if (!tsConfigPath) {
+        throw new Error(`Unable to locate tsconfig.json (use --project). Started from: ${args.inputTestFilePath}`);
+    }
+    const project = new ts_morph_1.Project({ tsConfigFilePath: tsConfigPath });
+    const sourceFile = project.addSourceFileAtPathIfExists(args.inputTestFilePath);
+    if (!sourceFile) {
+        throw new Error(`Input test file not found: ${args.inputTestFilePath}`);
+    }
+    const testCases = await (0, collectInvalidInputTestCases_1.collectInvalidInputTestCases)({ project, sourceFile });
+    const rendered = (0, renderGeneratedSpecFile_1.renderGeneratedSpecFile)({
+        sourceFile,
+        testCases,
+        strategySlug: INVALID_INPUT_STRATEGY_SLUG,
+    });
+    await promises_1.default.writeFile(outputFilePath, rendered, 'utf8');
+    // Apply autofixes first (eslint), then normalize formatting (prettier).
+    await (0, fixWithEslint_1.fixWithEslint)({
+        filePath: outputFilePath,
+        startSearchFrom: args.inputTestFilePath,
+    });
+    await (0, formatWithPrettier_1.formatWithPrettier)({
+        filePath: outputFilePath,
+        startSearchFrom: args.inputTestFilePath,
+    });
+    return { outputFilePath };
+}
+exports.generateNegativeTestsFile = generateNegativeTestsFile;
+function deriveBaseName(inputPath) {
+    const fileName = node_path_1.default.basename(inputPath);
+    if (fileName.endsWith('.spec.ts')) {
+        return fileName.slice(0, -'.spec.ts'.length);
+    }
+    const parsed = node_path_1.default.parse(fileName);
+    return parsed.name;
+}
+async function resolveIncrementingOutputPath(dir, fileName) {
+    const initial = node_path_1.default.join(dir, fileName);
+    if (!(0, node_fs_1.existsSync)(initial))
+        return initial;
+    const specSuffix = '.spec.ts';
+    if (fileName.endsWith(specSuffix)) {
+        const stem = fileName.slice(0, -specSuffix.length);
+        for (let i = 1; i < 10000; i++) {
+            const candidate = node_path_1.default.join(dir, `${stem}-${i}${specSuffix}`);
+            if (!(0, node_fs_1.existsSync)(candidate))
+                return candidate;
+        }
+        throw new Error(`Unable to find an available output filename in: ${dir}`);
+    }
+    const ext = node_path_1.default.extname(fileName);
+    const withoutExt = fileName.slice(0, -ext.length);
+    for (let i = 1; i < 10000; i++) {
+        const candidate = node_path_1.default.join(dir, `${withoutExt}-${i}${ext}`);
+        if (!(0, node_fs_1.existsSync)(candidate))
+            return candidate;
+    }
+    throw new Error(`Unable to find an available output filename in: ${dir}`);
+}
+async function findNearestTsConfig(startFile) {
+    let current = node_path_1.default.dirname(startFile);
+    // Walk upward until filesystem root.
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const candidate = node_path_1.default.join(current, 'tsconfig.json');
+        if ((0, node_fs_1.existsSync)(candidate))
+            return candidate;
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}

package/dist/gremlin/dist/generate/renderGeneratedSpecFile.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderGeneratedSpecFile = void 0;
+const ts_morph_1 = require("ts-morph");
+function renderGeneratedSpecFile(args) {
+    const preamble = renderPreamble(args.sourceFile);
+    if (args.testCases.length === 0) {
+        // Still emit a file to make behavior predictable.
+        return `${preamble}\n\n// gremlin: no ${args.strategySlug} test cases generated\n`;
+    }
+    const describeTitle = args.testCases[0]?.originDescribeTitle ??
+        'Generated - (negative) generated';
+    const describeBlock = renderDescribeBlock({
+        describeTitle,
+        strategySlug: args.strategySlug,
+        beforeEachText: args.testCases[0]?.beforeEachText,
+        afterEachText: args.testCases[0]?.afterEachText,
+        tests: args.testCases.map((t) => t.renderedTestText),
+    });
+    return `${preamble}\n\n${describeBlock}\n`;
+}
+exports.renderGeneratedSpecFile = renderGeneratedSpecFile;
+function renderPreamble(sourceFile) {
+    const keptStatements = sourceFile.getStatements().filter((stmt) => {
+        if (ts_morph_1.Node.isImportDeclaration(stmt))
+            return true;
+        // Drop the original test.describe(...) block(s)
+        if (ts_morph_1.Node.isExpressionStatement(stmt)) {
+            const expr = stmt.getExpression();
+            const call = expr.asKind(ts_morph_1.SyntaxKind.CallExpression);
+            if (!call)
+                return true;
+            const callee = call.getExpression();
+            // Drop top-level test('...', ...) (rare, but possible)
+            if (ts_morph_1.Node.isIdentifier(callee) && callee.getText() === 'test') {
+                return false;
+            }
+            // Drop top-level test.describe('...', ...)
+            if (ts_morph_1.Node.isPropertyAccessExpression(callee)) {
+                const isTestDescribe = callee.getName() === 'describe' &&
+                    ts_morph_1.Node.isIdentifier(callee.getExpression()) &&
+                    callee.getExpression().getText() === 'test';
+                if (isTestDescribe)
+                    return false;
+            }
+            return true;
+        }
+        // Keep other top-level declarations (constants, helper funcs, etc.)
+        return true;
+    });
+    return keptStatements
+        .map((s) => s.getText())
+        .join('\n\n')
+        .trim();
+}
+function renderDescribeBlock(args) {
+    const lines = [];
+    lines.push(`test.describe('${escapeSingleQuotes(args.describeTitle)} - ${escapeSingleQuotes(args.strategySlug)} - (negative) generated', () => {`);
+    if (args.beforeEachText) {
+        lines.push(indentBlock(dedent(args.beforeEachText), 2));
+    }
+    if (args.afterEachText) {
+        lines.push(indentBlock(dedent(args.afterEachText), 2));
+    }
+    for (const testText of args.tests) {
+        lines.push(indentBlock(testText, 2));
+    }
+    lines.push('});');
+    return lines.join('\n\n');
+}
+function indentBlock(text, spaces) {
+    const prefix = ' '.repeat(spaces);
+    return text
+        .split('\n')
+        .map((line) => (line.trim().length === 0 ? line : prefix + line))
+        .join('\n');
+}
+function dedent(text) {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    const nonEmpty = lines.filter((l) => l.trim().length > 0);
+    if (nonEmpty.length === 0)
+        return text.trim();
+    const minIndent = Math.min(...nonEmpty.map((l) => {
+        const match = l.match(/^\s*/);
+        return match ? match[0].length : 0;
+    }));
+    return lines
+        .map((l) => l.slice(minIndent))
+        .join('\n')
+        .trim();
+}
+function escapeSingleQuotes(value) {
+    return value.replaceAll("'", "\\'");
+}

package/dist/gremlin/dist/strategies/invalidInput/collectInvalidInputTestCases.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectInvalidInputTestCases = void 0;
+const ts_morph_1 = require("ts-morph");
+const extractValidInputSchemaForField_1 = require("./extractValidInputSchemaForField");
+const renderInvalidInputTest_1 = require("./renderInvalidInputTest");
+async function collectInvalidInputTestCases(args) {
+    const describeInfo = findPrimaryDescribeInfo(args.sourceFile);
+    const testCalls = findTestCalls(args.sourceFile);
+    const generated = [];
+    for (const testCall of testCalls) {
+        const originTitle = getStringLiteralArg(testCall, 0) ?? 'Unnamed test';
+        const callback = testCall.getArguments()[1];
+        if (!callback || !ts_morph_1.Node.isArrowFunction(callback))
+            continue;
+        const fillCalls = callback
+            .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+            .filter((call) => isFillMethodCall(call));
+        for (const fillCall of fillCalls) {
+            const propAccess = fillCall.getExpressionIfKindOrThrow(ts_morph_1.SyntaxKind.PropertyAccessExpression);
+            const pageObjectExpr = propAccess.getExpression();
+            const pageObjectName = pageObjectExpr.getText();
+            const fillMethodName = propAccess.getName();
+            const inputFieldName = inferInputFieldNameFromFillMethod(fillMethodName);
+            if (!inputFieldName)
+                continue;
+            const schema = (0, extractValidInputSchemaForField_1.extractValidInputSchemaForField)({
+                project: args.project,
+                typeAtNode: pageObjectExpr,
+                fieldName: inputFieldName,
+            });
+            if (!schema)
+                continue;
+            const invalidMin = makeInvalidString(schema._schema.minlength - 1);
+            const invalidMax = makeInvalidString(schema._schema.maxlength + 1);
+            const prefixStatements = computePrefixStatements({
+                testCall,
+                callback,
+                targetFillCall: fillCall,
+                replacementArgLiteral: toSingleQuotedStringLiteral(invalidMin),
+            });
+            const minParamsText = buildMinimalTestParams({
+                callback,
+                pageObjectName,
+                referencedText: prefixStatements,
+            });
+            const minTest = (0, renderInvalidInputTest_1.renderInvalidInputTest)({
+                testTitle: `${originTitle} - invalid ${inputFieldName} minlength`,
+                testParams: minParamsText,
+                prefixStatements,
+                pageObjectName,
+                inputFieldName,
+                violationEffect: schema._schema.violationEffect,
+                schema,
+                kind: 'minlength',
+                invalidValue: invalidMin,
+                originalCallback: callback,
+                targetFillCall: fillCall,
+            });
+            const prefixStatementsMax = computePrefixStatements({
+                testCall,
+                callback,
+                targetFillCall: fillCall,
+                replacementArgLiteral: toSingleQuotedStringLiteral(invalidMax),
+            });
+            const maxParamsText = buildMinimalTestParams({
+                callback,
+                pageObjectName,
+                referencedText: prefixStatementsMax,
+            });
+            const maxTest = (0, renderInvalidInputTest_1.renderInvalidInputTest)({
+                testTitle: `${originTitle} - invalid ${inputFieldName} maxlength`,
+                testParams: maxParamsText,
+                prefixStatements: prefixStatementsMax,
+                pageObjectName,
+                inputFieldName,
+                violationEffect: schema._schema.violationEffect,
+                schema,
+                kind: 'maxlength',
+                invalidValue: invalidMax,
+                originalCallback: callback,
+                targetFillCall: fillCall,
+            });
+            generated.push({
+                originTestTitle: originTitle,
+                originDescribeTitle: describeInfo?.title,
+                beforeEachText: describeInfo?.beforeEachText,
+                afterEachText: describeInfo?.afterEachText,
+                renderedTestText: minTest,
+            });
+            generated.push({
+                originTestTitle: originTitle,
+                originDescribeTitle: describeInfo?.title,
+                beforeEachText: describeInfo?.beforeEachText,
+                afterEachText: describeInfo?.afterEachText,
+                renderedTestText: maxTest,
+            });
+        }
+    }
+    return generated;
+}
+exports.collectInvalidInputTestCases = collectInvalidInputTestCases;
+function findTestCalls(sourceFile) {
+    return sourceFile
+        .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+        .filter((call) => {
+        const expr = call.getExpression();
+        return ts_morph_1.Node.isIdentifier(expr) && expr.getText() === 'test';
+    })
+        .filter((call) => call.getArguments().length >= 2);
+}
+function isFillMethodCall(call) {
+    const expr = call.getExpression();
+    if (!ts_morph_1.Node.isPropertyAccessExpression(expr))
+        return false;
+    const name = expr.getName();
+    return name.startsWith('fill') && name.length > 'fill'.length;
+}
+function inferInputFieldNameFromFillMethod(fillMethodName) {
+    if (!fillMethodName.startsWith('fill'))
+        return null;
+    const suffix = fillMethodName.slice('fill'.length);
+    if (suffix.length === 0)
+        return null;
+    const camel = suffix[0].toLowerCase() + suffix.slice(1);
+    return `${camel}Input`;
+}
+function getStringLiteralArg(call, index) {
+    const arg = call.getArguments()[index];
+    if (!arg)
+        return null;
+    const literal = arg.asKind(ts_morph_1.SyntaxKind.StringLiteral);
+    return literal ? literal.getLiteralText() : null;
+}
+function findPrimaryDescribeInfo(sourceFile) {
+    const describeCalls = sourceFile
+        .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+        .filter((call) => {
+        const expr = call.getExpression();
+        if (!ts_morph_1.Node.isPropertyAccessExpression(expr))
+            return false;
+        return (expr.getExpression().getText() === 'test' &&
+            expr.getName() === 'describe');
+    });
+    const primary = describeCalls[0];
+    if (!primary)
+        return null;
+    const title = getStringLiteralArg(primary, 0) ?? 'Generated';
+    const callback = primary.getArguments()[1];
+    if (!callback || !ts_morph_1.Node.isArrowFunction(callback)) {
+        return { title };
+    }
+    const block = callback.getBody().asKind(ts_morph_1.SyntaxKind.Block);
+    if (!block)
+        return { title };
+    const statements = block.getStatements();
+    const beforeEach = statements.find((s) => s.getText().trimStart().startsWith('test.beforeEach'));
+    const afterEach = statements.find((s) => s.getText().trimStart().startsWith('test.afterEach'));
+    return {
+        title,
+        beforeEachText: beforeEach?.getText(),
+        afterEachText: afterEach?.getText(),
+    };
+}
+function computePrefixStatements(args) {
+    if (!ts_morph_1.Node.isArrowFunction(args.callback))
+        return '';
+    const body = args.callback.getBody();
+    const block = body.asKind(ts_morph_1.SyntaxKind.Block);
+    if (!block)
+        return '';
+    const statements = block.getStatements();
+    const targetStatement = statements.find((stmt) => stmt
+        .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+        .some((c) => c === args.targetFillCall));
+    if (!targetStatement)
+        return '';
+    const idx = statements.indexOf(targetStatement);
+    const prefix = statements.slice(0, idx + 1);
+    const rendered = prefix.map((stmt) => {
+        if (stmt !== targetStatement)
+            return stmt.getText();
+        // Replace only the argument list for the targeted fill call.
+        return replaceCallArgInStatement({
+            statementText: stmt.getText(),
+            call: args.targetFillCall,
+            newArg: args.replacementArgLiteral,
+        });
+    });
+    return rendered.join('\n');
+}
+function replaceCallArgInStatement(args) {
+    const expr = args.call.getExpression();
+    if (!ts_morph_1.Node.isPropertyAccessExpression(expr))
+        return args.statementText;
+    const methodName = expr.getName();
+    // Naive but stable enough for our conventions.
+    const pattern = new RegExp(`${escapeRegExp(methodName)}\\s*\\(([^)]*)\\)`, 'm');
+    return args.statementText.replace(pattern, `${methodName}(${args.newArg})`);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function buildMinimalTestParams(args) {
+    const params = args.callback.getParameters();
+    if (params.length === 0)
+        return '{}';
+    const first = params[0];
+    const nameNode = first.getNameNode();
+    // Common convention: async ({loginPage, homePage}, testInfo) => ...
+    if (nameNode && ts_morph_1.Node.isObjectBindingPattern(nameNode)) {
+        const available = nameNode.getElements().map((el) => el.getName());
+        const required = new Set([args.pageObjectName]);
+        for (const candidate of available) {
+            if (candidate &&
+                isIdentifierReferenced({
+                    text: args.referencedText,
+                    identifier: candidate,
+                })) {
+                required.add(candidate);
+            }
+        }
+        const firstParamText = `{${Array.from(required).sort().join(', ')}}`;
+        const rest = params.slice(1).map((p) => p.getText());
+        return [firstParamText, ...rest].join(', ');
+    }
+    // Fallback: keep original parameters.
+    return params.map((p) => p.getText()).join(', ');
+}
+function isIdentifierReferenced(args) {
+    const escaped = escapeRegExp(args.identifier);
+    const re = new RegExp(`\\b${escaped}\\b`, 'm');
+    return re.test(args.text);
+}
+function makeInvalidString(length) {
+    if (length <= 0)
+        return '';
+    return 'a'.repeat(length);
+}
+function toSingleQuotedStringLiteral(value) {
+    // Keep generated output consistent with the repo's single-quote style.
+    return `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
+}