DevExpress/testcafe

This system is TestCafe, an end-to-end web testing framework that automates browser interactions using native automation protocols like Chrome DevTools Protocol and Marionette. It provides a comprehensive API for simulating user actions such as clicking, typing, and dragging, while supporting complex scenarios like multi-window management, iframe navigation, and HTTP request interception. The framework includes built-in capabilities for TypeScript and ES module support, live test reloading, and detailed reporting with visual diffs and video recording.

154 changes.

The project underwent a comprehensive migration of its core architecture to TypeScript, restructuring the runner, compiler, and client-side automation layers. This period introduced native automation as the default execution mode, replacing the legacy proxy-based model, and established a modular browser provider system. Extensive functional and unit tests were added to validate the new automation primitives, multi-window support, and improved error reporting infrastructure.

142 changes.

This period focused on modernizing the codebase by introducing ES module support, TypeScript compilation, and a new Live Mode for continuous testing. It also involved significant architectural shifts, including refactoring the browser providers to use native automation protocols like CDP and Marionette, and implementing video recording capabilities.

140 changes.

This period focused on migrating the core automation engine to a Chrome DevTools Protocol-based native mode, which became the default, while simultaneously rewriting major subsystems like the API structure, roles, and reporter in TypeScript. The work also introduced significant new features including a plugin-based reporter architecture, HTTP request mocking and logging APIs, and support for ESM and Google DevTools Recorder imports.

9 changes.

This period focused on expanding functional test coverage for regression issues in native automation, element visibility, and Web Worker handling. It also introduced a new replicator utility to support the serialization of complex JavaScript data structures beyond standard JSON capabilities.

Added a new example demonstrating how to run TestCafe tests in Chrome (Headless) using Bitbucket Pipelines CI. The example includes a sample Bitbucket Pipelines configuration file, a simple local server setup, an HTML page with interactive elements, and a corresponding TestCafe test script to verify functionality.

examples/running-tests-in-chrome-using-bitbucket-pipelines-ci · high confidence

Added a new TypeScript declaration file for the 'os-family' module, exposing boolean constants for Windows, Linux, and Mac detection. This enables TypeScript users to import and use the os-family library with proper type checking and IntelliSense support in their projects.

@types/os-family, @types/read-file-relative, @types/time-limit-promise · high confidence

TypeScript type definitions have been added for the 'unquote' library, declaring a default export function that accepts a string and returns a string. This enables type-checking and autocompletion for users of the unquote package in TypeScript projects.

@types/unquote · high confidence

A new example located at examples/running-tests-in-firefox-and-chrome-using-travis-ci demonstrates how to configure Travis CI to run TestCafe tests in both Firefox and Chrome browsers. The example includes a .travis.yml configuration file that sets up the necessary environment (including Xvfb and fluxbox for headless display), a simple static server (server.js), a test page (index.html), and a sample test (tests/index-test.js) that verifies button interaction.

examples/running-tests-in-firefox-and-chrome-using-travis-ci · high confidence

Added a new example directory containing sample files to demonstrate how to run TestCafe tests in the cloud using Travis CI and Sauce Labs. The example includes a Travis CI configuration file, a README with setup instructions, a simple HTML test page, and a local server script to serve the test assets.

examples/running-tests-using-travis-and-saucelabs · high confidence

The media directory now includes the official TestCafe logo (\testcafe-logo.svg\) and a survey banner graphic (\testcafe-survey-banner.svg\). These new SVG assets provide high-quality, scalable branding materials for use in documentation, the README, and other marketing or informational contexts.

media · high confidence

New transform classes have been added to the replicator system to handle serialization of client function return values. The FunctionTransform now reconstructs functions using evalFunction and injects selector dependencies, while SelectorNodeTransform and SelectorElementActionTransform serialize DOM nodes into snapshots, including support for custom DOM properties. A new ClientFunctionNodeTransform prevents the return of raw DOM nodes by throwing an error, ensuring only serializable data is passed back.

src/client/driver/command-executors/client-functions/replicator · high confidence

New helper modules in the gulp/docker directory now automate Docker environment preparation and functional test execution. The system detects the Docker daemon, manages Docker Machine instances (creating or starting them as needed), and configures environment variables. It also includes logic to determine publish tags based on versioning and provides a function to run functional tests inside a Docker container, handling platform-specific path corrections and permissions.

gulp/docker · high confidence

TypeScript type definitions for the error-stack-parser library have been added, providing a StackFrame interface with a getFileName method to improve type safety for consumers of this package.

@types/error-stack-parser · high confidence

Users can now write test files in TypeScript. This change introduces a new compiler module that handles TypeScript syntax, allowing for custom configuration files and compiler options. It also enables static analysis of TypeScript test files to retrieve test lists and metadata, including support for skipping tests and handling ESM mode.

src/compiler/test-file/formats/typescript · high confidence

This change introduces the TypeScript declaration file (@types/chrome-remote-interface) for the chrome-remote-interface library. It defines the core interfaces and types required for type-safe usage, including ProtocolApi, TargetInfo, GenericConnectionOptions, ConstructorOptions, and CloseTabOptions, as well as the main ChromeRemoteInterface function and its List and Close methods.

@types/chrome-remote-interface · high confidence

TypeScript definitions for the pinkie library have been added, enabling type-safe usage of its Promise implementation in server-side code. This allows the project to leverage pinkie's promise functionality with proper compile-time checking and IntelliSense support.

@types/pinkie · high confidence

New files have been added to the assets directory to centralize configuration for the application's static resources. The content-types.js file defines a mapping of file extensions to their corresponding MIME types (such as JavaScript, CSS, images, and JSON), while injectables.js exports the file paths for core TestCafe scripts, UI assets (including sprites and styles), and the default favicon. These changes provide a single source of truth for resource paths and content types used by the UI and automation layers.

src/assets · high confidence

The system now includes a dedicated provider for Microsoft Edge, allowing users to launch and automate the Edge browser. This provider extends the existing Chrome provider implementation and customizes the runtime environment by writing specific configuration preferences to the user profile directory. These preferences are designed to bypass the initial setup wizard and prevent automatic sign-in prompts, ensuring a consistent and unattended automation experience.

src/browser/provider/built-in/dedicated/edge · high confidence

The \src/utils/diff\ module has been introduced to provide detailed, color-coded diffs when comparing actual and expected values in test failures. This new utility leverages the \diff\ library to generate unified diffs, which are then processed to remove irrelevant lines and wrapped in HTML spans with CSS classes (\diff-added\, \diff-removed\, \diff-not-modified\) for visual distinction. The implementation includes helpers to stringify various data types (strings, functions, buffers, objects) and safely escape HTML content, ensuring that error messages now display precise differences between values rather than just generic mismatch notifications.

src/utils/diff · high confidence

A new example located in examples/using-assertions has been added to illustrate how to use TestCafe's built-in assertion API. The included test script demonstrates various assertion types, including checking for text content, verifying element counts with greater-than/less-than operators, validating checkbox states, comparing string equality, checking property types, and asserting numeric ranges.

examples/using-assertions · high confidence

Introduced a new Logger class in the live mode subsystem to manage user-facing console output. This component displays introductory instructions for live mode shortcuts (such as Ctrl+S to stop or Ctrl+R to restart), provides status updates when source files change or test runs start/stop, and indicates whether file watching is currently enabled or disabled.

src/live/logger · high confidence

The client now includes a visual progress panel (src/client/ui/progress-panel) that displays a title, a progress bar, and a success state during long-running operations. The panel is centered on the window, animates in and out with configurable delays, and updates the progress percentage based on elapsed time relative to a specified timeout. It uses native browser methods for timing and DOM manipulation, integrated with the application's shadow DOM and UI root.

src/client/ui/progress-panel · high confidence

Introduced a new replicator utility in src/utils/replicator that handles the encoding and decoding of complex JavaScript objects, including support for circular references, typed arrays, and custom transforms. This allows application code to safely serialize and deserialize data structures that go beyond standard JSON capabilities, such as Maps, Sets, and Error objects, while preserving object identity and structure.

src/utils/replicator · high confidence

A new service worker has been introduced to handle fetch requests for test pages, implementing a retry mechanism with delays to improve stability in poor network conditions. This change allows the client to make multiple requests for the test page, reducing failures due to transient network issues.

src/client/browser · high confidence

A new progress bar component has been added to the status bar, supporting both determinate (progress-based) and indeterminate (animation-based) states. The implementation includes a main ProgressBar class that manages the DOM structure and delegates rendering to DeterminateIndicator (which animates width based on time elapsed) and IndeterminateIndicator (which uses bezier-curve-based animations for two moving value elements). This provides visual feedback for ongoing operations within the client UI.

src/client/ui/status-bar/progress-bar · high confidence

