TASK-001-003: Add H2ResponseBuilder + H3ResponseBuilder fluent frame builders

Add fluent test helpers for constructing HTTP/2 and HTTP/3 frame-level byte
arrays, reducing verbosity and error-proneness in byte-level acceptance tests.

- H2ResponseBuilder: Settings, SettingsAck, Headers (HPACK), Data, WindowUpdate,
  Ping, GoAway, RstStream with Build() → byte[]
- H3ResponseBuilder: Settings, Headers (QPACK), Data, GoAway, MaxPushId,
  CancelPush with Build() → byte[]
- 7 unit tests per builder verifying round-trip through existing FrameDecoder

Author: st0o0

.maggus/daemon.stop-after-task

@@ -0,0 +1 @@
+38564

.maggus/features/feature_001.md

@@ -76,12 +76,12 @@ Migrate all 84 IntegrationTest files (83 acceptance + 1 unit) to deterministic S
 **Model:** opus
 
 **Acceptance Criteria:**
-- [ ] `H2ResponseBuilder` in `StreamTests/Acceptance/Shared/` with fluent API: `.Settings()`, `.Headers(streamId, status, headers)`, `.Data(streamId, body, endStream)`, `.WindowUpdate()`, `.Build()` returning `byte[]`
-- [ ] `H3ResponseBuilder` in `StreamTests/Acceptance/Shared/` with equivalent fluent API adapted for HTTP/3 frames (QPACK-encoded headers)
-- [ ] Builders produce valid frames decodable by existing `FrameDecoder` implementations
-- [ ] Unit test: H2 builder produces valid SETTINGS + HEADERS + DATA sequence
-- [ ] Unit test: H3 builder produces valid SETTINGS + HEADERS + DATA sequence
-- [ ] Build passes
+- [x] `H2ResponseBuilder` in `StreamTests/Acceptance/Shared/` with fluent API: `.Settings()`, `.Headers(streamId, status, headers)`, `.Data(streamId, body, endStream)`, `.WindowUpdate()`, `.Build()` returning `byte[]`
+- [x] `H3ResponseBuilder` in `StreamTests/Acceptance/Shared/` with equivalent fluent API adapted for HTTP/3 frames (QPACK-encoded headers)
+- [x] Builders produce valid frames decodable by existing `FrameDecoder` implementations
+- [x] Unit test: H2 builder produces valid SETTINGS + HEADERS + DATA sequence
+- [x] Unit test: H3 builder produces valid SETTINGS + HEADERS + DATA sequence
+- [x] Build passes
 
 ---
 

src/TurboHTTP.StreamTests/Acceptance/Shared/H2ResponseBuilder.cs

