public async Task Should_Be_Able_To_Recieve_Different_Types_Of_Messages()
{
/* Setup */
var publisher = BusClientFactory.CreateDefault();
var subscriber = BusClientFactory.CreateDefault();
var basicMsg = new BasicMessage {Prop = "Hello, world!"};
var simpleMsg = new SimpleMessage {IsSimple = true};
var basicMsgTcs = new TaskCompletionSource<BasicMessage>();
var simpleMsgTcs = new TaskCompletionSource<SimpleMessage>();
subscriber.SubscribeAsync<BasicMessage>((msg, i) =>
{
basicMsgTcs.SetResult(msg);
return basicMsgTcs.Task;
});
subscriber.SubscribeAsync<SimpleMessage>((msg, i) =>
{
simpleMsgTcs.SetResult(msg);
return basicMsgTcs.Task;
});
/* Test */
publisher.PublishAsync(basicMsg);
publisher.PublishAsync(simpleMsg);
Task.WaitAll(basicMsgTcs.Task, simpleMsgTcs.Task);
/* Assert */
Assert.Equal(basicMsgTcs.Task.Result.Prop, basicMsg.Prop);
Assert.Equal(simpleMsgTcs.Task.Result.IsSimple, simpleMsg.IsSimple);
}
public async Task Should_Support_The_Hello_World_Tutorial()
{
/* Setup */
using (var sender = TestClientFactory.CreateNormal())
using (var reciever = TestClientFactory.CreateNormal())
{
var sent = new BasicMessage { Prop = "Hello, world!" };
var recieved = new TaskCompletionSource<BasicMessage>();
reciever.SubscribeAsync<BasicMessage>((message, info) =>
{
recieved.SetResult(message);
return Task.FromResult(true);
}, configuration => configuration
.WithQueue(queue =>
queue
.WithName("hello")
.WithExclusivity(false)
.WithAutoDelete(false)
)
.WithRoutingKey("hello")
);
/* Test */
await sender.PublishAsync(sent,
configuration: builder => builder
.WithRoutingKey("hello")
);
await recieved.Task;
/* Assert */
Assert.Equal(expected: sent.Prop, actual: recieved.Task.Result.Prop);
}
}
public async Task Should_Be_Able_To_Subscribe_Without_Any_Additional_Config()
{
/* Setup */
using (var publisher = TestClientFactory.CreateNormal())
using (var subscriber = TestClientFactory.CreateNormal())
{
var message = new BasicMessage {Prop = "Hello, world!"};
var recievedTcs = new TaskCompletionSource<BasicMessage>();
subscriber.SubscribeAsync<BasicMessage>((msg, info) =>
{
if (msg.Prop == message.Prop)
{
recievedTcs.SetResult(msg);
}
return Task.FromResult(true);
});
/* Test */
publisher.PublishAsync(message);
await recievedTcs.Task;
/* Assert */
Assert.Equal(expected: message.Prop, actual: recievedTcs.Task.Result.Prop);
}
}
public async Task Should_Support_The_Worker_Queues_Tutorial()
{
/* Setup */
var sent = new BasicMessage { Prop = "Hello, world!" };
var recieved = new TaskCompletionSource<BasicMessage>();
var sender = BusClientFactory.CreateDefault();
var reciever = BusClientFactory.CreateDefault();
reciever.SubscribeAsync<BasicMessage>((message, info) =>
{
recieved.SetResult(message);
return Task.FromResult(true);
}, configuration => configuration
.WithPrefetchCount(1)
.WithQueue(queue =>
queue
.WithName("task_queue")
.WithDurability()
)
.WithRoutingKey("task_queue")
);
/* Test */
await sender.PublishAsync(sent,
configuration: builder => builder
.WithRoutingKey("task_queue")
);
await recieved.Task;
/* Assert */
Assert.Equal(sent.Prop, recieved.Task.Result.Prop);
}
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 void 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 };
var client = RawRabbitFactory.GetExtendableClient() as ExtendableBusClient<MessageContext>;
client.PublishAsync(secondBasicMsg);
client.PublishAsync(firstBasicMsg);
client.PublishAsync(thridBasicMsg);
client.PublishAsync(firstSimpleMsg);
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(basics.Count, 4);
Assert.Equal(simple.Count, 1);
}
public async Task Should_Be_Able_To_Subscribe_Without_Any_Additional_Config()
{
/* Setup */
var message = new BasicMessage { Prop = "Hello, world!" };
var recievedTcs = new TaskCompletionSource<BasicMessage>();
var publisher = BusClientFactory.CreateDefault();
var subscriber = BusClientFactory.CreateDefault();
subscriber.SubscribeAsync<BasicMessage>((msg, info) =>
{
recievedTcs.SetResult(msg);
return recievedTcs.Task;
});
/* Test */
publisher.PublishAsync(message);
await recievedTcs.Task;
/* Assert */
Assert.Equal(recievedTcs.Task.Result.Prop, message.Prop);
}
public async Task Should_Publish_Message_On_Error_Exchange_If_Subscribe_Throws_Exception()
{
/* Setup */
var conventions = new NamingConventions();
var client = BusClientFactory.CreateDefault(null, ioc => ioc.AddSingleton(c => conventions));
var recieveTcs = new TaskCompletionSource<HandlerExceptionMessage>();
MessageContext firstRecieved = null;
MessageContext secondRecieved = null;
client.SubscribeAsync<HandlerExceptionMessage>((message, context) =>
{
secondRecieved = context;
recieveTcs.TrySetResult(message);
return Task.FromResult(true);
}, c => c
.WithExchange(e => e.WithName(conventions.ErrorExchangeNamingConvention()))
.WithQueue(q => q.WithArgument(QueueArgument.MessageTtl, (int)TimeSpan.FromSeconds(1).TotalMilliseconds))
.WithRoutingKey("#"));
client.SubscribeAsync<BasicMessage>((message, context) =>
{
firstRecieved = context;
throw new Exception("Oh oh!");
});
var originalMsg = new BasicMessage { Prop = "Hello, world" };
/* Test */
client.PublishAsync(originalMsg);
await recieveTcs.Task;
/* Assert */
Assert.Equal(((BasicMessage)recieveTcs.Task.Result.Message).Prop, originalMsg.Prop);
Assert.NotNull(firstRecieved);
Assert.NotNull(secondRecieved);
Assert.Equal(firstRecieved.GlobalRequestId, secondRecieved.GlobalRequestId);
}
public async Task Should_Stop_Subscribe_When_Subscription_Is_Disposed()
{
/* Setup */
var publisher = BusClientFactory.CreateDefault();
var subscriber = BusClientFactory.CreateDefault();
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++;
firstRecievedTcs.SetResult(message);
return Task.FromResult(true);
});
/* Test */
await publisher.PublishAsync(firstMessage);
await firstRecievedTcs.Task;
subscription.Dispose();
var recievedAfterFirstPublish = recievedCount;
await publisher.PublishAsync(secondMessage);
await Task.Delay(20);
publisher.SubscribeAsync<BasicMessage>((message, context) =>
{
secondRecievedTcs.SetResult(message);
return Task.FromResult(true);
});
await secondRecievedTcs.Task;
/* 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_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);
}
}