Users can now import test recordings exported from the Google Chrome DevTools Recorder (JSON format) directly into the test runner. This new compiler parses the JSON structure and translates DevTools-specific actions—such as navigation, clicking (including right-click and double-click), hovering, typing with replace, scrolling, viewport resizing, iframe switching, and key events—into the framework's native test commands. The implementation includes a command factory that maps each recorder step to the appropriate internal command transformer, allowing users to leverage existing browser automation capabilities with tests generated via the DevTools UI.

src/compiler/test-file/formats/dev-tools · high confidence

Added the core event provider and pipeline context classes for handling request hooks in the native automation mode. The new \NativeAutomationRequestHookEventProvider\ manages request and response events, including safe retrieval of response bodies (with error handling for Protobuf requests) and header modification tracking, while \NativeAutomationPipelineContext\ provides the necessary context state for these operations.

src/native-automation/request-hooks · high confidence

Added a Dockerfile and entrypoint script to enable running TestCafe inside a container. The image is based on Alpine Linux and installs Node.js, Chromium, Firefox, and necessary display utilities (Xvfb, fluxbox) to support headless browser testing. The container exposes ports 1337 and 1338 for the TestCafe server and client connections, and runs the test suite via a custom entrypoint script that configures the display environment.

docker · high confidence

The client driver has been implemented from scratch to handle test execution in the browser. This new driver introduces support for managing multiple browser windows (including switching, closing, and restoring child windows) and nested iframes, ensuring commands are correctly routed between parent and child contexts. It also includes native dialog tracking, browser console message capture, and a robust storage mechanism that adapts to both proxy-based and native automation modes.

src/client/driver · high confidence

This change introduces the core client implementation for communicating with Firefox via the Marionette protocol. It adds the \commands.js\ module defining the specific WebDriver and Marionette command strings (such as NewSession, ExecuteScript, TakeScreenshot, and Window management) and the \index.js\ module which establishes the \MarionetteClient\ class. This class handles the low-level socket connection, packet serialization/deserialization, and command execution logic required to control the browser instance.

src/browser/provider/built-in/dedicated/firefox/marionette-client · high confidence

The status bar UI component has been introduced to provide real-time feedback during test execution. It displays the current test context (fixture and test names), browser user agent, and dynamic status messages such as 'Loading Web Page', 'Waiting for element to appear', and 'Waiting for assertion execution'. The component includes debugging controls (Resume, Step, Finish, Unlock Page) and manages its own visibility with show/hide animations. An \IframeStatusBar\ variant is also provided to handle status updates via cross-frame messaging when the test runner operates within an iframe.

src/client/ui/status-bar · high confidence

This change introduces the foundational client-side UI components for TestCafe, including the main UI root, status bar, progress panel, selector inspector, and custom select element emulation. It establishes the ShadowUI integration via Hammerhead, implements cross-iframe communication for showing/hiding the UI, and provides the necessary assets (sprites, styles) and initialization logic to overlay the testing interface on the target page.

src/client/ui · high confidence

The video-recorder module has been introduced to enable automatic video capture during test runs. This change adds the core infrastructure for spawning FFmpeg processes, managing temporary video files, and handling video encoding options. It integrates with the browser job lifecycle to start and stop recording per test run, supports path pattern customization for output files, and emits events when videos are saved, allowing consumers to access the recorded video paths and associated metadata.

src/video-recorder · high confidence

Added a new compiler and parser implementation for ES Next test files, enabling support for modern JavaScript features including JSX, Flow type annotations, and ESM modules. The compiler configures Babel with stage-2 and environment presets, while the parser extracts test metadata from static analysis of the source code.

src/compiler/test-file/formats/es-next · high confidence

Added a new ES module entry point (\index.mjs\) alongside the existing CommonJS entry point (\index.js\) in the \src/api/exportable-lib\ directory. This allows users to import core testing constructs—such as \Role\, \ClientFunction\, \Selector\, \RequestLogger\, \RequestMock\, \RequestHook\, \t\, \userVariables\, \fixture\, and \test\—using native ES module syntax, supporting the new ESM mode capability.

src/api/exportable-lib · high confidence

Adds a new Live Mode feature that automatically re-runs tests when source files change, enabling faster feedback during development. This change introduces the core Live Mode components in src/live, including a bootstrapper that mocks require to track file dependencies, a controller managing the file watcher and keyboard shortcuts (Ctrl+S to stop, Ctrl+R to restart, Ctrl+W to toggle watching), a test runner that caches configuration to avoid redundant parsing, and test run controllers that handle test lifecycle and state management.

src/live · high confidence

Added a new RequestLogger class that allows tests to capture and inspect HTTP request and response data. Users can configure logging options for headers and bodies, and use methods like contains(), count(), and clear() to assert on or manage the logged network activity within the test run.

src/api/request-hooks · high confidence

Added a new basic example in the examples/basic directory that demonstrates core TestCafe API usage. The example includes a page-model.js file defining a Page object with selectors for form fields, buttons, and UI elements, along with a test.js file containing tests for text typing, clicking labels, keyboard interactions, slider dragging, native dialog handling, select options, and form submission.

examples/basic · high confidence

Adds a new idle page displayed in the browser while a test session is waiting for commands. The page renders a logo, the user agent string, and a canvas-based spinner that animates while connected or shows a static indicator when disconnected. It polls the server for status updates via a configurable status URL, sends heartbeats to keep the connection alive, and can optionally enable test page retrying and init script execution based on the provided options.

src/client/browser/idle-page · high confidence

This change introduces a new set of utility modules in src/browser/provider/utils to support browser management. argument-parsing.js provides functions to parse browser launch arguments and configuration strings, handling mode detection and user arguments. browser-starter.js implements a BrowserStarter class that queues browser launch operations, specifically serializing them on macOS to prevent concurrent launch conflicts. client-functions.ts exports stringified scripts for retrieving the document title, window dimensions, and service worker availability, which are used by the browser provider to gather client-side state. Additionally, get-maximized-headless-window-size.js provides a utility to determine the window size for maximized headless browsers, defaulting to 1920x1080 or using an environment variable override.

src/browser/provider/utils · high confidence

This change introduces the core backend for the built-in browser provider system, establishing the registry of supported browser types (locally-installed, path-based, remote, Firefox, Chrome, Edge, and Chromium variants) and implementing the specific logic for each. Users can now rely on these built-in providers to automatically detect locally installed browsers, launch browsers via explicit file paths or JSON configurations, and connect to remote browser instances with appropriate handling for local vs. remote window manipulation capabilities.

src/browser/provider/built-in · high confidence

A new module at src/api/user-variables/index.ts has been added to provide a centralized singleton for storing and retrieving user-defined variables. This module exposes a simple getter and setter for a 'value' property, allowing tests to persist and access custom configuration data globally across test runs.

src/api/user-variables · high confidence

A new base implementation for dedicated browser providers has been added, establishing core infrastructure for managing multiple browser windows and leveraging Chrome DevTools Protocol (CDP). This class introduces support for multi-window scenarios through active window tracking and window descriptors, enables full-page screenshot capabilities, and provides native automation methods for resizing and maximizing windows. It also includes utilities for validating browser names and handling headless mode configurations, serving as the foundation for browser-specific provider implementations.

src/browser/provider/built-in/dedicated · high confidence

Added a new file-watcher component that tracks file changes and manages a dependency graph of loaded modules. When a watched file changes, the system clears the require cache for that file and its parents, then re-runs tests. This ensures that live mode correctly handles module dependencies and cache invalidation during development.

src/live/file-watcher · high confidence

This change adds a new communication subsystem in src/client/driver/driver-link that enables the test runner to coordinate across multiple browser windows and iframes. It defines a set of message types (such as switch-to-window, close-window, and establish-connection) and implements the logic to send commands to specific driver instances (e.g., inside an iframe or child window) and wait for confirmations, including configurable timeouts and retry intervals. This infrastructure allows the driver to reliably manage context switches and window lifecycles in complex multi-window scenarios.

src/client/driver/driver-link · high confidence

Added new \ChildIframeDriverLink\ and \ParentIframeDriverLink\ classes in the iframe driver-link module to facilitate command execution and status reporting via an invisible iframe. This implementation handles message passing between the driver and the test context, including connection establishment, command execution, and waiting for results, supporting the shift towards proxyless and native automation modes.

src/client/driver/driver-link/iframe · high confidence

Added a new request pipeline implementation for the native automation mode, including context management, safe API wrappers for Chrome DevTools Protocol calls, and handlers for special requests like favicons and service routes. This replaces the previous proxy-based request handling with a direct CDP-based approach, improving reliability for features like redirects, request hooks, and service workers.

src/native-automation/request-pipeline · high confidence

