public virtual void HandleMessage(IMessage message)
{
var destination = GetDestination(message);
if (destination == null)
{
return;
}
var lookupDestination = GetLookupDestination(destination);
if (lookupDestination == null)
{
return;
}
var headerAccessor = MessageHeaderAccessor.GetMutableAccessor(message);
headerAccessor.SetHeader(DestinationPatternsMessageCondition.LOOKUP_DESTINATION_HEADER, lookupDestination);
headerAccessor.LeaveMutable = true;
message = MessageBuilder.CreateMessage(message.Payload, headerAccessor.MessageHeaders);
HandleMessageInternal(message, lookupDestination);
headerAccessor.SetImmutable();
}
public void ShouldThrowAnExceptionWhenContentClassIdIsNotPresentWhenClassIdIsContainerType()
{
var accessor = MessageHeaderAccessor.GetMutableAccessor(headers);
accessor.SetHeader(typeMapper.ClassIdFieldName, typeof(List <>).FullName);
var excep = Assert.Throws <MessageConversionException>(() => typeMapper.ToType(accessor.MessageHeaders));
Assert.Contains("Could not resolve ", excep.Message);
}
public void GetMutableAccessorNewInstance()
{
IMessage message = MessageBuilder <string> .WithPayload("payload").Build();
var actual = MessageHeaderAccessor.GetMutableAccessor(message);
Assert.NotNull(actual);
Assert.True(actual.IsMutable);
}
public void GetMutableAccessorNewInstanceMatchingType()
{
var expected = new TestMessageHeaderAccessor();
IMessage message = MessageBuilder <string> .CreateMessage("payload", expected.MessageHeaders);
var actual = MessageHeaderAccessor.GetMutableAccessor(message);
Assert.NotNull(actual);
Assert.True(actual.IsMutable);
Assert.Equal(typeof(TestMessageHeaderAccessor), actual.GetType());
}
public void GetMutableAccessorNewInstance()
{
var message = MessageBuilder.WithPayload("payload").Build();
var actual = MessageHeaderAccessor.GetMutableAccessor(message);
Assert.NotNull(actual);
Assert.True(actual.IsMutable);
actual.SetHeader("foo", "bar");
}
public void ShouldLookInTheContentClassIdFieldNameToFindTheContainerClassIDWhenClassIdIsContainerType()
{
var accessor = MessageHeaderAccessor.GetMutableAccessor(headers);
accessor.SetHeader("contentType", typeof(string).ToString());
accessor.SetHeader(typeMapper.ClassIdFieldName, typeof(List <>).FullName);
typeMapper.ContentClassIdFieldName = "contentType";
var type = typeMapper.ToType(accessor.MessageHeaders);
Assert.Equal(typeof(List <string>), type);
}
public void ShouldLookInTheClassIdFieldNameToFindTheClassName()
{
var accessor = MessageHeaderAccessor.GetMutableAccessor(headers);
accessor.SetHeader("type", "System.String");
typeMapper.ClassIdFieldName = "type";
var type = typeMapper.ToType(accessor.MessageHeaders);
Assert.Equal(typeof(string), type);
}
public void ShouldThrowAnExceptionWhenKeyClassIdIsNotPresentWhenClassIdIsAMap()
{
var accessor = MessageHeaderAccessor.GetMutableAccessor(headers);
accessor.SetHeader(typeMapper.ClassIdFieldName, typeof(Dictionary <,>).FullName);
accessor.SetHeader(typeMapper.KeyClassIdFieldName, typeof(string).ToString());
var excep = Assert.Throws <MessageConversionException>(() => typeMapper.ToType(accessor.MessageHeaders));
Assert.Contains("Could not resolve ", excep.Message);
}
public void GetMutableAccessorSameInstance()
{
var expected = new TestMessageHeaderAccessor();
expected.LeaveMutable = true;
var message = MessageBuilder <string> .CreateMessage("payload", expected.MessageHeaders);
var actual = MessageHeaderAccessor.GetMutableAccessor(message);
Assert.NotNull(actual);
Assert.True(actual.IsMutable);
Assert.Same(expected, actual);
}
public void ShouldLookInTheValueClassIdFieldNameToFindTheValueClassIDWhenClassIdIsAMap()
{
var accessor = MessageHeaderAccessor.GetMutableAccessor(headers);
accessor.SetHeader("keyType", typeof(int).ToString());
accessor.SetHeader(typeMapper.ContentClassIdFieldName, typeof(string).ToString());
accessor.SetHeader(typeMapper.ClassIdFieldName, typeof(Dictionary <,>).FullName);
typeMapper.KeyClassIdFieldName = "keyType";
var type = typeMapper.ToType(accessor.MessageHeaders);
Assert.Equal(typeof(Dictionary <int, string>), type);
}
protected virtual void AddHeader(IMessageHeaders headers, string headerName, Type clazz)
{
var accessor = MessageHeaderAccessor.GetMutableAccessor(headers);
if (_classIdMapping.ContainsKey(clazz))
{
accessor.SetHeader(headerName, _classIdMapping[clazz]);
}
else
{
accessor.SetHeader(headerName, GetClassName(clazz));
}
}
public void ShouldUseTheClassProvidedByTheLookupMapIfPresent()
{
var accessor = MessageHeaderAccessor.GetMutableAccessor(headers);
accessor.SetHeader("__TypeId__", "trade");
typeMapper.SetIdClassMapping(new Dictionary <string, Type>()
{
{ "trade", typeof(SimpleTrade) }
});
var type = typeMapper.ToType(accessor.MessageHeaders);
Assert.Equal(typeof(SimpleTrade), type);
}
public void GetMutableAccessorSameInstance()
{
var expected = new TestMessageHeaderAccessor
{
LeaveMutable = true
};
var message = MessageBuilder.CreateMessage("payload", expected.MessageHeaders);
var actual = MessageHeaderAccessor.GetMutableAccessor(message);
Assert.NotNull(actual);
Assert.True(actual.IsMutable);
Assert.Same(expected, actual);
actual.SetHeader("foo", "bar");
Assert.Equal("bar", message.Headers.Get <string>("foo"));
}
public void ShouldUseTheContentClassProvidedByTheLookupMapIfPresent()
{
var accessor = MessageHeaderAccessor.GetMutableAccessor(headers);
accessor.SetHeader(typeMapper.ClassIdFieldName, typeof(List <>).FullName);
accessor.SetHeader("__ContentTypeId__", "trade");
var mapping = new Dictionary <string, Type>()
{
{ "trade", typeof(SimpleTrade) }
};
mapping.Add(typeMapper.ClassIdFieldName, typeof(List <>));
typeMapper.SetIdClassMapping(mapping);
var type = typeMapper.ToType(accessor.MessageHeaders);
Assert.Equal(typeof(List <SimpleTrade>), type);
}
protected override object DoTransform(IMessage message)
{
var payload = BuildJsonPayload(message.Payload);
var accessor = MessageHeaderAccessor.GetMutableAccessor(message);
var contentType = accessor.ContentType;
if (string.IsNullOrEmpty(contentType))
{
accessor.ContentType = ContentType;
}
var headers = accessor.MessageHeaders;
_defaultTypeMapper.FromType(message.Payload.GetType(), headers);
if (ResultType == typeof(string))
{
return(MessageBuilderFactory.WithPayload <string>((string)payload).CopyHeaders(headers).Build());
}
else
{
return(MessageBuilderFactory.WithPayload <byte[]>((byte[])payload).CopyHeaders(headers).Build());
}
}
