Example #1
0
        public void RemoveMessageRouteForNode_RemovesAllActorRegistrationsForThisMessageForThisNode()
        {
            var nodeIdentity       = Guid.NewGuid().ToByteArray();
            var messageIdentifier  = MessageIdentifier.Create <SimpleMessage>();
            var routeRegistrations = EnumerableExtensions.Produce(Randomizer.Int32(3, 10),
                                                                  () => CreateActorRouteRegistration(messageIdentifier,
                                                                                                     ReceiverIdentities.CreateForActor(),
                                                                                                     nodeIdentity));

            routeRegistrations.ForEach(r => externalRoutingTable.AddMessageRoute(r));
            //
            var res = externalRoutingTable.RemoveMessageRoute(new ExternalRouteRemoval
            {
                Route = new MessageRoute {
                    Message = messageIdentifier
                },
                NodeIdentifier = nodeIdentity
            });

            //
            Assert.AreEqual(PeerConnectionAction.Disconnect, res.ConnectionAction);
            var externalRouteLookupRequest = new ExternalRouteLookupRequest
            {
                ReceiverNodeIdentity = new ReceiverIdentifier(nodeIdentity)
            };

            CollectionAssert.IsEmpty(externalRoutingTable.FindRoutes(externalRouteLookupRequest));
        }
Example #2
0
        private void IfNodeIdentifierIsNotProvidedOrNotFound_PeerRemovalResultIsNotFound(byte[] removeNodeIdentity)
        {
            var nodeIdentity      = Guid.NewGuid().ToByteArray();
            var messageIdentifier = MessageIdentifier.Create <SimpleMessage>();
            var routeRegistration = CreateActorRouteRegistration(messageIdentifier,
                                                                 ReceiverIdentities.CreateForActor(),
                                                                 nodeIdentity);

            externalRoutingTable.AddMessageRoute(routeRegistration);
            //
            var res = externalRoutingTable.RemoveMessageRoute(new ExternalRouteRemoval
            {
                Route = new MessageRoute {
                    Message = messageIdentifier
                },
                NodeIdentifier = removeNodeIdentity
            });

            //
            Assert.AreEqual(PeerConnectionAction.NotFound, res.ConnectionAction);
            var externalRouteLookupRequest = new ExternalRouteLookupRequest
            {
                ReceiverNodeIdentity = new ReceiverIdentifier(nodeIdentity)
            };

            CollectionAssert.IsNotEmpty(externalRoutingTable.FindRoutes(externalRouteLookupRequest));
        }
Example #3
0
        public void RemoveNodeRoute_RemovesAllNodeRoutes()
        {
            var nodeIdentity       = Guid.NewGuid().ToByteArray();
            var routeRegistrations = EnumerableExtensions.Produce(Randomizer.Int32(3, 10),
                                                                  () =>
            {
                var messageIdentifier = new MessageIdentifier(Guid.NewGuid().ToByteArray(),
                                                              Randomizer.UInt16(),
                                                              Guid.NewGuid().ToByteArray());
                return(CreateActorRouteRegistration(messageIdentifier,
                                                    ReceiverIdentities.CreateForActor(),
                                                    nodeIdentity));
            });

            routeRegistrations.ForEach(r => externalRoutingTable.AddMessageRoute(r));
            //
            externalRoutingTable.RemoveNodeRoute(new ReceiverIdentifier(nodeIdentity));
            //
            var externalRouteLookupRequest = new ExternalRouteLookupRequest
            {
                ReceiverNodeIdentity = new ReceiverIdentifier(nodeIdentity)
            };

            CollectionAssert.IsEmpty(externalRoutingTable.FindRoutes(externalRouteLookupRequest));
        }
Example #4
0
        public void FindRoutesByMessageSentUnicast_ReturnsOneRoutes()
        {
            var messageIdentifier  = MessageIdentifier.Create <SimpleMessage>();
            var routeRegistrations = EnumerableExtensions.Produce(Randomizer.Int32(3, 10),
                                                                  () => CreateActorRouteRegistration(messageIdentifier));

            routeRegistrations.ForEach(r => externalRoutingTable.AddMessageRoute(r));
            //
            var externalRouteLookupRequest = new ExternalRouteLookupRequest
            {
                Message      = messageIdentifier,
                Distribution = DistributionPattern.Unicast
            };

            Assert.DoesNotThrow(() => externalRoutingTable.FindRoutes(externalRouteLookupRequest).Single());
        }