Added a new set of utility files under src/native-automation/utils to support the native automation feature. These modules provide core functionality including Chrome DevTools Protocol (CDP) interactions for handling redirects, navigation, and event dispatching (cdp.ts), request and response body decoding and encoding (string.ts), HTTP header conversion and manipulation (headers.ts), browser client retrieval (get-active-client.ts), and option conversion (convert.ts).

src/native-automation/utils · high confidence

The src/cli directory now contains the primary entry point (src/cli/index.js) which resolves and loads the local TestCafe installation if available, otherwise falling back to the global one. The core CLI logic has been moved to src/cli/cli.js, which handles argument parsing, browser provider initialization, and test execution. New modules include src/cli/authentication-helper.ts for handling interactive authentication prompts, src/cli/correct-browsers-and-sources.js for validating and correcting browser and source arguments, src/cli/remotes-wizard.ts for managing remote browser connections with QR code support, src/cli/termination-handler.js for graceful signal handling (SIGINT, SIGBREAK), src/cli/log.js for standardized logging with spinner support, and src/cli/node-arguments-filter.ts for filtering V8 and Node.js flags. An .eslintrc file is also added to configure linting rules for the CLI module.

src/cli · high confidence

The reporter subsystem has been rewritten in TypeScript to support a plugin-based architecture. This change introduces a \ReporterPlugin\ interface with lifecycle methods such as \init\, \reportTaskStart\, \reportTestStart\, \reportTestDone\, and \reportTaskDone\, allowing external plugins to hook into the test execution flow. It also adds a new \reportWarnings\ method for reporting test warnings and an \onBeforeWrite\ hook that enables plugins to intercept and modify output before it is written to the stream. The implementation includes a \ReporterPluginHost\ to manage plugin interactions and formatting, and defines specific interfaces for reporter sources and plugin factories.

src/reporter · high confidence

A new BrowserConnectionGateway component has been added to manage HTTP routes for browser connections, specifically supporting native automation features. This gateway registers endpoints for connection establishment, heartbeats, status checks, and native-specific actions such as window management (active window ID, closing windows) and event dispatching. It also serves necessary assets like the idle page and service worker, and handles error routes for native automation, effectively centralizing the communication layer between the test runner and browser instances.

src/browser/connection/gateway · high confidence

The CLI now supports a new \--disable-native-automation\ option, allowing users to explicitly opt out of the native automation mode. This change introduces the underlying argument parsing infrastructure for this feature, including the definition of the \nativeAutomation\ option in the command-line interface, which corresponds to the internal capability to run tests using native browser automation instead of the legacy proxy-based approach.

src/cli/argument-parser · high confidence

A new \src/shared/types.d.ts\ file has been added to define core TypeScript interfaces for the native automation feature. This includes \NativeMethods\ for browser API shims, emitter interfaces for client requests and script execution, and configuration options for opening browsers with native automation enabled (\NativeAutomationInitOptions\, \OpenBrowserAdditionalOptions\). These types support the underlying infrastructure for the new automation engine.

src/shared · high confidence

The test runner now utilizes a new Task class (src/runner/task/index.ts) to manage the execution lifecycle, supported by a TaskPhase enum (src/runner/task/phase.ts) that tracks states from initialization through start to completion. This component initializes core services including screenshots, warning logs, and video recording, and manages BrowserJob instances to handle test execution across browser connection groups. It also structures test metadata for reporting and emits lifecycle events via a message bus.

src/runner/task · high confidence

A new TypeScript file defining shared warning types has been added to the shared warnings module, specifically introducing an 'elementOverlapped' warning identifier for use across the application.

src/shared/warnings · high confidence

The native automation request hooks now handle two distinct CDP event types: \FrameNavigated\ and \RequestPaused\. For frame navigation events, the system creates a basic \RequestInfo\ with default values (empty method, headers, and body) since full request details are not available at that stage. For request paused events, the system extracts full request details including URL, method, headers (lowercased), and POST data, while also enabling response modification capabilities (setting/removing headers) and correctly identifying AJAX requests based on resource type. This allows request hooks to intercept and modify requests at the appropriate CDP lifecycle stages.

src/native-automation/request-hooks/event-factory · high confidence

The native dialog tracker has been extended to handle geolocation permission requests in addition to standard dialogs like alert, confirm, prompt, and print. When a geolocation request occurs, the tracker intercepts it and invokes the user-defined dialog handler, allowing tests to mock or manage these permissions. This change ensures that geolocation dialogs are tracked in the appeared dialogs list and can be handled consistently with other native browser dialogs.

src/client/driver/native-dialog-tracker · high confidence

Users can now perform direct HTTP requests (GET, POST, PUT, PATCH) from test code without a browser proxy, enabling API testing workflows. This new capability supports basic HTTP authentication, automatic cookie handling via the \withCredentials\ option, and flexible body serialization (JSON, form data, streams). The implementation introduces a new request module (\src/test-run/request\) that handles URL resolution, header preparation, and response processing, allowing tests to interact with backend services directly.

src/test-run/request · high confidence

Users can now use the RequestMock class to intercept and mock specific HTTP requests. This new API allows configuring a mock response for a request URL or pattern using a fluent interface: call onRequestTo() with the request filter rule, then respond() with the desired body, status code, and headers. The implementation integrates with the existing RequestHook infrastructure to handle request and response events, including CORS validation warnings.

src/api/request-hooks/request-mock · high confidence

A new Selector Inspector Panel has been added to the UI, providing tools to debug and interact with CSS selectors. The panel includes a 'Pick' button to visually select elements on the page, a text input to type and validate selectors with real-time match indicators, and a 'Copy' button to copy the generated selector string. It also features a hide/show toggle for the panel and a list view to expand and select from multiple generated selector options.

src/client/ui/selector-inspector-panel · high confidence

A new \src/client/core\ module has been introduced to centralize client-side automation logic. This module exposes core utilities for DOM manipulation, key mapping, and scrolling, alongside a \SelectController\ for emulating HTML select interactions. It also implements \preventRealEvents\ and \disableRealEventsPreventing\ to allow the test runner to intercept and control native browser events, ensuring that real user actions do not interfere with automated test execution.

src/client/core · high confidence

The test runner now supports executing custom client scripts while in Live mode. This change introduces a new TypeScript-based implementation for loading, validating, and routing client scripts (including handling file paths, modules, and inline content) and registers them with the proxy server. The script code is processed differently depending on whether native automation is enabled, ensuring compatibility with the Live mode execution environment.

src/custom-client-scripts · high confidence

Users can now import the \test\ and \fixture\ APIs directly from the \testcafe\ package (e.g., \import { test, fixture } from 'testcafe'\) in addition to using the global variables. The compiler now detects these import statements and correctly initializes the API structures with the appropriate test file context and base URL, ensuring consistent behavior whether the APIs are accessed globally or via explicit imports.

src/compiler/test-file · high confidence

The project source code has been restructured and migrated to TypeScript, introducing a new build configuration (tsconfig.json) and ESLint rules for arrow functions. The main entry point (src/index.js) now exposes the TestCafe API and embedding utilities, while the core TestCafe class (src/testcafe.js) initializes the proxy, registers client assets, and manages runners. New modules handle asset loading (src/load-assets.js), browser session storage via native automation (src/native-automation/session-storage/index.ts), and compiler file format extensions (src/compiler/test-file/formats/extensions.ts).

src · high confidence

The browser provider logic has been refactored into a modular system consisting of a base provider class, a plugin host for standardizing provider interactions, a pool for managing provider instances and caching, and utilities for parsing provider names. This change establishes a structured backend for browser providers, allowing for better separation of concerns and easier extension of browser support capabilities.

src/browser/provider · high confidence

The command definitions in src/test-run/commands have been rewritten in TypeScript, introducing strongly-typed command classes (such as ClickCommand, AssertionCommand, and UseRoleCommand) and dedicated option classes (like ClickOptions and TypeOptions). This change standardizes the internal structure of test actions and assertions, ensuring consistent validation and property assignment across the test runner.

src/test-run/commands · high confidence

The TypeScript definition source files in \ts-defs-src\ have been reorganized into a modular structure. The runner API types are now split into dedicated files for configuration, options, and the core runner interface, while test API exports and global declarations (such as \test\, \fixture\, and \t\) are separated into their own helper modules. This change improves the maintainability and clarity of the type definitions without altering the public API surface.

ts-defs-src · high confidence

A new utility function \isFileProtocol\ has been added to the shared utilities to check if a URL starts with the \file://\ protocol. This helper is intended to support navigation logic, specifically addressing issues with navigating to \about:blank\ or \file://\ pages in CDP mode.

src/shared/utils · high confidence

The Babel compiler integration has been restructured to explicitly configure and load specific Babel 7 plugins and presets. This includes setting up base options (such as retaining lines and disabling AST generation), defining presets for ES2015+ features (stage-2), Flow, React, and environment-specific transformations, and adding plugins for private methods, class properties, static blocks, and module resolution. The changes also introduce a utility to format Babel-produced code by normalizing whitespace and newlines, ensuring consistent output for both client functions and test code.

