feat(h11): add Http11Profile, Options, ConnectionReuseEvaluator, ChunkExtensionParser, RequestValidator

Phase 1 of HTTP/1.1 Redesign. New types in Protocol/Syntax/Http11/.
Old Protocol/Http11/ untouched — cutover in Phase 3.

29 new tests green, 262 total Http11 tests green.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: st0o0

src/TurboHTTP.Tests/Http11/ChunkExtensionParserV2Spec.cs

@@ -0,0 +1,81 @@
+using System.Text;
+using TurboHTTP.Protocol.Syntax.Http11;
+using Xunit;
+
+namespace TurboHTTP.Tests.Http11;
+
+[Trait("RFC", "RFC9112")]
+public sealed class ChunkExtensionParserV2Spec
+{
+    [Fact(Timeout = 5000)]
+    public void EmptyExtensions_ShouldParse()
+    {
+        var result = ChunkExtensionParser.TryParse([]);
+
+        Assert.True(result);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void NameOnlyExtension_ShouldParse()
+    {
+        var bytes = Encoding.UTF8.GetBytes("name");
+        var result = ChunkExtensionParser.TryParse(bytes);
+
+        Assert.True(result);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void NameValueExtension_ShouldParse()
+    {
+        var bytes = Encoding.UTF8.GetBytes("name=value");
+        var result = ChunkExtensionParser.TryParse(bytes);
+
+        Assert.True(result);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void QuotedStringValue_ShouldParse()
+    {
+        var bytes = Encoding.UTF8.GetBytes("name=\"quoted value\"");
+        var result = ChunkExtensionParser.TryParse(bytes);
+
+        Assert.True(result);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void MissingSemicolon_ShouldFail()
+    {
+        // Multiple extensions without semicolon separator should fail
+        var bytes = Encoding.UTF8.GetBytes("name1 name2");
+        var result = ChunkExtensionParser.TryParse(bytes);
+
+        Assert.False(result);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void MultipleValidExtensions_ShouldParse()
+    {
+        var bytes = Encoding.UTF8.GetBytes("name1=value1;name2=value2");
+        var result = ChunkExtensionParser.TryParse(bytes);
+
+        Assert.True(result);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void ExtensionWithWhitespace_ShouldParse()
+    {
+        var bytes = Encoding.UTF8.GetBytes("name = value ");
+        var result = ChunkExtensionParser.TryParse(bytes);
+
+        Assert.True(result);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void EscapedCharacterInQuotedString_ShouldParse()
+    {
+        var bytes = Encoding.UTF8.GetBytes("name=\"value\\\"with\\\"quotes\"");
+        var result = ChunkExtensionParser.TryParse(bytes);
+
+        Assert.True(result);
+    }
+}

src/TurboHTTP.Tests/Http11/ConnectionReuseEvaluatorV2Spec.cs

@@ -0,0 +1,102 @@
+using System.Net;
+using TurboHTTP.Protocol.Syntax.Http11;
+using Xunit;
+
+namespace TurboHTTP.Tests.Http11;
+
+[Trait("RFC", "RFC9112")]
+public sealed class ConnectionReuseEvaluatorV2Spec
+{
+    [Fact(Timeout = 5000)]
+    public void ProtocolError_ShouldClose()
+    {
+        var response = new HttpResponseMessage(HttpStatusCode.OK);
+        var decision = ConnectionReuseEvaluator.Evaluate(response, HttpVersion.Version11, protocolErrorOccurred: true);
+
+        Assert.False(decision.CanReuse);
+        Assert.Contains("Protocol error", decision.Reason);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void BodyNotConsumed_ShouldClose()
+    {
+        var response = new HttpResponseMessage(HttpStatusCode.OK);
+        var decision = ConnectionReuseEvaluator.Evaluate(response, HttpVersion.Version11, bodyFullyConsumed: false);
+
+        Assert.False(decision.CanReuse);
+        Assert.Contains("not fully consumed", decision.Reason);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void SwitchingProtocols_ShouldClose()
+    {
+        var response = new HttpResponseMessage((HttpStatusCode)101);
+        var decision = ConnectionReuseEvaluator.Evaluate(response, HttpVersion.Version11);
+
+        Assert.False(decision.CanReuse);
+        Assert.Contains("101 Switching Protocols", decision.Reason);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void ConnectionClose_ShouldClose()
+    {
+        var response = new HttpResponseMessage(HttpStatusCode.OK);
+        response.Headers.Connection.Add("close");
+        var decision = ConnectionReuseEvaluator.Evaluate(response, HttpVersion.Version11);
+
+        Assert.False(decision.CanReuse);
+        Assert.Contains("Connection: close", decision.Reason);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void Http10WithoutKeepAlive_ShouldClose()
+    {
+        var response = new HttpResponseMessage(HttpStatusCode.OK);
+        var decision = ConnectionReuseEvaluator.Evaluate(response, HttpVersion.Version10);
+
+        Assert.False(decision.CanReuse);
+        Assert.Contains("HTTP/1.0", decision.Reason);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void Http10WithKeepAlive_ShouldKeepAlive()
+    {
+        var response = new HttpResponseMessage(HttpStatusCode.OK);
+        response.Headers.Connection.Add("Keep-Alive");
+        var decision = ConnectionReuseEvaluator.Evaluate(response, HttpVersion.Version10);
+
+        Assert.True(decision.CanReuse);
+        Assert.Contains("HTTP/1.0", decision.Reason);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void Http11Default_ShouldKeepAlive()
+    {
+        var response = new HttpResponseMessage(HttpStatusCode.OK);
+        var decision = ConnectionReuseEvaluator.Evaluate(response, HttpVersion.Version11);
+
+        Assert.True(decision.CanReuse);
+        Assert.Contains("HTTP/1.1", decision.Reason);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void Http11WithClose_ShouldClose()
+    {
+        var response = new HttpResponseMessage(HttpStatusCode.OK);
+        response.Headers.Connection.Add("close");
+        var decision = ConnectionReuseEvaluator.Evaluate(response, HttpVersion.Version11);
+
+        Assert.False(decision.CanReuse);
+        Assert.Contains("Connection: close", decision.Reason);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void Http20_ShouldAlwaysKeepAlive()
+    {
+        var response = new HttpResponseMessage(HttpStatusCode.OK);
+        var decision = ConnectionReuseEvaluator.Evaluate(response, HttpVersion.Version20);
+
+        Assert.True(decision.CanReuse);
+        Assert.Contains("HTTP/2", decision.Reason);
+    }
+}

src/TurboHTTP.Tests/Http11/Http11ProfileSpec.cs

@@ -0,0 +1,31 @@
+using System.Net;
+using TurboHTTP.Protocol.Syntax.Http11;
+
+namespace TurboHTTP.Tests.Http11;
+
+public sealed class Http11ProfileSpec
+{
+    [Fact(Timeout = 5000)]
+    public void SupportsChunked_should_be_true()
+    {
+        Assert.True(Http11Profile.SupportsChunked);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void DefaultPersistent_should_be_true()
+    {
+        Assert.True(Http11Profile.DefaultPersistent);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void RequiresHost_should_be_true()
+    {
+        Assert.True(Http11Profile.RequiresHost);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void Version_should_be_11()
+    {
+        Assert.Equal(HttpVersion.Version11, Http11Profile.Version);
+    }
+}

src/TurboHTTP.Tests/Http11/RequestValidatorV2Spec.cs

@@ -0,0 +1,87 @@
+using System.Net.Http.Headers;
+using TurboHTTP.Protocol.Syntax.Http11.Client;
+using Xunit;
+
+namespace TurboHTTP.Tests.Http11;
+
+[Trait("RFC", "RFC9112")]
+public sealed class RequestValidatorV2Spec
+{
+    [Fact(Timeout = 5000)]
+    public void ValidGet_ShouldPass()
+    {
+        var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com");
+        request.Headers.Add("User-Agent", "Test");
+
+        RequestValidator.Validate(request);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void ValidPostWithBody_ShouldPass()
+    {
+        var request = new HttpRequestMessage(HttpMethod.Post, "http://example.com")
+        {
+            Content = new StringContent("test body")
+        };
+        request.Headers.Add("User-Agent", "Test");
+
+        RequestValidator.Validate(request);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void LowercaseMethod_ShouldThrow()
+    {
+        var request = new HttpRequestMessage(new HttpMethod("get"), "http://example.com");
+
+        var exception = Assert.Throws<ArgumentException>(() => RequestValidator.Validate(request));
+        Assert.Contains("uppercase", exception.Message);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void ValidRangeHeader_ShouldPass()
+    {
+        var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com");
+        request.Headers.Add("Range", "bytes=0-99");
+
+        RequestValidator.Validate(request);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void ValidMultipleRanges_ShouldPass()
+    {
+        var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com");
+        request.Headers.Add("Range", "bytes=0-100,200-300");
+
+        RequestValidator.Validate(request);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void ValidSuffixRange_ShouldPass()
+    {
+        var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com");
+        request.Headers.Add("Range", "bytes=-100");
+
+        RequestValidator.Validate(request);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void ValidPostWithContentHeaders_ShouldPass()
+    {
+        var request = new HttpRequestMessage(HttpMethod.Post, "http://example.com")
+        {
+            Content = new StringContent("test body")
+        };
+        request.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
+
+        RequestValidator.Validate(request);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void ValidMixedCaseMethod_ShouldThrow()
+    {
+        var request = new HttpRequestMessage(new HttpMethod("Get"), "http://example.com");
+
+        var exception = Assert.Throws<ArgumentException>(() => RequestValidator.Validate(request));
+        Assert.Contains("uppercase", exception.Message);
+    }
+}