Skip to content

0.21.0

Released: February 2026

This release introduces:

  • Tracing: See the full execution trace of your application when a test fails: every controller, database query, Kafka message, and HTTP call with timing and failure points
  • gRPC Mocking: Mock external gRPC services in your tests with a type-safe DSL
  • MySQL Support: New stove-mysql module for testing against MySQL databases
  • WireMock Test Scoping: WireMock snapshots are now scoped to the current test for cleaner failure reports
  • Dynamic Port Allocation: WireMock now defaults to port = 0 and gRPC Mock supports it, no more port conflicts in CI
  • Migration Type Aliases: PostgresqlMigration, MongodbMigration, etc. instead of verbose DatabaseMigration<XyzContext>
  • Elasticsearch 9 Support: Adapted to work with Elasticsearch 9.x
  • Spring Showcase Recipe: A comprehensive example project demonstrating all Stove features together

New Features

Tracing

When a test fails, you no longer have to guess what happened inside your application. Stove captures the entire call chain: every controller method, database query, Kafka message, and HTTP call, and displays it as a trace tree in the failure report:

═══════════════════════════════════════════════════════════════════════════════
EXECUTION TRACE (Call Chain)
═══════════════════════════════════════════════════════════════════════════════
✓ POST (377ms)
  ✓ POST /api/product/create (361ms)
    ✓ ProductController.create (141ms)
      ✓ ProductCreator.create (0ms)
      ✓ KafkaProducer.send (137ms)
        ✓ orders.created publish (81ms)
          ✗ orders.created process (82ms)  ← FAILURE POINT

Setup takes two steps:

  1. Enable in your Stove config:
Stove()
    .with {
        tracing {
            enableSpanReceiver()
        }
    }
  1. Attach the OpenTelemetry agent in your build. Copy StoveTracingConfiguration.kt to your project's buildSrc/src/main/kotlin/ directory, then add to your build.gradle.kts:
import com.trendyol.stove.gradle.stoveTracing

stoveTracing {
    serviceName = "my-service"
}

Gradle Plugin available since 0.21.2

Starting with 0.21.2, a standalone Gradle plugin is available that eliminates the need to copy this file. See the 0.21.2 release notes for details.

Everything else is automatic. Trace headers are injected into HTTP, Kafka, and gRPC calls, spans are collected and correlated, and failure reports are enriched with the trace tree.

A validation DSL is also available for asserting on the execution flow:

tracing {
    shouldContainSpan("OrderService.processOrder")
    shouldNotHaveFailedSpans()
    executionTimeShouldBeLessThan(500.milliseconds)
}

See the Tracing documentation for full details.

gRPC Mocking

New stove-grpc-mock module for mocking external gRPC services in your tests. This lets you test gRPC client code without running the actual upstream services.

dependencies {
    testImplementation("com.trendyol:stove-grpc-mock:$stoveVersion")
}

Configure in your Stove setup:

grpcMock {
    GrpcMockSystemOptions(port = 0) // Dynamic port allocation
}

Stub responses with a type-safe DSL:

grpcMock {
    mockUnary(
        FraudDetectionServiceGrpc.getCheckFraudMethod(),
        response = FraudCheckResponse.newBuilder()
            .setIsFraud(false)
            .setScore(0.1)
            .build()
    )
}

Supports unary, server streaming, and conditional matching. See the gRPC Mocking documentation for full details.

MySQL Support

New stove-mysql module with the same familiar DSL as PostgreSQL and MSSQL:

dependencies {
    testImplementation("com.trendyol:stove-mysql:$stoveVersion")
}

Stove()
    .with {
        mysql {
            MysqlOptions(
                databaseName = "mydb",
                configureExposedConfiguration = { cfg ->
                    listOf(
                        "spring.datasource.url=${cfg.jdbcUrl}",
                        "spring.datasource.username=${cfg.username}",
                        "spring.datasource.password=${cfg.password}"
                    )
                }
            )
        }
    }

Supports migrations, shouldQuery, shouldExecute, and all the database operations you'd expect. See the MySQL documentation for details.

WireMock Test Scoping

WireMock snapshots in failure reports are now scoped to the current test. Previously, all registered stubs and requests across the entire test suite would appear in the snapshot. Now you only see stubs and requests relevant to the test that failed, making failure reports much easier to read.

Dynamic Port Allocation

Both WireMock and gRPC Mock now support dynamic port allocation with port = 0, which prevents port conflicts when running tests in parallel on CI.

WireMock now defaults to port = 0. You no longer need to pick a port:

wiremock {
    WireMockSystemOptions(
        configureExposedConfiguration = { cfg ->
            listOf("external-apis.inventory.url=${cfg.baseUrl}")
        }
    )
}

gRPC Mock also supports port = 0:

grpcMock {
    GrpcMockSystemOptions(port = 0)
}

In both cases, the actual port is exposed via configureExposedConfiguration so your application receives the correct URL.

