public void CanDoBatchReply()
{
// arrange
const string returnAddress = "some random return address";
var firstMessage = new FirstMessage();
var secondMessage = new SecondMessage();
var someRandomMessage = new SomeRandomMessage();
var fakeContext = Mock <IMessageContext>();
fakeContext.Stub(s => s.ReturnAddress).Return(returnAddress);
fakeContext.Stub(s => s.Headers).Return(new Dictionary <string, object>());
fakeContext.Stub(s => s.Items).Return(new Dictionary <string, object>());
// act
using (new NoTransaction())
using (FakeMessageContext.Establish(fakeContext))
{
bus.Batch.Reply(new object[] { firstMessage, secondMessage, someRandomMessage });
}
// assert
sendMessages.AssertWasCalled(s => s.Send(Arg <string> .Is.Equal(returnAddress),
Arg <TransportMessageToSend> .Is.Anything,
Arg <ITransactionContext> .Is.Anything),
o => o.Repeat.Once());
}
public async Task <IActionResult> TriggerFirstMessage()
{
var message = new FirstMessage();
await _publishEndpoint.Publish(message);
return(Ok());
}
public void CanPublishBatchOfMessages()
{
// arrange
storeSubscriptions.Stub(s => s.GetSubscribers(typeof(FirstMessage))).Return(new[] { "first-sub1", "first-sub2" });
storeSubscriptions.Stub(s => s.GetSubscribers(typeof(SecondMessage))).Return(new[] { "second-sub1", "second-sub2" });
// act
var firstMessage1 = new FirstMessage();
var firstMessage2 = new FirstMessage();
var secondMessage1 = new SecondMessage();
var secondMessage2 = new SecondMessage();
bus.AttachHeader(firstMessage1, "firstMessage1", "foo");
bus.AttachHeader(firstMessage2, "firstMessage2", "foo");
bus.AttachHeader(secondMessage1, "secondMessage1", "foo");
bus.AttachHeader(secondMessage2, "secondMessage2", "foo");
bus.Batch.Publish(new object[] { firstMessage1, secondMessage1, firstMessage2, secondMessage2 });
// assert
sendMessages.AssertWasCalled(s => s.Send(Arg <string> .Is.Equal("first-sub1"),
Arg <TransportMessageToSend> .Matches(t => t.Headers.ContainsKey("firstMessage1") && t.Headers.ContainsKey("firstMessage2")), Arg <ITransactionContext> .Is.Anything));
sendMessages.AssertWasCalled(s => s.Send(Arg <string> .Is.Equal("first-sub2"),
Arg <TransportMessageToSend> .Matches(t => t.Headers.ContainsKey("firstMessage1") && t.Headers.ContainsKey("firstMessage2")), Arg <ITransactionContext> .Is.Anything));
sendMessages.AssertWasCalled(s => s.Send(Arg <string> .Is.Equal("second-sub1"),
Arg <TransportMessageToSend> .Matches(t => t.Headers.ContainsKey("secondMessage1") && t.Headers.ContainsKey("secondMessage2")), Arg <ITransactionContext> .Is.Anything));
sendMessages.AssertWasCalled(s => s.Send(Arg <string> .Is.Equal("second-sub2"),
Arg <TransportMessageToSend> .Matches(t => t.Headers.ContainsKey("secondMessage1") && t.Headers.ContainsKey("secondMessage2")), Arg <ITransactionContext> .Is.Anything));
}
public void FirstMessageJsonToObject()
{
FirstMessage result = parser.ParseJsonToObject <FirstMessage>(GetFirstMessageJson());
FirstMessage expected = GetFirstMessageObject();
helper.CompareList <string>(expected.sa, result.sa);
helper.CompareList <string>(expected.sb, result.sb);
Assert.AreEqual(expected.sz, result.sz);
}
public void first_message_is_not_dispatcher_to_second_message_handler()
{
var firstMessage = new FirstMessage();
_autofacMessageResolver.GetMessageHandlersFor(firstMessage)
.Select(messageHandler => messageHandler.GetType().Name)
.Should().NotContain(
nameof(SecondMessageHandler));
}
public void first_message_is_dispatched_to_base_message_handlers()
{
var firstMessage = new FirstMessage();
_autofacMessageResolver.GetMessageHandlersFor(firstMessage)
.Select(messageHandler => messageHandler.GetType().Name)
.Should().Contain(
nameof(BaseMessageHandler1),
nameof(BaseMessageHandler2));
}
public void ThrowsIfReturnAddressIsInconsistentlySpecified()
{
// arrange
var someMessage = new FirstMessage();
var anotherMessage = new SecondMessage();
bus.AttachHeader(someMessage, Headers.ReturnAddress, "some-endpoint");
bus.AttachHeader(anotherMessage, Headers.ReturnAddress, "another-endpoint");
// act
// assert
Assert.Throws <InconsistentReturnAddressException>(() => bus.Batch.Send(new object[] { someMessage, anotherMessage }));
}
public void TransfersMessageIdToDeferredMessage()
{
var headers = new Dictionary <string, object>
{
{ Headers.MessageId, "Oh the uniqueness" }
};
var message = new FirstMessage();
using (MessageContext.Establish(headers))
{
bus.Defer(TimeSpan.Zero, message);
}
bus.GetHeaderFor(message, Headers.MessageId).ShouldBe("Oh the uniqueness");
}
public void DoesNotThrowIfReturnAddressIsSpecifiedMultipleTimesInConsistentManner()
{
// arrange
var someMessage = new FirstMessage();
var anotherMessage = new SecondMessage();
bus.AttachHeader(someMessage, Headers.ReturnAddress, "same-endpoint");
bus.AttachHeader(anotherMessage, Headers.ReturnAddress, "same-endpoint");
// act
// assert
Assert.DoesNotThrow(() => bus.Batch.Send(new object[] { someMessage, anotherMessage }));
sendMessages.AssertWasCalled(s => s.Send(Arg <string> .Is.Anything,
Arg <TransportMessageToSend> .Matches(t => true),
Arg <ITransactionContext> .Is.Anything));
}
public async Task Should_remove_saga_when_completed_in_whenenter()
{
var correlationId = Guid.NewGuid();
var firstMessage = new FirstMessage(correlationId);
await InputQueueSendEndpoint.Send(firstMessage);
Guid?saga = await _repository.ShouldContainSagaInState(correlationId, _machine, x => x.OtherState, TestTimeout);
Assert.IsTrue(saga.HasValue);
_taskCompletionSource.SetResult(true);
saga = await _repository.ShouldNotContainSaga(correlationId, TestTimeout);
Assert.IsFalse(saga.HasValue);
}
public async Task Should_have_combined_event()
{
var correlationId = Guid.NewGuid();
var firstMessage = new FirstMessage(correlationId);
var secondMessage = new SecondMessage(correlationId);
await InputQueueSendEndpoint.Send(firstMessage);
await InputQueueSendEndpoint.Send(secondMessage);
Guid?saga = await _repository.ShouldContainSaga(x => x.CorrelationId == correlationId, TestTimeout);
Assert.IsTrue(saga.HasValue);
Task <ConsumeContext <CompleteMessage> > received =
await ConnectPublishHandler <CompleteMessage>(x => x.Message.CorrelationId == correlationId);
await received;
}
public void WillHappilyIncludeMessagesOfDifferentTypeInSameTransportMessage()
{
// arrange
var firstMessage = new FirstMessage();
var secondMessage = new SecondMessage();
var thirdMessage = new SomeRandomMessage();
var someEndpoint = "some-endpoint";
determineDestination.Stub(d => d.GetEndpointFor(typeof(FirstMessage))).Return(someEndpoint);
determineDestination.Stub(d => d.GetEndpointFor(typeof(SecondMessage))).Return(someEndpoint);
determineDestination.Stub(d => d.GetEndpointFor(typeof(SomeRandomMessage))).Return(someEndpoint);
// act
bus.Batch.Send(firstMessage, secondMessage, thirdMessage);
// assert
sendMessages.AssertWasCalled(s => s.Send(Arg <string> .Is.Equal(someEndpoint), Arg <TransportMessageToSend> .Is.Anything),
o => o.Repeat.Once());
}
public void WillHappilyIncludeMessagesOfDifferentTypeInSameTransportMessageAlsoWhenPublishing()
{
// arrange
var someSubscriberEndpoint = "some-subscriber";
storeSubscriptions.Stub(s => s.GetSubscribers(typeof(FirstMessage))).Return(new[] { someSubscriberEndpoint });
storeSubscriptions.Stub(s => s.GetSubscribers(typeof(SecondMessage))).Return(new[] { someSubscriberEndpoint });
// act
var firstMessage = new FirstMessage();
var secondMessage = new SecondMessage();
bus.Batch.Publish(firstMessage, secondMessage);
// assert
// check that the endpoint is right
sendMessages.AssertWasCalled(s => s.Send(Arg <string> .Is.Equal(someSubscriberEndpoint),
Arg <TransportMessageToSend> .Is.Anything),
o => o.Repeat.Once());
}
static void Main(string[] args)
{
Console.WriteLine("Starting RabbitMQ Message Sender");
Console.WriteLine();
var messageCount = 1;
var sender = new RabbitSender();
Console.WriteLine("Press enter key to send a message");
Console.WriteLine("Select the number for the Format - number of Message Type, and press Enter");
Console.WriteLine("1 = JSON");
Console.WriteLine("2 = XML");
Console.WriteLine("3 = Binary");
Console.WriteLine();
Console.WriteLine("1 = FirstMessage");
Console.WriteLine("2 = SecondMessage");
Console.WriteLine();
while (true)
{
var input = Console.ReadLine();
if (input.ToUpper() == "Q")
{
break;
}
if (!input.Contains("-"))
{
continue;
}
var data = input.Split('-');
var format = data[0];
var messageType = data[1];
if (format != "1" && format != "2" && format != "3")
{
continue;
}
if (messageType != "1" && messageType != "2")
{
continue;
}
object messageObj = null;
if (messageType == "1")
{
messageObj = new FirstMessage {
Message = $"Message: {messageCount}"
}
}
;
else
{
messageObj = new SecondMessage {
Message = $"Message: {messageCount}"
}
};
var messageBuffer = SerializeMessage(messageObj, format);
Console.WriteLine($"Foramt - {format}, Sending - {messageObj}");
sender.Send(messageBuffer, GetContentType(format), GetMessageType(messageObj));
messageCount++;
}
Console.ReadLine();
}
