GitHub stars
311

Install

/plugin install stove@stove-plugins

Run it inside Claude Code after adding the marketplace with /plugin marketplace add Trendyol/stove.

Contents

Discovered from source

Skills 1

Stove Skill Router

Open only the focused guides needed for the user's task. Guide links are relative to this skill directory, wherever it is installed.

First checks

  1. Check the project's resolved Stove version, existing test setup, and Gradle conventions before adding configuration. Follow task aliases to the actual Gradle Test task before configuring JVM options, tracing, or report paths. Standalone downloads follow upstream main; plugins declare their Stove version, and local copies follow their source checkout. Any of these can differ from the project's dependencies; do not upgrade dependencies just to match an example.
  2. Identify the application-under-test mode:
    • JVM in-process: Spring Boot, Ktor, Micronaut, Quarkus.
    • Host process: Go, Python, Rust, Node.js, or another binary via processApp / goApp.
    • Container image: any language via containerApp.
    • Already running app: staging/dev smoke tests via providedApplication.
  3. Identify test framework: Kotest uses StoveKotestExtension() and kotest.properties; JUnit uses StoveJUnitExtension. Cucumber uses StoveSteps suspend lambdas (or Stove step annotations) and StoveCucumberPlugin; read cucumber.md. Each needs explicit Stove startup and teardown in the framework lifecycle; the reporting adapter alone does not launch the app.
  4. Identify needed systems: HTTP, OIDC authentication, databases, Kafka, WireMock, gRPC, tracing, dashboard.
  5. Verify uncertain APIs against the resolved version's source artifacts; see gradle-config.md. In a Stove checkout, source also lives under lib/, starters/, test-extensions/, and server/stove-server/.

Paths such as docs/, examples/, and lib/ in these guides refer to the Stove repository, not the downstream application. When they are absent locally, consult that repository at the matching release tag, or published documentation.

Use Stove APIs before native handles

Use the system DSL for every operation it already supports. Before adding native access such as WireMock server(), HTTP client(), database session() / operations(), or a helper built on those handles, inspect the resolved version's relevant public methods, overloads, extensions (including companion extensions), inherited APIs, and builders. Familiarity with the underlying SDK, or not finding one guessed method name, is not evidence of a missing Stove API.

Choose in this order: existing system DSL, configuration or supported callback, managed native extension, then unrestricted native handle for a demonstrated gap. For a fallback, briefly name the required capability and the closest Stove API checked in a code comment or implementation note. Keep operations that Stove supports in its DSL.

Native access is correct when it is the documented API contract: Redis currently uses its client for data operations, and some configuration, migration, and cleanup callbacks receive native types. Do not invent missing wrappers. Before finishing, review new handle calls/imports and helpers for duplicated Stove functionality; inspect their receiver and purpose rather than banning a method name. See api-selection.md for the lookup workflow, common replacements, and valid exceptions.

Route by task

User needOpen
Gradle source sets, BOM, e2eTest, local artifact ambiguitygradle-config.md
JVM setup, system options, provided instances (existing infra), keyed systems (SystemKey)system-setup.md
Quarkus Bridge, CDI bean access, e2e bean preservation, augmented test classpathsystem-setup.md#quarkus-bridge-setup
Cucumber feature files, suspend steps, scenario reportingcucumber.md
Writing stove {} assertions and validation DSLwriting-tests.md
OIDC authentication, NAV/Keycloak providers, JWTs, token grants, or keyed issuersoidc.md
Choosing an API, using a native handle, or reviewing SDK-based helpersapi-selection.md
Go or other non-JVM process modeother-languages.md, then go-setup.md for Go
Docker-image AUT / Testcontainers runnercontainer.md
OpenTelemetry setup, Gradle plugin wiring, and trace assertionstracing.md, then gradle-config.md for task wiring
Continuous profiling, Drill Down, CPU/allocation analysis, or profiling runtime supportprofiling.md
Dashboard metadata, shared server, PostgreSQL, retention, or administrationdashboard.md
Agent queries and failed-run triage over MCPmcp.md
New Stove system implementationcustom-systems.md
Integration examples and full flowsStove recipes
Dependency conflicts or upgrade behavior changescompatibility.md
Chaos testing setup, fault and experiment DSLs, recovery assertions, or migrationchaos-testing.md
Failure diagnosis and common symptomsStove troubleshooting

Current API anchors