@@ -0,0 +1,135 @@
+using System.Text;
+using TurboHTTP.Protocol.Http2;
+using TurboHTTP.Protocol.Http2.Hpack;
+
+namespace TurboHTTP.StreamTests.Acceptance.Shared;
+
+/// <summary>
+/// Fluent builder for constructing HTTP/2 frame-level byte arrays.
+/// Produces valid frame sequences decodable by <see cref="FrameDecoder"/>.
+/// Intended for byte-level acceptance tests where hand-crafting frames is verbose.
+/// </summary>
+public sealed class H2ResponseBuilder
+{
+    private readonly List<Http2Frame> _frames = [];
+    private readonly HpackEncoder _encoder;
+
+    public H2ResponseBuilder(bool useHuffman = false)
+    {
+        _encoder = new HpackEncoder(useHuffman: useHuffman);
+    }
+
+    /// <summary>
+    /// Appends a SETTINGS frame with the given parameters on stream 0.
+    /// </summary>
+    public H2ResponseBuilder Settings(params (SettingsParameter Key, uint Value)[] parameters)
+    {
+        _frames.Add(new SettingsFrame(parameters));
+        return this;
+    }
+
+    /// <summary>
+    /// Appends a SETTINGS ACK frame on stream 0.
+    /// </summary>
+    public H2ResponseBuilder SettingsAck()
+    {
+        _frames.Add(new SettingsFrame([], isAck: true));
+        return this;
+    }
+
+    /// <summary>
+    /// Appends a HEADERS frame with HPACK-encoded pseudo-headers and regular headers.
+    /// </summary>
+    public H2ResponseBuilder Headers(int streamId, int status, IReadOnlyList<(string Name, string Value)>? headers = null, bool endStream = false)
+    {
+        var allHeaders = new List<(string, string)>
+        {
+            (":status", status.ToString())
+        };
+
+        if (headers != null)
+        {
+            allHeaders.AddRange(headers);
+        }
+
+        var encoded = _encoder.Encode(allHeaders);
+        _frames.Add(new HeadersFrame(streamId, encoded, endStream: endStream, endHeaders: true));
+        return this;
+    }
+
+    /// <summary>
+    /// Appends a DATA frame with the given body bytes.
+    /// </summary>
+    public H2ResponseBuilder Data(int streamId, ReadOnlyMemory<byte> body, bool endStream = true)
+    {
+        _frames.Add(new DataFrame(streamId, body, endStream: endStream));
+        return this;
+    }
+
+    /// <summary>
+    /// Appends a DATA frame with a UTF-8 string body.
+    /// </summary>
+    public H2ResponseBuilder Data(int streamId, string body, bool endStream = true)
+    {
+        return Data(streamId, Encoding.UTF8.GetBytes(body), endStream);
+    }
+
+    /// <summary>
+    /// Appends a WINDOW_UPDATE frame.
+    /// </summary>
+    public H2ResponseBuilder WindowUpdate(int streamId, int increment)
+    {
+        _frames.Add(new WindowUpdateFrame(streamId, increment));
+        return this;
+    }
+
+    /// <summary>
+    /// Appends a PING frame (8 bytes of opaque data).
+    /// </summary>
+    public H2ResponseBuilder Ping(ReadOnlyMemory<byte>? data = null, bool isAck = false)
+    {
+        var pingData = data ?? new byte[8];
+        _frames.Add(new PingFrame(pingData, isAck: isAck));
+        return this;
+    }
+
+    /// <summary>
+    /// Appends a GOAWAY frame on stream 0.
+    /// </summary>
+    public H2ResponseBuilder GoAway(int lastStreamId, Http2ErrorCode errorCode = Http2ErrorCode.NoError)
+    {
+        _frames.Add(new GoAwayFrame(lastStreamId, errorCode));
+        return this;
+    }
+
+    /// <summary>
+    /// Appends a RST_STREAM frame.
+    /// </summary>
+    public H2ResponseBuilder RstStream(int streamId, Http2ErrorCode errorCode)
+    {
+        _frames.Add(new RstStreamFrame(streamId, errorCode));
+        return this;
+    }
+
+    /// <summary>
+    /// Serializes all appended frames into a single contiguous byte array.
+    /// </summary>
+    public byte[] Build()
+    {
+        var totalSize = 0;
+        foreach (var frame in _frames)
+        {
+            totalSize += frame.SerializedSize;
+        }
+
+        var result = new byte[totalSize];
+        var span = result.AsSpan();
+
+        foreach (var frame in _frames)
+        {
+            frame.WriteTo(ref span);
+        }
+
+        return result;
+    }
+}

src/TurboHTTP.StreamTests/Acceptance/Shared/H2ResponseBuilderSpec.cs

