@durable-streams/client-conformance-tests 0.1.0

package/test-cases/consumer/streaming-equivalence.yaml

@@ -0,0 +1,226 @@
+id: consumer-streaming-equivalence
+name: Streaming Mode Equivalence
+description: Tests that SSE and Long-poll modes produce identical results
+category: consumer
+tags:
+  - core
+  - equivalence
+  - sse
+  - longpoll
+
+tests:
+  - id: equivalence-existing-data
+    name: Both modes return same existing data
+    description: SSE and long-poll should return identical data for existing content
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "chunk1"
+      - action: append
+        path: ${streamPath}
+        data: "chunk2"
+      - action: append
+        path: ${streamPath}
+        data: "chunk3"
+    operations:
+      # Read with long-poll
+      - action: read
+        path: ${streamPath}
+        live: long-poll
+        waitForUpToDate: true
+        expect:
+          data: "chunk1chunk2chunk3"
+          upToDate: true
+          storeDataAs: longpollData
+      # Read same stream with SSE
+      - action: read
+        path: ${streamPath}
+        live: sse
+        waitForUpToDate: true
+        expect:
+          data: "chunk1chunk2chunk3"
+          upToDate: true
+      # Verify both got same data
+      - action: assert
+        equals:
+          left: ${longpollData}
+          right: "chunk1chunk2chunk3"
+        message: "Long-poll and SSE should return identical data"
+
+  - id: equivalence-from-offset
+    name: Both modes resume from same offset correctly
+    description: SSE and long-poll should resume from offset identically
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "before"
+        expect:
+          storeOffsetAs: midOffset
+      - action: append
+        path: ${streamPath}
+        data: "after"
+    operations:
+      # Read from offset with long-poll
+      - action: read
+        path: ${streamPath}
+        offset: ${midOffset}
+        live: long-poll
+        waitForUpToDate: true
+        expect:
+          data: "after"
+          upToDate: true
+      # Read from same offset with SSE
+      - action: read
+        path: ${streamPath}
+        offset: ${midOffset}
+        live: sse
+        waitForUpToDate: true
+        expect:
+          data: "after"
+          upToDate: true
+
+  - id: equivalence-empty-stream
+    name: Both modes handle empty stream identically
+    description: SSE and long-poll should both report up-to-date on empty stream
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      # Read empty stream with long-poll
+      - action: read
+        path: ${streamPath}
+        live: long-poll
+        waitForUpToDate: true
+        expect:
+          chunkCount: 0
+          upToDate: true
+      # Read empty stream with SSE
+      - action: read
+        path: ${streamPath}
+        live: sse
+        waitForUpToDate: true
+        expect:
+          chunkCount: 0
+          upToDate: true
+
+  - id: equivalence-live-new-data
+    name: Both modes receive live data
+    description: SSE and long-poll should both receive newly appended data
+    requires:
+      - sse
+      - long-poll
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "initial"
+        expect:
+          storeOffsetAs: initialOffset
+    operations:
+      # Test long-poll receives new data
+      - action: read
+        path: ${streamPath}
+        offset: ${initialOffset}
+        live: long-poll
+        timeoutMs: 5000
+        background: true
+        as: longpollRead
+      - action: wait
+        ms: 100
+      - action: server-append
+        path: ${streamPath}
+        data: "live-data-lp"
+      - action: await
+        ref: longpollRead
+        expect:
+          dataContains: "live-data-lp"
+
+  - id: equivalence-sse-live-new-data
+    name: SSE receives live data
+    description: SSE should receive newly appended data in live mode
+    requires:
+      - sse
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "initial"
+        expect:
+          storeOffsetAs: initialOffset
+    operations:
+      # Test SSE receives new data
+      - action: read
+        path: ${streamPath}
+        offset: ${initialOffset}
+        live: sse
+        timeoutMs: 5000
+        background: true
+        as: sseRead
+      - action: wait
+        ms: 100
+      - action: server-append
+        path: ${streamPath}
+        data: "live-data-sse"
+      - action: await
+        ref: sseRead
+        expect:
+          dataContains: "live-data-sse"
+
+  - id: equivalence-offset-semantics
+    name: Offset semantics identical between modes
+    description: Reading from specific offsets should work identically
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "a"
+        expect:
+          storeOffsetAs: offset1
+      - action: append
+        path: ${streamPath}
+        data: "b"
+        expect:
+          storeOffsetAs: offset2
+      - action: append
+        path: ${streamPath}
+        data: "c"
+    operations:
+      # Long-poll from offset1 should get "bc"
+      - action: read
+        path: ${streamPath}
+        offset: ${offset1}
+        live: long-poll
+        waitForUpToDate: true
+        expect:
+          data: "bc"
+      # SSE from offset1 should also get "bc"
+      - action: read
+        path: ${streamPath}
+        offset: ${offset1}
+        live: sse
+        waitForUpToDate: true
+        expect:
+          data: "bc"
+      # Long-poll from offset2 should get "c"
+      - action: read
+        path: ${streamPath}
+        offset: ${offset2}
+        live: long-poll
+        waitForUpToDate: true
+        expect:
+          data: "c"
+      # SSE from offset2 should also get "c"
+      - action: read
+        path: ${streamPath}
+        offset: ${offset2}
+        live: sse
+        waitForUpToDate: true
+        expect:
+          data: "c"