src/compiler/babel · high confidence

The test runner now uses a dedicated validation module in src/test-run/commands/validations to enforce argument types and constraints for actions. This change introduces factory functions for creating validators (e.g., for integers, booleans, speed, and strings) and specific validators for complex arguments like roles, device specs, screenshot paths, cookies, and URLs. This ensures that invalid arguments passed to actions (such as \t.resizeWindow\, \t.takeScreenshot\, or \t.useRole\) are caught early with descriptive errors, improving reliability and debugging experience.

src/test-run/commands/validations · high confidence

The client driver's dependency structure has been refactored to use dedicated entry-point files for key libraries. New modules in src/client/driver/deps now explicitly re-export all named exports and the default export for hammerhead, testcafe-automation, testcafe-core, and testcafe-ui. This change centralizes how these dependencies are consumed within the driver, likely simplifying import paths and ensuring consistent access to both default and named exports from these packages.

src/client/driver/deps · high confidence

The Chrome browser provider has been rewritten to rely on the Chrome DevTools Protocol (CDP) and native automation rather than the legacy proxy-based approach. This change introduces a new configuration system that parses mode strings (userProfile, headless, emulation) and device specs, enabling device emulation and headless resizing via CDP. It also adds support for running Chrome in containerized environments (Docker/Podman) with specific flags, manages temporary browser profiles with customized preferences, and exposes new capabilities such as video capturing, multiple window handling, and native automation event dispatching.

src/browser/provider/built-in/dedicated/chrome · high confidence

The client-side build process has been restructured to use TypeScript for compilation and Rollup for bundling. This change introduces a new build configuration (rollup.config.js) that compiles TypeScript sources into IIFE bundles, sets up a TypeScript configuration (tsconfig.json) targeting ES5, and establishes an ESLint configuration (.eslintrc) with custom Hammerhead rules. Additionally, dependency re-export files (deps/) have been added to manage imports for hammerhead, testcafe-core, and testcafe-ui, ensuring the client scripts correctly access global objects like window\['%hammerhead%'\] and window\['%testCafeAutomation%'\].

src/client · high confidence

The compiler module has been restructured to support ES Modules (ESM) and a new raw-file compiler. A new ESM loader (src/compiler/esm-loader.ts) and compiler index (src/compiler/index.js) enable running tests in ESM mode, while a new raw-file compiler (src/compiler/test-file/formats/raw/compiler.js) allows defining tests via JSON files. Additionally, client function compilation (src/compiler/compile-client-function.js) now uses Babel to downgrade ES6 code for browser compatibility.

src/compiler · high confidence

The configuration subsystem has been restructured into a set of dedicated TypeScript modules (e.g., \configuration-base.ts\, \testcafe-configuration.ts\, \typescript-configuration.ts\) to improve maintainability and type safety. This change introduces support for loading configuration from CommonJS files (\.cjs\) in addition to JSON and JS, and adds specific compiler options for TypeScript (including JSX support and decorator metadata). It also standardizes default values for features like native automation, cross-domain emulation, and screenshot thumbnails, while enforcing stricter validation for hostnames and ports during initialization.

src/configuration · high confidence

The error reporting system in src/shared/errors has been expanded to provide more specific diagnostics when an element is not visible. A new module, element-hidden-reasons.ts, defines detailed messages for various visibility states, including elements outside the layout viewport, having zero dimensions, or being hidden via display, visibility, or collapse properties on the element or its parents. This granularity allows users to understand exactly why an interaction failed due to element invisibility.

src/shared/errors · high confidence

The notification system now provides richer context for warnings and debugging. Warnings generated via the new \addWarning\ utility automatically append the source code location (callsite) to the message, helping users identify where issues originate. A new debug logger has been introduced to manage breakpoint displays and stream overrides during test execution. Additionally, deprecation warnings for \t.setPageLoadTimeout\ and the \tsConfigPath\ option are now standardized, and specific warnings have been added for issues like missing \await\ on snapshot properties, overlapping elements during interactions, and configuration file conflicts.

src/notifications · high confidence

The build system now organizes test runner settings into two new modules: \gulp/constants/client-test-settings.js\ and \gulp/constants/functional-test-globs.js\. Client test settings now explicitly define the local browser aliases (Edge, Chrome, Firefox, Safari) and specific desktop/mobile browser targets for CI environments, including Sauce Labs credentials and version constraints. Functional test execution is now driven by explicit glob patterns that separate basic tests, legacy fixtures, compiler service tests, and screenshot tests, allowing for more granular control over which test suites are executed in different build tasks.

gulp/constants · high confidence

The Firefox browser provider has been restructured to launch Firefox via the Marionette protocol, enabling headless mode support and allowing window resizing through Marionette commands. The provider now generates a custom temporary Firefox profile for each session (unless a user-defined profile is specified), configuring preferences to disable telemetry, updates, and background tab throttling, while also enabling enterprise root certificate support. Configuration parsing has been updated to support specific modes like 'userProfile' and 'headless', and the provider now handles Marionette port allocation and client connection management.

src/browser/provider/built-in/dedicated/firefox · high confidence

The skip-js-errors module now supports a more granular configuration approach, allowing users to define custom logic for skipping JavaScript errors via callbacks or by specifying regex patterns for error messages, stack traces, and page URLs. This change introduces new interfaces and helper functions to parse and wrap these options, enabling more precise control over which errors are ignored during test execution.

src/api/skip-js-errors · high confidence

The click automation logic in the client has been refactored to handle specific UI elements more accurately. For labels containing buttons or links, clicks on those inner elements no longer incorrectly toggle the associated checkbox state, and disabled checkboxes remain unaffected by label clicks. Additionally, clicking a select element now reliably expands or collapses its dropdown menu across browsers, and selecting an option within a select list correctly triggers the expected input and change events.

src/client/automation/playback/click · high confidence

The browser manipulation module now includes robust logic for calculating element screenshot crops and validating scroll targets. A new \ensureCropOptions\ utility normalizes crop boundaries (handling negative coordinates and length constraints) and ensures the scroll target lies within the cropped area, throwing specific errors if the configuration is invalid. The main executor integrates this logic to correctly adjust for element borders, paddings, and margins, and automatically scrolls to the center of the crop area if the element exceeds viewport dimensions.

src/client/driver/command-executors/browser-manipulation · high confidence

When an unhandled error occurs within a custom TestCafe script, the error message now includes the original error template and, where applicable, a rendered callsite markup without the full stack trace. This provides clearer context for debugging issues originating from custom script execution by leveraging the new \callsite-record\ integration for HTML rendering.

src/errors/test-run/render-error-template · high confidence

The scroll automation logic has been updated to correctly handle cases where the target element is partially hidden by a sticky element (such as a header). The new implementation in \src/client/core/scroll\ calculates scroll positions that ensure the target is fully visible, preventing interactions with obscured content.

src/client/core/scroll · high confidence

The Chrome browser provider now uses the Chrome DevTools Protocol (CDP) via the \chrome-remote-interface\ library to manage browser sessions, replacing the previous implementation. This change introduces a new \BrowserClient\ class that handles connection setup, page enablement, network/runtime interception, and emulation settings (user agent, touch, device metrics) directly through CDP commands. It also includes utility functions for filtering internal tabs and managing target selection, laying the groundwork for more robust automation features like native window handling and screencast-based video recording.

src/browser/provider/built-in/dedicated/chrome/cdp-client · high confidence

The temp-directory cleanup mechanism now runs in a separate worker process to improve reliability and resource management. The main application spawns this detached child process, which handles directory registration and deletion asynchronously using the 'del' library and browser process termination logic. This change isolates cleanup operations from the main event loop, ensuring that temporary directories are removed even if the main process disconnects, and reduces the number of concurrent temp directories created for profiles.

src/utils/temp-directory/cleanup-process · high confidence

A new file at src/client/core/deps/hammerhead.js has been added to serve as a local re-export wrapper for the 'hammerhead' library. This change centralizes the import of the hammerhead dependency within the client core, ensuring consistent access to its exports and default export for other parts of the application.

src/client/core/deps · high confidence

The screenshot subsystem has been rewritten with a new \Capturer\ class and dedicated \crop.js\ module, enabling precise screenshot cropping based on client area dimensions and mark seeds, while also supporting full-page captures and configurable thumbnail generation. This change introduces a new path pattern system for organizing screenshot files, adds \actionId\ and \testRunId\ to screenshot metadata for better traceability, and ensures screenshots are only created when the capture actually succeeds, improving reliability and report accuracy.

src/screenshots · high confidence

