SessionHeaders

Tests/Unit/IndexedStructureTests.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using Esiur.Data;
+using Esiur.Net.Packets;
 using Esiur.Resource;
+using Esiur.Security.Authority;
 
 namespace Esiur.Tests.Unit;
 
@@ -81,6 +83,41 @@ public class IndexedStructureTests
         Assert.Contains("index 1", error.Message, StringComparison.OrdinalIgnoreCase);
     }
 
+    [Fact]
+    public void SessionHeaders_RoundTripUsingAuthenticationHeaderIndexes()
+    {
+        var source = new SessionHeaders
+        {
+            Version = (byte)3,
+            Domain = "example.test",
+            IPAddress = new byte[] { 127, 0, 0, 1 },
+            AuthenticationProtocol = "hash",
+            AuthenticationData = new byte[] { 1, 2, 3 },
+        };
+
+        var bytes = Codec.ComposeIndexedType(source, Warehouse.Default, null);
+        var legacyBytes = Codec.Compose(new Map<byte, object>
+        {
+            [(byte)EpAuthPacketHeader.Version] = source.Version,
+            [(byte)EpAuthPacketHeader.Domain] = source.Domain,
+            [(byte)EpAuthPacketHeader.IPAddress] = source.IPAddress,
+            [(byte)EpAuthPacketHeader.AuthenticationProtocol] = source.AuthenticationProtocol,
+            [(byte)EpAuthPacketHeader.AuthenticationData] = source.AuthenticationData,
+        }, Warehouse.Default, null);
+        var (_, raw) = Codec.ParseSync(bytes, 0, Warehouse.Default);
+        var map = Assert.IsType<Map<byte, object>>(raw);
+        var (_, parsed) = Codec.ParseIndexedType<SessionHeaders>(bytes, 0, Warehouse.Default);
+
+        Assert.Equal(legacyBytes, bytes);
+        Assert.Equal("example.test", map[(byte)EpAuthPacketHeader.Domain]);
+        Assert.Equal("hash", map[(byte)EpAuthPacketHeader.AuthenticationProtocol]);
+        Assert.False(map.ContainsKey((byte)EpAuthPacketHeader.ErrorMessage));
+        Assert.Equal(source.Domain, parsed.Domain);
+        Assert.Equal(source.IPAddress, parsed.IPAddress);
+        Assert.Equal(source.AuthenticationProtocol, parsed.AuthenticationProtocol);
+        Assert.Equal(source.AuthenticationData, parsed.AuthenticationData);
+    }
+
     private sealed class InvalidStructure : IndexedStructure
     {
         [Index(1)] public int First { get; set; }

Tests/Unit/Integration/SessionHeadersIntegrationTests.cs

@@ -0,0 +1,22 @@
+namespace Esiur.Tests.Unit.Integration;
+
+[Collection("Integration")]
+public class SessionHeadersIntegrationTests
+{
+    [Fact]
+    public async Task AuthenticatedHandshake_StoresTypedHeadersWithoutAuthenticationData()
+    {
+        await using var cluster = await IntegrationCluster
+            .StartAsync(_ => Task.CompletedTask)
+            .WaitAsync(TimeSpan.FromSeconds(10));
+
+        var serverConnection = Assert.Single(cluster.Server.Connections);
+
+        Assert.NotNull(cluster.Connection.Session.LocalHeaders.IPAddress);
+        Assert.Null(cluster.Connection.Session.RemoteHeaders.AuthenticationData);
+
+        Assert.Equal("test", serverConnection.Session.RemoteHeaders.Domain);
+        Assert.Equal("hash", serverConnection.Session.RemoteHeaders.AuthenticationProtocol);
+        Assert.Null(serverConnection.Session.RemoteHeaders.AuthenticationData);
+    }
+}