public void TestConverted()
{
var template = provider.GetRabbitTemplate();
var foo1 = new Foo1
{
Bar = "bar"
};
var ctx = provider.GetService <IApplicationContext>();
var converter = ctx.GetService <ISmartMessageConverter>(JsonMessageConverter.DEFAULT_SERVICE_NAME) as JsonMessageConverter;
converter.TypeMapper.DefaultType = typeof(Dictionary <string, object>);
converter.Precedence = TypePrecedence.TYPE_ID;
var returned = template.ConvertSendAndReceive <Foo2>("test.converted", foo1);
Assert.IsType <Foo2>(returned);
Assert.Equal("bar", returned.Bar);
converter.Precedence = TypePrecedence.INFERRED;
template.MessageConverter = new Support.Converter.SimpleMessageConverter();
var messagePostProcessor = new MessagePostProcessor();
var returned2 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.converted", "{ \"bar\" : \"baz\" }", messagePostProcessor);
Assert.Equal("{\"bar\":\"baz\"}", Encoding.UTF8.GetString(returned2));
var returned3 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.converted.list", "[{ \"bar\" : \"baz\" }]", messagePostProcessor);
Assert.Equal("{\"bar\":\"BAZZZZ\"}", Encoding.UTF8.GetString(returned3));
var returned4 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.converted.array", "[{ \"bar\" : \"baz\" }]", messagePostProcessor);
Assert.Equal("{\"bar\":\"BAZZxx\"}", Encoding.UTF8.GetString(returned4));
var returned5 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.converted.args1", "{ \"bar\" : \"baz\" }", messagePostProcessor);
Assert.Equal("\"bar=baztest.converted.args1\"", Encoding.UTF8.GetString(returned5));
var returned6 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.converted.args2", "{ \"bar\" : \"baz\" }", messagePostProcessor);
Assert.Equal("\"bar=baztest.converted.args2\"", Encoding.UTF8.GetString(returned6));
var beanMethodHeaders = new List <string>();
var mpp = new AfterReceivePostProcessors(beanMethodHeaders);
template.SetAfterReceivePostProcessors(mpp);
var returned7 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.converted.message", "{ \"bar\" : \"baz\" }", messagePostProcessor);
Assert.Equal("\"bar=bazFoo2MessageFoo2Service\"", Encoding.UTF8.GetString(returned7));
Assert.Equal(2, beanMethodHeaders.Count);
Assert.Equal("Foo2Service", beanMethodHeaders[0]);
Assert.Equal("Foo2Message", beanMethodHeaders[1]);
template.RemoveAfterReceivePostProcessor(mpp);
var foo2Service = ctx.GetService <Foo2Service>();
Assert.IsType <Foo2Service>(foo2Service.Bean);
Assert.NotNull(foo2Service.Method);
Assert.Equal("Foo2Message", foo2Service.Method.Name);
var returned8 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.notconverted.message", "{ \"bar\" : \"baz\" }", messagePostProcessor);
Assert.Equal("\"fooMessage`1\"", Encoding.UTF8.GetString(returned8));
Assert.Equal("string", foo2Service.StringHeader);
Assert.Equal(42, foo2Service.IntHeader);
var returned9 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.notconverted.channel", "{ \"bar\" : \"baz\" }", messagePostProcessor);
Assert.Equal("\"barAndChannel\"", Encoding.UTF8.GetString(returned9));
var returned10 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.notconverted.messagechannel", "{ \"bar\" : \"baz\" }", messagePostProcessor);
Assert.Equal("\"bar=bazMessage`1AndChannel\"", Encoding.UTF8.GetString(returned10));
var returned11 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.notconverted.messagingmessage", "{ \"bar\" : \"baz\" }", messagePostProcessor);
Assert.Equal("\"Message`1Dictionary`2\"", Encoding.UTF8.GetString(returned11));
var returned12 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.converted.foomessage", "{ \"bar\" : \"baz\" }", messagePostProcessor);
Assert.Equal("\"Message`1Foo2guest\"", Encoding.UTF8.GetString(returned12));
var returned13 = template.ConvertSendAndReceive <byte[]>(string.Empty, "test.notconverted.messagingmessagenotgeneric", "{ \"bar\" : \"baz\" }", messagePostProcessor);
Assert.Equal("\"Message`1Dictionary`2\"", Encoding.UTF8.GetString(returned13));
}
public C CreateListenerContainer(IRabbitListenerEndpoint endpoint)
{
var instance = CreateContainerInstance();
instance.ConnectionFactory = ConnectionFactory;
instance.ErrorHandler = ErrorHandler;
if (MessageConverter != null && endpoint != null)
{
endpoint.MessageConverter = MessageConverter;
}
if (AcknowledgeMode.HasValue)
{
instance.AcknowledgeMode = AcknowledgeMode.Value;
}
if (ChannelTransacted.HasValue)
{
instance.IsChannelTransacted = ChannelTransacted.Value;
}
if (ApplicationContext != null)
{
instance.ApplicationContext = ApplicationContext;
}
if (TransactionManager != null)
{
instance.TransactionManager = TransactionManager;
}
if (PrefetchCount.HasValue)
{
instance.PrefetchCount = PrefetchCount.Value;
}
if (DefaultRequeueRejected.HasValue)
{
instance.DefaultRequeueRejected = DefaultRequeueRejected.Value;
}
if (RecoveryBackOff != null)
{
instance.RecoveryBackOff = RecoveryBackOff;
}
if (MismatchedQueuesFatal.HasValue)
{
instance.MismatchedQueuesFatal = MismatchedQueuesFatal.Value;
}
if (MissingQueuesFatal.HasValue)
{
instance.MissingQueuesFatal = MissingQueuesFatal.Value;
}
if (ConsumerTagStrategy != null)
{
instance.ConsumerTagStrategy = ConsumerTagStrategy;
}
if (IdleEventInterval.HasValue)
{
instance.IdleEventInterval = IdleEventInterval.Value;
}
if (FailedDeclarationRetryInterval.HasValue)
{
instance.FailedDeclarationRetryInterval = FailedDeclarationRetryInterval.Value;
}
if (AutoStartup.HasValue)
{
instance.IsAutoStartup = AutoStartup.Value;
}
instance.Phase = Phase;
if (AfterReceivePostProcessors != null)
{
instance.SetAfterReceivePostProcessors(AfterReceivePostProcessors.ToArray());
}
if (DeBatchingEnabled.HasValue)
{
instance.IsDeBatchingEnabled = DeBatchingEnabled.Value;
}
if (BatchListener && DeBatchingEnabled.HasValue)
{
// turn off container debatching by default for batch listeners
instance.IsDeBatchingEnabled = false;
}
if (endpoint != null)
{
if (endpoint.AutoStartup.HasValue)
{
instance.IsAutoStartup = endpoint.AutoStartup.Value;
}
if (endpoint.AckMode.HasValue)
{
instance.AcknowledgeMode = endpoint.AckMode.Value;
}
if (endpoint.BatchingStrategy != null)
{
instance.BatchingStrategy = endpoint.BatchingStrategy;
}
instance.ListenerId = endpoint.Id;
endpoint.BatchListener = BatchListener;
endpoint.SetupListenerContainer(instance);
}
var adapterListener = instance.MessageListener as AbstractMessageListenerAdapter;
if (adapterListener != null)
{
if (BeforeSendReplyPostProcessors != null)
{
adapterListener.SetBeforeSendReplyPostProcessors(BeforeSendReplyPostProcessors.ToArray());
}
if (RetryTemplate != null)
{
adapterListener.RetryTemplate = RetryTemplate;
if (ReplyRecoveryCallback != null)
{
adapterListener.RecoveryCallback = ReplyRecoveryCallback;
}
}
if (DefaultRequeueRejected.HasValue)
{
adapterListener.DefaultRequeueRejected = DefaultRequeueRejected.Value;
}
if (endpoint != null && endpoint.ReplyPostProcessor != null)
{
adapterListener.ReplyPostProcessor = endpoint.ReplyPostProcessor;
}
}
InitializeContainer(instance, endpoint);
ContainerCustomizer?.Invoke(instance);
return(instance);
}
