Proto commits in Trendyol/stove

These 28 commits are when the Protocol Buffers files have changed:

2026-07-16

feat: mock journal foundation re-work. grpc/wiremock (#1271) * fix(mocks): test-scoped fail-open call journals for wiremock and grpc-mock grpc-mock validate() scanned a process-global request log, so one test's unmatched request failed every other test. It now records into a test-scoped GrpcCallJournal: stubs are tagged with the registering test id, requests are attributed metadata-first (x-stove-test-id/baggage) with the matched stub's tag as fallback, validate()/snapshot() are scoped, and completed tests' entries are cleared via a report listener. wiremock's journal dropped untagged serve events and validate() only counted requests tagged with the current test, so apps without test-id propagation got false verification counts and false validation passes. Untagged entries now land in shared buckets visible to every test (fail-open: only provably-foreign evidence is excluded), attribution is request-header/baggage-first, and validate() reads the journal instead of the raw server log. Stubs registered outside a test context stay untagged instead of being tagged "default", via the new StoveReporter.currentTestIdOrNull(). Adds lib/MOCKS_ROADMAP.md tracking the mock-systems capability roadmap. * refactor(scoping): shared fail-open TestScopedJournal foundation in core Extracts the mock journals' common machinery into com.trendyol.stove.scoping: a generic TestScopedJournal<T> (tagged/untagged buckets, fail-open reads), a TestScopeCleanupListener (drains completed tests on next test start, clears stale retried test ids, never clears untagged entries), and the test-id header/baggage extraction relocated from messaging.kafka — which keeps thin forwarding functions so existing imports and the Kafka foundation stay intact. wiremock's journal shrinks to attribution logic over two shared journals; grpc-mock's journal class is deleted and the system composes the shared one directly. Journal-semantics unit tests move to core. Deliberately excludes the Kafka wait engine: mock verification stays point-in-time per the roadmap decision. * fix(grpc-mock): defined stub precedence, method-type fail-fast, owned bidi lifecycle Stub matching is now last-registered-wins, so test-local stubs override earlier fixture defaults (matching WireMock's semantics); with removeStubAfterRequestMatched the earlier stub serves again once the winner is consumed. Registering stubs of different gRPC method types for one method previously let registration order silently pick the handler type — it now fails fast at registration. Bidi handlers launch into a system-owned supervisor scope cancelled at close instead of leaking two orphan CoroutineScope(Dispatchers.IO) per call, and the channel-forwarding observer drops its dead full-buffer fallback (the channel is UNLIMITED). Bidi stubs reject request matchers explicitly instead of silently ignoring them. * feat(mocks): near-miss diagnostics on validation and verification failures wiremock validate() failures now diff each unmatched request against the test-scoped closest stubs (ranked by WireMock match distance, top three, rendered with WireMock's Diff); a zero-distance candidate is explained as already consumed or registered later instead of showing an empty diff. Zero-match verifications diff the expected pattern against the requests the test actually received. grpc-mock captures per-candidate rejection reasons at request time — so diagnostics survive stub removal — naming which matcher rejected and, for ExactMessage, rendering expected-versus-received payloads by parsing the request bytes with the expected message's own parser. validate() failures list the reasons under each unmatched method. Matcher evaluation moved from GrpcMockSystem to internal extensions next to the matcher types. * feat(grpc-mock): typed verification, descriptor-typed stubbing, reified matchers Adds the module's missing verification surface: point-in-time, test-scoped shouldHaveBeenCalled<T>/shouldNotHaveBeenCalled<T> that parse journaled request bytes as the expected proto type and evaluate a caller condition — exact-count semantics, no time parameter (mock assertions run after the anchor assertion has already absorbed any async wait). Failures report matching-versus-received counts plus the parsed payloads the test sent. Stubbing and verification also accept generated MethodDescriptors, killing string-typo UNIMPLEMENTED debugging, and RequestMatcher.message<T> { ... } gives typed request matching without manual parseFrom. Error stubs are now type-agnostic: they no longer conflict with streaming stubs for the same method, and handler-type lookup skips them. * feat(wiremock): faults, response latency, retry-journey DSL, dynamic responses Resilience testing becomes one-liners over WireMock's native support: mockFault(method, url, fault) injects connection-level failures, and every mock*/mock*Containing accepts delay: Duration? for deadline/timeout tests. behaviourFor gains a retry journey: failsTimes(2, withStatus = 503) followed by thenSucceeds { ... } models "dependency recovers after N attempts" without hand-rolling scenario states. mockDynamic(method, url) { request, serde -> ... } computes responses from the received request at serve time through a Stove response transformer, correlated to stubs via metadata so WireMock's stub-id assignment cannot break the mapping. * feat(grpc-mock): per-stub delay, stream-then-error, error trailers, health/reflection Deadline testing becomes possible: unary/stream/client-stream/error stubs accept delay: Duration?, dispatched through the system-owned handler scope, so a client deadline against a slow stub yields DEADLINE_EXCEEDED. Server streams accept thenFailWith: Status? to emit all items and then fail instead of completing — the classic mid-stream failure. Error stubs accept trailers: Metadata?, the carrier real gRPC APIs use for structured error details. GrpcMockSystemOptions gains opt-in enableHealthService (grpc.health.v1, for applications that gate startup on a healthy channel) and enableReflectionService (grpcurl inspection), served via io.grpc:grpc-services. * docs(mocks): mark completed roadmap items and record verification status Library-side themes D, A, B, and C1 are implemented; remaining items are dashboard-side (C2/C3, cross-test match warnings) and Theme E later bets. * fix(grpc-mock): journal calls to methods with no stubs instead of dropping them A request to a method with no registered stubs short-circuited inside gRPC — DynamicHandlerRegistry.lookupMethod returned null, so the server answered UNIMPLEMENTED before any Stove code ran. A typo'd method name was therefore invisible to the journal, validate(), snapshots, and near-miss diagnostics. The registry now serves a synthetic BIDI recorder handler for unknown methods: it journals the request (method name plus metadata, so fail-open test attribution still applies) with a "no stubs registered for this method" near-miss, then answers UNIMPLEMENTED immediately — client-visible behavior is unchanged, and request payloads are not consumed. BIDI accepts any client message pattern, so the handler is safe regardless of the method's real type. This makes mock capture complete: every request that reaches either mock is journaled, which the planned exchange-inspector dashboard view assumes. * feat(interactions): mock exchange events with proven-only attribution Every request that reaches a mock now becomes a MockInteraction — matched or not — feeding the dashboard's network-tab/swimlane view and any other diagnostics consumer. Attribution is proven-only: the X-Stove-Test-Id header, W3C baggage, or the matched stub's registration tag (the fixture carries the identity, so matched traffic needs no propagation); everything else is explicitly UNATTRIBUTED, never inferred from timing or heuristics. Core gains com.trendyol.stove.interactions (MockInteraction, listener/ publisher contracts mirroring SpanListenerRegistry, attribution resolver, body truncation, traceparent trace-id extraction) and the scoping package now reports which transport carried the test id. wiremock emits at ServeEventListener.afterComplete, where timing is final: status or fault name, latency, truncated bodies, near-miss candidates for unmatched exchanges, trace id. grpc-mock emits from a call-observing interceptor that wraps every call: final status and latency including CANCELLED/DEADLINE_EXCEEDED outcomes the handler never sees, payload message/byte counts, match info filled by the stub path through a Context key. Built-in grpc.* services are skipped. Bidi calls are now journaled like every other type — matched and unmatched — closing the last capture gap, and bidi error stubs go through the delay/trailer-aware dispatch. DashboardSystem subscribes to all publishers and forwards interactions as the new MockInteractionEvent proto oneof arm (additive, wire-compatible; older CLIs ignore it). * feat(interactions): mock warnings pipeline and failure-time snapshots Closes M6 and the ambiguous-signals lane: both mocks implement MockWarningPublisher and raise diagnostics that never fail tests, all from provable evidence only (TestScopedJournal.taggedEntries — shared fixtures and non-propagating traffic can never accuse an unrelated test): - CROSS_TEST_MATCH at serve time, when request and stub carry provably different test ids; - UNUSED_STUB at test end, for stubs the test registered that nothing matched — dead fixtures, or tests passing without the interaction they think they prove; - UNVALIDATED_UNMATCHED at test end, when a test's own unmatched requests exist and validate() was never called. DashboardSystem forwards them as the new MockWarningEvent oneof arm and now also emits a FAILURE-triggered snapshot of the failing system at the moment the first failing entry is recorded — state at failure genuinely differs from state at test end. SnapshotEvent gains timestamp and trigger. grpc-mock snapshots now expose the stored near-miss reasons on unmatched requests instead of dropping them. * feat(stove-cli): ingest mock diagnostics * feat(mocks): complete journal diagnostics experience * feat(spa): refine evidence UX and restore live updates * refactor(spa): quiet evidence debugging UX * fix(mocks): harden diagnostics and live journal * fix(grpc-mock): redact decode error details

feat(mocks): complete journal diagnostics experience

feat(interactions): mock warnings pipeline and failure-time snapshots Closes M6 and the ambiguous-signals lane: both mocks implement MockWarningPublisher and raise diagnostics that never fail tests, all from provable evidence only (TestScopedJournal.taggedEntries — shared fixtures and non-propagating traffic can never accuse an unrelated test): - CROSS_TEST_MATCH at serve time, when request and stub carry provably different test ids; - UNUSED_STUB at test end, for stubs the test registered that nothing matched — dead fixtures, or tests passing without the interaction they think they prove; - UNVALIDATED_UNMATCHED at test end, when a test's own unmatched requests exist and validate() was never called. DashboardSystem forwards them as the new MockWarningEvent oneof arm and now also emits a FAILURE-triggered snapshot of the failing system at the moment the first failing entry is recorded — state at failure genuinely differs from state at test end. SnapshotEvent gains timestamp and trigger. grpc-mock snapshots now expose the stored near-miss reasons on unmatched requests instead of dropping them.

feat(interactions): mock exchange events with proven-only attribution Every request that reaches a mock now becomes a MockInteraction — matched or not — feeding the dashboard's network-tab/swimlane view and any other diagnostics consumer. Attribution is proven-only: the X-Stove-Test-Id header, W3C baggage, or the matched stub's registration tag (the fixture carries the identity, so matched traffic needs no propagation); everything else is explicitly UNATTRIBUTED, never inferred from timing or heuristics. Core gains com.trendyol.stove.interactions (MockInteraction, listener/ publisher contracts mirroring SpanListenerRegistry, attribution resolver, body truncation, traceparent trace-id extraction) and the scoping package now reports which transport carried the test id. wiremock emits at ServeEventListener.afterComplete, where timing is final: status or fault name, latency, truncated bodies, near-miss candidates for unmatched exchanges, trace id. grpc-mock emits from a call-observing interceptor that wraps every call: final status and latency including CANCELLED/DEADLINE_EXCEEDED outcomes the handler never sees, payload message/byte counts, match info filled by the stub path through a Context key. Built-in grpc.* services are skipped. Bidi calls are now journaled like every other type — matched and unmatched — closing the last capture gap, and bidi error stubs go through the delay/trailer-aware dispatch. DashboardSystem subscribes to all publishers and forwards interactions as the new MockInteractionEvent proto oneof arm (additive, wire-compatible; older CLIs ignore it).

2026-05-19

wip

2026-05-18

WIP: log capture fature implementation

2026-04-15

chore: reorganize recipes structure and update configuration files

2026-04-13

feat(cli, core): add support for kotest & junit testing styles on UI and cli (#1128) * adjust skills with latest changes

2026-04-07

feat: Stove version alignment across CLI, BOM (#1114) * feat: emphasize Stove version alignment across CLI, BOM, and test dependencies - Added guidance on version alignment to multiple documentation files, including `getting-started.md` and `18-dashboard.md`. - Clarified how mismatched versions can affect dashboard data. - Introduced a `VersionMismatchBanner` component in the CLI UI to highlight version mismatches. * fix: build dependency

2026-03-31

refactor: BREAKING! rename portal to dashobard (#1104)

2026-03-27

portal cli & spa & lib (#1086)

2026-02-02

chore(recipes): folder revisit

recipes: add showcase & improve console renderer

2026-01-12

feat: add mock support for gRPC #938 (#974)

2026-01-07

update docs bump project version stove-bom use typed accessors seperate extensions adjust kotest.properties TestSytem -> Stove recipes: revert recipes for now revamp the project names and package names

2025-12-09

refactor: compatibility tests for spring

feat: spring-boot-4x support, includes spring-kafka 4x (#934) * feat: spring-boot-4x support, includes spring-kafka 4x * change wiremock url * create common packages * use compileOnly to leverage package binding in downstreams compile time * add spring-boot deps runtime check

2025-12-02

feat(#674): add grpc support, wire and kotlin (#921) * feat(#674): add grpc support, wire and kotlin

2024-12-03

refactor(standalone-kafka): use StoveSerde<Any,ByteArry> interface to bridge the messages and let users select their ser/de #560 (#664)

The documentation is generated from this commit.

2024-11-29

spring-kafka: ser/de (#658) * Improvements for spring-kafka to work with StoveSerde interface * add protobuf tests for spring-kafka to make sure that ser/de abstraction works when needed

2024-11-15

Added configuration option for value serializer (#627) * Added configurable value serializer * removed unused import * test implementation kafka streams with protobuf * Added test for deserializer * broke after clean build. fix will come later * Fixed dependencies to user existing libs reintroduced deserialization test example Cleanup * Move dependencies to libs WIP TODO kafka streams (latest version breaks code) rewrite test to kotest * improved comment * tests to kotest * CustomSerde typo fix * removed unused parameter * move kafka streams to libs version * removed runblocking * review: apply more functional assertion and propose removing thread.sleeps * review: solve detekt problem * Removed commented out thread.sleep --------- Co-authored-by: dklein <dklein@afsgroup.nl> Co-authored-by: Oguzhan Soykan <oguzhansoykan@gmail.com>

2024-07-05

standalone-kafka: simplify isCommitted logic

2024-06-17

standalone-kafka: also record acknowledged messages

2024-05-01

implement healthcheck for kafka sink

2024-04-30

Handle offsets properly

2024-04-29

shouldBeFailed and shouldBeRetried improved

Enrich Ktor example with stanalone kafka and and proper configuration handling (#409)

2024-04-26

feature: Standalone kafka now hosts a grpc endpoint to communicate and understand the messages