public void Start_ValidNetworkConfiguration_ConnectToPeerAsStartListeningForPeers()
{
// Arrange
var peerListenerMock = AutoMockContainer.GetMock <IPeerListener>();
var peerMessageListenerMock = AutoMockContainer.GetMock <IPeerMessageListener>();
var peerMock = AutoMockContainer.GetMock <IPeer>();
peerMock
.SetupGet(x => x.EndPoint)
.Returns(_peerEndPoint);
var peer = peerMock.Object;
var peerFactoryMock = AutoMockContainer.GetMock <IPeerFactory>();
peerFactoryMock
.Setup(x => x.ConnectTo(_peerEndPoint))
.Returns(Task.FromResult(peer));
var serverContextMock = this.AutoMockContainer.GetMock <IServerContext>();
serverContextMock
.SetupGet(x => x.ConnectedPeers)
.Returns(new ConcurrentDictionary <EndPoint, IPeer>());
var server = AutoMockContainer.Create <Server>();
// Act
server.Start();
// Assert
peerFactoryMock.Verify(x => x.ConnectTo(_peerEndPoint), Times.Once);
peerListenerMock.Verify(x => x.Start(), Times.Once);
peerMessageListenerMock.Verify(x => x.StartFor(peer, It.IsAny <CancellationToken>()), Times.Once);
}
public void SendBroadcast_PeerIsNotTheSameAsSource_MessageSendToPeer()
{
// Arrange
var peerMockSource = new Mock <IPeer>();
peerMockSource
.SetupGet(x => x.EndPoint)
.Returns(new EndPoint(Protocol.Tcp, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8000)));
var peerMockNotSource = new Mock <IPeer>();
peerMockNotSource
.SetupGet(x => x.EndPoint)
.Returns(new EndPoint(Protocol.Tcp, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8001)));
var connectedPeers = new ConcurrentDictionary <EndPoint, IPeer>();
connectedPeers.TryAdd(peerMockSource.Object.EndPoint, peerMockSource.Object);
connectedPeers.TryAdd(peerMockNotSource.Object.EndPoint, peerMockNotSource.Object);
this.AutoMockContainer
.GetMock <IServerContext>()
.SetupGet(x => x.ConnectedPeers)
.Returns(connectedPeers);
var server = AutoMockContainer.Create <Server>();
var message = new Message();
// Act
server.Broadcast(message, peerMockSource.Object);
// Assert
peerMockSource.Verify(x => x.Send(message), Times.Never);
peerMockNotSource.Verify(x => x.Send(message), Times.Once);
}
public void Start_PeerIsNotAllowed_WarningLoggedAndPeerDisconnected()
{
// Arrange
var networkAcl = new NetworkAcl(NetworkAclType.Blacklist, new[] { new NetworkAcl.Entry("localhost") });
var networkAclLoaderMock = this.AutoMockContainer.GetMock <INetworkAclLoader>();
networkAclLoaderMock
.Setup(x => x.Load(It.IsAny <NetworkAclConfig>()))
.Returns(networkAcl);
var loggerMock = this.AutoMockContainer.GetMock <ILogger <Server> >();
var peerMock = AutoMockContainer.GetMock <IPeer>();
peerMock
.SetupGet(x => x.EndPoint)
.Returns(_peerEndPoint);
var peer = peerMock.Object;
var peerFactoryMock = AutoMockContainer.GetMock <IPeerFactory>();
peerFactoryMock
.Setup(x => x.ConnectTo(_peerEndPoint))
.Returns(Task.FromResult(peer));
var server = AutoMockContainer.Create <Server>();
// Act
server.Start();
// Assert
loggerMock.Verify(x => x.LogWarning(It.Is <string>(s => s.StartsWith("Something went wrong with "))), Times.Once);
peerMock.Verify(x => x.Disconnect(), Times.Once);
}
public async Task GetBlockHashFromHeight_HashFound_ReturnValidUInt256()
{
// Arrange
const uint heightParameter = 0;
var heightByteArray = heightParameter.BuildIxHeightToHashKey();
var byteArrayParameter = new byte[]
{
157, 179, 60, 8, 66, 122, 255, 105, 126, 49, 180, 74, 212, 41, 126, 177, 14, 255, 59, 82, 218, 113, 248,
145, 98, 5, 128, 140, 42, 70, 32, 69
};
var expectedUint256 = UInt256.Parse("0x4520462a8c80056291f871da523bff0eb17e29d44ab4317e69ff7a42083cb39d");
var rocksDbContextMock = AutoMockContainer.GetMock <IRocksDbContext>();
rocksDbContextMock
.Setup(x => x.Get(It.Is <byte[]>(a =>
a.Where((b, i) => b == heightByteArray[i]).Count() == heightByteArray.Length)))
.ReturnsAsync(byteArrayParameter);
var testee = AutoMockContainer.Create <RocksDbRepository>();
// Act
var result = await testee.GetBlockHashFromHeight(heightParameter);
// Assert
result
.Should()
.BeEquivalentTo(expectedUint256);
}
public async Task SetIndexClaimable_WritesCorrectKeyValue()
{
var inputHash = UInt160.Parse(RandomInt().ToString("X40"));
var expectedKey = inputHash.BuildIndexClaimableKey();
var inputReferences = new List <CoinReference>
{
new CoinReference
{
PrevHash = UInt256.Parse(RandomInt().ToString("X64")),
PrevIndex = (ushort)RandomInt(10)
},
new CoinReference
{
PrevHash = UInt256.Parse(RandomInt().ToString("X64")),
PrevIndex = (ushort)RandomInt(10)
}
}.ToHashSet();
var expectedBytes = new byte[1];
_serializerMock
.Setup(m => m.Serialize(It.Is <HashSet <CoinReference> >(arr => arr.SetEquals(inputReferences)), null))
.Returns(expectedBytes);
var rocksDbContextMock = AutoMockContainer.GetMock <IRocksDbContext>();
var testee = AutoMockContainer.Create <RocksDbRepository>();
await testee.SetIndexClaimable(inputHash, inputReferences);
rocksDbContextMock.Verify(m => m.Save(expectedKey, expectedBytes));
}
public async Task SetIndexConfirmed_WritesCorrectKeyValue()
{
var inputHash = UInt160.Parse(RandomInt().ToString("X40"));
var expectedKey = inputHash.BuildIxConfirmedKey();
var inputReferences = new List <CoinReference>
{
new CoinReference
{
PrevHash = UInt256.Parse(RandomInt().ToString("X64")),
PrevIndex = (ushort)RandomInt(10)
},
new CoinReference
{
PrevHash = UInt256.Parse(RandomInt().ToString("X64")),
PrevIndex = (ushort)RandomInt(10)
}
}.ToHashSet();
var expectedBytes = new byte[1];
_serializerMock
.Setup(m => m.Serialize(It.Is <CoinReference[]>(arr => arr.SequenceEqual(inputReferences.ToArray())), null))
.Returns(expectedBytes);
var redisDbContextMock = AutoMockContainer.GetMock <IRedisDbContext>();
var testee = AutoMockContainer.Create <RedisDbBinaryRepository>();
await testee.SetIndexConfirmed(inputHash, inputReferences);
redisDbContextMock.Verify(m => m.Set(It.Is <RedisKey>(b => b.Equals(expectedKey)), It.Is <RedisValue>(b => b.Equals(expectedBytes))));
}
public async Task UpdateBalance_ChangesBalanceByDelta()
{
var acctHash = UInt160.Parse(RandomInt().ToString("X40"));
var assetId = UInt256.Parse(RandomInt().ToString("X64"));
var change = RandomInt(1) == 0 ? RandomInt() : -RandomInt();
var originalBalance = RandomInt();
var expectedBalance = originalBalance + change;
var acct = new Account
{
ScriptHash = UInt160.Parse(RandomInt().ToString("X40")),
Balances = new Dictionary <UInt256, Fixed8>
{
{ assetId, new Fixed8(originalBalance) }
}
};
var repositoryMock = AutoMockContainer.GetMock <IRepository>();
repositoryMock.Setup(m => m.GetAccount(acctHash)).ReturnsAsync(acct);
var testee = AutoMockContainer.Create <AccountManager>();
await testee.UpdateBalance(acctHash, assetId, new Fixed8(change));
repositoryMock.Verify(m => m.AddAccount(It.Is <Account>(a =>
a.ScriptHash.Equals(acct.ScriptHash) && a.Balances[assetId].Equals(new Fixed8(expectedBalance)))));
}
public void Can_delegate_message_handling()
{
// Arrange
var serverContextMock = AutoMockContainer
.GetMock <IServerContext>()
.SetupDefaultServerContext();
var containerMock = AutoMockContainer.GetMock <IContainer>();
containerMock
.Setup(c => c.Resolve(It.IsAny <Type>()))
.Returns(() => new NullVersionMessageHandler());
var loggerMock = AutoMockContainer.GetMock <ILogger <MessageHandlerProxy> >();
var messageHandlerProxy = new MessageHandlerProxy(containerMock.Object, new[] { typeof(NullVersionMessageHandler) }, loggerMock.Object);
// Act
var task = messageHandlerProxy.Handle(new VersionMessage(serverContextMock.Object.Version), null);
task.Wait();
// Assert
task.IsCompletedSuccessfully.Should().Be(true);
}
public async Task Persist_AccountStateDescriptor_UpdateVotes()
{
var scriptHash = new UInt160(RandomByteArray(20));
var value = new byte[1];
var input = new StateTransaction
{
Descriptors = new[]
{
new StateDescriptor
{
Type = StateType.Account,
Field = "Votes",
Key = scriptHash.ToArray(),
Value = value
}
}
};
var ecpoints = new ECPoint[0];
var deserializerMock = AutoMockContainer.GetMock <IBinarySerializer>();
deserializerMock.Setup(m => m.Deserialize <ECPoint[]>(value, null)).Returns(ecpoints);
var accountManagerMock = AutoMockContainer.GetMock <IAccountManager>();
var testee = AutoMockContainer.Create <StateTransactionPersister>();
await testee.Persist(input);
accountManagerMock.Verify(m => m.UpdateVotes(It.Is <UInt160>(u => u.Equals(scriptHash)), ecpoints));
}
protected override void Register(AutoMockContainer container)
{
base.Register(container);
Config.KeyInfoServer = null;
Config.AutoApproveKeys = false;
}
public void BaseSetup()
{
var mockRepository = new MockRepository(MockBehavior.Default);
autoMockContainer = new AutoMockContainer(mockRepository);
subjectObj = null;
}
public void Can_handle_handshake_different_once_error_while_connecting_to_peer()
{
// Arrange
AutoMockContainer.Register(GetNetworkConfig("tcp://localhost:8081"));
var peerMock = AutoMockContainer.GetMock <IPeer>();
peerMock.Setup(x => x.Receive <VersionMessage>())
.Returns(() =>
{
var peerVersionMessage = new VersionMessage();
peerVersionMessage.Payload.Nonce = 0;
return(Task.FromResult(peerVersionMessage));
});
var peerFactoryMock = AutoMockContainer.GetMock <IPeerFactory>();
peerFactoryMock.Setup(x => x.ConnectTo(It.IsAny <EndPoint>())).Returns(Task.FromResult(peerMock.Object));
var server = AutoMockContainer.Create <Server>();
// Act
server.Start();
Task.Delay(100).Wait();
// Asset
peerMock.Verify(x => x.Send(new VerAckMessage()), Times.Never);
}
protected override void Register(AutoMockContainer container)
{
_feedManagerMock = container.GetMock <IFeedManager>();
_packageManagerMock = container.GetMock <IPackageManager>();
base.Register(container);
}
public async Task GetIndexConfirmed_BinaryValueFound_ReturnsValue()
{
var input = UInt160.Parse(RandomInt().ToString("X40"));
var expectedBytes = new byte[1];
var expectedSet = new HashSet <CoinReference>
{
new CoinReference
{
PrevHash = UInt256.Parse(RandomInt().ToString("X64")),
PrevIndex = 0
},
new CoinReference
{
PrevHash = UInt256.Parse(RandomInt().ToString("X64")),
PrevIndex = 0
}
};
var contextMock = AutoMockContainer.GetMock <IRedisDbContext>();
contextMock.Setup(m => m.Get(input.BuildIxConfirmedKey())).ReturnsAsync(expectedBytes);
var deserializerMock = AutoMockContainer.GetMock <IBinaryDeserializer>();
deserializerMock.Setup(m => m.Deserialize <HashSet <CoinReference> >(expectedBytes, null))
.Returns(expectedSet);
var testee = AutoMockContainer.Create <RedisDbBinaryRepository>();
BinaryDeserializer.Initialize(deserializerMock.Object);
var result = await testee.GetIndexConfirmed(input);
result.SetEquals(expectedSet).Should().BeTrue();
}
public async Task Persist_MinerTx_NoSpecialCalls()
{
var input = new MinerTransaction();
var testee = AutoMockContainer.Create <TransactionPersister>();
await testee.Persist(input);
}
public async Task Persist_ValidatorStateDescriptor_NewValidator()
{
var pubKey = new byte[33];
pubKey[0] = 0x02;
var input = new StateTransaction
{
Descriptors = new[]
{
new StateDescriptor
{
Type = StateType.Validator,
Key = pubKey,
Field = "Registered",
Value = new byte[] { 0x01 }
}
}
};
var repositoryMock = AutoMockContainer.GetMock <IRepository>();
repositoryMock.Setup(m => m.GetValidator(It.Is <ECPoint>(p => p.CompareTo(new ECPoint(pubKey)) == 0)))
.ReturnsAsync((Validator)null);
var testee = AutoMockContainer.Create <StateTransactionPersister>();
await testee.Persist(input);
repositoryMock.Verify(m => m.AddValidator(It.Is <Validator>(v =>
v.PublicKey.CompareTo(new ECPoint(pubKey)) == 0 &&
v.Registered &&
v.Votes.Equals(Fixed8.Zero))));
}
public async Task Process_AddsContract()
{
var pubKey = new byte[33];
pubKey[0] = 0x02;
var input = new RegisterTransaction
{
Hash = UInt256.Parse(RandomInt().ToString("X64")),
AssetType = (AssetType)RandomInt(16),
Name = RandomString(10),
Amount = new Fixed8(RandomInt()),
Precision = (byte)RandomInt(8),
Owner = new ECPoint(pubKey),
Admin = UInt160.Parse(RandomInt().ToString("X40"))
};
var repositoryMock = AutoMockContainer.GetMock <IRepository>();
var testee = AutoMockContainer.Create <RegisterTransactionProcessor>();
await testee.Process(input);
repositoryMock.Verify(m => m.AddAsset(It.Is <Asset>(a =>
a.Id.Equals(input.Hash) &&
a.AssetType.Equals(input.AssetType) &&
a.Name == input.Name &&
a.Amount.Equals(input.Amount) &&
a.Precision == input.Precision &&
a.Owner.CompareTo(input.Owner) == 0 &&
a.Admin.Equals(input.Admin))));
}
public void TestGetTransactions_WhenSetCorrectCriteria_ThenAllCriteriaShouldSetToRepositoryCorrectly()
{
// Arrange
var expectedCurrentcy = "THB";
var expectedStatusCode = "A";
var expectedFromDate = "20201220";
var expectedToDate = "20201020";
var dataFormat = "yyyyMMdd";
AutoMockContainer.Mock <ITransactionRepository>()
.Setup(x => x.GetTransactionBySearchCriteria(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DateTime?>(), It.IsAny <DateTime?>()))
.Callback <string, string, DateTime?, DateTime?>((currentcy, statusCode, fromDate, toDate) =>
{
// Assert
Assert.AreEqual(expectedCurrentcy, currentcy);
Assert.AreEqual(expectedStatusCode, statusCode);
Assert.AreEqual(expectedFromDate, fromDate.Value.ToString(dataFormat));
Assert.AreEqual(expectedToDate, toDate.Value.ToString(dataFormat));
}).ReturnsAsync(It.IsAny <List <TransactionEntity> >());
var transactionManager = AutoMockContainer.Create <TransactionManager>();
// Act
transactionManager.GetTransactions(expectedCurrentcy, expectedStatusCode, expectedFromDate, expectedToDate, dataFormat).Wait();
}
public void Verify_WithPrevBlockHeaderVerifyWitnessFail()
{
var testee = AutoMockContainer.Create <BlockOperationManager>();
var block = new Block
{
PreviousBlockHash = UInt256.Parse("7ee8170d86de43d6c105699273f9b82d077180e5e0f8e4d942f43d7804cc54d3"),
Index = 3,
Timestamp = 111,
Witness = new Witness()
};
var prevBlockHeader = new BlockHeader
{
Index = 2,
Timestamp = 110
};
this.AutoMockContainer
.GetMock <IBlockRepository>()
.Setup(b => b.GetBlockHeader(block.PreviousBlockHash))
.ReturnsAsync(() => prevBlockHeader);
this.AutoMockContainer
.GetMock <IWitnessOperationsManager>()
.Setup(b => b.Verify(block.Witness))
.Returns(() => false);
var result = testee.Verify(block);
result.Should().BeFalse();
}
public void Dispose_ServerIsRunning_StopListenerAndDisconnectPeer()
{
// Arrange
var peerMessageListenerMock = AutoMockContainer.GetMock <IPeerMessageListener>();
var peerMock = AutoMockContainer.GetMock <IPeer>();
peerMock
.SetupGet(x => x.EndPoint)
.Returns(_peerEndPoint);
var peerFactoryMock = AutoMockContainer.GetMock <IPeerFactory>();
peerFactoryMock
.Setup(x => x.ConnectTo(_peerEndPoint))
.Returns(Task.FromResult(peerMock.Object));
var peerListenerMock = AutoMockContainer.GetMock <IPeerListener>();
var server = AutoMockContainer.Create <Server>();
var serverContextMock = this.AutoMockContainer.GetMock <IServerContext>();
serverContextMock
.SetupGet(x => x.ConnectedPeers)
.Returns(new ConcurrentDictionary <EndPoint, IPeer>());
// Act
server.Start();
server.Dispose();
// Assert
peerListenerMock.Verify(x => x.Start(), Times.Once);
peerMessageListenerMock.Verify(x => x.StartFor(peerMock.Object, It.IsAny <CancellationToken>()), Times.Once);
peerMock.Verify(x => x.Disconnect(), Times.Once);
peerListenerMock.Verify(x => x.Stop(), Times.AtLeastOnce);
}
public async Task Handle_VerAckMessageReceived_PeerIsReady()
{
// Arrange
var verAckMessage = new VerAckMessage();
var version = new VersionPayload
{
CurrentBlockIndex = 1
};
var peerMock = AutoMockContainer.GetMock <IPeer>();
peerMock.SetupProperty(x => x.IsReady, false);
peerMock.SetupProperty(x => x.Version, version);
var expectedLastBlockHeader = new BlockHeader(HeaderType.Header)
{
Index = 1
};
this.AutoMockContainer
.GetMock <IBlockchainContext>()
.SetupGet(x => x.LastBlockHeader)
.Returns(expectedLastBlockHeader);
var messageHandler = AutoMockContainer.Get <VerAckMessageHandler>();
// Act
await messageHandler.Handle(verAckMessage, peerMock.Object);
// Assert
peerMock.Object.IsReady
.Should()
.BeTrue();
}
public void Broadcast_PeerIsTheSameAsSource_MessageNotSendToPeer()
{
// Arrange
var peerMock = new Mock <IPeer>();
peerMock
.SetupGet(x => x.EndPoint)
.Returns(_peerEndPoint);
var connectedPeers = new ConcurrentDictionary <EndPoint, IPeer>();
connectedPeers.TryAdd(peerMock.Object.EndPoint, peerMock.Object);
this.AutoMockContainer
.GetMock <IServerContext>()
.SetupGet(x => x.ConnectedPeers)
.Returns(connectedPeers);
var server = AutoMockContainer.Create <Server>();
var message = new Message();
// Act
server.Broadcast(message, peerMock.Object);
// Assert
peerMock.Verify(x => x.Send(message), Times.Never);
}
public async Task GetIndexClaimable_ValueFound_ReturnsFilledSet()
{
var input = UInt160.Parse(RandomInt().ToString("X40"));
var expectedBytes = new byte[1];
var expectedReferences = new List <CoinReference>
{
new CoinReference
{
PrevHash = UInt256.Parse(RandomInt().ToString("X64")),
PrevIndex = (ushort)RandomInt(10)
},
new CoinReference
{
PrevHash = UInt256.Parse(RandomInt().ToString("X64")),
PrevIndex = (ushort)RandomInt(10)
}
}.ToHashSet();
var rocksDbContextMock = AutoMockContainer.GetMock <IRocksDbContext>();
rocksDbContextMock
.Setup(m => m.Get(It.Is <byte[]>(b => b.SequenceEqual(input.BuildIndexClaimableKey()))))
.ReturnsAsync(expectedBytes);
_serializerMock
.Setup(m => m.Deserialize <HashSet <CoinReference> >(expectedBytes, null))
.Returns(expectedReferences);
var testee = AutoMockContainer.Create <RocksDbRepository>();
var result = await testee.GetIndexClaimable(input);
result.Should().BeOfType <HashSet <CoinReference> >();
result.Count.Should().Be(expectedReferences.Count);
result.SetEquals(expectedReferences).Should().BeTrue();
}
public async Task Persist_Transaction_Errors()
{
var input = new Transaction();
var testee = AutoMockContainer.Create <TransactionPersister>();
await testee.Persist(input);
}
public async Task Persist_TransactionWithOutputs_GainOutputs()
{
var input = new ContractTransaction
{
Hash = UInt256.Parse(RandomInt().ToString("X64")),
Outputs = new TransactionOutput[3]
};
for (var i = 0; i < input.Outputs.Length; i++)
{
input.Outputs[i] = new TransactionOutput
{
AssetId = UInt256.Parse(RandomInt().ToString("X64")),
ScriptHash = UInt160.Parse(RandomInt().ToString("X40")),
Value = new Fixed8(RandomInt())
}
}
;
var accountManagerMock = AutoMockContainer.GetMock <IAccountManager>();
var repositoryMock = AutoMockContainer.GetMock <IRepository>();
var testee = AutoMockContainer.Create <TransactionPersister>();
await testee.Persist(input);
foreach (var expectedOutput in input.Outputs)
{
accountManagerMock.Verify(m =>
m.UpdateBalance(expectedOutput.ScriptHash, expectedOutput.AssetId, expectedOutput.Value));
}
repositoryMock.Verify(m => m.AddCoinStates(input.Hash,
It.Is <CoinState[]>(cs => cs.Length == input.Outputs.Length && cs.All(c => c.Equals(CoinState.New)))));
}
public async Task Persist_AddContract()
{
var input = new PublishTransaction
{
Script = RandomByteArray(10),
Description = RandomString(10),
ReturnType = (ContractParameterType)RandomInt(10),
ParameterList = new[] { (ContractParameterType)RandomInt(10), (ContractParameterType)RandomInt(10) },
Name = RandomString(10),
Version = (byte)RandomInt(10),
Author = RandomString(10),
Email = RandomString(10)
};
var repositoryMock = AutoMockContainer.GetMock <IRepository>();
var testee = AutoMockContainer.Create <PublishTransactionPersister>();
await testee.Persist(input);
repositoryMock.Verify(m => m.AddContract(It.Is <Contract>(c =>
c.Code != null &&
c.Code.ScriptHash.Equals(input.Script.ToScriptHash()) &&
c.Code.Script == input.Script &&
c.Code.ReturnType == input.ReturnType &&
c.Code.Parameters == input.ParameterList &&
c.Name == input.Name &&
c.Version == input.CodeVersion &&
c.Author == input.Author &&
c.Email == input.Email &&
c.Description == input.Description)));
}
public async Task Can_activate_peer_on_verack_receiving()
{
// Arrange
var blockchain = new NullBlockchain();
AutoMockContainer.Register <IBlockchain>(blockchain);
var verAckMessage = new VerAckMessage();
var version = new VersionPayload();
var peerMock = AutoMockContainer.GetMock <IPeer>();
peerMock.SetupProperty(x => x.IsReady, false);
peerMock.SetupProperty(x => x.Version, version);
blockchain.LastBlockHeader.Index = 1;
version.CurrentBlockIndex = 1;
var messageHandler = AutoMockContainer.Get <VerAckMessageHandler>();
// Act
await messageHandler.Handle(verAckMessage, peerMock.Object);
// Assert
peerMock.Object.IsReady.Should().BeTrue();
}
public async Task Can_send_get_block_headers_message_if_peer_block_header_height_is_different()
{
// Arrange
var blockHeader = new BlockHeader()
{
Index = 1,
Hash = UInt256.Zero
};
var blockchainMock = this.AutoMockContainer.GetMock <IBlockchain>();
blockchainMock
.SetupGet(x => x.LastBlockHeader)
.Returns(blockHeader);
var verAckMessage = new VerAckMessage();
var version = new VersionPayload();
var peerMock = AutoMockContainer.GetMock <IPeer>();
peerMock.SetupProperty(x => x.Version, version);
version.CurrentBlockIndex = 2;
var messageHandler = AutoMockContainer.Get <VerAckMessageHandler>();
// Act
await messageHandler.Handle(verAckMessage, peerMock.Object);
// Assert
// TODO: This need to evaluate correctly that the right GetBlockHeadersMessage is been generated.
peerMock.Verify(x => x.Send(It.IsAny <GetBlockHeadersMessage>()), Times.Once);
}
public void Verify_WithInputsWithSamePrevHashAndPrevIndex()
{
var testee = AutoMockContainer.Create <TransactionOperationManager>();
var transaction = new Transaction
{
Attributes = new []
{
new TransactionAttribute
{
Usage = TransactionAttributeUsage.ContractHash
}
},
Inputs = new[]
{
new CoinReference
{
PrevHash = UInt256.Zero,
PrevIndex = 1
},
new CoinReference
{
PrevHash = UInt256.Zero,
PrevIndex = 1
}
}
};
var result = testee.Verify(transaction);
result.Should().BeFalse();
}
public void Initalize()
{
_factory = new MockRepository(MockBehavior.Loose);
_container = new AutoMockContainer(_factory);
_coins = new List<Coin>();
_purchaseServiceMock = _container.GetMock<IPurchaseService>();
var product_a = new Product() { Price = 1, Title = "Apple" };
var product_b = new Product() { Price = .75m, Title = "Banana" };
var slot_a = new Slot() { Button = "A", Product = product_a, MaxNumberOfProduct = 5, Quantity = 4 };
var slot_b = new Slot() { Button = "B", Product = product_b, MaxNumberOfProduct = 5, Quantity = 0 };
_dollar = new Coin() { Title = "One Dollar", Value = 1, ShortName = "O" };
_quarter = new Coin() { Title = "Quarter", Value = .25m, ShortName = "Q" };
_dime = new Coin() { Title = "Dime", Value = .1m, ShortName = "d" };
_nickle = new Coin() { Title = "Nickle", Value = .05m, ShortName = "n" };
_penny = new Coin() { Title = "Penny", Value = .01m, ShortName = "p" };
_slots = new List<Slot>() { slot_a, slot_b };
_maxSlots = 5;
_machineService = new MachineService(_maxSlots, _purchaseServiceMock.Object);
}
protected override void Register(AutoMockContainer container)
{
base.Register(container);
// Mock Zero Install version
container.Register(new ImplementationVersion("1.0"));
}
public void Initalize()
{
_factory = new MockRepository(MockBehavior.Loose);
_container = new AutoMockContainer(_factory);
_frameServiceMock = _container.GetMock<IFrameService>();
_players = new List<Player>();
_frames = new List<Frame>();
var score = 0;
var player_a = new Player() { FirstName = "Andrew", LastName = "Leaf", Frames = _frames, Score = score };
var player_b = new Player() { FirstName = "Jennifer", LastName = "Leaf", Frames = _frames, Score = score };
_players.Add(player_a);
_players.Add(player_b);
_gameService = new GameService(_frameServiceMock.Object);
}
public void initalize()
{
_factory = new MockRepository(MockBehavior.Loose);
_container = new AutoMockContainer(_factory);
}
public void Setup(MockBehavior behavior)
{
MockRepository = new MockRepository(behavior);
Container = new AutoMockContainer(MockRepository);
}
public Application_RequestService_Tests()
{
_mockRepository = new MockRepository(MockBehavior.Loose);
_autoMockContainer = new AutoMockContainer(_mockRepository);
}
public void Setup()
{
container = new AutoMockContainer(new MockFactory(MockBehavior.Loose));
}
