@xylentis/testgen 0.0.0-stage → 1.1.0

package/dist/generators/playwright-go.js

@@ -0,0 +1,388 @@
+import { devices } from 'playwright-core';
+import { isRegex, parseLocator } from '../locator.js';
+import { pascalCase, snakeCase } from '../naming.js';
+import { PageAliases, isBlankUrl, shortcutOf, signalsOf, toKeyboardModifiers } from '../recording.js';
+import { CodeWriter, doubleQuote } from './writer.js';
+const playwrightGoModule = 'github.com/mxschmitt/playwright-go';
+// Roles with a playwright.AriaRole<Name> constant in playwright-go.
+const ariaRoles = new Set(('alert alertdialog application article banner blockquote button caption cell checkbox code ' +
+    'columnheader combobox complementary contentinfo definition deletion dialog directory document emphasis feed figure ' +
+    'form generic grid gridcell group heading img insertion link list listbox listitem log main marquee math meter menu ' +
+    'menubar menuitem menuitemcheckbox menuitemradio navigation none note option paragraph presentation progressbar radio ' +
+    'radiogroup region row rowgroup rowheader scrollbar search searchbox separator slider spinbutton status strong ' +
+    'subscript superscript switch tab table tablist tabpanel term textbox time timer toolbar tooltip tree treegrid treeitem').split(' '));
+const capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+export const playwrightGo = {
+    id: 'playwright-go',
+    framework: 'Playwright for Go (playwright-go)',
+    language: 'Go',
+    highlight: 'go',
+    testFileName: name => `${snakeCase(name)}_test.go`,
+    generate(recording, options) {
+        const imports = new Set(['os', 'testing']);
+        const locators = new GoLocators(() => imports.add('regexp'));
+        const body = new CodeWriter('\t');
+        const aliases = new PageAliases();
+        const declared = new Set();
+        const dialogHandlers = new Set();
+        let usesExpect = false;
+        // Whether a page is referenced by any action after `index` (Go rejects unused variables).
+        const usedAfter = (pageGuid, index) => recording.actions.slice(index + 1).some(a => a.pageGuid === pageGuid);
+        const declarePage = (alias, used) => {
+            declared.add(alias);
+            body.line(`${used ? alias : '_'}, err ${used ? ':=' : '='} context.NewPage()`);
+            body.line('require.NoError(t, err)');
+        };
+        recording.actions.forEach((actionInContext, index) => {
+            const { action, pageGuid } = actionInContext;
+            const pageAlias = aliases.alias(pageGuid);
+            if (action.name === 'openPage') {
+                const navigates = !isBlankUrl(action.url);
+                declarePage(pageAlias, navigates || usedAfter(pageGuid, index));
+                if (navigates)
+                    emit(body, { expr: `${pageAlias}.Goto(${doubleQuote(action.url)})`, returnsValue: true });
+                return;
+            }
+            if (!declared.has(pageAlias))
+                declarePage(pageAlias, true);
+            // The browser is closed when the test ends; only pages opened later are closed explicitly.
+            if (action.name === 'closePage') {
+                if (pageAlias !== 'page')
+                    emit(body, { expr: `${pageAlias}.Close()`, returnsValue: false });
+                return;
+            }
+            const signals = signalsOf(actionInContext);
+            if (signals.dialog && !dialogHandlers.has(pageAlias)) {
+                // playwright-go has no once('dialog'); the handler stays for later dialogs of this page.
+                dialogHandlers.add(pageAlias);
+                body.block(`${pageAlias}.OnDialog(func(dialog playwright.Dialog) {`, () => {
+                    body.line('t.Logf("Dialog message: %s", dialog.Message())');
+                    body.line('_ = dialog.Dismiss()');
+                }, '})');
+            }
+            const call = actionCall(pageAlias, action, locators);
+            if (action.name.startsWith('assert'))
+                usesExpect = true;
+            if (call.todo)
+                body.line(`// TODO(testgen): ${call.todo}`);
+            let wrapped = call;
+            if (signals.download)
+                wrapped = { expr: `${pageAlias}.ExpectDownload(${callback(wrapped)})`, returnsValue: true };
+            if (signals.popup) {
+                const popupAlias = aliases.alias(signals.popup.popupPageGuid);
+                const used = usedAfter(signals.popup.popupPageGuid, index);
+                if (used)
+                    declared.add(popupAlias);
+                body.line(`${used ? popupAlias : '_'}, err ${used ? ':=' : '='} ${pageAlias}.ExpectPopup(${callback(wrapped)})`);
+                body.line('require.NoError(t, err)');
+            }
+            else {
+                emit(body, wrapped);
+            }
+            if (recording.header.generateExpectSignal && signals.expect) {
+                usesExpect = true;
+                emit(body, { expr: `expect.Locator(${locators.render(pageAlias, parseLocator(signals.expect.selector))}).ToBeVisible()`, returnsValue: false });
+            }
+        });
+        if (!declared.size && !recording.header.saveStorage)
+            body.line('_ = context');
+        if (recording.header.saveStorage)
+            emit(body, { expr: `context.StorageState(playwright.BrowserContextStorageStateOptions{Path: playwright.String(${doubleQuote(recording.header.saveStorage)})})`, returnsValue: true });
+        const w = new CodeWriter('\t');
+        w.line(`package ${goPackageName(options.packageName)}`);
+        w.line();
+        w.line('import (');
+        w.indent(() => {
+            for (const name of [...imports].sort())
+                w.line(doubleQuote(name));
+            w.line();
+            w.line(doubleQuote(playwrightGoModule));
+            w.line(doubleQuote('github.com/stretchr/testify/require'));
+        });
+        w.line(')');
+        w.line();
+        w.line('// Generated by testgen from a Playwright recording. Set HEADED=1 to watch the browser.');
+        w.block(`func Test${pascalCase(options.name)}(t *testing.T) {`, () => {
+            w.line('pw, err := playwright.Run()');
+            w.line('require.NoError(t, err)');
+            w.line('t.Cleanup(func() { _ = pw.Stop() })');
+            w.line();
+            const launchFields = [];
+            if (recording.header.launchOptions.channel)
+                launchFields.push(['Channel', `playwright.String(${doubleQuote(recording.header.launchOptions.channel)})`]);
+            launchFields.push(['Headless', 'playwright.Bool(os.Getenv("HEADED") == "")']);
+            w.line(`browser, err := pw.${browserType(recording.header)}.Launch(${structLiteral('playwright.BrowserTypeLaunchOptions', launchFields)})`);
+            w.line('require.NoError(t, err)');
+            w.line('t.Cleanup(func() { _ = browser.Close() })');
+            w.line();
+            const context = contextOptions(recording.header, options.testIdAttribute);
+            for (const line of context.before)
+                w.line(line);
+            w.line(`context, err := browser.NewContext(${context.fields.length ? structLiteral('playwright.BrowserNewContextOptions', context.fields) : ''})`);
+            w.line('require.NoError(t, err)');
+            if (options.testIdAttribute !== 'data-testid')
+                w.line(`pw.Selectors.SetTestIdAttribute(${doubleQuote(options.testIdAttribute)})`);
+            if (usesExpect)
+                w.line('expect := playwright.NewPlaywrightAssertions()');
+            w.line();
+            w.line(body.toString().trimEnd());
+        });
+        return [{ path: this.testFileName(options.name), content: w.toString() }];
+    },
+};
+function goPackageName(name) {
+    const cleaned = (name ?? '').toLowerCase().replace(/[^a-z0-9_]/g, '');
+    return cleaned && !/^[0-9]/.test(cleaned) ? cleaned : 'e2e';
+}
+function browserType(header) {
+    return { firefox: 'Firefox', webkit: 'WebKit' }[header.browserName] ?? 'Chromium';
+}
+function emit(w, call) {
+    if (call.returnsValue) {
+        w.line(`_, err = ${call.expr}`);
+        w.line('require.NoError(t, err)');
+    }
+    else {
+        w.line(`require.NoError(t, ${call.expr})`);
+    }
+}
+// func() error { ... } wrapping a call, for ExpectPopup / ExpectDownload.
+function callback(call) {
+    const expr = call.expr.replace(/\n/g, '\n\t');
+    if (!call.returnsValue)
+        return `func() error {\n\treturn ${expr}\n}`;
+    return `func() error {\n\t_, err := ${expr}\n\treturn err\n}`;
+}
+// gofmt-compatible composite literal: one line for a single field, aligned values otherwise.
+function structLiteral(type, fields) {
+    if (fields.length === 1)
+        return `${type}{${fields[0][0]}: ${fields[0][1]}}`;
+    const width = Math.max(...fields.map(([key]) => key.length));
+    const lines = fields.map(([key, value]) => `\t${key}:${' '.repeat(width - key.length + 1)}${value},`);
+    return `${type}{\n${lines.join('\n')}\n}`;
+}
+function contextOptions(header, testIdAttribute) {
+    const before = [];
+    const fields = [];
+    let options = { ...header.contextOptions };
+    const device = header.deviceName ? devices[header.deviceName] : undefined;
+    if (header.deviceName && device) {
+        before.push(`device := pw.Devices[${doubleQuote(header.deviceName)}]`);
+        fields.push(['UserAgent', 'playwright.String(device.UserAgent)'], ['Viewport', 'device.Viewport'], ['DeviceScaleFactor', 'playwright.Float(device.DeviceScaleFactor)'], ['IsMobile', 'playwright.Bool(device.IsMobile)'], ['HasTouch', 'playwright.Bool(device.HasTouch)']);
+        options = Object.fromEntries(Object.entries(options).filter(([key, value]) => JSON.stringify(device[key]) !== JSON.stringify(value)));
+    }
+    const unsupported = [];
+    const set = (key, value) => {
+        const existing = fields.findIndex(([name]) => name === key);
+        if (existing >= 0)
+            fields[existing] = [key, value];
+        else
+            fields.push([key, value]);
+    };
+    for (const [key, value] of Object.entries(options)) {
+        if (value === undefined || key === 'recordHar')
+            continue;
+        switch (key) {
+            case 'viewport':
+                if (value === null)
+                    set('NoViewport', 'playwright.Bool(true)');
+                else
+                    set('Viewport', `&playwright.Size{Width: ${value.width}, Height: ${value.height}}`);
+                break;
+            case 'userAgent':
+                set('UserAgent', `playwright.String(${doubleQuote(String(value))})`);
+                break;
+            case 'locale':
+                set('Locale', `playwright.String(${doubleQuote(String(value))})`);
+                break;
+            case 'timezoneId':
+                set('TimezoneId', `playwright.String(${doubleQuote(String(value))})`);
+                break;
+            case 'colorScheme':
+                set('ColorScheme', `playwright.ColorScheme${pascalCase(String(value))}`);
+                break;
+            case 'ignoreHTTPSErrors':
+                set('IgnoreHttpsErrors', `playwright.Bool(${!!value})`);
+                break;
+            case 'storageState':
+                set('StorageStatePath', `playwright.String(${doubleQuote(String(value))})`);
+                break;
+            case 'deviceScaleFactor':
+                set('DeviceScaleFactor', `playwright.Float(${Number(value)})`);
+                break;
+            case 'isMobile':
+                set('IsMobile', `playwright.Bool(${!!value})`);
+                break;
+            case 'hasTouch':
+                set('HasTouch', `playwright.Bool(${!!value})`);
+                break;
+            case 'geolocation':
+                set('Geolocation', `&playwright.Geolocation{Latitude: ${value.latitude}, Longitude: ${value.longitude}}`);
+                break;
+            case 'permissions':
+                set('Permissions', `[]string{${value.map(doubleQuote).join(', ')}}`);
+                break;
+            case 'screen': break;
+            default: unsupported.push(key);
+        }
+    }
+    if (unsupported.length)
+        before.unshift(`// TODO(testgen): context options not converted: ${unsupported.join(', ')}.`);
+    return { before, fields };
+}
+function actionCall(subject, action, locators) {
+    const locator = 'selector' in action ? locators.render(subject, parseLocator(action.selector)) : subject;
+    const expect = (assertion) => ({ expr: `expect.Locator(${locator}).${assertion}`, returnsValue: false });
+    switch (action.name) {
+        case 'click': {
+            const method = action.clickCount === 2 ? 'Dblclick' : 'Click';
+            const fields = [];
+            if (action.button !== 'left')
+                fields.push(['Button', `playwright.MouseButton${capitalize(action.button)}`]);
+            const modifiers = toKeyboardModifiers(action.modifiers);
+            if (modifiers.length)
+                fields.push(['Modifiers', `[]playwright.KeyboardModifier{${modifiers.map(m => `*playwright.KeyboardModifier${m}`).join(', ')}}`]);
+            if (action.clickCount > 2)
+                fields.push(['ClickCount', `playwright.Int(${action.clickCount})`]);
+            if (action.position)
+                fields.push(['Position', `&playwright.Position{X: ${action.position.x}, Y: ${action.position.y}}`]);
+            const options = fields.length ? structLiteral(`playwright.Locator${method}Options`, fields) : '';
+            return { expr: `${locator}.${method}(${options})`, returnsValue: false };
+        }
+        case 'hover': {
+            const options = action.position ? `playwright.LocatorHoverOptions{Position: &playwright.Position{X: ${action.position.x}, Y: ${action.position.y}}}` : '';
+            return { expr: `${locator}.Hover(${options})`, returnsValue: false };
+        }
+        case 'check':
+            return { expr: `${locator}.Check()`, returnsValue: false };
+        case 'uncheck':
+            return { expr: `${locator}.Uncheck()`, returnsValue: false };
+        case 'fill':
+            return { expr: `${locator}.Fill(${doubleQuote(action.text)})`, returnsValue: false };
+        case 'setInputFiles': {
+            const files = action.files.length === 1 ? doubleQuote(action.files[0]) : `[]string{${action.files.map(doubleQuote).join(', ')}}`;
+            return { expr: `${locator}.SetInputFiles(${files})`, returnsValue: false };
+        }
+        case 'press':
+            return { expr: `${locator}.Press(${doubleQuote(shortcutOf(action))})`, returnsValue: false };
+        case 'navigate':
+            return { expr: `${subject}.Goto(${doubleQuote(action.url)})`, returnsValue: true };
+        case 'select':
+            return { expr: `${locator}.SelectOption(playwright.SelectOptionValues{ValuesOrLabels: playwright.StringSlice(${action.options.map(doubleQuote).join(', ')})})`, returnsValue: true };
+        case 'assertText':
+            return expect(`${action.substring ? 'ToContainText' : 'ToHaveText'}(${doubleQuote(action.text)})`);
+        case 'assertChecked':
+            return expect(action.checked ? 'ToBeChecked()' : 'Not().ToBeChecked()');
+        case 'assertVisible':
+            return expect('ToBeVisible()');
+        case 'assertValue':
+            return expect(action.value ? `ToHaveValue(${doubleQuote(action.value)})` : 'ToBeEmpty()');
+        case 'assertSnapshot':
+            if (action.ariaSnapshot)
+                return expect(`ToMatchAriaSnapshot(${doubleQuote(action.ariaSnapshot)})`);
+            return { ...expect('ToBeVisible()'), todo: 'aria snapshot assertion; the recording does not include the snapshot.' };
+        case 'openPage':
+        case 'closePage':
+            throw new Error(`${action.name} is handled by the caller`);
+    }
+}
+// Renders Playwright locator steps as playwright-go calls.
+class GoLocators {
+    _onRegexp;
+    constructor(_onRegexp) {
+        this._onRegexp = _onRegexp;
+    }
+    render(subject, steps) {
+        return subject + steps.map(step => '.' + this._step(subject, step)).join('');
+    }
+    _value(matcher) {
+        if (!isRegex(matcher))
+            return doubleQuote(matcher);
+        this._onRegexp();
+        const flags = matcher.flags.replace(/[^ims]/g, '');
+        const source = (flags ? `(?${flags})` : '') + matcher.source;
+        return `regexp.MustCompile(${source.includes('`') ? doubleQuote(source) : '`' + source + '`'})`;
+    }
+    _step(subject, step) {
+        const owner = { 'page': 'Page', 'locator': 'Locator', 'frame-locator': 'FrameLocator' }[step.base];
+        const body = step.body;
+        const filter = (field, value) => `Filter(playwright.LocatorFilterOptions{${field}: ${value}})`;
+        switch (step.kind) {
+            case 'default':
+                if (step.hasText !== undefined)
+                    return `Locator(${doubleQuote(body)}, playwright.${owner}LocatorOptions{HasText: ${this._value(step.hasText)}})`;
+                if (step.hasNotText !== undefined)
+                    return `Locator(${doubleQuote(body)}, playwright.${owner}LocatorOptions{HasNotText: ${this._value(step.hasNotText)}})`;
+                return `Locator(${doubleQuote(body)})`;
+            case 'frame-locator':
+                return `FrameLocator(${doubleQuote(body)})`;
+            case 'frame':
+                return 'ContentFrame()';
+            case 'any-frame':
+                return `Locator(${doubleQuote('internal:control=any-frame')})`;
+            case 'nth':
+                return `Nth(${body})`;
+            case 'first':
+                return 'First()';
+            case 'last':
+                return 'Last()';
+            case 'visible':
+                return filter('Visible', 'playwright.Bool(true)');
+            case 'filter-visible':
+                return filter('Visible', `playwright.Bool(${body === 'true'})`);
+            case 'has-text':
+                return filter('HasText', this._value(step.body));
+            case 'has-not-text':
+                return filter('HasNotText', this._value(step.body));
+            case 'has':
+                return filter('Has', this.render(subject, step.inner));
+            case 'hasNot':
+                return filter('HasNot', this.render(subject, step.inner));
+            case 'and':
+                return `And(${this.render(subject, step.inner)})`;
+            case 'or':
+                return `Or(${this.render(subject, step.inner)})`;
+            case 'chain':
+                return `Locator(${this.render(subject, step.inner)})`;
+            case 'test-id':
+                return `GetByTestId(${this._value(step.body)})`;
+            case 'role':
+                return this._role(owner, step);
+            case 'text':
+                return this._byText(owner, 'GetByText', step);
+            case 'alt':
+                return this._byText(owner, 'GetByAltText', step);
+            case 'placeholder':
+                return this._byText(owner, 'GetByPlaceholder', step);
+            case 'label':
+                return this._byText(owner, 'GetByLabel', step);
+            case 'title':
+                return this._byText(owner, 'GetByTitle', step);
+        }
+    }
+    _byText(owner, method, step) {
+        if (isRegex(step.body) || !step.exact)
+            return `${method}(${this._value(step.body)})`;
+        return `${method}(${this._value(step.body)}, playwright.${owner}${method}Options{Exact: playwright.Bool(true)})`;
+    }
+    _role(owner, step) {
+        const role = step.body;
+        const roleValue = ariaRoles.has(role) ? `*playwright.AriaRole${capitalize(role)}` : `playwright.AriaRole(${doubleQuote(role)})`;
+        const fields = [];
+        if (step.name !== undefined)
+            fields.push(`Name: ${this._value(step.name)}`);
+        if (step.description !== undefined)
+            fields.push(`Description: ${this._value(step.description)}`);
+        if (step.exact && (typeof step.name === 'string' || typeof step.description === 'string'))
+            fields.push('Exact: playwright.Bool(true)');
+        for (const { name, value } of step.attrs ?? []) {
+            const field = capitalize(name);
+            if (typeof value === 'boolean')
+                fields.push(`${field}: playwright.Bool(${value})`);
+            else if (typeof value === 'number')
+                fields.push(`${field}: playwright.Int(${value})`);
+        }
+        return fields.length ? `GetByRole(${roleValue}, playwright.${owner}GetByRoleOptions{${fields.join(', ')}})` : `GetByRole(${roleValue})`;
+    }
+}
+//# sourceMappingURL=playwright-go.js.map

