added unit tests for ProxyProtocol

test/SuperSocket.Tests/FixedHeaderProtocolTest.cs

@@ -55,11 +55,14 @@ protected override IServer CreateServer(IHostConfigurator hostConfigurator)
                 })
                 .ConfigureAppConfiguration((HostBuilder, configBuilder) =>
                 {
-                    configBuilder.AddInMemoryCollection(new Dictionary<string, string>
-                    {
-                        { "serverOptions:values:enableSendingPipe", "true" }
-                    });
+                    configBuilder.AddInMemoryCollection(LoadMemoryConfig(new Dictionary<string, string>()));
                 }).BuildAsServer() as IServer;
         }
+
+        protected virtual Dictionary<string, string> LoadMemoryConfig(Dictionary<string, string> configSettings)
+        {
+            configSettings["serverOptions:values:enableSendingPipe"] = "true";
+            return configSettings;
+        }
     }
 }

test/SuperSocket.Tests/ProtocolTestBase.cs

@@ -6,6 +6,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
 using SuperSocket;
 using SuperSocket.Server;
 using SuperSocket.Server.Abstractions;
@@ -24,6 +25,11 @@ protected ProtocolTestBase(ITestOutputHelper outputHelper) : base(outputHelper)
 
         protected abstract IServer CreateServer(IHostConfigurator hostConfigurator);
 
+        protected virtual IHostConfigurator CreateHostConfigurator(Type hostConfiguratorType)
+        {
+            return CreateObject<IHostConfigurator>(hostConfiguratorType);
+        }
+
         protected abstract string CreateRequest(string sourceLine);
 
         [Theory]
