public async Task Given_Noncritical_Message_Not_Acknowledged_When_Sending_Then_MessageNotAcknowledgedException()
{
await With.HttpHostedBusInstances(async (platibus0, platibus1) =>
{
var message = new TestMessage
{
GuidData = Guid.NewGuid(),
IntData = RNG.Next(0, int.MaxValue),
StringData = "Hello, world!",
DateData = DateTime.UtcNow,
SimulateAcknowledgementFailure = true
};
Exception exception = null;
try
{
await platibus0.Send(message, new SendOptions
{
Importance = MessageImportance.Low
});
}
catch (Exception ex)
{
exception = ex;
}
Assert.That(exception, Is.Not.Null);
Assert.That(exception, Is.InstanceOf<MessageNotAcknowledgedException>());
});
}
public static async Task HandleMessage(TestMessage message, IMessageContext messageContext,
CancellationToken cancellationToken)
{
if (message.SimulateAuthorizationFailure)
{
throw new UnauthorizedAccessException();
}
await messageContext.SendReply(new TestReply
{
GuidData = message.GuidData,
IntData = message.IntData,
StringData = message.StringData,
DateData = message.DateData
}, cancellationToken: cancellationToken);
if (message.SimulateAcknowledgementFailure)
{
return;
}
messageContext.Acknowledge();
}
protected virtual async Task <SendResult> SendMessageAndAwaitReply(int i, CancellationToken ct, SendOptions options = null)
{
var message = new TestMessage
{
DateData = DateTime.UtcNow,
GuidData = Guid.NewGuid(),
IntData = i,
StringData = "TestMessage_" + i
};
try
{
var sentMessage = await Sender.Send(message, options, ct);
var reply = await sentMessage.GetReply(ct);
return(new SendResult(message, reply, null));
}
catch (Exception ex)
{
return(new SendResult(message, null, ex));
}
}
public async Task Given_Message_When_Sending_Then_Reply_Should_Be_Observed()
{
await With.RabbitMQHostedBusInstances(async (platibus0, platibus1) =>
{
var replyReceivedEvent = new ManualResetEvent(false);
var repliesCompletedEvent = new ManualResetEvent(false);
var replies = new ConcurrentQueue<object>();
var message = new TestMessage
{
GuidData = Guid.NewGuid(),
IntData = RNG.Next(0, int.MaxValue),
StringData = "Hello, world!",
DateData = DateTime.UtcNow
};
var sentMessage = await platibus0.Send(message);
var subscription = sentMessage
.ObserveReplies()
.Subscribe(r =>
{
replies.Enqueue(r);
replyReceivedEvent.Set();
}, () => repliesCompletedEvent.Set());
var replyReceived = await replyReceivedEvent.WaitOneAsync(TimeSpan.FromSeconds(30));
var repliesCompleted = await repliesCompletedEvent.WaitOneAsync(TimeSpan.FromSeconds(30));
subscription.Dispose();
Assert.That(replyReceived, Is.True);
Assert.That(repliesCompleted, Is.True);
Assert.That(replies.Count, Is.EqualTo(1));
var reply = replies.First();
Assert.That(reply, Is.InstanceOf<TestReply>());
});
}
public SendResult(TestMessage message, object reply, Exception exception)
{
Message = message;
Reply = reply;
Exception = exception;
}
private static async Task<TimeSpan> RunTest(int messageCount, bool durable = false)
{
return await With.HttpHostedBusInstances(async (platibus0, platibus1) =>
{
var sw = Stopwatch.StartNew();
var sendOptions = new SendOptions
{
Importance = durable ? MessageImportance.Critical : MessageImportance.Low
};
var repliesReceieved = Enumerable.Range(0, messageCount)
.Select(async i =>
{
var message = new TestMessage {IntData = i};
var sentMessage = await platibus0.Send(message, sendOptions);
return await sentMessage.GetReply();
});
var replies = await Task.WhenAll(repliesReceieved);
sw.Stop();
Console.WriteLine("{0} messages sent and replies received in {1}", messageCount, sw.Elapsed);
return sw.Elapsed;
});
}
