@durable-streams/client-conformance-tests 0.1.0

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

@@ -0,0 +1,108 @@
+id: consumer-errors
+name: Consumer Error Handling
+description: Tests for error handling in consumer operations
+category: consumer
+tags:
+  - core
+  - errors
+  - read
+
+tests:
+  - id: read-nonexistent-stream
+    name: Read non-existent stream
+    description: Client should handle 404 when reading non-existent stream
+    operations:
+      - action: read
+        path: /nonexistent-read-stream
+        live: false
+        expect:
+          status: 404
+          errorCode: NOT_FOUND
+
+  - id: read-deleted-stream
+    name: Read deleted stream
+    description: Client should handle 404 when stream was deleted
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "before-delete"
+      - action: delete
+        path: ${streamPath}
+    operations:
+      - action: read
+        path: ${streamPath}
+        live: false
+        expect:
+          status: 404
+          errorCode: NOT_FOUND
+
+  - id: read-invalid-offset
+    name: Read with invalid offset
+    description: Client should handle invalid offset format
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "data"
+    operations:
+      - action: read
+        path: ${streamPath}
+        offset: "not-a-valid-offset-format"
+        live: false
+        expect:
+          status: 400
+          errorCode: INVALID_OFFSET
+
+  - id: read-future-offset
+    name: Read with future offset
+    description: Client should handle offset beyond stream end
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "small"
+    operations:
+      - action: read
+        path: ${streamPath}
+        # Use an offset that's definitely beyond the stream
+        offset: "ffffffffffffffff"
+        live: false
+        expect:
+          # Server should either return empty or 400
+          chunkCount: 0
+
+  - id: longpoll-nonexistent
+    name: Long-poll non-existent stream
+    description: Long-poll should fail on non-existent stream
+    tags:
+      - longpoll
+    requires:
+      - long-poll
+    operations:
+      - action: read
+        path: /nonexistent-longpoll-stream
+        live: long-poll
+        timeoutMs: 1000
+        expect:
+          status: 404
+          errorCode: NOT_FOUND
+
+  - id: sse-nonexistent
+    name: SSE non-existent stream
+    description: SSE should fail on non-existent stream
+    tags:
+      - sse
+    requires:
+      - sse
+    operations:
+      - action: read
+        path: /nonexistent-sse-stream
+        live: sse
+        timeoutMs: 1000
+        expect:
+          status: 404
+          errorCode: NOT_FOUND

package/test-cases/consumer/message-ordering.yaml