package/test-cases/lifecycle/dynamic-headers.yaml

@@ -0,0 +1,147 @@
+id: lifecycle-dynamic-headers
+name: Dynamic Headers and Parameters
+description: |
+  Tests for dynamic header and parameter handling.
+  Production clients need to support headers/params that are computed per-request
+  (e.g., OAuth token refresh, request timestamps, correlation IDs).
+category: lifecycle
+tags:
+  - headers
+  - params
+  - auth
+  - dynamic
+requires:
+  - dynamicHeaders
+
+tests:
+  - id: dynamic-header-per-request
+    name: Dynamic headers evaluated per request
+    description: |
+      Headers provided as functions should be evaluated on each request,
+      not cached. This is critical for token refresh scenarios.
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      # Configure adapter to use a counter-based dynamic header
+      - action: set-dynamic-header
+        name: X-Request-Counter
+        valueType: counter
+      # First append - should have counter=1
+      - action: append
+        path: ${streamPath}
+        data: "first"
+        expect:
+          status: 200
+          headersSent:
+            X-Request-Counter: "1"
+      # Second append - should have counter=2 (not cached)
+      - action: append
+        path: ${streamPath}
+        data: "second"
+        expect:
+          status: 200
+          headersSent:
+            X-Request-Counter: "2"
+      # Third append - should have counter=3
+      - action: append
+        path: ${streamPath}
+        data: "third"
+        expect:
+          status: 200
+          headersSent:
+            X-Request-Counter: "3"
+
+  - id: dynamic-header-on-read
+    name: Dynamic headers on repeated reads
+    description: Headers should be freshly evaluated on each read request
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "test-data"
+    operations:
+      - action: set-dynamic-header
+        name: X-Request-Counter
+        valueType: counter
+      # First read
+      - action: read
+        path: ${streamPath}
+        live: false
+        expect:
+          status: 200
+          headersSent:
+            X-Request-Counter: "1"
+      # Second read from same offset - counter should increment
+      - action: read
+        path: ${streamPath}
+        live: false
+        expect:
+          status: 200
+          headersSent:
+            X-Request-Counter: "2"
+
+  - id: dynamic-param-per-request
+    name: Dynamic params evaluated per request
+    description: |
+      URL parameters provided as functions should be evaluated on each request.
+      Useful for signed URLs, dynamic routing, etc.
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "data"
+    operations:
+      - action: set-dynamic-param
+        name: request_id
+        valueType: counter
+      - action: read
+        path: ${streamPath}
+        live: false
+        expect:
+          status: 200
+          paramsSent:
+            request_id: "1"
+      - action: read
+        path: ${streamPath}
+        live: false
+        expect:
+          status: 200
+          paramsSent:
+            request_id: "2"
+
+  - id: token-refresh-simulation
+    name: Token refresh simulation
+    description: |
+      Simulates OAuth token refresh by changing the Authorization header value
+      between requests. The client must use the new value, not cache the old one.
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      # Set initial token
+      - action: set-dynamic-header
+        name: Authorization
+        valueType: token
+        initialValue: "Bearer token-v1"
+      - action: append
+        path: ${streamPath}
+        data: "first"
+        expect:
+          status: 200
+          headersSent:
+            Authorization: "Bearer token-v1"
+      # Simulate token refresh
+      - action: set-dynamic-header
+        name: Authorization
+        valueType: token
+        initialValue: "Bearer token-v2"
+      - action: append
+        path: ${streamPath}
+        data: "second"
+        expect:
+          status: 200
+          headersSent:
+            Authorization: "Bearer token-v2"

package/test-cases/lifecycle/headers-params.yaml