@@ -35,7 +41,7 @@ protected ProtocolTestBase(ITestOutputHelper outputHelper) : base(outputHelper)
         [InlineData(typeof(KestralConnectionHostConfigurator))]
         public virtual async Task TestNormalRequest(Type hostConfiguratorType)
         {
-            var hostConfigurator = CreateObject<IHostConfigurator>(hostConfiguratorType);
+            var hostConfigurator = CreateHostConfigurator(hostConfiguratorType);
 
             using (var server = CreateServer(hostConfigurator))
             {
@@ -69,7 +75,7 @@ public virtual async Task TestNormalRequest(Type hostConfiguratorType)
         [InlineData(typeof(KestralConnectionHostConfigurator))]
         public virtual async Task TestMiddleBreak(Type hostConfiguratorType)
         {
-            var hostConfigurator = CreateObject<IHostConfigurator>(hostConfiguratorType);
+            var hostConfigurator = CreateHostConfigurator(hostConfiguratorType);
 
             using (var server = CreateServer(hostConfigurator))
             {
@@ -105,7 +111,7 @@ public virtual async Task TestMiddleBreak(Type hostConfiguratorType)
         [InlineData(typeof(KestralConnectionHostConfigurator))]
         public virtual async Task TestFragmentRequest(Type hostConfiguratorType)
         {
-            var hostConfigurator = CreateObject<IHostConfigurator>(hostConfiguratorType);
+            var hostConfigurator = CreateHostConfigurator(hostConfiguratorType);
 
             using (var server = CreateServer(hostConfigurator))
             {
@@ -146,7 +152,7 @@ public virtual async Task TestFragmentRequest(Type hostConfiguratorType)
         [InlineData(typeof(KestralConnectionHostConfigurator))]
         public virtual async Task TestBatchRequest(Type hostConfiguratorType)
         {
-            var hostConfigurator = CreateObject<IHostConfigurator>(hostConfiguratorType);
+            var hostConfigurator = CreateHostConfigurator(hostConfiguratorType);
 
             using (var server = CreateServer(hostConfigurator))
             {
@@ -195,7 +201,7 @@ public virtual async Task TestBatchRequest(Type hostConfiguratorType)
         //[InlineData(typeof(UdpHostConfigurator))]
         public virtual async Task TestBreakRequest(Type hostConfiguratorType)
         {
-            var hostConfigurator = CreateObject<IHostConfigurator>(hostConfiguratorType);
+            var hostConfigurator = CreateHostConfigurator(hostConfiguratorType);
 
             using (var server = CreateServer(hostConfigurator))
             {

test/SuperSocket.Tests/ProxyProtocolHostConfigurator.cs

@@ -0,0 +1,74 @@
+using System.IO;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading.Tasks;
+using SuperSocket.Client;
+using SuperSocket.Connection;
+using SuperSocket.ProtoBase;
+using SuperSocket.Server.Abstractions;
+using SuperSocket.Server.Abstractions.Host;
+
+namespace SuperSocket.Tests
+{
+    public class ProxyProtocolHostConfigurator : IHostConfigurator
+    {
+        private IHostConfigurator _innerHostConfigurator;
+
+        private static readonly byte[] _proxyProtocolV2_IPV4_SampleData = new byte[]
+            {
+                0x0D, 0x0A, 0x0D, 0x0A,
+                0x00, 0x0D, 0x0A, 0x51,
+                0x55, 0x49, 0x54, 0x0A,
+                0x21, 0x11, 0x00, 0x0c,
+                0xac, 0x13, 0x00, 0x01,
+                0xac, 0x13, 0x00, 0x03,
+                0xa6, 0x52, 0x00, 0x50
+            };
+
+        public ProxyProtocolHostConfigurator(IHostConfigurator hostConfigurator)
+        {
+            _innerHostConfigurator = hostConfigurator;
+        }
+
+        public string WebSocketSchema => _innerHostConfigurator.WebSocketSchema;
+
+        public bool IsSecure => _innerHostConfigurator.IsSecure;
+
+        public ListenOptions Listener => _innerHostConfigurator.Listener;
+
+        public void Configure(ISuperSocketHostBuilder hostBuilder)
+        {
+            _innerHostConfigurator.Configure(hostBuilder);
+        }
+
+        public IEasyClient<TPackageInfo> ConfigureEasyClient<TPackageInfo>(IPipelineFilter<TPackageInfo> pipelineFilter, ConnectionOptions options) where TPackageInfo : class
+        {
+            return _innerHostConfigurator.ConfigureEasyClient<TPackageInfo>(pipelineFilter, options);
+        }
+
+        public Socket CreateClient()
+        {
+            return _innerHostConfigurator.CreateClient();
+        }
+
+        public async ValueTask<Stream> GetClientStream(Socket socket)
+        {
+            var stream = await _innerHostConfigurator.GetClientStream(socket);
+
+            await stream.WriteAsync(_proxyProtocolV2_IPV4_SampleData, 0, _proxyProtocolV2_IPV4_SampleData.Length);
+            await stream.FlushAsync();
+
+            return stream;
+        }
+
+        public TextReader GetStreamReader(Stream stream, Encoding encoding)
+        {
+            return _innerHostConfigurator.GetStreamReader(stream, encoding);
+        }
+
+        public ValueTask KeepSequence()
+        {
+            return _innerHostConfigurator.KeepSequence();
+        }
+    }
+}

test/SuperSocket.Tests/ProxyProtocolTest.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Hosting;
+using SuperSocket;
+using SuperSocket.ProtoBase;
+using SuperSocket.Server.Host;
+using SuperSocket.Server.Abstractions;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace SuperSocket.Tests
+{
+    [Trait("Category", "ProxyProtocol")]
+    public class ProxyProtocolTest : FixedHeaderProtocolTest
+    {
+        public ProxyProtocolTest(ITestOutputHelper outputHelper)
+            : base(outputHelper)
+        {
+        }
+
+        protected override IHostConfigurator CreateHostConfigurator(Type hostConfiguratorType)
+        {
+            return new ProxyProtocolHostConfigurator(base.CreateHostConfigurator(hostConfiguratorType));
+        }
+
+        protected override Dictionary<string, string> LoadMemoryConfig(Dictionary<string, string> configSettings)
+        {
+            base.LoadMemoryConfig(configSettings);
+            configSettings["serverOptions:enableProxyProtocol"] = "true";
+            return configSettings;
+        }
+    }
+}