@@ -0,0 +1,209 @@
+id: consumer-message-ordering
+name: Message Ordering
+description: Tests that messages are received in strict offset order
+category: consumer
+tags:
+  - core
+  - ordering
+  - live
+
+tests:
+  - id: ordering-sequential-appends
+    name: Sequential appends maintain order
+    description: Messages should be read in the same order they were appended
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      - action: append
+        path: ${streamPath}
+        data: "first"
+      - action: append
+        path: ${streamPath}
+        data: "second"
+      - action: append
+        path: ${streamPath}
+        data: "third"
+      - action: append
+        path: ${streamPath}
+        data: "fourth"
+      - action: append
+        path: ${streamPath}
+        data: "fifth"
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "firstsecondthirdfourthfifth"
+
+  - id: ordering-longpoll-preserves-order
+    name: Long-poll preserves message order
+    description: Messages received via long-poll should be in offset order
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "a"
+      - action: append
+        path: ${streamPath}
+        data: "b"
+      - action: append
+        path: ${streamPath}
+        data: "c"
+    operations:
+      - action: read
+        path: ${streamPath}
+        live: long-poll
+        waitForUpToDate: true
+        expect:
+          data: "abc"
+
+  - id: ordering-sse-preserves-order
+    name: SSE preserves message order
+    description: Messages received via SSE should be in offset order
+    requires:
+      - sse
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "x"
+      - action: append
+        path: ${streamPath}
+        data: "y"
+      - action: append
+        path: ${streamPath}
+        data: "z"
+    operations:
+      - action: read
+        path: ${streamPath}
+        live: sse
+        waitForUpToDate: true
+        expect:
+          data: "xyz"
+
+  - id: ordering-offset-monotonic
+    name: Offsets are monotonically increasing
+    description: Each message's offset should be greater than the previous
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "1"
+        expect:
+          storeOffsetAs: offset1
+      - action: append
+        path: ${streamPath}
+        data: "2"
+        expect:
+          storeOffsetAs: offset2
+      - action: append
+        path: ${streamPath}
+        data: "3"
+        expect:
+          storeOffsetAs: offset3
+    operations:
+      # Read from offset1 should get "23"
+      - action: read
+        path: ${streamPath}
+        offset: ${offset1}
+        expect:
+          data: "23"
+      # Read from offset2 should get "3"
+      - action: read
+        path: ${streamPath}
+        offset: ${offset2}
+        expect:
+          data: "3"
+      # Read from offset3 should get nothing (at end)
+      - action: read
+        path: ${streamPath}
+        offset: ${offset3}
+        expect:
+          chunkCount: 0
+          upToDate: true
+
+  - id: ordering-live-new-data
+    name: Live mode receives new data in order
+    description: New data appended during live read should arrive in order
+    requires:
+      - long-poll
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "init"
+        expect:
+          storeOffsetAs: initialOffset
+    operations:
+      # Start long-poll in background
+      - action: read
+        path: ${streamPath}
+        offset: ${initialOffset}
+        live: long-poll
+        timeoutMs: 5000
+        maxChunks: 3
+        background: true
+        as: liveRead
+      - action: wait
+        ms: 100
+      # Append data in order
+      - action: server-append
+        path: ${streamPath}
+        data: "A"
+      - action: server-append
+        path: ${streamPath}
+        data: "B"
+      - action: server-append
+        path: ${streamPath}
+        data: "C"
+      # Wait for live read to get the data
+      - action: await
+        ref: liveRead
+        expect:
+          dataContains: "ABC"
+
+  - id: ordering-many-messages
+    name: Order preserved with many messages
+    description: Order should be maintained even with many sequential appends
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      - action: append
+        path: ${streamPath}
+        data: "01"
+      - action: append
+        path: ${streamPath}
+        data: "02"
+      - action: append
+        path: ${streamPath}
+        data: "03"
+      - action: append
+        path: ${streamPath}
+        data: "04"
+      - action: append
+        path: ${streamPath}
+        data: "05"
+      - action: append
+        path: ${streamPath}
+        data: "06"
+      - action: append
+        path: ${streamPath}
+        data: "07"
+      - action: append
+        path: ${streamPath}
+        data: "08"
+      - action: append
+        path: ${streamPath}
+        data: "09"
+      - action: append
+        path: ${streamPath}
+        data: "10"
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "01020304050607080910"

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

