@xylentis/testgen 0.0.0-stage → 1.1.0

package/runtime/selenium-js/testgen-support.js

@@ -0,0 +1,618 @@
+// 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).
+//
+// The Playwright locator API (page.getByRole(), locator.click(), expect(locator).toHaveText(), ...)
+// implemented on Selenium WebDriver, with Playwright-like auto-waiting. Locators are resolved inside
+// the page by testgenResolve() (bottom of this file), so getByRole/getByText/getByLabel find the
+// same elements the Playwright recorder pointed at.
+//
+// Environment variables: HEADED=1 shows the browser, SELENIUM_REMOTE_URL runs on a Selenium Grid,
+// TESTGEN_TIMEOUT sets the auto-wait timeout in milliseconds (default 10000).
+'use strict';
+
+const assert = require('node:assert');
+const path = require('node:path');
+const { Browser, Builder, Button, Key, Select, until } = require('selenium-webdriver');
+const chrome = require('selenium-webdriver/chrome');
+const edge = require('selenium-webdriver/edge');
+const firefox = require('selenium-webdriver/firefox');
+const remote = require('selenium-webdriver/remote');
+
+const defaultTimeout = Number(process.env.TESTGEN_TIMEOUT || 10_000);
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+async function createDriver(browser = 'chrome', options = {}) {
+  const headed = !!process.env.HEADED;
+  const args = options.args || [];
+  const builder = new Builder();
+  if (browser === 'firefox') {
+    const firefoxOptions = new firefox.Options().addArguments(...args);
+    if (!headed)
+      firefoxOptions.addArguments('-headless');
+    builder.forBrowser(Browser.FIREFOX).setFirefoxOptions(firefoxOptions);
+  } else if (browser === 'edge') {
+    const edgeOptions = new edge.Options().addArguments(...args);
+    if (!headed)
+      edgeOptions.addArguments('--headless=new');
+    builder.forBrowser(Browser.EDGE).setEdgeOptions(edgeOptions);
+  } else if (browser === 'safari') {
+    builder.forBrowser(Browser.SAFARI);
+  } else {
+    const chromeOptions = new chrome.Options().addArguments(...args);
+    if (!headed)
+      chromeOptions.addArguments('--headless=new');
+    builder.forBrowser(Browser.CHROME).setChromeOptions(chromeOptions);
+  }
+  // Builder connects to SELENIUM_REMOTE_URL by itself when it is set.
+  const driver = await builder.build();
+  if (process.env.SELENIUM_REMOTE_URL)
+    driver.setFileDetector(new remote.FileDetector());
+  if (options.viewport)
+    await setViewportSize(driver, options.viewport.width, options.viewport.height);
+  return driver;
+}
+
+// Playwright viewports are inner sizes; WebDriver sizes the whole window.
+async function setViewportSize(driver, width, height) {
+  await driver.manage().window().setRect({ width, height });
+  const [innerWidth, innerHeight] = await driver.executeScript('return [window.innerWidth, window.innerHeight];');
+  if (innerWidth !== width || innerHeight !== height)
+    await driver.manage().window().setRect({ width: 2 * width - innerWidth, height: 2 * height - innerHeight });
+}
+
+function toMatcher(value) {
+  return value instanceof RegExp ? { source: value.source, flags: value.flags } : String(value);
+}
+
+function format(value) {
+  if (value instanceof RegExp)
+    return String(value);
+  if (value instanceof Locator)
+    return value.toString();
+  if (typeof value === 'string')
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, '\\\'')}'`;
+  if (value && typeof value === 'object')
+    return `{ ${Object.entries(value).map(([key, v]) => `${key}: ${format(v)}`).join(', ')} }`;
+  return String(value);
+}
+
+// Text value of a selector engine body: "text"i (substring), "text"s (exact) or /regex/flags.
+function parseTextBody(body) {
+  const regex = /^\/(.*)\/([dgimsuvy]*)$/.exec(body);
+  if (regex)
+    return { v: { source: regex[1], flags: regex[2] }, exact: false };
+  if (body.endsWith('"s') || body.endsWith('"'))
+    return { v: JSON.parse(body.endsWith('"s') ? body.slice(0, -1) : body), exact: true };
+  if (body.endsWith('"i'))
+    return { v: JSON.parse(body.slice(0, -1)), exact: false };
+  return { v: body, exact: false };
+}
+
+function selectorStep(selector) {
+  if (selector.startsWith('xpath='))
+    return { t: 'xpath', v: selector.slice('xpath='.length) };
+  if (selector.startsWith('//') || selector.startsWith('..'))
+    return { t: 'xpath', v: selector };
+  if (selector.startsWith('css='))
+    return { t: 'css', v: selector.slice('css='.length) };
+  const hasText = /^internal:(has-text|has-not-text)=(.*)$/s.exec(selector);
+  if (hasText)
+    return { t: 'hasText', ...parseTextBody(hasText[2]), not: hasText[1] === 'has-not-text' };
+  const text = /^(?:internal:)?text=(.*)$/s.exec(selector);
+  if (text)
+    return { t: 'text', ...parseTextBody(text[1]) };
+  if (selector.startsWith('id='))
+    return { t: 'css', v: `[id=${JSON.stringify(selector.slice('id='.length))}]` };
+  if (/^[a-zA-Z_0-9-]+=/.test(selector) && !selector.startsWith('internal:attr='))
+    throw new Error(`testgen: selector engine not supported on Selenium: ${selector}`);
+  if (selector.startsWith('internal:'))
+    throw new Error(`testgen: selector not supported on Selenium: ${selector}`);
+  return { t: 'css', v: selector };
+}
+
+class Locator {
+  constructor(page, steps, description) {
+    this._page = page;
+    this._steps = steps;
+    this._description = description;
+  }
+
+  toString() {
+    return this._description;
+  }
+
+  _with(step, call) {
+    return new Locator(this._page, [...this._steps, step], `${this._description}.${call}`);
+  }
+
+  getByRole(role, options = {}) {
+    const step = { t: 'role', role };
+    if (options.name !== undefined)
+      step.name = toMatcher(options.name);
+    if (options.exact)
+      step.exact = true;
+    const attrs = {};
+    for (const key of ['checked', 'disabled', 'expanded', 'includeHidden', 'level', 'pressed', 'selected']) {
+      if (options[key] !== undefined)
+        attrs[key] = options[key];
+    }
+    if (Object.keys(attrs).length)
+      step.attrs = attrs;
+    return this._with(step, `getByRole(${format(role)}${Object.keys(options).length ? ', ' + format(options) : ''})`);
+  }
+
+  getByText(text, options = {}) {
+    return this._byText('text', 'getByText', text, options);
+  }
+
+  getByLabel(text, options = {}) {
+    return this._byText('label', 'getByLabel', text, options);
+  }
+
+  getByPlaceholder(text, options = {}) {
+    return this._byText('placeholder', 'getByPlaceholder', text, options);
+  }
+
+  getByAltText(text, options = {}) {
+    return this._byText('alt', 'getByAltText', text, options);
+  }
+
+  getByTitle(text, options = {}) {
+    return this._byText('title', 'getByTitle', text, options);
+  }
+
+  _byText(kind, method, text, options) {
+    const step = { t: kind, v: toMatcher(text), exact: !!options.exact };
+    return this._with(step, `${method}(${format(text)}${options.exact ? ', { exact: true }' : ''})`);
+  }
+
+  getByTestId(testId) {
+    return this._with({ t: 'testid', attr: this._page._testIdAttribute, v: toMatcher(testId) }, `getByTestId(${format(testId)})`);
+  }
+
+  locator(selectorOrLocator, options = {}) {
+    const result = selectorOrLocator instanceof Locator
+      ? new Locator(this._page, [...this._steps, ...selectorOrLocator._steps], `${this._description}.locator(${selectorOrLocator})`)
+      : this._with(selectorStep(selectorOrLocator), `locator(${format(selectorOrLocator)})`);
+    return Object.keys(options).length ? result.filter(options) : result;
+  }
+
+  frameLocator(selector) {
+    return this.locator(selector).contentFrame();
+  }
+
+  contentFrame() {
+    return this._with({ t: 'frame' }, 'contentFrame()');
+  }
+
+  filter(options = {}) {
+    let result = this;
+    if (options.hasText !== undefined)
+      result = result._with({ t: 'hasText', v: toMatcher(options.hasText) }, `filter({ hasText: ${format(options.hasText)} })`);
+    if (options.hasNotText !== undefined)
+      result = result._with({ t: 'hasText', v: toMatcher(options.hasNotText), not: true }, `filter({ hasNotText: ${format(options.hasNotText)} })`);
+    if (options.has)
+      result = result._with({ t: 'has', steps: options.has._steps }, `filter({ has: ${options.has} })`);
+    if (options.hasNot)
+      result = result._with({ t: 'has', steps: options.hasNot._steps, not: true }, `filter({ hasNot: ${options.hasNot} })`);
+    if (options.visible !== undefined)
+      result = result._with({ t: 'visible', v: !!options.visible }, `filter({ visible: ${!!options.visible} })`);
+    return result;
+  }
+
+  nth(index) {
+    return this._with({ t: 'nth', v: index }, `nth(${index})`);
+  }
+
+  first() {
+    return this._with({ t: 'nth', v: 0 }, 'first()');
+  }
+
+  last() {
+    return this._with({ t: 'nth', v: -1 }, 'last()');
+  }
+
+  and(locator) {
+    return this._with({ t: 'and', steps: locator._steps }, `and(${locator})`);
+  }
+
+  or(locator) {
+    return this._with({ t: 'or', steps: locator._steps }, `or(${locator})`);
+  }
+
+  // Elements currently matching the locator (no waiting).
+  async elements() {
+    const driver = this._page._driver;
+    await this._page._activate();
+    await driver.switchTo().defaultContent();
+    let segment = [];
+    for (const step of this._steps) {
+      if (step.t !== 'frame') {
+        segment.push(step);
+        continue;
+      }
+      const [frame] = await driver.executeScript(testgenResolve, JSON.stringify(segment));
+      if (!frame)
+        return [];
+      await driver.switchTo().frame(frame);
+      segment = [];
+    }
+    return driver.executeScript(testgenResolve, JSON.stringify(segment));
+  }
+
+  async count() {
+    return (await this.elements()).length;
+  }
+
+  // Waits for the first matching element to be ready, then runs `action` on it.
+  async _act(name, action, { visible = true, enabled = false } = {}) {
+    const deadline = Date.now() + this._page._timeout;
+    let reason = '';
+    for (;;) {
+      try {
+        const [element] = await this.elements();
+        if (!element)
+          reason = 'no element matches';
+        else if (visible && !await element.isDisplayed())
+          reason = 'element is not visible';
+        else if (enabled && !await element.isEnabled())
+          reason = 'element is not enabled';
+        else {
+          const result = await action(element);
+          await this._page._handleDialogs();
+          return result;
+        }
+      } catch (error) {
+        if (!isRetryable(error))
+          throw error;
+        reason = error.message;
+      }
+      if (Date.now() > deadline)
+        throw new Error(`${name}: timeout ${this._page._timeout}ms exceeded waiting for ${this} (${reason})`);
+      await sleep(100);
+    }
+  }
+
+  async click(options = {}) {
+    const driver = this._page._driver;
+    const simple = !options.button && !options.modifiers && !options.clickCount && !options.position;
+    return this._act('click', async element => {
+      if (simple)
+        return element.click();
+      const button = { right: Button.RIGHT, middle: Button.MIDDLE }[options.button] ?? Button.LEFT;
+      const actions = driver.actions({ async: true });
+      const keys = (options.modifiers || []).map(modifierKey);
+      keys.forEach(key => actions.keyDown(key));
+      await moveTo(actions, element, options.position);
+      for (let i = 0; i < (options.clickCount || 1); i++)
+        actions.press(button).release(button);
+      keys.reverse().forEach(key => actions.keyUp(key));
+      return actions.perform();
+    }, { enabled: true });
+  }
+
+  async dblclick() {
+    const driver = this._page._driver;
+    return this._act('dblclick', element => driver.actions({ async: true }).doubleClick(element).perform(), { enabled: true });
+  }
+
+  async hover(options = {}) {
+    const driver = this._page._driver;
+    return this._act('hover', async element => {
+      const actions = driver.actions({ async: true });
+      await moveTo(actions, element, options.position);
+      return actions.perform();
+    });
+  }
+
+  async fill(value) {
+    return this._act('fill', async element => {
+      await element.clear();
+      if (value)
+        await element.sendKeys(value);
+    }, { enabled: true });
+  }
+
+  async press(key) {
+    return this._act('press', element => element.sendKeys(toKeys(key)));
+  }
+
+  async check() {
+    return this._setChecked(true);
+  }
+
+  async uncheck() {
+    return this._setChecked(false);
+  }
+
+  async _setChecked(checked) {
+    return this._act(checked ? 'check' : 'uncheck', async element => {
+      if (await isChecked(element) !== checked)
+        await element.click();
+    }, { enabled: true });
+  }
+
+  async selectOption(values) {
+    const list = Array.isArray(values) ? values : [values];
+    return this._act('selectOption', async element => {
+      const select = new Select(element);
+      if (await select.isMultiple())
+        await select.deselectAll();
+      for (const value of list) {
+        try {
+          await select.selectByValue(value);
+        } catch {
+          await select.selectByVisibleText(value);
+        }
+      }
+    }, { enabled: true });
+  }
+
+  async setInputFiles(files) {
+    const list = (Array.isArray(files) ? files : [files]).map(file => path.resolve(file));
+    return this._act('setInputFiles', element => element.sendKeys(list.join('\n')), { visible: false });
+  }
+}
+
+async function moveTo(actions, element, position) {
+  if (!position)
+    return actions.move({ origin: element });
+  // Playwright positions are relative to the top-left corner, WebDriver offsets to the center.
+  const rect = await element.getRect();
+  return actions.move({ origin: element, x: Math.round(position.x - rect.width / 2), y: Math.round(position.y - rect.height / 2) });
+}
+
+class Page extends Locator {
+  static async attach(driver, options = {}) {
+    return new Page(driver, await driver.getWindowHandle(), options);
+  }
+
+  constructor(driver, handle, options = {}) {
+    super(null, [], 'page');
+    this._page = this;
+    this._driver = driver;
+    this._handle = handle;
+    this._options = options;
+    this._testIdAttribute = options.testIdAttribute || 'data-testid';
+    this._timeout = options.timeout || defaultTimeout;
+    this._dialogHandlers = [];
+  }
+
+  async _activate() {
+    const current = await this._driver.getWindowHandle().catch(() => undefined);
+    if (current !== this._handle)
+      await this._driver.switchTo().window(this._handle);
+  }
+
+  async goto(url) {
+    await this._activate();
+    await this._driver.get(url);
+  }
+
+  async close() {
+    await this._activate();
+    await this._driver.close();
+  }
+
+  context() {
+    return {
+      newPage: async () => {
+        await this._driver.switchTo().newWindow('tab');
+        return new Page(this._driver, await this._driver.getWindowHandle(), this._options);
+      },
+    };
+  }
+
+  // Supports 'popup': resolves to the window opened after this call.
+  waitForEvent(event) {
+    if (event !== 'popup')
+      return Promise.reject(new Error(`testgen: page.waitForEvent('${event}') is not supported on Selenium`));
+    const known = this._driver.getAllWindowHandles();
+    const popup = (async () => {
+      const before = new Set(await known);
+      const deadline = Date.now() + this._timeout;
+      for (;;) {
+        const handle = (await this._driver.getAllWindowHandles()).find(h => !before.has(h));
+        if (handle)
+          return new Page(this._driver, handle, this._options);
+        if (Date.now() > deadline)
+          throw new Error(`waitForEvent('popup'): timeout ${this._timeout}ms exceeded`);
+        await sleep(100);
+      }
+    })();
+    // Avoid an unhandled rejection when the test fails before awaiting the popup.
+    popup.catch(() => {});
+    return popup;
+  }
+
+  // Supports 'dialog': the handler runs for the next alert/confirm/prompt opened by an action.
+  once(event, handler) {
+    if (event !== 'dialog')
+      throw new Error(`testgen: page.once('${event}') is not supported on Selenium`);
+    this._dialogHandlers.push(handler);
+  }
+
+  async _handleDialogs() {
+    if (!this._dialogHandlers.length)
+      return;
+    let alert;
+    try {
+      alert = await this._driver.wait(until.alertIsPresent(), 2000);
+    } catch {
+      return;
+    }
+    const dialog = new Dialog(alert, await alert.getText());
+    await this._dialogHandlers.shift()(dialog);
+    await dialog._settled;
+  }
+}
+
+class Dialog {
+  constructor(alert, message) {
+    this._alert = alert;
+    this._message = message;
+    this._settled = Promise.resolve();
+  }
+
+  message() {
+    return this._message;
+  }
+
+  dismiss() {
+    return this._settled = this._alert.dismiss();
+  }
+
+  accept(promptText) {
+    this._settled = (async () => {
+      if (promptText !== undefined)
+        await this._alert.sendKeys(promptText);
+      await this._alert.accept();
+    })();
+    return this._settled;
+  }
+}
+
+function expect(locator) {
+  return new LocatorAssertions(locator, false);
+}
+
+class LocatorAssertions {
+  constructor(locator, negated) {
+    this._locator = locator;
+    this._negated = negated;
+  }
+
+  get not() {
+    return new LocatorAssertions(this._locator, !this._negated);
+  }
+
+  // Polls until `check` passes (or fails, when negated) for the first matching element.
+  async _poll(name, expected, check) {
+    const page = this._locator._page;
+    const deadline = Date.now() + page._timeout;
+    let actual = '<element not found>';
+    for (;;) {
+      try {
+        const [element] = await this._locator.elements();
+        const result = element ? await check(element) : { pass: false, actual: '<element not found>' };
+        if (result.pass !== this._negated)
+          return;
+        actual = result.actual;
+      } catch (error) {
+        if (!isRetryable(error))
+          throw error;
+        actual = error.message;
+      }
+      if (Date.now() > deadline) {
+        throw new assert.AssertionError({
+          message: `expect(${this._locator})${this._negated ? '.not' : ''}.${name}(${expected === undefined ? '' : format(expected)}) failed after ${page._timeout}ms\nReceived: ${actual}`,
+        });
+      }
+      await sleep(100);
+    }
+  }
+
+  async toBeVisible() {
+    return this._poll('toBeVisible', undefined, async element => {
+      const visible = await element.isDisplayed();
+      return { pass: visible, actual: visible ? 'visible' : 'hidden' };
+    });
+  }
+
+  async toHaveText(expected) {
+    return this._poll('toHaveText', expected, async element => {
+      const text = normalize(await element.getProperty('textContent'));
+      return { pass: textMatches(text, expected, true), actual: text };
+    });
+  }
+
+  async toContainText(expected) {
+    return this._poll('toContainText', expected, async element => {
+      const text = normalize(await element.getProperty('textContent'));
+      return { pass: textMatches(text, expected, false), actual: text };
+    });
+  }
+
+  async toHaveValue(expected) {
+    return this._poll('toHaveValue', expected, async element => {
+      const value = String(await element.getProperty('value'));
+      return { pass: expected instanceof RegExp ? expected.test(value) : value === expected, actual: value };
+    });
+  }
+
+  async toBeEmpty() {
+    return this._poll('toBeEmpty', undefined, async element => {
+      const tag = await element.getTagName();
+      const value = /^(input|textarea)$/i.test(tag) ? await element.getProperty('value') : normalize(await element.getProperty('textContent'));
+      return { pass: !value, actual: value };
+    });
+  }
+
+  async toBeChecked() {
+    return this._poll('toBeChecked', undefined, async element => {
+      const checked = await isChecked(element);
+      return { pass: checked, actual: checked ? 'checked' : 'unchecked' };
+    });
+  }
+}
+
+function normalize(text) {
+  return String(text ?? '').replace(/​/g, '').trim().replace(/\s+/g, ' ');
+}
+
+function textMatches(text, expected, whole) {
+  if (expected instanceof RegExp)
+    return expected.test(text);
+  return whole ? text === normalize(expected) : text.includes(normalize(expected));
+}
+
+async function isChecked(element) {
+  const tag = await element.getTagName();
+  const type = String(await element.getAttribute('type')).toLowerCase();
+  if (tag.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio'))
+    return element.isSelected();
+  return await element.getAttribute('aria-checked') === 'true';
+}
+
+function isRetryable(error) {
+  const retryable = ['StaleElementReferenceError', 'ElementNotInteractableError', 'ElementClickInterceptedError',
+    'NoSuchElementError', 'NoSuchFrameError', 'InvalidElementStateError', 'NoSuchWindowError'];
+  if (retryable.includes(error.name))
+    return true;
+  // Scripts fail while the page navigates; real script errors carry a testgen or syntax message.
+  return error.name === 'JavascriptError' && !/testgen:|SyntaxError|not a valid/.test(error.message);
+}
+
+const namedKeys = {
+  Enter: Key.ENTER, Tab: Key.TAB, Escape: Key.ESCAPE, Backspace: Key.BACK_SPACE, Delete: Key.DELETE,
+  ArrowUp: Key.ARROW_UP, ArrowDown: Key.ARROW_DOWN, ArrowLeft: Key.ARROW_LEFT, ArrowRight: Key.ARROW_RIGHT,
+  Home: Key.HOME, End: Key.END, PageUp: Key.PAGE_UP, PageDown: Key.PAGE_DOWN, Insert: Key.INSERT, Space: ' ',
+  F1: Key.F1, F2: Key.F2, F3: Key.F3, F4: Key.F4, F5: Key.F5, F6: Key.F6,
+  F7: Key.F7, F8: Key.F8, F9: Key.F9, F10: Key.F10, F11: Key.F11, F12: Key.F12,
+};
+
+function modifierKey(name) {
+  switch (name) {
+    case 'Alt': return Key.ALT;
+    case 'Control': return Key.CONTROL;
+    case 'Meta': return Key.META;
+    case 'Shift': return Key.SHIFT;
+    case 'ControlOrMeta': return process.platform === 'darwin' ? Key.META : Key.CONTROL;
+  }
+  throw new Error(`testgen: unknown modifier ${name}`);
+}
+
+// Playwright key names ("Enter", "Shift+Tab", "ControlOrMeta+a") → WebDriver keys.
+function toKeys(shortcut) {
+  const parts = shortcut.split(/\+(?=.)/);
+  const key = parts.pop();
+  const modifiers = parts.map(modifierKey);
+  const keyValue = namedKeys[key] ?? key;
+  return modifiers.length ? Key.chord(...modifiers, keyValue) : keyValue;
+}
+
+/* @testgen-engine */
+
+module.exports = { createDriver, setViewportSize, Page, Locator, Dialog, expect };