@@ -0,0 +1,176 @@
+using TurboHTTP.Protocol.Http2;
+using TurboHTTP.Protocol.Http2.Hpack;
+
+namespace TurboHTTP.StreamTests.Acceptance.Shared;
+
+/// <summary>
+/// Verifies that <see cref="H2ResponseBuilder"/> produces valid HTTP/2 frame sequences
+/// decodable by <see cref="FrameDecoder"/>.
+/// </summary>
+public sealed class H2ResponseBuilderSpec
+{
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC9113-4.1")]
+    public void Build_should_produce_valid_settings_headers_data_sequence()
+    {
+        var bytes = new H2ResponseBuilder()
+            .Settings(
+                (SettingsParameter.MaxConcurrentStreams, 100),
+                (SettingsParameter.InitialWindowSize, 65535))
+            .SettingsAck()
+            .Headers(1, 200, [("content-type", "text/plain")])
+            .Data(1, "hello")
+            .Build();
+
+        using var decoder = new FrameDecoder();
+        var frames = decoder.Decode(new ReadOnlyMemory<byte>(bytes));
+
+        Assert.Equal(4, frames.Count);
+
+        var settings = Assert.IsType<SettingsFrame>(frames[0]);
+        Assert.False(settings.IsAck);
+        Assert.Equal(2, settings.Parameters.Count);
+        Assert.Equal(SettingsParameter.MaxConcurrentStreams, settings.Parameters[0].Item1);
+        Assert.Equal(100u, settings.Parameters[0].Item2);
+
+        var settingsAck = Assert.IsType<SettingsFrame>(frames[1]);
+        Assert.True(settingsAck.IsAck);
+
+        var headers = Assert.IsType<HeadersFrame>(frames[2]);
+        Assert.Equal(1, headers.StreamId);
+        Assert.True(headers.EndHeaders);
+        Assert.False(headers.EndStream);
+
+        var hpackDecoder = new HpackDecoder();
+        var decoded = hpackDecoder.Decode(headers.HeaderBlockFragment.Span);
+        Assert.Contains(decoded, h => h.Name == ":status" && h.Value == "200");
+        Assert.Contains(decoded, h => h.Name == "content-type" && h.Value == "text/plain");
+
+        var data = Assert.IsType<DataFrame>(frames[3]);
+        Assert.Equal(1, data.StreamId);
+        Assert.True(data.EndStream);
+        Assert.Equal("hello"u8.ToArray(), data.Data.ToArray());
+    }
+
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC9113-6.5")]
+    public void Build_should_produce_valid_empty_settings_ack()
+    {
+        var bytes = new H2ResponseBuilder()
+            .SettingsAck()
+            .Build();
+
+        using var decoder = new FrameDecoder();
+        var frames = decoder.Decode(new ReadOnlyMemory<byte>(bytes));
+
+        Assert.Single(frames);
+        var settings = Assert.IsType<SettingsFrame>(frames[0]);
+        Assert.True(settings.IsAck);
+        Assert.Empty(settings.Parameters);
+    }
+
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC9113-6.9")]
+    public void Build_should_produce_valid_window_update()
+    {
+        var bytes = new H2ResponseBuilder()
+            .WindowUpdate(0, 65535)
+            .WindowUpdate(1, 32768)
+            .Build();
+
+        using var decoder = new FrameDecoder();
+        var frames = decoder.Decode(new ReadOnlyMemory<byte>(bytes));
+
+        Assert.Equal(2, frames.Count);
+
+        var wu0 = Assert.IsType<WindowUpdateFrame>(frames[0]);
+        Assert.Equal(0, wu0.StreamId);
+        Assert.Equal(65535, wu0.Increment);
+
+        var wu1 = Assert.IsType<WindowUpdateFrame>(frames[1]);
+        Assert.Equal(1, wu1.StreamId);
+        Assert.Equal(32768, wu1.Increment);
+    }
+
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC9113-6.1")]
+    public void Build_should_produce_headers_only_response_with_end_stream()
+    {
+        var bytes = new H2ResponseBuilder()
+            .Headers(1, 204, endStream: true)
+            .Build();
+
+        using var decoder = new FrameDecoder();
+        var frames = decoder.Decode(new ReadOnlyMemory<byte>(bytes));
+
+        Assert.Single(frames);
+        var headers = Assert.IsType<HeadersFrame>(frames[0]);
+        Assert.Equal(1, headers.StreamId);
+        Assert.True(headers.EndStream);
+        Assert.True(headers.EndHeaders);
+
+        var hpackDecoder = new HpackDecoder();
+        var decoded = hpackDecoder.Decode(headers.HeaderBlockFragment.Span);
+        Assert.Single(decoded);
+        Assert.Equal(":status", decoded[0].Name);
+        Assert.Equal("204", decoded[0].Value);
+    }
+
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC9113-6.8")]
+    public void Build_should_produce_valid_goaway_frame()
+    {
+        var bytes = new H2ResponseBuilder()
+            .GoAway(3, Http2ErrorCode.NoError)
+            .Build();
+
+        using var decoder = new FrameDecoder();
+        var frames = decoder.Decode(new ReadOnlyMemory<byte>(bytes));
+
+        Assert.Single(frames);
+        var goaway = Assert.IsType<GoAwayFrame>(frames[0]);
+        Assert.Equal(3, goaway.LastStreamId);
+        Assert.Equal(Http2ErrorCode.NoError, goaway.ErrorCode);
+    }
+
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC9113-6.4")]
+    public void Build_should_produce_valid_rst_stream_frame()
+    {
+        var bytes = new H2ResponseBuilder()
+            .RstStream(1, Http2ErrorCode.Cancel)
+            .Build();
+
+        using var decoder = new FrameDecoder();
+        var frames = decoder.Decode(new ReadOnlyMemory<byte>(bytes));
+
+        Assert.Single(frames);
+        var rst = Assert.IsType<RstStreamFrame>(frames[0]);
+        Assert.Equal(1, rst.StreamId);
+        Assert.Equal(Http2ErrorCode.Cancel, rst.ErrorCode);
+    }
+
+    [Fact(Timeout = 5000)]
+    [Trait("RFC", "RFC9113-4.1")]
+    public void Build_should_produce_byte_exact_round_trip_through_decoder()
+    {
+        var builder = new H2ResponseBuilder();
+        var bytes = builder
+            .Settings((SettingsParameter.HeaderTableSize, 4096))
+            .SettingsAck()
+            .Headers(1, 200)
+            .Data(1, "body")
+            .WindowUpdate(0, 100)
+            .Build();
+
+        using var decoder = new FrameDecoder();
+        var frames = decoder.Decode(new ReadOnlyMemory<byte>(bytes));
+
+        Assert.Equal(5, frames.Count);
+        Assert.IsType<SettingsFrame>(frames[0]);
+        Assert.IsType<SettingsFrame>(frames[1]);
+        Assert.IsType<HeadersFrame>(frames[2]);
+        Assert.IsType<DataFrame>(frames[3]);
+        Assert.IsType<WindowUpdateFrame>(frames[4]);
+    }
+}