baseline: OpenMU upstream b5a0961 (fresh source)

tests/MUnique.OpenMU.Network.Tests/SocketConnectionTest.cs

@@ -0,0 +1,162 @@
+// <copyright file="SocketConnectionTest.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Network.Tests;
+
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using Microsoft.Extensions.Logging.Abstractions;
+using Pipelines.Sockets.Unofficial;
+
+/// <summary>
+/// Test of the async connection implementation.
+/// </summary>
+[TestFixture]
+[Ignore("It's using real sockets")]
+public class SocketConnectionTest
+{
+    /// <summary>
+    /// Tests the receive function with a pipelined connection object.
+    /// </summary>
+    [Test]
+    public void TestReceivePipelined()
+    {
+        this.TestReceivePipelined(socket => new Connection(SocketConnection.Create(socket), null, null, new NullLogger<Connection>()));
+    }
+
+    /// <summary>
+    /// Tests the receive function with a pipelined connection object with encryptor/decryptor.
+    /// </summary>
+    [Test]
+    public void TestReceivePipelinedWithEncryption()
+    {
+        this.TestReceivePipelined(socket =>
+        {
+            var socketConnection = SocketConnection.Create(socket);
+            return new Connection(socketConnection, new PipelinedDecryptor(socketConnection.Input), new PipelinedEncryptor(socketConnection.Output), new NullLogger<Connection>());
+        });
+    }
+
+    /// <summary>
+    /// Tests if the connection is disconnected after sending invalid data.
+    /// </summary>
+    [Test]
+    public async Task TestDisconnectOnInvalidHeaderSentAsync()
+    {
+        IConnection? connection = null;
+        var server = new TcpListener(IPAddress.Any, 5000);
+        server.Start();
+        try
+        {
+            server.BeginAcceptSocket(
+                asyncResult =>
+                {
+                    var clientSocket = server.EndAcceptSocket(asyncResult);
+                    var socketConnection = SocketConnection.Create(clientSocket);
+                    connection = new Connection(socketConnection, new PipelinedDecryptor(socketConnection.Input), new PipelinedEncryptor(socketConnection.Output), new NullLogger<Connection>());
+                }, null);
+
+            using var client = new TcpClient("127.0.0.1", 5000);
+            while (connection == null)
+            {
+                Thread.Sleep(10);
+            }
+
+#pragma warning disable 4014
+            connection.BeginReceiveAsync();
+#pragma warning restore 4014
+
+            var packet = new byte[22222];
+            packet[0] = 0xDE;
+            packet[1] = 0xAD;
+            packet[2] = 0xBE;
+            packet[3] = 0xAF;
+            await connection.Output.WriteAsync(packet).ConfigureAwait(false);
+            await Task.Delay(1000).ConfigureAwait(false);
+
+            Assert.That(connection.Connected, Is.False);
+        }
+        finally
+        {
+            server.Stop();
+        }
+    }
+
+    /// <summary>
+    /// Tests if the connection is disconnected after receiving invalid data.
+    /// </summary>
+    [Test]
+    public void TestDisconnectOnInvalidHeaderReceived()
+    {
+        var server = new TcpListener(IPAddress.Any, 5000);
+        server.Start();
+        try
+        {
+            server.BeginAcceptSocket(
+                asyncResult =>
+                {
+                    var clientSocket = server.EndAcceptSocket(asyncResult);
+                    var packet = new byte[] { 0xDE, 0xAD, 0xBE, 0xEF, 0, 0, 0, 0, 0, 0 };
+                    clientSocket.BeginSend(packet, 0, packet.Length, SocketFlags.None, null, null);
+                }, null);
+
+            using var client = new TcpClient("127.0.0.1", 5000);
+            var socketConnection = SocketConnection.Create(client.Client);
+            var connection = new Connection(socketConnection, new PipelinedDecryptor(socketConnection.Input), new PipelinedEncryptor(socketConnection.Output), new NullLogger<Connection>());
+
+            _ = connection.BeginReceiveAsync();
+
+            Thread.Sleep(100);
+            Assert.That(connection.Connected, Is.False);
+        }
+        finally
+        {
+            server.Stop();
+        }
+    }
+
+    /// <summary>
+    /// Tests the receiving of data with any <see cref="IConnection"/> implementation.
+    /// </summary>
+    /// <param name="connectionCreator">The connection creator.</param>
+    private void TestReceivePipelined(Func<Socket, IConnection> connectionCreator)
+    {
+        const int maximumPacketCount = 1000;
+
+        IConnection? connection = null;
+        var server = new TcpListener(IPAddress.Any, 5000);
+        server.Start();
+        server.BeginAcceptSocket(
+            asyncResult =>
+            {
+                var clientSocket = server.EndAcceptSocket(asyncResult);
+                connection = connectionCreator(clientSocket);
+            }, null);
+        using (var client = new TcpClient("127.0.0.1", 5000))
+        {
+            while (connection == null)
+            {
+                Thread.Sleep(10);
+            }
+
+            int packetCount = 0;
+            connection.PacketReceived += async p => Interlocked.Increment(ref packetCount);
+            _ = connection.BeginReceiveAsync();
+
+            var packet = new byte[] { 0xC1, 10, 0, 0, 0, 0, 0, 0, 0, 0 };
+            for (int i = 0; i < maximumPacketCount; i++)
+            {
+                client.Client.BeginSend(packet, 0, packet.Length, SocketFlags.None, null, null);
+            }
+
+            while (packetCount < maximumPacketCount)
+            {
+                Thread.Sleep(1);
+            }
+        }
+
+        server.Stop();
+    }
+}