@xylentis/testgen 1.1.0 → 1.2.0

package/dist/vendor/playwright/locatorParser.js

@@ -0,0 +1,235 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { asLocators } from './locatorGenerators.js';
+import { encodeTestIdAttributeName } from './locatorUtils.js';
+import { parseSelector } from './selectorParser.js';
+import { escapeForAttributeSelector, escapeForTextSelector } from './stringUtils.js';
+function parseLocator(locator, testIdAttributeName) {
+    locator = locator
+        .replace(/AriaRole\s*\.\s*([\w]+)/g, (_, group) => group.toLowerCase())
+        .replace(/(get_by_role|getByRole)\s*\(\s*(?:["'`])([^'"`]+)['"`]/g, (_, group1, group2) => `${group1}(${group2.toLowerCase()}`);
+    const params = [];
+    let template = '';
+    for (let i = 0; i < locator.length; ++i) {
+        const quote = locator[i];
+        if (quote !== '"' && quote !== '\'' && quote !== '`' && quote !== '/') {
+            template += quote;
+            continue;
+        }
+        const isRegexEscaping = locator[i - 1] === 'r' || locator[i] === '/';
+        ++i;
+        let text = '';
+        while (i < locator.length) {
+            if (locator[i] === '\\') {
+                if (isRegexEscaping) {
+                    if (locator[i + 1] !== quote)
+                        text += locator[i];
+                    ++i;
+                    text += locator[i];
+                }
+                else {
+                    ++i;
+                    if (locator[i] === 'n')
+                        text += '\n';
+                    else if (locator[i] === 'r')
+                        text += '\r';
+                    else if (locator[i] === 't')
+                        text += '\t';
+                    else
+                        text += locator[i];
+                }
+                ++i;
+                continue;
+            }
+            if (locator[i] !== quote) {
+                text += locator[i++];
+                continue;
+            }
+            break;
+        }
+        params.push({ quote, text });
+        template += (quote === '/' ? 'r' : '') + '$' + params.length;
+    }
+    // Equalize languages.
+    template = template.toLowerCase()
+        .replace(/get_by_alt_text/g, 'getbyalttext')
+        .replace(/get_by_test_id/g, 'getbytestid')
+        .replace(/get_by_([\w]+)/g, 'getby$1')
+        .replace(/has_not_text/g, 'hasnottext')
+        .replace(/has_text/g, 'hastext')
+        .replace(/has_not/g, 'hasnot')
+        .replace(/frame_locator/g, 'framelocator')
+        .replace(/content_frame/g, 'contentframe')
+        .replace(/[{}\s]/g, '')
+        .replace(/new\(\)/g, '')
+        .replace(/new[\w]+\.[\w]+options\(\)/g, '')
+        .replace(/\.set/g, ',set')
+        .replace(/\.or_\(/g, 'or(') // Python has "or_" instead of "or".
+        .replace(/\.and_\(/g, 'and(') // Python has "and_" instead of "and".
+        .replace(/:/g, '=')
+        .replace(/,re\.ignorecase/g, 'i')
+        .replace(/,pattern.case_insensitive/g, 'i')
+        .replace(/,regexoptions.ignorecase/g, 'i')
+        .replace(/re.compile\(([^)]+)\)/g, '$1') // Python has regex strings as r"foo"
+        .replace(/pattern.compile\(([^)]+)\)/g, 'r$1')
+        .replace(/newregex\(([^)]+)\)/g, 'r$1')
+        .replace(/string=/g, '=')
+        .replace(/regex=/g, '=')
+        .replace(/,,/g, ',')
+        .replace(/,\)/g, ')');
+    const preferredQuote = params.map(p => p.quote).filter(quote => '\'"`'.includes(quote))[0];
+    return { selector: transform(template, params, testIdAttributeName), preferredQuote };
+}
+function countParams(template) {
+    return [...template.matchAll(/\$\d+/g)].length;
+}
+function shiftParams(template, sub) {
+    return template.replace(/\$(\d+)/g, (_, ordinal) => `$${ordinal - sub}`);
+}
+function transform(template, params, testIdAttributeName) {
+    // Recursively handle filter(has=, hasnot=, sethas(), sethasnot()).
+    // TODO: handle and(locator), or(locator), locator(locator), locator(has=, hasnot=, sethas(), sethasnot()).
+    while (true) {
+        const hasMatch = template.match(/filter\(,?(has=|hasnot=|sethas\(|sethasnot\()/);
+        if (!hasMatch)
+            break;
+        // Extract inner locator based on balanced parens.
+        const start = hasMatch.index + hasMatch[0].length;
+        let balance = 0;
+        let end = start;
+        for (; end < template.length; end++) {
+            if (template[end] === '(')
+                balance++;
+            else if (template[end] === ')')
+                balance--;
+            if (balance < 0)
+                break;
+        }
+        // Replace Java sethas(...) and sethasnot(...) with has=... and hasnot=...
+        let prefix = template.substring(0, start);
+        let extraSymbol = 0;
+        if (['sethas(', 'sethasnot('].includes(hasMatch[1])) {
+            // Eat extra ) symbol at the end of sethas(...)
+            extraSymbol = 1;
+            prefix = prefix.replace(/sethas\($/, 'has=').replace(/sethasnot\($/, 'hasnot=');
+        }
+        const paramsCountBeforeHas = countParams(template.substring(0, start));
+        const hasTemplate = shiftParams(template.substring(start, end), paramsCountBeforeHas);
+        const paramsCountInHas = countParams(hasTemplate);
+        const hasParams = params.slice(paramsCountBeforeHas, paramsCountBeforeHas + paramsCountInHas);
+        const hasSelector = JSON.stringify(transform(hasTemplate, hasParams, testIdAttributeName));
+        // Replace filter(has=...) with filter(has2=$5). Use has2 to avoid matching the same filter again.
+        // Replace filter(hasnot=...) with filter(hasnot2=$5). Use hasnot2 to avoid matching the same filter again.
+        template = prefix.replace(/=$/, '2=') + `$${paramsCountBeforeHas + 1}` + shiftParams(template.substring(end + extraSymbol), paramsCountInHas - 1);
+        // Replace inner params with $5 value.
+        const paramsBeforeHas = params.slice(0, paramsCountBeforeHas);
+        const paramsAfterHas = params.slice(paramsCountBeforeHas + paramsCountInHas);
+        params = paramsBeforeHas.concat([{ quote: '"', text: hasSelector }]).concat(paramsAfterHas);
+    }
+    // Transform to selector engines.
+    template = template
+        .replace(/\,set([\w]+)\(([^)]+)\)/g, (_, group1, group2) => ',' + group1.toLowerCase() + '=' + group2.toLowerCase())
+        .replace(/framelocator\(\)/g, 'internal:control=any-frame')
+        .replace(/framelocator\(([^)]+)\)/g, '$1.internal:control=enter-frame')
+        .replace(/contentframe(\(\))?/g, 'internal:control=enter-frame')
+        .replace(/locator\(([^)]+),hastext=([^),]+)\)/g, 'locator($1).internal:has-text=$2')
+        .replace(/locator\(([^)]+),hasnottext=([^),]+)\)/g, 'locator($1).internal:has-not-text=$2')
+        .replace(/locator\(([^)]+),hastext=([^),]+)\)/g, 'locator($1).internal:has-text=$2')
+        .replace(/locator\(([^)]+)\)/g, '$1')
+        .replace(/getbyrole\(([^)]+)\)/g, 'internal:role=$1')
+        .replace(/getbytext\(([^)]+)\)/g, 'internal:text=$1')
+        .replace(/getbylabel\(([^)]+)\)/g, 'internal:label=$1')
+        .replace(/getbytestid\(([^)]+)\)/g, `internal:testid=[${encodeTestIdAttributeName(testIdAttributeName)}=$1]`)
+        .replace(/getby(placeholder|alt|title)(?:text)?\(([^)]+)\)/g, 'internal:attr=[$1=$2]')
+        .replace(/first(\(\))?/g, 'nth=0')
+        .replace(/last(\(\))?/g, 'nth=-1')
+        .replace(/nth\(([^)]+)\)/g, 'nth=$1')
+        .replace(/filter\(,?visible=true\)/g, 'visible=true')
+        .replace(/filter\(,?visible=false\)/g, 'visible=false')
+        .replace(/\.visible(\(\))?(?!=)/g, '.visible=true')
+        .replace(/filter\(,?hastext=([^)]+)\)/g, 'internal:has-text=$1')
+        .replace(/filter\(,?hasnottext=([^)]+)\)/g, 'internal:has-not-text=$1')
+        .replace(/filter\(,?has2=([^)]+)\)/g, 'internal:has=$1')
+        .replace(/filter\(,?hasnot2=([^)]+)\)/g, 'internal:has-not=$1')
+        .replace(/,exact=false/g, '')
+        .replace(/(,name=\$\d+)(,description=\$\d+),exact=true/g, '$1s$2s') // exact=true is shared between name and description, so we need a special case for applying it to both.
+        .replace(/,exact=true/g, 's')
+        .replace(/,includehidden=/g, ',include-hidden=')
+        .replace(/\,/g, '][');
+    const parts = template.split('.');
+    // Turn "internal:control=enter-frame >> nth=0" into "nth=0 >> internal:control=enter-frame"
+    // because these are swapped in locators vs selectors.
+    for (let index = 0; index < parts.length - 1; index++) {
+        if (parts[index] === 'internal:control=enter-frame' && parts[index + 1].startsWith('nth=')) {
+            // Swap nth and enter-frame.
+            const [nth] = parts.splice(index, 1);
+            parts.splice(index + 1, 0, nth);
+        }
+    }
+    // Substitute params.
+    return parts.map(t => {
+        if (!t.startsWith('internal:') || t === 'internal:control')
+            return t.replace(/\$(\d+)/g, (_, ordinal) => { const param = params[+ordinal - 1]; return param.text; });
+        t = t.includes('[') ? t.replace(/\]/, '') + ']' : t;
+        t = t
+            .replace(/(?:r)\$(\d+)(i)?/g, (_, ordinal, suffix) => {
+            const param = params[+ordinal - 1];
+            if (t.startsWith('internal:attr') || t.startsWith('internal:testid') || t.startsWith('internal:role'))
+                return escapeForAttributeSelector(new RegExp(param.text), false) + (suffix || '');
+            return escapeForTextSelector(new RegExp(param.text, suffix), false);
+        })
+            .replace(/\$(\d+)(i|s)?/g, (_, ordinal, suffix) => {
+            const param = params[+ordinal - 1];
+            if (t.startsWith('internal:has=') || t.startsWith('internal:has-not='))
+                return param.text;
+            if (t.startsWith('internal:testid'))
+                return escapeForAttributeSelector(param.text, true);
+            if (t.startsWith('internal:attr') || t.startsWith('internal:role'))
+                return escapeForAttributeSelector(param.text, suffix === 's');
+            return escapeForTextSelector(param.text, suffix === 's');
+        });
+        return t;
+    }).join(' >> ');
+}
+export function locatorOrSelectorAsSelector(language, locator, testIdAttributeName = 'data-testid') {
+    try {
+        return unsafeLocatorOrSelectorAsSelector(language, locator, testIdAttributeName);
+    }
+    catch (e) {
+        return '';
+    }
+}
+export function unsafeLocatorOrSelectorAsSelector(language, locator, testIdAttributeName = 'data-testid') {
+    try {
+        parseSelector(locator);
+        return locator;
+    }
+    catch (e) {
+    }
+    const { selector, preferredQuote } = parseLocator(locator, testIdAttributeName);
+    const locators = asLocators(language, selector, undefined, undefined, preferredQuote);
+    const digest = digestForComparison(language, locator);
+    if (locators.some(candidate => digestForComparison(language, candidate) === digest))
+        return selector;
+    return '';
+}
+function digestForComparison(language, locator) {
+    locator = locator.replace(/\s/g, '');
+    if (language === 'javascript')
+        locator = locator.replace(/\\?["`]/g, '\'').replace(/,{}/g, '');
+    return locator;
+}
+//# sourceMappingURL=locatorParser.js.map

package/dist/vendor/playwright/locatorUtils.js

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { escapeForAttributeSelector, escapeForTextSelector } from './stringUtils.js';
+function getByAttributeTextSelector(attrName, text, options) {
+    return `internal:attr=[${attrName}=${escapeForAttributeSelector(text, options?.exact || false)}]`;
+}
+// Multiple test id attribute names can be joined with a comma. Attribute names cannot contain commas.
+export function splitTestIdAttributeNames(testIdAttributeName) {
+    return testIdAttributeName.split(',');
+}
+export function encodeTestIdAttributeName(testIdAttributeName) {
+    return testIdAttributeName.includes(',') ? JSON.stringify(testIdAttributeName) : testIdAttributeName;
+}
+export function getByTestIdSelector(testIdAttributeName, testId) {
+    return `internal:testid=[${encodeTestIdAttributeName(testIdAttributeName)}=${escapeForAttributeSelector(testId, true)}]`;
+}
+export function getByLabelSelector(text, options) {
+    return 'internal:label=' + escapeForTextSelector(text, !!options?.exact);
+}
+export function getByAltTextSelector(text, options) {
+    return getByAttributeTextSelector('alt', text, options);
+}
+export function getByTitleSelector(text, options) {
+    return getByAttributeTextSelector('title', text, options);
+}
+export function getByPlaceholderSelector(text, options) {
+    return getByAttributeTextSelector('placeholder', text, options);
+}
+export function getByTextSelector(text, options) {
+    return 'internal:text=' + escapeForTextSelector(text, !!options?.exact);
+}
+export function getByRoleSelector(role, options = {}) {
+    const props = [];
+    if (options.checked !== undefined)
+        props.push(['checked', String(options.checked)]);
+    if (options.disabled !== undefined)
+        props.push(['disabled', String(options.disabled)]);
+    if (options.selected !== undefined)
+        props.push(['selected', String(options.selected)]);
+    if (options.expanded !== undefined)
+        props.push(['expanded', String(options.expanded)]);
+    if (options.includeHidden !== undefined)
+        props.push(['include-hidden', String(options.includeHidden)]);
+    if (options.level !== undefined)
+        props.push(['level', String(options.level)]);
+    if (options.name !== undefined)
+        props.push(['name', escapeForAttributeSelector(options.name, !!options.exact)]);
+    if (options.description !== undefined)
+        props.push(['description', escapeForAttributeSelector(options.description, !!options.exact)]);
+    if (options.pressed !== undefined)
+        props.push(['pressed', String(options.pressed)]);
+    return `internal:role=${role}${props.map(([n, v]) => `[${n}=${v}]`).join('')}`;
+}
+//# sourceMappingURL=locatorUtils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylentis/testgen",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Record a UI test once with the Playwright recorder, then generate it for Playwright (TypeScript, Go) and Selenium (Java, JavaScript).",
   "keywords": [
     "playwright",
@@ -11,6 +11,7 @@
     "e2e",
     "playwright-go",
     "junit",
+    "testng",
     "mocha"
   ],
   "author": "Xylentis (https://portal.xylentis.com)",
@@ -39,7 +40,8 @@
     "prepare": "npm run build",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
-    "e2e": "bash e2e/run.sh"
+    "e2e": "bash e2e/run.sh",
+    "release": "node scripts/release.mjs"
   },
   "dependencies": {
     "playwright-core": "1.63.0"

package/runtime/playwright-go/testgen_data_test.go

@@ -0,0 +1,64 @@
+// Generated by testgen: rewritten every time tests are generated, do not edit.
+// testgen (@xylentis/testgen), Copyright (C) 2026 Xylentis. Licensed under AGPL-3.0-only with an additional
+// permission: as part of tests generated by testgen, this file may be used, modified and distributed under
+// terms of your choice (see NOTICE in @xylentis/testgen).
+
+package e2e
+
+import (
+	"bytes"
+	"encoding/csv"
+	"os"
+	"strings"
+	"testing"
+)
+
+// readTestgenCSV returns the rows of the CSV data file of a data-driven test, with the given columns.
+// The file is UTF-8, with or without a BOM, separated by commas or semicolons (as Excel saves it in
+// some languages), and its first line names the columns; other columns are ignored, blank lines skipped.
+func readTestgenCSV(t *testing.T, file string, columns ...string) []map[string]string {
+	t.Helper()
+	data, err := os.ReadFile(file)
+	if err != nil {
+		t.Fatalf("testgen: %v", err)
+	}
+	data = bytes.TrimPrefix(data, []byte("\uFEFF"))
+	reader := csv.NewReader(bytes.NewReader(data))
+	reader.FieldsPerRecord = -1
+	if firstLine, _, _ := strings.Cut(string(data), "\n"); !strings.Contains(firstLine, ",") && strings.Contains(firstLine, ";") {
+		reader.Comma = ';'
+	}
+	records, err := reader.ReadAll()
+	if err != nil {
+		t.Fatalf("testgen: data file %s: %v", file, err)
+	}
+	if len(records) == 0 {
+		t.Fatalf("testgen: data file %s is empty", file)
+	}
+	header := map[string]int{}
+	for i, name := range records[0] {
+		header[strings.TrimSpace(name)] = i
+	}
+	for _, column := range columns {
+		if _, ok := header[column]; !ok {
+			t.Fatalf("testgen: data file %s has no column %q (it has %s)", file, column, strings.Join(records[0], ", "))
+		}
+	}
+	var rows []map[string]string
+	for _, record := range records[1:] {
+		if strings.TrimSpace(strings.Join(record, "")) == "" {
+			continue
+		}
+		row := map[string]string{}
+		for _, column := range columns {
+			if i := header[column]; i < len(record) {
+				row[column] = record[i]
+			}
+		}
+		rows = append(rows, row)
+	}
+	if len(rows) == 0 {
+		t.Fatalf("testgen: data file %s has no data rows", file)
+	}
+	return rows
+}

package/runtime/playwright-ts/testgen-data.ts

@@ -0,0 +1,70 @@
+// Generated by testgen: rewritten every time tests are generated, do not edit.
+// testgen (@xylentis/testgen), Copyright (C) 2026 Xylentis. Licensed under AGPL-3.0-only with an additional
+// permission: as part of tests generated by testgen, this file may be used, modified and distributed under
+// terms of your choice (see NOTICE in @xylentis/testgen).
+import fs from 'node:fs';
+
+/**
+ * Rows of the CSV data file of a data-driven test, as objects with the given columns. The file is UTF-8,
+ * with or without a BOM, separated by commas or semicolons (as Excel saves it in some languages), and its
+ * first line names the columns; other columns are ignored, blank lines skipped.
+ */
+export function readCsv<Column extends string>(file: string, columns: Column[]): Record<Column, string>[] {
+  const text = fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, '');
+  const firstLine = text.split(/\r?\n/, 1)[0];
+  const separator = !firstLine.includes(',') && firstLine.includes(';') ? ';' : ',';
+  const [header, ...records] = parseCsv(text, separator);
+  if (!header)
+    throw new Error(`testgen: data file ${file} is empty`);
+  const names = header.map(name => name.trim());
+  for (const column of columns) {
+    if (!names.includes(column))
+      throw new Error(`testgen: data file ${file} has no column "${column}" (it has ${names.join(', ')})`);
+  }
+  const rows = records
+      .filter(record => record.some(cell => cell.trim()))
+      .map(record => Object.fromEntries(columns.map(column => [column, record[names.indexOf(column)] ?? ''])) as Record<Column, string>);
+  if (!rows.length)
+    throw new Error(`testgen: data file ${file} has no data rows`);
+  return rows;
+}
+
+// RFC 4180: quoted fields may contain separators, line breaks and doubled quotes.
+function parseCsv(text: string, separator: string): string[][] {
+  const rows: string[][] = [];
+  let row: string[] = [];
+  let field = '';
+  let quoted = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (quoted) {
+      if (c === '"' && text[i + 1] === '"') {
+        field += '"';
+        i++;
+      } else if (c === '"') {
+        quoted = false;
+      } else {
+        field += c;
+      }
+    } else if (c === '"') {
+      quoted = true;
+    } else if (c === separator) {
+      row.push(field);
+      field = '';
+    } else if (c === '\n' || c === '\r') {
+      if (c === '\r' && text[i + 1] === '\n')
+        i++;
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = '';
+    } else {
+      field += c;
+    }
+  }
+  if (field || row.length) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}