public void TestBadDecode()
{
var bytes = new byte[] { (byte)0xff, 99 };
IMessage <byte[]> message = new Steeltoe.Messaging.Support.GenericMessage <byte[]>(bytes);
Assert.Throws <ArgumentOutOfRangeException>(() => EmbeddedHeaderUtils.ExtractHeaders(message, false));
}
public void TestConfigurableHeaders()
{
var message = MessageBuilder <byte[]>
.WithPayload(Encoding.UTF8.GetBytes("Hello"))
.SetHeader("foo", "bar")
.SetHeader("baz", "quxx")
.SetHeader("contentType", "text/plain")
.Build();
var headers = new string[] { "foo" };
var embedded = EmbeddedHeaderUtils.EmbedHeaders(new MessageValues(message), EmbeddedHeaderUtils.HeadersToEmbed(headers));
Assert.Equal(0xff, embedded[0]);
var embeddedString = Encoding.UTF8.GetString(embedded);
Assert.Equal("\u0002\u000BcontentType\u0000\u0000\u0000\u000C\"text/plain\"\u0003foo\u0000\u0000\u0000\u0005\"bar\"Hello", embeddedString.Substring(1));
var extracted = EmbeddedHeaderUtils.ExtractHeaders(MessageBuilder <byte[]> .WithPayload(embedded).Build(), false);
Assert.Equal("Hello", Encoding.UTF8.GetString((byte[])extracted.Payload));
Assert.Equal("bar", extracted["foo"]);
Assert.Null(extracted["baz"]);
Assert.Equal("text/plain", extracted["contentType"]);
Assert.Null(extracted["timestamp"]);
var extractedWithRequestHeaders = EmbeddedHeaderUtils.ExtractHeaders(MessageBuilder <byte[]> .WithPayload(embedded).Build(), true);
Assert.Equal("bar", extractedWithRequestHeaders["foo"]);
Assert.Null(extractedWithRequestHeaders["baz"]);
Assert.Equal("text/plain", extractedWithRequestHeaders["contentType"]);
Assert.NotNull(extractedWithRequestHeaders["timestamp"]);
Assert.NotNull(extractedWithRequestHeaders["id"]);
Assert.IsType <long>(extractedWithRequestHeaders["timestamp"]);
Assert.IsType <Guid>(extractedWithRequestHeaders["id"]);
}
public override IMessage PreSend(IMessage message, IMessageChannel channel)
{
if (message.Payload is byte[] &&
!message.Headers.ContainsKey(BinderHeaders.NATIVE_HEADERS_PRESENT) &&
EmbeddedHeaderUtils.MayHaveEmbeddedHeaders((byte[])message.Payload))
{
MessageValues messageValues;
try
{
messageValues = EmbeddedHeaderUtils.ExtractHeaders((IMessage <byte[]>)message, true);
}
catch (Exception)
{
/*
* debug() rather then error() since we don't know for sure that it
* really is a message with embedded headers, it just meets the
* criteria in EmbeddedHeaderUtils.mayHaveEmbeddedHeaders().
*/
// this.logger?.LogDebug(EmbeddedHeaderUtils.DecodeExceptionMessage(message), e);
messageValues = new MessageValues(message);
}
return(messageValues.ToMessage());
}
return(message);
}
private IMessage SerializeAndEmbedHeadersIfApplicable(IMessage message)
{
var transformed = new MessageValues(message);
object payload;
if (embedHeaders)
{
transformed.TryGetValue(MessageHeaders.CONTENT_TYPE, out var contentType);
// transform content type headers to String, so that they can be properly
// embedded in JSON
if (contentType != null)
{
transformed[MessageHeaders.CONTENT_TYPE] = contentType.ToString();
}
payload = EmbeddedHeaderUtils.EmbedHeaders(transformed, embeddedHeaders);
}
else
{
payload = transformed.Payload;
}
return(IntegrationServices.MessageBuilderFactory.WithPayload(payload).CopyHeaders(transformed.Headers).Build());
}
public void TestHeaderEmbeddingMissingHeader()
{
var message = MessageBuilder <byte[]>
.WithPayload(Encoding.UTF8.GetBytes("Hello"))
.SetHeader("foo", "bar")
.Build();
var embedded = EmbeddedHeaderUtils.EmbedHeaders(new MessageValues(message), "foo", "baz");
Assert.Equal(0xff, embedded[0]);
var embeddedString = Encoding.UTF8.GetString(embedded);
Assert.Equal("\u0001\u0003foo\u0000\u0000\u0000\u0005\"bar\"Hello", embeddedString.Substring(1));
}
public void TestHeaderExtractionWithDirectPayload()
{
var message = MessageBuilder <byte[]>
.WithPayload(Encoding.UTF8.GetBytes("Hello"))
.SetHeader("foo", "bar")
.SetHeader("baz", "quxx")
.Build();
var embedded = EmbeddedHeaderUtils.EmbedHeaders(new MessageValues(message), "foo", "baz");
Assert.Equal(0xff, embedded[0]);
var embeddedString = Encoding.UTF8.GetString(embedded);
Assert.Equal("\u0002\u0003foo\u0000\u0000\u0000\u0005\"bar\"\u0003baz\u0000\u0000\u0000\u0006\"quxx\"Hello", embeddedString.Substring(1));
var extracted = EmbeddedHeaderUtils.ExtractHeaders(embedded);
Assert.Equal("Hello", Encoding.UTF8.GetString((byte[])extracted.Payload));
Assert.Equal("bar", extracted["foo"]);
Assert.Equal("quxx", extracted["baz"]);
}
public void TestUnicodeHeader()
{
var message = IntegrationMessageBuilder <byte[]>
.WithPayload(Encoding.UTF8.GetBytes("Hello"))
.SetHeader("foo", "bar")
.SetHeader("baz", "ØØØØØØØØ")
.Build();
var embedded = EmbeddedHeaderUtils.EmbedHeaders(new MessageValues(message), "foo", "baz");
Assert.Equal(0xff, embedded[0]);
var embeddedString = Encoding.UTF8.GetString(embedded);
Assert.Equal("\u0002\u0003foo\u0000\u0000\u0000\u0005\"bar\"\u0003baz\u0000\u0000\u0000\u0012\"ØØØØØØØØ\"Hello", embeddedString.Substring(1));
var extracted = EmbeddedHeaderUtils.ExtractHeaders(IntegrationMessageBuilder <byte[]> .WithPayload(embedded).Build(), false);
Assert.Equal("Hello", Encoding.UTF8.GetString((byte[])extracted.Payload));
Assert.Equal("bar", extracted["foo"]);
Assert.Equal("ØØØØØØØØ", extracted["baz"]);
}
public void TestEmbedded()
{
var searchDirectories = GetSearchDirectories("TestBinder");
IServiceProvider serviceProvider = CreateStreamsContainer(
searchDirectories,
"spring:cloud:stream:bindings:foo:consumer:headerMode=" + HeaderMode.EmbeddedHeaders.ToString()).BuildServiceProvider();
var messageConverter = serviceProvider.GetService <ISmartMessageConverter>();
Assert.NotNull(messageConverter);
var binder = serviceProvider.GetService <IBinder>() as AbstractPollableMessageSourceBinder;
Assert.NotNull(binder);
var configurer = serviceProvider.GetService <MessageConverterConfigurer>();
Assert.NotNull(configurer);
var setter = binder.GetType().GetProperty("MessageSourceDelegate").GetSetMethod();
var messageSource = new TestFuncMessageSource(() =>
{
var original = new MessageValues(
Encoding.UTF8.GetBytes("foo"),
new Dictionary <string, object>()
{
{ MessageHeaders.CONTENT_TYPE, "application/octet-stream" }
});
var payload = new byte[0];
try
{
payload = EmbeddedHeaderUtils.EmbedHeaders(original, MessageHeaders.CONTENT_TYPE);
}
catch (Exception e)
{
Assert.NotNull(e);
}
return(Message.Create <byte[]>(payload));
});
setter.Invoke(binder, new object[] { messageSource });
var options = serviceProvider.GetService <IOptions <BindingServiceOptions> >();
options.Value.Bindings.TryGetValue("foo", out var bindingOptions);
Assert.Equal(HeaderMode.EmbeddedHeaders, bindingOptions.Consumer.HeaderMode);
var pollableSource = new DefaultPollableMessageSource(serviceProvider.GetService <IApplicationContext>(), messageConverter);
configurer.ConfigurePolledMessageSource(pollableSource, "foo");
pollableSource.AddInterceptor(new TestEmbededChannelInterceptor());
binder.BindConsumer("foo", "bar", pollableSource, bindingOptions.Consumer);
var handler = new TestConvertSimpleHandler();
Assert.True(pollableSource.Poll(handler));
Assert.IsType <string>(handler.Payload);
var str = handler.Payload as string;
Assert.Equal("FOO", str);
handler.Message.Headers.TryGetValue(MessageHeaders.CONTENT_TYPE, out var contentType);
Assert.Equal("application/octet-stream", contentType.ToString());
}
