public void Init()
{
_testScheduler = new TestScheduler();
_correlationManager = Substitute.For <IPeerMessageCorrelationManager>();
_gossipManager = Substitute.For <IBroadcastManager>();
_keySigner = Substitute.For <FakeKeySigner>();
var peerSettings = Substitute.For <IPeerSettings>();
peerSettings.NetworkType.Returns(NetworkType.Devnet);
var peerValidator = Substitute.For <IPeerIdValidator>();
peerValidator.ValidatePeerIdFormat(Arg.Any <PeerId>()).Returns(true);
_factory = new TestPeerServerChannelFactory(
_correlationManager,
_gossipManager,
_keySigner,
peerValidator,
peerSettings,
_testScheduler);
_senderId = PeerIdHelper.GetPeerId("sender");
_correlationId = CorrelationId.GenerateCorrelationId();
_signature = ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength);
_keySigner.Verify(Arg.Any <ISignature>(), Arg.Any <byte[]>(), default)
.ReturnsForAnyArgs(true);
}
private async Task BroadcastNewDfsFileAddressAsync(Cid dfsFileAddress, ByteString previousDeltaHash)
{
if (dfsFileAddress == null)
{
return;
}
try
{
_logger.Verbose(
"Broadcasting new delta dfs address {dfsAddress} for delta with previous delta hash {previousDeltaHash}",
dfsFileAddress, previousDeltaHash.ToByteArray().ToCid());
var newDeltaHashOnDfs = new DeltaDfsHashBroadcast
{
DeltaDfsHash = dfsFileAddress.ToArray().ToByteString(),
PreviousDeltaDfsHash = previousDeltaHash
}.ToProtocolMessage(_peerId, CorrelationId.GenerateCorrelationId());
await _broadcastManager.BroadcastAsync(newDeltaHashOnDfs).ConfigureAwait(false);
}
catch (Exception exception)
{
_logger.Error(exception, "Failed to broadcast new dfs address {dfsAddress}");
}
}
public async Task Can_Process_DeltaHeightRequest_Correctly()
{
var deltaHeightRequestMessage = new LatestDeltaHashRequest();
var fakeContext = Substitute.For <IChannelHandlerContext>();
var channeledAny = new ObserverDto(fakeContext,
deltaHeightRequestMessage.ToProtocolMessage(PeerIdHelper.GetPeerId(),
CorrelationId.GenerateCorrelationId()));
var observableStream = new[] { channeledAny }.ToObservable(_testScheduler);
_deltaHeightRequestObserver.StartObserving(observableStream);
_testScheduler.Start();
var hash = MultiHash.ComputeHash(new byte[32]);
var cid = new Cid {
Hash = hash
};
await fakeContext.Channel.ReceivedWithAnyArgs(1)
.WriteAndFlushAsync(new LatestDeltaHashResponse
{
DeltaIndex = new DeltaIndex {
Cid = cid.ToArray().ToByteString(), Height = 100
}
}.ToProtocolMessage(PeerIdHelper.GetPeerId(), CorrelationId.GenerateCorrelationId()))
.ConfigureAwait(false);
_subbedLogger.ReceivedWithAnyArgs(1);
}
public async Task Cancel_File_Transfer()
{
var sender = PeerIdHelper.GetPeerId("sender");
IDownloadFileInformation fileTransferInformation = new DownloadFileTransferInformation(
sender,
sender,
_fakeContext.Channel,
CorrelationId.GenerateCorrelationId(),
string.Empty,
555);
var cancellationTokenSource = new CancellationTokenSource();
_nodeFileTransferFactory.RegisterTransfer(fileTransferInformation);
_nodeFileTransferFactory
.FileTransferAsync(fileTransferInformation.CorrelationId, cancellationTokenSource.Token)
.ConfigureAwait(false).GetAwaiter();
Assert.Single(_nodeFileTransferFactory.Keys);
cancellationTokenSource.Cancel();
await TaskHelper.WaitForAsync(() => fileTransferInformation.IsCompleted, TimeSpan.FromSeconds(10));
var fileCleanedUp = !File.Exists(fileTransferInformation.TempPath);
Assert.True(fileTransferInformation.IsExpired());
Assert.True(fileCleanedUp);
Assert.Empty(_nodeFileTransferFactory.Keys);
}
// [Fact(Skip = "true")]
public async Task PeerClientChannelFactory_should_put_the_correct_handlers_on_the_inbound_pipeline()
{
var testingChannel = new EmbeddedChannel("test".ToChannelId(),
true, _factory.InheritedHandlers.ToArray());
var senderId = PeerIdHelper.GetPeerId("sender");
var correlationId = CorrelationId.GenerateCorrelationId();
var protocolMessage = new PingRequest().ToProtocolMessage(senderId, correlationId);
var signature = ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength);
var signedMessage = protocolMessage.Sign(signature);
_keySigner.Verify(Arg.Is <ISignature>(s => s.SignatureBytes.SequenceEqual(signature)), Arg.Any <byte[]>(),
default)
.ReturnsForAnyArgs(true);
var observer = new ProtocolMessageObserver(0, Substitute.For <ILogger>());
var messageStream = ((ObservableServiceHandler)_factory.InheritedHandlers.Last()).MessageStream;
using (messageStream.Subscribe(observer))
{
testingChannel.WriteInbound(signedMessage);
_correlationManager.DidNotReceiveWithAnyArgs().TryMatchResponse(protocolMessage);
await _gossipManager.DidNotReceiveWithAnyArgs().BroadcastAsync(null);
_keySigner.ReceivedWithAnyArgs(1).Verify(null, null, null);
_testScheduler.Start();
observer.Received.Count.Should().Be(1);
observer.Received.Single().Payload.CorrelationId.ToCorrelationId().Id.Should().Be(correlationId.Id);
}
}
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 RpcClientChannelFactory_should_put_the_correct_inbound_handlers_on_the_pipeline()
{
var testingChannel = new EmbeddedChannel("test".ToChannelId(),
true, _factory.InheritedHandlers.ToArray());
var senderId = PeerIdHelper.GetPeerId("sender");
var correlationId = CorrelationId.GenerateCorrelationId();
var signatureBytes = ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength);
var protocolMessage = new PingResponse()
.ToSignedProtocolMessage(senderId, signatureBytes, correlationId: correlationId);
_keySigner.Verify(Arg.Any <ISignature>(), Arg.Any <byte[]>(), Arg.Any <SigningContext>())
.Returns(true);
_correlationManager.TryMatchResponse(protocolMessage).Returns(true);
var observer = new ProtocolMessageObserver(0, Substitute.For <ILogger>());
var messageStream = _factory.InheritedHandlers.OfType <ObservableServiceHandler>().Single().MessageStream;
using (messageStream.Subscribe(observer))
{
testingChannel.WriteInbound(protocolMessage);
_correlationManager.Received(1).TryMatchResponse(protocolMessage);
_keySigner.ReceivedWithAnyArgs(1).Verify(null, null, null);
_testScheduler.Start();
observer.Received.Count.Should().Be(1);
observer.Received.Single().Payload.CorrelationId.ToCorrelationId().Id.Should().Be(correlationId.Id);
}
}
private async Task AddFileToDfs(long byteSize)
{
var fakeNode = Substitute.For <IRpcClient>();
var sender = PeerIdHelper.GetPeerId("sender");
var recipient = PeerIdHelper.GetPeerId("recipient");
var senderPeerId = sender;
var peerSettings = senderPeerId.ToSubstitutedPeerSettings();
var recipientPeerId = recipient;
var fileToTransfer = FileHelper.CreateRandomTempFile(byteSize);
var addFileToDfsRequestHandler =
new AddFileToDfsRequestObserver(_dfs, peerSettings, _nodeFileTransferFactory, _logger);
var transferBytesRequestHandler =
new TransferFileBytesRequestObserver(_nodeFileTransferFactory, peerSettings, _logger);
var uniqueFileKey = CorrelationId.GenerateCorrelationId();
var crcValue = FileHelper.GetCrcValue(fileToTransfer);
//Create a response object and set its return value
var request = new AddFileToDfsRequest
{
Node = "node1",
FileName = fileToTransfer,
FileSize = (ulong)byteSize
}.ToProtocolMessage(sender, uniqueFileKey);
request.SendToHandler(_fakeContext, addFileToDfsRequestHandler);
Assert.Single(_nodeFileTransferFactory.Keys);
var fileTransferInformation =
_nodeFileTransferFactory.GetFileTransferInformation(uniqueFileKey);
Assert.True(fileTransferInformation.Initialised, "File transfer not initialised");
using (var fs = File.Open(fileToTransfer, FileMode.Open))
{
var fileUploadInformation = new UploadFileTransferInformation(fs, senderPeerId, recipientPeerId,
fakeNode.Channel, uniqueFileKey);
for (uint i = 0; i < fileTransferInformation.MaxChunk; i++)
{
fileUploadInformation.GetUploadMessageDto(i).Content
.SendToHandler(_fakeContext, transferBytesRequestHandler);
}
}
Assert.True(fileTransferInformation.ChunkIndicatorsTrue());
await TaskHelper.WaitForAsync(() => fileTransferInformation.DfsHash != null, TimeSpan.FromSeconds(15));
Assert.NotNull(fileTransferInformation.DfsHash);
long ipfsCrcValue;
using (var ipfsStream = await _dfs.ReadAsync(fileTransferInformation.DfsHash))
{
ipfsCrcValue = FileHelper.GetCrcValue(ipfsStream);
}
Assert.Equal(crcValue, ipfsCrcValue);
}
/// <inheritdoc />
public void RestoreMemento(IHastingsMemento hastingsMemento)
{
Logger.Debug("Restoring memento with Peer {peer} and neighbours [{neighbours}]", hastingsMemento.Peer);
Peer = hastingsMemento.Peer;
Neighbours = hastingsMemento.Neighbours;
PnrCorrelationId = CorrelationId.GenerateCorrelationId();
}
public void Can_Get_Correct_Chunk_Transfer_File_Bytes_Request_Message(uint chunks)
{
int byteLengthForChunks = (int) (Constants.FileTransferChunkSize * chunks);
byte[] expectedBytes =
Enumerable.Range(0, byteLengthForChunks).Select(i => (byte) i).ToArray();
using (MemoryStream ms = new MemoryStream(expectedBytes))
{
var uploadFileInformation = new UploadFileTransferInformation(
ms,
PeerIdHelper.GetPeerId("test1"),
PeerIdHelper.GetPeerId("test2"),
null,
CorrelationId.GenerateCorrelationId());
for (uint chunkToTest = 0; chunkToTest < chunks; chunkToTest++)
{
var startIdx = (int) chunkToTest * Constants.FileTransferChunkSize;
var expectedChunk = expectedBytes.Skip(startIdx).Take(Constants.FileTransferChunkSize);
var uploadDto = uploadFileInformation.GetUploadMessageDto(chunkToTest);
var transferRequest = uploadDto.Content.FromProtocolMessage<TransferFileBytesRequest>();
transferRequest.ChunkBytes.ToArray()
.SequenceEqual(expectedChunk).Should().BeTrue();
}
}
}
public async Task Subscribe_To_Message_Stream_Should_Return_VersionRequest()
{
await _rpcServer.StartAsync();
VersionRequest returnedVersionRequest = null;
var targetVersionRequest = new VersionRequest {
Query = true
};
var protocolMessage =
targetVersionRequest.ToProtocolMessage(_peerId, CorrelationId.GenerateCorrelationId());
var observerDto = new ObserverDto(_channelHandlerContext, protocolMessage);
_rpcServer.MessageStream
.Where(x => x.Payload != null && x.Payload.TypeUrl == typeof(VersionRequest).ShortenedProtoFullName())
.SubscribeOn(_testScheduler)
.Subscribe(request => returnedVersionRequest = request.Payload.FromProtocolMessage <VersionRequest>());
_mockSocketReplySubject.OnNext(observerDto);
_testScheduler.Start();
targetVersionRequest.Should().Be(returnedVersionRequest);
}
public async Task Get_File_Rpc(long byteSize)
{
var addedIpfsHash = AddFileToDfs(byteSize, out var crcValue, out var stream);
Stream fileStream = null;
try
{
var nodePeerId = PeerIdHelper.GetPeerId("sender");
var rpcPeerId = PeerIdHelper.GetPeerId("recipient");
var peerSettings = Substitute.For <IPeerSettings>();
peerSettings.PeerId.Returns(rpcPeerId);
var nodePeer = nodePeerId;
var rpcPeer = rpcPeerId;
var correlationId = CorrelationId.GenerateCorrelationId();
var fakeFileOutputPath = Path.GetTempFileName();
IDownloadFileInformation fileDownloadInformation = new DownloadFileTransferInformation(rpcPeer,
nodePeer,
_fakeContext.Channel, correlationId, fakeFileOutputPath, 0);
var getFileFromDfsResponseHandler =
new GetFileFromDfsResponseObserver(_logger, _fileDownloadFactory);
var transferBytesHandler =
new TransferFileBytesRequestObserver(_fileDownloadFactory, peerSettings, _logger);
_fileDownloadFactory.RegisterTransfer(fileDownloadInformation);
var getFileResponse = new GetFileFromDfsResponse
{
FileSize = (ulong)byteSize,
ResponseCode = ByteString.CopyFrom((byte)FileTransferResponseCodeTypes.Successful.Id)
}.ToProtocolMessage(nodePeer, correlationId);
getFileResponse.SendToHandler(_fakeContext, getFileFromDfsResponseHandler);
fileStream = await _dfsService.UnixFsApi.ReadFileAsync(addedIpfsHash.ToString());
IUploadFileInformation fileUploadInformation = new UploadFileTransferInformation(
fileStream,
rpcPeer,
nodePeer,
_fakeContext.Channel,
correlationId);
for (uint i = 0; i < fileUploadInformation.MaxChunk; i++)
{
var transferMessage = fileUploadInformation
.GetUploadMessageDto(i);
transferMessage.Content.SendToHandler(_fakeContext, transferBytesHandler);
}
await TaskHelper.WaitForAsync(() => fileDownloadInformation.IsCompleted, TimeSpan.FromSeconds(10));
Assert.AreEqual(crcValue, FileHelper.GetCrcValue(fileDownloadInformation.TempPath));
}
finally
{
stream.Close();
fileStream?.Close();
}
}
PeerServerChannelFactory_Pipeline_Should_Produce_Response_Object_PeerClientChannelFactory_Can_Process()
{
var recipient = PeerIdHelper.GetPeerId("recipient");
var sender = PeerIdHelper.GetPeerId("sender");
var signature = Substitute.For <ISignature>();
_peerIdValidator.ValidatePeerIdFormat(Arg.Any <PeerId>()).Returns(true);
_serverKeySigner.CryptoContext.SignatureLength.Returns(64);
_serverKeySigner.Sign(Arg.Any <byte[]>(), default).ReturnsForAnyArgs(signature);
var correlationId = CorrelationId.GenerateCorrelationId();
var protocolMessage = new PingResponse().ToProtocolMessage(sender, correlationId);
var dto = new MessageDto(
protocolMessage,
recipient
);
_clientCorrelationManager.TryMatchResponse(Arg.Any <ProtocolMessage>()).Returns(true);
_serverChannel.WriteOutbound(dto);
var sentBytes = _serverChannel.ReadOutbound <DatagramPacket>();
_serverCorrelationManager.DidNotReceiveWithAnyArgs()
.AddPendingRequest(Arg.Any <CorrelatableMessage <ProtocolMessage> >());
_serverKeySigner.ReceivedWithAnyArgs(1).Sign(Arg.Any <byte[]>(), default);
_clientKeySigner.Verify(
Arg.Any <ISignature>(),
Arg.Any <byte[]>(),
default)
.ReturnsForAnyArgs(true);
var observer = new ProtocolMessageObserver(0, Substitute.For <ILogger>());
var messageStream = _clientFactory.InheritedHandlers.OfType <ObservableServiceHandler>().Single()
.MessageStream;
using (messageStream.Subscribe(observer))
{
_clientChannel.WriteInbound(sentBytes);
_clientChannel.ReadInbound <ProtocolMessage>();
_clientCorrelationManager.ReceivedWithAnyArgs(1).TryMatchResponse(Arg.Any <ProtocolMessage>());
_clientKeySigner.ReceivedWithAnyArgs(1).Verify(null, null, null);
_testScheduler.Start();
observer.Received.Count.Should().Be(1);
observer.Received.Single().Payload.CorrelationId.ToCorrelationId().Id.Should().Be(correlationId.Id);
}
await _serverChannel.DisconnectAsync();
await _clientChannel.DisconnectAsync();
}
/// <inheritdoc />
public void BroadcastFavouriteCandidateDelta(FavouriteDeltaBroadcast favourite)
{
Guard.Argument(favourite, nameof(favourite)).NotNull().Require(c => c.IsValid());
var protocolMessage = favourite.ToProtocolMessage(_peerId, CorrelationId.GenerateCorrelationId());
_broadcastManager.BroadcastAsync(protocolMessage);
_logger.Debug("Started broadcasting favourite candidate {0}", favourite);
}
public static void RandomElementReturnsCorrectTypeOfString()
{
var randomList = new List <string>();
randomList.Add(CorrelationId.GenerateCorrelationId().Id.ToString());
var returnedElement = randomList.RandomElement();
returnedElement.Should().BeOfType <string>();
}
private ProtocolMessage GetSignedMessage()
{
var protocolMessage = new PeerNeighborsRequest()
.ToProtocolMessage(_senderId, CorrelationId.GenerateCorrelationId());
var signedMessage = protocolMessage.Sign();
return(signedMessage);
}
public async Task Can_Process_GetNeighbourRequest_Correctly()
{
// mock a random set of peers
var randomPeers = new List <Peer>
{
new Peer {
PeerId = PeerIdHelper.GetPeerId("peer1"), LastSeen = DateTime.Now
},
new Peer {
PeerId = PeerIdHelper.GetPeerId("peer2"), LastSeen = DateTime.Now
},
new Peer {
PeerId = PeerIdHelper.GetPeerId("peer3"), LastSeen = DateTime.Now
},
new Peer {
PeerId = PeerIdHelper.GetPeerId("peer4"), LastSeen = DateTime.Now
},
new Peer {
PeerId = PeerIdHelper.GetPeerId("peer5"), LastSeen = DateTime.Now
},
new Peer {
PeerId = PeerIdHelper.GetPeerId("peer6")
}
};
// add them to the mocked repository, and set return expectation
AddMockPeerToDbAndSetReturnExpectation(randomPeers, _subbedPeerRepository);
var peerSettings = _peerId.ToSubstitutedPeerSettings();
var neighbourRequestHandler = new GetNeighbourRequestObserver(peerSettings,
_subbedPeerRepository,
_subbedLogger
);
var peerNeighbourRequestMessage = new PeerNeighborsRequest();
var fakeContext = Substitute.For <IChannelHandlerContext>();
var channeledAny = new ObserverDto(fakeContext,
peerNeighbourRequestMessage.ToProtocolMessage(PeerIdHelper.GetPeerId(),
CorrelationId.GenerateCorrelationId()));
var observableStream = new[] { channeledAny }.ToObservable(_testScheduler);
neighbourRequestHandler.StartObserving(observableStream);
var peerNeighborsResponseMessage = new PeerNeighborsResponse();
for (var i = 0; i < 5; i++)
{
peerNeighborsResponseMessage.Peers.Add(PeerIdHelper.GetPeerId());
}
_testScheduler.Start();
await fakeContext.Channel.ReceivedWithAnyArgs(1)
.WriteAndFlushAsync(
peerNeighborsResponseMessage.ToProtocolMessage(_peerId, CorrelationId.GenerateCorrelationId()));
}
public DownloadFileTransferInformationTests()
{
_downloadFileInformation =
new DownloadFileTransferInformation(null,
null,
null,
CorrelationId.GenerateCorrelationId(),
"",
10);
}
public void SendMessage <T>(T message) where T : IMessage
{
var protocolMessage =
message.ToProtocolMessage(_senderPeerId, CorrelationId.GenerateCorrelationId());
var messageDto = new MessageDto(
protocolMessage,
_recipientPeerId);
_rpcClient.SendMessage(messageDto);
}
public static void ToAnySigned_should_set_the_wrapper_fields()
{
var guid = CorrelationId.GenerateCorrelationId();
var peerId = PeerIdHelper.GetPeerId("blablabla");
var wrapped = new PeerId().ToProtocolMessage(peerId, guid);
wrapped.CorrelationId.ToCorrelationId().Id.Should().Be(guid.Id);
wrapped.PeerId.Should().Be(peerId);
wrapped.TypeUrl.Should().Be(PeerId.Descriptor.ShortenedFullName());
}
public void Can_Clean_Up_Broadcast()
{
var correlationId = CorrelationId.GenerateCorrelationId();
var fakeMessage =
new TransactionBroadcast()
.ToProtocolMessage(PeerIdHelper.GetPeerId("Test"), correlationId);
_fakeChannel.WriteInbound(fakeMessage);
_broadcastManager.Received(1).RemoveSignedBroadcastMessageData(correlationId);
}
private MultiHash AddFileToDfs(long byteSize, out long crcValue, out Stream stream)
{
var fileToTransfer = FileHelper.CreateRandomTempFile(byteSize);
var fakeId = _hashProvider.ComputeUtf8MultiHash(CorrelationId.GenerateCorrelationId().ToString());
crcValue = FileHelper.GetCrcValue(fileToTransfer);
stream = new MemoryStream(File.ReadAllBytes(fileToTransfer));
_dfsService.UnixFsApi.ReadFileAsync(fakeId.ToString()).Returns(stream);
return(fakeId);
}
#pragma warning disable 693
protected void TryMatchResponseAsync_Should_Not_Match_Existing_Records_With_Non_Matching_Correlation_Id <T>()
#pragma warning restore 693
where T : IMessage, new()
{
var responseMatchingNothing =
new T().ToProtocolMessage(PeerIds[1], CorrelationId.GenerateCorrelationId());
var request = CorrelationManager.TryMatchResponse(responseMatchingNothing);
request.Should().BeFalse();
}
public void Null_SenderPeerIdentifierContext_Throws_Exception()
{
var channelHandlerContext = Substitute.For <IChannelHandlerContext>();
var correlationId = CorrelationId.GenerateCorrelationId();
var logger = Substitute.For <ILogger>();
var responseObserver = new TestRpcResponseObserver(logger);
Assert.Throws <ArgumentNullException>(() => responseObserver
.HandleResponseObserver(new VersionResponse(), channelHandlerContext,
null, correlationId));
}
public void RpcClientChannelFactory_should_put_the_correct_outbound_handlers_on_the_pipeline()
{
var testingChannel = new EmbeddedChannel("test".ToChannelId(),
true, _factory.InheritedHandlers.ToArray());
var senderId = PeerIdHelper.GetPeerId("sender");
var correlationId = CorrelationId.GenerateCorrelationId();
var protocolMessage = new PingRequest().ToProtocolMessage(senderId, correlationId);
testingChannel.WriteOutbound(protocolMessage);
_correlationManager.DidNotReceiveWithAnyArgs().TryMatchResponse(default);
public async Task Message_Eviction_Should_Cause_Eviction_Event()
{
var peerIds = new[]
{
PeerIdHelper.GetPeerId("peer1"),
PeerIdHelper.GetPeerId("peer2"),
PeerIdHelper.GetPeerId("peer3")
};
var pendingRequests = peerIds.Select(peerId => new CorrelatableMessage <ProtocolMessage>
{
Content = new VersionRequest().ToProtocolMessage(PeerIdHelper.GetPeerId("sender"),
CorrelationId.GenerateCorrelationId()),
Recipient = peerId,
SentAt = DateTimeOffset.MinValue.Add(TimeSpan.Zero)
}).ToList();
var pendingResponses = pendingRequests.Select(peerId => new CorrelatableMessage <ProtocolMessage>
{
Content = new VersionResponse().ToProtocolMessage(PeerIdHelper.GetPeerId("sender"),
peerId.Content.CorrelationId.ToCorrelationId()),
Recipient = peerId.Recipient,
SentAt = DateTimeOffset.MinValue.Add(TimeSpan.Zero)
}).ToList();
pendingRequests.ForEach(_rpcMessageCorrelationManager.AddPendingRequest);
//Log the number of evicted events
var evictedEvents = 0;
//Subscribe to eviction events, so we can count them and assert against them.
_rpcMessageCorrelationManager.EvictionEvents.Subscribe(response => evictedEvents++);
//Evict all messages.
_cancellationTokenSource.Cancel();
//Required to evict the cache, microsoft removed the timer in newer versions but read will if the cache has expired
//https://referencesource.microsoft.com/#System.Runtime.Caching/System/Caching/MemoryCacheStore.cs,ae04d12e168ec1ab
pendingResponses.ForEach(pendingResponse =>
_rpcMessageCorrelationManager.TryMatchResponse(pendingResponse.Content));
//To prevent cache eviction multi threading delay
const int milliseconds = 100;
while (evictedEvents < pendingRequests.Count)
{
_testScheduler.AdvanceBy(milliseconds);
await Task.Delay(milliseconds).ConfigureAwait(false);
}
evictedEvents.Should().Be(pendingRequests.Count);
}
public static IHastingsOriginator SubOriginator(PeerId peer = default,
INeighbours neighbours = default,
ICorrelationId expectedPnr = default)
{
var subbedOriginator = Substitute.For <IHastingsOriginator>();
subbedOriginator.Neighbours.Count.Returns(5);
subbedOriginator.Peer.Returns(peer ?? new PeerId());
subbedOriginator.Neighbours.Returns(neighbours ?? Substitute.For <INeighbours>());
subbedOriginator.PnrCorrelationId.Returns(expectedPnr ?? CorrelationId.GenerateCorrelationId());
return(subbedOriginator);
}
public void Null_Mempool_Throws_Exception()
{
var channelHandlerContext = Substitute.For <IChannelHandlerContext>();
var senderPeerIdentifier = PeerIdHelper.GetPeerId();
var correlationId = CorrelationId.GenerateCorrelationId();
var logger = Substitute.For <ILogger>();
var getMempoolResponseObserver = new GetMempoolResponseObserver(logger);
Assert.Throws <ArgumentNullException>(() => getMempoolResponseObserver
.HandleResponseObserver(null, channelHandlerContext,
senderPeerIdentifier, correlationId));
}
#pragma warning disable 693
protected void PrepareCacheWithPendingRequests <T>()
#pragma warning restore 693
where T : IMessage, new()
{
PendingRequests = PeerIds.Select((p, i) => new CorrelatableMessage <ProtocolMessage>
{
Content = new T().ToProtocolMessage(_senderPeerId, CorrelationId.GenerateCorrelationId()),
Recipient = p,
SentAt = DateTimeOffset.MinValue.Add(TimeSpan.FromMilliseconds(100 * i))
}).ToList();
PendingRequests.ForEach(AddRequestExpectation);
}
public static INeighbours MockNeighbours(int amount = 5,
NeighbourStateTypes stateTypes = null,
ICorrelationId correlationId = default)
{
var neighbours = Enumerable.Range(0, amount).Select(i =>
new Neighbour(
PeerIdHelper.GetPeerId(
StringHelper.RandomString()
),
stateTypes ?? NeighbourStateTypes.NotContacted,
correlationId ?? CorrelationId.GenerateCorrelationId()));
return(new Neighbours(neighbours));
}