The \src/utils/get-options\ directory has been restructured to provide specialized parsers for various configuration options, replacing ad-hoc parsing logic. This includes a new \base.ts\ utility for generic key-value parsing, and specific modules for \compiler\ (handling TypeScript options with array conversion), \dashboard\ (ensuring string types for buildId/token), \grep\ (validating regex patterns), \meta\ (enforcing key-value pairs), \quarantine\ (validating attempt limits and thresholds), \screenshot\ (handling path fallbacks), \skip-js-errors\ (validating callback and options objects), \ssl\ (reading certificate files from disk), and \video\ (generic parsing). A new \getAssertionTimeout\ helper also centralizes timeout resolution logic.

src/utils/get-options · high confidence

The native automation engine is now the default browser automation mode, replacing the previous legacy approach. This change brings improved stability and performance, including fixes for issues such as YouTube redirects hanging, cookie filtering errors (including httpOnly handling), and unhandled promise rejections in request hooks. Users will benefit from more reliable test execution without needing to explicitly opt-in to this mode.

src/native-automation · high confidence

The src/api module introduces new TypeScript files to manage test page URLs and track test run contexts. test-page-url.ts adds logic to resolve relative URLs against a base, ensure protocols, and validate URL formats for roles and base URLs. test-run-tracker.ts implements a mechanism to hook into async operations (timers, promises) to maintain context across async boundaries, allowing the system to identify the active test run. wrap-test-function.ts and wrap-custom-action.ts utilize this tracker to mark functions with test run IDs and handle warnings related to missing awaits on snapshot properties.

src/api · high confidence

The \src/client/automation/playback\ directory now contains dedicated automation classes for several interaction types, replacing or supplementing previous logic. \DblClickAutomation\ implements a two-step click sequence with a configurable delay (0ms for touch devices, 160ms otherwise) and ensures the \dblclick\ event is raised on the element actually clicked during the second step. \RClickAutomation\ handles right-click interactions by simulating \mousedown\, \mouseup\, and \contextmenu\ events, including proper focus management for content-editable elements. \HoverAutomation\ provides a simple wrapper for hover actions. \SetScrollAutomation\ and \ScrollIntoViewAutomation\ implement programmatic scrolling, supporting absolute positions, relative offsets (\byX\/\byY\), and named positions (e.g., 'top', 'center'). \UploadAutomation\ now specifically handles required input attributes during native automation uploads, temporarily removing the \required\ attribute to allow file selection and restoring it upon form submission. \DispatchEventAutomation\ allows for generic event dispatching with support for various event types (mouse, keyboard, focus, etc.) and constructor selection.

src/client/automation/playback · high confidence

The driver's barrier logic in src/client/driver/barriers has been replaced with a new implementation consisting of RequestBarrier, ScriptExecutionBarrier, and BarriersComplex. This change introduces a structured approach to waiting for network requests and script execution to complete, utilizing emitters to track request states and script loading events, along with configurable delays and timeouts to ensure stability before proceeding.

src/client/driver/barriers · medium confidence

The client-functions command executor has been replaced with a new implementation that uses a replicator to handle argument encoding and decoding, and an isolated \evalFunction\ module to execute user code. This isolation restricts access to internal TestCafe objects for the evaluated code, while explicitly passing \Promise\ and \RegExp\ constructors to ensure \instanceof\ checks work correctly across different execution contexts. The new executor also wraps uncaught errors in \UncaughtErrorInClientFunctionCode\ to provide better debugging information, such as the instantiation callsite name.

src/client/driver/command-executors/client-functions · high confidence

The client-side barrier system now includes dedicated emitters for tracking XMLHttpRequests and Fetch API calls, as well as dynamic script loading events, allowing the test runner to wait for network and script activity to settle. Additionally, a new page-unload barrier has been introduced to manage navigation timing, featuring a configurable timeout, a check for pending file downloads, and a watchdog timer to prevent test hangs if the page fails to unload properly.

src/client/core/barriers · high confidence

The reporter now uses a new \CommandFormatter\ class to structure command data for the UI. This formatter handles specific command types (like selectors, client functions, roles, and URLs) and applies security masking to confidential information, such as text typed into password fields.

src/reporter/command · high confidence

The drag automation logic in the client has been replaced with a new implementation that supports both HTML5 native drag-and-drop and standard mouse simulation. This change introduces a base class for drag operations and specific implementations for dragging to a target element (with configurable destination offsets) and dragging to a specific screen offset. The new code handles touch device events, manages drag-and-drop state (including data transfer and drop allowance), and ensures that a click event is not raised after a drag-and-drop operation completes.

src/client/automation/playback/drag · high confidence

The runtime error handling logic has been reorganized into a dedicated module (\src/errors/runtime\) featuring a new set of structured error classes (such as \GeneralError\, \APIError\, \TestCompilationError\, and \ReporterPluginError\) and a centralized template system. This change introduces specific error codes and detailed, user-facing messages for a wide range of runtime scenarios, including browser connection issues, configuration parsing failures, client script loading errors, and native automation constraints. It also adds a type assertion utility to provide clearer feedback when invalid argument types are passed to API methods.

src/errors/runtime · high confidence

The cursor UI module has been refactored into a shared implementation that supports cross-iframe interaction. A new \iframe-cursor.js\ component handles sending cursor movement and button state requests to the parent frame, while \index.js\ manages the local cursor element's visibility, positioning, and visual states (left/right click down) using Hammerhead's shadow UI. Message definitions in \messages.js\ standardize the communication protocol between iframes and the main frame for cursor synchronization.

src/client/ui/cursor · high confidence

The client-side automation for selecting text within editable elements has been refactored into a new modular structure. This change introduces a base \SelectBaseAutomation\ class that handles the core mouse/touch interaction logic (mousedown, move, mouseup) and delegates specific selection behaviors to specialized implementations: \SelectTextAutomation\ for standard text inputs and \SelectEditableContentAutomation\ for content-editable regions. A new utility module (\calculate-select-text-arguments.js\) has been added to robustly calculate start and end positions, including support for line-based selection in textareas. This restructuring improves the reliability of text selection across different browser engines and element types.

src/client/automation/playback/select · high confidence

The test-run error reporting system has been refactored to provide more detailed and structured error messages. A new \TestRunErrorFormattableAdapter\ class now handles the formatting of error data, including callsite markup and HTML decoration. Specific error classes (e.g., \PageLoadError\, \TimeoutError\, \UncaughtErrorInTestCode\) are defined in \index.js\ with clear properties, and their user-facing messages are managed via a comprehensive template system in \templates.js\. Utility functions in \utils.js\ support rendering subtitles for different test phases, formatting URLs, and generating diffs, resulting in clearer, more actionable feedback for users when tests fail.

src/errors/test-run · high confidence

The command-executors module has been restructured to support more robust navigation and child-window handling. Navigation commands now wait for both request barriers and page unload events before completing, ensuring the page is fully settled. New executors allow selecting child windows by their ID, returning either the driver link or the driver window itself, and properly reject with a specific error if the window is not found. Selector execution now integrates with the status bar to show and hide waiting indicators during element resolution, and a shared utility standardizes how executor results are wrapped into driver status objects.

src/client/driver/command-executors · high confidence

The gulp helpers for running functional tests have been rewritten to support new testing capabilities. The main test runner now accepts a nativeAutomation option, which sets an environment variable to enable native automation mode for tests. Additionally, a new helper creates package.json files with "type": "module" for test fixtures, enabling tests to run in ESM mode. The test infrastructure also includes a custom Mocha reporter that tracks and displays unstable (retried) tests, and a helper to handle module exports transformation for ESM compatibility.

gulp/helpers · high confidence

The bin directory now uses a new entry point, bin/testcafe-with-v8-flag-filter.js, which integrates the v8-flags-filter library to manage Node.js startup flags. This script specifically enables ESM (ECMAScript Modules) support by injecting the --no-warnings flag and conditionally adding the --experimental-loader flag for Node.js versions outside the stable 18.19.0–18.x and 20.8.0+ ranges. The original bin/testcafe.js has been simplified to a thin wrapper that directly requires the CLI module, separating the flag-filtering logic from the core execution path.

bin · high confidence

The internal implementation of ClientFunctions has been restructured to use a dedicated \ClientFunctionBuilder\ class and a new replicator system for serializing function code and dependencies. This change introduces a new \ExecuteClientFunctionCommand\ for handling execution and adds type definitions to distinguish between ClientFunctions and Selectors, ensuring more robust handling of function arguments and test run context.

src/client-functions · medium confidence

The selector functionality has been restructured into a new modular architecture within the client functions. This change introduces dedicated modules for text and attribute filtering (selector-text-filter, selector-attribute-filter) and defines a comprehensive set of snapshot properties (snapshot-properties) that determine which element attributes and states are available for assertion. The core selector builder (selector-builder) and API addition logic (add-api) have been rewritten to support these new filtering mechanisms and to properly handle custom methods and DOM properties, ensuring that selector chains and derivative selectors correctly propagate options and maintain execution context.

