private async Task StartTestTransportAsync(
TestTransport transport,
CancellationToken cancellationToken = default(CancellationToken))
{
_ = transport.StartAsync(cancellationToken);
await transport.WaitForRunningAsync();
}
public async Task DoNotBroadcastToSourcePeer()
{
TestTransport transportA = CreateTestTransport(new PrivateKey());
TestTransport transportB = CreateTestTransport(new PrivateKey());
TestTransport transportC = CreateTestTransport(new PrivateKey());
await StartTestTransportAsync(transportA);
await StartTestTransportAsync(transportB);
await StartTestTransportAsync(transportC);
try
{
await transportA.AddPeersAsync(new[] { transportB.AsPeer }, null);
await transportB.AddPeersAsync(new[] { transportC.AsPeer }, null);
transportA.BroadcastTestMessage(null, "foo");
await transportC.WaitForTestMessageWithData("foo");
await Task.Delay(100);
Assert.True(transportC.ReceivedTestMessageOfData("foo"));
Assert.False(transportA.ReceivedTestMessageOfData("foo"));
}
finally
{
transportA.Dispose();
transportB.Dispose();
transportC.Dispose();
}
}
public async Task RefreshTable()
{
const int peersCount = 10;
var privateKey = new PrivateKey();
var privateKeys = Enumerable.Range(0, peersCount).Select(
i => GeneratePrivateKeyOfBucketIndex(privateKey.ToAddress(), i / 2));
TestTransport transport = CreateTestTransport(privateKey);
TestTransport[] transports =
privateKeys.Select(key => CreateTestTransport(key)).ToArray();
await StartTestTransportAsync(transport);
foreach (var t in transports)
{
await StartTestTransportAsync(t);
}
try
{
foreach (var t in transports)
{
transport.Table.AddPeer(
(BoundPeer)t.AsPeer,
DateTimeOffset.UtcNow - TimeSpan.FromMinutes(2));
}
IReadOnlyList <BoundPeer> refreshCandidates =
transport.Table.PeersToRefresh(TimeSpan.FromMinutes(1));
Assert.Equal(peersCount, transport.Peers.Count());
Assert.Equal(peersCount / 2, refreshCandidates.Count);
Assert.Equal(peersCount / 2, transport.Table.NonEmptyBuckets.Count());
await transport.Protocol.RefreshTableAsync(TimeSpan.FromMinutes(1), default);
Assert.NotEqual(
refreshCandidates.ToHashSet(),
transport.Table.PeersToRefresh(TimeSpan.FromMinutes(1)).ToHashSet());
Assert.Equal(
peersCount / 2,
transport.Table.PeersToRefresh(TimeSpan.FromMinutes(1)).Count());
Assert.Equal(peersCount / 2, transport.Table.NonEmptyBuckets.Count());
await transport.Protocol.RefreshTableAsync(TimeSpan.FromMinutes(1), default);
Assert.Empty(transport.Table.PeersToRefresh(TimeSpan.FromMinutes(1)));
}
finally
{
transport.Dispose();
foreach (var t in transports)
{
t.Dispose();
}
}
}
public async Task BroadcastMessage(int count)
{
var seed = CreateTestTransport();
await StartTestTransportAsync(seed);
var transports = new TestTransport[count];
for (var i = 0; i < count; i++)
{
transports[i] = CreateTestTransport();
await StartTestTransportAsync(transports[i]);
}
try
{
foreach (var transport in transports)
{
await transport.BootstrapAsync(new[] { seed.AsPeer });
}
Log.Debug("Bootstrap completed.");
var tasks =
transports.Select(transport => transport.WaitForTestMessageWithData("foo"));
seed.BroadcastTestMessage(null, "foo");
Log.Debug("Broadcast completed.");
await Task.WhenAll(tasks);
}
finally
{
seed.Dispose();
foreach (var transport in transports)
{
Assert.True(transport.ReceivedTestMessageOfData("foo"));
transport.Dispose();
}
}
}
