UT for Version/Verack messages (#853)

* UT for Version/Verack messages

* Indentation

* Indentation

* Update ProtocolHandler.cs

* Fixing ClassInit;
Removing shutdown;
Initializing testblockchain during class setup (only once)

* Running formatter

* Eriks suggestion

* fix typo

* removed ProtocolFactory

* remove TestProtocolFactory

* simplify

* CreateActor

* Revert "CreateActor"

This reverts commit 3ad56f7.

* removed parameter from RemoteNode

* fix

* removed unused parameters

* format

neo.UnitTests/UT_Culture.cs

@@ -1,5 +1,6 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
@@ -36,7 +37,8 @@ where t.GetCustomAttribute<TestClassAttribute>() != null
 
             var cultures = new string[] { "en-US", "zh-CN", "de-DE", "ko-KR", "ja-JP" };
             var originalUICulture = CultureInfo.CurrentCulture;
-            var emtpyObjArray = new object[] { };
+            var emptyObjArray = new object[] { };
+            var testContext = new object[] { new UnitTestContext() };
 
             // run all the tests, varying the culture each time.
             try
@@ -47,26 +49,26 @@ where t.GetCustomAttribute<TestClassAttribute>() != null
 
                     foreach (var c in testClasses)
                     {
-                        var instance = c.Constructor.Invoke(emtpyObjArray);
+                        var instance = c.Constructor.Invoke(emptyObjArray);
                         if (c.ClassInit != null)
                         {
-                            c.ClassInit.Invoke(instance, emtpyObjArray);
+                            c.ClassInit.Invoke(instance, testContext);
                         }
                         foreach (var m in c.TestMethods)
                         {
                             if (c.TestInit != null)
                             {
-                                c.TestInit.Invoke(instance, emtpyObjArray);
+                                c.TestInit.Invoke(instance, emptyObjArray);
                             }
-                            m.Invoke(instance, emtpyObjArray);
+                            m.Invoke(instance, emptyObjArray);
                             if (c.TestCleanup != null)
                             {
-                                c.TestCleanup.Invoke(instance, emtpyObjArray);
+                                c.TestCleanup.Invoke(instance, emptyObjArray);
                             }
                         }
                         if (c.ClassCleanup != null)
                         {
-                            c.ClassCleanup.Invoke(instance, emtpyObjArray);
+                            c.ClassCleanup.Invoke(instance, emptyObjArray);
                         }
                     }
                 }
@@ -79,6 +81,21 @@ where t.GetCustomAttribute<TestClassAttribute>() != null
         }
     }
 
+    public class UnitTestContext : TestContext
+    {
+        public override IDictionary<string, object> Properties => throw new NotImplementedException();
+
+        public override void WriteLine(string message)
+        {
+            Console.WriteLine(message);
+        }
+
+        public override void WriteLine(string format, params object[] args)
+        {
+            Console.WriteLine(format, args);
+        }
+    }
+
     public class NotReRunnableAttribute : Attribute
     {
 

neo.UnitTests/UT_ProtocolHandler.cs

@@ -0,0 +1,50 @@
+using Akka.TestKit.Xunit2;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Network.P2P;
+using Neo.Network.P2P.Capabilities;
+using Neo.Network.P2P.Payloads;
+
+namespace Neo.UnitTests
+{
+    [TestClass]
+    public class UT_ProtocolHandler : TestKit
+    {
+        private NeoSystem testBlockchain;
+
+        [TestCleanup]
+        public void Cleanup()
+        {
+            Shutdown();
+        }
+
+        [TestInitialize]
+        public void TestSetup()
+        {
+            testBlockchain = TestBlockchain.InitializeMockNeoSystem();
+        }
+
+        [TestMethod]
+        public void ProtocolHandler_Test_SendVersion_TellParent()
+        {
+            var senderProbe = CreateTestProbe();
+            var parent = CreateTestProbe();
+            var protocolActor = ActorOfAsTestActorRef(() => new ProtocolHandler(testBlockchain), parent);
+
+            var payload = new VersionPayload()
+            {
+                UserAgent = "".PadLeft(1024, '0'),
+                Nonce = 1,
+                Magic = 2,
+                Timestamp = 5,
+                Version = 6,
+                Capabilities = new NodeCapability[]
+                {
+                    new ServerCapability(NodeCapabilityType.TcpServer, 25)
+                }
+            };
+
+            senderProbe.Send(protocolActor, Message.Create(MessageCommand.Version, payload));
+            parent.ExpectMsg<VersionPayload>();
+        }
+    }
+}

neo.UnitTests/UT_RemoteNode.cs

@@ -0,0 +1,85 @@
+using Akka.IO;
+using Akka.TestKit.Xunit2;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Network.P2P;
+using Neo.Network.P2P.Capabilities;
+using Neo.Network.P2P.Payloads;
+
+namespace Neo.UnitTests
+{
+    [TestClass]
+    public class UT_RemoteNode : TestKit
+    {
+        private static NeoSystem testBlockchain;
+
+        public UT_RemoteNode()
+            : base($"remote-node-mailbox {{ mailbox-type: \"{typeof(RemoteNodeMailbox).AssemblyQualifiedName}\" }}" +
+                $"protocol-handler-mailbox {{ mailbox-type: \"{typeof(ProtocolHandlerMailbox).AssemblyQualifiedName}\" }}")
+        {
+        }
+
+        [ClassInitialize]
+        public static void TestSetup(TestContext ctx)
+        {
+            testBlockchain = TestBlockchain.InitializeMockNeoSystem();
+        }
+
+        [TestMethod]
+        public void RemoteNode_Test_Abort_DifferentMagic()
+        {
+            var connectionTestProbe = CreateTestProbe();
+            var remoteNodeActor = ActorOfAsTestActorRef(() => new RemoteNode(testBlockchain, connectionTestProbe, null, null));
+
+            connectionTestProbe.ExpectMsg<Tcp.Write>();
+
+            var payload = new VersionPayload()
+            {
+                UserAgent = "".PadLeft(1024, '0'),
+                Nonce = 1,
+                Magic = 2,
+                Timestamp = 5,
+                Version = 6,
+                Capabilities = new NodeCapability[]
+                {
+                    new ServerCapability(NodeCapabilityType.TcpServer, 25)
+                }
+            };
+
+            var testProbe = CreateTestProbe();
+            testProbe.Send(remoteNodeActor, payload);
+
+            connectionTestProbe.ExpectMsg<Tcp.Abort>();
+        }
+
+        [TestMethod]
+        public void RemoteNode_Test_Accept_IfSameMagic()
+        {
+            var connectionTestProbe = CreateTestProbe();
+            var remoteNodeActor = ActorOfAsTestActorRef(() => new RemoteNode(testBlockchain, connectionTestProbe, null, null));
+
+            connectionTestProbe.ExpectMsg<Tcp.Write>();
+
+            var payload = new VersionPayload()
+            {
+                UserAgent = "Unit Test".PadLeft(1024, '0'),
+                Nonce = 1,
+                Magic = ProtocolSettings.Default.Magic,
+                Timestamp = 5,
+                Version = 6,
+                Capabilities = new NodeCapability[]
+                {
+                    new ServerCapability(NodeCapabilityType.TcpServer, 25)
+                }
+            };
+
+            var testProbe = CreateTestProbe();
+            testProbe.Send(remoteNodeActor, payload);
+
+            var verackMessage = connectionTestProbe.ExpectMsg<Tcp.Write>();
+
+            //Verack
+            verackMessage.Data.Count.Should().Be(3);
+        }
+    }
+}