public FavouriteDeltaObserverTests()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_deltaElector = Substitute.For <IDeltaElector>();
_fakeChannelContext = Substitute.For <IChannelHandlerContext>();
var logger = Substitute.For <ILogger>();
_voterId = PeerIdHelper.GetPeerId("favourite delta voter");
_producerId = PeerIdHelper.GetPeerId("candidate delta producer");
_favouriteDeltaObserver = new FavouriteDeltaObserver(_deltaElector, hashProvider, logger);
_newHash = MultiBase.Decode(hashProvider.ComputeUtf8MultiHash("newHash").CreateCid());
_prevHash = MultiBase.Decode(hashProvider.ComputeUtf8MultiHash("prevHash").CreateCid());
}
public void Can_Save_Decreased_Peer()
{
var pid = PeerIdHelper.GetPeerId("some_peer");
var savedPeer = SavePeerInRepo(pid);
var peerReputationChange = Substitute.For <IPeerReputationChange>();
peerReputationChange.PeerId.Returns(pid);
peerReputationChange.ReputationEvent.Returns(Substitute.For <IReputationEvents>());
peerReputationChange.ReputationEvent.Amount.Returns(-100);
_reputationManager.OnNext(peerReputationChange);
var updatedSubbedPeer = _reputationManager.PeerRepository.Get(savedPeer.DocumentId);
updatedSubbedPeer.Reputation.Should().Be(0);
}
private void PopulatePeers(int count)
{
var peerList = new List <Peer>();
for (var i = 10; i < count + 10; i++)
{
var peer = new Peer
{
PeerId = PeerIdHelper.GetPeerId(i.ToString())
};
peerList.Add(peer);
_peers.Get(peer.DocumentId).Returns(peer);
}
_peers.AsQueryable().Returns(peerList.AsQueryable());
}
public void When_receiving_invalid_candidate_should_log_and_not_hit_the_cache()
{
var elector = new DeltaElector(_cache, _deltaProducersProvider, _reputationManager, _logger);
elector.OnNext(new FavouriteDeltaBroadcast {
Candidate = new CandidateDeltaBroadcast
{
Hash = ByteUtil.GenerateRandomByteArray(32).ToByteString(),
ProducerId = PeerIdHelper.GetPeerId("unknown_producer")
},
VoterId = PeerIdHelper.GetPeerId("candidate field is invalid")
});
_cache.DidNotReceiveWithAnyArgs().TryGetValue(Arg.Any <object>(), out Arg.Any <object>());
_cache.DidNotReceiveWithAnyArgs().CreateEntry(Arg.Any <object>());
}
public void PeerBlackListingRequestObserver_should_set_Blacklist_flag_on_known_peers(string publicKeySeed, bool blacklist)
{
var targetedId = PeerIdHelper.GetPeerId(publicKeySeed);
var request = new SetPeerBlacklistRequest
{
PublicKey = targetedId.PublicKey,
Ip = targetedId.Ip,
Blacklist = blacklist
};
var responseContent = GetSetPeerBlacklistRequest(request);
responseContent.Blacklist.Should().Be(blacklist);
responseContent.Ip.Should().BeEquivalentTo(targetedId.Ip);
responseContent.PublicKey.Should().BeEquivalentTo(targetedId.PublicKey);
}
public void CanHandlerDownloadChunk()
{
var guid = CorrelationId.GenerateCorrelationId();
var request = new TransferFileBytesRequest
{
ChunkBytes = ByteString.Empty,
ChunkId = 1,
CorrelationFileName = CorrelationId.GenerateCorrelationId().Id.ToByteString()
}.ToProtocolMessage(PeerIdHelper.GetPeerId("Test"), guid);
_downloadFileTransferFactory.DownloadChunk(Arg.Any <TransferFileBytesRequest>())
.Returns(FileTransferResponseCodeTypes.Successful);
request.SendToHandler(_context, _observer);
_downloadFileTransferFactory.Received(1).DownloadChunk(Arg.Any <TransferFileBytesRequest>());
}
public void RpcServerChannelFactory_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 PingResponse().ToProtocolMessage(senderId, correlationId);
testingChannel.WriteOutbound(protocolMessage);
_correlationManager.DidNotReceiveWithAnyArgs().TryMatchResponse(protocolMessage);
_keySigner.DidNotReceiveWithAnyArgs().Sign(Arg.Any <byte[]>(), default);
testingChannel.ReadOutbound <IByteBuffer>();
}
public async Task Can_Process_PingRequest_Correctly()
{
var pingRequestMessage = new PingRequest();
var fakeContext = Substitute.For <IChannelHandlerContext>();
var channeledAny = new ObserverDto(fakeContext, pingRequestMessage.ToProtocolMessage(PeerIdHelper.GetPeerId(), CorrelationId.GenerateCorrelationId()));
var observableStream = new[] { channeledAny }.ToObservable(_testScheduler);
_pingRequestObserver.StartObserving(observableStream);
_testScheduler.Start();
await fakeContext.Channel.ReceivedWithAnyArgs(1)
.WriteAndFlushAsync(new PingResponse().ToProtocolMessage(PeerIdHelper.GetPeerId(), CorrelationId.GenerateCorrelationId()));
_subbedLogger.ReceivedWithAnyArgs(1);
}
public void EntityStoreAuditsCreateTime()
{
var repo = new InMemoryRepository <Peer, string>();
var peer = new Peer {
PeerId = PeerIdHelper.GetPeerId("Test")
};
repo.Add(peer);
var retrievedPeer = repo.Get(peer.DocumentId);
var now = DateTime.UtcNow.Date;
var datecomparer = retrievedPeer.Created.Date.ToString("MM/dd/yyyy");
// ReSharper disable once SuspiciousTypeConversion.Global
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
datecomparer.Should().Equals(now.ToString("MM/dd/yyyy"));
retrievedPeer.Modified.Should().BeNull();
}
public async Task Does_Process_IMessageDto_Types()
{
var protocolMessage =
new PingRequest().ToProtocolMessage(PeerIdHelper.GetPeerId("sender"));
var messageDto = new MessageDto(protocolMessage, PeerIdHelper.GetPeerId("recipient"));
var correlatableHandler = new CorrelatableHandler <IMessageCorrelationManager>(_fakeMessageCorrelationManager);
await correlatableHandler.WriteAsync(_fakeContext, messageDto);
_fakeMessageCorrelationManager
.ReceivedWithAnyArgs()
.AddPendingRequest(Arg.Any <CorrelatableMessage <ProtocolMessage> >()
);
await _fakeContext.ReceivedWithAnyArgs(1).WriteAsync(Arg.Any <IMessageDto <ProtocolMessage> >());
}
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 Can_WalkForward_With_Valid_Candidate()
{
var knownStepPid =
PeerIdHelper.GetPeerId("hey_its_jimmys_brother_the_guy_with_the_beautiful_voice");
var knownNextCandidate =
PeerIdHelper.GetPeerId("these_eyes....");
var discoveryTestBuilder = new DiscoveryTestBuilder()
.WithLogger()
.WithScheduler(_testScheduler)
.WithPeerRepository()
.WithDns()
.WithPeerSettings()
.WithPeerClient()
.WithCancellationProvider()
.WithPeerClientObservables()
.WithCurrentStep(default, true, knownStepPid)
public void Init()
{
_channel = new EmbeddedChannel(
new DatagramPacketEncoder <IMessage>(new ProtobufEncoder())
);
var senderPid = PeerIdHelper.GetPeerId("sender",
IPAddress.Loopback,
10000
);
_recipientPid = PeerIdHelper.GetPeerId("sender",
IPAddress.Loopback,
20000
);
_protocolMessageSigned = new PingRequest().ToSignedProtocolMessage(senderPid, (byte[])default);
public AddFileToDfsRequestObserverTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_manualResetEvent = new ManualResetEvent(false);
_senderIdentifier = PeerIdHelper.GetPeerId("sender");
var peerSettings = _senderIdentifier.ToSubstitutedPeerSettings();
_fakeDfs = Substitute.For <IDfs>();
var logger = Substitute.For <ILogger>();
_fakeContext = Substitute.For <IChannelHandlerContext>();
_nodeFileTransferFactory = Substitute.For <IDownloadFileTransferFactory>();
_addFileToDfsRequestObserver = new AddFileToDfsRequestObserver(_fakeDfs,
peerSettings,
_nodeFileTransferFactory,
logger);
}
protected MessageCorrelationManagerTests()
{
SubbedLogger = Substitute.For <ILogger>();
ChangeTokenProvider = Substitute.For <IChangeTokenProvider>();
var changeToken = Substitute.For <IChangeToken>();
ChangeTokenProvider.GetChangeToken().Returns(changeToken);
Cache = Substitute.For <IMemoryCache>();
_senderPeerId = PeerIdHelper.GetPeerId("sender");
PeerIds = new[]
{
PeerIdHelper.GetPeerId("peer1"),
PeerIdHelper.GetPeerId("peer2"),
PeerIdHelper.GetPeerId("peer3")
};
}
private IRepository <PeerDao, string> PopulatePeerRepo(ILifetimeScope scope, out PeerDao peerDaoOutput)
{
var peerRepo = scope.Resolve <IRepository <PeerDao, string> >();
var peerDao = new PeerDao().ToDao(new Peer {
PeerId = PeerIdHelper.GetPeerId(new Random().Next().ToString())
});
peerDao.Id = Guid.NewGuid().ToString();
peerDao.PeerIdentifier = new PeerIdDao().ToDao(PeerIdHelper.GetPeerId(new Random().Next().ToString()));
peerDao.PeerIdentifier.Id = Guid.NewGuid().ToString();
peerRepo.Add(peerDao);
peerDaoOutput = peerDao;
return(peerRepo);
}
public PeerServiceTests(ITestOutputHelper output) : base(output)
{
_pid = PeerIdHelper.GetPeerId("im_a_key");
_guid = CorrelationId.GenerateCorrelationId();
_logger = Substitute.For <ILogger>();
_serverChannel = new EmbeddedObservableChannel($"Server:{CurrentTestName}");
_udpServerServerChannelFactory = Substitute.For <IUdpServerChannelFactory>();
_peerSettings = Substitute.For <IPeerSettings>();
_peerSettings.BindAddress.Returns(IPAddress.Parse("127.0.0.1"));
_peerSettings.Port.Returns(1234);
_udpServerServerChannelFactory.BuildChannel(Arg.Any <IEventLoopGroupFactory>(), _peerSettings.BindAddress, _peerSettings.Port).Returns(_serverChannel);
_peerDiscovery = Substitute.For <IPeerDiscovery>();
_p2PMessageHandlers = new List <IP2PMessageObserver>();
}
public async Task Can_receive_PeerNeighborsResponse()
{
var pingRequestHandler = new TestMessageObserver <PeerNeighborsResponse>(_logger);
var neighbourIds = "abc".Select(i => PeerIdHelper.GetPeerId(i.ToString()));
var responseContent = new PeerNeighborsResponse();
responseContent.Peers.AddRange(neighbourIds);
var response = responseContent.ToProtocolMessage(_pid, _guid);
await InitialisePeerServiceAndSendMessage(pingRequestHandler, response).ConfigureAwait(false);
pingRequestHandler.SubstituteObserver.Received(1).OnNext(Arg.Any <PeerNeighborsResponse>());
var call = pingRequestHandler.SubstituteObserver.ReceivedCalls().Single();
((PeerNeighborsResponse)call.GetArguments()[0]).Peers
.Should().BeEquivalentTo(responseContent.Peers);
}
private static Peer[] PreparePeerRepositoryContent()
{
var blacklistedPeers = Enumerable.Range(0, 5).Select(i => new Peer
{
Reputation = 0,
PeerId = PeerIdHelper.GetPeerId($"blacklisted-{i}"),
BlackListed = true
});
var goodPeers = Enumerable.Range(0, 23).Select(i => new Peer
{
Reputation = 125,
PeerId = PeerIdHelper.GetPeerId($"good-{i}")
});
var fakePeers = blacklistedPeers.Concat(goodPeers).ToArray();
return(fakePeers);
}
public void CandidateDeltaBroadcastDao_CandidateDeltaBroadcast_Should_Be_Convertible()
{
var candidateDeltaBroadcastDao = GetMapper <CandidateDeltaBroadcastDao>();
var previousHash = _hashProvider.ComputeMultiHash(Encoding.UTF8.GetBytes("previousHash"));
var hash = _hashProvider.ComputeMultiHash(Encoding.UTF8.GetBytes("anotherHash"));
var original = new CandidateDeltaBroadcast
{
Hash = hash.ToArray().ToByteString(),
ProducerId = PeerIdHelper.GetPeerId("test"),
PreviousDeltaDfsHash = previousHash.ToArray().ToByteString()
};
var candidateDeltaBroadcast = candidateDeltaBroadcastDao.ToDao(original);
var reconverted = candidateDeltaBroadcast.ToProtoBuff();
reconverted.Should().Be(original);
}
public void When_voter_not_a_producer_should_not_save_vote()
{
var favourite = DeltaHelper.GetFavouriteDelta(_hashProvider);
_deltaProducersProvider
.GetDeltaProducersFromPreviousDelta(Arg.Any <Cid>())
.Returns(new List <PeerId> {
PeerIdHelper.GetPeerId("the only known producer")
});
var elector = new DeltaElector(_cache, _deltaProducersProvider, _reputationManager, _logger);
elector.OnNext(favourite);
_deltaProducersProvider.Received(1)
.GetDeltaProducersFromPreviousDelta(Arg.Is <Cid>(h =>
favourite.Candidate.PreviousDeltaDfsHash.Equals(h.ToArray().ToByteString())));
_cache.DidNotReceiveWithAnyArgs().TryGetValue(default, out _);
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 PeerBlackListingRequestObserverTests()
{
_logger = Substitute.For <ILogger>();
_fakeContext = Substitute.For <IChannelHandlerContext>();
var fakeChannel = Substitute.For <IChannel>();
_fakeContext.Channel.Returns(fakeChannel);
_fakeContext.Channel.RemoteAddress.Returns(EndpointBuilder.BuildNewEndPoint("192.0.0.1", 42042));
_testScheduler = new TestScheduler();
_peerRepository = Substitute.For <IPeerRepository>();
var fakePeers = PreparePeerRepositoryContent();
_peerRepository.GetAll().Returns(fakePeers);
_senderId = PeerIdHelper.GetPeerId("sender");
}
public DeltaVoterTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_cache = Substitute.For <IMemoryCache>();
_previousDeltaHash = _hashProvider.ComputeMultiHash(ByteUtil.GenerateRandomByteArray(32));
_producerIds = "1234"
.Select((c, i) => PeerIdHelper.GetPeerId(c.ToString()))
.Shuffle();
_producersProvider = Substitute.For <IDeltaProducersProvider>();
_producersProvider.GetDeltaProducersFromPreviousDelta(Arg.Any <MultiHash>())
.Returns(_producerIds);
_localIdentifier = PeerIdHelper.GetPeerId("myself, a producer");
_peerSettings = _localIdentifier.ToSubstitutedPeerSettings();
_logger = Substitute.For <ILogger>();
}
public async Task Can_Process_DeltaHeightRequest_Correctly()
{
var fakeContext = Substitute.For <IChannelHandlerContext>();
var deltaHistoryRequestMessage = new DeltaHistoryRequest();
var channeledAny = new ObserverDto(fakeContext,
deltaHistoryRequestMessage.ToProtocolMessage(PeerIdHelper.GetPeerId(),
CorrelationId.GenerateCorrelationId()
)
);
var observableStream = new[] { channeledAny }.ToObservable(_testScheduler);
_deltaHistoryRequestObserver.StartObserving(observableStream);
_testScheduler.Start();
var response = new DeltaHistoryResponse();
var hp = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
var lastDeltaHash = hp.ComputeMultiHash(ByteUtil.GenerateRandomByteArray(32));
for (uint x = 0; x < 10; x++)
{
var delta = new Delta
{
PreviousDeltaDfsHash = lastDeltaHash.Digest.ToByteString()
};
var index = new DeltaIndex
{
Height = 10,
Cid = delta.ToByteString()
};
response.DeltaIndex.Add(index);
lastDeltaHash = hp.ComputeMultiHash(ByteUtil.GenerateRandomByteArray(32));
}
await fakeContext.Channel.ReceivedWithAnyArgs(1)
.WriteAndFlushAsync(response.ToProtocolMessage(PeerIdHelper.GetPeerId(), CorrelationId.GenerateCorrelationId())).ConfigureAwait(false);
_subbedLogger.ReceivedWithAnyArgs(1);
}
public void Init()
{
_keySigner = Substitute.For <FakeKeySigner>();
_keySigner.Verify(Arg.Any <ISignature>(), Arg.Any <byte[]>(), default).ReturnsForAnyArgs(true);
_fakeBroadcastManager = Substitute.For <IBroadcastManager>();
_broadcastHandler = new BroadcastHandler(_fakeBroadcastManager);
var fakeSignature = Substitute.For <ISignature>();
fakeSignature.SignatureBytes.Returns(ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength));
_signingContext = DevNetPeerSigningContext.Instance;
var peerId = PeerIdHelper.GetPeerId("Test");
var innerMessage = new TransactionBroadcast();
_broadcastMessageSigned = innerMessage
.ToSignedProtocolMessage(peerId, fakeSignature, _signingContext)
.ToSignedProtocolMessage(peerId, fakeSignature, _signingContext);
}
public static ICommandContext GenerateCliCommandContext()
{
var userOutput = Substitute.For <IUserOutput>();
var nodeRpcClientFactory = Substitute.For <IRpcClientFactory>();
var certificateStore = Substitute.For <ICertificateStore>();
var commandContext = Substitute.For <ICommandContext>();
commandContext.UserOutput.Returns(userOutput);
commandContext.RpcClientFactory.Returns(nodeRpcClientFactory);
commandContext.CertificateStore.Returns(certificateStore);
IHashProvider hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
var deltaMultiHash = hashProvider.ComputeUtf8MultiHash("previous");
commandContext.PeerId.Returns(
PeerIdHelper.GetPeerId(deltaMultiHash.Digest, IPAddress.Any, 9010));
return(commandContext);
}
public GetDeltaRequestObserverTests()
{
var builder = new ContainerBuilder();
builder.RegisterModule <HashingModule>();
var container = builder.Build();
container.BeginLifetimeScope();
_hashProvider = container.Resolve <IHashProvider>();
_testScheduler = new TestScheduler();
var logger = Substitute.For <ILogger>();
var peerIdentifier = PeerIdHelper.GetPeerId("responder");
var peerSettings = peerIdentifier.ToSubstitutedPeerSettings();
_deltaCache = Substitute.For <IDeltaCache>();
_observer = new GetDeltaRequestObserver(_hashProvider, _deltaCache, peerSettings, logger);
_fakeContext = Substitute.For <IChannelHandlerContext>();
}
public BadFavouritesData()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
Add(null, typeof(ArgumentNullException));
Add(new FavouriteDeltaBroadcast(), typeof(InvalidDataException));
Add(new FavouriteDeltaBroadcast
{
Candidate = new CandidateDeltaBroadcast
{
Hash = ByteUtil.GenerateRandomByteArray(32).ToByteString(),
ProducerId = PeerIdHelper.GetPeerId("unknown_producer")
},
VoterId = PeerIdHelper.GetPeerId("candidate field is invalid")
}, typeof(InvalidDataException));
Add(new FavouriteDeltaBroadcast
{
Candidate = DeltaHelper.GetCandidateDelta(hashProvider)
}, typeof(InvalidDataException));
}
