TASK-021-006: TLS Uniform Coverage Part 1 (Compression + Cookie + Redirect + Retry)

Author: st0o0

.maggus/COMMIT.md

@@ -0,0 +1,12 @@
+TASK-021-006: TLS Uniform Coverage Part 1 (Compression + Cookie + Redirect + Retry)
+
+Add four dedicated TLS integration test classes mirroring the HTTP/1.1 feature test classes
+over HTTPS transport. All 41 new tests pass; build is zero-warning.
+
+- TLS/CompressionIntegrationTests: 7 tests (gzip, deflate, brotli, identity, negotiate)
+- TLS/CookieIntegrationTests: 11 tests (set/echo, Secure over HTTPS, HttpOnly, SameSite,
+  Max-Age expiry, domain/path scoping, multi-cookie, delete, set-and-redirect)
+- TLS/RedirectIntegrationTests: 14 tests (301-308, chains, loop, relative URL, method
+  preservation, HTTPS→HTTP downgrade blocking for cross-scheme and cross-origin routes)
+- TLS/RetryIntegrationTests: 9 tests (408/503 retries, Retry-After seconds and HTTP-date,
+  succeed-after-N, idempotent PUT/DELETE, non-idempotent POST)

.maggus/features/feature_021.md

@@ -202,14 +202,14 @@ TurboHttp has 139 integration tests but coverage is heavily skewed toward HTTP/1
 **Note:** The existing `IntegrationTests.cs` (9 tests) covers a mix of basic features. The new files provide dedicated per-feature coverage. The old file can remain as a cross-cutting sanity check.
 
 **Acceptance Criteria:**
-- [ ] `CompressionIntegrationTests.cs` created with 7 tests
-- [ ] `CookieIntegrationTests.cs` created with 11 tests
-- [ ] `RedirectIntegrationTests.cs` created with 14 tests
-- [ ] `RetryIntegrationTests.cs` created with 9 tests
-- [ ] All tests use `KestrelTlsFixture`, `[Collection("TLS")]`, `scheme: "https"`
-- [ ] DisplayNames follow `Compression-TLS-001` / `Cookie-TLS-001` / `Redirect-TLS-001` / `Retry-TLS-001`
-- [ ] All 41 tests pass
-- [ ] Build passes with zero warnings
+- [x] `CompressionIntegrationTests.cs` created with 7 tests
+- [x] `CookieIntegrationTests.cs` created with 11 tests
+- [x] `RedirectIntegrationTests.cs` created with 14 tests
+- [x] `RetryIntegrationTests.cs` created with 9 tests
+- [x] All tests use `KestrelTlsFixture`, `[Collection("TLS")]`, `scheme: "https"`
+- [x] DisplayNames follow `Compression-TLS-001` / `Cookie-TLS-001` / `Redirect-TLS-001` / `Retry-TLS-001`
+- [x] All 41 tests pass
+- [x] Build passes with zero warnings
 
 **Files:**
 - `src/TurboHttp.IntegrationTests/TLS/CompressionIntegrationTests.cs`

src/TurboHttp.IntegrationTests/TLS/CompressionIntegrationTests.cs

