@xylentis/testgen 1.1.1 → 1.2.0

package/dist/editing.js

@@ -0,0 +1,167 @@
+import { describeSelector } from './locator.js';
+import { isEnvironmentVariable, pageOrderProblem, shortcutOf } from './recording.js';
+import { collectSecrets } from './secrets.js';
+import { locatorOrSelectorAsSelector } from './vendor/playwright/locatorParser.js';
+// `secrets` saves collecting them again for each step.
+export function stepFields(recording, index, secrets = collectSecrets(recording)) {
+    const step = stepAt(recording, index);
+    const { action } = step;
+    const fields = {};
+    if ('selector' in action)
+        fields.locator = describeSelector(action.selector);
+    const label = valueLabels[action.name];
+    if (label) {
+        fields.valueLabel = label;
+        fields.value = valueOf(action);
+    }
+    if (action.name === 'assertText')
+        fields.substring = action.substring;
+    if (action.name === 'assertChecked')
+        fields.checked = action.checked;
+    if (action.name === 'fill') {
+        const secret = secrets.of(index);
+        if (secret)
+            fields.secret = secret.name;
+        fields.secretChosen = step.secret !== undefined;
+    }
+    return fields;
+}
+export function deleteStep(recording, index) {
+    stepAt(recording, index);
+    return checked({ ...recording, actions: recording.actions.filter((_, i) => i !== index) });
+}
+// Moves step `index` so that it becomes step `to`.
+export function moveStep(recording, index, to) {
+    const step = stepAt(recording, index);
+    stepAt(recording, to);
+    const actions = recording.actions.filter((_, i) => i !== index);
+    actions.splice(to, 0, step);
+    return checked({ ...recording, actions });
+}
+// `testIdAttribute` reads getByTestId() in a typed locator.
+export function editStep(recording, index, change, testIdAttribute) {
+    const step = stepAt(recording, index);
+    let action = step.action;
+    const edited = { ...step };
+    if (change.locator !== undefined) {
+        if (!('selector' in action))
+            throw new Error(`Step ${index + 1} has no locator.`);
+        action = { ...action, selector: parseLocatorText(change.locator, testIdAttribute) };
+    }
+    if (change.value !== undefined)
+        action = withValue(action, change.value, index);
+    if (change.substring !== undefined) {
+        if (action.name !== 'assertText')
+            throw new Error(`Step ${index + 1} does not check a text.`);
+        action = { ...action, substring: change.substring };
+    }
+    if (change.checked !== undefined) {
+        if (action.name !== 'assertChecked')
+            throw new Error(`Step ${index + 1} does not check a checkbox.`);
+        action = { ...action, checked: change.checked };
+    }
+    if (change.secret !== undefined) {
+        if (action.name !== 'fill')
+            throw new Error(`Only steps that type a value can keep it in an environment variable.`);
+        if (typeof change.secret === 'string' && !isEnvironmentVariable(change.secret))
+            throw new Error(`"${change.secret}" is not an environment variable name: use letters, digits and _, e.g. TEST_PASSWORD.`);
+        if (change.secret === null)
+            delete edited.secret;
+        else
+            edited.secret = change.secret;
+    }
+    edited.action = action;
+    return checked({ ...recording, actions: recording.actions.map((s, i) => i === index ? edited : s) });
+}
+const valueLabels = {
+    fill: 'Text',
+    select: 'Options',
+    assertText: 'Expected text',
+    assertValue: 'Expected value',
+    navigate: 'URL',
+    openPage: 'URL',
+    press: 'Key',
+    setInputFiles: 'Files',
+};
+function valueOf(action) {
+    switch (action.name) {
+        case 'fill':
+        case 'assertText':
+            return action.text;
+        case 'select':
+            return action.options.join('\n');
+        case 'assertValue':
+            return action.value;
+        case 'navigate':
+        case 'openPage':
+            return action.url;
+        case 'press':
+            return shortcutOf(action);
+        case 'setInputFiles':
+            return action.files.join('\n');
+        default:
+            return '';
+    }
+}
+function withValue(action, value, index) {
+    const lines = value.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+    switch (action.name) {
+        case 'fill':
+            return { ...action, text: value };
+        case 'assertText':
+            return { ...action, text: value };
+        case 'assertValue':
+            return { ...action, value };
+        case 'select':
+            if (!lines.length)
+                throw new Error(`Step ${index + 1} needs at least one option to select.`);
+            return { ...action, options: lines };
+        case 'setInputFiles':
+            return { ...action, files: lines };
+        case 'navigate':
+        case 'openPage':
+            if (!value.trim() && action.name === 'navigate')
+                throw new Error(`Step ${index + 1} needs a URL.`);
+            return { ...action, url: value.trim() };
+        case 'press':
+            return { ...action, ...parseShortcut(value, index) };
+        default:
+            throw new Error(`Step ${index + 1} has no value to change.`);
+    }
+}
+// "Shift+Enter" → key and the recorder's modifier bits (Alt 1, Control 2, Meta 4, Shift 8).
+function parseShortcut(shortcut, index) {
+    const parts = shortcut.trim().split(/\+(?=.)/);
+    const key = parts.pop();
+    if (!key)
+        throw new Error(`Step ${index + 1} needs a key, e.g. Enter or Control+A.`);
+    const bits = { Alt: 1, Control: 2, ControlOrMeta: 2, Meta: 4, Shift: 8 };
+    let modifiers = 0;
+    for (const part of parts) {
+        if (!bits[part])
+            throw new Error(`Unknown modifier "${part}" in step ${index + 1}: use Alt, Control, ControlOrMeta, Meta or Shift.`);
+        modifiers |= bits[part];
+    }
+    return { key, modifiers };
+}
+// A locator as written in a Playwright test (with or without `page.`) or a selector → selector.
+function parseLocatorText(text, testIdAttribute) {
+    const locator = text.trim().replace(/^(await\s+)?page\d*\./, '').replace(/;$/, '');
+    const selector = locator ? locatorOrSelectorAsSelector('javascript', locator, testIdAttribute) : '';
+    if (!selector)
+        throw new Error(`Cannot read the locator "${text.trim()}". Write it as in a Playwright test, e.g. getByRole('button', { name: 'Sign in' }), getByLabel('Email') or locator('#email').`);
+    return selector;
+}
+function stepAt(recording, index) {
+    const step = Number.isInteger(index) ? recording.actions[index] : undefined;
+    if (!step)
+        throw new Error(`There is no step ${index + 1}.`);
+    return step;
+}
+function checked(recording) {
+    const problem = pageOrderProblem(recording);
+    if (problem)
+        throw new Error(problem);
+    return recording;
+}
+//# sourceMappingURL=editing.js.map

