## TASK-041-003: Migrate StreamTests RFC9113 → Http2/ component folders

Migrated all 13 stream test files from `TurboHttp.StreamTests/RFC9113/` to
component-based `Http2/` subfolders following the conventions introduced in Feature 040.

### Files created

**Http2/Encoding/**
- `Http2EncoderSpec.cs` (from `01_Http20EncoderStageTests.cs`)
- `Http2EncoderFrameSerializationSpec.cs` (from `02_Http20EncoderStageFrameSerializationTests.cs`)
- `Http2BatchEncodingSpec.cs` (from `03_Http20BatchEncodingTests.cs`)

**Http2/Decoding/**
- `Http2DecoderSpec.cs` (from `04_Http20DecoderStageTests.cs`)
- `Http2DecoderFrameParsingSpec.cs` (from `05_Http20DecoderStageFrameParsingTests.cs`)

**Http2/Connection/**
- `Http2ConnectionSettingsSpec.cs` (from `06_Http20ConnectionStageSettingsTests.cs`)
- `Http2ConnectionPingSpec.cs` (from `07_Http20ConnectionStagePingTests.cs`)
- `Http2ConnectionGoAwaySpec.cs` (from `08_Http20ConnectionStageGoAwayTests.cs`)
- `Http2ConnectionFlowControlSpec.cs` (from `09_Http20ConnectionStageFlowControlTests.cs`)
- `Http2ConnectionBackpressureSpec.cs` (from `10_Http20ConnectionStageBackpressureTests.cs`)
- `Http2ConnectionStreamAcquireSpec.cs` (from `11_Http20ConnectionStageStreamAcquireTests.cs`)
- `Http2ConnectionFlowControlBatchingSpec.cs` (from `24_Http20FlowControlBatchingTests.cs`)

**Http2/**
- `Http2EngineEndToEndSpec.cs` (from `22_Http20EngineEndToEndTests.cs`)

### Changes applied to each file
- Namespace: `TurboHttp.StreamTests.RFC9113` → `TurboHttp.StreamTests.Http2.*`
- Class names: `*Tests` → `*Spec` (sealed)
- Method names: converted to BDD style `Subject_should_behavior_when_condition()`
- RFC traceability: `[Fact(DisplayName = "RFC9113-...")]` → `[Trait("RFC", "RFC9113-X.Y")]`
- Timeouts: `[Fact(Timeout = ...)]` preserved on all async tests

### Deleted
- `src/TurboHttp.StreamTests/RFC9113/` (all 13 files + empty folder)

### Verification
- `dotnet test --project TurboHttp.StreamTests/TurboHttp.StreamTests.csproj` → 658 tests, all green
- `dotnet test --filter-trait "RFC=RFC9113-6.5"` → 10 tests found (Settings spec)
- `dotnet test --filter-trait "RFC=RFC9113"` → 7 tests found (Engine end-to-end spec)

Author: st0o0

.maggus/features/feature_041.md

@@ -124,15 +124,15 @@ moved to Http2/ subfolders so that HTTP/2 stage tests are organized by component
 **Parallel:** yes — can run alongside TASK-041-002
 
 **Acceptance Criteria:**
-- [ ] All remaining files in `TurboHttp.StreamTests/RFC9113/` moved to correct `Http2/` subfolder
-- [ ] All remaining files in `TurboHttp.StreamTests/RFC7541/` moved to `Http2/Hpack/`
-- [ ] All namespaces updated to `TurboHttp.StreamTests.Http2.*`
-- [ ] All class names end with `Spec`
-- [ ] All method names follow BDD pattern
-- [ ] No `DisplayName` with RFC tags remain in migrated files
-- [ ] `[Trait("RFC", ...)]` present on each test
-- [ ] `dotnet test --project TurboHttp.StreamTests/TurboHttp.StreamTests.csproj` green
-- [ ] `dotnet test --filter "Trait~RFC9113"` finds all migrated stream tests
+- [x] All remaining files in `TurboHttp.StreamTests/RFC9113/` moved to correct `Http2/` subfolder
+- [x] All remaining files in `TurboHttp.StreamTests/RFC7541/` moved to `Http2/Hpack/`
+- [x] All namespaces updated to `TurboHttp.StreamTests.Http2.*`
+- [x] All class names end with `Spec`
+- [x] All method names follow BDD pattern
+- [x] No `DisplayName` with RFC tags remain in migrated files
+- [x] `[Trait("RFC", ...)]` present on each test
+- [x] `dotnet test --project TurboHttp.StreamTests/TurboHttp.StreamTests.csproj` green (658 tests)
+- [x] `dotnet test --filter-trait "RFC=RFC9113"` finds all migrated stream tests
 
 ---
 

…ttp20ConnectionStageBackpressureTests.cs …ction/Http2ConnectionBackpressureSpec.cssrc/TurboHttp.StreamTests/RFC9113/10_Http20ConnectionStageBackpressureTests.cs renamed to src/TurboHttp.StreamTests/Http2/Connection/Http2ConnectionBackpressureSpec.cs src/TurboHttp.StreamTests/RFC9113/10_Http20ConnectionStageBackpressureTests.cs renamed to src/TurboHttp.StreamTests/Http2/Connection/Http2ConnectionBackpressureSpec.cs

@@ -5,23 +5,15 @@
 using TurboHttp.Protocol.RFC9113;
 using TurboHttp.Streams.Stages.Decoding;
 
-namespace TurboHttp.StreamTests.RFC9113;
+namespace TurboHttp.StreamTests.Http2.Connection;
 
 /// <summary>
 /// Tests backpressure behaviour in the HTTP/2 connection stage per RFC 9113.
 /// Verifies that the stage correctly applies flow control and does not emit frames faster than the downstream can consume.
 /// </summary>
-/// <remarks>
-/// Stage under test: <see cref="Http20ConnectionStage"/>.
-/// RFC 9113 §5.2: HTTP/2 flow control and backpressure in connection-level frame processing.
-/// </remarks>
-public sealed class Http20ConnectionStageBackpressureTests : StreamTestBase
+[Trait("RFC", "RFC9113-5.2")]
+public sealed class Http2ConnectionBackpressureSpec : StreamTestBase
 {
-    /// <summary>
-    /// Creates an Http20ConnectionStage graph with a <see cref="Source.Queue{T}"/> for InApp
-    /// and a <see cref="TestPublisher.ManualProbe{T}"/> for InServer.
-    /// Subscriber probes capture all three outlets for assertion.
-    /// </summary>
     private (
         ISourceQueueWithComplete<HttpRequestMessage> RequestQueue,
         TestPublisher.ManualProbe<Http2Frame> ServerProbe,
@@ -57,20 +49,12 @@ public sealed class Http20ConnectionStageBackpressureTests : StreamTestBase
         return (requestQueue, serverProbe, serverBoundProbe, appOutProbe, signalProbe);
     }
 
-    /// <summary>
-    /// Offers a request to the queue and asserts it is enqueued (accepted).
-    /// </summary>
     private static async Task OfferAsync(ISourceQueueWithComplete<HttpRequestMessage> queue, HttpRequestMessage request)
     {
         var result = await queue.OfferAsync(request).WaitAsync(TimeSpan.FromSeconds(3), TestContext.Current.CancellationToken);
         Assert.IsType<QueueOfferResult.Enqueued>(result);
     }
 
-    /// <summary>
-    /// Sends <paramref name="count"/> GET requests through the queue and verifies
-    /// each one is forwarded to OutServer and emits a StreamAcquireItem signal.
-    /// Returns the next available odd stream ID.
-    /// </summary>
     private static async Task<int> FillStreamsAsync(
         ISourceQueueWithComplete<HttpRequestMessage> queue,
         TestSubscriber.ManualProbe<Http2Frame> serverBoundProbe,
@@ -89,8 +73,9 @@ private static async Task<int> FillStreamsAsync(
         return streamId;
     }
 
-    [Fact(Timeout = 10_000, DisplayName = "RFC9113-5.1.2-20CS-BP-001: Backpressure gates request inlet at max concurrent streams")]
-    public async Task Should_Stop_Pulling_When_At_MaxConcurrentStreams_Limit()
+    [Fact(Timeout = 10_000)]
+    [Trait("RFC", "RFC9113-5.1.2")]
+    public async Task Http2ConnectionBackpressure_should_stop_pulling_when_at_max_concurrent_streams_limit()
     {
         var (requestQueue, _, serverBoundProbe, appOutProbe, signalProbe) = CreateProbes(3);
 
@@ -102,18 +87,16 @@ public async Task Should_Stop_Pulling_When_At_MaxConcurrentStreams_Limit()
         serverBoundSub.Request(100);
         signalSub.Request(100);
 
-        // Fill 3 streams (the limit)
-        var nextId = await FillStreamsAsync(requestQueue, serverBoundProbe, signalProbe, 3);
+        await FillStreamsAsync(requestQueue, serverBoundProbe, signalProbe, 3);
 
-        // Offer a 4th request — it enters the queue buffer but the stage won't pull it
         await OfferAsync(requestQueue, new HttpRequestMessage(HttpMethod.Get, "http://example.com/"));
 
-        // The 4th frame should NOT appear on OutServer because the stage is gating _inApp
         serverBoundProbe.ExpectNoMsg(TimeSpan.FromMilliseconds(300), TestContext.Current.CancellationToken);
     }
 
-    [Fact(Timeout = 10_000, DisplayName = "RFC9113-5.1.2-20CS-BP-002: END_STREAM decrements active streams and resumes pull")]
-    public async Task Should_Decrement_And_Resume_Pull_When_EndStream_Received()
+    [Fact(Timeout = 10_000)]
+    [Trait("RFC", "RFC9113-5.1.2")]
+    public async Task Http2ConnectionBackpressure_should_decrement_and_resume_pull_when_end_stream_received()
     {
         var (requestQueue, serverProbe, serverBoundProbe, appOutProbe, signalProbe) = CreateProbes(3);
 
@@ -127,27 +110,23 @@ public async Task Should_Decrement_And_Resume_Pull_When_EndStream_Received()
 
         var srvSub = serverProbe.ExpectSubscription(TestContext.Current.CancellationToken);
 
-        // Fill 3 streams (the limit)
-        var nextId = await FillStreamsAsync(requestQueue, serverBoundProbe, signalProbe, 3);
+        await FillStreamsAsync(requestQueue, serverBoundProbe, signalProbe, 3);
 
-        // Offer a 4th request — queued but not yet pulled by stage
         await OfferAsync(requestQueue, new HttpRequestMessage(HttpMethod.Get, "http://example.com/"));
 
-        // Verify gated
         serverBoundProbe.ExpectNoMsg(TimeSpan.FromMilliseconds(200), TestContext.Current.CancellationToken);
 
-        // Server sends END_STREAM on stream 1 (zero-length DataFrame).
         // DATA without prior HEADERS produces no HttpResponseMessage on OutResponse;
         // CloseStream still decrements _activeStreams and TryPullRequest resumes the gate.
         srvSub.SendNext(new DataFrame(streamId: 1, data: Array.Empty<byte>(), endStream: true));
 
-        // Pull resumes — the 4th frame now appears on OutServer
         serverBoundProbe.ExpectNext(TimeSpan.FromSeconds(3), TestContext.Current.CancellationToken);
         signalProbe.ExpectNext(TimeSpan.FromSeconds(3), TestContext.Current.CancellationToken);
     }
 
-    [Fact(Timeout = 10_000, DisplayName = "RFC9113-5.1.2-20CS-BP-003: RstStreamFrame decrements active streams and resumes pull")]
-    public async Task Should_Decrement_And_Resume_Pull_When_RstStream_Received()
+    [Fact(Timeout = 10_000)]
+    [Trait("RFC", "RFC9113-5.1.2")]
+    public async Task Http2ConnectionBackpressure_should_decrement_and_resume_pull_when_rst_stream_received()
     {
         var (requestQueue, serverProbe, serverBoundProbe, appOutProbe, signalProbe) = CreateProbes(3);
 
@@ -161,26 +140,21 @@ public async Task Should_Decrement_And_Resume_Pull_When_RstStream_Received()
 
         var srvSub = serverProbe.ExpectSubscription(TestContext.Current.CancellationToken);
 
-        // Fill 3 streams (the limit)
-        var nextId = await FillStreamsAsync(requestQueue, serverBoundProbe, signalProbe, 3);
+        await FillStreamsAsync(requestQueue, serverBoundProbe, signalProbe, 3);
 
-        // Offer a 4th request — queued but gated
         await OfferAsync(requestQueue, new HttpRequestMessage(HttpMethod.Get, "http://example.com/"));
         serverBoundProbe.ExpectNoMsg(TimeSpan.FromMilliseconds(200), TestContext.Current.CancellationToken);
 
-        // Server sends RST_STREAM on stream 3.
-        // RST_STREAM is consumed internally; CloseStream decrements _activeStreams and resumes the gate.
         srvSub.SendNext(new RstStreamFrame(streamId: 3, Http2ErrorCode.Cancel));
 
-        // Pull resumes — the 4th frame now appears on OutServer
         serverBoundProbe.ExpectNext(TimeSpan.FromSeconds(3), TestContext.Current.CancellationToken);
         signalProbe.ExpectNext(TimeSpan.FromSeconds(3), TestContext.Current.CancellationToken);
     }
 
-    [Fact(Timeout = 10_000, DisplayName = "RFC9113-5.1.2-20CS-BP-004: SETTINGS MAX_CONCURRENT_STREAMS mid-session enforces new limit immediately")]
-    public async Task Should_Enforce_New_ConcurrentStreams_Limit_When_Settings_Updated_MidSession()
+    [Fact(Timeout = 10_000)]
+    [Trait("RFC", "RFC9113-5.1.2")]
+    public async Task Http2ConnectionBackpressure_should_enforce_new_concurrent_streams_limit_when_settings_updated_mid_session()
     {
-        // Start with limit=100, open 2 streams, then SETTINGS lowers limit to 2
         var (requestQueue, serverProbe, serverBoundProbe, appOutProbe, signalProbe) = CreateProbes(100);
 
         var appOutSub = appOutProbe.ExpectSubscription(TestContext.Current.CancellationToken);
@@ -193,11 +167,8 @@ public async Task Should_Enforce_New_ConcurrentStreams_Limit_When_Settings_Updat
 
         var srvSub = serverProbe.ExpectSubscription(TestContext.Current.CancellationToken);
 
-        // Open 2 streams
         await FillStreamsAsync(requestQueue, serverBoundProbe, signalProbe, 2);
 
-        // Server sends SETTINGS lowering MAX_CONCURRENT_STREAMS to 2.
-        // SETTINGS is consumed internally; OutResponse receives nothing.
         srvSub.SendNext(new SettingsFrame(
             [(SettingsParameter.MaxConcurrentStreams, 2u)]));
 
@@ -208,7 +179,6 @@ public async Task Should_Enforce_New_ConcurrentStreams_Limit_When_Settings_Updat
 
         // The stage had an outstanding pull from when limit was 100.
         // That in-flight pull will be satisfied by the next offered element regardless of the new limit.
-        // Offer the 3rd request — it passes through on the pre-existing pull.
         await OfferAsync(requestQueue, new HttpRequestMessage(HttpMethod.Get, "http://example.com/"));
         serverBoundProbe.ExpectNext(TimeSpan.FromSeconds(3), TestContext.Current.CancellationToken);
         signalProbe.ExpectNext(TimeSpan.FromSeconds(3), TestContext.Current.CancellationToken);
@@ -218,11 +188,9 @@ public async Task Should_Enforce_New_ConcurrentStreams_Limit_When_Settings_Updat
         serverBoundProbe.ExpectNoMsg(TimeSpan.FromMilliseconds(300), TestContext.Current.CancellationToken);
 
         // Close streams 1 and 3 to drop to activeStreams=1 < limit=2 → pull resumes.
-        // DATA/RST_STREAM are consumed internally; CloseStream manages _activeStreams.
         srvSub.SendNext(new DataFrame(streamId: 1, data: Array.Empty<byte>(), endStream: true));
         srvSub.SendNext(new RstStreamFrame(streamId: 3, Http2ErrorCode.Cancel));
 
-        // The 4th frame should now flow through
         serverBoundProbe.ExpectNext(TimeSpan.FromSeconds(3), TestContext.Current.CancellationToken);
         signalProbe.ExpectNext(TimeSpan.FromSeconds(3), TestContext.Current.CancellationToken);
     }

…113/24_Http20FlowControlBatchingTests.cs …ttp2ConnectionFlowControlBatchingSpec.cssrc/TurboHttp.StreamTests/RFC9113/24_Http20FlowControlBatchingTests.cs renamed to src/TurboHttp.StreamTests/Http2/Connection/Http2ConnectionFlowControlBatchingSpec.cs src/TurboHttp.StreamTests/RFC9113/24_Http20FlowControlBatchingTests.cs renamed to src/TurboHttp.StreamTests/Http2/Connection/Http2ConnectionFlowControlBatchingSpec.cs

@@ -6,17 +6,14 @@
 using TurboHttp.Streams;
 using TurboHttp.Streams.Stages.Decoding;
 
-namespace TurboHttp.StreamTests.RFC9113;
+namespace TurboHttp.StreamTests.Http2.Connection;
 
 /// <summary>
-/// Tests for HTTP/2 flow-control batching: C1 (1 MB initial window) and
-/// C2 (WINDOW_UPDATE accumulation with threshold flush).
+/// Tests HTTP/2 flow-control batching: initial window configuration and
+/// WINDOW_UPDATE accumulation with threshold flush per RFC 9113.
 /// </summary>
-/// <remarks>
-/// Stage under test: <see cref="Http20ConnectionStage"/>, <see cref="Http20Engine"/>.
-/// RFC 9113 §6.9: Flow control, WINDOW_UPDATE semantics and batching strategy.
-/// </remarks>
-public sealed class Http20FlowControlBatchingTests : StreamTestBase
+[Trait("RFC", "RFC9113-6.9")]
+public sealed class Http2ConnectionFlowControlBatchingSpec : StreamTestBase
 {
     // Default window is 65535 → threshold = max(16384, 65535/4) = 16384.
     private const int DefaultThreshold = 16384;
@@ -58,16 +55,16 @@ public sealed class Http20FlowControlBatchingTests : StreamTestBase
         return (downstream, serverBound);
     }
 
-    [Fact(Timeout = 5_000, DisplayName = "RFC9113-6.9-H2FC-001: Http20Engine default initial window is 1 MiB")]
-    public void Should_HaveOneMibInitialWindow_When_DefaultConstructorUsed()
+    [Fact(Timeout = 5_000)]
+    public void Http2Engine_should_have_one_mib_initial_window_when_default_constructor_used()
     {
         var engine = new Http20Engine();
 
         Assert.Equal(1_048_576, engine.InitialWindowSize);
     }
 
-    [Fact(Timeout = 5_000, DisplayName = "RFC9113-6.9-H2FC-002: No WINDOW_UPDATE sent when response has no DATA frames")]
-    public async Task Should_SendNoWindowUpdate_When_ResponseIsHeadersOnly()
+    [Fact(Timeout = 5_000)]
+    public async Task Http2ConnectionFlowControlBatching_should_send_no_window_update_when_response_is_headers_only()
     {
         var headers = new HeadersFrame(
             streamId: 1,
@@ -82,8 +79,8 @@ public async Task Should_SendNoWindowUpdate_When_ResponseIsHeadersOnly()
         Assert.Empty(windowUpdates);
     }
 
-    [Fact(Timeout = 5_000, DisplayName = "RFC9113-6.9-H2FC-003: Stream WINDOW_UPDATE flushed on stream close below threshold")]
-    public async Task Should_FlushStreamPending_OnStreamClose_WhenBelowThreshold()
+    [Fact(Timeout = 5_000)]
+    public async Task Http2ConnectionFlowControlBatching_should_flush_stream_pending_on_stream_close_when_below_threshold()
     {
         // 1024 bytes is well below the 16384 threshold → no immediate WINDOW_UPDATE.
         // On stream close the stream-level pending is flushed; connection-level is NOT.
@@ -99,8 +96,8 @@ public async Task Should_FlushStreamPending_OnStreamClose_WhenBelowThreshold()
         Assert.DoesNotContain(windowUpdates, f => f.StreamId == 0);
     }
 
-    [Fact(Timeout = 5_000, DisplayName = "RFC9113-6.9-H2FC-004: Both WINDOW_UPDATEs sent immediately when threshold crossed")]
-    public async Task Should_SendBothWindowUpdates_When_ThresholdCrossed_InSingleFrame()
+    [Fact(Timeout = 5_000)]
+    public async Task Http2ConnectionFlowControlBatching_should_send_both_window_updates_when_threshold_crossed_in_single_frame()
     {
         // Exactly 16384 bytes crosses both connection and stream threshold at once.
         var data = new DataFrame(streamId: 1, data: new byte[DefaultThreshold], endStream: true);
@@ -114,8 +111,8 @@ public async Task Should_SendBothWindowUpdates_When_ThresholdCrossed_InSingleFra
         Assert.Contains(windowUpdates, f => f.StreamId == 1 && f.Increment == DefaultThreshold);
     }
 
-    [Fact(Timeout = 5_000, DisplayName = "RFC9113-6.9-H2FC-005: Pending batched across multiple DATA frames until threshold")]
-    public async Task Should_SendSingleBatchedWindowUpdate_When_MultipleFramesAccumulateToThreshold()
+    [Fact(Timeout = 5_000)]
+    public async Task Http2ConnectionFlowControlBatching_should_send_single_batched_window_update_when_multiple_frames_accumulate_to_threshold()
     {
         // Two 8192-byte frames accumulate to 16384 → threshold crossed on second frame.
         var frame1 = new DataFrame(streamId: 1, data: new byte[8192], endStream: false);
@@ -139,8 +136,8 @@ public async Task Should_SendSingleBatchedWindowUpdate_When_MultipleFramesAccumu
         Assert.Equal(DefaultThreshold, streamUpdate.Increment);
     }
 
-    [Fact(Timeout = 5_000, DisplayName = "RFC9113-6.9-H2FC-006: Two streams accumulate WINDOW_UPDATE independently")]
-    public async Task Should_BatchStreamsIndependently_When_TwoStreamsSendDataBelowThreshold()
+    [Fact(Timeout = 5_000)]
+    public async Task Http2ConnectionFlowControlBatching_should_batch_streams_independently_when_two_streams_send_data_below_threshold()
     {
         // Stream 1: 16384 bytes → hits threshold on its own → stream WU(1) sent.
         // Stream 3: 8192 bytes → below threshold → stream WU(3) flushed only at close.