Skip to content
End-to-end testing against the runtime

Boot the app.
Verify the flow.

Stove starts the application under test, wires the dependencies it talks to, and lets you assert the complete flow in one Kotlin DSL. Postgres, Kafka, Redis, gRPC, WireMock, tracing, and more. JVM-first. Polyglot-ready.

✨ Launch the wizard Getting started Recipes GitHub →
// boot real app + real deps, assert real behavior stove { http { post<OrderResponse>("/orders", body) { it.status shouldBe 201 } } postgresql { shouldQuery<OrderRow>( query = "SELECT * FROM orders", mapper = { row -> OrderRow(row.string("id")) } ) { it.size shouldBe 1 } } kafka { shouldBePublished<OrderCreated> { actual.userId == userId } } }

In 30 seconds Stove registers the systems your app depends on, then registers one AUT runner. A system is a dependency, client, mock, or observability module such as HTTP, PostgreSQL, Kafka, WireMock, tracing, or dashboard. An AUT runner starts the app through a framework, process, or container runner, or targets an already-running app with providedApplication(). For framework/process/container runners, Stove passes generated connection details before the app starts; provided applications must already be configured externally. When a test fails, the failure report adds a timeline and system snapshots to the stack trace.

What you actually get

🧱
Real dependencies

Testcontainers by default, or provided instances when existing infrastructure should be reused.

🎛️
One DSL, many systems

The same stove { } shape works across Postgres, Kafka, gRPC, WireMock, Redis, MongoDB, Elasticsearch, and custom systems.

🌐
Polyglot AUT

Spring, Ktor, Micronaut, and Quarkus runners, plus Go, Python, Rust, Node, and other apps through process or container mode.

🛰️
Failures with context

Reporting is built in; tracing adds span trees, dashboard stores run evidence, and MCP exposes agent-readable evidence when enabled.

See the run while it happens

When dashboard { } is registered and the stove CLI is running, registered systems stream local run evidence into a dashboard you can keep open while iterating. Timeline entries, system snapshots, Kafka observations, and exported spans stay attached to the test that produced them.

Stove Dashboard v0.24.0 local evidence stream
Live MCP /mcp
OrderFlowTest create order publishes event failed 412 ms
Timeline (4) Trace (5) Snapshots (3) Flow
Timeline 412 ms
  1. HTTP POST /orders 201 / 42 ms
  2. PostgreSQL insert orders 18 ms
  3. Kafka order.created published partition 0
  4. HTTP POST /payment/charge 500 / 117 ms
Trace tree traceparent linked
test: create order 412 ms
HTTP POST /orders 405 ms
OrderService.place 318 ms
PaymentClient.charge gateway timeout
Kafka send order.created 9 ms
System evidence captured at failure
Kafka 1 message order.created
PostgreSQL 1 row orders.status = PENDING
HTTP 500 payment gateway timeout
MCP: stove_failure_detail MCP: stove_trace

Open Dashboard docs

Setup wizard

Pick runtime, framework, systems, mocks, and observability. The wizard composes version-aligned Gradle dependencies, StoveConfig.kt, and a sample test that exercises the selected systems. State syncs to the URL; share or bookmark presets.

Why Stove exists

JVM frameworks solve application startup well, but e2e suites still need the same surrounding mechanics in every service: dependency lifecycle, dynamic ports, runtime configuration, application boot, cleanup, and diagnostics.

Without Stove

  • Hand-rolled Testcontainers setup per service
  • Mocks where they shouldn't be (the bug hides there)
  • Framework-specific test harness rewritten each time
  • Stack traces without the system timeline
  • Separate test harnesses for polyglot services

With Stove

  • Declarative Stove().with { ... } wiring
  • Real DB, real broker, and external services mocked only at the network boundary
  • One DSL across Spring · Ktor · Micronaut · Quarkus
  • Failures include timeline and snapshots; tracing, dashboard, and MCP add deeper evidence when enabled
  • Go/Python/Rust apps drop in via process/container mode

One testing model. Many stacks.

Architecture

Stove architecture

Building from source

# requires JDK 17+ and Docker
./gradlew build

Background and motivation: original Medium article.