public void SubscribeToPeerConnectedOrDisconnectedTest()
        {
            var bus = new YottoBusFactory().Create();

            using (var peer1 = bus.CreatePeer())
                using (var peer2 = bus.CreatePeer())
                {
                    peer1.Connect();

                    var subscriberForConnected    = new SubscriberFor <PeerConnected>();
                    var subscriberForDisconnected = new SubscriberFor <PeerDisconnected>();
                    peer1.Register(subscriberForConnected);
                    peer1.Register(subscriberForDisconnected);

                    Thread.Sleep(50);

                    peer2.Connect();

                    AwaitAssert(TimeSpan.FromSeconds(10), () =>
                    {
                        Assert.True(subscriberForConnected.ReceivedMessages.Any(m => m is PeerConnected && ((PeerConnected)m).Identity.Equals(peer2.Identity)));
                    });

                    peer2.Disconnect();

                    AwaitAssert(TimeSpan.FromSeconds(10), () =>
                    {
                        Assert.True(subscriberForDisconnected.ReceivedMessages.Any(m => m is PeerDisconnected && ((PeerDisconnected)m).Identity.Equals(peer2.Identity)));
                    });
                }
        }
        public void SendDedicatedMessageTest()
        {
            var bus = new YottoBusFactory().Create();

            using (var peer1 = bus.CreatePeer())
                using (var peer2 = bus.CreatePeer())
                {
                    peer1.Connect();
                    peer2.Connect();

                    var subscriberToReceive = new SubscriberFor <string>();
                    var subscriberToSkip    = new SubscriberFor <string>();
                    peer1.Register(subscriberToReceive);
                    peer2.Register(subscriberToSkip);

                    Thread.Sleep(50);

                    var message = "Hello";
                    peer2.Send(message, peer1.Identity);

                    AwaitAssert(TimeSpan.FromSeconds(5), () =>
                    {
                        CollectionAssert.Contains(subscriberToReceive.ReceivedMessages, message);
                    });

                    Thread.Sleep(1000);

                    CollectionAssert.IsEmpty(subscriberToSkip.ReceivedMessages);
                }
        }
        public void PublishSubscribeTest()
        {
            var bus = new YottoBusFactory().Create();

            using (var peer1 = bus.CreatePeer())
            {
                peer1.Connect();

                var subscriber = new SubscriberFor <string>();
                peer1.Register(subscriber);

                Thread.Sleep(50);

                var message = "Hello";
                peer1.Publish(message);

                AwaitAssert(TimeSpan.FromSeconds(5), () =>
                {
                    CollectionAssert.Contains(subscriber.ReceivedMessages, message);
                    CollectionAssert.Contains(subscriber.MessageSenders, peer1.Identity);
                });
            }
        }
        public void PeersInDifferentContextDoNotReceiveSubscribedMessages()
        {
            var bus = new YottoBusFactory().Create();

            using (var peer1 = bus.CreatePeer("contextOne"))
                using (var peer2 = bus.CreatePeer("contextTwo"))
                {
                    peer1.Connect();
                    peer2.Connect();

                    var subscriber = new SubscriberFor <string>();
                    peer1.Register(subscriber);

                    Thread.Sleep(50);

                    var message = "Hello";
                    peer2.Publish(message);

                    Thread.Sleep(5000);

                    CollectionAssert.DoesNotContain(subscriber.ReceivedMessages, message);
                    CollectionAssert.DoesNotContain(subscriber.MessageSenders, peer1.Identity);
                }
        }