public void PublishMessageUsingPublicationAddressNoAckTest()
        {
            // Arrange
            byte[] messageBody            = { 0xBE, 0xBE };
            var    routingKeyTest         = "routingkeytest";
            var    exchangeNameTest       = "exchangenametest";
            var    publicationAddressTest = new PublicationAddress(ExchangeType.Topic, exchangeNameTest, routingKeyTest);

            var modelMock = new Mock <IModel>();

            modelMock.Setup(m => m.BasicPublish(exchangeNameTest, routingKeyTest, It.IsAny <bool>(), It.IsAny <IBasicProperties>(), messageBody))
            .Verifiable("Message was not published");

            var requestModelPublisher = Mock.Of <IRequestModelPublisher>();
            var rabbitModelPublisher  = Sys.ActorOf(RabbitModelPublisher.CreateProps(modelMock.Object, requestModelPublisher));

            var publishMessageUsingRoutingKey = Mock.Of <IPublishMessageUsingPublicationAddress>(pmurk =>
                                                                                                 pmurk.PublicationAddress == publicationAddressTest &&
                                                                                                 pmurk.Message == messageBody);

            // Act
            rabbitModelPublisher.Tell(publishMessageUsingRoutingKey);

            // Assert
            AwaitAssert(() => modelMock.VerifyAll(), TimeSpan.FromSeconds(5), TimeSpan.FromMilliseconds(100));
        }
        public void PublishMessageToQueueNoAckTest()
        {
            // Arrange
            byte[] messageBody   = { 0xBE, 0xBE };
            var    queueNameTest = "queueNameTest";


            var modelMock = new Mock <IModel>();

            modelMock.Setup(m => m.BasicPublish(string.Empty, queueNameTest, It.IsAny <bool>(), It.IsAny <IBasicProperties>(), messageBody))
            .Verifiable("Message was not published");

            var requestModelPublisher = Mock.Of <IRequestModelPublisher>();
            var rabbitModelPublisher  = Sys.ActorOf(RabbitModelPublisher.CreateProps(modelMock.Object, requestModelPublisher));

            var publishMessageUsingRoutingKey = Mock.Of <IPublishMessageToQueue>(pmtq =>
                                                                                 pmtq.QueueName == queueNameTest &&
                                                                                 pmtq.Message == messageBody);

            // Act
            rabbitModelPublisher.Tell(publishMessageUsingRoutingKey);

            // Assert
            AwaitAssert(() => modelMock.VerifyAll(), TimeSpan.FromSeconds(5), TimeSpan.FromMilliseconds(100));
        }
        public async Task PublishMessageUsingRoutingKeyWithAckWaitsForAckAndTimeouts()
        {
            // Arrange
            byte[] message1Body     = { 0xBE, 0xBE };
            var    routingKeyTest   = "routingkeytest";
            var    exchangeNameTest = "exchangenametest";
            ulong  nextPublishSeqNo = 776;

            var modelMock = new Mock <IModel>();

            modelMock.Setup(m => m.NextPublishSeqNo).Returns(() => nextPublishSeqNo++);

            Expression <Action <IModel> > message1PublishAction = m => m.BasicPublish(exchangeNameTest, routingKeyTest,
                                                                                      It.IsAny <bool>(), It.IsAny <IBasicProperties>(), message1Body);

            modelMock.Setup(message1PublishAction)
            .Verifiable("Message 1 was not published");

            var requestModelPublisher =
                Mock.Of <IRequestModelPublisher>(rmp => rmp.WaitForPublishAcks == true &&
                                                 rmp.AckTimeout == TimeSpan.FromSeconds(1));
            var rabbitModelPublisher = Sys.ActorOf(RabbitModelPublisher.CreateProps(modelMock.Object, requestModelPublisher));

            var publishMessage1UsingRoutingKey = Mock.Of <IPublishMessageUsingRoutingKey>(pmurk =>
                                                                                          pmurk.RoutingKey == routingKeyTest &&
                                                                                          pmurk.ExchangeName == exchangeNameTest &&
                                                                                          pmurk.Message == message1Body);

            // Act
            var message1Task = await rabbitModelPublisher.Ask <Task <bool> >(publishMessage1UsingRoutingKey);

            // Assert
            AwaitAssert(() => modelMock.Verify(message1PublishAction, Times.Once), TimeSpan.FromSeconds(5), TimeSpan.FromMilliseconds(100));
            AwaitAssert(() => Assert.IsTrue(message1Task.IsFaulted), TimeSpan.FromMilliseconds(1100), TimeSpan.FromMilliseconds(100));
        }