src/client-functions/selectors · high confidence

The action executor has been restructured to support native browser automation (CDP) alongside the legacy proxy-based approach. This change introduces a new modular architecture where specific actions (click, type, press, etc.) are handled by dedicated automation classes imported from testcafe-automation, allowing for more precise control and performance improvements. The executor now integrates with a native automation dispatcher to handle events directly in the browser, improving reliability for complex interactions like iframe clicks and text input. Additionally, the system now emits warnings from client-side actions, providing better feedback on potential issues during test execution.

src/client/driver/command-executors/action-executor · high confidence

The browser connection module has been rewritten in TypeScript, introducing a more structured and type-safe approach to managing browser states and connections. This change includes the introduction of new status enums (BrowserConnectionStatus, HeartbeatStatus) and error hints to better handle connection lifecycle events and provide clearer error messages to users. Additionally, the refactoring adds support for tracking active browser connections and managing remote browser queues more efficiently, which improves stability and debugging capabilities during test execution.

src/browser/connection · high confidence

The client-side automation logic has been refactored to use TypeScript and introduces a dedicated Cursor module for managing mouse position, visibility, and button states, which is now exposed via the global \%testCafeAutomation%\ object. This change includes the addition of MoveAutomation for handling mouse movements with configurable speed and modifiers, and updates the element detection logic in \get-element.ts\ to better handle image maps and multi-line links. The automation entry point (\index.js\) now explicitly exports these new components and settings, providing a cleaner interface for test execution.

src/client/automation · high confidence

The client-side automation utilities in src/client/core/utils have been restructured and modernized. This includes replacing legacy browser-specific checks (such as IE leftovers and Opera detection) with standardized logic, removing jQuery dependencies in favor of native DOM methods and Hammerhead utilities, and introducing TypeScript support for core utility modules like delay, nextTick, and position calculations. The refactoring also introduces dedicated modules for array operations, content-editable handling, and scroll automation, ensuring more reliable and consistent behavior for user interactions like typing, clicking, and scrolling across different browsers and environments.

src/client/core/utils · high confidence

The automation utility layer in src/client/automation/utils has been restructured to provide more robust support for user interactions. New helper functions have been introduced to accurately calculate screen and client coordinates (get-device-point, get-automation-point, screen-point-to-client) and to manage keyboard event properties (get-key-code, get-key-identifier, get-key-properties) with proper browser compatibility. The core utils.js module now includes enhanced logic for setting caret positions and managing focus, specifically addressing edge cases such as focusing elements via associated labels, handling content-editable parents, and working around Safari 13 restrictions on focusing elements within iframes. Additionally, a new utility ensures that mouse events are correctly triggered after scrolling actions to maintain accurate hover states.

src/client/automation/utils · high confidence

The error handling system in src/errors has been restructured to improve the clarity of error reports for users. A new stack filtering mechanism (create-stack-filter.js and stack-cleaning-hook.js) now removes internal TestCafe, Babel, and Node.js frames from stack traces, ensuring that only relevant test-code locations are shown. This is supported by new utilities for detecting internal modules (is-internal-stack-frame.ts, internal-modules-prefix.ts) and capturing precise callsites (get-callsite.js). Additionally, the error classification system (types.js) has been expanded with new error codes for features like execution timeouts, cookies, and multiple windows, and the error list management (error-list.js) and test function error processing (process-test-fn-error.js) have been refactored to better categorize and present these errors.

src/errors · high confidence

The move automation logic has been restructured into a modular event-sequence system that distinguishes between standard mouse movements and HTML5 drag-and-drop interactions. This change ensures that mouseenter and mouseleave events are correctly raised as the cursor moves between elements, and that the relatedTarget property is properly populated for drag events (dragenter, dragleave, dragover). Additionally, the system now correctly handles touch devices by preventing unnecessary touchmove events when the left mouse button is held, improving the fidelity of simulated user interactions.

src/client/automation/playback/move/event-sequence · high confidence

The mouse move automation logic has been restructured to support native drag-and-drop operations and improved cross-iframe navigation. A new DragMoveAutomation class now handles drag sequences, correctly initializing DataTransfer objects and managing drag state for elements like images and links. The move logic itself is split into smaller, reusable components (get-line-rect-intersection, mouse-move-step) to calculate precise cursor paths. Additionally, cross-iframe movement is enhanced to properly handle cursor transitions between iframes and the parent window, ensuring correct event firing (mouseout/mouseleave) and coordinate calculations.

src/client/automation/playback/move · high confidence

The press action implementation in the client automation layer has been refactored to support both legacy proxy-based and new native automation modes. The new code introduces a \PressAutomation\ class that coordinates key press sequences, handling shortcut detection, modifier states, and cross-iframe communication. It integrates with \NativeAutomationInput\ to dispatch events via Chrome DevTools Protocol (CDP) when native automation is enabled, while falling back to the existing \KeyPressSimulator\ for standard browser event simulation. This change improves the reliability of keyboard interactions, particularly for shortcuts and special keys, and ensures consistent behavior across different browser environments by leveraging updated key property mappings and event handling logic.

src/client/automation/playback/press · high confidence

The selector executor has been restructured to improve how element selection, filtering, and state capture are handled. A new SelectorFilter class now centralizes logic for visibility checks, hidden element filtering, and index-based selection (nth), providing clearer error reporting for failed filter operations. The core executor now uses a configurable delay (200ms) to poll for element visibility, ensuring more robust handling of dynamic content. Additionally, new snapshot classes (NodeSnapshot, ElementSnapshot, ElementActionSnapshot) have been introduced to capture detailed element properties like attributes, styles, bounding client rect, and child counts, enabling richer context for debugging and test assertions.

src/client/driver/command-executors/client-functions/selector-executor · high confidence

The temporary directory utility has been rewritten to reduce the number of created temp directories by reusing existing ones. It now employs a lockfile mechanism (\.testcafe-lockfile\) to coordinate access, allowing the system to find and acquire a free, existing temporary directory if available, or create a new one only when necessary. The implementation includes logic to detect and overwrite stale lockfiles (older than 2 days) and ensures proper cleanup of directories on process exit.

src/utils/temp-directory · high confidence

The text typing automation logic has been restructured to support both legacy event simulation and a new native automation path (via Chrome DevTools Protocol). The implementation now detects when native automation is available and, if enabled, uses a dedicated input handler for inserting text or executing event sequences, which improves reliability and performance. Additionally, the typing process for contenteditable elements has been refined to better handle browser-specific quirks, such as managing selection states, simulating beforeinput and textinput events correctly across Chrome, Safari, and Firefox, and ensuring proper cursor placement and event firing.

src/client/automation/playback/type · high confidence

The core API structure files in src/api/structure (including base-unit, fixture, test, test-file, testing-unit, and unit-type) have been rewritten from JavaScript to TypeScript. This migration introduces strict typing for test and fixture definitions, including new properties for global before/after hooks and concurrency control, while preserving the existing public API surface for users.

src/api/structure · high confidence

The runner module (src/runner) has been rewritten in TypeScript, introducing new internal components such as Bootstrapper, BrowserSet, BrowserJob, and dedicated hook controllers for fixtures and test runs. This refactor enables native automation to run by default, replacing the previous proxy-based browser connection model for local browsers. The change also adds support for global before/after hooks at both the fixture and test-run levels, improves browser connection lifecycle management, and refactors the reporter stream handling to prevent conflicts when multiple reporters write to the same output.

src/runner · high confidence

The utility functions in src/utils have been rewritten in TypeScript, introducing new modules for handling asynchronous events (AsyncEventEmitter), filtering (async-filter), and execution queues (async-queue). This change also adds dedicated utilities for detecting virtual machines (check-is-vm), parsing user agents (parse-user-agent), and managing file paths and patterns (path-pattern, check-file-path). Additionally, new helpers for HTTP handling, error management, and debug logging have been integrated to support the updated architecture.

src/utils · high confidence

The test execution engine in src/test-run has been rewritten in TypeScript, introducing a more structured and maintainable architecture. This change extracts assertion execution into a dedicated executor that handles retry delays and unawaited promise detection, and moves browser manipulation commands (such as resizing, maximizing, and screenshotting) into a dedicated queue to ensure they are processed in order. Additionally, cookie and storage management are now handled by pluggable providers (Proxy vs. Native Automation/CDP) via factory classes, allowing the test runner to seamlessly switch between proxy-based and native automation modes without scattering conditional logic throughout the core test run flow.

src/test-run · high confidence

The Role module in src/role has been rewritten from JavaScript to TypeScript. This change introduces strict type definitions for Role options (such as preserveUrl), utilizes nanoid for generating unique role identifiers, and implements a phase-based state machine (uninitialized, pendingInitialization, initialized) to manage role lifecycle. The core Role class now extends EventEmitter and includes explicit handling for initialization errors and state snapshots, providing better type safety and structure for role-based testing workflows.

