// [InlineData(2000)] // ~1m
#endif
        public async void Snowball_ConfirmsAndExecutes_SingleMessage(int peersCount)
        {
            var hashResolver = new FakeHashResolver();
            var executor     = await ExecutorFakes.GetExecutor(ExecutorFakes.TestAgents);

            var peerConnectorProvider = new FakePeerConnectorProvider();
            var peers = Enumerable.Range(0, peersCount).Select(x => FakePeerConnectorProvider.GetFakePeer()).ToArray();

            var snowballParameters = await hashResolver.StoreAsync <object>(new SnowballParameters(5, 0.8, 25));

            var(chain, inputMessages, expectedOutputMessages) = await ExecutorFakes.GetTestAgentScenario(hashResolver, "Apocryph-SnowballConsensus", snowballParameters, peersCount);

            var chainId = Hash.From(chain);

            var started = new TaskCompletionSource <bool>();

            async IAsyncEnumerable <(Hash <Chain>, Slot?[])> kothStates()
            {
                await started.Task;

                yield return(chainId, peers.Select(peer => (Slot?)new Slot(peer, new byte[0])).ToArray());
            }

            var outputStreams = await SnowballFakes.StartSnowballNetwork(peers, hashResolver, peerConnectorProvider, chain, executor,
                                                                         peer => (inputMessages.ToAsyncEnumerable(), "-", kothStates()));

            started.TrySetResult(true);

            // NOTE: Using WhenAll here, since (A) we need to iterate all streams fully and (B) PerperFakeStream does not propagate completion

            var cancellation = new CancellationTokenSource();

            await Task.WhenAll(outputStreams.Select(async stream =>
            {
                try
                {
                    var enumerator = stream.GetAsyncEnumerator();
                    foreach (var expectedMessage in expectedOutputMessages)
                    {
                        await enumerator.MoveNextAsync(cancellation.Token);
                        Assert.Equal(enumerator.Current, expectedMessage, SerializedComparer.Instance);
                    }
                    // NOTE: Would be nice to confirm there are no other stream items
                }
                catch (Exception e)
                {
                    _output.WriteLine(e.ToString());
                    throw;
                }
            }));

            cancellation.Cancel();
        }
Пример #2
0
        public async void ExecutionStream_Returns_ExpectedMesages()
        {
            var hashResolver = new FakeHashResolver();
            var executor     = await ExecutorFakes.GetExecutor(ExecutorFakes.TestAgents);

            var(chain, inputMessages, expectedOutputMessages) = await ExecutorFakes.GetTestAgentScenario(hashResolver, "Apocryph-DummyConsensus", null, 1);

            var dummyConsensus = new DummyConsensus();

            var outputMessages = await dummyConsensus.ExecutionStream((inputMessages.ToAsyncEnumerable(), chain, executor), hashResolver).ToArrayAsync();

            Assert.Equal(outputMessages, expectedOutputMessages, SerializedComparer.Instance);
        }