Stove

Stove is an end-to-end testing framework for JVM applications. It boots your real application together with the dependencies it actually uses, so your tests exercise the real runtime flow instead of a hand-built harness full of mocks.

If your service talks to HTTP APIs, Kafka, databases, Redis, gRPC services, or external providers, Stove lets you bring those pieces into one test setup and assert the full behavior in one place.

Since JVM languages interoperate, your application and tests do not need to use the same language. Write the app in Java, Kotlin, or Scala, and keep the tests consistent on the Stove side.

The only hard requirement is Docker, because Stove uses Testcontainers under the hood.

Not a Replacement for Unit Tests

Stove is for end-to-end and component tests, not unit tests. Keep unit tests for fast feedback on isolated logic.

See It Quickly

The core idea is small:

Stove()
  .with {
    httpClient {
      HttpClientSystemOptions(baseUrl = "http://localhost:8080")
    }

    kafka {
      KafkaSystemOptions(...)
    }

    springBoot(
      runner = { params -> run(params) },
      withParameters = listOf("server.port=8080")
    )
  }
  .run()

stove {
  http {
    get<String>("/hello") { body ->
      body shouldContain "hello"
    }
  }

  kafka {
    shouldBePublished<String> { it.contains("created") }
  }
}

You start the real app, bring up only the dependencies you need, and assert through the surfaces that matter.

Choose Your Path

• New to Stove

  Start with the shared setup model and learn the basic DSL once.

  Getting Started

• Already know your framework

  Pick the starter that matches your application runtime.

  Supported Frameworks

• Already know your dependencies

  Add Kafka, PostgreSQL, WireMock, HTTP, tracing, and other components as needed.

  Components

• Want a working project

  Open a complete example and adapt it instead of starting from scratch.

  Examples on GitHub

Why Stove

The JVM ecosystem has strong application frameworks, but e2e setup is usually framework-specific and repetitive. Teams end up rebuilding the same boilerplate around containers, startup wiring, ports, config injection, test cleanup, and diagnostics.

Stove standardizes that workflow:

• start physical dependencies first
• boot the real application through its actual entrypoint
• inject container/runtime configuration into the app
• assert through HTTP, Kafka, gRPC, databases, and tracing
• keep the same test DSL across frameworks

One testing model, multiple JVM stacks.

Supported Frameworks

Stove currently ships starters for:

• Spring Boot
• Ktor
• Micronaut
• Quarkus

See the full overview in Supported Frameworks, including bridge() availability and example links.

What You Can Test

Stove composes framework starters with pluggable components, so you can match your test environment to your production architecture.

• APIs through HTTP or gRPC
• event flows through Kafka
• persistence through PostgreSQL, MySQL, MongoDB, Redis, and more
• external integrations through WireMock and gRPC Mock
• execution diagnostics through Reporting and Tracing

High Level Architecture

Start Here

1. Read Getting Started for the shared setup.
2. Open your starter guide under Supported Frameworks.
3. Add the components you need from Components.
4. Compare against a real project in examples.

Building From Source

To build Stove locally you need:

• JDK 17+
• Docker

Then run:

./gradlew build

Want the background and motivation? Read the original Medium article.