dBFT 2.0

neo.UnitTests/TestBlockchain.cs

@@ -0,0 +1,65 @@
+using Moq;
+using Neo.Cryptography.ECC;
+using Neo.IO.Wrappers;
+using Neo.Ledger;
+using Neo.Persistence;
+using System;
+
+namespace Neo.UnitTests
+{
+    public static class TestBlockchain
+    {
+        private static NeoSystem TheNeoSystem;
+
+        public static NeoSystem InitializeMockNeoSystem()
+        {
+            if (TheNeoSystem == null)
+            {
+                var mockSnapshot = new Mock<Snapshot>();
+                mockSnapshot.SetupGet(p => p.Blocks).Returns(new TestDataCache<UInt256, BlockState>());
+                mockSnapshot.SetupGet(p => p.Transactions).Returns(new TestDataCache<UInt256, TransactionState>());
+                mockSnapshot.SetupGet(p => p.Accounts).Returns(new TestDataCache<UInt160, AccountState>());
+                mockSnapshot.SetupGet(p => p.UnspentCoins).Returns(new TestDataCache<UInt256, UnspentCoinState>());
+                mockSnapshot.SetupGet(p => p.SpentCoins).Returns(new TestDataCache<UInt256, SpentCoinState>());
+                mockSnapshot.SetupGet(p => p.Validators).Returns(new TestDataCache<ECPoint, ValidatorState>());
+                mockSnapshot.SetupGet(p => p.Assets).Returns(new TestDataCache<UInt256, AssetState>());
+                mockSnapshot.SetupGet(p => p.Contracts).Returns(new TestDataCache<UInt160, ContractState>());
+                mockSnapshot.SetupGet(p => p.Storages).Returns(new TestDataCache<StorageKey, StorageItem>());
+                mockSnapshot.SetupGet(p => p.HeaderHashList)
+                    .Returns(new TestDataCache<UInt32Wrapper, HeaderHashList>());
+                mockSnapshot.SetupGet(p => p.ValidatorsCount).Returns(new TestMetaDataCache<ValidatorsCountState>());
+                mockSnapshot.SetupGet(p => p.BlockHashIndex).Returns(new TestMetaDataCache<HashIndexState>());
+                mockSnapshot.SetupGet(p => p.HeaderHashIndex).Returns(new TestMetaDataCache<HashIndexState>());
+
+                var mockStore = new Mock<Store>();
+
+                var defaultTx = TestUtils.CreateRandomHashInvocationMockTransaction().Object;
+                mockStore.Setup(p => p.GetBlocks()).Returns(new TestDataCache<UInt256, BlockState>());
+                mockStore.Setup(p => p.GetTransactions()).Returns(new TestDataCache<UInt256, TransactionState>(
+                    new TransactionState
+                    {
+                        BlockIndex = 1,
+                        Transaction = defaultTx
+                    }));
+
+                mockStore.Setup(p => p.GetAccounts()).Returns(new TestDataCache<UInt160, AccountState>());
+                mockStore.Setup(p => p.GetUnspentCoins()).Returns(new TestDataCache<UInt256, UnspentCoinState>());
+                mockStore.Setup(p => p.GetSpentCoins()).Returns(new TestDataCache<UInt256, SpentCoinState>());
+                mockStore.Setup(p => p.GetValidators()).Returns(new TestDataCache<ECPoint, ValidatorState>());
+                mockStore.Setup(p => p.GetAssets()).Returns(new TestDataCache<UInt256, AssetState>());
+                mockStore.Setup(p => p.GetContracts()).Returns(new TestDataCache<UInt160, ContractState>());
+                mockStore.Setup(p => p.GetStorages()).Returns(new TestDataCache<StorageKey, StorageItem>());
+                mockStore.Setup(p => p.GetHeaderHashList()).Returns(new TestDataCache<UInt32Wrapper, HeaderHashList>());
+                mockStore.Setup(p => p.GetValidatorsCount()).Returns(new TestMetaDataCache<ValidatorsCountState>());
+                mockStore.Setup(p => p.GetBlockHashIndex()).Returns(new TestMetaDataCache<HashIndexState>());
+                mockStore.Setup(p => p.GetHeaderHashIndex()).Returns(new TestMetaDataCache<HashIndexState>());
+                mockStore.Setup(p => p.GetSnapshot()).Returns(mockSnapshot.Object);
+
+                Console.WriteLine("initialize NeoSystem");
+                TheNeoSystem = new NeoSystem(mockStore.Object); // new Mock<NeoSystem>(mockStore.Object);
+            }
+
+            return TheNeoSystem;
+        }
+    }
+}

neo.UnitTests/TestUtils.cs

@@ -1,14 +1,21 @@
-using Neo.Cryptography.ECC;
+using Moq;
+using Neo.Cryptography.ECC;
+using Neo.IO;
 using Neo.Network.P2P.Payloads;
+using Neo.Persistence;
 using Neo.VM;
 using System;
+using System.Collections.Generic;
+using System.IO;
 
 namespace Neo.UnitTests
 {
     public static class TestUtils
     {
+        public static readonly Random TestRandom = new Random(1337); // use fixed seed for guaranteed determinism
+
         public static byte[] GetByteArray(int length, byte firstByte)
-        {            
+        {
             byte[] array = new byte[length];
             array[0] = firstByte;
             for (int i = 1; i < length; i++)
@@ -95,5 +102,50 @@ private static void setupBlockBaseWithValues(BlockBase bb, UInt256 val256, out U
             };
             bb.Witness = scriptVal;
         }
-    }    
+
+        public static Mock<InvocationTransaction> CreateRandomHashInvocationMockTransaction()
+        {
+            var mockTx = new Mock<InvocationTransaction>
+            {
+                CallBase = true
+            };
+            mockTx.Setup(p => p.Verify(It.IsAny<Snapshot>(), It.IsAny<IEnumerable<Transaction>>())).Returns(true);
+            var tx = mockTx.Object;
+            var randomBytes = new byte[16];
+            TestRandom.NextBytes(randomBytes);
+            tx.Script = randomBytes;
+            tx.Attributes = new TransactionAttribute[0];
+            tx.Inputs = new CoinReference[0];
+            tx.Outputs = new TransactionOutput[0];
+            tx.Witnesses = new Witness[0];
+
+            return mockTx;
+        }
+
+        public static Mock<MinerTransaction> CreateRandomMockMinerTransaction()
+        {
+            var mockTx = new Mock<MinerTransaction>
+            {
+                CallBase = true
+            };
+            var tx = mockTx.Object;
+            tx.Attributes = new TransactionAttribute[0];
+            tx.Inputs = new CoinReference[0];
+            tx.Outputs = new TransactionOutput[0];
+            tx.Witnesses = new Witness[0];
+            tx.Nonce = (uint)TestRandom.Next();
+            return mockTx;
+        }
+
+        public static T CopyMsgBySerialization<T>(T serializableObj, T newObj) where T : ISerializable
+        {
+            using (MemoryStream ms = new MemoryStream(serializableObj.ToArray(), false))
+            using (BinaryReader reader = new BinaryReader(ms))
+            {
+                newObj.Deserialize(reader);
+            }
+
+            return newObj;
+        }
+    }
 }