public void Should_unsubscribe_on_dispose_then_publish_event_to_subscribers()
        {
            //Arrange
            Messenger unit = GetUnit();

            UnitTestMessage unityTestMessage = new UnitTestMessage();

            //Act
            UnitTestMessage    message1          = null;
            ISubscriptionToken subscriptionToken = unit.Subscribe((UnitTestMessage message) =>
            {
                message1 = message;
            });
            UnitTestMessage message2 = null;

            unit.Subscribe((UnitTestMessage message) =>
            {
                message2 = message;
            });

            subscriptionToken.Dispose();

            unit.Publish(unityTestMessage);

            //Assert
            Assert.Null(message1);
            Assert.AreEqual(unityTestMessage, message2);
        }
        public void Should_publish_event_to_subscribers()
        {
            //Arrange
            Messenger unit = GetUnit();

            UnitTestMessage unityTestMessage = new UnitTestMessage();

            //Act
            UnitTestMessage message1 = null;

            unit.Subscribe((UnitTestMessage message) =>
            {
                message1 = message;
            });
            UnitTestMessage message2 = null;

            unit.Subscribe((UnitTestMessage message) =>
            {
                message2 = message;
            });

            unit.Publish(unityTestMessage);

            //Assert
            Assert.AreEqual(unityTestMessage, message1);
            Assert.AreEqual(unityTestMessage, message2);
        }
 private async Task HandleMessage(UnitTestMessage message)
 {
     await Task.Run(() =>
     {
         genericCallbackCalled = true;
     });
 }
        public async void HandleMessageAsync_ValidMessage_Successful()
        {
            // Arrange
            MessageHandler <UnitTestMessage> messageHandler = new MessageHandler <UnitTestMessage>(HandleMessage);
            UnitTestMessage message = new UnitTestMessage();

            // Act
            await messageHandler.HandleMessageAsync(message);

            // Assert
            Assert.True(genericCallbackCalled);
        }
        public void CanHandle_NotValidMessage_False()
        {
            // Arrange
            MessageHandler <IMessage> messageHandler = new MessageHandler <IMessage>(HandleMessage);
            UnitTestMessage           message        = new UnitTestMessage();
            bool result;

            // Act
            result = messageHandler.CanHandle(message);

            // Assert
            Assert.False(result);
        }
        public void SendMessage_ValidMessage_MessageIsInPipeline()
        {
            // Arrange
            MessageSystem   messageSystem = new MessageSystem();
            UnitTestMessage message       = new UnitTestMessage();

            // Act
            messageSystem.SendMessage(message);

            // Assert
            Assert.Single(messageSystem.ActiveMessages);
            Assert.IsType <UnitTestMessage>(messageSystem.ActiveMessages.First());
        }
        public async void ProcessMessages_Successful()
        {
            // Arrange
            MessageSystem   messageSystem = new MessageSystem();
            UnitTestMessage message       = new UnitTestMessage();

            messageSystem.RegisterReceiver <UnitTestMessage>(HandleMessage);
            messageSystem.SendMessage(message);

            // Act
            await messageSystem.ProcessMessagesAsync();

            // Assert
            Assert.Empty(messageSystem.ActiveMessages);
            Assert.True(callbackExecuted);
        }