@durable-streams/client-conformance-tests 0.1.5 → 0.1.7

package/test-cases/consumer/fault-injection.yaml

@@ -0,0 +1,202 @@
+id: consumer-fault-injection
+name: Advanced Fault Injection
+description: Tests for client resilience against various network and server faults
+category: consumer
+tags:
+  - fault-injection
+  - resilience
+  - chaos
+  - advanced
+
+tests:
+  - id: delay-recovery
+    name: Client handles delayed responses
+    description: Client should successfully read data even with server delays
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "delayed-data"
+    operations:
+      # Inject a 500ms delay
+      - action: inject-error
+        path: ${streamPath}
+        delayMs: 500
+        count: 1
+      # Client should wait and succeed
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "delayed-data"
+    cleanup:
+      - action: clear-errors
+
+  - id: delay-with-jitter
+    name: Client handles delayed responses with jitter
+    description: Client should handle variable delays (delay + random jitter)
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "jittery-data"
+    operations:
+      # Inject delay with jitter (300-600ms total)
+      - action: inject-error
+        path: ${streamPath}
+        delayMs: 300
+        jitterMs: 300
+        count: 1
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "jittery-data"
+    cleanup:
+      - action: clear-errors
+
+  - id: connection-drop-recovery
+    name: Client recovers from dropped connection
+    description: Client should retry when connection is dropped mid-request
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "persistent-data"
+    operations:
+      # Drop connection once
+      - action: inject-error
+        path: ${streamPath}
+        dropConnection: true
+        count: 1
+      # Client should retry and eventually succeed
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "persistent-data"
+    cleanup:
+      - action: clear-errors
+
+  - id: multiple-connection-drops
+    name: Client recovers from multiple dropped connections
+    description: Client should retry through multiple connection failures
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "resilient-data"
+    operations:
+      # Drop connection twice
+      - action: inject-error
+        path: ${streamPath}
+        dropConnection: true
+        count: 2
+      # Client should retry multiple times and succeed
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "resilient-data"
+    cleanup:
+      - action: clear-errors
+
+  - id: method-specific-fault
+    name: Fault only affects specific HTTP method
+    description: Fault should only trigger for specified method
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      # Inject fault only for POST (append)
+      - action: inject-error
+        path: ${streamPath}
+        status: 503
+        method: POST
+        count: 1
+      # GET should work fine (no fault)
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: ""
+      # POST (append) should fail first then succeed on retry
+      - action: append
+        path: ${streamPath}
+        data: "method-filtered"
+      # Verify data was appended
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "method-filtered"
+    cleanup:
+      - action: clear-errors
+
+  - id: delay-then-error
+    name: Delay followed by error
+    description: Combined delay and error response
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "combined-fault-data"
+    operations:
+      # Delay 200ms then return 503
+      - action: inject-error
+        path: ${streamPath}
+        delayMs: 200
+        status: 503
+        count: 1
+      # Client should wait, get error, retry, and succeed
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "combined-fault-data"
+    cleanup:
+      - action: clear-errors
+
+  - id: append-with-delay
+    name: Append succeeds with server delay
+    description: Append should complete successfully even with server-side delay
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      # Add 500ms delay on first append
+      - action: inject-error
+        path: ${streamPath}
+        delayMs: 500
+        count: 1
+      # Append should wait and succeed
+      - action: append
+        path: ${streamPath}
+        data: "delayed-append"
+      # Verify data was appended
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "delayed-append"
+    cleanup:
+      - action: clear-errors
+
+  - id: delay-under-timeout
+    name: Client succeeds with delay under timeout
+    description: Client should succeed when delay is less than client timeout
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "within-timeout"
+    operations:
+      # 1 second delay (should be under most client timeouts)
+      - action: inject-error
+        path: ${streamPath}
+        delayMs: 1000
+        count: 1
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "within-timeout"
+    cleanup:
+      - action: clear-errors

package/test-cases/consumer/offset-handling.yaml

