All Classes and Interfaces
Class
Description
Implemented by request-scoped contexts that participate in the
POST-handler dispatch chain via the
context.actions registry.Fast ANSI colorizer for JSON text.
OAuth 2.0 Authorization Code + PKCE Auth Handler.
Locator-based Element implementation that delegates all operations to a Driver.
Backing object for the
boot global exposed inside karate-boot.js.Discovers
karate-boot.js (workdir root, then classpath root) and evaluates
it once per Suite.Chrome DevTools Protocol client built on WebSocket.
CDP-based implementation of Dialog.
CDP-based browser driver implementation.
CDP-specific driver configuration options.
Wrapper for Chrome DevTools Protocol events with JSONPath extraction.
Listener interface for CDP events.
CDP-based implementation of keyboard actions.
CDP-based browser launcher.
Fluent builder for Chrome DevTools Protocol messages.
CDP-based implementation of mouse actions.
Wrapper for Chrome DevTools Protocol responses with JSONPath extraction.
Represents an async channel (e.g. kafka, grpc) created by a
ChannelFactory.Factory for creating
Channel instances.The 'clean' subcommand for cleaning Karate output directories.
SPI for ext JARs to contribute
karate CLI subcommands (e.g.Config-only evaluation: evaluate a project's
karate-base.js + karate-config.js (+ the
env-specific karate-config-<env>.js) for a working dir and return the merged config
Map without running any features (no SUITE_ENTER/SUITE_EXIT, no
scenarios).Console output utilities with ANSI color support.
Core driver interface defining the primitive operations.
CSRF (Cross-Site Request Forgery) protection utilities.
CSRF token object exposed to templates.
A
ResultListener that generates Cucumber JSON reports.Generates Cucumber JSON reports compatible with third-party tools (Allure, ReportPortal, etc.).
Default implementation of
HttpClientFactory that creates a new
ApacheHttpClient instance for each call.Interface for JavaScript dialogs (alert, confirm, prompt, or beforeunload).
Functional interface for handling JavaScript dialogs (alert, confirm, prompt, beforeunload).
Thrown when a pending Runtime.evaluate is cancelled because a JavaScript
dialog (alert, confirm, prompt) opened in the browser.
A disk-backed list implementation for handling large collections without
exhausting memory.
Browser automation driver interface.
Runtime exception for browser driver errors.
Base options interface for browser drivers.
Provider for browser driver instances.
Represents a DOM element found by a locator.
Error event (ERROR).
Chai-style BDD assertion API for Karate.
Karate ext SPI — singletons-per-Suite that observe the run via
RunListener.Mints a per-scenario ext-global instance, bound fresh into each
scenario's JS scope.
Turns a bare
ReferenceError: X is not defined inside a step into an actionable failure —
when X is a global that an ext would have bound, had the project declared it.Faker API for generating random test data.
Wrapper for a Feature with an optional tag selector.
Feature-level events (FEATURE_ENTER, FEATURE_EXIT).
File-based implementation of SessionStore.
Positional element finder for relative locators.
Devmode post-processor that emits paired
<!-- ka:fragment-begin -->
/ <!-- ka:fragment-end --> comments around every fragment resolution
and suppresses the synthetic <ka-trace> wrapper element that
TraceWrappingHandler injected at processor time.Lexer for Gherkin syntax with embedded JavaScript expressions.
Global constants and utilities for Karate runtime.
A
ResultListener that generates HTML reports.Generates HTML reports with inlined JSON data and Alpine.js client-side rendering.
Fluent HTTP client API for making HTTP requests from Java code.
Factory for creating HttpClient instances.
HTTP-level events (HTTP_ENTER, HTTP_EXIT).
Thymeleaf dialect for HTMX support.
In-memory implementation of SessionStore.
Functional interface for handling intercepted network requests.
Represents an intercepted HTTP request.
Represents a mock HTTP response for request interception.
A
RunListener that streams events to a JSON Lines (.jsonl) file.A
ResultListener that generates JUnit XML reports.Generates JUnit XML reports compatible with CI systems (Jenkins, GitHub Actions, etc.).
Holds runtime configuration settings set via the 'configure' keyword.
The exception surfaced to callers (JUnit / surefire, the fluent
Runner API, any
code that catches a Karate failure) when a step fails.Main implementation of the karate.* JavaScript API.
Minimal context interface for KarateJs to access runtime information.
Stateless utility methods for the karate.* JavaScript API.
Applies system-property and environment-variable overrides to a
Runner.Builder
at the start of parallel().Represents Karate project configuration loaded from karate-pom.json.
Logging configuration nested object.
Output configuration nested object.
Keyboard actions interface for browser automation.
Interface for handling large collections that may need to be stored
on disk to avoid memory exhaustion.
Local HTTP server to capture OAuth redirect with authorization code.
Utility class for transforming locators into JavaScript expressions.
Thread-local log collector for scenario execution.
Fluent log writer that captures to LogContext buffer AND cascades to SLF4J.
Snapshot of the report-buffer threshold, the log mask/pretty settings and — only if
something changes them while it is live — the per-category Logback levels.
Declarative HTTP log masking.
Main entry point for the Karate CLI.
Context interface exposed to templates and server-side JavaScript.
Current-eval scope accessor injected onto a
MarkupContext
by MarkupTemplateContext at engine-bind time.Represents a parsed match expression.
The 'mock' subcommand for starting mock servers.
Configuration holder for mock servers.
Mock server request handler that routes requests to matching scenarios.
Deprecated, for removal: This API element is subject to removal in a future version.
Public API for creating mock servers from feature files.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
MockServer.Builder instead.Builder for creating MockServer instances.
Mouse actions interface for browser automation.
Callback interface for OAuth 2.0 browser-based authorization.
Manages OAuth 2.0 token storage and refresh.
Scenario-outline-level event (OUTLINE_ENTER).
Page load strategies for navigation.
Provides protection against path traversal attacks in resource resolution.
Exception thrown when a path traversal attempt is detected.
Interface for capturing custom performance events from Java code.
Represents a performance event for Gatling integration.
Hook interface for performance testing integration (e.g., Gatling).
PKCE (Proof Key for Code Exchange) code verifier and challenge generator.
Driver provider that maintains a bounded pool of drivers.
Utilities for waiting on ports and HTTP endpoints.
Builder for ProcessConfig.
Immutable configuration for process execution.
Main process wrapper exposed to JavaScript.
Progress event (PROGRESS).
Imperative spec for one ext's report-asset contribution, built fluently inside
Ext.onBoot(Suite) and handed to
Suite.registerReportAssets(ReportAssets, ClassLoader) (see EXT.md § Report assets).One nav-page (or other slot) contribution.
Represents a single failure in a match operation with structured data.
Interface for receiving test execution results as they stream in.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
SuiteResult instead.Resource resolver that resolves paths relative to a configured root.
The 'run' subcommand for executing Karate tests.
Base interface for runtime events fired during test execution.
Event types for the unified runtime event system.
Unified listener interface for runtime events.
Factory for creating per-thread RunListener instances.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
Runner instead.Main entry point for running Karate tests programmatically.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
Runner.Builder instead.Shared helpers for run-event JSON shaping — cross-run-stable slug computation
and tag-text extraction.
SameSite cookie attribute values per RFC 6265bis.
Manages locks for parallel scenario execution.
Handle for releasing acquired locks.
Scenario-level events (SCENARIO_ENTER, SCENARIO_EXIT).
Applies security headers to HTTP responses to protect against common web vulnerabilities.
Configuration for the HTTP server including routing, sessions, and security settings.
Server-side context exposed to templates and API handlers.
Per-request lifecycle wrapper that provides isolated Engine instances.
Main request handler implementing routing for static files, API endpoints, and HTML templates.
Exception used internally to signal a redirect.
Session state carrier.
Interface for session persistence.
Server-Sent Events connection wrapping a Netty channel.
Handler for Server-Sent Events (SSE) connections.
SSL/TLS configuration for both client and server contexts.
Factory for creating SSLContext instances from SslConfig.
SSL utilities for creating SSL contexts and self-signed certificates.
A named report embed, generalised to one-or-more
StepResult.Parts plus optional
meta (see EXT.md § Embeds).One asset within an
StepResult.Embed: either inline data (core writes the
file and sets fileName) or a report-relative url (the ext wrote
the asset itself, e.g. under ext/image/assets/).Step-level events (STEP_ENTER, STEP_EXIT).
Static utility methods for step execution.
The callable target and (optional) argument expression of a call step, e.g.
Parsed result of a feature path with optional tag selector or line filter.
Immutable suite configuration and execution engine.
Suite-level events (SUITE_ENTER, SUITE_EXIT).
Advanced tag selector supporting V1-compatible expressions.
Values helper class for valuesFor('@tag') functionality.
Signal thrown by
ServerMarkupContext.redirect(String) and
ServerMarkupContext.switchTemplate(String) to cleanly abort
template rendering or API handler evaluation when a redirect or a
template switch is requested.Enum-driven configuration for all W3C WebDriver browser types.
W3C WebDriver protocol driver implementation.
W3C WebDriver configuration options.
W3C WebDriver Element implementation that holds a W3C element ID.
W3C WebDriver Actions API keyboard input implementation.
W3C-based implementation of mouse actions.
W3C WebDriver HTTP session client.
Protocol-agnostic WebSocket client built on Netty.
Netty handler for WebSocket client connections.
Configuration for WebSocket client connections using builder pattern.
WebSocket connection wrapping a Netty channel.
Exception type for WebSocket errors with cause differentiation.
Immutable wrapper for WebSocket frames (text, binary, control frames).
Handler for WebSocket upgrade requests.
MockServerinstead.