@@ -0,0 +1,209 @@
+id: consumer-offset-handling
+name: Offset Handling
+description: Tests for offset edge cases and boundary conditions
+category: consumer
+tags:
+  - core
+  - offset
+  - edge-cases
+
+tests:
+  - id: offset-minus-one-start
+    name: Offset -1 reads from start
+    description: Using offset -1 should read from the beginning of the stream
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "beginning"
+      - action: append
+        path: ${streamPath}
+        data: "middle"
+      - action: append
+        path: ${streamPath}
+        data: "end"
+    operations:
+      - action: read
+        path: ${streamPath}
+        offset: "-1"
+        expect:
+          data: "beginningmiddleend"
+
+  - id: offset-empty-stream
+    name: Read from empty stream
+    description: Reading from an empty stream should return no data and up-to-date
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      - action: read
+        path: ${streamPath}
+        expect:
+          chunkCount: 0
+          upToDate: true
+
+  - id: offset-at-end
+    name: Read from end of stream
+    description: Reading from the current end offset should return no new data
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "data"
+        expect:
+          storeOffsetAs: endOffset
+    operations:
+      - action: read
+        path: ${streamPath}
+        offset: ${endOffset}
+        expect:
+          chunkCount: 0
+          upToDate: true
+
+  - id: offset-resume-partial
+    name: Resume read from middle offset
+    description: Reading from a middle offset should only return subsequent data
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "part1"
+        expect:
+          storeOffsetAs: afterPart1
+      - action: append
+        path: ${streamPath}
+        data: "part2"
+        expect:
+          storeOffsetAs: afterPart2
+      - action: append
+        path: ${streamPath}
+        data: "part3"
+    operations:
+      # From afterPart1, should get part2 and part3
+      - action: read
+        path: ${streamPath}
+        offset: ${afterPart1}
+        expect:
+          data: "part2part3"
+      # From afterPart2, should only get part3
+      - action: read
+        path: ${streamPath}
+        offset: ${afterPart2}
+        expect:
+          data: "part3"
+
+  - id: offset-stored-correctly
+    name: Stored offset can be used to resume
+    description: Offsets stored from reads should work for resumption
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "chunk1"
+      - action: append
+        path: ${streamPath}
+        data: "chunk2"
+    operations:
+      # First read stores the offset
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "chunk1chunk2"
+          storeOffsetAs: resumeOffset
+      # Append more data
+      - action: append
+        path: ${streamPath}
+        data: "chunk3"
+      # Resume from stored offset should only get new data
+      - action: read
+        path: ${streamPath}
+        offset: ${resumeOffset}
+        expect:
+          data: "chunk3"
+
+  - id: offset-longpoll-resume
+    name: Long-poll respects offset for resumption
+    description: Long-poll should only return data after the specified offset
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "old"
+        expect:
+          storeOffsetAs: oldOffset
+      - action: append
+        path: ${streamPath}
+        data: "new"
+    operations:
+      - action: read
+        path: ${streamPath}
+        offset: ${oldOffset}
+        live: long-poll
+        timeoutMs: 1000
+        expect:
+          data: "new"
+          upToDate: true
+
+  - id: offset-sse-resume
+    name: SSE respects offset for resumption
+    description: SSE should only return data after the specified offset
+    requires:
+      - sse
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "old"
+        expect:
+          storeOffsetAs: oldOffset
+      - action: append
+        path: ${streamPath}
+        data: "new"
+    operations:
+      - action: read
+        path: ${streamPath}
+        offset: ${oldOffset}
+        live: sse
+        waitForUpToDate: true
+        expect:
+          data: "new"
+
+  - id: offset-multiple-reads-same-offset
+    name: Multiple reads from same offset
+    description: Reading from the same offset multiple times should return the same data
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "consistent"
+        expect:
+          storeOffsetAs: startOffset
+      - action: append
+        path: ${streamPath}
+        data: "data"
+    operations:
+      # First read
+      - action: read
+        path: ${streamPath}
+        offset: ${startOffset}
+        expect:
+          data: "data"
+      # Second read from same offset should get same result
+      - action: read
+        path: ${streamPath}
+        offset: ${startOffset}
+        expect:
+          data: "data"
+      # Third read to confirm
+      - action: read
+        path: ${streamPath}
+        offset: ${startOffset}
+        expect:
+          data: "data"

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

