public async Task WhenPublishGivenModifierConfiguredForMessageTypeThenModifierExecuted()
        {
            // arrange
            BusBuilder.Produce <SomeMessage>(x =>
            {
                x.DefaultTopic("default-topic");
                x.WithModifier((message, sbMessage) =>
                {
                    sbMessage.MessageId    = message.Id;
                    sbMessage.PartitionKey = (message.Value % 2).ToString(CultureInfo.InvariantCulture);
                });
            });

            var m1 = new SomeMessage {
                Id = "1", Value = 10
            };
            var m2 = new SomeMessage {
                Id = "2", Value = 3
            };

            // act
            await ProviderBus.Value.Publish(m1).ConfigureAwait(false);

            await ProviderBus.Value.Publish(m2).ConfigureAwait(false);

            // assert
            var topicClient = TopicClientMockByName["default-topic"];

            topicClient.Verify(x => x.SendAsync(It.Is <Message>(m => m.MessageId == "1" && m.PartitionKey == "0")), Times.Once);
            topicClient.Verify(x => x.SendAsync(It.Is <Message>(m => m.MessageId == "2" && m.PartitionKey == "1")), Times.Once);
        }
        public async Task WhenPublishTopicClientOrQueueClientIsCreatedForTopicNameOrQueueName()
        {
            // arrange
            BusBuilder.Produce <SomeMessage>(x => x.ToTopic());
            BusBuilder.Produce <OtherMessage>(x => x.ToQueue());

            var sm1 = new SomeMessage {
                Id = "1", Value = 10
            };
            var sm2 = new SomeMessage {
                Id = "2", Value = 12
            };
            var om1 = new OtherMessage {
                Id = "1"
            };
            var om2 = new OtherMessage {
                Id = "2"
            };

            // act
            await ProviderBus.Value.Publish(sm1, "some-topic").ConfigureAwait(false);

            await ProviderBus.Value.Publish(sm2, "some-topic").ConfigureAwait(false);

            await ProviderBus.Value.Publish(om1, "some-queue").ConfigureAwait(false);

            await ProviderBus.Value.Publish(om2, "some-queue").ConfigureAwait(false);

            // assert
            TopicClientMockByName.Should().ContainKey("some-topic");
            TopicClientMockByName.Should().HaveCount(1);
            QueueClientMockByName.Should().ContainKey("some-queue");
            QueueClientMockByName.Should().HaveCount(1);
        }
        public void WhenCreateGivenSameMessageTypeConfiguredTwiceForTopicAndForQueueThenConfigurationExceptionThrown()
        {
            // arrange
            BusBuilder.Produce <SomeMessage>(x => x.ToTopic());
            BusBuilder.Produce <SomeMessage>(x => x.ToQueue());

            // act
            Func <IMessageBus> creation = () => BusBuilder.Build();

            // assert
            creation.Should().Throw <ConfigurationMessageBusException>()
            .WithMessage($"The produced message type '{typeof(SomeMessage).FullName}' was declared more than once*");
        }
        public void WhenCreateGivenSameDefaultNameUsedForTopicAndForQueueThenConfigurationExceptionThrown()
        {
            // arrange
            const string name = "the-same-name";

            BusBuilder.Produce <SomeMessage>(x => x.DefaultTopic(name));
            BusBuilder.Produce <OtherMessage>(x => x.DefaultQueue(name));

            // act
            Func <IMessageBus> creation = () => BusBuilder.Build();

            // assert
            creation.Should().Throw <ConfigurationMessageBusException>()
            .WithMessage($"The same name '{name}' was used for queue and topic*");
        }