public async Task Should_Use_Routing_Key_Transformer_If_Present()
{
/* Setup */
using (var legacyClient = TestClientFactory.CreateExtendable(ioc => ioc.AddSingleton(s => RawRabbitConfiguration.Local.AsLegacy())))
using (var currentClient = TestClientFactory.CreateExtendable())
{
var legacyTcs = new TaskCompletionSource <BasicMessage>();
var currentTcs = new TaskCompletionSource <BasicMessage>();
currentClient.SubscribeAsync <BasicMessage>((message, context) =>
{
if (!currentTcs.Task.IsCompleted)
{
currentTcs.SetResult(message);
return(currentTcs.Task);
}
if (!legacyTcs.Task.IsCompleted)
{
legacyTcs.SetResult(message);
return(legacyTcs.Task);
}
return(Task.FromResult(true));
});
/* Test */
// 1. Verify subscriber
currentClient.PublishAsync <BasicMessage>();
await currentTcs.Task;
// 2. Change Type
await currentClient.UpdateTopologyAsync(c => c
.ExchangeForMessage <BasicMessage>()
.UseConfiguration(
exchange => exchange.WithType(ExchangeType.Direct),
bindingKey => bindingKey.Replace(".#", string.Empty))
);
// 3. Verify subscriber
legacyClient.PublishAsync <BasicMessage>();
await legacyTcs.Task;
/* Assert */
Assert.True(true);
}
}
public async Task Should_Honor_Timeout()
{
/* Setup */
var cfg = RawRabbitConfiguration.Local;
cfg.RequestTimeout = TimeSpan.FromMilliseconds(200);
using (var client = TestClientFactory.CreateExtendable(ioc => ioc.AddSingleton(c => cfg)))
{
/* Test */
var chain = client.ExecuteSequence(c => c
.PublishAsync <FirstMessage>()
.Complete <SecondMessage>()
);
/* Assert */
await Assert.ThrowsAsync <TimeoutException>(async() => await chain.Task);
}
}
public async Task Should_Be_Able_To_Bulk_Get_Messages()
{
var firstBasicMsg = new BasicMessage {
Prop = "This is the first message"
};
var secondBasicMsg = new BasicMessage {
Prop = "This is the second message"
};
var thridBasicMsg = new BasicMessage {
Prop = "This is the thrid message"
};
var firstSimpleMsg = new SimpleMessage {
IsSimple = true
};
using (var client = TestClientFactory.CreateExtendable())
{
await client.PublishAsync(secondBasicMsg);
await client.PublishAsync(firstBasicMsg);
await client.PublishAsync(thridBasicMsg);
await client.PublishAsync(firstSimpleMsg);
await Task.Delay(500);
var bulk = client.GetMessages(cfg => cfg
.ForMessage <BasicMessage>(msg => msg
.FromQueues(_firstBasicQueue, _secondBasicQueue)
.WithBatchSize(4))
.ForMessage <SimpleMessage>(msg => msg
.FromQueues(_firstSimpleQueue)
.GetAll()
.WithNoAck()
));
var basics = bulk.GetMessages <BasicMessage>().ToList();
var simple = bulk.GetMessages <SimpleMessage>().ToList();
bulk.AckAll();
Assert.Equal(expected: 4, actual: basics.Count);
Assert.Equal(expected: 1, actual: simple.Count);
}
}
public async Task Should_Not_Interupt_Existing_Subscribers_When_Using_Custom_Config()
{
/* Setup */
var cfg = RawRabbitConfiguration.Local.AsLegacy();
using (var client = TestClientFactory.CreateExtendable(ioc => ioc.AddSingleton(s => cfg)))
{
var firstTcs = new TaskCompletionSource <BasicMessage>();
var secondTcs = new TaskCompletionSource <BasicMessage>();
client.SubscribeAsync <BasicMessage>((message, context) =>
{
if (!firstTcs.Task.IsCompleted)
{
firstTcs.SetResult(message);
return(firstTcs.Task);
}
if (!secondTcs.Task.IsCompleted)
{
secondTcs.SetResult(message);
return(secondTcs.Task);
}
return(Task.FromResult(true));
});
/* Test */
// 1. Verify subscriber
client.PublishAsync <BasicMessage>();
await firstTcs.Task;
// 2. Change Type
await client.UpdateTopologyAsync(c => c
.ExchangeForMessage <BasicMessage>()
.UseConfiguration(e => e.WithType(ExchangeType.Topic)));
// 3. Verify subscriber
client.PublishAsync <BasicMessage>();
await secondTcs.Task;
/* Assert */
Assert.True(true, "First and second message was delivered.");
}
}
public async Task Should_Honor_Last_Configuration()
{
/* Setup */
using (var client = TestClientFactory.CreateExtendable())
{
const string exchangeName = "topology";
TestChannel.ExchangeDelete(exchangeName);
/* Test */
var result = await client.UpdateTopologyAsync(c => c
.ForExchange(exchangeName)
.UseConfiguration(e => e.WithType(ExchangeType.Headers))
.ForExchange(exchangeName)
.UseConfiguration(e => e.WithType(ExchangeType.Topic))
.ForExchange(exchangeName)
.UseConfiguration(e => e.WithType(ExchangeType.Direct))
.ForExchange(exchangeName)
.UseConfiguration(e => e.WithType(ExchangeType.Fanout)));
/* Assert */
Assert.Equal(result.Exchanges[0].Exchange.ExchangeType, ExchangeType.Fanout.ToString().ToLower());
}
}
public async Task Should_Call_Message_Handler_In_Correct_Order()
{
/* Setup */
using (var publisher = TestClientFactory.CreateExtendable())
{
publisher.SubscribeAsync <FirstMessage>((message, context) =>
publisher.PublishAsync(new SecondMessage(), context.GlobalRequestId));
publisher.SubscribeAsync <SecondMessage>((message, context) =>
publisher.PublishAsync(new ThirdMessage(), context.GlobalRequestId));
publisher.SubscribeAsync <ThirdMessage>((message, context) =>
publisher.PublishAsync(new ForthMessage(), context.GlobalRequestId));
var recieveIndex = 0;
var secondMsgDate = DateTime.MinValue;
var thirdMsgDate = DateTime.MinValue;
/* Test */
var chain = _client.ExecuteSequence(c => c
.PublishAsync(new FirstMessage())
.When <SecondMessage>((message, context) =>
{
secondMsgDate = DateTime.Now;
return(Task.FromResult(true));
})
.When <ThirdMessage>((message, context) =>
{
thirdMsgDate = DateTime.Now;
return(Task.FromResult(true));
})
.Complete <ForthMessage>()
);
await chain.Task;
/* Assert */
Assert.True(secondMsgDate < thirdMsgDate);
}
}
public async Task Should_Update_Exhange_Type()
{
/* Setup */
const string exchangeName = "topology";
TestChannel.ExchangeDelete(exchangeName);
TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Direct);
using (var client = TestClientFactory.CreateExtendable())
{
/* Test */
await client.UpdateTopologyAsync(t => t
.ForExchange(exchangeName)
.UseConfiguration(e => e
.WithType(ExchangeType.Topic)
.WithDurability(false))
);
/* Assert */
TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Topic);
Assert.True(true, "Did not throw");
Assert.Throws <OperationInterruptedException>(() => TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Direct));
}
}
public MessageSequenceTests()
{
_client = TestClientFactory.CreateExtendable();
}