@@ -0,0 +1,197 @@
+id: consumer-offset
+name: Offset Resumption
+description: Tests for offset handling and stream resumption
+category: consumer
+tags:
+  - core
+  - offset
+  - resumption
+
+tests:
+  - id: offset-monotonic
+    name: Offsets are monotonically increasing
+    description: Each read should return an offset greater than the previous
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "AAA"
+        expect:
+          storeOffsetAs: afterA
+      - action: append
+        path: ${streamPath}
+        data: "BBB"
+        expect:
+          storeOffsetAs: afterB
+      - action: append
+        path: ${streamPath}
+        data: "CCC"
+        expect:
+          storeOffsetAs: afterC
+    operations:
+      # Read from afterA should get BBB and CCC
+      - action: read
+        path: ${streamPath}
+        offset: ${afterA}
+        live: false
+        expect:
+          data: "BBBCCC"
+          storeOffsetAs: readOffset1
+      # Read from afterB should get only CCC
+      - action: read
+        path: ${streamPath}
+        offset: ${afterB}
+        live: false
+        expect:
+          data: "CCC"
+          storeOffsetAs: readOffset2
+      # Read from afterC should get nothing (up-to-date)
+      - action: read
+        path: ${streamPath}
+        offset: ${afterC}
+        live: false
+        expect:
+          upToDate: true
+
+  - id: offset-exact-resumption
+    name: Exact resumption from offset
+    description: Reading from an offset should not skip or duplicate data
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "AAAA"
+        expect:
+          storeOffsetAs: afterA
+      - action: append
+        path: ${streamPath}
+        data: "BBBB"
+        expect:
+          storeOffsetAs: afterB
+      - action: append
+        path: ${streamPath}
+        data: "CCCC"
+    operations:
+      # Read from beginning, should get all
+      - action: read
+        path: ${streamPath}
+        live: false
+        expect:
+          data: "AAAABBBBCCCC"
+      # Read from after A, should get B and C
+      - action: read
+        path: ${streamPath}
+        offset: ${afterA}
+        live: false
+        expect:
+          data: "BBBBCCCC"
+      # Read from after B, should get only C
+      - action: read
+        path: ${streamPath}
+        offset: ${afterB}
+        live: false
+        expect:
+          data: "CCCC"
+
+  - id: offset-persists-across-sessions
+    name: Offset works across client sessions
+    description: An offset obtained in one session should work in another
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "session1-data"
+        expect:
+          storeOffsetAs: savedOffset
+      - action: append
+        path: ${streamPath}
+        data: "session2-data"
+    operations:
+      # Simulate new session by just using the saved offset
+      - action: read
+        path: ${streamPath}
+        offset: ${savedOffset}
+        live: false
+        expect:
+          data: "session2-data"
+          upToDate: true
+
+  - id: offset-from-head
+    name: Offset from HEAD request
+    description: Offset from HEAD should be usable for reading
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "before-head"
+    operations:
+      - action: head
+        path: ${streamPath}
+        expect:
+          storeAs: headResult
+      - action: append
+        path: ${streamPath}
+        data: "after-head"
+      - action: read
+        path: ${streamPath}
+        offset: ${headResult.offset}
+        live: false
+        expect:
+          data: "after-head"
+
+  - id: offset-zero-start
+    name: Read from offset zero
+    description: Reading from offset 0 or empty should start from beginning
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "from-the-start"
+    operations:
+      - action: read
+        path: ${streamPath}
+        offset: "0"
+        live: false
+        expect:
+          data: "from-the-start"
+      - action: read
+        path: ${streamPath}
+        live: false
+        expect:
+          data: "from-the-start"
+
+  - id: offset-byte-exactness
+    name: Byte-exact offset resumption
+    description: Resuming from offset should not lose or duplicate any bytes
+    tags:
+      - property
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "0123456789"
+        expect:
+          storeOffsetAs: mid
+      - action: append
+        path: ${streamPath}
+        data: "abcdefghij"
+    operations:
+      # Full read should have all data
+      - action: read
+        path: ${streamPath}
+        live: false
+        expect:
+          data: "0123456789abcdefghij"
+      # Partial read from mid offset should have only second half
+      - action: read
+        path: ${streamPath}
+        offset: ${mid}
+        live: false
+        expect:
+          data: "abcdefghij"