Prefer these shapes unless local source proves otherwise:

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

    // runner last
    springBoot(
        runner = { params -> com.yourcompany.app.run(params) },
        withParameters = listOf("server.port=8080")
    )
}.run()
processApp {
    ProcessApplicationOptions(
        command = listOf("./build/app"),
        target = ProcessTarget.Server(
            port = 8080,
            portEnvVar = "PORT",
            readiness = ReadinessStrategy.HttpGet(url = "http://localhost:8080/health")
        )
    )
}
goApp(
    binaryPath = System.getProperty("go.app.binary")
        ?: error("go.app.binary system property not set"),
    target = ProcessTarget.Server(
        port = 8080,
        portEnvVar = "PORT",
        readiness = ReadinessStrategy.HttpGet(url = "http://localhost:8080/health")
    )
)
containerApp(
    image = "ghcr.io/acme/app:sha",
    target = ContainerTarget.Server(
        hostPort = 8080,
        internalPort = 8080,
        portEnvVar = "PORT",
        readiness = ReadinessStrategy.HttpGet(url = "http://localhost:8080/health")
    )
)
providedApplication {
    ProvidedApplicationOptions(
        readiness = ReadinessStrategy.HttpGet(url = "https://staging.example.com/health")
    )
}

Dashboard and MCP defaults

Run the server with stove.

SurfaceDefault
UI / REST / MCPhttp://localhost:4040
gRPC event ingestionlocalhost:4041
StorageSQLite at ~/.stove-dashboard.db; set --database-url for PostgreSQL
Completed-run retention3 passed and 5 failed per app; set --retention-passed-runs-per-app / --retention-failed-runs-per-app; 0 means unlimited per outcome
Idle running-run expiry3600 seconds without ingestion; set --run-idle-timeout-seconds; 0 disables expiry
Administrationdedicated /admin page

In test code, DashboardIngestion.Grpc(host, port) defaults to localhost:4041. Shared servers intentionally have no authentication or authorization, so expose every Stove surface only on a trusted internal network.

Guardrails for agents

  • New examples use the current API. When maintaining a pre-0.20 suite, preserve imports such as com.trendyol.stove.testing.e2e.* if its resolved artifacts require them; an upgrade needs coordinated dependency, import, lifecycle, and API changes. See compatibility.md.
  • With current dependencies, do not use removed runner types such as ContainerAppOptions, ProcessAppOptions, or GoAppOptions; legacy maintenance follows the resolved release.
  • ReadinessStrategy.HttpGet takes url = "...", not path = "...".
  • bridge() is JVM-framework-specific. Import com.trendyol.stove.spring.bridge, com.trendyol.stove.ktor.bridge, com.trendyol.stove.micronaut.bridge, or com.trendyol.stove.quarkus.bridge based on the selected framework and resolved Stove version.
  • Quarkus Bridge requires an augmented uber-jar first on the test runtime classpath, raw main output excluded, and quarkus.arc.remove-unused-beans=false as a fixed e2e build default. The isolated fast-jar launcher does not support Bridge. See Quarkus Bridge setup.
  • Configure Stove().with { ... }.run() in the framework lifecycle, usually beforeProject() for Kotest, and pair it with Stove.stop() in teardown. Reuse the existing setup rather than starting Stove inside individual tests.
  • System cleanup callbacks run at Stove.stop(), not between tests. Use unique test data or explicit per-test cleanup when tests share state.
  • Keep examples minimal and app-specific. Add only the systems the user actually needs.
  • Choose either stove-kafka or stove-spring-kafka; they have overlapping classes and different options. Verify which integration the project uses before copying Kafka examples.
  • To prove the AUT consumed a Kafka message, use shouldBeConsumed<T>(atLeastIn = ...) with the expected topic and a unique message identifier. Do not replace it with a second consumer, offset/lag polling, message-store polling, or a custom latch/listener. Diagnose missing interceptor/bridge observations before changing the assertion; see Kafka assertions for setup, failure semantics, and uninstrumented-app limits.
  • Wire Kafka observation as part of the setup: JVM apps need the selected integration's interceptors; Go apps use Stove's provided go/stove-kafka bridge; other process apps can implement the existing observer protocol. Register the framework-specific JVM bridge() when tests need DI access, but do not confuse it with Kafka observation or add it to process/container runners. Follow the observation wiring matrix.
  • Every custom Gradle Test task needs test classes, runtime classpath, and the test engine configured; see gradle-config.md.
  • Container AUTs need addresses reachable from inside the container. Host-mapped database, broker, and tracing endpoints are not automatically valid there; see container.md.
  • Ktor runners must not block: the app's run must start the engine with wait = false (a blocking main hangs the suite).
  • Mock verifications (wiremock/grpcMock shouldHaveBeenCalled) are point-in-time — do not invent a within/timeout parameter. Await async flows with the Kafka atLeastIn or HTTP assertion first, then verify the mock.
  • WireMock (0.26+): prefer the structured request / respond / behaviour DSL for new examples. String verb functions match URL paths; use reusable RequestSpecs across stubbing, verification, and callsFor, and use rawStub before unmanaged server() access. No compiler opt-in is required; Stove APIs may evolve in minor releases and release notes provide migration guidance.
  • gRPC Mock (0.26+): among matching stubs the last registered wins; mixing RPC types for one method fails fast; bidi stubs reject requestMatcher. Prefer MethodDescriptor overloads and RequestMatcher.message<T> { ... } over name strings and byte matchers.

MCP servers 1

Sponsors

Details

Marketplace
Trendyol/stove
Source
.agents
Category
Community