package/dist/generate.js

@@ -16,12 +16,25 @@ export function generateTargets(recording, options) {
             : path.join(options.outDir ?? '.', options.targets.length > 1 ? generator.id : '');
         const name = options.name ?? (options.output ? nameFromFileName(options.output) : 'recorded');
         const packageName = options.packageName ?? defaultPackage(generator, directory);
-        const files = generator.generate(recording, { name, packageName, testIdAttribute });
+        const files = generator.generate(recording, { name, packageName, testIdAttribute, logSteps: options.logSteps, dataDriven: options.dataDriven });
         if (options.output)
             files[0] = { ...files[0], path: path.basename(options.output) };
-        return { generator, directory, files };
+        // Java data files are classpath resources: src/test/java/<package> → src/test/resources/<package>.
+        const resources = generator.language === 'Java' ? resourceDirectory(directory) : undefined;
+        return {
+            generator,
+            directory,
+            files: files.map(file => file.data && resources ? { ...file, path: path.relative(directory, path.join(resources, file.path)) } : file),
+        };
     });
 }
+function resourceDirectory(directory) {
+    const absolute = path.resolve(directory);
+    const match = /([\\/]src[\\/](?:test|main|it)[\\/])java(?=[\\/]|$)/.exec(absolute);
+    if (!match)
+        return undefined;
+    return path.join(absolute.slice(0, match.index) + match[1] + 'resources', absolute.slice(match.index + match[0].length));
+}
 // Java: package from the path below src/test/java (or src/main/java). Go: the directory name when it
 // is a valid package name (the generator falls back to "e2e").
 function defaultPackage(generator, directory) {
@@ -35,15 +48,19 @@ function defaultPackage(generator, directory) {
     return undefined;
 }
 export function writeTargets(outputs) {
-    const written = [];
+    const result = { written: [], kept: [] };
     for (const { directory, files } of outputs) {
-        fs.mkdirSync(directory, { recursive: true });
         for (const file of files) {
             const filePath = path.join(directory, file.path);
+            if (file.data && fs.existsSync(filePath)) {
+                result.kept.push(filePath);
+                continue;
+            }
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
             fs.writeFileSync(filePath, file.content);
-            written.push(filePath);
+            result.written.push(filePath);
         }
     }
-    return written;
+    return result;
 }
 //# sourceMappingURL=generate.js.map

package/dist/generators/index.js

@@ -1,8 +1,8 @@
 import { playwrightGo } from './playwright-go.js';
 import { playwrightTs } from './playwright-ts.js';
-import { seleniumJava } from './selenium-java.js';
+import { seleniumJava, seleniumJavaTestng } from './selenium-java.js';
 import { seleniumJs } from './selenium-js.js';
-export const generators = [playwrightTs, playwrightGo, seleniumJava, seleniumJs];
+export const generators = [playwrightTs, playwrightGo, seleniumJava, seleniumJavaTestng, seleniumJs];
 export function findGenerator(id) {
     const generator = generators.find(g => g.id === id);
     if (!generator)

package/dist/generators/javascript-body.js

@@ -1,13 +1,40 @@
-import { asLocator } from '../vendor/playwright/locatorGenerators.js';
+import { JavaScriptLocatorFactory, asLocator, asLocatorWithFactory } from '../vendor/playwright/locatorGenerators.js';
 import { formatObject } from '../vendor/playwright/stringUtils.js';
 import { PageAliases, isBlankUrl, shortcutOf, signalsOf, toKeyboardModifiers } from '../recording.js';
+import { isEmpty, joinPieces } from './test-data.js';
 import { singleQuote } from './writer.js';
+const javaScriptPieces = {
+    text: singleQuote,
+    column: (column) => `row.${column.name}`,
+    secret: (secret) => `secret(${singleQuote(secret.name)})`,
+};
+// `const rows = readCsv(...)` for a data-driven test, its column list wrapped at 120 characters.
+export function writeReadCsv(w, dataFile, columns) {
+    w.line(`// Data-driven: the test runs once per row of ${dataFile}, next to this file. Its first row holds the recorded values.`);
+    const head = `const rows = readCsv(path.join(__dirname, ${singleQuote(dataFile)}), [`;
+    const names = columns.map(c => singleQuote(c.name));
+    if (head.length + names.join(', ').length + 3 <= 120) {
+        w.line(`${head}${names.join(', ')}]);`);
+        return;
+    }
+    w.line(head);
+    const lines = [''];
+    for (const name of names) {
+        const last = lines[lines.length - 1];
+        if (last && 2 + last.length + name.length + 2 > 120)
+            lines.push(name + ',');
+        else
+            lines[lines.length - 1] = (last ? last + ' ' : '') + name + ',';
+    }
+    w.indent(() => lines.forEach(line => w.line(line)));
+    w.line(']);');
+}
 // Test body written against the Playwright JavaScript API. Used by the Playwright target and by
 // the Selenium JavaScript target, whose support file implements the same API on WebDriver.
 // Follows Playwright's own `playwright-test` code generator.
 export function writeJavaScriptBody(w, recording, options) {
     const aliases = new PageAliases();
-    for (const actionInContext of recording.actions) {
+    recording.actions.forEach((actionInContext, index) => {
         const action = actionInContext.action;
         // Resolve before skipping, so pages are numbered in the order they are opened.
         const pageAlias = aliases.alias(actionInContext.pageGuid);
@@ -16,11 +43,11 @@ export function writeJavaScriptBody(w, recording, options) {
                 w.line(`const ${pageAlias} = await page.context().newPage();`);
             if (!isBlankUrl(action.url))
                 w.line(`await ${pageAlias}.goto(${singleQuote(action.url)});`);
-            continue;
+            return;
         }
         // The test runner closes pages itself.
         if (action.name === 'closePage')
-            continue;
+            return;
         const signals = signalsOf(actionInContext);
         if (signals.dialog) {
             w.line(`${pageAlias}.once('dialog', dialog => {`);
@@ -38,17 +65,22 @@ export function writeJavaScriptBody(w, recording, options) {
             w.line(`const ${download}Promise = ${pageAlias}.waitForEvent('download');`);
         if (signals.download && !download)
             w.line(options.todo('the next step starts a download, which is not checked here.'));
-        w.line(actionCall(pageAlias, actionInContext, options));
+        const literals = {
+            value: (text) => options.values.value(index, text),
+            locator: (selector) => javaScriptLocator(selector, text => expression(options.values.locator(index, text))),
+        };
+        w.line(actionCall(pageAlias, actionInContext, options, literals));
         if (popupAlias)
             w.line(`const ${popupAlias} = await ${popupAlias}Promise;`);
         if (download)
             w.line(`const ${download} = await ${download}Promise;`);
         if (recording.header.generateExpectSignal && signals.expect)
-            w.line(`await expect(${pageAlias}.${asLocator('javascript', signals.expect.selector)}).toBeVisible();`);
-    }
+            w.line(`await expect(${pageAlias}.${literals.locator(signals.expect.selector)}).toBeVisible();`);
+    });
 }
-function actionCall(subject, { action }, options) {
-    const locator = 'selector' in action ? `${subject}.${asLocator('javascript', action.selector)}` : subject;
+function actionCall(subject, { action }, options, literals) {
+    const locator = 'selector' in action ? `${subject}.${literals.locator(action.selector)}` : subject;
+    const value = (text) => joinPieces(literals.value(text), javaScriptPieces);
     switch (action.name) {
         case 'click': {
             const method = action.clickCount === 2 ? 'dblclick' : 'click';
@@ -71,7 +103,7 @@ function actionCall(subject, { action }, options) {
         case 'uncheck':
             return `await ${locator}.uncheck();`;
         case 'fill':
-            return `await ${locator}.fill(${singleQuote(action.text)});`;
+            return `await ${locator}.fill(${value(action.text)});`;
         case 'setInputFiles':
             return `await ${locator}.setInputFiles(${formatObject(action.files.length === 1 ? action.files[0] : action.files)});`;
         case 'press':
@@ -79,15 +111,15 @@ function actionCall(subject, { action }, options) {
         case 'navigate':
             return `await ${subject}.goto(${singleQuote(action.url)});`;
         case 'select':
-            return `await ${locator}.selectOption(${formatObject(action.options.length === 1 ? action.options[0] : action.options)});`;
+            return `await ${locator}.selectOption(${action.options.length === 1 ? value(action.options[0]) : formatObject(action.options)});`;
         case 'assertText':
-            return `await expect(${locator}).${action.substring ? 'toContainText' : 'toHaveText'}(${singleQuote(action.text)});`;
+            return `await expect(${locator}).${action.substring ? 'toContainText' : 'toHaveText'}(${value(action.text)});`;
         case 'assertChecked':
             return `await expect(${locator})${action.checked ? '' : '.not'}.toBeChecked();`;
         case 'assertVisible':
             return `await expect(${locator}).toBeVisible();`;
         case 'assertValue':
-            return `await expect(${locator}).${action.value ? `toHaveValue(${singleQuote(action.value)})` : 'toBeEmpty()'};`;
+            return `await expect(${locator}).${isEmpty(literals.value(action.value)) ? 'toBeEmpty()' : `toHaveValue(${value(action.value)})`};`;
         case 'assertSnapshot':
             if (action.ariaSnapshot)
                 return `await expect(${locator}).toMatchAriaSnapshot(${singleQuote(action.ariaSnapshot)});`;
@@ -96,6 +128,52 @@ function actionCall(subject, { action }, options) {
             return options.todo(`unsupported recorded action ${JSON.stringify(action)}`);
     }
 }
+// An expression for a locator text, or undefined to keep the text as a literal.
+function expression(pieces) {
+    return pieces.length === 1 && 'text' in pieces[0] ? undefined : joinPieces(pieces, javaScriptPieces);
+}
+// Playwright's own JavaScript locator code, with some texts written as expressions. Those texts are
+// rendered as placeholders first, so that everything else keeps Playwright's formatting.
+function javaScriptLocator(selector, textExpression) {
+    const expressions = [];
+    const placeholder = (text) => {
+        const replacement = typeof text === 'string' ? textExpression(text) : undefined;
+        if (replacement === undefined)
+            return text;
+        expressions.push(replacement);
+        return `__testgen_${expressions.length - 1}__`;
+    };
+    const inner = new JavaScriptLocatorFactory();
+    const factory = {
+        generateLocator(base, kind, body, options = {}) {
+            switch (kind) {
+                case 'role':
+                    return inner.generateLocator(base, kind, body, { ...options, name: placeholder(options.name) });
+                case 'default':
+                    return inner.generateLocator(base, kind, body, { ...options, hasText: placeholder(options.hasText), hasNotText: placeholder(options.hasNotText) });
+                case 'has-text':
+                case 'has-not-text':
+                case 'test-id':
+                case 'text':
+                case 'alt':
+                case 'placeholder':
+                case 'label':
+                case 'title':
+                    return inner.generateLocator(base, kind, placeholder(body), options);
+                default:
+                    return inner.generateLocator(base, kind, body, options);
+            }
+        },
+        chainLocators: locators => inner.chainLocators(locators),
+    };
+    try {
+        return asLocatorWithFactory(factory, selector).replace(/'__testgen_(\d+)__'/g, (_, i) => expressions[Number(i)]);
+    }
+    catch {
+        // Not a selector Playwright can turn into locators: asLocator() keeps it as it is.
+        return asLocator('javascript', selector);
+    }
+}
 function formatOptions(value) {
     return Object.values(value).some(v => v !== undefined) ? formatObject(value) : '';
 }

package/dist/generators/playwright-go.js

@@ -2,6 +2,8 @@ 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 { readRuntimeFile } from './runtime.js';
+import { collectTestValues, isEmpty, joinPieces, toCsv } from './test-data.js';
 import { CodeWriter, doubleQuote } from './writer.js';
 const playwrightGoModule = 'github.com/mxschmitt/playwright-go';
 // Roles with a playwright.AriaRole<Name> constant in playwright-go.
@@ -12,15 +14,29 @@ const ariaRoles = new Set(('alert alertdialog application article banner blockqu
     '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);
+// Names a secret's variable cannot take: Go keywords, imported packages and the test's own variables.
+const goNames = new Set(('break case chan const continue default defer else fallthrough for func go goto if import interface ' +
+    'map package range return select struct switch type var fmt os playwright regexp require testing ' +
+    'pw err browser context page expect device dialog t i row ok').split(' '));
+const reservedName = (name) => goNames.has(name) || /^page\d+$/.test(name);
 export const playwrightGo = {
     id: 'playwright-go',
     framework: 'Playwright for Go (playwright-go)',
     language: 'Go',
     highlight: 'go',
+    features: ['dataDriven'],
     testFileName: name => `${snakeCase(name)}_test.go`,
     generate(recording, options) {
         const imports = new Set(['os', 'testing']);
         const locators = new GoLocators(() => imports.add('regexp'));
+        const values = collectTestValues(recording, { dataDriven: options.dataDriven, reserved: reservedName });
+        const { columns } = values;
+        const dataFile = `testdata/${snakeCase(options.name)}.csv`;
+        const goPieces = {
+            text: doubleQuote,
+            column: (column) => `row[${doubleQuote(column.name)}]`,
+            secret: (secret) => values.variable(secret),
+        };
         const body = new CodeWriter('\t');
         const aliases = new PageAliases();
         const declared = new Set();
@@ -60,7 +76,12 @@ export const playwrightGo = {
                     body.line('_ = dialog.Dismiss()');
                 }, '})');
             }
-            const call = actionCall(pageAlias, action, locators);
+            const literals = {
+                value: text => joinPieces(values.value(index, text), goPieces),
+                isEmpty: text => isEmpty(values.value(index, text)),
+                locator: text => joinPieces(values.locator(index, text), goPieces),
+            };
+            const call = actionCall(pageAlias, action, locators, literals);
             if (action.name.startsWith('assert'))
                 usesExpect = true;
             if (call.todo)
@@ -81,15 +102,18 @@ export const playwrightGo = {
             }
             if (recording.header.generateExpectSignal && signals.expect) {
                 usesExpect = true;
-                emit(body, { expr: `expect.Locator(${locators.render(pageAlias, parseLocator(signals.expect.selector))}).ToBeVisible()`, returnsValue: false });
+                emit(body, { expr: `expect.Locator(${locators.render(pageAlias, parseLocator(signals.expect.selector), literals.locator)}).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 });
+        if (columns.length)
+            imports.add('fmt');
+        const packageName = goPackageName(options.packageName);
         const w = new CodeWriter('\t');
-        w.line(`package ${goPackageName(options.packageName)}`);
+        w.line(`package ${packageName}`);
         w.line();
         w.line('import (');
         w.indent(() => {
@@ -103,6 +127,14 @@ export const playwrightGo = {
         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) {`, () => {
+            if (values.secrets.length) {
+                w.line('// Values typed into password fields are not kept in the test: set them as environment variables.');
+                for (const secret of values.secrets) {
+                    w.line(`${values.variable(secret)}, ok := os.LookupEnv(${doubleQuote(secret.name)})`);
+                    w.line(`require.True(t, ok, ${doubleQuote(`set the environment variable ${secret.name}, the value to type into a password field`)})`);
+                }
+                w.line();
+            }
             w.line('pw, err := playwright.Run()');
             w.line('require.NoError(t, err)');
             w.line('t.Cleanup(func() { _ = pw.Stop() })');
@@ -118,16 +150,42 @@ export const playwrightGo = {
             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)');
+            const newContext = `context, err := browser.NewContext(${context.fields.length ? structLiteral('playwright.BrowserNewContextOptions', context.fields) : ''})`;
+            const setTestIdAttribute = `pw.Selectors.SetTestIdAttribute(${doubleQuote(options.testIdAttribute)})`;
+            if (!columns.length) {
+                w.line(newContext);
+                w.line('require.NoError(t, err)');
+                if (options.testIdAttribute !== 'data-testid')
+                    w.line(setTestIdAttribute);
+                if (usesExpect)
+                    w.line('expect := playwright.NewPlaywrightAssertions()');
+                w.line();
+                if (options.dataDriven)
+                    w.line('// Data-driven: nothing in the recording is typed, selected or asserted with a value, so there is no data file.');
+                w.line(body.toString().trimEnd());
+                return;
+            }
             if (options.testIdAttribute !== 'data-testid')
-                w.line(`pw.Selectors.SetTestIdAttribute(${doubleQuote(options.testIdAttribute)})`);
+                w.line(setTestIdAttribute);
             if (usesExpect)
                 w.line('expect := playwright.NewPlaywrightAssertions()');
             w.line();
-            w.line(body.toString().trimEnd());
+            w.line(`// Data-driven: a subtest runs for each row of ${dataFile}. Its first row holds the recorded values.`);
+            w.block(`for i, row := range readTestgenCSV(t, ${[dataFile, ...columns.map(c => c.name)].map(doubleQuote).join(', ')}) {`, () => {
+                w.block('t.Run(fmt.Sprintf("row %d", i+1), func(t *testing.T) {', () => {
+                    w.line(newContext);
+                    w.line('require.NoError(t, err)');
+                    w.line('t.Cleanup(func() { _ = context.Close() })');
+                    w.line();
+                    w.line(body.toString().trimEnd());
+                }, '})');
+            });
         });
-        return [{ path: this.testFileName(options.name), content: w.toString() }];
+        const files = [{ path: this.testFileName(options.name), content: w.toString() }];
+        if (columns.length) {
+            files.push({ path: 'testgen_data_test.go', content: readRuntimeFile('playwright-go/testgen_data_test.go').replace(/^package \w+$/m, `package ${packageName}`), support: true }, { path: dataFile, content: toCsv([columns.map(c => c.name), columns.map(c => c.value)]), data: true });
+        }
+        return files;
     },
 };
 function goPackageName(name) {
@@ -230,8 +288,8 @@ function contextOptions(header, testIdAttribute) {
         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;
+function actionCall(subject, action, locators, literals) {
+    const locator = 'selector' in action ? locators.render(subject, parseLocator(action.selector), literals.locator) : subject;
     const expect = (assertion) => ({ expr: `expect.Locator(${locator}).${assertion}`, returnsValue: false });
     switch (action.name) {
         case 'click': {
@@ -258,7 +316,7 @@ function actionCall(subject, action, locators) {
         case 'uncheck':
             return { expr: `${locator}.Uncheck()`, returnsValue: false };
         case 'fill':
-            return { expr: `${locator}.Fill(${doubleQuote(action.text)})`, returnsValue: false };
+            return { expr: `${locator}.Fill(${literals.value(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 };
@@ -268,15 +326,15 @@ function actionCall(subject, action, locators) {
         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 };
+            return { expr: `${locator}.SelectOption(playwright.SelectOptionValues{ValuesOrLabels: playwright.StringSlice(${action.options.length === 1 ? literals.value(action.options[0]) : action.options.map(doubleQuote).join(', ')})})`, returnsValue: true };
         case 'assertText':
-            return expect(`${action.substring ? 'ToContainText' : 'ToHaveText'}(${doubleQuote(action.text)})`);
+            return expect(`${action.substring ? 'ToContainText' : 'ToHaveText'}(${literals.value(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()');
+            return expect(literals.isEmpty(action.value) ? 'ToBeEmpty()' : `ToHaveValue(${literals.value(action.value)})`);
         case 'assertSnapshot':
             if (action.ariaSnapshot)
                 return expect(`ToMatchAriaSnapshot(${doubleQuote(action.ariaSnapshot)})`);
@@ -289,15 +347,21 @@ function actionCall(subject, action, locators) {
 // Renders Playwright locator steps as playwright-go calls.
 class GoLocators {
     _onRegexp;
+    _literal = doubleQuote;
     constructor(_onRegexp) {
         this._onRegexp = _onRegexp;
     }
-    render(subject, steps) {
+    // `literal` writes the text arguments of GetBy* and Filter calls.
+    render(subject, steps, literal = doubleQuote) {
+        this._literal = literal;
+        return this._render(subject, steps);
+    }
+    _render(subject, steps) {
         return subject + steps.map(step => '.' + this._step(subject, step)).join('');
     }
     _value(matcher) {
         if (!isRegex(matcher))
-            return doubleQuote(matcher);
+            return this._literal(matcher);
         this._onRegexp();
         const flags = matcher.flags.replace(/[^ims]/g, '');
         const source = (flags ? `(?${flags})` : '') + matcher.source;
@@ -335,15 +399,15 @@ class GoLocators {
             case 'has-not-text':
                 return filter('HasNotText', this._value(step.body));
             case 'has':
-                return filter('Has', this.render(subject, step.inner));
+                return filter('Has', this._render(subject, step.inner));
             case 'hasNot':
-                return filter('HasNot', this.render(subject, step.inner));
+                return filter('HasNot', this._render(subject, step.inner));
             case 'and':
-                return `And(${this.render(subject, step.inner)})`;
+                return `And(${this._render(subject, step.inner)})`;
             case 'or':
-                return `Or(${this.render(subject, step.inner)})`;
+                return `Or(${this._render(subject, step.inner)})`;
             case 'chain':
-                return `Locator(${this.render(subject, step.inner)})`;
+                return `Locator(${this._render(subject, step.inner)})`;
             case 'test-id':
                 return `GetByTestId(${this._value(step.body)})`;
             case 'role':