src/role · high confidence

The client-side test run templates (iframe.js.mustache and index.js.mustache) have been updated to pass configuration flags for native automation and experimental multiple windows to the driver. This enables the test runner to operate using native browser automation protocols instead of the proxy-based approach, supporting features like multiple browser windows and native dialog handling while maintaining compatibility with existing proxy-based execution.

src/client/test-run · high confidence

The TestController API is now fully implemented in TypeScript, providing the core interface for test actions, assertions, and custom actions. This change introduces a proxy mechanism that resolves the active TestController from the current execution context, ensuring that API calls are correctly routed to the running test. The implementation includes support for multiple window switching, native dialog handling, cookie management, and request hooks, while also adding warnings for deprecated usage patterns and unawaited promises.

src/api/test-controller · high confidence

Added a utility function to correctly handle CLI argument parsing, specifically addressing an issue where boolean options like \quarantine\ and \skipJsErrors\ could not be explicitly set to false. The new logic ensures that boolean values provided in the command line are correctly identified and processed, preventing them from being incorrectly moved to the end of the argument list.

src/cli/utils · high confidence

Resolves an issue where the t.eval() method failed to work correctly within 'execute-async-expression' scripts. The change introduces a dedicated module for executing JavaScript expressions, ensuring that async expressions are properly wrapped and that error locations (line and column) are accurately parsed and reported for both TestCafe errors and standard runtime errors.

src/test-run/execute-js-expression · high confidence

The native automation client in src/native-automation/client has been restructured to improve input simulation fidelity. A new event descriptor system now correctly handles keyboard modifier keys (Ctrl, Alt, Meta, Shift) for actions like hover and key presses, ensuring that hotkey combinations do not generate unintended character inputs. Additionally, the input layer now supports touch events on touch-enabled devices, mapping mouse actions to touch equivalents, and includes logic to handle specific shortcuts like Ctrl+A for select-all operations.

src/native-automation/client · high confidence

