public async Task Should_Implicit_Forward_Context_On_Publish()
{
/* Setup */
using (var publisher = TestClientFactory.CreateNormal())
using (var firstSubscriber = TestClientFactory.CreateNormal())
using (var secondSubscriber = TestClientFactory.CreateNormal())
{
var firstCtxTcs = new TaskCompletionSource <MessageContext>();
var secondCtxTcs = new TaskCompletionSource <MessageContext>();
firstSubscriber.SubscribeAsync <BasicMessage>((msg, i) =>
{
firstCtxTcs.SetResult(i);
firstSubscriber.PublishAsync(new SimpleMessage());
return(firstCtxTcs.Task);
});
secondSubscriber.SubscribeAsync <SimpleMessage>((msg, i) =>
{
secondCtxTcs.SetResult(i);
return(secondCtxTcs.Task);
});
/* Test */
publisher.PublishAsync <BasicMessage>();
Task.WaitAll(firstCtxTcs.Task, secondCtxTcs.Task);
/* Assert */
Assert.Equal(firstCtxTcs.Task.Result.GlobalRequestId, secondCtxTcs.Task.Result.GlobalRequestId);
}
}
public async Task Should_Be_Able_To_Publish_Message_After_Failed_Publish()
{
using (var firstClient = TestClientFactory.CreateNormal())
using (var secondClient = TestClientFactory.CreateNormal())
{
/* Setup */
var tcs = new TaskCompletionSource <bool>();
firstClient.SubscribeAsync <SimpleMessage>((message, context) =>
{
tcs.TrySetResult(true);
return(Task.FromResult(true));
});
/* Test */
try
{
await
secondClient.PublishAsync(new SimpleMessage(),
configuration : cfg => cfg.WithExchange(e => e.WithType(ExchangeType.Direct)));
}
catch (Exception)
{
await Task.Delay(50);
Assert.False(tcs.Task.IsCompleted);
}
secondClient.PublishAsync(new SimpleMessage());
await tcs.Task;
/* Assert */
Assert.True(true);
}
}
public void Should_Be_Able_To_Perform_Subscribe_For_Multiple_Types()
{
/* Setup */
using (var subscriber = TestClientFactory.CreateNormal())
using (var publisher = TestClientFactory.CreateNormal())
{
var basicTcs = new TaskCompletionSource <BasicMessage>();
var simpleTcs = new TaskCompletionSource <SimpleMessage>();
subscriber.SubscribeAsync <BasicMessage>((message, context) =>
{
basicTcs.SetResult(message);
return(Task.FromResult(true));
});
subscriber.SubscribeAsync <SimpleMessage>((message, context) =>
{
simpleTcs.SetResult(message);
return(Task.FromResult(true));
});
/* Test */
publisher.PublishAsync <BasicMessage>();
publisher.PublishAsync <SimpleMessage>();
Task.WaitAll(basicTcs.Task, simpleTcs.Task);
/* Assert */
Assert.True(true, "Successfully recieved messages.");
}
}
public async Task Should_Successfully_Perform_Nested_Requests()
{
/* Setup */
using (var requester = TestClientFactory.CreateNormal())
using (var firstResponder = TestClientFactory.CreateNormal())
using (var secondResponder = TestClientFactory.CreateNormal())
{
var payload = Guid.NewGuid();
firstResponder.RespondAsync <FirstRequest, FirstResponse>(async(req, i) =>
{
var secondResp = await firstResponder.RequestAsync <SecondRequest, SecondResponse>(new SecondRequest());
return(new FirstResponse {
Infered = secondResp.Source
});
});
secondResponder.RespondAsync <SecondRequest, SecondResponse>((req, i) =>
Task.FromResult(new SecondResponse {
Source = payload
})
);
/* Test */
var response = await requester.RequestAsync <FirstRequest, FirstResponse>(new FirstRequest());
/* Assert */
Assert.Equal(expected: payload, actual: response.Infered);
}
}
public async Task Should_Be_Able_To_Perform_Multiple_Pub_Subs()
{
/* Setup */
using (var subscriber = TestClientFactory.CreateNormal())
using (var publisher = TestClientFactory.CreateNormal())
{
const int numberOfCalls = 100;
var recived = 0;
var recievedTcs = new TaskCompletionSource <bool>();
subscriber.SubscribeAsync <BasicMessage>((message, context) =>
{
Interlocked.Increment(ref recived);
if (numberOfCalls == recived)
{
recievedTcs.SetResult(true);
}
return(Task.FromResult(true));
});
/* Test */
var sw = Stopwatch.StartNew();
for (int i = 0; i < numberOfCalls; i++)
{
publisher.PublishAsync <BasicMessage>();
}
await recievedTcs.Task;
sw.Stop();
/* Assert */
Assert.True(true, $"Completed {numberOfCalls} in {sw.ElapsedMilliseconds} ms.");
}
}
public async Task Should_Just_Work()
{
/* Setup */
using (var requester = TestClientFactory.CreateNormal())
using (var responder = TestClientFactory.CreateNormal())
{
const int numberOfCalls = 10000;
var array = new Task[numberOfCalls];
responder.RespondAsync <FirstRequest, FirstResponse>((req, i) =>
Task.FromResult(new FirstResponse {
Infered = Guid.NewGuid()
})
);
/* Test */
var sw = new Stopwatch();
sw.Start();
for (var i = 0; i < numberOfCalls; i++)
{
var response = requester.RequestAsync <FirstRequest, FirstResponse>();
array[i] = response;
}
Task.WaitAll(array);
sw.Stop();
var ids = array
.OfType <Task <FirstResponse> >()
.Select(b => b.Result.Infered)
.Where(id => id != Guid.Empty)
.Distinct()
.ToList();
/* Assert */
Assert.Equal(expected: numberOfCalls, actual: ids.Count);
}
}
public async Task Should_Retry_And_Leave_Requester_Hanging_On_Rpc()
{
using (var requester = TestClientFactory.CreateNormal <AdvancedMessageContext>())
using (var responder = TestClientFactory.CreateNormal <AdvancedMessageContext>())
{
var delay = TimeSpan.FromSeconds(1);
var hasBeenDelayed = false;
var firstRecieved = DateTime.MinValue;
var secondRecieved = DateTime.MinValue;
responder.RespondAsync <BasicRequest, BasicResponse>((request, context) =>
{
if (!hasBeenDelayed)
{
firstRecieved = DateTime.Now;
hasBeenDelayed = true;
context.RetryLater(delay);
return(Task.FromResult <BasicResponse>(null));
}
secondRecieved = DateTime.Now;
return(Task.FromResult(new BasicResponse()));
});
/* Test */
var response = await requester.RequestAsync <BasicRequest, BasicResponse>();
var actualDelay = secondRecieved - firstRecieved;
await Task.Delay(80);
/* Assert */
Assert.Equal(expected: delay.Seconds, actual: actualDelay.Seconds);
}
}
public async Task Should_Not_Throw_If_Response_Is_Handled_Within_Time_Limit()
{
/* Setup */
var requester = TestClientFactory.CreateNormal(ioc =>
{
ioc.AddSingleton(p =>
{
var cfg = RawRabbitConfiguration.Local;
cfg.RequestTimeout = TimeSpan.FromMilliseconds(200);
return(cfg);
});
});
using (var responder = TestClientFactory.CreateNormal())
using (requester)
{
responder.RespondAsync <FirstRequest, FirstResponse>((request, context) =>
{
return(Task.FromResult(new FirstResponse()));
}, cfg => cfg.WithQueue(q => q.WithAutoDelete()));
/* Test */
await requester.RequestAsync <FirstRequest, FirstResponse>();
/* Assert */
Assert.True(true, "Response recieved without throwing.");
}
}
public async Task Should_Interupt_Task_After_Timeout_Not_Met()
{
/* Setup */
var requester = TestClientFactory.CreateNormal(ioc =>
{
ioc.AddSingleton(p =>
{
var cfg = RawRabbitConfiguration.Local;
cfg.RequestTimeout = TimeSpan.FromMilliseconds(200);
return(cfg);
});
});
using (var responder = TestClientFactory.CreateNormal())
using (requester)
{
responder.RespondAsync <FirstRequest, FirstResponse>((request, context) =>
{
return(Task
.Run(() => Task.Delay(250))
.ContinueWith(t => new FirstResponse()));
}, cfg => cfg.WithQueue(q => q.WithAutoDelete()));
/* Test */
/* Assert */
await Assert.ThrowsAsync <TimeoutException>(() => requester.RequestAsync <FirstRequest, FirstResponse>());
}
}
public async Task Should_Work_When_Not_Awaiting_One_Response_At_A_Time()
{
/* Setup */
using (var requester = TestClientFactory.CreateNormal())
using (var responder = TestClientFactory.CreateNormal())
{
const int numberOfCalls = 10;
var tasks = new Task[numberOfCalls];
responder.RespondAsync <FirstRequest, FirstResponse>((req, i) =>
Task.FromResult(new FirstResponse {
Infered = Guid.NewGuid()
}),
cfg => cfg.WithQueue(q => q.WithAutoDelete()));
/* Test */
for (int i = 0; i < numberOfCalls; i++)
{
var responseTask = requester.RequestAsync <FirstRequest, FirstResponse>();
tasks[i] = responseTask;
}
Task.WaitAll(tasks);
var ids = tasks
.OfType <Task <FirstResponse> >()
.Select(t => t.Result.Infered)
.Distinct()
.ToList();
/* Assert */
Assert.Equal(expected: numberOfCalls, actual: ids.Count);
}
}
public async Task Should_Honor_Custom_Config()
{
/* Setup */
using (var client = TestClientFactory.CreateNormal(ioc => ioc
.AddSingleton <IConfigurationEvaluator, AttributeConfigEvaluator>()
))
{
var tcs = new TaskCompletionSource <AttributedMessage>();
client.SubscribeAsync <AttributedMessage>((message, context) =>
{
tcs.TrySetResult(message);
return(Task.FromResult(true));
}, c => c
.WithRoutingKey("special")
.WithExchange(e => e.WithName("special")));
/* Test */
await
client.PublishAsync(new AttributedMessage(),
configuration : c => c.WithRoutingKey("special").WithExchange(e => e.WithName("special")));
await tcs.Task;
/* Assert */
Assert.True(true, "Routing successful.");
}
}
public async Task Should_Send_Message_Context_Correctly()
{
/* Setup */
var expectedId = Guid.NewGuid();
var contextProvider = new MessageContextProvider <MessageContext>(new JsonSerializer(), () => new MessageContext {
GlobalRequestId = expectedId
});
using (var subscriber = TestClientFactory.CreateNormal())
using (var publisher = TestClientFactory.CreateNormal(collection => collection.AddSingleton <IMessageContextProvider <MessageContext> >(contextProvider)))
{
var subscribeTcs = new TaskCompletionSource <Guid>();
subscriber.SubscribeAsync <BasicMessage>((msg, c) =>
{
subscribeTcs.SetResult(c.GlobalRequestId);
return(subscribeTcs.Task);
});
/* Test */
publisher.PublishAsync <BasicMessage>();
await subscribeTcs.Task;
/* Assert */
Assert.Equal(expected: expectedId, actual: subscribeTcs.Task.Result);
}
}
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 void Should_Be_Able_To_Deliver_Messages_To_Unique_Subscribers()
{
/* Setup */
using (var firstSubscriber = TestClientFactory.CreateNormal())
using (var secondSubscriber = TestClientFactory.CreateNormal())
using (var publisher = TestClientFactory.CreateNormal())
{
var firstTcs = new TaskCompletionSource <bool>();
var secondTcs = new TaskCompletionSource <bool>();
firstSubscriber.SubscribeAsync <BasicMessage>((message, context) =>
{
firstTcs.SetResult(true);
return(Task.FromResult(true));
}, cfg => cfg.WithSubscriberId("first_subscriber"));
secondSubscriber.SubscribeAsync <BasicMessage>((message, context) =>
{
secondTcs.SetResult(true);
return(Task.FromResult(true));
}, cfg => cfg.WithSubscriberId("second_subscriber"));
/* Test */
var ackTask = publisher.PublishAsync <BasicMessage>();
Task.WaitAll(ackTask, firstTcs.Task, secondTcs.Task);
/* Assert */
Assert.True(true, "Published and subscribe sucessfull.");
}
}
public async Task Should_Be_Able_To_Nack_On_Subscribe()
{
/* Setup */
using (var subscriber = TestClientFactory.CreateNormal <AdvancedMessageContext>())
using (var secondSubscriber = TestClientFactory.CreateNormal <AdvancedMessageContext>())
using (var publisher = TestClientFactory.CreateNormal <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 void Should_Throw_When_Subscribed_Not_Initialized_Queue()
{
using (var client = TestClientFactory.CreateNormal())
{
/* Setup */
const string queueName = "not.initialized.queue";
var tcs = new TaskCompletionSource <DynamicMessage>();
/* Test */
Assert.Throws <AggregateException>(() =>
client.SubscribeAsync <DynamicMessage>((message, context) =>
{
tcs.TrySetResult(message);
return(Task.FromResult(true));
}, cfg => cfg
.WithQueue(q => q
.AssumeInitialized()
.WithName(queueName))
));
Assert.False(tcs.Task.IsCompleted);
}
}
public async Task Should_Forward_Context_On_Rpc_To_Publish()
{
/* Setup */
using (var requester = TestClientFactory.CreateNormal())
using (var firstResponder = TestClientFactory.CreateNormal())
using (var firstSubscriber = TestClientFactory.CreateNormal())
{
var tcs = new TaskCompletionSource <bool>();
MessageContext firstContext = null;
MessageContext secondContext = null;
firstResponder.RespondAsync <FirstRequest, FirstResponse>(async(req, c) =>
{
firstContext = c;
await firstResponder.PublishAsync(new BasicMessage(), c.GlobalRequestId);
return(new FirstResponse());
});
firstSubscriber.SubscribeAsync <BasicMessage>((req, c) =>
{
secondContext = c;
tcs.SetResult(true);
return(tcs.Task);
});
/* Test */
requester.RequestAsync <FirstRequest, FirstResponse>();
await tcs.Task;
/* Assert */
Assert.Equal(firstContext.GlobalRequestId, secondContext.GlobalRequestId);
}
}
public async Task Should_Be_Able_To_Subscibe_To_Pure_Json_Message()
{
var conventions = new NamingConventions();
using (var client = TestClientFactory.CreateNormal(ioc => ioc.AddSingleton <INamingConventions>(c => conventions)))
{
/* Setup */
var tcs = new TaskCompletionSource <BasicMessage>();
var subscription = client.SubscribeAsync <BasicMessage>((message, context) =>
{
tcs.TrySetResult(message);
return(Task.FromResult(true));
});
var uniqueValue = Guid.NewGuid().ToString();
var jsonMsg = JsonConvert.SerializeObject(new BasicMessage {
Prop = uniqueValue
});
/* Test */
TestChannel.BasicPublish(
conventions.ExchangeNamingConvention(typeof(BasicMessage)),
conventions.QueueNamingConvention(typeof(BasicMessage)),
true,
null,
Encoding.UTF8.GetBytes(jsonMsg));
await tcs.Task;
/* Assert */
Assert.Equal(uniqueValue, tcs.Task.Result.Prop);
}
}
public void Should_Be_Able_To_Delivery_Message_To_Multiple_Subscribers_On_Same_Host()
{
/* Setup */
using (var subscriber = TestClientFactory.CreateNormal())
using (var publisher = TestClientFactory.CreateNormal())
{
var firstTcs = new TaskCompletionSource <bool>();
var secondTcs = new TaskCompletionSource <bool>();
subscriber.SubscribeAsync <BasicMessage>((message, context) =>
{
firstTcs.SetResult(true);
return(Task.FromResult(true));
});
subscriber.SubscribeAsync <BasicMessage>((message, context) =>
{
secondTcs.SetResult(true);
return(Task.FromResult(true));
});
/* Test */
var ackTask = publisher.PublishAsync <BasicMessage>();
Task.WaitAll(ackTask, firstTcs.Task, secondTcs.Task);
/* Assert */
Assert.True(true, "Published and subscribe sucessfull.");
}
}
public async Task Should_Use_Guest_Credentials_By_Default()
{
/* Setup */
/* Test */
var b = TestClientFactory.CreateNormal();
b.Dispose();
/* Assert */
Assert.True(true, "Does not throw.");
}
public async Task Should_Work_For_Rpc()
{
/* Setup */
using (var client = TestClientFactory.CreateNormal(ioc => ioc.AddSingleton <IConfigurationEvaluator, AttributeConfigEvaluator>()))
{
client.RespondAsync <AttributedRequest, AttributedResponse>((message, context) =>
Task.FromResult(new AttributedResponse())
);
/* Test */
await client.RequestAsync <AttributedRequest, AttributedResponse>();
/* Assert */
Assert.True(true, "Routing successful.");
}
}
public async Task Should_Give_Clear_Error_Message_If_User_Does_Not_Exist()
{
/* Setup */
var config = new RawRabbitConfiguration
{
Username = "******",
Password = "******",
Hostnames = { "localhost" },
VirtualHost = "/",
Port = 5672
};
/* Test */
/* Assert */
Assert.ThrowsAny <AuthenticationFailureException>(() => TestClientFactory.CreateNormal(ioc => ioc.AddSingleton(p => config)));
}
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_Nack_Message()
{
/* Setup */
using (var firstResponder = TestClientFactory.CreateNormal <AdvancedMessageContext>())
using (var secondResponder = TestClientFactory.CreateNormal <AdvancedMessageContext>())
using (var requester = TestClientFactory.CreateNormal <AdvancedMessageContext>())
{
var hasBeenNacked = false;
firstResponder.RespondAsync <BasicRequest, BasicResponse>((request, context) =>
{
BasicResponse response = null;
if (!hasBeenNacked)
{
context?.Nack();
hasBeenNacked = true;
}
else
{
response = new BasicResponse();
}
return(Task.FromResult(response));
}, c => c.WithNoAck(false));
secondResponder.RespondAsync <BasicRequest, BasicResponse>((request, context) =>
{
BasicResponse response = null;
if (!hasBeenNacked)
{
context?.Nack();
hasBeenNacked = true;
}
else
{
response = new BasicResponse();
}
return(Task.FromResult(response));
}, c => c.WithNoAck(false));
/* Test */
var result = await requester.RequestAsync <BasicRequest, BasicResponse>(new BasicRequest(), configuration : cfg => cfg
.WithReplyQueue(
q => q.WithName("special_reply_queue")));
/* Assert */
Assert.NotNull(result);
Assert.True(hasBeenNacked);
}
}
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_Successfully_Retry_With_Different_TimeSpans()
{
/* Setup */
using (var subscriber = TestClientFactory.CreateNormal <AdvancedMessageContext>())
using (var publisher = TestClientFactory.CreateNormal <AdvancedMessageContext>())
{
var recived = new List <DateTime>();
var redelivered = new List <DateTime>();
var allRedelivered = new TaskCompletionSource <bool>();
var recievedCount = 0;
subscriber.SubscribeAsync <BasicMessage>((message, context) =>
{
recievedCount++;
if (recievedCount <= 3)
{
recived.Add(DateTime.Now);
context.RetryLater(TimeSpan.FromSeconds(recievedCount));
}
else
{
redelivered.Add(DateTime.Now);
if (redelivered.Count == 3)
{
allRedelivered.SetResult(true);
}
}
return(Task.FromResult(true));
});
/* Test */
await publisher.PublishAsync(new BasicMessage { Prop = "I'm about to be reborn!" });
await publisher.PublishAsync(new BasicMessage { Prop = "I'm about to be reborn!" });
await publisher.PublishAsync(new BasicMessage { Prop = "I'm about to be reborn!" });
await allRedelivered.Task;
/* Assert */
for (var i = 0; i < 3; i++)
{
Assert.Equal(expected: (redelivered[i] - recived[i]).Seconds, actual: i + 1);
}
}
}
public async Task Should_Be_Able_To_Use_Priority()
{
/* Setup */
using (var subscriber = TestClientFactory.CreateNormal())
using (var publisher = TestClientFactory.CreateNormal())
{
var prioritySent = false;
var queueBuilt = new TaskCompletionSource <bool>();
var priorityTcs = new TaskCompletionSource <BasicMessage>();
subscriber.SubscribeAsync <BasicMessage>(async(message, context) =>
{
await queueBuilt.Task;
if (!prioritySent)
{
await subscriber.PublishAsync(new BasicMessage
{
Prop = "I am important!"
}, configuration: cfg => cfg.WithProperties(p =>
{
p.Priority = 3;
}));
prioritySent = true;
}
else
{
priorityTcs.TrySetResult(message);
}
}, cfg => cfg
.WithQueue(q => q.WithArgument(QueueArgument.MaxPriority, 3))
.WithSubscriberId("priority")
.WithPrefetchCount(1));
/* Test */
await publisher.PublishAsync(new BasicMessage { Prop = "I will be delivered" });
await
publisher.PublishAsync(new BasicMessage { Prop = "Someone will pass me in the queue" },
configuration : cfg => cfg.WithProperties(p => p.Priority = 0));
queueBuilt.SetResult(true);
await priorityTcs.Task;
/* Asset */
Assert.Equal(expected: "I am important!", actual: priorityTcs.Task.Result.Prop);
}
}
public async Task Should_Run_Basic_Return_When_The_Manatory_Set_After_Failed_Publish()
{
/* Setup */
using (var client = TestClientFactory.CreateNormal())
{
var tcs = new TaskCompletionSource <bool>();
/* Test */
await client.PublishAsync(new SimpleMessage(),
configuration : cfg => cfg
.WithMandatoryDelivery((obj, evt) =>
{
tcs.SetResult(true);
}));
/* Assert */
Assert.True(tcs.Task.Result);
}
}
public async Task Should_Throw_Exception_To_Requester_If_Responder_Throws_Async()
{
/* Setup */
using (var requester = TestClientFactory.CreateNormal())
using (var responder = TestClientFactory.CreateNormal())
{
responder.RespondAsync <BasicRequest, BasicResponse>((request, context) =>
{
throw new NotSupportedException("I'll throw this");
});
/* Test */
/* Assert */
var e = await Assert.ThrowsAsync <MessageHandlerException>(() => requester.RequestAsync <BasicRequest, BasicResponse>());
Assert.NotNull(e);
}
}
public BulkGetTests()
{
var basicQueueBase = "basicmessage";
var simpleQueueBase = "simplemessage";
var firstSuffix = "first_subscriber";
var secondSuffix = "second_subscriber";
_firstBasicQueue = $"{basicQueueBase}_{firstSuffix}";
_secondBasicQueue = $"{basicQueueBase}_{secondSuffix}";
_firstSimpleQueue = $"{simpleQueueBase}_{firstSuffix}";
using (var subscriber = TestClientFactory.CreateNormal())
{
subscriber.SubscribeAsync <BasicMessage>((message, context) => Task.FromResult(true), cfg => cfg.WithSubscriberId(firstSuffix).WithQueue(q => q.WithAutoDelete(false)));
subscriber.SubscribeAsync <BasicMessage>((message, context) => Task.FromResult(true), cfg => cfg.WithSubscriberId(secondSuffix).WithQueue(q => q.WithAutoDelete(false)));
subscriber.SubscribeAsync <SimpleMessage>((message, context) => Task.FromResult(true), cfg => cfg.WithSubscriberId(firstSuffix).WithQueue(q => q.WithAutoDelete(false)));
}
}