package/dist/generators/playwright-ts.js

@@ -0,0 +1,50 @@
+import { devices } from 'playwright-core';
+import { formatObject } from '../vendor/playwright/stringUtils.js';
+import { kebabCase, words } from '../naming.js';
+import { writeJavaScriptBody } from './javascript-body.js';
+import { CodeWriter, singleQuote } from './writer.js';
+export const playwrightTs = {
+    id: 'playwright-ts',
+    framework: 'Playwright Test',
+    language: 'TypeScript',
+    highlight: 'typescript',
+    testFileName: name => `${kebabCase(name)}.spec.ts`,
+    generate(recording, options) {
+        const { header } = recording;
+        const w = new CodeWriter('  ');
+        w.line(`import { test, expect${header.deviceName ? ', devices' : ''} } from '@playwright/test';`);
+        const use = useOptions(header, options.testIdAttribute);
+        if (use) {
+            w.line();
+            w.line(`test.use(${use});`);
+        }
+        w.line();
+        w.block(`test(${singleQuote(words(options.name).join(' '))}, async ({ page }) => {`, () => {
+            writeJavaScriptBody(w, recording, {
+                supportsDownloads: true,
+                todo: message => `// TODO(testgen): ${message}`,
+            });
+        }, '});');
+        return [{ path: this.testFileName(options.name), content: w.toString() }];
+    },
+};
+// Context options for test.use(), spreading the device descriptor like Playwright's codegen.
+function useOptions(header, testIdAttribute) {
+    const options = { ...header.contextOptions, recordHar: undefined };
+    if (testIdAttribute !== 'data-testid')
+        options.testIdAttribute = testIdAttribute;
+    const device = header.deviceName ? devices[header.deviceName] : undefined;
+    if (!device) {
+        const text = formatObject(options);
+        return text === '{}' ? '' : text;
+    }
+    // Only keep what differs from the device descriptor.
+    for (const key of Object.keys(options)) {
+        if (JSON.stringify(device[key]) === JSON.stringify(options[key]))
+            delete options[key];
+    }
+    const lines = formatObject(options).split('\n');
+    const spread = `  ...devices[${singleQuote(header.deviceName)}],`;
+    return lines.length === 1 ? `{\n${spread}\n}` : [lines[0], spread, ...lines.slice(1)].join('\n');
+}
+//# sourceMappingURL=playwright-ts.js.map