@@ -0,0 +1,165 @@
+using System.Net;
+using TurboHttp.IntegrationTests.Shared;
+
+namespace TurboHttp.IntegrationTests.TLS;
+
+[Collection("TLS")]
+public sealed class CompressionIntegrationTests
+{
+    private readonly ServerFixture _server;
+    private readonly ActorSystemFixture _systemFixture;
+
+    public CompressionIntegrationTests(ServerFixture server, ActorSystemFixture systemFixture)
+    {
+        _server = server;
+        _systemFixture = systemFixture;
+    }
+
+    private ClientHelper CreateClient()
+    {
+        return ClientHelper.CreateClient(
+            _server.HttpsPort,
+            new Version(1, 1),
+            scheme: "https",
+            system: _systemFixture.System);
+    }
+
+    [Fact(DisplayName = "Compression-TLS-001: gzip response transparently decompressed over HTTPS")]
+    public async Task Gzip_Response_Transparently_Decompressed_Over_Https()
+    {
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        await using var helper = CreateClient();
+
+        var request = new HttpRequestMessage(HttpMethod.Get, "/compress/gzip/4");
+        var response = await helper.Client.SendAsync(request, cts.Token);
+
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        var body = await response.Content.ReadAsByteArrayAsync(cts.Token);
+        Assert.Equal(4 * 1024, body.Length);
+
+        for (var i = 0; i < body.Length; i++)
+        {
+            Assert.Equal((byte)('A' + i % 26), body[i]);
+        }
+    }
+
+    [Fact(DisplayName = "Compression-TLS-002: deflate response transparently decompressed over HTTPS")]
+    public async Task Deflate_Response_Transparently_Decompressed_Over_Https()
+    {
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        await using var helper = CreateClient();
+
+        var request = new HttpRequestMessage(HttpMethod.Get, "/compress/deflate/2");
+        var response = await helper.Client.SendAsync(request, cts.Token);
+
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        var body = await response.Content.ReadAsByteArrayAsync(cts.Token);
+        Assert.Equal(2 * 1024, body.Length);
+
+        for (var i = 0; i < body.Length; i++)
+        {
+            Assert.Equal((byte)('A' + i % 26), body[i]);
+        }
+    }
+
+    [Fact(DisplayName = "Compression-TLS-003: brotli response transparently decompressed over HTTPS")]
+    public async Task Brotli_Response_Transparently_Decompressed_Over_Https()
+    {
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        await using var helper = CreateClient();
+
+        var request = new HttpRequestMessage(HttpMethod.Get, "/compress/br/3");
+        var response = await helper.Client.SendAsync(request, cts.Token);
+
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        var body = await response.Content.ReadAsByteArrayAsync(cts.Token);
+        Assert.Equal(3 * 1024, body.Length);
+
+        for (var i = 0; i < body.Length; i++)
+        {
+            Assert.Equal((byte)('A' + i % 26), body[i]);
+        }
+    }
+
+    [Fact(DisplayName = "Compression-TLS-004: identity encoding passes through unchanged over HTTPS")]
+    public async Task Identity_Encoding_Passes_Through_Unchanged_Over_Https()
+    {
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        await using var helper = CreateClient();
+
+        var request = new HttpRequestMessage(HttpMethod.Get, "/compress/identity/1");
+        var response = await helper.Client.SendAsync(request, cts.Token);
+
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        var body = await response.Content.ReadAsByteArrayAsync(cts.Token);
+        Assert.Equal(1 * 1024, body.Length);
+
+        for (var i = 0; i < body.Length; i++)
+        {
+            Assert.Equal((byte)('A' + i % 26), body[i]);
+        }
+    }
+
+    [Fact(DisplayName = "Compression-TLS-005: content negotiation with Accept-Encoding gzip returns gzip over HTTPS")]
+    public async Task Negotiate_AcceptEncoding_Gzip_Over_Https()
+    {
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        await using var helper = CreateClient();
+
+        var request = new HttpRequestMessage(HttpMethod.Get, "/compress/negotiate");
+        request.Headers.TryAddWithoutValidation("Accept-Encoding", "gzip");
+        var response = await helper.Client.SendAsync(request, cts.Token);
+
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        var body = await response.Content.ReadAsByteArrayAsync(cts.Token);
+
+        Assert.Equal(1024, body.Length);
+
+        for (var i = 0; i < body.Length; i++)
+        {
+            Assert.Equal((byte)('A' + i % 26), body[i]);
+        }
+    }
+
+    [Fact(DisplayName = "Compression-TLS-006: content negotiation with Accept-Encoding br returns brotli over HTTPS")]
+    public async Task Negotiate_AcceptEncoding_Brotli_Over_Https()
+    {
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        await using var helper = CreateClient();
+
+        var request = new HttpRequestMessage(HttpMethod.Get, "/compress/negotiate");
+        request.Headers.TryAddWithoutValidation("Accept-Encoding", "br");
+        var response = await helper.Client.SendAsync(request, cts.Token);
+
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        var body = await response.Content.ReadAsByteArrayAsync(cts.Token);
+
+        Assert.Equal(1024, body.Length);
+
+        for (var i = 0; i < body.Length; i++)
+        {
+            Assert.Equal((byte)('A' + i % 26), body[i]);
+        }
+    }
+
+    [Fact(DisplayName = "Compression-TLS-007: content negotiation with no Accept-Encoding returns identity over HTTPS")]
+    public async Task Negotiate_NoAcceptEncoding_Returns_Identity_Over_Https()
+    {
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        await using var helper = CreateClient();
+
+        var request = new HttpRequestMessage(HttpMethod.Get, "/compress/negotiate");
+        request.Headers.Remove("Accept-Encoding");
+        var response = await helper.Client.SendAsync(request, cts.Token);
+
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        var body = await response.Content.ReadAsByteArrayAsync(cts.Token);
+
+        Assert.Equal(1024, body.Length);
+
+        for (var i = 0; i < body.Length; i++)
+        {
+            Assert.Equal((byte)('A' + i % 26), body[i]);
+        }
+    }
+}