@xylentis/testgen 0.0.0-stage → 1.1.0

package/NOTICE

@@ -0,0 +1,29 @@
+testgen (@xylentis/testgen)
+Copyright (C) 2026 Xylentis (https://portal.xylentis.com)
+
+This program is free software: you can redistribute it and/or modify it under the terms of the
+GNU Affero General Public License as published by the Free Software Foundation, version 3 only
+(SPDX: AGPL-3.0-only). This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Affero General Public License in the LICENSE file for details.
+
+Additional permission under section 7 of the GNU Affero General Public License, version 3:
+
+  Test files generated by testgen, and the support files testgen writes next to them
+  (runtime/selenium/engine.js, runtime/selenium-java/TestgenSupport.java,
+  runtime/selenium-js/testgen-support.js and copies of them), may be used, copied, modified
+  and distributed under terms of your choice, as part of test code produced with testgen.
+  This permission does not cover testgen itself, nor the use of these files in another test
+  generator or code generator.
+
+Third-party code:
+
+  Files under src/vendor/playwright (compiled to dist/vendor/playwright) come from Playwright
+  (https://github.com/microsoft/playwright), Copyright (c) Microsoft Corporation, licensed under
+  the Apache License, Version 2.0 (see the LICENSE file next to them). Playwright's NOTICE reads:
+
+    Playwright
+    Copyright (c) Microsoft Corporation
+
+    This software contains code derived from the Puppeteer project (https://github.com/puppeteer/puppeteer),
+    available under the Apache 2.0 license (https://github.com/puppeteer/puppeteer/blob/master/LICENSE).

package/README.md

@@ -1,3 +1,196 @@
-# Temporary Holding Version
+# Automation Test Code: testgen
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Ghi thao tác trên web **một lần** bằng recorder của Playwright, rồi sinh test UI cho **nhiều framework và nhiều ngôn ngữ**.
+Cách dùng giống `npx playwright codegen`, nhưng không chỉ sinh code Playwright mà còn sinh cả Selenium, và thêm ngôn ngữ Go.
+
+![Giao diện testgen](https://cdn.jsdelivr.net/npm/@xylentis/testgen@1/docs/testgen-ui.png)
+
+| Target | Framework | Ngôn ngữ | File sinh ra |
+| --- | --- | --- | --- |
+| `playwright-ts` | Playwright Test (`@playwright/test`) | TypeScript | `login.spec.ts` |
+| `playwright-go` | [playwright-go](https://github.com/mxschmitt/playwright-go) + testify | Go | `login_test.go` |
+| `selenium-java` | Selenium 4 + JUnit 5 | Java 17+ | `LoginTest.java` + `TestgenSupport.java` |
+| `selenium-js` | Selenium 4 + Mocha | JavaScript | `login.spec.js` + `testgen-support.js` |
+
+## Cài đặt
+
+Cần **Node.js 22+** (khuyên dùng bản LTS 24).
+
+```bash
+npm install -g @xylentis/testgen     # cài lệnh `testgen`
+testgen ui
+
+npx @xylentis/testgen ui             # hoặc chạy luôn, không cần cài
+npm i -D @xylentis/testgen           # hoặc cài vào project, rồi gọi `npx testgen ...`
+```
+
+Để ghi thao tác cần một trình duyệt. Nếu máy đã có **Google Chrome** thì chọn Chrome là xong. Nếu muốn dùng Chromium của Playwright thì tải về bằng:
+
+```bash
+npx playwright-core install chromium
+```
+
+## Dùng giao diện (khuyên dùng)
+
+```bash
+testgen ui                  # mở http://127.0.0.1:9323
+```
+
+1. Nhập URL, chọn trình duyệt rồi bấm **Record**.
+2. Một cửa sổ trình duyệt mở ra. Bạn thao tác như người dùng thật: click, gõ, chọn…
+   - Thanh công cụ của recorder nằm ở đầu trang, dùng để thêm assert: *Assert visibility*, *Assert text*, *Assert value*.
+   - Cửa sổ Playwright Inspector được ẩn đi, chỉ còn trình duyệt bạn đang thao tác. Muốn hiện lại thì dùng `testgen record --inspector`.
+3. Trong khi bạn thao tác, giao diện testgen cập nhật **danh sách bước** và **code của cả 4 target**.
+4. Đóng trình duyệt hoặc bấm **Stop** khi xong.
+5. Với từng target, bạn có thể **Copy**, **Download** hoặc **Save files** để lưu thẳng vào thư mục project. Đường dẫn tính từ thư mục bạn chạy `testgen ui`.
+
+Một số thao tác khác:
+
+- **Đổi Test name / Package / Test id attribute:** code sinh lại ngay.
+- **Download recording:** lưu file `.jsonl` để lần sau sinh lại.
+- **Open recording…:** mở lại một file đã lưu.
+
+## Dùng dòng lệnh
+
+```bash
+# Ghi rồi sinh luôn (đóng trình duyệt là sinh). Mặc định ra ./generated/<target>/
+testgen record https://your-app.example --channel chrome
+
+# Chỉ một vài target, chọn thư mục ra
+testgen record https://your-app.example -t selenium-java,playwright-go -d tests/generated
+
+# Sinh lại từ một bản ghi đã lưu
+testgen generate generated/recording.jsonl -t selenium-java -o src/test/java/com/acme/e2e/LoginTest.java
+testgen generate generated/recording.jsonl -t playwright-go -o e2e/login_test.go
+testgen generate generated/recording.jsonl -d out          # tất cả target, mỗi target một thư mục
+
+testgen targets                                            # liệt kê target
+```
+
+| Tùy chọn | Ý nghĩa |
+| --- | --- |
+| `-t, --target` | Danh sách target, cách nhau bằng dấu phẩy. Mặc định là tất cả. |
+| `-o, --output` | File test cần ghi, chỉ dùng khi có 1 target. File hỗ trợ (support) được đặt cạnh file test. |
+| `-d, --out-dir` | Thư mục ra. Nếu có nhiều target thì mỗi target một thư mục con. |
+| `-n, --name` | Tên test. Mặc định lấy từ tên file `--output`, nếu không có thì là `recorded`. |
+| `--package` | Package cho Java/Go. Java tự lấy từ đường dẫn sau `src/test/java/`, Go tự lấy từ tên thư mục. |
+| `--test-id-attribute` | Thuộc tính dùng cho `getByTestId` (mặc định `data-testid`). |
+| `--save` | (`record`) Nơi lưu bản ghi `.jsonl`. |
+| `--browser`, `--channel`, `--device`, `--viewport-size`, `--lang`, `--timezone`, `--color-scheme`, `--user-agent`, `--ignore-https-errors`, `--load-storage`, `--save-storage` | (`record`) Giống hệt `playwright codegen`. |
+| `--inspector` | (`record`) Hiện thêm cửa sổ Playwright Inspector (mặc định ẩn). |
+
+## Chạy test đã sinh
+
+Trong `e2e/projects/` có sẵn project mẫu cho từng target. Đó là đúng các project dùng để kiểm thử testgen, nên copy về dùng ngay được.
+
+**playwright-ts**: cần `@playwright/test` (xem `e2e/projects/playwright-ts`):
+
+```bash
+npm i -D @playwright/test && npx playwright install chromium
+npx playwright test
+```
+
+**playwright-go**: lưu ý module path hiện tại là `github.com/mxschmitt/playwright-go`:
+
+```bash
+go get github.com/mxschmitt/playwright-go@v0.6201.1 github.com/stretchr/testify
+go run github.com/mxschmitt/playwright-go/cmd/playwright install --with-deps chromium
+go test ./...                 # HEADED=1 go test ./... để xem trình duyệt
+```
+
+**selenium-java**: cần `selenium-java` và `junit-jupiter` (xem `e2e/projects/selenium-java/pom.xml`). `LoginTest.java` và `TestgenSupport.java` phải nằm cùng package. Chạy bằng `mvn test`.
+
+**selenium-js**: cần `selenium-webdriver` và `mocha` (xem `e2e/projects/selenium-js`). `testgen-support.js` phải nằm cạnh file test. Chạy bằng `npx mocha`.
+
+Biến môi trường mà test Selenium hiểu:
+
+- `HEADED=1`: hiện trình duyệt.
+- `SELENIUM_REMOTE_URL=http://grid:4444`: chạy trên Selenium Grid.
+- `TESTGEN_TIMEOUT=15000`: thời gian tự chờ, đơn vị ms, mặc định 10000.
+
+### Code Selenium trông như thế nào
+
+Selenium không có `getByRole` hay `getByText`, cũng không tự chờ element. Vì vậy test Selenium đi kèm một **file hỗ trợ** (`TestgenSupport.java` / `testgen-support.js`) để code sinh ra vẫn gọn và chạy ổn định:
+
+```java
+page.navigate("http://127.0.0.1:4321/");
+page.getByRole("textbox", "Email").fill("qa@example.com");
+page.getByLabel("Country").selectOption("jp");
+page.getByRole("button", "Sign in").click();
+page.getByTestId("welcome").shouldContainText("Welcome, qa@example.com (jp)");
+page.getByRole("listitem").filterHasText("Buy milk Delete").getByRole("button").click();
+var page1 = page.waitForPopup(() -> page.getByRole("link", "Open help").click());
+```
+
+Bản JavaScript dùng **đúng API của Playwright** (`page.getByRole('button', { name: 'Sign in' })`, `expect(...).toHaveText(...)`). Thân test vì thế giống hệt bản `playwright-ts`, chỉ khác phần khởi tạo driver.
+
+Bên dưới vẫn là Selenium WebDriver: các hành động dùng `WebElement.click()`, `sendKeys()`, `Select`, `Actions`. Biến `driver` vẫn có sẵn trong test nếu bạn cần viết thêm code Selenium thuần.
+
+## Cách hoạt động
+
+```
+ Bạn thao tác trên trình duyệt
+        │  recorder của Playwright (như `playwright codegen --target=jsonl`, Inspector ẩn), ghi lại mỗi bước
+        ▼
+ recording.jsonl   ── danh sách bước, chưa gắn với ngôn ngữ nào (click, fill, assertText…)
+        │  selector → chuỗi locator: dùng lại mã của Playwright (src/vendor/playwright)
+        ▼
+ Generators (src/generators/*)
+   ├─ playwright-ts   giống `playwright codegen --target playwright-test`
+   ├─ playwright-go   API playwright-go + require.NoError
+   ├─ selenium-java   JUnit 5 + TestgenSupport.java
+   └─ selenium-js     Mocha + testgen-support.js
+                          └─ runtime/selenium/engine.js: chạy trong trang (executeScript)
+                             để tìm element theo role / text / label / test id… như Playwright
+```
+
+- **Recorder:** dùng nguyên recorder của Playwright, nên cách chọn locator (ưu tiên test id, role + tên, label…) giống hệt Playwright codegen.
+- **Engine locator cho Selenium:** được kiểm tra bằng cách so kết quả với chính Playwright trên 70 locator mẫu (`test/engine.test.ts`).
+
+## Giới hạn hiện tại
+
+- **Định dạng JSONL là định dạng nội bộ của Playwright.** Vì vậy `playwright-core` được ghim ở `1.63.0`. Khi nâng cấp phải chạy lại `npm test` và `npm run e2e` (xem `src/vendor/playwright/README.md`).
+- **Selenium không làm được các việc sau**, nên chỗ đó sẽ có comment `// TODO(testgen)`:
+  - chờ download;
+  - assert aria snapshot (thay bằng kiểm tra visible);
+  - click chuột giữa;
+  - giả lập thiết bị đầy đủ (chỉ áp dụng viewport và user agent);
+  - `colorScheme` / `timezone` / `geolocation`;
+  - lưu storage state.
+- **`getByRole` trên Selenium chỉ gần đúng**, vì thuật toán tính accessible name được đơn giản hóa. Khi gặp sai lệch, hãy thêm `data-testid` cho app, hoặc thêm trường hợp đó vào `test/engine.test.ts`.
+- **Bản ghi không lưu đường dẫn đầy đủ của file upload**, chỉ có tên file. Cần sửa đường dẫn trong `setInputFiles(...)`.
+
+## Phát triển
+
+Package trên npm chỉ chứa bản build. Để sửa code thì làm việc trên repo:
+
+```bash
+npm ci            # tự build (script prepare); gọi tool bằng `node dist/cli.js`
+npm test          # vitest: so engine với Playwright, snapshot code sinh ra, test giao diện (cần Chrome)
+npm run e2e       # sinh test cho cả 4 target rồi chạy trên app demo e2e/app (cần Go, JDK 17+ và Maven, Chrome)
+E2E_TARGETS="selenium-js playwright-go" npm run e2e
+```
+
+- **Ghi lại bản demo:** chạy app (`e2e/app`) ở cổng 4321, rồi chạy `node e2e/record-demo.mjs`. Script này điều khiển recorder thật của Playwright, không cần người thao tác.
+- **Code sinh ra cho 2 bản ghi mẫu** được lưu thành snapshot trong `test/__snapshots__/`. Đổi generator thì chạy `npx vitest run -u` và review diff.
+- **Thêm target mới:**
+  1. Viết một `Generator` trong `src/generators/` và đăng ký trong `src/generators/index.ts`.
+  2. Thêm project mẫu trong `e2e/projects/`.
+  3. Thêm bước chạy trong `e2e/run.sh`.
+
+```
+src/            CLI (cli.ts), đọc bản ghi, generators, server giao diện (ui/server.ts)
+src/vendor/     mã lấy từ Playwright (Apache-2.0), xem NOTICE
+runtime/        file hỗ trợ Selenium (Java, JS) + engine locator chạy trong trang
+ui/             giao diện web (HTML/CSS/JS thuần, không cần build)
+test/           unit test, fixture, snapshot
+e2e/            app demo, bản ghi thật, project mẫu cho từng target, run.sh
+```
+
+## License
+
+[GNU AGPL-3.0-only](LICENSE), Copyright (C) 2026 Xylentis.
+
+- **testgen:** ai sửa testgen rồi phát hành lại, kể cả đem chạy thành dịch vụ qua mạng, đều phải công bố mã nguồn bản đã sửa theo AGPL.
+- **Code sinh ra:** test do testgen sinh ra và các file hỗ trợ đi kèm (`TestgenSupport.java`, `testgen-support.js`, engine) được dùng, sửa và phân phối **tự do** trong test của bạn, theo điều khoản bổ sung ở mục 7 của AGPL. Điều khoản này không cho phép dùng các file đó để làm một công cụ sinh code khác. Xem [NOTICE](NOTICE).
+- **Code lấy từ Playwright:** các file trong `src/vendor/playwright` vẫn theo Apache License 2.0.

package/dist/cli.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { generateTargets, writeTargets } from './generate.js';
+import { generators } from './generators/index.js';
+import { startCodegen, waitForExit } from './record.js';
+import { parseRecording } from './recording.js';
+import { startUiServer } from './ui/server.js';
+const usage = `testgen: record a UI test once with the Playwright recorder, then generate it for several
+frameworks and languages.
+
+Usage:
+  testgen ui [--port <port>] [--no-open]            Web UI: record and watch the code of every target live
+  testgen record [url] [options]                    Record in a browser, generate when it is closed
+  testgen generate <recording.jsonl> [options]      Generate tests from a saved recording
+  testgen targets                                   List the available targets
+
+Output options:
+  -t, --target <ids>           Comma-separated targets (default: all of them)
+  -o, --output <file>          Test file to write (one target only); support files go next to it
+  -d, --out-dir <dir>          Output directory; one sub-directory per target when there are several
+                               (default for record: ./generated)
+  -n, --name <name>            Test name (default: taken from --output, else "recorded")
+      --package <name>         Java or Go package (default: derived from the output path)
+      --test-id-attribute <a>  Attribute used by getByTestId (default: data-testid)
+      --save <file.jsonl>      record: where to keep the recording (default: <out-dir>/recording.jsonl)
+
+Recorder options (record), same as playwright codegen:
+  --browser <chromium|firefox|webkit>  --channel <chrome|msedge|...>  --device <name>
+  --viewport-size <w,h>  --lang <locale>  --timezone <id>  --color-scheme <light|dark>
+  --user-agent <ua>  --ignore-https-errors  --load-storage <file>  --save-storage <file>
+  --inspector                 also show Playwright's Inspector window (hidden by default)
+`;
+const options = {
+    'target': { type: 'string', short: 't' },
+    'output': { type: 'string', short: 'o' },
+    'out-dir': { type: 'string', short: 'd' },
+    'name': { type: 'string', short: 'n' },
+    'package': { type: 'string' },
+    'test-id-attribute': { type: 'string', default: 'data-testid' },
+    'save': { type: 'string' },
+    'browser': { type: 'string', short: 'b' },
+    'channel': { type: 'string' },
+    'device': { type: 'string' },
+    'viewport-size': { type: 'string' },
+    'lang': { type: 'string' },
+    'timezone': { type: 'string' },
+    'color-scheme': { type: 'string' },
+    'user-agent': { type: 'string' },
+    'ignore-https-errors': { type: 'boolean' },
+    'load-storage': { type: 'string' },
+    'save-storage': { type: 'string' },
+    'inspector': { type: 'boolean' },
+    'port': { type: 'string', default: '9323' },
+    'host': { type: 'string', default: '127.0.0.1' },
+    'open': { type: 'boolean', default: true },
+    'help': { type: 'boolean', short: 'h' },
+};
+async function main(argv) {
+    const { values, positionals } = parseArgs({ args: argv, options, allowPositionals: true, allowNegative: true });
+    const [command, ...rest] = positionals;
+    if (values.help || !command) {
+        process.stdout.write(usage);
+        return;
+    }
+    const targets = values.target ? values.target.split(',').map(t => t.trim()).filter(Boolean) : generators.map(g => g.id);
+    const output = {
+        targets,
+        output: values.output,
+        name: values.name,
+        packageName: values.package,
+        testIdAttribute: values['test-id-attribute'],
+    };
+    switch (command) {
+        case 'targets':
+            for (const generator of generators)
+                console.log(`${generator.id.padEnd(16)}${generator.framework} (${generator.language})`);
+            return;
+        case 'generate': {
+            const file = rest[0];
+            if (!file)
+                throw new Error('Usage: testgen generate <recording.jsonl> [options]');
+            const recording = parseRecording(fs.readFileSync(file, 'utf8'), file);
+            if (!values.output && !values['out-dir']) {
+                if (targets.length !== 1)
+                    throw new Error('Pass --out-dir (or a single --target to print the test to stdout).');
+                const [{ files }] = generateTargets(recording, output);
+                process.stdout.write(files[0].content);
+                for (const support of files.slice(1))
+                    console.error(`note: the test also needs ${support.path}; use --out-dir or --output to write it.`);
+                return;
+            }
+            report(writeTargets(generateTargets(recording, { ...output, outDir: values['out-dir'] })));
+            return;
+        }
+        case 'record': {
+            const outDir = values['out-dir'] ?? (values.output ? undefined : 'generated');
+            const save = path.resolve(values.save ?? path.join(outDir ?? path.dirname(values.output), 'recording.jsonl'));
+            fs.mkdirSync(path.dirname(save), { recursive: true });
+            fs.rmSync(save, { force: true });
+            const codegen = {
+                browser: values.browser,
+                channel: values.channel,
+                device: values.device,
+                viewportSize: values['viewport-size'],
+                lang: values.lang,
+                timezone: values.timezone,
+                colorScheme: values['color-scheme'],
+                userAgent: values['user-agent'],
+                ignoreHttpsErrors: values['ignore-https-errors'],
+                loadStorage: values['load-storage'],
+                saveStorage: values['save-storage'],
+                testIdAttribute: values['test-id-attribute'],
+                inspector: values.inspector,
+            };
+            console.log('Recording... interact with the page, then close the browser window (or press Ctrl+C) to generate the tests.');
+            const recorder = startCodegen(rest[0], save, codegen);
+            // Ctrl+C ends the recording, not testgen: the tests are still generated afterwards.
+            const stopRecorder = () => recorder.kill('SIGINT');
+            process.on('SIGINT', stopRecorder);
+            const code = await waitForExit(recorder);
+            process.off('SIGINT', stopRecorder);
+            if (!fs.existsSync(save))
+                throw new Error(`Nothing was recorded (the recorder exited with code ${code}).`);
+            console.log(`Recording saved to ${path.relative(process.cwd(), save)}`);
+            report(writeTargets(generateTargets(parseRecording(fs.readFileSync(save, 'utf8'), save), { ...output, outDir })));
+            return;
+        }
+        case 'ui': {
+            const server = await startUiServer({ port: Number(values.port), host: values.host, cwd: process.cwd() });
+            console.log(`testgen UI: ${server.url}  (Ctrl+C to stop)`);
+            if (values.open)
+                openInBrowser(server.url);
+            const stop = () => server.close().then(() => process.exit(0));
+            process.on('SIGINT', stop);
+            process.on('SIGTERM', stop);
+            return;
+        }
+        default:
+            throw new Error(`Unknown command "${command}".\n\n${usage}`);
+    }
+}
+function report(files) {
+    for (const file of files)
+        console.log(`  wrote ${path.relative(process.cwd(), file)}`);
+}
+function openInBrowser(url) {
+    const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    spawn(command, args, { stdio: 'ignore', detached: true }).on('error', () => { }).unref();
+}
+main(process.argv.slice(2)).catch(error => {
+    console.error(`testgen: ${error.message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/generate.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { findGenerator } from './generators/index.js';
+import { nameFromFileName } from './naming.js';
+export function generateTargets(recording, options) {
+    if (!options.targets.length)
+        throw new Error('Pick at least one target with --target.');
+    if (options.output && options.targets.length > 1)
+        throw new Error('--output takes a single target; use --out-dir for several targets.');
+    return options.targets.map(id => {
+        const generator = findGenerator(id);
+        const directory = options.output
+            ? path.dirname(options.output)
+            : 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: options.testIdAttribute });
+        if (options.output)
+            files[0] = { ...files[0], path: path.basename(options.output) };
+        return { generator, directory, files };
+    });
+}
+// 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) {
+    const absolute = path.resolve(directory).split(path.sep).join('/');
+    if (generator.language === 'Java') {
+        const match = /\/src\/(?:test|main|it)\/java\/(.+)$/.exec(absolute);
+        return match ? match[1].split('/').join('.') : undefined;
+    }
+    if (generator.language === 'Go' && /^[a-z][a-z0-9_]*$/.test(path.basename(absolute)))
+        return path.basename(absolute);
+    return undefined;
+}
+export function writeTargets(outputs) {
+    const written = [];
+    for (const { directory, files } of outputs) {
+        fs.mkdirSync(directory, { recursive: true });
+        for (const file of files) {
+            const filePath = path.join(directory, file.path);
+            fs.writeFileSync(filePath, file.content);
+            written.push(filePath);
+        }
+    }
+    return written;
+}
+//# sourceMappingURL=generate.js.map

package/dist/generators/index.js

@@ -0,0 +1,12 @@
+import { playwrightGo } from './playwright-go.js';
+import { playwrightTs } from './playwright-ts.js';
+import { seleniumJava } from './selenium-java.js';
+import { seleniumJs } from './selenium-js.js';
+export const generators = [playwrightTs, playwrightGo, seleniumJava, seleniumJs];
+export function findGenerator(id) {
+    const generator = generators.find(g => g.id === id);
+    if (!generator)
+        throw new Error(`Unknown target "${id}". Available targets: ${generators.map(g => g.id).join(', ')}`);
+    return generator;
+}
+//# sourceMappingURL=index.js.map

package/dist/generators/javascript-body.js

@@ -0,0 +1,102 @@
+import { asLocator } from '../vendor/playwright/locatorGenerators.js';
+import { formatObject } from '../vendor/playwright/stringUtils.js';
+import { PageAliases, isBlankUrl, shortcutOf, signalsOf, toKeyboardModifiers } from '../recording.js';
+import { singleQuote } from './writer.js';
+// 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) {
+        const action = actionInContext.action;
+        // Resolve before skipping, so pages are numbered in the order they are opened.
+        const pageAlias = aliases.alias(actionInContext.pageGuid);
+        if (action.name === 'openPage') {
+            if (pageAlias !== 'page')
+                w.line(`const ${pageAlias} = await page.context().newPage();`);
+            if (!isBlankUrl(action.url))
+                w.line(`await ${pageAlias}.goto(${singleQuote(action.url)});`);
+            continue;
+        }
+        // The test runner closes pages itself.
+        if (action.name === 'closePage')
+            continue;
+        const signals = signalsOf(actionInContext);
+        if (signals.dialog) {
+            w.line(`${pageAlias}.once('dialog', dialog => {`);
+            w.indent(() => {
+                w.line('console.log(`Dialog message: ${dialog.message()}`);');
+                w.line('dialog.dismiss().catch(() => {});');
+            });
+            w.line('});');
+        }
+        const popupAlias = signals.popup ? aliases.alias(signals.popup.popupPageGuid) : undefined;
+        const download = signals.download && options.supportsDownloads ? `download${signals.download.downloadAlias}` : undefined;
+        if (popupAlias)
+            w.line(`const ${popupAlias}Promise = ${pageAlias}.waitForEvent('popup');`);
+        if (download)
+            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));
+        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();`);
+    }
+}
+function actionCall(subject, { action }, options) {
+    const locator = 'selector' in action ? `${subject}.${asLocator('javascript', action.selector)}` : subject;
+    switch (action.name) {
+        case 'click': {
+            const method = action.clickCount === 2 ? 'dblclick' : 'click';
+            const clickOptions = {};
+            if (action.button !== 'left')
+                clickOptions.button = action.button;
+            const modifiers = toKeyboardModifiers(action.modifiers);
+            if (modifiers.length)
+                clickOptions.modifiers = modifiers;
+            if (action.clickCount > 2)
+                clickOptions.clickCount = action.clickCount;
+            if (action.position)
+                clickOptions.position = action.position;
+            return `await ${locator}.${method}(${formatOptions(clickOptions)});`;
+        }
+        case 'hover':
+            return `await ${locator}.hover(${formatOptions({ position: action.position })});`;
+        case 'check':
+            return `await ${locator}.check();`;
+        case 'uncheck':
+            return `await ${locator}.uncheck();`;
+        case 'fill':
+            return `await ${locator}.fill(${singleQuote(action.text)});`;
+        case 'setInputFiles':
+            return `await ${locator}.setInputFiles(${formatObject(action.files.length === 1 ? action.files[0] : action.files)});`;
+        case 'press':
+            return `await ${locator}.press(${singleQuote(shortcutOf(action))});`;
+        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)});`;
+        case 'assertText':
+            return `await expect(${locator}).${action.substring ? 'toContainText' : 'toHaveText'}(${singleQuote(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()'};`;
+        case 'assertSnapshot':
+            if (action.ariaSnapshot)
+                return `await expect(${locator}).toMatchAriaSnapshot(${singleQuote(action.ariaSnapshot)});`;
+            return `${options.todo('aria snapshot assertion; the recording does not include the snapshot.')}\nawait expect(${locator}).toBeVisible();`;
+        default:
+            return options.todo(`unsupported recorded action ${JSON.stringify(action)}`);
+    }
+}
+function formatOptions(value) {
+    return Object.values(value).some(v => v !== undefined) ? formatObject(value) : '';
+}
+//# sourceMappingURL=javascript-body.js.map