public void When_replying_message_interface_should_set_interface_as_message_type()
{
var replyPipeline = new FakePipeline <IOutgoingReplyContext>();
var messageOperations = CreateMessageOperations(replyPipeline: replyPipeline);
messageOperations.Reply <IMyMessage>(new FakeRootContext(), m => { }, new ReplyOptions());
Assert.That(replyPipeline.ReceivedContext.Message.MessageType, Is.EqualTo(typeof(IMyMessage)));
}
public async Task When_replying_message_class_should_set_class_as_message_typeAsync()
{
var replyPipeline = new FakePipeline <IOutgoingReplyContext>();
var messageOperations = CreateMessageOperations(replyPipeline: replyPipeline);
await messageOperations.Reply <MyMessage>(new FakeRootContext(), m => { }, new ReplyOptions());
Assert.That(replyPipeline.ReceivedContext.Message.MessageType, Is.EqualTo(typeof(MyMessage)));
}
public void When_publishing_event_class_should_set_class_as_message_type()
{
var publishPipeline = new FakePipeline <IOutgoingPublishContext>();
var messageOperations = CreateMessageOperations(publishPipeline: publishPipeline);
messageOperations.Publish <MyMessage>(new FakeRootContext(), m => { }, new PublishOptions());
Assert.That(publishPipeline.ReceivedContext.Message.MessageType, Is.EqualTo(typeof(MyMessage)));
}
public async Task When_publishing_event_interface_should_set_interface_as_message_typeAsync()
{
var publishPipeline = new FakePipeline <IOutgoingPublishContext>();
var messageOperations = CreateMessageOperations(publishPipeline: publishPipeline);
await messageOperations.Publish <IMyMessage>(new FakeRootContext(), m => { }, new PublishOptions());
Assert.That(publishPipeline.ReceivedContext.Message.MessageType, Is.EqualTo(typeof(IMyMessage)));
}
public async Task When_sending_message_interface_should_set_interface_as_message_typeAsync()
{
var sendPipeline = new FakePipeline <IOutgoingSendContext>();
var messageOperations = CreateMessageOperations(sendPipeline: sendPipeline);
await messageOperations.Send <IMyMessage>(new FakeRootContext(), m => { }, new SendOptions());
Assert.That(sendPipeline.ReceivedContext.Message.MessageType, Is.EqualTo(typeof(IMyMessage)));
}
public void When_sending_message_interface_should_set_interface_as_message_type()
{
var sendPipeline = new FakePipeline <IOutgoingSendContext>();
var context = CreateContext(sendPipeline);
MessageOperations.Send <IMyMessage>(context, m => { }, new SendOptions());
Assert.That(sendPipeline.ReceivedContext.Message.MessageType, Is.EqualTo(typeof(IMyMessage)));
}
public void When_publishing_event_interface_should_set_interface_as_message_type()
{
var publishPipeline = new FakePipeline <IOutgoingPublishContext>();
var context = CreateContext(publishPipeline);
MessageOperations.Publish <IMyMessage>(context, m => { }, new PublishOptions());
Assert.That(publishPipeline.ReceivedContext.Message.MessageType, Is.EqualTo(typeof(IMyMessage)));
}
public void When_replying_message_class_should_set_class_as_message_type()
{
var replyPipeline = new FakePipeline <IOutgoingReplyContext>();
var context = CreateContext(replyPipeline);
MessageOperations.Reply <MyMessage>(context, m => { }, new ReplyOptions());
Assert.That(replyPipeline.ReceivedContext.Message.MessageType, Is.EqualTo(typeof(MyMessage)));
}
public void When_sending_message_class_should_set_class_as_message_type()
{
var sendPipeline = new FakePipeline <IOutgoingSendContext>();
var messageOperations = CreateMessageOperations(sendPipeline: sendPipeline);
messageOperations.Send <MyMessage>(new FakeRootContext(), m => { }, new SendOptions());
Assert.That(sendPipeline.ReceivedContext.Message.MessageType, Is.EqualTo(typeof(MyMessage)));
}
public void When_sending_should_generate_message_id_and_set_message_id_header()
{
var sendPipeline = new FakePipeline <IOutgoingSendContext>();
var messageOperations = CreateMessageOperations(sendPipeline: sendPipeline);
messageOperations.Send <MyMessage>(new FakeRootContext(), m => { }, new SendOptions());
var messageId = sendPipeline.ReceivedContext.MessageId;
Assert.IsNotNull(messageId);
Assert.AreEqual(messageId, sendPipeline.ReceivedContext.Headers[Headers.MessageId]);
}
public void When_publishing_should_generate_message_id_and_set_message_id_header()
{
var publishPipeline = new FakePipeline <IOutgoingPublishContext>();
var messageOperations = CreateMessageOperations(publishPipeline: publishPipeline);
messageOperations.Publish <MyMessage>(new FakeRootContext(), m => { }, new PublishOptions());
var messageId = publishPipeline.ReceivedContext.MessageId;
Assert.IsNotNull(messageId);
Assert.AreEqual(messageId, publishPipeline.ReceivedContext.Headers[Headers.MessageId]);
}
public void When_replying_should_generate_message_id_and_set_message_id_header()
{
var replyPipeline = new FakePipeline <IOutgoingReplyContext>();
var messageOperations = CreateMessageOperations(replyPipeline: replyPipeline);
messageOperations.Reply <MyMessage>(new FakeRootContext(), m => { }, new ReplyOptions());
var messageId = replyPipeline.ReceivedContext.MessageId;
Assert.IsNotNull(messageId);
Assert.AreEqual(messageId, replyPipeline.ReceivedContext.Headers[Headers.MessageId]);
}
MessageOperations CreateMessageOperations(
FakePipeline <IOutgoingPublishContext> publishPipeline = null,
FakePipeline <IOutgoingSendContext> sendPipeline = null,
FakePipeline <IOutgoingReplyContext> replyPipeline = null,
FakePipeline <ISubscribeContext> subscribePipeline = null,
FakePipeline <IUnsubscribeContext> subscribeContext = null)
{
return(new MessageOperations(
new MessageMapper(),
publishPipeline ?? new FakePipeline <IOutgoingPublishContext>(),
sendPipeline ?? new FakePipeline <IOutgoingSendContext>(),
replyPipeline ?? new FakePipeline <IOutgoingReplyContext>(),
subscribePipeline ?? new FakePipeline <ISubscribeContext>(),
subscribeContext ?? new FakePipeline <IUnsubscribeContext>()));
}
public void When_publishing_with_user_defined_message_id_should_set_defined_id_and_header()
{
const string expectedMessageID = "expected message id";
var publishPipeline = new FakePipeline <IOutgoingPublishContext>();
var context = CreateContext(publishPipeline);
var publishOptions = new PublishOptions();
publishOptions.SetMessageId(expectedMessageID);
MessageOperations.Publish <MyMessage>(context, m => { }, publishOptions);
Assert.AreEqual(expectedMessageID, publishPipeline.ReceivedContext.MessageId);
Assert.AreEqual(expectedMessageID, publishPipeline.ReceivedContext.Headers[Headers.MessageId]);
}
public async Task When_publishing_with_user_defined_message_id_should_set_defined_id_and_headerAsync()
{
const string expectedMessageID = "expected message id";
var publishPipeline = new FakePipeline <IOutgoingPublishContext>();
var messageOperations = CreateMessageOperations(publishPipeline: publishPipeline);
var publishOptions = new PublishOptions();
publishOptions.SetMessageId(expectedMessageID);
await messageOperations.Publish <MyMessage>(new FakeRootContext(), m => { }, publishOptions);
Assert.AreEqual(expectedMessageID, publishPipeline.ReceivedContext.MessageId);
Assert.AreEqual(expectedMessageID, publishPipeline.ReceivedContext.Headers[Headers.MessageId]);
}
public void When_sending_with_user_defined_message_id_should_set_defined_id_and_header()
{
const string expectedMessageID = "expected message id";
var sendPipeline = new FakePipeline <IOutgoingSendContext>();
var messageOperations = CreateMessageOperations(sendPipeline: sendPipeline);
var sendOptions = new SendOptions();
sendOptions.SetMessageId(expectedMessageID);
messageOperations.Send <MyMessage>(new FakeRootContext(), m => { }, sendOptions);
Assert.AreEqual(expectedMessageID, sendPipeline.ReceivedContext.MessageId);
Assert.AreEqual(expectedMessageID, sendPipeline.ReceivedContext.Headers[Headers.MessageId]);
}
public void When_replying_should_clone_headers()
{
var replyPipeline = new FakePipeline <IOutgoingReplyContext>();
var messageOperations = CreateMessageOperations(replyPipeline: replyPipeline);
var replyOptions = new ReplyOptions();
replyOptions.SetHeader("header1", "header1 value");
messageOperations.Reply <MyMessage>(new FakeRootContext(), m => { }, replyOptions);
replyPipeline.ReceivedContext.Headers.Add("header2", "header2 value");
replyPipeline.ReceivedContext.Headers["header1"] = "updated header1 value";
var optionsHeaders = replyOptions.GetHeaders();
Assert.AreEqual(1, optionsHeaders.Count);
Assert.AreEqual("header1 value", optionsHeaders["header1"]);
}
public void When_sending_should_clone_headers()
{
var sendPipeline = new FakePipeline <IOutgoingSendContext>();
var messageOperations = CreateMessageOperations(sendPipeline: sendPipeline);
var sendOptions = new SendOptions();
sendOptions.SetHeader("header1", "header1 value");
messageOperations.Send <MyMessage>(new FakeRootContext(), m => { }, sendOptions);
sendPipeline.ReceivedContext.Headers.Add("header2", "header2 value");
sendPipeline.ReceivedContext.Headers["header1"] = "updated header1 value";
var optionsHeaders = sendOptions.GetHeaders();
Assert.AreEqual(1, optionsHeaders.Count);
Assert.AreEqual("header1 value", optionsHeaders["header1"]);
}
public void When_publishing_should_clone_headers()
{
var publishPipeline = new FakePipeline <IOutgoingPublishContext>();
var messageOperations = CreateMessageOperations(publishPipeline: publishPipeline);
var publishOptions = new PublishOptions();
publishOptions.SetHeader("header1", "header1 value");
messageOperations.Publish <MyMessage>(new FakeRootContext(), m => { }, publishOptions);
publishPipeline.ReceivedContext.Headers.Add("header2", "header2 value");
publishPipeline.ReceivedContext.Headers["header1"] = "updated header1 value";
var optionsHeaders = publishOptions.GetHeaders();
Assert.AreEqual(1, optionsHeaders.Count);
Assert.AreEqual("header1 value", optionsHeaders["header1"]);
}
