public override void Dispose()
{
TestChannel.ExchangeDelete("rawrabbit.integrationtests.testmessages");
TestChannel.QueueDelete("basicmessage");
TestChannel.QueueDelete("simplemessage");
base.Dispose();
}
public async Task Should_Be_Able_To_Get_BasicGetResult_Message()
{
using (var client = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var message = new BasicMessage {
Prop = "Get me, get it?"
};
var conventions = new NamingConventions();
var exchangeName = conventions.ExchangeNamingConvention(message.GetType());
var queueName = conventions.QueueNamingConvention(message.GetType());
TestChannel.QueueDeclare(queueName, true, false, false, null);
TestChannel.ExchangeDeclare(exchangeName, ExchangeType.Topic);
TestChannel.QueueBind(queueName, exchangeName, conventions.RoutingKeyConvention(message.GetType()) + ".#");
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
/* Test */
var ackable = await client.GetAsync(cfg => cfg.FromQueue(queueName));
/* Assert */
Assert.NotNull(ackable);
Assert.NotEmpty(ackable.Content.Body);
TestChannel.QueueDelete(queueName);
TestChannel.ExchangeDelete(exchangeName);
}
}
public override void Dispose()
{
TestChannel.QueueDelete(_firstBasicQueue);
TestChannel.QueueDelete(_firstSimpleQueue);
TestChannel.QueueDelete(_secondBasicQueue);
base.Dispose();
}
public async Task Should_Be_Able_To_Ack_Messages_And_Then_Full_List()
{
using (var client = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var message = new BasicMessage {
Prop = "Get me, get it?"
};
var conventions = new NamingConventions();
var exchangeName = conventions.ExchangeNamingConvention(message.GetType());
TestChannel.QueueDeclare(conventions.QueueNamingConvention(message.GetType()), true, false, false, null);
TestChannel.ExchangeDeclare(conventions.ExchangeNamingConvention(message.GetType()), ExchangeType.Topic);
TestChannel.QueueBind(conventions.QueueNamingConvention(message.GetType()), exchangeName, conventions.RoutingKeyConvention(message.GetType()) + ".#");
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
/* Test */
var ackable = await client.GetManyAsync <BasicMessage>(3);
ackable.Content[1].Ack();
ackable.Ack();
TestChannel.QueueDelete(conventions.QueueNamingConvention(message.GetType()));
TestChannel.ExchangeDelete(exchangeName);
/* Assert */
Assert.True(true);
}
}
public async Task Should_Be_Able_To_Get_Message_When_Batch_Size_Is_Smaller_Than_Queue_Length()
{
using (var client = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var message = new BasicMessage {
Prop = "Get me, get it?"
};
var conventions = new NamingConventions();
var exchangeName = conventions.ExchangeNamingConvention(message.GetType());
TestChannel.QueueDeclare(conventions.QueueNamingConvention(message.GetType()), true, false, false, null);
TestChannel.ExchangeDeclare(conventions.ExchangeNamingConvention(message.GetType()), ExchangeType.Topic);
TestChannel.QueueBind(conventions.QueueNamingConvention(message.GetType()), conventions.ExchangeNamingConvention(message.GetType()), conventions.RoutingKeyConvention(message.GetType()) + ".#");
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
/* Test */
var ackable = await client.GetManyAsync <BasicMessage>(2);
TestChannel.QueueDelete(conventions.QueueNamingConvention(message.GetType()));
TestChannel.ExchangeDelete(exchangeName);
/* Assert */
Assert.NotNull(ackable);
Assert.Equal(ackable.Content.Count, 2);
}
}
public async Task Should_Be_Able_To_Nack_On_Subscribe()
{
/* Setup */
var subscriber = BusClientFactory.CreateDefault <AdvancedMessageContext>();
var secondSubscriber = BusClientFactory.CreateDefault <AdvancedMessageContext>();
var publisher = BusClientFactory.CreateDefault <AdvancedMessageContext>();
var callcount = 0;
var subscribeTcs = new TaskCompletionSource <bool>();
var secondSubscribeTcs = new TaskCompletionSource <bool>();
subscriber.SubscribeAsync <BasicMessage>((message, context) =>
{
Interlocked.Increment(ref callcount);
context?.Nack();
subscribeTcs.TrySetResult(true);
return(Task.FromResult(true));
});
secondSubscriber.SubscribeAsync <BasicMessage>((message, context) =>
{
secondSubscribeTcs.TrySetResult(true);
return(Task.FromResult(true));
});
Task.WaitAll(
publisher.PublishAsync <BasicMessage>(),
subscribeTcs.Task,
secondSubscribeTcs.Task
);
TestChannel.QueueDelete("basicmessage");
Assert.Equal(expected: 1, actual: callcount);
}
public MessageSequenceTests()
{
_client = RawRabbitFactory.GetExtendableClient() as ExtendableBusClient <MessageContext>;
TestChannel.QueueDelete("basicrequest_dnx");
TestChannel.QueueDelete("firstmessage_dnx");
TestChannel.QueueDelete("secondmessage_dnx");
TestChannel.QueueDelete("thirdmessage_dnx");
}
public MessageSequenceTests()
{
_client = RawRabbitFactory.Create();
TestChannel.QueueDelete("basicrequest_dnx");
TestChannel.QueueDelete("firstmessage_dnx");
TestChannel.QueueDelete("secondmessage_dnx");
TestChannel.QueueDelete("thirdmessage_dnx");
}
public async Task Should_Stop_Subscribe_When_Subscription_Is_Disposed()
{
/* Setup */
using (var publisher = TestClientFactory.CreateNormal())
using (var subscriber = TestClientFactory.CreateNormal())
{
var firstMessage = new BasicMessage {
Prop = "Value"
};
var secondMessage = new BasicMessage {
Prop = "AnotherValue"
};
var firstRecievedTcs = new TaskCompletionSource <BasicMessage>();
var secondRecievedTcs = new TaskCompletionSource <BasicMessage>();
var recievedCount = 0;
var subscription = subscriber.SubscribeAsync <BasicMessage>((message, context) =>
{
recievedCount++;
if (!firstRecievedTcs.Task.IsCompleted)
{
firstRecievedTcs.SetResult(message);
}
return(Task.FromResult(true));
}, cfg => cfg.WithQueue(q => q.WithAutoDelete(false)));
/* Test */
publisher.PublishAsync(firstMessage);
await firstRecievedTcs.Task;
subscription.Dispose();
var recievedAfterFirstPublish = recievedCount;
publisher.PublishAsync(secondMessage);
await Task.Delay(20);
publisher.SubscribeAsync <BasicMessage>((message, context) =>
{
secondRecievedTcs.SetResult(message);
return(Task.FromResult(true));
}, cfg => cfg.WithQueue(q => q.WithAutoDelete(false)));
await secondRecievedTcs.Task;
TestChannel.QueueDelete(subscription.QueueName);
/* Assert */
Assert.Equal(recievedAfterFirstPublish, recievedCount);
Assert.Equal(firstRecievedTcs.Task.Result.Prop, firstMessage.Prop);
Assert.Equal(secondRecievedTcs.Task.Result.Prop, secondMessage.Prop);
}
}
public async Task Should_Be_Able_To_Nack_One_In_Batch()
{
using (var client = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var message = new BasicMessage {
Prop = "Get me, get it?"
};
var nacked = new BasicMessage {
Prop = "Not me! Plz?"
};
var conventions = new NamingConventions();
var exchangeName = conventions.ExchangeNamingConvention(message.GetType());
TestChannel.QueueDeclare(conventions.QueueNamingConvention(message.GetType()), true, false, false, null);
TestChannel.ExchangeDeclare(exchangeName, ExchangeType.Topic);
TestChannel.QueueBind(conventions.QueueNamingConvention(message.GetType()), conventions.ExchangeNamingConvention(message.GetType()), conventions.RoutingKeyConvention(message.GetType()) + ".#");
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(nacked, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
/* Test */
var ackableList = await client.GetManyAsync <BasicMessage>(3);
foreach (var ackableMsg in ackableList.Content)
{
if (string.Equals(ackableMsg.Content.Prop, message.Prop))
{
ackableMsg.Ack();
}
else
{
ackableMsg.Nack();
}
}
var getAgain = await client.GetAsync <BasicMessage>();
TestChannel.QueueDelete(conventions.QueueNamingConvention(message.GetType()));
TestChannel.ExchangeDelete(exchangeName);
/* Assert */
Assert.NotNull(getAgain);
Assert.Equal(getAgain.Content.Prop, nacked.Prop);
}
}
public async Task Should_Be_Able_To_Subscribe_Initialized_Queue_And_Exchange()
{
using (var client = TestClientFactory.CreateNormal())
{
/* Setup */
const string exchangeName = "initialized.exchange";
const string queueName = "initialized.queue";
try
{
TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Fanout);
TestChannel.QueueDeclare(queueName, true, false, false);
var tcs = new TaskCompletionSource <DynamicMessage>();
client.SubscribeAsync <DynamicMessage>((message, context) =>
{
tcs.TrySetResult(message);
return(Task.FromResult(true));
}, cfg => cfg
.WithQueue(q => q
.AssumeInitialized()
.WithName(queueName))
.WithSubscriberId(string.Empty)
.WithExchange(e => e
.AssumeInitialized()
.WithName(exchangeName)));
/* Test */
await client.PublishAsync(new DynamicMessage { Body = new { IsDynamic = true } },
configuration : cfg => cfg
.WithExchange(e => e
.AssumeInitialized()
.WithName(exchangeName)));
await tcs.Task;
/* Assert */
Assert.True(tcs.Task.Result.Body.IsDynamic);
}
finally
{
/* Teardown */
TestChannel.QueueDelete(queueName);
TestChannel.ExchangeDelete(exchangeName);
}
}
}
public async Task Should_Be_Able_To_Get_BasicGetResult_When_Queue_IsEmpty()
{
using (var client = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var message = new BasicMessage();
var conventions = new NamingConventions();
var queueName = conventions.QueueNamingConvention(message.GetType());
TestChannel.QueueDeclare(queueName, true, false, false, null);
/* Test */
var ackable = await client.GetAsync(cfg => cfg.FromQueue(queueName));
/* Assert */
Assert.NotNull(ackable);
Assert.Null(ackable.Content);
TestChannel.QueueDelete(queueName);
}
}
public override void Dispose()
{
TestChannel.QueueDelete("hello");
base.Dispose();
}
public HelloWorldTest()
{
TestChannel.QueueDelete("hello");
}
public TopicExchangeTests()
{
TestChannel.ExchangeDelete("rawrabbit.integrationtests.testmessages");
TestChannel.QueueDelete("basicmessage");
TestChannel.QueueDelete("simplemessage");
}
public override void Dispose()
{
TestChannel.QueueDelete("task_queue");
base.Dispose();
}
public WorkQueueTest()
{
TestChannel.QueueDelete("task_queue");
}
public NackingTests()
{
TestChannel.QueueDelete("basicmessage");
}
