// [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 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);
            }
        }
Esempio n. 3
0
        public async Task PeerServerChannelFactory_should_put_the_correct_handlers_on_the_inbound_pipeline()
        {
            var testingChannel = new EmbeddedChannel("test".ToChannelId(),
                                                     true, _factory.InheritedHandlers.ToArray());

            var protocolMessage = new PingRequest().ToProtocolMessage(_senderId, _correlationId);

            var signedMessage = protocolMessage.ToSignedProtocolMessage(signature: _signature);

            var observer = new ProtocolMessageObserver(0, Substitute.For <ILogger>());

            var messageStream = GetObservableServiceHandler().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(signedMessage.CorrelationId.ToCorrelationId().Id);
            }
        }
        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();
        }
Esempio n. 5
0
        RpcClientChannelFactory_Pipeline_Should_Produce_Request_Object_RpcServerChannelFactory_Can_Process_Into_Observable()
        {
            var recipient = PeerIdHelper.GetPeerId("recipient");
            var sender    = PeerIdHelper.GetPeerId("sender");
            var signature = Substitute.For <ISignature>();

            signature.SignatureBytes.Returns(ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength));

            _peerIdValidator.ValidatePeerIdFormat(Arg.Any <PeerId>()).Returns(true);

            _clientKeySigner.Sign(Arg.Any <byte[]>(), default).ReturnsForAnyArgs(signature);

            var correlationId = CorrelationId.GenerateCorrelationId();

            var protocolMessage = new GetPeerCountRequest().ToProtocolMessage(sender, correlationId);
            var dto             = new MessageDto(
                protocolMessage,
                recipient
                );

            _clientChannel.WriteOutbound(dto);

            var sentBytes = _clientChannel.ReadOutbound <IByteBuffer>();

            // obviously
            sentBytes.Should().BeAssignableTo <IByteBuffer>();

            _clientCorrelationManager.ReceivedWithAnyArgs(1).AddPendingRequest(
                Arg.Is <CorrelatableMessage <ProtocolMessage> >(c =>
                                                                c.Content.CorrelationId.ToCorrelationId().Equals(correlationId)));

            _clientKeySigner.ReceivedWithAnyArgs(1).Sign(Arg.Is(signature.SignatureBytes), default);

            _serverKeySigner.Verify(
                Arg.Any <ISignature>(),
                Arg.Any <byte[]>(),
                default
                )
            .ReturnsForAnyArgs(true);

            _authenticationStrategy.Authenticate(Arg.Any <PeerId>()).Returns(true);

            var observer = new ProtocolMessageObserver(0, Substitute.For <ILogger>());

            var messageStream = _serverFactory.InheritedHandlers.OfType <ObservableServiceHandler>().Single()
                                .MessageStream;

            using (messageStream.Subscribe(observer))
            {
                _serverChannel.WriteInbound(sentBytes);
                _serverCorrelationManager.DidNotReceiveWithAnyArgs().TryMatchResponse(protocolMessage);

                _serverKeySigner.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();
        }