예제 #1
0
        public void LeaveMutable()
        {
            var accessor = new MessageHeaderAccessor();

            accessor.SetHeader("foo", "bar");
            accessor.LeaveMutable = true;
            var headers = accessor.MessageHeaders;
            var message = MessageBuilder <string> .CreateMessage("payload", headers);

            accessor.SetHeader("foo", "baz");

            Assert.Equal("baz", headers.Get <string>("foo"));
            Assert.Same(accessor, MessageHeaderAccessor.GetAccessor <MessageHeaderAccessor>(message, typeof(MessageHeaderAccessor)));
        }
예제 #2
0
        public void LeaveMutableDefaultBehavior()
        {
            var accessor = new MessageHeaderAccessor();

            accessor.SetHeader("foo", "bar");
            var headers = accessor.MessageHeaders;
            var message = MessageBuilder <string> .CreateMessage("payload", headers);

            Assert.Throws <InvalidOperationException>(() => accessor.LeaveMutable = true);

            Assert.Throws <InvalidOperationException>(() => accessor.SetHeader("foo", "baz"));

            Assert.Equal("bar", headers.Get <string>("foo"));
            Assert.Same(accessor, MessageHeaderAccessor.GetAccessor <MessageHeaderAccessor>(message, typeof(MessageHeaderAccessor)));
        }
        public void SendWithTimeoutMutable()
        {
            IMessage sent = null;

            var chanMock = new Mock <ISubscribableChannel>();
            var channel  = chanMock.Object;

            chanMock.Setup(
                chan => chan.Send(It.IsAny <IMessage>(), It.Is <int>(i => i == 30000)))
            .Callback <IMessage, int>((m, t) => sent = m)
            .Returns(true);

            var accessor = new MessageHeaderAccessor
            {
                LeaveMutable = true
            };
            var message = Message.Create <string>("request", accessor.MessageHeaders);

            accessor.SetHeader(MessageChannelTemplate.DEFAULT_SEND_TIMEOUT_HEADER, 30000);
            Template.Send(channel, message);
            chanMock.Verify(chan => chan.Send(It.IsAny <IMessage>(), It.Is <int>(i => i == 30000)));
            Assert.NotNull(sent);
            Assert.False(sent.Headers.ContainsKey(MessageChannelTemplate.DEFAULT_SEND_TIMEOUT_HEADER));
            Assert.False(sent.Headers.ContainsKey(MessageChannelTemplate.DEFAULT_RECEIVE_TIMEOUT_HEADER));
        }
        public async Task SendAsyncWithTimeoutMutable()
        {
            IMessage sent = null;

            var chanMock = new Mock <ISubscribableChannel>();
            var channel  = chanMock.Object;

            chanMock.Setup(
                chan => chan.SendAsync(It.IsAny <IMessage>(), It.Is <CancellationToken>(t => t.IsCancellationRequested == false)))
            .Callback <IMessage, CancellationToken>((m, t) => sent = m)
            .Returns(new ValueTask <bool>(true));

            var accessor = new MessageHeaderAccessor
            {
                LeaveMutable = true
            };
            var message = Message.Create <string>("request", accessor.MessageHeaders);

            accessor.SetHeader(MessageChannelTemplate.DEFAULT_SEND_TIMEOUT_HEADER, 30000);
            await Template.SendAsync(channel, message);

            chanMock.Verify(chan => chan.SendAsync(It.IsAny <IMessage>(), It.Is <CancellationToken>(t => t.IsCancellationRequested == false)));
            Assert.NotNull(sent);
            Assert.False(sent.Headers.ContainsKey(MessageChannelTemplate.DEFAULT_SEND_TIMEOUT_HEADER));
            Assert.False(sent.Headers.ContainsKey(MessageChannelTemplate.DEFAULT_RECEIVE_TIMEOUT_HEADER));
        }
예제 #5
0
        public void TestBuildMultipleIMessages()
        {
            var headerAccessor = new MessageHeaderAccessor();
            var messageBuilder = MessageBuilder.WithPayload("payload").SetHeaders(headerAccessor);

            headerAccessor.SetHeader("foo", "bar1");
            var message1 = messageBuilder.Build();

            headerAccessor.SetHeader("foo", "bar2");
            var message2 = messageBuilder.Build();

            headerAccessor.SetHeader("foo", "bar3");
            var message3 = messageBuilder.Build();

            Assert.Equal("bar1", message1.Headers.Get <string>("foo"));
            Assert.Equal("bar2", message2.Headers.Get <string>("foo"));
            Assert.Equal("bar3", message3.Headers.Get <string>("foo"));
        }
