All Classes and Interfaces
Class
Description
Transport-agnostic control-plane integration tests.
See: https://github.com/swagger-api/swagger-inflector
Shared scaffolding for
LlmClient implementations: URL parsing,
base-request construction (method, path, host, scheme, custom headers) and a
shared ObjectMapper.Focused packaging-smoke base for maven-invoker subprojects.
AbstractSchemaSerializer<T extends io.swagger.v3.oas.models.media.Schema>
Transport-agnostic matching/priority/TTL/verify/retrieve semantic tests.
Explicit per-transport decode-smoke integration tests.
Handles Kubernetes MutatingAdmissionWebhook requests (admission.k8s.io/v1).
A curated catalog of adversarial responses — the kind of hostile or
malformed output an agent might receive from a compromised tool or a
jailbroken upstream model.
A named adversarial payload.
Deterministic, read-only analysis of an agent run reconstructed from recorded
LLM requests.
The correlated call graph of an agent run.
A directed edge in the agent-run call graph.
A node in the agent-run call graph.
Structural summary of an agent run (for
explain_agent_run).A single tool call the assistant made.
Result of a
verify_tool_call-style inspection.Outbound handler that adds an
Alt-Svc header to responses served
over the TCP (HTTP/1.1 and HTTP/2) paths when HTTP/3 is enabled.Immutable model of the AsyncAPI AMQP 0.9.1 channel binding
(
channels.<name>.bindings.amqp), carrying the publish-time routing
information that AmqpMessagePublisher
needs to deliver a message to a RabbitMQ broker.The two shapes an AMQP channel can take, per the AsyncAPI
is field.A
MessagePublisher that delivers messages to an AMQP 0.9.1 broker
(RabbitMQ) using the official com.rabbitmq:amqp-client library.Codec for Anthropic Messages API (version 2024-10-22).
Runtime client for the Anthropic Messages API (
POST /v1/messages,
x-api-key + anthropic-version).This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
See: https://github.com/swagger-api/swagger-inflector
Represents a single channel from an AsyncAPI specification,
with its name, zero or more message payload examples, and
optional publish-time bindings (MQTT qos/retain, Kafka key).
SPI interface for the AsyncAPI control-plane, defined in mockserver-core so that
HttpState can route PUT/GET /mockserver/asyncapi
without depending on the mockserver-async module.Implementation of
AsyncApiControlPlane that lives in the mockserver-async
module and is registered into the core's AsyncApiControlPlaneRegistry
at server startup.Process-wide holder for the optional
AsyncApiControlPlane implementation.Generates HTTP mock
Expectations from a parsed AsyncAPI spec so that the
example messages each channel describes can be served over plain HTTP — without
standing up a live Kafka / MQTT / AMQP broker.Represents a single message definition within an AsyncAPI channel.
Orchestrates publishing of example messages derived from an AsyncAPI spec
to a message broker via a
MessagePublisher.Parses an AsyncAPI 2.x or 3.x document (JSON or YAML) into an
AsyncApiSpec.Validates JSON payloads against an AsyncAPI channel's JSON Schema definition,
reusing
JsonSchemaValidator from mockserver-core (which uses the
com.networknt:json-schema-validator library under the hood).Result of a schema validation.
A parsed AsyncAPI specification containing the channels and their message definitions.
A single control-plane audit record: one mutation (or, when read auditing is
enabled, one read) of the MockServer control plane, capturing who/what/when/
where/outcome.
Thread-safe, append-only, bounded ring buffer of
AuditEntry records
for control-plane mutations.Immutable outcome of authenticating a control-plane request, carrying not just
the boolean decision but the VERIFIED principal, the source of that verification,
and a redaction-safe subset of token claims and scopes.
Stateless, deterministic implementation of AWS Signature Version 4 (header-based
Authorization header signing) using only JDK crypto primitives:
MessageDigest (SHA-256) and Mac / SecretKeySpec
(HmacSHA256).BlobStore implementation backed by Azure Blob Storage.Registers the
AzureBlobStore with the core
StateBackendFactory so that blobStoreType=azure
selects it.Codec for Azure OpenAI Service (API version 2024-10-21).
Runtime client for Azure OpenAI.
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
Compares a CURRENT set of recorded interactions against a previously-saved BASELINE and produces a
structured
BaselineDiffReport so CI can detect when the shape of recorded traffic changed.One recorded interaction (request + response).
Structured drift report produced by
BaselineDiffer when comparing a CURRENT set of
recorded interactions against a previously-saved BASELINE.Codec for AWS Bedrock (Anthropic-on-Bedrock) invokeModel API (version bedrock-2023-05-31).
Encoder and decoder for the AWS event-stream binary message format
(
application/vnd.amazon.eventstream).A decoded event-stream message with parsed headers and raw payload.
Runtime client for Amazon Bedrock's Anthropic models
(
POST /model/{modelId}/invoke).Installed after a WebSocket handshake when the HttpWebSocketResponse has matchers.
Callback interface for sending response frames to the client.
See: https://github.com/swagger-api/swagger-inflector
An opaque binary blob with key and optional metadata, stored in a
BlobStore.Binary large-object store abstraction.
SPI for pluggable
BlobStore implementations.Builds a
BodyMatcher for a given Body template.Shared body-matching dispatch used by BOTH request matching
(
HttpRequestPropertiesMatcher) and response matching (HttpResponseMatcher).Minimal abstraction over the pieces of an HTTP message that the shared body-dispatch logic in
BodyMatching needs to match an actual message body against a template body matcher.See: https://github.com/swagger-api/swagger-inflector
A thread-safe, bounded FIFO store for
RecordedMessage instances.Dispatches breakpoint-held exchanges to a callback WebSocket client for
interactive resolution, reusing the same
WebSocketClientRegistry
dispatch primitives that object-callback (forwardObject /
responseObject) features already use.The resolution decision for a paused (breakpointed) exchange.
A registered breakpoint: a request matcher + set of phases at which matching
forwarded exchanges should be paused for interactive inspection/modification.
Process-wide registry of breakpoint matchers.
Demonstrates using interactive breakpoints to modify proxied (forwarded) traffic.
Phases at which a breakpoint matcher can intercept a forwarded exchange.
Handler invoked when a REQUEST-phase breakpoint is hit.
Handler invoked when a RESPONSE-phase breakpoint is hit.
Handler invoked when a RESPONSE_STREAM or INBOUND_STREAM phase breakpoint is hit.
Declarative capture-rule processor (WS2.2).
Declarative capture rule (WS2.2): when an expectation matches an incoming
request, each capture rule extracts a value from the request and stores it
into scenario state under the
CaptureRule.into name, so a later request's
response template can read it back via scenario.get(name) (WS2.1).The part of the request a capture rule reads from.
Process-wide registry of known cassettes — fixture files of MockServer expectations
recorded with
record_llm_fixtures or loaded with load_expectations_from_file.Safety circuit-breaker for service-scoped chaos: when the number of
error-class chaos faults (5xx synthetic errors, dropped connections,
and quota-limit responses) within a configurable sliding window exceeds a
threshold, all active service-scoped chaos profiles are automatically halted
(disabled) via
ServiceChaosRegistry.reset().Orchestrates scheduled multi-stage chaos experiments.
An experiment definition: name, ordered stages, whether to loop, and an
optional deferred start (
startDelayMillis and/or cronSchedule).Snapshot of the current experiment status.
A single stage: profiles to apply to specific hosts for a duration.
Shared deterministic probability-draw logic for chaos injection, used by both
HttpChaosProfile (HTTP fault injection) and LlmChaosProfile
(LLM fault injection).Persisted, named library of reusable chaos experiment profiles.
A bounded
ConcurrentLinkedDeque that evicts the oldest element(s) once it reaches
maxSize, invoking an optional callback on each evicted element.Priority-ordered queue with insertion-order eviction past
maxSize.Immutable snapshot of cluster membership and health for the
GET /mockserver/cluster operability endpoint.A single cluster member.
Codec for Cohere's rerank endpoint (
POST /v1/rerank).A composite
TransparentProxyHandler.OriginalDestinationResolver that tries
an ordered chain of resolution strategies and returns the first non-null result.A conditional (if-then-else) request matcher.
DTO for
ConditionalRequestDefinition (if-then-else request matching).Matcher for
ConditionalRequestDefinition (if-then-else request matching).A single resolved configuration property: its
mockserver.* key, the value
actually in effect (already redacted when sensitive), and the ConfigurationProperties.ResolvedProperty.source tier
that supplied it (one of the SOURCE_* constants).A Connect protocol (buf.build Connect) unary error.
The canonical Connect error codes.
Convenience factory for Connect protocol (buf.build Connect) unary responses.
Detects Connect protocol (buf.build Connect) unary requests and, when a proto descriptor is
loaded, validates the request message JSON against the method's input type.
Resolves the original destination of a transparently intercepted TCP connection
by reading the Linux conntrack table (
/proc/net/nf_conntrack).Coarse, hierarchical authorization for the control plane ("RBAC by standards
conformance"): maps a verified principal's scopes/groups through a configured
value -> role mapping into the set of granted ControlPlaneRoles, then
decides whether those granted roles satisfy the role REQUIRED by an operation.A coarse control-plane authorization role with a strict hierarchy:
ADMIN ⊇ MUTATE ⊇ READ.Serialisable predicate descriptors for LLM conversation matching.
In-process event bus that bridges protocol events to scenario state
transitions.
Describes a cross-protocol scenario correlation: when a protocol event
matching
CrossProtocolScenario.trigger (and optionally CrossProtocolScenario.matchPattern) is
observed, the named scenario is advanced to CrossProtocolScenario.targetState.Identifies the protocol event that triggers a cross-protocol scenario
state transition.
Cryptographic hashing and HMAC helpers for templates.
CSV parsing and formatting helpers for templates.
Loads the
CustomJsonUnitMatcherProvider class named by
mockserver.customJsonUnitMatchersClass and exposes the matchers it produces.Plug-in point for registering custom json-unit
matchers so they can be referenced from JSON body expectations using the
${json-unit.matches:name} placeholder.See: https://github.com/swagger-api/swagger-inflector
Applies the configured
defaultResponseHeaders to outgoing responses that MockServer
returns, using add-if-absent semantics so any header explicitly set on the matched response
always wins.The disposition (handling outcome) of a recorded request, used to narrow a
Verification to only those requests that were handled in a particular way.Resolves the original destination of a transparently intercepted TCP connection
by consulting the
DnsIntentRegistry — a record of hostname-to-IP answers
that MockServer's DNS server has handed out.Thread-safe bounded registry that records the hostname-to-IP answers MockServer's
DNS server has handed out.
See: https://github.com/swagger-api/swagger-inflector
Fires a fire-and-forget HTTP POST webhook whenever a
DriftRecord of sufficient severity is
stored, carrying the record as JSON.Compares a real forwarded response against a matching stub expectation's
configured response and emits
DriftRecords for any structural
discrepancies (status code, headers, JSON schema).Replays recorded LLM request/response exchanges against a live provider and
reports structural drift in the responses (new/removed fields, type
changes) — closing the loop on stale VCR cassettes.
A recorded request and the body of its recorded response.
A single drift observation: one field/aspect of a forwarded response that
differs structurally from the matching stub expectation's response.
Result of a drift-detection run: one
DriftReport.ExchangeDrift per recorded
exchange that was replayed against the live provider, plus rollup counts.Per-exchange structural-drift outcome.
Thread-safe LRU-capped store of
DriftRecord entries.Categories of structural drift detected when comparing a forwarded (real)
response against a matching stub expectation's configured response.
Inspects the incoming Netty HttpRequest (headers only) and, when a matching expectation
is configured with
respondBeforeBody=true, dispatches the response and closes the
connection before HttpObjectAggregator buffers the request body.Response writer for the early-dispatch path.
Resolves the original destination of a transparently intercepted TCP connection
by reading a pinned BPF hash map populated by an external eBPF program.
Shared, deterministic embedding-vector generation used by every provider
embedding codec (OpenAI, Gemini, Ollama, Bedrock Titan/Cohere).
See: https://github.com/swagger-api/swagger-inflector
See: https://github.com/swagger-api/swagger-inflector
Serializable entry stored in the expectation
KeyValueStore.Exports a list of
Expectations into third-party tooling formats —
OpenAPI 3 spec, Postman v2.1 collection, or a Bruno collection ZIP.Deprecated.
instead use org.mockserver.client.initialize.PluginExpectationInitializer or org.mockserver.server.initialize.ExpectationInitializer
Thrown when an expectation initializer (initialization JSON / OpenAPI file or initialization class)
fails to load and
failOnInitializationError is enabled, so that the failure aborts server
startup instead of being logged at WARN and ignored.Represents a single step in an ordered multi-action expectation pipeline.
Pluggable factory for the expectation store (
RequestMatchers).Creates the
RequestMatchers instance backing an HttpState.Generates copy-paste-ready C# expectation code for the MockServer .NET client
(
MockServer.Client).Generates copy-paste-ready Go expectation code for the MockServer Go client
(
github.com/mock-server/mockserver-monorepo/mockserver-client-go).Generates copy-paste-ready JavaScript/TypeScript expectation code for the
MockServer Node.js client (
mockserver-client).Generates copy-paste-ready PHP expectation code for the MockServer PHP client
(
mock-server/mockserver-client).Generates copy-paste-ready Python expectation code for the MockServer Python
client (
mockserver).Generates copy-paste-ready Ruby expectation code for the MockServer Ruby
client (
mockserver-client).Generates copy-paste-ready Rust expectation code for the MockServer Rust
client (
mockserver-client crate, module mockserver_client).Controls what happens to an expectation's primary response when a blocking
before-action fails or times out.Represents a single field-level difference between two
HttpRequest objects.Filesystem-backed
BlobStore implementation.Masks sensitive data in recorded expectations before they are written to fixture files.
See: https://github.com/swagger-api/swagger-inflector
Per-upstream circuit breaker for forwarded/proxied requests.
Stateless retry logic for forwarded/proxied requests.
A body matcher that matches when the request body is "similar enough" to an
expected string, using a deterministic string-similarity metric
(normalised Jaro-Winkler) with a configurable threshold between
0.0
and 1.0.Deterministic fuzzy / similarity body matcher.
BlobStore implementation backed by Google Cloud Storage.Codec for Google Gemini generateContent API (version v1beta-2025).
Runtime client for the Google Gemini
generateContent API.Optional exporter that publishes explicit OpenTelemetry spans via OTLP.
Static emit point for explicit GenAI semantic-convention spans describing the
LLM completions MockServer serves.
Per-generation-run options controlling how
ExampleBuilder produces example values
when the generateRealisticExampleValues configuration flag is enabled.This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
AST-aware GraphQL body matcher.
Generates mock
Expectations from a GraphQL schema document (SDL text or an
introspection JSON result).Synthesizes schema-valid GraphQL responses for a matched query, given a registered
GraphQL schema.
Thrown when a GraphQL schema or query cannot be parsed, or a schema-valid response
cannot be synthesized for a request.
Handles the graphql-transport-ws
protocol over an already-established WebSocket connection.
Callback interface for sending text frames to the client, with optional delay support.
Per-stream handler for serving gRPC Server Reflection interactively over the
bidirectional-streaming multiplex pipeline.
Response action for true bidirectional gRPC streaming.
Per-stream router that inspects the first
Http2HeadersFrame to determine whether
this stream is a true bidirectional-streaming gRPC method.Reactive rule for bidirectional gRPC streaming: each inbound client message is matched
against rules in order; the first rule whose
GrpcBidiRule.matchJson matches the inbound
message JSON emits its GrpcBidiRule.responses as DATA frames.Transport-neutral helper that matches an inbound gRPC bidi message (as JSON)
against a
GrpcBidiRule's matchJson pattern.Per-stream handler for true bidirectional gRPC streaming.
Evaluates a
GrpcChaosProfile against the current request context
(match count, quota state) and decides whether to inject a gRPC fault.The outcome of a gRPC chaos fault decision.
Declarative gRPC fault/chaos injection profile for probabilistically returning
gRPC error statuses (UNAVAILABLE, DEADLINE_EXCEEDED, RESOURCE_EXHAUSTED,
INTERNAL, etc.) on matched gRPC method calls, with latency, quota, and
count-window controls.
Process-wide registry of gRPC chaos profiles, keyed by gRPC service name.
Synthesizes schema-valid example protobuf messages from a loaded protobuf
Descriptors.Descriptor.Handles grpc.health.v1.Health/Check requests without a proto descriptor.
Adapter that bridges gRPC request/response framing for the HTTP/3 path.
Holds the parts of a gRPC response for HTTP/3 framing:
the gRPC-framed body bytes, the grpc-status value, and
an optional grpc-message.
Per-stream child initializer used with
Http2MultiplexHandler
when the gRPC bidi-streaming multiplex pipeline is enabled.Handles gRPC Server Reflection requests without a generated proto stub.
Transport-neutral helper that encodes a single gRPC stream message (JSON) into
a gRPC length-prefixed frame, ready to be written as an HTTP/2 DATA frame or an
HTTP/3 DATA frame.
Transport-neutral renderer that turns a
GrpcStreamMessage bidi response into the JSON
string to emit on the wire, applying optional response templating against the matched inbound
gRPC message.Transport-neutral seam for writing a server-streaming gRPC response
(
GrpcStreamResponse).Translates between gRPC-Web framing and standard gRPC framing.
Imports expectations from HAR (HTTP Archive) format JSON files.
HTML entity escaping helpers for templates: escape a string so it can be
safely embedded in HTML, and reverse the operation.
Emits an HTTP/2
GOAWAY frame on a connection-level (default) HTTP/2 pipeline so the client
is told to stop opening new streams and drain — the graceful "this connection is going away"
signal a server sends before a shutdown / preemption.Reads the first
Http2Settings objectHTTP/3 CONNECT-UDP (MASQUE, RFC 9298) relay handler.
Drives true bidirectional gRPC streaming over a single QUIC bidirectional stream
(HTTP/3).
A
ResponseWriter that writes gRPC responses over HTTP/3 with correct
gRPC wire framing: initial HEADERS (:status=200,
content-type=application/grpc), DATA (gRPC length-prefixed message),
and trailing HEADERS (grpc-status, grpc-message).HTTP/3 request stream handler that bridges incoming QUIC requests into
MockServer's standard request-processing pipeline (expectation matching,
actions, recording, proxy forwarding).
Converts between HTTP/3 frames and MockServer's
HttpRequest/HttpResponse model.Parsed HTTP/3 pseudo-headers and regular headers.
A
ResponseWriter that serialises the MockServer HttpResponse
as HTTP/3 frames and writes them to a QUIC stream channel.HTTP/3 (QUIC) server for MockServer, integrated with the full request pipeline.
Declarative HTTP fault/chaos injection for mocked and forwarded responses:
probabilistic connection-drop injection, error status injection (e.g. 500,
503, 429 with an optional
Retry-After header), latency injection, and
response-body corruption (truncateBodyAtFraction keeps only a leading
fraction of the body bytes; malformedBody appends a broken-JSON
fragment) for testing client-side body-parsing resilience, and a slow
("dribbled") response (slowResponseChunkSize + slowResponseChunkDelay
send the body in small chunks with a delay between each) for testing read
timeouts on a trickling response.Well-known stream-level error codes for HTTP/2 (RFC 7540 section 7) and HTTP/3
(RFC 9114 section 8.1).
Applies an
HttpError action to the underlying Netty channel: writes raw response bytes,
resets the request stream (HTTP/2 RST_STREAM, written here; HTTP/3 RESET_STREAM, handled by the
HTTP/3 response writer seam in mockserver-netty), and/or drops the connection.Forward a request to an upstream host; if upstream returns a configured
status code (default 500-599) or times out, return a fallback mock response.
Handles forward-with-fallback actions: forwards the request to the upstream
host defined by the
HttpForward; if the upstream returns a status code
matching the fallback criteria (default 500-599) or the request times out /
fails to connect, the configured fallback HttpResponse is returned
instead.Process-wide, stateful request quota for HTTP chaos — a fixed-window rate
limiter, the HTTP counterpart of
LlmQuotaRegistry.Identifies a memoizable body-conversion target.
Matches HTTP request properties against expectation criteria.
Matches an actual
HttpResponse against a template HttpResponse.A minimal, self-contained predicate that gates whether a
HttpResponseModifier applies.Applies
FixtureRedactor masking to expectations produced by the import
pipeline (HarImporter, PostmanCollectionImporter) before they
are persisted, so real credentials in captured traffic never land in the
expectation store.Redaction options for an import.
Incremental gRPC length-prefixed frame decoder that accumulates across multiple
feed() calls, retaining any trailing partial bytes for the next call.Validates that the destination host of a forward or proxy action is not a
loopback, link-local, RFC 1918 private, or cloud metadata address.
BlobStore backed by an Infinispan LOCAL cache.Infinispan cache listener that bridges Infinispan cache events to the
MockServer
InvalidationListener SPI.KeyValueStore backed by an Infinispan Cache.Infinispan-backed
StateBackend supporting both LOCAL (non-clustered)
and CLUSTERED (JGroups transport, REPL_SYNC) modes.Registers the
InfinispanStateBackend with the core
StateBackendFactory so that stateBackend=infinispan
selects it.Per-request in-flight token used by the WS7.2 graceful-shutdown connection drain.
In-memory
BlobStore implementation backed by a
ConcurrentHashMap.In-memory
KeyValueStore for expectations, backed by a
CircularPriorityQueue that provides identical ordering and
insertion-order eviction to today's RequestMatchers internals.General-purpose in-memory
KeyValueStore backed by a
ConcurrentHashMap.Default in-memory
StateBackend that wraps today's exact data
structures for zero behaviour change.See: https://github.com/swagger-api/swagger-inflector
A single entry in a
BaselineDiffReport, describing one interaction (matched across the
baseline and current sets by its request key of METHOD normalized-path).Listener for state-change events on a
KeyValueStore.Describes where to extract the isolation key from an inbound HTTP request
for per-session conversation state isolation.
Per-iteration template variable exposed to a
LoadScenario step under the
key "iteration", sibling of request / response.This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
String escaping for the small set of code paths that hand-assemble JSON inside
provider codecs (streaming chunks, where building a full Jackson tree per token
is unwarranted overhead).
See: https://github.com/swagger-api/swagger-inflector
See https://github.com/json-path/JsonPath
Pretty-prints an already-parsed
JsonNode tree to a JSON string.See http://json-schema.org/
Thrown when a schema-valid response body cannot be generated from an inline JSON Schema
(for example the schema cannot be parsed, or the example engine produces no example).
Synthesizes a schema-valid response body from a plain (inline) JSON Schema, without requiring a
full OpenAPI specification to be attached to the expectation.
Exposes JVM runtime metrics (heap / non-heap memory, threads, GC) as
Prometheus gauges so the dashboard Metrics view and Grafana can chart
MockServer's process health.
A
MessagePublisher that delegates to a Kafka KafkaProducer.A
MessageSubscriber that uses a Kafka KafkaConsumer to subscribe
to topics and record received messages.Immutable carrier for Kafka security configuration (SASL and/or SSL).
Utility for applying
KafkaSecurity settings to Kafka client
Properties.KeysAndValuesModifier<T extends KeysAndValues<I,T>,K extends KeysAndValuesModifier<T,K,I>,I extends KeyAndValue>
KeysAndValuesModifierDTO<T extends KeysAndValues<I,T>,K extends KeysAndValuesModifier<T,K,I>,I extends KeyAndValue,D extends DTO<K>>
KeysToMultiValuesModifier<T extends KeysToMultiValues<I,T>,K extends KeysToMultiValuesModifier<T,K,I>,I extends KeyToMultiValue>
KeysToMultiValuesModifierDTO<T extends KeysToMultiValues<I,T>,K extends KeysToMultiValuesModifier<T,K,I>,I extends KeyToMultiValue,D extends DTO<K>>
Versioned key-value store abstraction for shared MockServer state.
A key-value entry with version metadata.
Convenience re-exports of LLM model-class static factories so that
users can write a single import:
Declares a real LLM backend that MockServer can call as a client
(the opposite direction to the mock codecs, which build outbound mock
responses).
Resolves which
LlmBackend a runtime-LLM feature should use, across the
three config layers (simplest first):
Provider env conventions — auto-detect from OPENAI_API_KEY
/ ANTHROPIC_API_KEY / GEMINI_API_KEY / OLLAMA_HOST
(the same vars each provider SDK reads).
MockServer properties — a single default backend via
mockserver.llmProvider / llmApiKey / llmModel /
llmBaseUrl.
Named backends JSON — mockserver.llmBackendsConfig points
at a JSON array of backends, selectable by name.
The default backend prefers layer 2 (explicit properties) over layer 1 (env);
named backends come from layer 3.Declarative fault/chaos injection for an
HttpLlmResponse, for testing
agent resilience: probabilistic provider errors (e.g. 429/529 with a
Retry-After header), mid-stream truncation, and malformed SSE chunks.Per-provider knowledge for calling a real LLM as a client.
Orchestrates an outbound completion against a real LLM backend: looks up the
per-provider
LlmClient, builds the request, sends it via the
LlmTransport, and parses the response into a Completion.Builder for multi-turn LLM conversation mocks with optional per-session isolation.
Matches inbound HTTP requests against LLM conversation predicates.
Cost-budget circuit-breaker for LLM forwarding.
Pure, deterministic helper that produces the provider-specific
JSON error body real LLM providers return for overload / rate-limit / server
errors.
Pure, deterministic helper that produces the provider-specific
overload / rate-limit / server-error response bodies (and the matching default
HTTP status) that real LLM providers return.
Immutable (status, jsonBody) pair returned by
LlmErrorBody.bodyFor(org.mockserver.model.Provider, org.mockserver.llm.LlmErrorBody.Kind).The kind of provider error to synthesise.
Builder for LLM provider failover/retry test scenarios.
Fluent builder for creating LLM mock expectations.
Examples of mocking Large Language Model (LLM) provider responses.
Renders an
LlmOptimisationReport to a copy-paste Markdown
"optimisation brief" — bundle (A) of the LLM optimisation export feature.Structured, deterministic optimisation report for a captured LLM session
(the JSON bundle "B" of the LLM optimisation export feature).
One captured LLM call (request/response exchange).
A structured, copy-paste-friendly remediation for a
LlmOptimisationReport.Signal.How the captured traffic was grouped into one report.
What redaction was applied before the report/brief was produced.
Identity and scope of the session this report covers.
A deterministic optimisation lead.
A single assistant tool call observed in a call.
Aggregated counts across every included call.
A deterministic, in-product verdict — A–F grade plus the recoverable-spend
headline.
Builds a deterministic
LlmOptimisationReport from captured LLM
FORWARDED_REQUEST exchanges.A transport-agnostic captured exchange: the forwarded request, the
upstream response, and the request timestamp in epoch millis (or
null when unknown).Application service that turns captured
REQUEST_RESPONSES log entries
into an LlmOptimisationReport (JSON bundle) or a rendered Markdown
brief, applying the optional session/host/provider
filters, redaction, and the mockserver.llmOptimisationMaxCalls bound.Optional filters; null/blank means "no filter".
The built report plus the markdown brief, so callers render once.
Estimated cost calculation for LLM API usage.
The cheapest model in a provider's pricing table — its prefix label and
blended (input+output per-million) rate.
Input/output list price in USD per million tokens.
Maps a forwarded request's target host/URL to an LLM
Provider, enabling
GenAI observability on the proxy/forward path.Process-wide, stateful request quota for LLM responses — a fixed-window rate
limiter.
Pure, deterministic helper that produces the provider-specific
rate-limit HTTP headers real LLM providers send.
Utility for encoding and decoding LLM conversation isolation metadata
in scenario names.
Transport seam for outbound runtime-LLM calls.
The load profile of a
LoadScenario: an ordered list of LoadStages the orchestrator
runs in sequence.An API-driven load scenario: an ordered list of templated request
LoadSteps
driven at a target concurrency described by a LoadProfile, with optional
per-iteration data variation via the scenario's HttpTemplate.TemplateType.Orchestrates an in-process API-driven load scenario.
Immutable snapshot of a load scenario's progress, serialized by the GET endpoint.
Persisted, named registry of load scenario definitions.
Serializer for
LoadScenario, mirroring VerificationSequenceSerializer.Lifecycle state of a registered load scenario in the load-scenario registry.
One stage of a
LoadProfile: a contiguous slice of the run holding or ramping a setpoint
for durationMillis.The kind of a
LoadStage in a LoadProfile.One ordered step of a
LoadScenario: the request to fire and the optional
think-time to wait before firing the next step in the same iteration.Tiny thread-safe formatter exposing the same
format(Date) call shape the previous
public DateFormat LOG_DATE_FORMAT field offered, backed by an immutable
DateTimeFormatter.See: https://github.com/swagger-api/swagger-inflector
Base interface for all matchers in MockServer.
Shared daemon-thread executor used by request matchers (regex, XPath) to
bound the runtime of pathological user-supplied expressions.
Deterministic conformance / contract tester for a target MCP (Model Context Protocol)
server reachable over Streamable HTTP.
Outcome of a single named conformance check.
Result of a single JSON-RPC exchange.
One JSON-RPC exchange against the target server.
Full conformance report.
Registry of MCP prompts exposed by MockServer's own MCP server.
Transport-neutral MCP (Model Context Protocol) JSON-RPC request processor.
Result of processing an MCP request.
Netty channel handler that intercepts MCP (Model Context Protocol) requests
on the TCP (HTTP/1.1 and HTTP/2) path.
Generates Model Context Protocol tool definitions
from the current mock expectations, so an AI agent can discover and (via an MCP client) call the
mocked endpoints as tools.
Generates example JSON payloads for each channel in an
AsyncApiSpec.Publishes a message payload to a named channel (topic).
Subscribes to a message broker channel and records received messages for
later retrieval/verification — the consumer counterpart of
MessagePublisher.Small static helpers for deriving low-cardinality metric label values from load-scenario traffic.
Composite key (scenario + run_id) for the load gauge readers.
Produces short, actionable remediation hints from match-difference fields.
High-level operating mode for MockServer, packaging the common
record / replay / pass-through workflows into a single switch (set via
PUT /mockserver/mode).A scenario and its current state, as returned by the scenario control-plane endpoints.
An enriched Testcontainers module for MockServer.
Wires the
IP_TRANSPARENT socket option on the server bootstrap when
TPROXY mode is enabled.Configure MockServer when used in conjunction with
MockServerExtensionA
MessagePublisher that delegates to an MQTT MqttClient.A
MessageSubscriber that uses an MQTT MqttClient to subscribe
to topics and record received messages.Immutable carrier for MQTT security configuration (username/password and/or SSL).
Utility for building
MqttConnectOptions from MqttSecurity
configuration.Matches a
multipart/form-data request body at the field level.Decodes a
multipart/form-data request body into field-level
Parameters maps that can be matched the same way form parameters are.Immutable holder for the three field-level views of a decoded multipart body.
Matches a
multipart/form-data request body at the field level.The pair of values needed to decode an actual multipart request: the raw
body bytes and the request
Content-Type header (carrying the boundary).See: https://github.com/samskivert/jmustache or http://mustache.github.io/mustache.5.html for syntax
LlmTransport backed by the server's NettyHttpClient.Transport-selection utility that picks the highest-performance Netty transport
available on the current platform: Linux epoll when the native library is
present, NIO everywhere else.
Opt-in normalisation applied to LLM prompt text before
ConversationPredicates substring/regex comparisons are evaluated.See: https://github.com/swagger-api/swagger-inflector
Control-plane authentication handler for an external OIDC IdP: verifies an
Authorization: Bearer <jwt> access token's signature against the IdP's JWK
set, asserts issuer, audience, exp/nbf and required scopes, and surfaces the
VERIFIED sub as the principal (source verified-oidc) along with a
redaction-safe subset of claims and the normalised scope set.Mock OIDC
/authorize endpoint implementing the OAuth2 authorization-code grant.In-memory state backing the mock OIDC authorization-code flow.
Immutable record of an issued authorization code: the redirect_uri it was bound to, optional
PKCE challenge, the requested scope, and the
nonce echoed from the authorize request.Record of a device code issued by the device-authorization endpoint (RFC 8628).
Record of an opaque access token (issued when
OidcProviderConfiguration.isOpaqueAccessToken())
so the introspection endpoint can validate it: the claims to echo back and the absolute expiry.Immutable description of a generated OIDC provider.
Mock OIDC/OAuth2 device-authorization endpoint, implementing the OAuth 2.0 Device Authorization Grant
(RFC 8628 §3.2).
Mock OIDC/OAuth2 introspection endpoint (RFC 7662).
Extends
CustomJWTClaimsVerifier (which already enforces audience, exp/nbf
with skew, required claims and exact-match claims) to additionally assert, for an
external OIDC IdP:
the iss claim equals the configured issuer, and
the token's granted scopes (parsed from the configured scope claim) contain
every required scope.
Issuer and scope checks run BEFORE delegating to the superclass so a wrong issuer
or insufficient scope is reported with a precise message.Verifies a control-plane OIDC bearer token against a remote/immutable JWK set.
Resolves the
AsymmetricKeyPair that an OIDC provider signs tokens with and publishes via
its JWKS endpoint.Mock OIDC end-session (
/logout) endpoint, the end_session_endpoint advertised in
the discovery document.Configuration for the OIDC mock identity provider.
Generates MockServer
Expectations that serve a complete set of OIDC/OAuth2
identity provider endpoints: discovery, JWKS, token, authorize, userinfo, introspection,
revocation, and end-session (logout).Normalises an OIDC token's granted scopes into a flat
Set of strings.Mock OIDC
/token endpoint.Mints the OIDC token-endpoint response (access_token, id_token, refresh_token) at request time.
Codec for Ollama
/api/chat endpoint (version ollama-2025).Runtime client for a local Ollama server.
Codec for OpenAI Chat Completions API (version 2025-01).
Runtime client for the OpenAI Chat Completions API
(
POST /v1/chat/completions, Authorization: Bearer).Codec for OpenAI Responses API (version 2025-03).
Runtime client for the OpenAI Responses API (
POST /v1/responses,
Authorization: Bearer).Given an OpenAPI spec, builds representative example requests for each operation,
sends them via an injected HTTP-send function, and validates each response against the spec.
Structured result for a single contract test operation.
Given an OpenAPI spec, generates deliberately malformed and boundary-case requests
for each operation, sends them via an injected HTTP-send function, and classifies
each outcome as HANDLED (4xx) or UNEXPECTED (5xx, 2xx, or connection error).
Resolves OpenAPI runtime expressions (RFC 3.4.16) in callback after-action requests
using values from the triggering HTTP request.
Serves the embedded OpenAPI specification at GET /mockserver/openapi.yaml
Pure-function helper for incremental OpenAPI sync: given the set of existing
expectation ids, the set of newly-generated ids, and the namespace prefixes
that the new generation covers, determines which existing ids should be pruned.
Validates a list of request/response pairs against an OpenAPI specification.
Structured result for a single request/response pair validation.
Deterministic optimisation-signal detectors over the assembled calls of an
LlmOptimisationReport.Resolves per-signal OTLP HTTP endpoints from the single configured base URL
(see
mockserver.otelEndpoint).Optional exporter that publishes MockServer's explicitly-defined
metrics (the same
Metrics.Name gauges exposed for Prometheus) via
OpenTelemetry OTLP.Exports MockServer response expectations as a
Pact v3 consumer contract (JSON), so traffic mocked or
recorded in MockServer can be published to a Pact Broker / PactFlow and used for
consumer-driven contract testing.
Imports a Pact v3 consumer contract (JSON) and generates one
MockServer
Expectation per interaction, so a contract published by a consumer (or exported
via PactExporter) can be replayed by MockServer as a stub provider.Maps a Pact interaction's provider states (the
"given ..." preconditions) onto MockServer's existing scenario-state mechanism, so that
an imported interaction can be gated on its provider state being activated before the
interaction is served or verified.
Verifies that MockServer's currently-active expectations satisfy each interaction
in a Pact v3 consumer contract.
The result of verifying a single Pact interaction.
The overall result of verifying a Pact contract.
A multimodal audio content part recognised in a decoded request message.
A multimodal image content part recognised in a decoded request message.
Extracts the regex capture groups from a matched expectation's path pattern against the actual
request path, so they can be exposed to response/forward templates.
Holds the numbered and named capture groups extracted from a path match.
Represents a single streaming frame that has been paused at a breakpoint,
awaiting external resolution via the control-plane REST API or an automatic timeout.
Direction of the paused frame relative to MockServer.
Server-to-client WebSocket message carrying a paused stream frame for interactive
breakpoint resolution.
Sliding window p50/p95 tracker for response times per expectation ID.
If the MockServer is started using the Maven Plugin a initializationClass property can be specified to initialize expectations, when the MockServer starts.
Imports expectations from Postman Collection v2.x (v2.0 and v2.1) JSON files.
Declarative request to simulate a server preemption (Kubernetes node drain / Spot
reclamation / a SIGTERM the platform sends before killing the pod): the server cordons itself
(rejecting new exchanges), drains in-flight requests for a bounded window, and optionally signals
HTTP/2 clients to stop with a GOAWAY.
How new exchanges arriving while cordoned are turned away, and how HTTP/2 clients are told to
drain.
Process-wide state machine for a simulated server preemption (node drain / Spot
reclamation / pre-SIGTERM): when
PreemptionSimulator.start(PreemptionRequest) is called the server becomes
cordoned — new data-plane exchanges are turned away (503 + Connection: close on HTTP/1.1,
GOAWAY on HTTP/2, per PreemptionRequest.Mode) while in-flight requests are allowed to drain
for a bounded window.Deterministic normalisation of LLM prompt text prior to conversation-predicate
matching.
Deterministic, read-only heuristic that infers the
Provider from an
HttpRequest's path (and, as a fallback, its Host header).Inbound handler that detects and parses PROXY protocol v1 (text format) and v2 (binary
format) headers prepended to TCP connections by upstream load balancers (e.g., AWS GWLB,
HAProxy, nginx with
proxy_protocol on).Immutable carrier for per-message publish-time options extracted from AsyncAPI bindings.
The interpolation curve used to ramp a value (virtual users or arrival rate) from a
start setpoint to an end setpoint across a LoadStage as its
progress p advances over [0, 1].Declarative, protocol-agnostic rate-limiting / quota action attached to an
Expectation (a sibling of chaos).Process-wide, stateful, protocol-neutral rate-limit registry backing the
declarative
RateLimit expectation clause.The decision for a single acquire: whether the request is allowed plus the
header-facing limit/remaining/reset values.
Opt-in post-processing of recorded (proxy SPY/CAPTURE) expectations that
(a) deduplicates structurally-identical recorded request/response pairs,
keeping a single representative, and (b) templatizes variable path
segments so that, for example, recorded calls to
/users/1,
/users/2 and /users/3 collapse into a single expectation that
matches /users/{id} (a declared MockServer path parameter, which the
matcher normalises to a .* regex segment).An immutable record of a message received from a broker subscription.
Declarative retry/backoff recovery primitive attached to an
HttpResponse:
"fail the first K matches, then serve the configured success response".Serialization DTO for
RecoverAfter.Node-local, stateful per-key attempt counter for the
RecoverAfter
recovery primitive.Regular expression helpers for templates: test for a match, replace all
matches, and extract a capture group from the first match.
Shared JSONPath / XPath extraction helper used by the Velocity and JavaScript template engines so
those engines extract request-body fields with the exact same underlying libraries, error handling
and return semantics as the Mustache engine's
jsonPath / xPath lambdas.Velocity tool exposing JSONPath extraction as
$jsonPath.find("$.field") (and $jsonPath.jsonPath(...)).Velocity tool exposing XPath extraction as
$xPath.find("//field") (and $xPath.xPath(...)).Static emit point for request-level OpenTelemetry spans describing HTTP
request/response handling by MockServer.
Configuration for a mocked rerank response (Cohere
/v1/rerank,
Voyage /v1/rerank, ...).Shared, deterministic rerank scoring used by the rerank codecs (Cohere,
Voyage).
The provider-specific envelope wrapping the per-document scores.
One scored, original-index-tagged document.
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
BlobStore implementation backed by AWS S3 (or any S3-compatible
store such as MinIO).In-memory state backing the mock SAML SSO flow.
Immutable description of a generated mock SAML IdP, holding everything the SSO callback needs
to mint and sign a fresh
Response per request.Builds and enveloped-signs a SAML 2.0
<LogoutResponse> for the Single-Logout (SLO)
HTTP-POST profile, using only the JDK XML APIs and the JDK XML Digital Signature API (no
OpenSAML dependency), mirroring SamlResponseBuilder.Configuration for the SAML 2.0 mock identity provider.
Generates MockServer
Expectations that stand up a complete mock SAML 2.0 Identity
Provider implementing the SP-initiated Web-Browser-SSO POST profile, so applications using SAML
SSO can be tested without a real IdP.Builds and enveloped-signs a SAML 2.0
<Response> document using only the JDK XML APIs
(javax.xml DOM) and the JDK XML Digital Signature API (javax.xml.crypto.dsig.*) —
no OpenSAML/Shibboleth dependency.The RSA signing credential (private key + X.509 certificate) used to enveloped-sign SAML
assertions and to publish the IdP signing certificate in the metadata.
Mock SAML 2.0 IdP Single-Logout (SLO) endpoint implementing the HTTP-POST profile.
Mock SAML 2.0 IdP Single-Sign-On endpoint implementing the SP-initiated Web-Browser-SSO POST
profile.
Generates realistic, schema/format-aware example values using Datafaker with a fixed seed
for deterministic output.
Template helper that exposes scenario state (the WireMock "scenarios" pattern)
to response templates, so a value captured or derived in one request can drive
a later response.
Serves the SCIM collection endpoints:
GET <basePath>/Users|Groups (list with optional
filter + pagination) and POST <basePath>/Users|Groups (create).Minimal SCIM filter evaluator supporting a single
attr op "value" comparison over
top-level attributes.Applies a SCIM 2.0
PatchOp (urn:ietf:params:scim:api:messages:2.0:PatchOp) to a
stored resource.Signals a malformed PatchOp; carries the SCIM
scimType keyword.Configuration for the SCIM 2.0 mock provider.
Generates MockServer
Expectations that serve a complete SCIM 2.0 provider: CRUD over
Users and Groups plus the SCIM discovery endpoints
(/ServiceProviderConfig, /ResourceTypes, /Schemas).Serves the SCIM single-resource endpoints:
GET, PUT, PATCH, DELETE
on <basePath>/Users|Groups/{id}.In-memory state backing the mock SCIM 2.0 provider.
Immutable description of a registered SCIM provider: its Users and Groups stores plus the
per-provider enforcement flags.
Shapes raw stored resources into SCIM 2.0 wire representations and builds the SCIM envelopes
(ListResponse and Error).
The two SCIM resource types served by this provider, expressed as the singular resource name
used in URLs (
Users, Groups) mapped to its core schema URN.Which traffic an SLO sample or objective applies to.
Controls how GraphQL body matching compares the selection set (fields).
Optional LLM-powered extension to
DriftAnalyzer.Process-wide opt-in gate for semantic prompt matching.
Fuzzy, exploratory semantic match of a prompt against an expected
intent, using a runtime LLM as a yes/no judge (via the Phase-2
LlmCompletionService).Severity classification assigned by LLM-powered semantic drift analysis.
Process-wide registry of service-scoped HTTP chaos profiles, keyed by
upstream host.
Configuration for the MockServer sidecar injection.
Builds a RFC 6902 JSON Patch that injects the MockServer sidecar container
and iptables-REDIRECT init container into a Kubernetes Pod spec.
A resilience verdict request: a named set of
SloObjectives evaluated
synchronously over an already-elapsed SloWindow.DTO for
SloCriteria, the body of PUT /mockserver/verifySLO.Serializer for the
PUT /mockserver/verifySLO endpoint.A single objective within an
SloCriteria: one service-level indicator
compared against a threshold.The service-level indicator computed over the window.
DTO for
SloObjective.The evaluated outcome of a single
SloObjective: the observed indicator
value over the window and whether it satisfied the threshold.Process-wide store of recent request samples used to evaluate
SloCriteria into an SloVerdict.Result of an error-rate query over a window: error and total sample counts.
The resilience verdict produced by
SloEvaluator for one
SloCriteria.The time window over which an
SloCriteria is evaluated.DTO for
SloWindow.This exception indicates there was an error while trying to communicate over a socket
This exception indicates there was an error while trying to communicate over a socket
This class is expected to be used from within a
ReplayingDecoder, or with enough bytes available.Reads the original destination of an intercepted TCP connection on Linux.
Resolves the original destination of a transparently intercepted TCP connection
by calling
getsockopt(fd, SOL_IP, SO_ORIGINAL_DST, ...) via JNA on Linux.This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
Converts a recorded
Expectation (from a FORWARDED_REQUEST log entry) into an
SSE-aware replay expectation when the forwarded response was a streaming response.Parses raw
text/event-stream bytes into a list of SseEvent objects
suitable for constructing an HttpSseResponse.Pluggable backend for all shared MockServer state.
Pluggable factory for the
StateBackend.Creates a
StateBackend for an HttpState instance.Transport-neutral seam for resetting the request stream with an error code instead of returning a
response (an
HttpError carrying streamError).Process-wide registry of streaming response frame breakpoints.
Dispatches stream-frame breakpoint-held frames to a callback WebSocket client for
interactive resolution.
The resolution decision for a paused (breakpointed) streaming response frame.
Client-to-server WebSocket reply carrying the resolution decision for a paused
stream frame.
Closes the channel when an
IdleStateEvent fires, which indicates that no
streaming chunk has been received within the configured idle timeout period.An
HttpObjectAggregator that can recognise streaming responses — specifically
Server-Sent Events (Content-Type: text/event-stream) — so that, when
MockServer is acting as a proxy, such responses can be relayed to the client
incrementally instead of being fully buffered in memory before being forwarded.A chunk sink for streaming response bodies.
The wire format used by a provider for streaming responses.
Applies streaming physics (timing delays) to a list of SSE events.
Consumes unaggregated
HttpObjects on the NettyHttpClient channel when
a streaming response is detected.See: https://github.com/swagger-api/swagger-inflector
Deterministic string-similarity metrics used by
FuzzyMatcher.Compares two JSON documents by shape — the set of field paths and
their value types — ignoring values.
The structural delta between a recorded ("baseline") and a live document.
Builds the prompt sent to a runtime LLM backend to generate a realistic
MockServer expectation from an unmatched request.
Result returned by the AI stub generation endpoint.
Netty
ChannelDuplexHandler that injects raw TCP-layer faults
before HTTP decoding, based on the TcpChaosProfile
registered in TcpChaosRegistry for the connection's remote host.Declarative TCP-layer fault/chaos injection profile, applied at the raw byte
level before HTTP decoding.
Process-wide registry of TCP-layer chaos profiles, keyed by host.
Represents a timed auto-transition for a scenario state machine.
Records the wall-clock time when the first inbound byte (response head) arrives
from the upstream server.
Pure, deterministic approximate token counter for LLM text.
Resolves the original destination of a transparently intercepted TCP connection
using the TPROXY (IP_TRANSPARENT) mechanism.
Shared Netty channel
AttributeKey constants for W3C trace context.Netty handler that extracts W3C
traceparent / tracestate
headers from inbound HttpRequest objects and stores the parsed
W3CTraceContext as a channel attribute.Compares two
HttpRequest objects field-by-field and returns a list of FieldDiff
entries describing the differences.A Netty channel handler that resolves the original destination for transparently
intercepted connections and stores it as the
HttpActionHandler.REMOTE_SOCKET
channel attribute.Strategy interface for resolving the original destination.
Utility for transparent HTTP proxy mode — provides Host-header parsing helpers
and an
TransparentProxyInitializer.isEnabled() configuration check.Sub-builder for configuring a single turn within an LLM conversation mock.
Token usage for an LLM completion.
A value paired with an optimistic-concurrency version number.
Wrapper that pairs a value with an explicit version number for storage in
an Infinispan cache.
Codec for Voyage AI's rerank endpoint (
POST /v1/rerank).Parsed W3C traceparent header.
Body matcher that delegates matching to a WASM module stored in the
WasmStore.DTO for serialising/deserialising
WasmBody to/from JSON.Body matcher that delegates matching to a WASM module loaded in the
WasmStore.Immutable view of the parts of an HTTP request that a WASM matcher module can
inspect: the
method, path, headers, and body.Thin wrapper around a compiled chicory WASM instance.
Thread-safe in-memory store for WASM modules, keyed by module name.
Kubernetes MutatingAdmissionWebhook HTTPS server.
Callback interface for stream-frame breakpoint decision replies received
over the callback WebSocket.
Generates MockServer
Expectations from a WSDL 1.1 document so SOAP web services
can be mocked without hand-authoring stubs.See: https://github.com/swagger-api/swagger-inflector
See http://xml-schema.org/
XPath evaluation helper for templates: evaluate an XPath expression against an
XML document and return the string result.
YAML helpers for templates: convert YAML to JSON and read a field out of a
YAML document.