Added Docker-based TestCafe server tests; Added QUnit tests for contenteditable automation actions; Added client tests for contenteditable selection and typing automation; Added client tests for text selection automation; Added client-side automation tests; Added client-side legacy test fixtures for API actions and assertions; Added client-side test fixtures for core utility modules; Added client-side test infrastructure and configuration; Added concurrency test fixtures; Added expected error snapshots for action and assertion validation; Added expected legacy test-run error fixtures; Added functional test fixtures for reporter validation; Added functional tests for API features and regression fixes; Added functional tests for ClientFunction API; Added functional tests for ES-next assertion API; Added functional tests for HTTP authentication scenarios; Added functional tests for Live Mode; Added functional tests for Request Hooks API; Added functional tests for RequestMock edge cases; Added functional tests for Role initialization and state management; Added functional tests for Selector error handling and snapshot properties; Added functional tests for TestController API and missing await tracking; Added functional tests for Worker postMessage handling; Added functional tests for beforeunload dialog handling; Added functional tests for browser reconnect and disconnect handling; Added functional tests for client-side JavaScript error handling and skipping; Added functional tests for concurrent test execution; Added functional tests for custom browser user profiles; Added functional tests for custom user profile browser provider; Added functional tests for document.title handling; Added functional tests for document.title handling in iframes; Added functional tests for drag and drop API actions; Added functional tests for drag and select-editable-content API actions; Added functional tests for drag commands; Added functional tests for driver protocol and native automation behaviors; Added functional tests for driver storage isolation and action prevention; Added functional tests for file upload commands; Added functional tests for generic API error handling; Added functional tests for iframe switching and cross-origin messaging; Added functional tests for legacy API click and selector timeout behaviors; Added functional tests for multiple browser window scenarios; Added functional tests for native dialog handling in iframes; Added functional tests for page JavaScript error handling scenarios; Added functional tests for proxy bypass configuration; Added functional tests for quarantine mode configuration; Added functional tests for raw file upload API; Added functional tests for reporter stream handling and configuration; Added functional tests for request pipeline scenarios; Added functional tests for screenshot capture actions; Added functional tests for screenshot capture on test failures; Added functional tests for scroll API and scroll-initiated mouse events; Added functional tests for scroll API methods; Added functional tests for t.click() API validation and edge cases; Added functional tests for t.rightClick API; Added functional tests for t.takeScreenshot API; Added functional tests for t.typeText API; Added functional tests for text selection APIs; Added functional tests for text selection actions; Added functional tests for the --stop-on-first-fail option; Added functional tests for the HTTP request API; Added functional tests for the JSON compiler API; Added functional tests for the NavigateTo command; Added functional tests for the Selector Inspector and Status Bar UI components; Added functional tests for the Type API action; Added functional tests for the pressKey API; Added functional tests for the select-editable-content command; Added functional tests for the t.dispatchEvent API; Added functional tests for the t.doubleClick API; Added functional tests for the t.maximizeWindow API; Added functional tests for the t.useRole API; Added functional tests for the t.wait API; Added functional tests for the typeText API; Added functional tests for typing into non-text HTML5 input elements; Added functional tests for video recording capabilities; Added functional tests for window resizing and maximization; Added functional tests for window resizing and maximization APIs; Added legacy functional tests for JavaScript error handling and file uploads; Added legacy functional tests for error handling and screenshot generation; Added regression test for 'this' context in beforeunload event; Added regression test for BOM trimming in Native Automation; Added regression test for CDP click scroll position in nested iframes; Added regression test for Chrome emulation mode on iPhone X; Added regression test for Enter key behavior on buttons; Added regression test for GH-8091 TypeScript execution; Added regression test for Hi-DPI and zoomed page hangs; Added regression test for RequestHook header modification; Added regression test for RequestHook header modification logging; Added regression test for RequireJS module loading; Added regression test for SVG elements breaking text search; Added regression test for TestCafe Studio hangs with async reporters; Added regression test for TestCafe initialization with null; Added regression test for assertion stack trace accuracy in class methods; Added regression test for async reporter completion; Added regression test for beforeunload dialog handling during role initialization; Added regression test for border-radius selector timeout behavior; Added regression test for cancelled page redirect; Added regression test for caret position detection; Added regression test for checkbox space-key interaction; Added regression test for click focus behavior; Added regression test for click focus behavior on non-focusable elements; Added regression test for clicking 1px elements; Added regression test for clicking SVG elements inside shadow DOM; Added regression test for clicking elements behind the status bar; Added regression test for clicking elements overlapped by the status bar; Added regression test for clicking elements that move during interaction; Added regression test for clicking elements under the TestCafe panel; Added regression test for client scripts and request mocks in native automation; Added regression test for concurrency with quarantine mode; Added regression test for concurrent request logging; Added regression test for conflicting reporter output streams; Added regression test for cross-domain iframe focus; Added regression test for cross-domain iframe service URLs; Added regression test for cursor behavior in iframes; Added regression test for custom element click behavior; Added regression test for disabled select element interaction; Added regression test for double-click speed independence; Added regression test for double-scrolling issue in iframe automation; Added regression test for drag-to-element click behavior; Added regression test for dynamic iframe switching; Added regression test for element removal during navigation; Added regression test for empty JSON file handling; Added regression test for fake link click performance; Added regression test for fetch failures on non-existent paths; Added regression test for file input value retrieval; Added regression test for file protocol iframe access; Added regression test for file upload on hidden inputs; Added regression test for fixture hook isolation; Added regression test for form submission in iframe; Added regression test for fractional element dimensions; Added regression test for full-page screenshot sizing in Chrome headless; Added regression test for hovering hidden elements; Added regression test for iframe HTML src handling; Added regression test for iframe childNodes length; Added regression test for iframe console message capture; Added regression test for iframe cross-domain redirect hang; Added regression test for iframe cursor behavior; Added regression test for iframe rewriting in IE and Edge; Added regression test for input focus loss during typeText; Added regression test for key event properties; Added regression test for legacy test compatibility in native automation mode; Added regression test for localStorage persistence across navigation in Safari; Added regression test for minimal browser window sizing; Added regression test for mouse event 'which' property in native automation; Added regression test for native Date method usage; Added regression test for native automation authorization header handling; Added regression test for non-existent child selector; Added regression test for non-integer click offsets; Added regression test for page decoding in native automation mode; Added regression test for reconnecting under bad network conditions; Added regression test for reporter completion before fixture start; Added regression test for resource caching between tests; Added regression test for scroll-related visibility errors; Added regression test for scrolling to elements in shadow roots; Added regression test for scrolling to elements obscured by sticky footers; Added regression test for scrolling to elements overlapped by the TestCafe panel; Added regression test for scrolling with absolute-positioned body; Added regression test for scrolling with negative margins; Added regression test for select element input event timing; Added regression test for select input 'input' event firing; Added regression test for selecting elements in dynamically rewritten iframes; Added regression test for service worker request handling in native automation; Added regression test for shadow element in event handlers; Added regression test for single quotes in fixture and test names; Added regression test for smart assertions with delayed DOM updates; Added regression test for string statusCode handling; Added regression test for tab action with cross-domain iframes; Added regression test for table focus/blur behavior; Added regression test for test and fixture method execution order; Added regression test for test run collision; Added regression test for test start/done event ordering; Added regression test for textarea selection and input events; Added regression test for title node textContent in native automation mode; Added regression test for typeText replacement behavior; Added regression test for typeText with editable content selection; Added regression test for typing text in editable iframes; Added regression test for window.self override; Added regression test for zero-height element visibility; Added regression tests for --window-size in headless Chrome; Added regression tests for Ctrl+A text selection in Native Automation mode; Added regression tests for GH-5239 page retry behavior; Added regression tests for RequestHook AJAX event handling; Added regression tests for SVG element visibility checks; Added regression tests for Shadow DOM interactions; Added regression tests for checkbox label click behavior; Added regression tests for click and dblclick event handling; Added regression tests for click event handling during DOM mutations; Added regression tests for clicking elements hidden by fixed-position ancestors; Added regression tests for concurrency handling and multiline element clicks; Added regression tests for contentEditable selection handling; Added regression tests for contenteditable automation; Added regression tests for cookie clearing during role switching; Added regression tests for cookie handling in Native Automation; Added regression tests for cookie restoration with User Roles; Added regression tests for download link clicks in iframes; Added regression tests for drag event relatedTarget property; Added regression tests for element automation edge cases; Added regression tests for element visibility and automation waiting logic; Added regression tests for error ID propagation to reporters; Added regression tests for event timing and unnecessary delays; Added regression tests for file downloads in Chrome and Firefox; Added regression tests for focus handling in iframes; Added regression tests for focus handling with negative tabIndex elements; Added regression tests for hidden element interaction; Added regression tests for iframe and Web Worker request handling in Native Automation; Added regression tests for iframe switching and timeout handling; Added regression tests for input event handling and text input behavior; Added regression tests for invalid URL protocol validation; Added regression tests for invisible iframe interactions; Added regression tests for label focus behavior with tabIndex; Added regression tests for legacy iframe, action, and validation behaviors; Added regression tests for local storage restoration with UseRole; Added regression tests for native automation browser profile validation; Added regression tests for newlines in names and escaped selectors; Added regression tests for page redirect hanging issue; Added regression tests for page scrolling behavior; Added regression tests for radio button keyboard navigation; Added regression tests for scroll automation edge cases; Added regression tests for scroll indentation behavior; Added regression tests for scrolling to elements hidden by fixed positioning; Added regression tests for selector error callstacks; Added regression tests for selector option propagation; Added regression tests for stack trace filtering; Added regression tests for typing in contenteditable divs with invisible children; Added regression tests for unawaited assertion methods; Added regression tests for uncaught exception and rejection handling; Added regression tests for unhandled exceptions and promise rejections; Added skipped regression test for iframe switching after form submission; Added smoke tests for CoffeeScript API support; Added smoke tests for TypeScript API support; Added test coverage for Worker handling of undefined optional chaining; Added test coverage for client function compilation with typeof; Added test example for Travis and SauceLabs integration; Added test fixture for ES-next assertion scenarios; Added test fixture for callsite record validation; Added test fixture for drag-and-drop interactions; Added test fixture for editable content selection; Added test fixture for file upload functionality; Added test fixture for hover event logging; Added test fixture for isIFrameWindowInDOM utility; Added test fixture for legacy runner iframe; Added test fixture pages for driver functional tests; Added test fixture pages for press-key functionality; Added test fixture servers for functional testing; Added test fixtures for JavaScript error scenarios; Added test fixtures for RequestMock scenarios; Added test fixtures for async expression runtime and test-run errors; Added test fixtures for click action scenarios; Added test fixtures for cross-domain iframe message events; Added test fixtures for document.title behavior; Added test fixtures for drag-and-drop functionality; Added test fixtures for element visibility and interaction edge cases; Added test fixtures for file upload scenarios; Added test fixtures for generic error handling scenarios; Added test fixtures for multiple-window scenarios; Added test fixtures for page error scenarios; Added test fixtures for quarantine mode behavior; Added test fixtures for request hook API scenarios; Added test fixtures for request hook mock routes; Added test fixtures for screenshot capture scenarios; Added test for ES6 method syntax in ClientFunction arguments; Added test for childNodes order preservation; Added test for click actions under bad network conditions; Added test for client function compilation with destructuring; Added test for debug warnings in headless mode; Added test for file download in native automation mode; Added test for handling unreachable page errors; Added test for injected head scripts in iframes; Added test for module-type Web Workers; Added test for request body encoding in Native Automation RequestLogger; Added test for unhandled page errors; Added test helpers for server-side error assertions and mocking; Added test to verify video recording is skipped for skipped fixtures; Added test utilities for the selector inspector panel; Added test utility modules for functional testing infrastructure; Added test view template for upload success; Added tests for ES module test structure imports; Added tests for ESM module import behavior; Added tests for Linux GUI error handling and runner configuration; Added tests for RequestLogger functionality; Added tests for Selector property await warnings and usage; Added tests for Service Worker requests in native automation; Added tests for TestController chained callsites and assertions; Added tests for basic and NTLM HTTP authentication scenarios; Added tests for browser console message retrieval; Added tests for custom client scripts injection and error handling; Added tests for dependency license compliance checking; Added tests for file URL navigation support; Added tests for fixture and test lifecycle hooks; Added tests for global fixture, test, and testRun hooks; Added tests for multi-window mode restrictions on remote browsers; Added tests for native automation multiple-window handling; Added tests for native dialog handling in legacy fixtures; Added tests for page load timeout configuration and deprecation; Added tests for page reload control options; Added tests for quarantine mode error reporting; Added tests for raw Selector API variations; Added tests for request hook redirect behavior; Added tests for script execution barrier; Added tests for script execution barrier behavior; Added tests for shared code usage in iframes; Added tests for t.navigateTo and test.page URL handling; Added tests for test and fixture info in hooks; Added tests for the app command feature; Added tests for the disable page reloads API; Added tests for the disablePageCaching run option; Added tests for the getCurrentCDPSession API; Added tests for the new ES-Next file upload API; Added tests for the setNativeDialogHandler command; Added tests for the speed configuration option; Added tests for the t.browser API in headless Chrome; Added tests for the t.pressKey API; Added tests for userVariables API access; Added vendor test fixture for async.js; Expanded test coverage for RequestHook API behaviors; Expanded test coverage for multiple window interactions; Expanded test suite coverage for test file parsing and validation; Initial server-side test suite and linting configuration; Test coverage for headless debug warnings; Updated reporter expected output fixtures.

Added package-lock.json files to the basic, Bitbucket Pipelines, Travis CI, and SauceLabs example projects to ensure deterministic dependency resolution for users following these guides.

(dependencies) · high confidence

The repository has been initialized with essential configuration files, including a \.dockerignore\ to optimize Docker builds, an \.editorconfig\ to standardize coding styles across editors, and a comprehensive \.eslintrc\ enforcing TypeScript and JavaScript linting rules. Additionally, a \CHANGELOG.md\ is introduced, documenting the history of TestCafe releases from v3.7.2 back to v0.12.1, providing users with a record of bug fixes and feature additions.

(repo-wide) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 43 → 46 (+2.9)
• Rubric changed (rubric-2026.09.12 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 76 → 76 (+0.0)
• Architecture 45 → 49 (+3.9)
• Maturity 55 → 55 (-0.0)
• Readiness 34 → 34 (+0.7)
• Security 53 → 61 (+7.3)
• Performance 85 (new)

• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no pnpm-resolved versions to grade)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• Off-boarding risk: anonymized user #1

• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• Low cohesion: Fixture (LCOM4 8) (src/api/structure/fixture.ts)
• Low cohesion: RunnerMock (LCOM4 5) (test/server/live-test.js)
• Low cohesion: Test (LCOM4 6) (src/api/structure/test.ts)
• Medium CVE: [GHSA redacted] (package-lock.json)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Off-boarding risk: anonymized user #1
• Outdated (npm): @babel/core
• Outdated (npm): @babel/plugin-proposal-decorators
• Outdated (npm): @babel/plugin-transform-async-generator-functions
• Outdated (npm): @babel/plugin-transform-async-to-generator
• Outdated (npm): @babel/plugin-transform-class-properties
• Outdated (npm): @babel/plugin-transform-class-static-block
• Outdated (npm): @babel/plugin-transform-exponentiation-operator
• …and 47 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

DevExpress/testcafe was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.