public void Valid_GetVersion_Request_Should_Send_VersionResponse()
{
var testScheduler = new TestScheduler();
var versionRequest = new VersionRequest();
var protocolMessage =
versionRequest.ToProtocolMessage(PeerIdHelper.GetPeerId("sender"));
var messageStream = MessageStreamHelper.CreateStreamWithMessage(_fakeContext, testScheduler,
protocolMessage
);
var peerSettings = PeerIdHelper.GetPeerId("sender").ToSubstitutedPeerSettings();
var handler = new GetVersionRequestObserver(peerSettings, _logger);
handler.StartObserving(messageStream);
testScheduler.Start();
var receivedCalls = _fakeContext.Channel.ReceivedCalls().ToList();
receivedCalls.Count.Should().Be(1);
var sentResponseDto = (IMessageDto <ProtocolMessage>)receivedCalls.Single().GetArguments().Single();
var versionResponseMessage = sentResponseDto.Content.FromProtocolMessage <VersionResponse>();
versionResponseMessage.Version.Should().Be(NodeUtil.GetVersion());
}
public void RpcServer_Can_Handle_SignMessageRequest(string message)
{
var sender = PeerIdHelper.GetPeerId("sender");
var peerSettings = Substitute.For <IPeerSettings>();
peerSettings.PeerId.Returns(sender);
var signMessageRequest = new SignMessageRequest
{
Message = message.ToUtf8ByteString(),
SigningContext = new SigningContext()
};
var protocolMessage =
signMessageRequest.ToProtocolMessage(sender);
var messageStream =
MessageStreamHelper.CreateStreamWithMessage(_fakeContext, _testScheduler, protocolMessage);
var handler =
new SignMessageRequestObserver(peerSettings, _logger, _keySigner);
handler.StartObserving(messageStream);
_testScheduler.Start();
var receivedCalls = _fakeContext.Channel.ReceivedCalls().ToList();
receivedCalls.Count.Should().Be(1);
var sentResponseDto = (IMessageDto <ProtocolMessage>)receivedCalls.Single().GetArguments().Single();
var signResponseMessage = sentResponseDto.Content.FromProtocolMessage <SignMessageResponse>();
signResponseMessage.OriginalMessage.Should().Equal(message);
signResponseMessage.Signature.Should().NotBeEmpty();
signResponseMessage.PublicKey.Should().NotBeEmpty();
}
public void RpcClient_Can_Handle_SignMessageResponse(SignedResponse signedResponse)
{
var testScheduler = new TestScheduler();
var signMessageResponse = new SignMessageResponse
{
OriginalMessage = signedResponse.OriginalMessage,
PublicKey = signedResponse.PublicKey,
Signature = signedResponse.Signature,
};
var correlationId = CorrelationId.GenerateCorrelationId();
var protocolMessage =
signMessageResponse.ToProtocolMessage(PeerIdHelper.GetPeerId("sender"), correlationId);
var messageStream = MessageStreamHelper.CreateStreamWithMessage(_fakeContext, testScheduler,
protocolMessage
);
_handler = new SignMessageResponseObserver(_output, _logger);
_handler.StartObserving(messageStream);
testScheduler.Start();
_output.Received(1).WriteLine(Arg.Any <string>());
}
public void GetMempool_UsingFilledMempool_ShouldSendGetMempoolResponse(List <TransactionBroadcast> mempoolTransactions)
{
var testScheduler = new TestScheduler();
var mempool = Substitute.For <IMempool <MempoolDocument> >();
mempool.Repository.GetAll().Returns(mempoolTransactions);
var protocolMessage = new GetMempoolRequest().ToProtocolMessage(PeerIdHelper.GetPeerId("sender_key"));
var messageStream = MessageStreamHelper.CreateStreamWithMessage(_fakeContext, testScheduler, protocolMessage);
var peerSettings = PeerIdHelper.GetPeerId("sender").ToSubstitutedPeerSettings();
var handler = new GetMempoolRequestObserver(peerSettings, mempool, _logger);
handler.StartObserving(messageStream);
testScheduler.Start();
var receivedCalls = _fakeContext.Channel.ReceivedCalls().ToList();
receivedCalls.Count.Should().Be(1);
var sentResponseDto = (IMessageDto <ProtocolMessage>)receivedCalls.Single().GetArguments().Single();
var responseContent = sentResponseDto.Content.FromProtocolMessage <GetMempoolResponse>();
responseContent.Transactions.Should().BeEquivalentTo(mempoolTransactions);
}
public async Task RpcServer_Can_Handle_SignMessageRequest(string message)
{
var sender = PeerIdHelper.GetPeerId("sender");
var peerSettings = Substitute.For <IPeerSettings>();
peerSettings.PeerId.Returns(sender);
var signMessageRequest = new SignMessageRequest
{
Message = message.ToUtf8ByteString(),
SigningContext = new SigningContext()
};
var protocolMessage =
signMessageRequest.ToProtocolMessage(sender);
await TaskHelper.WaitForAsync(
() => _keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey) != null,
TimeSpan.FromSeconds(2));
var messageStream =
MessageStreamHelper.CreateStreamWithMessage(_fakeContext, _testScheduler, protocolMessage);
var handler =
new SignMessageRequestObserver(peerSettings, _logger, _keySigner);
handler.StartObserving(messageStream);
_testScheduler.Start();
var receivedCalls = _fakeContext.Channel.ReceivedCalls().ToList();
_logger.DidNotReceiveWithAnyArgs().Error((Exception) default, default);
/// <summary>
/// Tests the data/communication through protobuf
/// </summary>
/// <returns></returns>
private GetPeerInfoResponse GetPeerInfoTest(PeerId peerId)
{
var testScheduler = new TestScheduler();
_fakeContext.Channel.RemoteAddress.Returns(EndpointBuilder.BuildNewEndPoint("192.0.0.1", 42042));
var senderPeerIdentifier = PeerIdHelper.GetPeerId("sender");
var getPeerInfoRequest = new GetPeerInfoRequest {
PublicKey = peerId.PublicKey, Ip = peerId.Ip
};
var protocolMessage =
getPeerInfoRequest.ToProtocolMessage(senderPeerIdentifier);
var messageStream = MessageStreamHelper.CreateStreamWithMessage(_fakeContext, testScheduler, protocolMessage);
var peerSettings = senderPeerIdentifier.ToSubstitutedPeerSettings();
var handler = new GetPeerInfoRequestObserver(peerSettings, _logger, _peerRepository);
handler.StartObserving(messageStream);
testScheduler.Start();
var receivedCalls = _fakeContext.Channel.ReceivedCalls().ToList();
receivedCalls.Count.Should().Be(1);
var sentResponseDto = (IMessageDto <ProtocolMessage>)receivedCalls[0].GetArguments().Single();
return(sentResponseDto.Content.FromProtocolMessage <GetPeerInfoResponse>());
}
/// <summary>Executes the test case.</summary>
/// <param name="fakePeers">The fake peers.</param>
/// <param name="withPublicKey">if set to <c>true</c> [send message to handler with the public key].</param>
private void ExecuteTestCase(IReadOnlyCollection <string> fakePeers, bool withPublicKey)
{
var testScheduler = new TestScheduler();
IPeerRepository peerRepository = Substitute.For <IPeerRepository>();
Peer targetPeerToDelete = null;
var fakePeerList = fakePeers.ToList().Select(fakePeer =>
{
var peer = new Peer
{
Reputation = 0,
LastSeen = DateTime.Now.Subtract(TimeSpan.FromSeconds(fakePeers.ToList().IndexOf(fakePeer))),
PeerId = PeerIdHelper.GetPeerId(fakePeer)
};
if (targetPeerToDelete == null)
{
targetPeerToDelete = peer;
}
return(peer);
}).ToList();
peerRepository.FindAll(Arg.Any <ISpecification <Peer> >()).Returns(withPublicKey ? new List <Peer> {
targetPeerToDelete
} : fakePeerList);
// Build a fake remote endpoint
_fakeContext.Channel.RemoteAddress.Returns(EndpointBuilder.BuildNewEndPoint("192.0.0.1", 42042));
var peerId = PeerIdHelper.GetPeerId("sender");
var removePeerRequest = new RemovePeerRequest
{
PeerIp = targetPeerToDelete.PeerId.Ip,
PublicKey = withPublicKey ? targetPeerToDelete.PeerId.PublicKey : ByteString.Empty
};
var protocolMessage = removePeerRequest.ToProtocolMessage(peerId);
var messageStream = MessageStreamHelper.CreateStreamWithMessage(_fakeContext, testScheduler, protocolMessage);
var peerSettings = peerId.ToSubstitutedPeerSettings();
var handler = new RemovePeerRequestObserver(peerSettings, peerRepository, _logger);
handler.StartObserving(messageStream);
testScheduler.Start();
var receivedCalls = _fakeContext.Channel.ReceivedCalls().ToList();
receivedCalls.Count().Should().Be(1);
var sentResponseDto = (IMessageDto <ProtocolMessage>)receivedCalls[0].GetArguments().Single();
var signResponseMessage = sentResponseDto.Content.FromProtocolMessage <RemovePeerResponse>();
signResponseMessage.DeletedCount.Should().Be(withPublicKey ? 1 : (uint)fakePeers.Count);
}
public void MessageHandler_should_subscribe_to_next_and_complete()
{
var completingStream = MessageStreamHelper.CreateStreamWithMessages(_fakeContext, _testScheduler, _responseMessages);
_handler.StartObserving(completingStream);
_testScheduler.Start();
_handler.SubstituteObserver.Received(10).OnNext(Arg.Any <GetInfoResponse>());
_handler.SubstituteObserver.Received(0).OnError(Arg.Any <Exception>());
_handler.SubstituteObserver.Received(1).OnCompleted();
}
private IObservable <IObserverDto <ProtocolMessage> > CreateStreamWithDeltaRequest(MultiHash hash)
{
var deltaRequest = new GetDeltaRequest {
DeltaDfsHash = hash.ToArray().ToByteString()
};
var message = deltaRequest.ToProtocolMessage(PeerIdHelper.GetPeerId("sender"));
var observable = MessageStreamHelper.CreateStreamWithMessage(_fakeContext, _testScheduler, message);
return(observable);
}
public void OnNext_Should_Still_Get_Called_After_HandleBroadcast_Failure()
{
var testScheduler = new TestScheduler();
var candidateDeltaMessages = Enumerable.Repeat(DeltaHelper.GetCandidateDelta(_hashProvider), 10).ToArray();
var messageStream = MessageStreamHelper.CreateStreamWithMessages(testScheduler, candidateDeltaMessages);
using (var observer = new FailingBroadCastObserver(Substitute.For <ILogger>()))
{
observer.StartObserving(messageStream);
testScheduler.Start();
observer.Counter.Should().Be(10);
}
}
public void MessageHandler_should_not_receive_null_or_untyped_messages()
{
_responseMessages[2].TypeUrl = "";
_responseMessages[5] = NullObjects.ProtocolMessage;
_responseMessages[9] = null;
var mixedTypesStream = MessageStreamHelper.CreateStreamWithMessages(_fakeContext, _testScheduler, _responseMessages);
_handler.StartObserving(mixedTypesStream);
_testScheduler.Start();
_handler.SubstituteObserver.Received(7).OnNext(Arg.Any <GetInfoResponse>());
_handler.SubstituteObserver.Received(0).OnError(Arg.Any <Exception>());
_handler.SubstituteObserver.Received(1).OnCompleted();
}
public void OnNext_Should_Still_Get_Called_After_HandleBroadcast_Failure()
{
var testScheduler = new TestScheduler();
var candidateDeltaMessages = Enumerable.Repeat(new PeerNeighborsRequest(), 10).ToArray();
var peerSettings = PeerIdHelper.GetPeerId("server").ToSubstitutedPeerSettings();
var messageStream = MessageStreamHelper.CreateStreamWithMessages(testScheduler, candidateDeltaMessages);
using (var observer = new FailingRequestObserver(Substitute.For <ILogger>(),
peerSettings))
{
observer.StartObserving(messageStream);
testScheduler.Start();
observer.Counter.Should().Be(10);
}
}
public void TestPeerListRequestResponse(int fakePeers)
{
var peerService = Substitute.For <IPeerRepository>();
var peerList = new List <Peer>();
for (var i = 0; i < fakePeers; i++)
{
peerList.Add(new Peer
{
Reputation = 0,
LastSeen = DateTime.Now,
PeerId = PeerIdHelper.GetPeerId(i.ToString())
});
}
// Build a fake remote endpoint
_fakeContext.Channel.RemoteAddress.Returns(EndpointBuilder.BuildNewEndPoint("192.0.0.1", 42042));
peerService.GetAll().Returns(peerList);
var sendPeerId = PeerIdHelper.GetPeerId("sender");
var protocolMessage =
new GetPeerCountRequest().ToProtocolMessage(PeerIdHelper.GetPeerId("sender"));
var messageStream =
MessageStreamHelper.CreateStreamWithMessage(_fakeContext, _testScheduler, protocolMessage);
var peerSettings = sendPeerId.ToSubstitutedPeerSettings();
var handler = new PeerCountRequestObserver(peerSettings, peerService, _logger);
handler.StartObserving(messageStream);
_testScheduler.Start();
var receivedCalls = _fakeContext.Channel.ReceivedCalls().ToList();
receivedCalls.Count.Should().Be(1);
var sentResponseDto = (IMessageDto <ProtocolMessage>)receivedCalls[0].GetArguments().Single();
var responseContent = sentResponseDto.Content.FromProtocolMessage <GetPeerCountResponse>();
responseContent.PeerCount.Should().Be(fakePeers);
}
public void TestPeerListRequestResponse(params string[] fakePeers)
{
var testScheduler = new TestScheduler();
var peerService = Substitute.For <IPeerRepository>();
var peerList = new List <Peer>();
fakePeers.ToList().ForEach(fakePeer =>
{
peerList.Add(new Peer
{
Reputation = 0,
LastSeen = DateTime.Now,
PeerId = PeerIdHelper.GetPeerId(fakePeer)
});
});
// Let peerRepository return the fake peer list
peerService.GetAll().Returns(peerList.ToArray());
// Build a fake remote endpoint
_fakeContext.Channel.RemoteAddress.Returns(EndpointBuilder.BuildNewEndPoint("192.0.0.1", 42042));
var protocolMessage = new GetPeerListRequest().ToProtocolMessage(PeerIdHelper.GetPeerId("sender"));
var messageStream =
MessageStreamHelper.CreateStreamWithMessage(_fakeContext, testScheduler, protocolMessage);
var peerSettings = PeerIdHelper.GetPeerId("sender").ToSubstitutedPeerSettings();
var handler = new PeerListRequestObserver(peerSettings, _logger, peerService);
handler.StartObserving(messageStream);
testScheduler.Start();
var receivedCalls = _fakeContext.Channel.ReceivedCalls().ToList();
receivedCalls.Count.Should().Be(1);
var sentResponseDto = (IMessageDto <ProtocolMessage>)receivedCalls[0].GetArguments().Single();
var responseContent = sentResponseDto.Content.FromProtocolMessage <GetPeerListResponse>();
responseContent.Peers.Count.Should().Be(fakePeers.Length);
}
public void OnNext_Should_Still_Get_Called_After_HandleBroadcast_Failure()
{
var testScheduler = new TestScheduler();
var candidateDeltaMessages = Enumerable.Range(0, 10)
.Select(i => new GetPeerCountResponse {
PeerCount = i
}).ToArray();
var messageStream = MessageStreamHelper.CreateStreamWithMessages(testScheduler, candidateDeltaMessages);
using (var observer = new FailingResponseObserver(Substitute.For <ILogger>()))
{
observer.StartObserving(messageStream);
testScheduler.Start();
observer.Counter.Should().Be(10);
}
}
private SetPeerBlacklistResponse GetSetPeerBlacklistRequest(SetPeerBlacklistRequest request)
{
var protocolMessage = request.ToProtocolMessage(_senderId);
var messageStream = MessageStreamHelper.CreateStreamWithMessage(_fakeContext, _testScheduler, protocolMessage);
var peerSettings = _senderId.ToSubstitutedPeerSettings();
var handler = new PeerBlackListingRequestObserver(peerSettings, _logger, _peerRepository);
handler.StartObserving(messageStream);
_testScheduler.Start();
var receivedCalls = _fakeContext.Channel.ReceivedCalls().ToList();
receivedCalls.Count.Should().Be(1);
var sentResponseDto = (IMessageDto <ProtocolMessage>)receivedCalls.Single().GetArguments().Single();
return(sentResponseDto.Content.FromProtocolMessage <SetPeerBlacklistResponse>());
}
public void MessageHandler_should_not_receive_messages_of_the_wrong_type()
{
_responseMessages[3] = new PingResponse().ToProtocolMessage(
_responseMessages[3].PeerId,
_responseMessages[3].CorrelationId.ToCorrelationId());
_responseMessages[7] = new PingRequest().ToProtocolMessage(
_responseMessages[7].PeerId,
_responseMessages[7].CorrelationId.ToCorrelationId());
var mixedTypesStream = MessageStreamHelper.CreateStreamWithMessages(_fakeContext, _testScheduler, _responseMessages);
_handler.StartObserving(mixedTypesStream);
_testScheduler.Start();
_handler.SubstituteObserver.Received(8).OnNext(Arg.Any <GetInfoResponse>());
_handler.SubstituteObserver.Received(0).OnError(Arg.Any <Exception>());
_handler.SubstituteObserver.Received(1).OnCompleted();
}
public void Observer_Can_Process_GetNeighbourResponse_Correctly()
{
var testScheduler = new TestScheduler();
var peers = new[]
{
PeerIdHelper.GetPeerId(),
PeerIdHelper.GetPeerId(),
PeerIdHelper.GetPeerId()
};
var peerNeighborsResponse = new PeerNeighborsResponse
{
Peers =
{
peers
}
};
var protocolMessage =
peerNeighborsResponse.ToProtocolMessage(PeerIdHelper.GetPeerId("sender"),
CorrelationId.GenerateCorrelationId());
var peerNeighborsResponseObserver = Substitute.For <IObserver <IPeerClientMessageDto> >();
var messageStream = MessageStreamHelper.CreateStreamWithMessage(_fakeContext, testScheduler,
protocolMessage);
_observer.StartObserving(messageStream);
using (_observer.MessageStream.Subscribe(peerNeighborsResponseObserver.OnNext))
{
testScheduler.Start();
peerNeighborsResponseObserver.Received(1)
.OnNext(Arg.Is <IPeerClientMessageDto>(p => test(p.Message, peers[0])));
peerNeighborsResponseObserver.Received(1)
.OnNext(Arg.Is <IPeerClientMessageDto>(p => test(p.Message, peers[1])));
peerNeighborsResponseObserver.Received(1)
.OnNext(Arg.Is <IPeerClientMessageDto>(p => test(p.Message, peers[2])));
}
}
public void Observer_Can_Process_PingResponse_Correctly()
{
var testScheduler = new TestScheduler();
var pingResponse = new PingResponse();
var protocolMessage =
pingResponse.ToProtocolMessage(PeerIdHelper.GetPeerId("sender"),
CorrelationId.GenerateCorrelationId());
var pingResponseObserver = Substitute.For <IObserver <IPeerClientMessageDto> >();
var messageStream = MessageStreamHelper.CreateStreamWithMessage(_fakeContext, testScheduler,
protocolMessage);
_observer.StartObserving(messageStream);
using (_observer.MessageStream.Subscribe(pingResponseObserver.OnNext))
{
testScheduler.Start();
pingResponseObserver.Received(1).OnNext(Arg.Any <IPeerClientMessageDto>());
}
}
public void HandlerCanSendErrorOnException()
{
var testScheduler = new TestScheduler();
_downloadFileTransferFactory.DownloadChunk(Arg.Any <TransferFileBytesRequest>()).Returns(FileTransferResponseCodeTypes.Error);
var sender = PeerIdHelper.GetPeerId("sender");
var requestDto = new MessageDto(new TransferFileBytesRequest().ToProtocolMessage(sender)
, PeerIdHelper.GetPeerId("recipient"));
var messageStream = MessageStreamHelper.CreateStreamWithMessage(_context, testScheduler, requestDto.Content);
_observer.StartObserving(messageStream);
testScheduler.Start();
var receivedCalls = _context.Channel.ReceivedCalls().ToList();
receivedCalls.Count.Should().Be(1);
var sentResponseDto = (IMessageDto <ProtocolMessage>)receivedCalls.Single().GetArguments().Single();
var transferFileBytesResponse = sentResponseDto.Content.FromProtocolMessage <TransferFileBytesResponse>();
transferFileBytesResponse.ResponseCode.Should().Equal((byte)FileTransferResponseCodeTypes.Error);
}
public async Task GetInfoMessageRequest_UsingValidRequest_ShouldSendGetInfoResponse()
{
var protocolMessage = new GetInfoRequest
{
Query = true
}.ToProtocolMessage(PeerIdHelper.GetPeerId("sender"));
var expectedResponseContent = JsonConvert
.SerializeObject(_config.GetSection("CatalystNodeConfiguration").AsEnumerable(),
Formatting.Indented);
var messageStream = MessageStreamHelper.CreateStreamWithMessage(_fakeContext, _testScheduler,
protocolMessage
);
var peerSettings = PeerIdHelper.GetPeerId("sender").ToSubstitutedPeerSettings();
var handler = new GetInfoRequestObserver(
peerSettings, _config, _logger);
handler.StartObserving(messageStream);
_testScheduler.Start();
await _fakeContext.Channel.Received(1).WriteAndFlushAsync(Arg.Any <object>());
var receivedCalls = _fakeContext.Channel.ReceivedCalls().ToList();
receivedCalls.Count.Should().Be(1,
"the only call should be the one we checked above");
var response = ((IMessageDto <ProtocolMessage>)receivedCalls.Single().GetArguments()[0])
.Content.FromProtocolMessage <GetInfoResponse>();
response.Query.Should().Match(expectedResponseContent,
"the expected response should contain config information");
}