@@ -30,6 +30,215 @@ tests:
         expect:
           data: "beginningmiddleend"
 
+  - id: offset-now-skips-historical
+    name: Offset 'now' skips historical data
+    description: Using offset=now should return empty body with tail offset
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "historical"
+      - action: append
+        path: ${streamPath}
+        data: "data"
+    operations:
+      - action: read
+        path: ${streamPath}
+        offset: "now"
+        expect:
+          chunkCount: 0
+          upToDate: true
+          storeOffsetAs: nowOffset
+      # Verify we can resume from the offset
+      - action: append
+        path: ${streamPath}
+        data: "future"
+      - action: read
+        path: ${streamPath}
+        offset: ${nowOffset}
+        expect:
+          data: "future"
+
+  - id: offset-now-empty-stream
+    name: Offset 'now' on empty stream
+    description: Using offset=now on an empty stream should work correctly
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      - action: read
+        path: ${streamPath}
+        offset: "now"
+        expect:
+          chunkCount: 0
+          upToDate: true
+          storeOffsetAs: startOffset
+      # Verify the offset works for future data
+      - action: append
+        path: ${streamPath}
+        data: "firstdata"
+      - action: read
+        path: ${streamPath}
+        offset: ${startOffset}
+        expect:
+          data: "firstdata"
+
+  - id: offset-now-empty-stream-longpoll
+    name: Offset 'now' on empty stream with long-poll
+    description: Using offset=now with long-poll on an empty stream should wait for data
+    requires:
+      - longPoll
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      # Long-poll with offset=now on empty stream should timeout
+      - action: read
+        path: ${streamPath}
+        offset: "now"
+        live: long-poll
+        timeoutMs: 1000
+        expect:
+          status: 204
+          upToDate: true
+          storeOffsetAs: pollOffset
+      # Verify the offset is valid and works for future data
+      - action: append
+        path: ${streamPath}
+        data: "firstdata"
+      - action: read
+        path: ${streamPath}
+        offset: ${pollOffset}
+        expect:
+          data: "firstdata"
+
+  - id: offset-now-empty-stream-sse
+    name: Offset 'now' on empty stream with SSE
+    description: Using offset=now with SSE on an empty stream should provide valid offset
+    requires:
+      - sse
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      # SSE with offset=now on empty stream
+      - action: read
+        path: ${streamPath}
+        offset: "now"
+        live: sse
+        waitForUpToDate: true
+        expect:
+          chunkCount: 0
+          upToDate: true
+          storeOffsetAs: sseOffset
+      # Verify the offset is valid and works for future data
+      - action: append
+        path: ${streamPath}
+        data: "firstdata"
+      - action: read
+        path: ${streamPath}
+        offset: ${sseOffset}
+        expect:
+          data: "firstdata"
+
+  - id: offset-now-matches-tail
+    name: Offset 'now' returns same offset as tail
+    description: The offset from offset=now should match the stream tail offset
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "somedata"
+    operations:
+      # Get tail offset via normal read
+      - action: read
+        path: ${streamPath}
+        expect:
+          storeOffsetAs: tailOffset
+      # Get offset via offset=now
+      - action: read
+        path: ${streamPath}
+        offset: "now"
+        expect:
+          storeOffsetAs: nowOffset
+      # Append and verify both offsets work identically
+      - action: append
+        path: ${streamPath}
+        data: "newdata"
+      - action: read
+        path: ${streamPath}
+        offset: ${tailOffset}
+        expect:
+          data: "newdata"
+      - action: read
+        path: ${streamPath}
+        offset: ${nowOffset}
+        expect:
+          data: "newdata"
+
+  - id: offset-now-longpoll-waits
+    name: Offset 'now' with long-poll immediately waits for data
+    description: Using offset=now with long-poll should immediately start waiting for new data (no round trip)
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "existingdata"
+    operations:
+      # Long-poll with offset=now should timeout with 204 since no new data arrives
+      # This proves it immediately started waiting (skipping historical data)
+      - action: read
+        path: ${streamPath}
+        offset: "now"
+        live: long-poll
+        timeoutMs: 1000
+        expect:
+          status: 204
+          upToDate: true
+          storeOffsetAs: pollOffset
+      # Verify the offset works for future data
+      - action: append
+        path: ${streamPath}
+        data: "afterpoll"
+      - action: read
+        path: ${streamPath}
+        offset: ${pollOffset}
+        expect:
+          data: "afterpoll"
+
+  - id: offset-now-sse
+    name: Offset 'now' with SSE mode
+    description: Using offset=now with SSE should skip historical data and provide correct offset
+    requires:
+      - sse
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "historicalsse"
+    operations:
+      - action: read
+        path: ${streamPath}
+        offset: "now"
+        live: sse
+        waitForUpToDate: true
+        expect:
+          chunkCount: 0
+          storeOffsetAs: sseOffset
+      # Verify offset works
+      - action: append
+        path: ${streamPath}
+        data: "futuredata"
+      - action: read
+        path: ${streamPath}
+        offset: ${sseOffset}
+        expect:
+          data: "futuredata"
+
   - id: offset-empty-stream
     name: Read from empty stream
     description: Reading from an empty stream should return no data and up-to-date

