public async Task GetReturnsOperationResultFailIfNoMessages()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var opResult = await bunny.Consumer <ConsumeMessage>(get).AsAutoAck().GetAsync(carrot => Task.CompletedTask);
Assert.NotNull(opResult);
Assert.Equal(OperationState.GetFailed, opResult.State);
}
private async Task <IBunny> ConsumeGeneric(Func <ICarrot <ConsumeMessage>, Task> carrot, string toQueue = queue)
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var consumer = bunny.Consumer <ConsumeMessage>(toQueue).Callback(carrot);
var operationResult = await consumer.StartConsumingAsync();
Assert.True(operationResult.IsSuccess);
Assert.Equal(OperationState.ConsumerAttached, operationResult.State);
SetupAndPublish(bunny, toQueue);
return(bunny);
}
public async Task GetSucceedsIfMessageIsAvailable()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var msg = new ConsumeMessage();
var bytes = Config.Serialize(msg);
bunny.Channel(newOne: true).BasicPublish("", get, false, null, bytes);
var opResult = await bunny.Consumer <ConsumeMessage>(get).AsAutoAck().GetAsync(carrot => Task.CompletedTask);
Assert.NotNull(opResult);
Assert.Equal(OperationState.Get, opResult.State);
Assert.NotNull(opResult.Message.MyText);
}
public async Task <OperationResult <TResponse> > StartRespondingAsync()
{
var result = new OperationResult <TResponse>();
var publisher = _bunny.Publisher <TResponse>(DEFAULT_EXCHANGE)
.WithSerialize(_serialize);
publisher.UseUniqueChannel(uniqueChannel: _useUniqueChannel);
Func <ICarrot <TRequest>, Task> _receiver = async carrot =>
{
var request = carrot.Message;
try
{
TResponse response = await _respond(request);
string reply_to = carrot.MessageProperties.ReplyTo;
publisher.WithRoutingKey(reply_to);
result = await publisher.SendAsync(response);
}
catch (System.Exception ex)
{
result.IsSuccess = false;
result.State = OperationState.RpcReplyFailed;
result.Error = ex;
}
};
// consume
IQueue forceDeclare = _bunny.Setup()
.Queue(_consumeFromQueue)
.AsDurable()
.Bind(_rpcExchange, _consumeFromQueue);
var consumeResult = await _bunny.Consumer <TRequest>(_consumeFromQueue)
.DeserializeMessage(_deserialize)
.Callback(_receiver)
.StartConsumingAsync(forceDeclare);
if (consumeResult.IsSuccess)
{
result.IsSuccess = true;
result.State = OperationState.Response;
}
else
{
result.IsSuccess = false;
result.Error = consumeResult.Error;
result.State = consumeResult.State;
}
return(result);
}
public void NackRequeues()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var consumer = bunny.Consumer <ConsumeMessage>(queue).Callback(async carrot =>
{
var result = await carrot.SendNackAsync(withRequeue: true);
Assert.Equal(OperationState.Nacked, result.State);
uint count = bunny.Channel().MessageCount(nackReQueue);
Assert.Equal((uint)1, count);
});
SetupAndPublish(bunny, nackReQueue);
}
public async Task StartConsumingAsyncWithForceDeclaresTheQueue()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var before = await bunny.Setup().QueueExistsAsync("force-declared");
var queue = bunny.Setup().Queue("force-declared");
var consumer = await bunny.Consumer <ConsumeMessage>()
.StartConsumingAsync(queue);
var after = await bunny.Setup().QueueExistsAsync("force-declared");
Assert.False(before);
Assert.True(after);
var deleted = await bunny.Setup().DeleteQueueAsync("force-declared", force: true);
Assert.True(deleted);
}
public async Task MultipleCallToConsumeAlwaysReturnUccess()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
ConsumeMessage result = null;
var consumer = bunny.Consumer <ConsumeMessage>(queue).Callback(async carrot =>
{
result = carrot.Message;
var opResult = await carrot.SendAckAsync();
Assert.True(opResult.IsSuccess);
Assert.NotNull(result);
Assert.Equal(nameof(ConsumeMessage), result.MyText);
});
var result1 = await consumer.StartConsumingAsync();
var result2 = await consumer.StartConsumingAsync();
var result3 = await consumer.StartConsumingAsync();
Assert.Equal(result1, result2, new EqualityOpResult());
Assert.Equal(result1, result3, new EqualityOpResult());
Assert.Equal(result2, result2, new EqualityOpResult());
}