package/dist/generators/runtime.js

@@ -0,0 +1,16 @@
+import fs from 'node:fs';
+// Support files ship as real sources under runtime/ (next to src/ and dist/).
+const runtimeRoot = new URL('../../runtime/', import.meta.url);
+export function readRuntimeFile(relativePath) {
+    return fs.readFileSync(new URL(relativePath, runtimeRoot), 'utf8');
+}
+// In-page locator engine shared by every Selenium support file.
+export function engineSource() {
+    return readRuntimeFile('selenium/engine.js');
+}
+// Reads a support file and splices the engine in place of its `@testgen-engine` marker.
+export function readRuntime(relativePath, embedEngine = source => source) {
+    const engine = embedEngine(engineSource().trimEnd());
+    return readRuntimeFile(relativePath).replace(/\/\* @testgen-engine \*\/|@testgen-engine/, () => engine);
+}
+//# sourceMappingURL=runtime.js.map

package/dist/generators/selenium-common.js

@@ -0,0 +1,38 @@
+// Selenium browser name for the browser the recording was made with.
+export function seleniumBrowser(header) {
+    if (header.browserName === 'firefox')
+        return 'firefox';
+    if (header.browserName === 'webkit')
+        return 'safari';
+    return header.launchOptions.channel?.startsWith('msedge') ? 'edge' : 'chrome';
+}
+const ignoredContextOptions = new Set(['recordHar', 'recordVideo', 'deviceScaleFactor', 'isMobile', 'hasTouch', 'screen']);
+export function seleniumDriverOptions(header) {
+    const browser = seleniumBrowser(header);
+    const result = { args: [], unsupported: [] };
+    for (const [key, value] of Object.entries(header.contextOptions)) {
+        if (value === undefined || value === null || ignoredContextOptions.has(key))
+            continue;
+        if (key === 'viewport') {
+            result.viewport = value;
+        }
+        else if (key === 'locale' && (browser === 'chrome' || browser === 'edge')) {
+            result.args.push(`--lang=${value}`);
+        }
+        else if (key === 'userAgent' && (browser === 'chrome' || browser === 'edge')) {
+            result.args.push(`--user-agent=${value}`);
+        }
+        else if (key === 'ignoreHTTPSErrors' && value === true && (browser === 'chrome' || browser === 'edge')) {
+            result.args.push('--ignore-certificate-errors');
+        }
+        else {
+            result.unsupported.push(key);
+        }
+    }
+    if (header.deviceName)
+        result.unsupported.push(`device "${header.deviceName}" (only its viewport and user agent are applied)`);
+    if (header.saveStorage)
+        result.unsupported.push(`saving the storage state to ${header.saveStorage}`);
+    return result;
+}
+//# sourceMappingURL=selenium-common.js.map