Spring Showcase Recipe

A new comprehensive recipe at recipes/kotlin-recipes/spring-showcase/ demonstrates all Stove features working together in a realistic Spring Boot application:

  • HTTP endpoints with PostgreSQL
  • Kafka producers and consumers
  • gRPC server and client with mocked upstream
  • WireMock for external HTTP APIs
  • Tracing
  • Database migrations
  • db-scheduler integration

This is the best starting point for understanding how Stove fits into a real project.

Migration Type Aliases

Each module that supports migrations now provides a convenient type alias, so you no longer need to remember DatabaseMigration<PostgresSqlMigrationContext> and similar verbose signatures:

// Before
class CreateUsersTable : DatabaseMigration<PostgresSqlMigrationContext> { ... }

// After
class CreateUsersTable : PostgresqlMigration { ... }

Available aliases:

Module Type Alias
stove-postgres PostgresqlMigration
stove-mysql MySqlMigration
stove-mssql MsSqlMigration
stove-mongodb MongodbMigration
stove-couchbase CouchbaseMigration
stove-elasticsearch ElasticsearchMigration
stove-redis RedisMigration
stove-kafka KafkaMigration

The generic DatabaseMigration<T> interface remains fully supported. The aliases are purely additive.

Improvements

Elasticsearch 9 Support

stove-elasticsearch now works with Elasticsearch 9.x (specifically 9.3.0). The module adapts to the updated client API automatically.

Improved Failure Reports

  • Exception details (type, message, stack trace) are now extracted from OpenTelemetry spans and displayed in trace trees
  • Console renderer output is cleaner and better formatted
  • Kafka report entries now include all relevant state

Tracing Configuration Cache Compatibility

The Stove Tracing Gradle plugin and the stoveTracing buildSrc helper are both fully compatible with Gradle configuration cache, so builds with --configuration-cache work correctly.

Non-ASCII Test ID Support

Trace context test IDs now handle non-ASCII characters (e.g., Japanese, Korean) correctly by normalizing to ASCII with hash suffixes for uniqueness. This ensures consistent behavior when test names use non-Latin scripts.

BridgeSystem Suspended

BridgeSystem methods are now suspend functions, allowing proper coroutine support in bridge implementations.

Bug Fixes

  • HTTP streaming: Fixed a flow collection issue that could cause streaming responses to hang
  • Kafka tests: Fixed flaky test behavior in Kafka system tests
  • Tracing configuration cache: Fixed serialization issues when using Gradle configuration cache with the Stove Tracing plugin
  • ASCII character handling: Fixed edge cases in test ID sanitization for non-ASCII characters

Dependency Updates

  • Elasticsearch 9.3.0
  • Kafka (Confluent) 8.1.1
  • Confluent Platform Kafka 8.0.3
  • gRPC Java 1.79.0
  • Protobuf 4.33.5
  • OpenTelemetry 1.59.0
  • Kotlin (latest patch)
  • Ktor 3.4.0
  • Flyway 12.x
  • HikariCP 7.x
  • Various Spring, Quarkus, and Micronaut updates

Migration Guide

From 0.20.x to 0.21.0

This is a non-breaking release. All existing APIs remain compatible.

New Features to Opt Into

Tracing: Add stove-tracing to your dependencies and follow the setup guide.

gRPC Mocking: Add stove-grpc-mock to your dependencies if you need to mock external gRPC services. See the gRPC Mocking documentation.

MySQL: Add stove-mysql if you're testing against MySQL. See the MySQL documentation.

Test Framework Extensions

StoveKotestExtension (stove-extensions-kotest) and StoveJUnitExtension (stove-extensions-junit) are separate packages that must be on your classpath. Kotest requires 6.1.3 or later; JUnit requires Jupiter 6.x if possible.

In Kotest 6.x, AbstractProjectConfig is no longer auto-scanned. Add a kotest.properties file in your test resources (e.g. src/test-e2e/resources/kotest.properties):

kotest.framework.config.fqn=com.myapp.e2e.TestConfig

Set the value to the fully qualified name of your AbstractProjectConfig class. See the Getting Started guide for full details.

  • If using Elasticsearch, verify compatibility with Elasticsearch 9.x
  • If using the Stove Tracing plugin or stoveTracing, no changes needed. Configuration cache compatibility is automatic
  • Consider switching GrpcMockSystemOptions to port = 0 for CI-friendly dynamic port allocation

Getting Started

dependencies {
    testImplementation(platform("com.trendyol:stove-bom:0.21.0"))

    testImplementation("com.trendyol:stove")
    testImplementation("com.trendyol:stove-spring")
    testImplementation("com.trendyol:stove-tracing")
    testImplementation("com.trendyol:stove-extensions-kotest")
    // Add components as needed
}

For snapshot versions:

repositories {
    maven("https://central.sonatype.com/repository/maven-snapshots")
}