Example #5
0
        public void IfNoRoutesRegisteredForMessage_EmptyListOfPeerConnectionsReturned()
        {
            var routeRegistration = CreateActorRouteRegistration(MessageIdentifier.Create <SimpleMessage>());
            var messageIdentifier = MessageIdentifier.Create <AsyncExceptionMessage>();

            externalRoutingTable.AddMessageRoute(routeRegistration);
            //
            var externalRouteLookupRequest = new ExternalRouteLookupRequest
            {
                Message = messageIdentifier,
                ReceiverNodeIdentity = null
            };
            var routes = externalRoutingTable.FindRoutes(externalRouteLookupRequest);

            //
            CollectionAssert.IsEmpty(routes);
        }
Example #6
0
        public void FindRoutesByMessageSentUnicast_ReturnsOneRoutes()
        {
            var messageIdentifier = MessageIdentifier.Create <SimpleMessage>();

            Randomizer.Int32(3, 10)
            .Produce(() => CreateActorRouteRegistration(messageIdentifier))
            .ForEach(r => externalRoutingTable.AddMessageRoute(r))
            .ToList();
            //
            var externalRouteLookupRequest = new ExternalRouteLookupRequest
            {
                Message      = messageIdentifier,
                Distribution = DistributionPattern.Unicast
            };

            externalRoutingTable.FindRoutes(externalRouteLookupRequest).Single();
        }
Example #7
0
        public void FindRoutesByMessageSentBroadcast_ReturnsAllRegisteredRoutes()
        {
            var messageIdentifier  = MessageIdentifier.Create <SimpleMessage>();
            var routeRegistrations = EnumerableExtensions.Produce(Randomizer.Int32(3, 10),
                                                                  () => CreateActorRouteRegistration(messageIdentifier));

            routeRegistrations.ForEach(r => externalRoutingTable.AddMessageRoute(r));
            //
            var externalRouteLookupRequest = new ExternalRouteLookupRequest
            {
                Message      = messageIdentifier,
                Distribution = DistributionPattern.Broadcast
            };
            var routes = externalRoutingTable.FindRoutes(externalRouteLookupRequest);

            //
            Assert.AreEqual(routeRegistrations.Count(), routes.Count());
        }
Example #8
0
        public void IfAllNodeMessageRoutesAreRemoved_PeerIsDisconnected()
        {
            var nodeIdentity      = Guid.NewGuid().ToByteArray();
            var messageIdentifier = MessageIdentifier.Create <SimpleMessage>();
            var actors            = Randomizer.Int32(3, 10)
                                    .Produce(ReceiverIdentities.CreateForActor);

            actors.Select(actor => CreateActorRouteRegistration(messageIdentifier,
                                                                actor,
                                                                nodeIdentity))
            .ForEach(r => externalRoutingTable.AddMessageRoute(r))
            .ToList();
            //

            for (var i = 0; i < actors.Count(); i++)
            {
                var externalRouteRemoval = new ExternalRouteRemoval
                {
                    NodeIdentifier = nodeIdentity,
                    Route          = new MessageRoute
                    {
                        Message  = messageIdentifier,
                        Receiver = actors.ElementAt(i)
                    }
                };
                var res = externalRoutingTable.RemoveMessageRoute(externalRouteRemoval);
                if (LastMessageRouteRemoved(i, actors.Count()))
                {
                    Assert.Equal(PeerConnectionAction.Disconnect, res.ConnectionAction);
                }
                else
                {
                    Assert.Equal(PeerConnectionAction.KeepConnection, res.ConnectionAction);
                }
            }
            //
            var externalRouteLookupRequest = new ExternalRouteLookupRequest
            {
                ReceiverNodeIdentity = new ReceiverIdentifier(nodeIdentity)
            };

            Assert.Empty(externalRoutingTable.FindRoutes(externalRouteLookupRequest));
        }
Example #9
0
        public void FindRoutesByMessage_ReturnsRouteRegardlessOfReceiverNode()
        {
            var routeRegistration = CreateActorRouteRegistration();
            var messageIdentifier = routeRegistration.Route.Message;

            externalRoutingTable.AddMessageRoute(routeRegistration);
            //
            var externalRouteLookupRequest = new ExternalRouteLookupRequest
            {
                Message = messageIdentifier,
                ReceiverNodeIdentity = null
            };
            var route = externalRoutingTable.FindRoutes(externalRouteLookupRequest)
                        .First();

            //
            Assert.AreEqual(routeRegistration.Peer, route.Node);
            Assert.AreEqual(routeRegistration.Health.Uri, route.Health.Uri);
            Assert.AreEqual(routeRegistration.Health.HeartBeatInterval, route.Health.HeartBeatInterval);
            Assert.IsFalse(route.Connected);
        }