public async Task HandleEvent_Test()
        {
            var eventData = new PeerConnectedEventData
                            (
                new NodeInfo {
                Endpoint = "127.0.0.1:1234", Pubkey = ByteString.CopyFromUtf8("Pubkey")
            },
                HashHelper.ComputeFrom("BestChainHash"),
                100
                            );

            AnnouncementReceivedEventData announcementEventData = null;

            _eventBus.Subscribe <AnnouncementReceivedEventData>(d =>
            {
                announcementEventData = d;
                return(Task.CompletedTask);
            });

            await _peerConnectedEventHandler.HandleEventAsync(eventData);

            var nodes = await _peerDiscoveryService.GetNodesAsync(1);

            nodes.Nodes[0].ShouldBe(eventData.NodeInfo);

            announcementEventData.ShouldNotBeNull();
            announcementEventData.Announce.BlockHash.ShouldBe(eventData.BestChainHash);
            announcementEventData.Announce.BlockHeight.ShouldBe(eventData.BestChainHeight);
            announcementEventData.SenderPubKey.ShouldBe(eventData.NodeInfo.Pubkey.ToHex());
        }
Esempio n. 2
0
        public async Task ConfirmHandshake_Test()
        {
            PeerConnectedEventData received = null;

            _eventBus.Subscribe <PeerConnectedEventData>(t =>
            {
                received = t;
                return(Task.CompletedTask);
            });
            var request = new ConfirmHandshakeRequest();
            var context = BuildServerCallContext(null, "ipv4:127.0.0.1:7878");

            var result = await _serverService.ConfirmHandshake(request, context);

            result.ShouldBe(new VoidReply());
            received.ShouldBe(null);

            var peer     = _peerPool.GetPeers(true).First();
            var pubkey   = peer.Info.Pubkey;
            var metadata = new Metadata {
                { GrpcConstants.PubkeyMetadataKey, pubkey }
            };

            context = BuildServerCallContext(metadata, "ipv4:127.0.0.1:7878");
            result  = await _serverService.ConfirmHandshake(request, context);

            result.ShouldBe(new VoidReply());
            received.ShouldNotBeNull();
        }
Esempio n. 3
0
        public async Task DialPeerAsync_GoodPeer_ShouldLaunchConnectionEvent()
        {
            PeerConnectedEventData eventData = null;

            _eventBus.Subscribe <PeerConnectedEventData>(e =>
            {
                eventData = e;
                return(Task.CompletedTask);
            });

            // two different hosts with the same pubkey.
            IpEndPointHelper.TryParse(NetworkTestConstants.GoodPeerEndpoint, out var endpoint);
            var added = await _networkServer.ConnectAsync(endpoint);

            added.ShouldBeTrue();
            _peerPool.FindPeerByEndpoint(endpoint).ShouldNotBeNull();

            eventData.ShouldNotBeNull();
        }
        public void ConfirmHandshake_Test()
        {
            PeerConnectedEventData eventData = null;

            _eventBus.Subscribe <PeerConnectedEventData>(e =>
            {
                eventData = e;
                return(Task.CompletedTask);
            });

            _connectionService.ConfirmHandshake(NetworkTestConstants.FakePubkey);
            eventData.ShouldBeNull();

            var peer = CreatePeerAndAddToPeerPool();

            _connectionService.ConfirmHandshake(NetworkTestConstants.FakePubkey);
            peer.IsConnected.ShouldBeTrue();
            peer.SyncState.ShouldBe(SyncState.Syncing);

            eventData.ShouldNotBeNull();
        }
        public async Task DialPeerAsync_GoodPeer_Test()
        {
            PeerConnectedEventData eventData = null;

            _eventBus.Subscribe <PeerConnectedEventData>(e =>
            {
                eventData = e;
                return(Task.CompletedTask);
            });

            AElfPeerEndpointHelper.TryParse(NetworkTestConstants.GoodPeerEndpoint, out var endpoint);

            var added = await _connectionService.ConnectAsync(endpoint);

            added.ShouldBeTrue();

            var peer = (GrpcPeer)_peerPool.FindPeerByEndpoint(endpoint);

            peer.ShouldNotBeNull();
            peer.IsConnected.ShouldBeTrue();
            peer.SyncState.ShouldBe(SyncState.Syncing);

            eventData.ShouldNotBeNull();
        }