예제 #6
0
        public void TestBuildIMessageWithDefaultMutability()
        {
            var accessor = new MessageHeaderAccessor();
            var headers  = accessor.MessageHeaders;
            var message  = MessageBuilder.CreateMessage("foo", headers);

            Assert.Throws <InvalidOperationException>(() => accessor.SetHeader("foo", "bar"));

            Assert.Equal(accessor, MessageHeaderAccessor.GetAccessor(message, typeof(MessageHeaderAccessor)));
        }
예제 #7
0
        public void ToDictionary()
        {
            var accessor = new MessageHeaderAccessor();

            accessor.SetHeader("foo", "bar1");
            var map1 = accessor.ToDictionary();

            accessor.SetHeader("foo", "bar2");
            var map2 = accessor.ToDictionary();

            accessor.SetHeader("foo", "bar3");
            var map3 = accessor.ToDictionary();

            Assert.Equal(1, map1.Count);
            Assert.Equal(1, map2.Count);
            Assert.Equal(1, map3.Count);

            Assert.Equal("bar1", map1["foo"]);
            Assert.Equal("bar2", map2["foo"]);
            Assert.Equal("bar3", map3["foo"]);
        }
예제 #8
0
        public void TestBuildIMessageWithMutableHeaders()
        {
            var accessor = new MessageHeaderAccessor
            {
                LeaveMutable = true
            };
            var headers = accessor.MessageHeaders;
            var message = MessageBuilder.CreateMessage("payload", headers);

            accessor.SetHeader("foo", "bar");

            Assert.Equal("bar", headers.Get <string>("foo"));
            Assert.Equal(accessor, MessageHeaderAccessor.GetAccessor(message, typeof(MessageHeaderAccessor)));
        }
예제 #9
0
        public void ToMessageWithPayloadAndMutableHeaders()
        {
            var accessor = new MessageHeaderAccessor();

            accessor.SetHeader("foo", "bar");
            accessor.LeaveMutable = true;
            var headers = accessor.MessageHeaders;

            var converter = new SimpleMessageConverter();
            var message   = converter.ToMessage("payload", headers);

            Assert.Equal("payload", message.Payload);
            Assert.Same(headers, message.Headers);
            Assert.Equal("bar", message.Headers["foo"]);
        }
예제 #10
0
        public void ToMessageWithMutableMessageHeaders()
        {
            var accessor = new MessageHeaderAccessor();

            accessor.SetHeader("foo", "bar");
            accessor.LeaveMutable = true;

            var headers   = accessor.MessageHeaders;
            var converter = new TestMessageConverter();
            var message   = converter.ToMessage("ABC", headers);

            Assert.Same(headers, message.Headers);
            Assert.Null(message.Headers.Id);
            Assert.Null(message.Headers.Timestamp);
            Assert.Equal(MimeTypeUtils.TEXT_PLAIN, message.Headers[MessageHeaders.CONTENT_TYPE]);
        }
예제 #11
0
        public void ConvertAndSendPayloadAndMutableHeadersToDestination()
        {
            var accessor = new MessageHeaderAccessor();

            accessor.SetHeader("foo", "bar");
            accessor.LeaveMutable = true;
            var messageHeaders = accessor.MessageHeaders;

            _template.MessageConverter = new StringMessageConverter();
            _template.ConvertAndSend("somewhere", "payload", messageHeaders);

            var actual = _template.Message.Headers;

            Assert.Same(messageHeaders, actual);
            Assert.Equal(new MimeType("text", "plain", Encoding.UTF8), actual[MessageHeaders.CONTENT_TYPE]);
            Assert.Equal("bar", actual["foo"]);
        }
예제 #12
0
        public void ExistingHeadersModification()
        {
            IDictionary <string, object> map = new Dictionary <string, object>();

            map.Add("foo", "bar");
            map.Add("bar", "baz");
            var message = new GenericMessage <string>("payload", map);

            Thread.Sleep(50);

            var accessor = new MessageHeaderAccessor(message);

            accessor.SetHeader("foo", "BAR");
            var actual = accessor.MessageHeaders;

            Assert.Equal(3, actual.Count);
            Assert.NotEqual(message.Headers.Id, actual.Id);
            Assert.Equal("BAR", actual.Get <string>("foo"));
            Assert.Equal("baz", actual.Get <string>("bar"));
        }
        public void ExistingHeadersModification()
        {
            IDictionary <string, object> map = new Dictionary <string, object>
            {
                { "foo", "bar" },
                { "bar", "baz" }
            };
            var message = Message.Create <string>("payload", map);

            Thread.Sleep(50);

            var accessor = new MessageHeaderAccessor(message);

            accessor.SetHeader("foo", "BAR");
            var actual = accessor.MessageHeaders;

            Assert.Equal(3, ((HeadersDictionary)actual).Count);
            Assert.NotEqual(message.Headers.Id, actual.Id);
            Assert.Equal("BAR", actual.Get <string>("foo"));
            Assert.Equal("baz", actual.Get <string>("bar"));
        }