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"]); }