package/test-cases/producer/idempotent/autoclaim.yaml

@@ -0,0 +1,214 @@
+id: idempotent-autoclaim
+name: Idempotent Producer - AutoClaim
+description: |
+  Tests for the autoClaim feature that enables ephemeral producers.
+  When autoClaim=true, the client automatically claims the next epoch
+  when fenced (403) and blocks pipelining until epoch is known.
+category: producer
+tags:
+  - idempotent
+  - autoclaim
+  - ephemeral
+
+tests:
+  - id: autoclaim-with-pipelining
+    name: autoClaim works with maxInFlight > 1
+    description: |
+      When autoClaim is true, the client should block pipelining until the first batch
+      completes and the epoch is known. After that, full pipelining should be enabled.
+      This test verifies that autoClaim + maxInFlight > 1 works correctly.
+    setup:
+      - action: create
+        as: streamPath
+        contentType: text/plain
+    operations:
+      # Send 20 messages with autoClaim=true and maxInFlight=5
+      # The first batch should block until epoch is claimed, then pipelining kicks in
+      - action: idempotent-append-batch
+        path: ${streamPath}
+        producerId: autoclaim-producer
+        autoClaim: true
+        maxInFlight: 5
+        items:
+          - data: "ac-00"
+          - data: "ac-01"
+          - data: "ac-02"
+          - data: "ac-03"
+          - data: "ac-04"
+          - data: "ac-05"
+          - data: "ac-06"
+          - data: "ac-07"
+          - data: "ac-08"
+          - data: "ac-09"
+          - data: "ac-10"
+          - data: "ac-11"
+          - data: "ac-12"
+          - data: "ac-13"
+          - data: "ac-14"
+          - data: "ac-15"
+          - data: "ac-16"
+          - data: "ac-17"
+          - data: "ac-18"
+          - data: "ac-19"
+        expect:
+          allSucceed: true
+      # Verify all messages are in the stream
+      - action: read
+        path: ${streamPath}
+        expect:
+          dataContainsAll:
+            - "ac-00"
+            - "ac-05"
+            - "ac-10"
+            - "ac-15"
+            - "ac-19"
+          upToDate: true
+
+  - id: autoclaim-with-pipelining-json
+    name: autoClaim with pipelining works for JSON streams
+    description: Same test with JSON content type
+    setup:
+      - action: create
+        as: streamPath
+        contentType: application/json
+    operations:
+      - action: idempotent-append-batch
+        path: ${streamPath}
+        producerId: autoclaim-json-producer
+        autoClaim: true
+        maxInFlight: 5
+        items:
+          - data: '{"msg": 0}'
+          - data: '{"msg": 1}'
+          - data: '{"msg": 2}'
+          - data: '{"msg": 3}'
+          - data: '{"msg": 4}'
+          - data: '{"msg": 5}'
+          - data: '{"msg": 6}'
+          - data: '{"msg": 7}'
+          - data: '{"msg": 8}'
+          - data: '{"msg": 9}'
+        expect:
+          allSucceed: true
+      - action: read
+        path: ${streamPath}
+        expect:
+          dataContainsAll:
+            - '"msg":0'
+            - '"msg":5'
+            - '"msg":9'
+          upToDate: true
+
+  - id: autoclaim-recovers-from-stale-epoch
+    name: autoClaim recovers when fenced by newer epoch
+    description: |
+      If a producer with autoClaim gets 403 (stale epoch) because another instance
+      claimed a higher epoch, it should automatically bump its epoch and retry.
+    setup:
+      - action: create
+        as: streamPath
+        contentType: text/plain
+    operations:
+      # Establish epoch=5 via raw server-append (simulating another producer instance)
+      - action: server-append
+        path: ${streamPath}
+        data: "from-epoch-5"
+        producerId: recovery-producer
+        producerEpoch: 5
+        producerSeq: 0
+        expect:
+          status: 200
+      # Client with autoClaim starts at epoch=0, should get 403 then recover with epoch=6
+      - action: idempotent-append
+        path: ${streamPath}
+        producerId: recovery-producer
+        epoch: 0
+        autoClaim: true
+        data: "recovered"
+        expect:
+          success: true
+      # Verify both messages are in the stream
+      - action: read
+        path: ${streamPath}
+        expect:
+          dataContainsAll:
+            - "from-epoch-5"
+            - "recovered"
+          upToDate: true
+
+  - id: autoclaim-recovers-from-403
+    name: Client with autoClaim recovers from 403 fencing
+    description: |
+      When a producer with autoClaim=true gets fenced (403), it should
+      automatically claim the next epoch and retry successfully.
+    setup:
+      - action: create
+        as: streamPath
+        contentType: text/plain
+    operations:
+      # Another producer claims epoch=5
+      - action: server-append
+        path: ${streamPath}
+        data: "fencer"
+        producerId: autoclaim-producer
+        producerEpoch: 5
+        producerSeq: 0
+        expect:
+          status: 200
+      # Now use idempotent-append with autoClaim starting at epoch=0
+      # It should get 403, then retry with epoch=6
+      - action: idempotent-append
+        path: ${streamPath}
+        producerId: autoclaim-producer
+        epoch: 0
+        autoClaim: true
+        data: "recovered"
+        expect:
+          success: true
+      # Verify both messages are in stream
+      - action: read
+        path: ${streamPath}
+        expect:
+          dataContainsAll:
+            - "fencer"
+            - "recovered"
+          upToDate: true
+
+  - id: autoclaim-batch-recovers-from-403
+    name: Batch with autoClaim recovers from 403 fencing
+    description: Same test for batch operations
+    setup:
+      - action: create
+        as: streamPath
+        contentType: text/plain
+    operations:
+      # Another producer claims epoch=3
+      - action: server-append
+        path: ${streamPath}
+        data: "blocker"
+        producerId: batch-autoclaim
+        producerEpoch: 3
+        producerSeq: 0
+        expect:
+          status: 200
+      # Batch with autoClaim should recover
+      - action: idempotent-append-batch
+        path: ${streamPath}
+        producerId: batch-autoclaim
+        autoClaim: true
+        maxInFlight: 1
+        items:
+          - data: "batch-msg-0"
+          - data: "batch-msg-1"
+          - data: "batch-msg-2"
+        expect:
+          allSucceed: true
+      - action: read
+        path: ${streamPath}
+        expect:
+          dataContainsAll:
+            - "blocker"
+            - "batch-msg-0"
+            - "batch-msg-1"
+            - "batch-msg-2"
+          upToDate: true