Unit Test for Wallets Module

neo.UnitTests/Network/P2P/Payloads/UT_Transaction.cs

@@ -84,24 +84,12 @@ public void Size_Get()
             uut.Size.Should().Be(83);
         }
 
-        private NEP6Wallet GenerateTestWallet()
-        {
-            JObject wallet = new JObject();
-            wallet["name"] = "noname";
-            wallet["version"] = new System.Version().ToString();
-            wallet["scrypt"] = new ScryptParameters(0, 0, 0).ToJson();
-            wallet["accounts"] = new JArray();
-            wallet["extra"] = null;
-            wallet.ToString().Should().Be("{\"name\":\"noname\",\"version\":\"0.0\",\"scrypt\":{\"n\":0,\"r\":0,\"p\":0},\"accounts\":[],\"extra\":null}");
-            return new NEP6Wallet(wallet);
-        }
-
         [TestMethod]
         public void FeeIsMultiSigContract()
         {
             var store = TestBlockchain.GetStore();
-            var walletA = GenerateTestWallet();
-            var walletB = GenerateTestWallet();
+            var walletA = TestUtils.GenerateTestWallet();
+            var walletB = TestUtils.GenerateTestWallet();
             var snapshot = store.GetSnapshot();
 
             using (var unlockA = walletA.Unlock("123"))
@@ -188,7 +176,7 @@ public void FeeIsMultiSigContract()
         [TestMethod]
         public void FeeIsSignatureContractDetailed()
         {
-            var wallet = GenerateTestWallet();
+            var wallet = TestUtils.GenerateTestWallet();
             var snapshot = store.GetSnapshot();
 
             using (var unlock = wallet.Unlock("123"))
@@ -303,7 +291,7 @@ public void FeeIsSignatureContractDetailed()
         [TestMethod]
         public void FeeIsSignatureContract_TestScope_Global()
         {
-            var wallet = GenerateTestWallet();
+            var wallet = TestUtils.GenerateTestWallet();
             var snapshot = store.GetSnapshot();
 
             // no password on this wallet
@@ -394,7 +382,7 @@ public void FeeIsSignatureContract_TestScope_Global()
         [TestMethod]
         public void FeeIsSignatureContract_TestScope_CurrentHash_GAS()
         {
-            var wallet = GenerateTestWallet();
+            var wallet = TestUtils.GenerateTestWallet();
             var snapshot = store.GetSnapshot();
 
             // no password on this wallet
@@ -486,7 +474,7 @@ public void FeeIsSignatureContract_TestScope_CurrentHash_GAS()
         [TestMethod]
         public void FeeIsSignatureContract_TestScope_CalledByEntry_Plus_GAS()
         {
-            var wallet = GenerateTestWallet();
+            var wallet = TestUtils.GenerateTestWallet();
             var snapshot = store.GetSnapshot();
 
             // no password on this wallet
@@ -581,7 +569,7 @@ public void FeeIsSignatureContract_TestScope_CalledByEntry_Plus_GAS()
         [TestMethod]
         public void FeeIsSignatureContract_TestScope_CurrentHash_NEO_FAULT()
         {
-            var wallet = GenerateTestWallet();
+            var wallet = TestUtils.GenerateTestWallet();
             var snapshot = store.GetSnapshot();
 
             // no password on this wallet
@@ -639,7 +627,7 @@ public void FeeIsSignatureContract_TestScope_CurrentHash_NEO_FAULT()
         [TestMethod]
         public void FeeIsSignatureContract_TestScope_CurrentHash_NEO_GAS()
         {
-            var wallet = GenerateTestWallet();
+            var wallet = TestUtils.GenerateTestWallet();
             var snapshot = store.GetSnapshot();
 
             // no password on this wallet
@@ -736,7 +724,7 @@ public void FeeIsSignatureContract_TestScope_CurrentHash_NEO_GAS()
         [TestMethod]
         public void FeeIsSignatureContract_TestScope_NoScopeFAULT()
         {
-            var wallet = GenerateTestWallet();
+            var wallet = TestUtils.GenerateTestWallet();
             var snapshot = store.GetSnapshot();
 
             // no password on this wallet
@@ -966,7 +954,7 @@ public void FeeIsSignatureContract_TestScope_Global_Default()
             Cosigner cosigner = new Cosigner();
             cosigner.Scopes.Should().Be(WitnessScope.Global);
 
-            var wallet = GenerateTestWallet();
+            var wallet = TestUtils.GenerateTestWallet();
             var snapshot = store.GetSnapshot();
 
             // no password on this wallet

neo.UnitTests/TestUtils.cs

@@ -1,6 +1,11 @@
-using Neo.IO;
+using FluentAssertions;
+using Neo.IO;
+using Neo.IO.Json;
+using Neo.Ledger;
 using Neo.Network.P2P.Payloads;
+using Neo.SmartContract.Manifest;
 using Neo.VM;
+using Neo.Wallets.NEP6;
 using System;
 using System.IO;
 
@@ -21,6 +26,18 @@ public static byte[] GetByteArray(int length, byte firstByte)
             return array;
         }
 
+        public static NEP6Wallet GenerateTestWallet()
+        {
+            JObject wallet = new JObject();
+            wallet["name"] = "noname";
+            wallet["version"] = new System.Version().ToString();
+            wallet["scrypt"] = new ScryptParameters(0, 0, 0).ToJson();
+            wallet["accounts"] = new JArray();
+            wallet["extra"] = null;
+            wallet.ToString().Should().Be("{\"name\":\"noname\",\"version\":\"0.0\",\"scrypt\":{\"n\":0,\"r\":0,\"p\":0},\"accounts\":[],\"extra\":null}");
+            return new NEP6Wallet(wallet);
+        }
+
         public static Transaction GetTransaction()
         {
             return new Transaction
@@ -37,6 +54,15 @@ public static Transaction GetTransaction()
             };
         }
 
+        internal static ContractState GetContract()
+        {
+            return new ContractState
+            {
+                Script = new byte[] { 0x01, 0x01, 0x01, 0x01 },
+                Manifest = ContractManifest.CreateDefault(UInt160.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff01"))
+            };
+        }
+
         public static void SetupHeaderWithValues(Header header, UInt256 val256, out UInt256 merkRootVal, out UInt160 val160, out ulong timestampVal, out uint indexVal, out Witness scriptVal)
         {
             setupBlockBaseWithValues(header, val256, out merkRootVal, out val160, out timestampVal, out indexVal, out scriptVal);
@@ -109,5 +135,13 @@ public static T CopyMsgBySerialization<T>(T serializableObj, T newObj) where T :
 
             return newObj;
         }
+
+        public static void DeleteFile(string file)
+        {
+            if (File.Exists(file))
+            {
+                File.Delete(file);
+            }
+        }
     }
-}
+}

neo.UnitTests/Wallets/NEP6/UT_NEP6Account.cs

@@ -0,0 +1,139 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Cryptography;
+using Neo.IO.Json;
+using Neo.SmartContract;
+using Neo.Wallets;
+using Neo.Wallets.NEP6;
+
+namespace Neo.UnitTests.Wallets.NEP6
+{
+    [TestClass]
+    public class UT_NEP6Account
+    {
+        NEP6Account account;
+        UInt160 hash;
+        NEP6Wallet wallet;
+        private static string nep2;
+        private static KeyPair keyPair;
+
+        [ClassInitialize]
+        public static void ClassSetup(TestContext context) {
+            byte[] privateKey = { 0x01,0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
+            keyPair = new KeyPair(privateKey);
+            nep2 = keyPair.Export("Satoshi", 0, 0, 0);
+        }
+
+        [TestInitialize]
+        public void TestSetup()
+        {
+            wallet = TestUtils.GenerateTestWallet();
+            byte[] array1 = { 0x01 };
+            hash = new UInt160(Crypto.Default.Hash160(array1));
+            account = new NEP6Account(wallet, hash);
+        }
+
+        [TestMethod]
+        public void TestConstructorWithNep2Key()
+        {
+            account.ScriptHash.Should().Be(hash);
+            account.Decrypted.Should().BeTrue();
+            account.HasKey.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void TestConstructorWithKeyPair()
+        {
+            NEP6Wallet wallet = new NEP6Wallet("a");
+            byte[] array1 = { 0x01 };
+            var hash = new UInt160(Crypto.Default.Hash160(array1));
+            string password = "hello world";
+            NEP6Account account = new NEP6Account(wallet, hash, keyPair, password);
+            account.ScriptHash.Should().Be(hash);
+            account.Decrypted.Should().BeTrue();
+            account.HasKey.Should().BeTrue();
+        }
+
+        [TestMethod]
+        public void TestFromJson()
+        {
+            JObject json = new JObject();
+            json["address"] = "ARxgjcH2K1yeW5f5ryuRQNaBzSa9TZzmVS";
+            json["key"] = null;
+            json["label"] = null;
+            json["isDefault"] = true;
+            json["lock"] = false;
+            json["contract"] = null;
+            json["extra"] = null;
+            NEP6Account account = NEP6Account.FromJson(json, wallet);
+            account.ScriptHash.Should().Be("ARxgjcH2K1yeW5f5ryuRQNaBzSa9TZzmVS".ToScriptHash());
+            account.Label.Should().BeNull();
+            account.IsDefault.Should().BeTrue();
+            account.Lock.Should().BeFalse();
+            account.Contract.Should().BeNull();
+            account.Extra.Should().BeNull();
+            account.GetKey().Should().BeNull();
+
+            json["key"] = "6PYRjVE1gAbCRyv81FTiFz62cxuPGw91vMjN4yPa68bnoqJtioreTznezn";
+            json["label"] = "label";
+            account = NEP6Account.FromJson(json, wallet);
+            account.Label.Should().Be("label");
+            account.HasKey.Should().BeTrue();
+        }
+
+        [TestMethod]
+        public void TestGetKey()
+        {
+            account.GetKey().Should().BeNull();
+            wallet.Unlock("Satoshi");
+            account = new NEP6Account(wallet, hash, nep2);
+            account.GetKey().Should().Be(keyPair);
+        }
+
+        [TestMethod]
+        public void TestGetKeyWithString()
+        {
+            account.GetKey("Satoshi").Should().BeNull();
+            account = new NEP6Account(wallet, hash, nep2);
+            account.GetKey("Satoshi").Should().Be(keyPair);
+        }
+
+        [TestMethod]
+        public void TestToJson()
+        {
+            JObject nep6contract = new JObject();
+            nep6contract["script"] = "2103603f3880eb7aea0ad4500893925e4a42fea48a44ee6f898a10b3c7ce05d2a267ac";
+            JObject parameters = new JObject();
+            parameters["type"] = 0x00;
+            parameters["name"] = "Sig";
+            JArray array = new JArray
+            {
+                parameters
+            };
+            nep6contract["parameters"] = array;
+            nep6contract["deployed"] = false;
+            account.Contract = NEP6Contract.FromJson(nep6contract);
+            JObject json = account.ToJson();
+            json["address"].Should().Equals("AZk5bAanTtD6AvpeesmYgL8CLRYUt5JQsX");
+            json["label"].Should().BeNull();
+            json["isDefault"].ToString().Should().Be("false");
+            json["lock"].ToString().Should().Be("false");
+            json["key"].Should().BeNull();
+            json["contract"]["script"].ToString().Should().Be("\"2103603f3880eb7aea0ad4500893925e4a42fea48a44ee6f898a10b3c7ce05d2a267ac\"");
+            json["extra"].Should().BeNull();
+
+            account.Contract = null;
+            json = account.ToJson();
+            json["contract"].Should().BeNull();
+        }
+
+        [TestMethod]
+        public void TestVerifyPassword()
+        {
+            account = new NEP6Account(wallet, hash, nep2);
+            account.VerifyPassword("Satoshi").Should().BeTrue();
+            account.VerifyPassword("b").Should().BeFalse();
+        }
+    }
+}

neo.UnitTests/Wallets/NEP6/UT_NEP6Contract.cs

@@ -0,0 +1,67 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.IO.Json;
+using Neo.SmartContract;
+using Neo.Wallets.NEP6;
+
+namespace Neo.UnitTests.Wallets.NEP6
+{
+    [TestClass]
+    public class UT_NEP6Contract
+    {
+        [TestMethod]
+        public void TestFromNullJson()
+        {
+            NEP6Contract nep6Contract = NEP6Contract.FromJson(null);
+            nep6Contract.Should().BeNull();
+        }
+
+        [TestMethod]
+        public void TestFromJson()
+        {
+            string json = "{\"script\":\"2103ef891df4c0b7eefb937d21ea0fb88cde8e0d82a7ff11872b5e7047969dafb4eb68747476aa\"," +
+                "\"parameters\":[{\"name\":\"signature\",\"type\":\"Signature\"}],\"deployed\":false}";
+            JObject @object = JObject.Parse(json);
+
+            NEP6Contract nep6Contract = NEP6Contract.FromJson(@object);
+            nep6Contract.Script.Should().BeEquivalentTo("2103ef891df4c0b7eefb937d21ea0fb88cde8e0d82a7ff11872b5e7047969dafb4eb68747476aa".HexToBytes());
+            nep6Contract.ParameterList.Length.Should().Be(1);
+            nep6Contract.ParameterList[0].Should().Be(ContractParameterType.Signature);
+            nep6Contract.ParameterNames.Length.Should().Be(1);
+            nep6Contract.ParameterNames[0].Should().Be("signature");
+            nep6Contract.Deployed.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void TestToJson()
+        {
+            NEP6Contract nep6Contract = new NEP6Contract()
+            {
+                Script = new byte[] { 0x00, 0x01 },
+                ParameterList = new ContractParameterType[] { ContractParameterType.Boolean, ContractParameterType.Integer },
+                ParameterNames = new string[] { "param1", "param2" },
+                Deployed = false
+            };
+
+            JObject @object = nep6Contract.ToJson();
+            JString jString = (JString)@object["script"];
+            jString.Value.Should().Be(nep6Contract.Script.ToHexString());
+
+            JBoolean jBoolean = (JBoolean)@object["deployed"];
+            jBoolean.Value.Should().BeFalse();
+
+            JArray parameters = (JArray)@object["parameters"];
+            parameters.Count.Should().Be(2);
+
+            jString = (JString)(parameters[0]["name"]);
+            jString.Value.Should().Be("param1");
+            jString = (JString)(parameters[0]["type"]);
+            jString.Value.Should().Be(ContractParameterType.Boolean.ToString());
+
+            jString = (JString)(parameters[1]["name"]);
+            jString.Value.Should().Be("param2");
+            jString = (JString)(parameters[1]["type"]);
+            jString.Value.Should().Be(ContractParameterType.Integer.ToString());
+        }
+    }
+}