@@ -0,0 +1,117 @@
+id: lifecycle-headers
+name: Headers and Parameters
+description: Tests for header and parameter handling
+category: lifecycle
+tags:
+  - headers
+  - params
+  - auth
+
+tests:
+  - id: custom-headers-create
+    name: Custom headers on create
+    description: Client should send custom headers on create
+    operations:
+      - action: create
+        as: streamPath
+        headers:
+          X-Custom-Header: "custom-value"
+          X-Another-Header: "another-value"
+        expect:
+          status: 201
+
+  - id: custom-headers-append
+    name: Custom headers on append
+    description: Client should send custom headers on append
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      - action: append
+        path: ${streamPath}
+        data: "with-headers"
+        headers:
+          X-Request-Id: "req-12345"
+          Authorization: "Bearer test-token"
+        expect:
+          status: 200
+
+  - id: custom-headers-read
+    name: Custom headers on read
+    description: Client should send custom headers on read
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "data"
+    operations:
+      - action: read
+        path: ${streamPath}
+        headers:
+          Authorization: "Bearer read-token"
+        live: false
+        expect:
+          status: 200
+
+  - id: custom-headers-head
+    name: Custom headers on head
+    description: Client should send custom headers on HEAD
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      - action: head
+        path: ${streamPath}
+        headers:
+          X-Trace-Id: "trace-abc"
+        expect:
+          status: 200
+
+  - id: custom-headers-delete
+    name: Custom headers on delete
+    description: Client should send custom headers on delete
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      - action: delete
+        path: ${streamPath}
+        headers:
+          Authorization: "Bearer delete-token"
+        expect:
+          status: 200
+
+  - id: content-type-preserved
+    name: Content type is preserved
+    description: Content type set on create should be returned on read
+    operations:
+      - action: create
+        as: streamPath
+        contentType: application/x-custom-type
+        expect:
+          status: 201
+      - action: head
+        path: ${streamPath}
+        expect:
+          contentType: application/x-custom-type
+    cleanup:
+      - action: delete
+        path: ${streamPath}
+
+  - id: content-type-with-charset
+    name: Content type with charset
+    description: Content type with charset parameter should be preserved
+    operations:
+      - action: create
+        as: streamPath
+        contentType: text/plain; charset=utf-8
+        expect:
+          status: 201
+      - action: head
+        path: ${streamPath}
+        expect:
+          contentType: text/plain; charset=utf-8
+    cleanup:
+      - action: delete
+        path: ${streamPath}

package/test-cases/lifecycle/stream-lifecycle.yaml

@@ -0,0 +1,148 @@
+id: lifecycle-stream
+name: Stream Lifecycle
+description: Tests for complete stream lifecycle operations
+category: lifecycle
+tags:
+  - core
+  - lifecycle
+
+tests:
+  - id: full-lifecycle
+    name: Full stream lifecycle
+    description: Create, append, read, and delete a stream
+    operations:
+      - action: create
+        as: streamPath
+        contentType: text/plain
+        expect:
+          status: 201
+      - action: append
+        path: ${streamPath}
+        data: "lifecycle-test-data"
+        expect:
+          status: 200
+      - action: read
+        path: ${streamPath}
+        live: false
+        expect:
+          data: "lifecycle-test-data"
+          upToDate: true
+      - action: delete
+        path: ${streamPath}
+        expect:
+          status: 200
+      - action: read
+        path: ${streamPath}
+        live: false
+        expect:
+          status: 404
+
+  - id: connect-existing
+    name: Connect to existing stream
+    description: Connect should work for existing streams
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "pre-existing"
+    operations:
+      - action: connect
+        path: ${streamPath}
+        expect:
+          status: 200
+      - action: read
+        path: ${streamPath}
+        live: false
+        expect:
+          data: "pre-existing"
+
+  - id: head-metadata
+    name: HEAD returns metadata
+    description: HEAD should return stream metadata without body
+    setup:
+      - action: create
+        as: streamPath
+        contentType: application/json
+      - action: append
+        path: ${streamPath}
+        data: '{"key": "value"}'
+    operations:
+      - action: head
+        path: ${streamPath}
+        expect:
+          status: 200
+          contentType: application/json
+          hasOffset: true
+
+  - id: head-empty-stream
+    name: HEAD on empty stream
+    description: HEAD should work on empty stream
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      - action: head
+        path: ${streamPath}
+        expect:
+          status: 200
+          hasOffset: true
+
+  - id: multiple-streams
+    name: Multiple independent streams
+    description: Operations on one stream should not affect others
+    operations:
+      - action: create
+        as: stream1
+      - action: create
+        as: stream2
+      - action: append
+        path: ${stream1}
+        data: "stream1-data"
+      - action: append
+        path: ${stream2}
+        data: "stream2-data"
+      - action: read
+        path: ${stream1}
+        live: false
+        expect:
+          data: "stream1-data"
+      - action: read
+        path: ${stream2}
+        live: false
+        expect:
+          data: "stream2-data"
+      - action: delete
+        path: ${stream1}
+      - action: read
+        path: ${stream2}
+        live: false
+        expect:
+          data: "stream2-data"
+    cleanup:
+      - action: delete
+        path: ${stream2}
+
+  - id: recreate-after-delete
+    name: Create after delete
+    description: Creating after delete should succeed as a new stream
+    operations:
+      - action: create
+        as: streamPath
+        expect:
+          status: 201
+      - action: append
+        path: ${streamPath}
+        data: "original"
+      - action: delete
+        path: ${streamPath}
+        expect:
+          status: 200
+      # Create at same path should succeed as a new stream
+      - action: create
+        path: ${streamPath}
+        expect:
+          status: 201
+    cleanup:
+      - action: delete
+        path: ${streamPath}