public async Task ConfirmsAndAcksWork()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
IQueue queue = bunny.Setup()
.Queue("constraint")
.MaxLength(1)
.QueueExpiry(1500)
.Bind("amq.direct", "constraint-key")
.OverflowReject();
bool isNacked = false;
bool isAcked = false;
var publisher = bunny.Publisher <TestMessage>("amq.direct");
Func <BasicNackEventArgs, Task> nacker = ea => { isNacked = true; return(Task.CompletedTask); };
Func <BasicAckEventArgs, Task> acker = ea => { isAcked = true; return(Task.CompletedTask); };
await publisher.WithQueueDeclare(queue)
.WithConfirm(acker, nacker)
.WithRoutingKey("constraint-key")
.SendAsync(new TestMessage()
{
Text = "Confirm-1st"
});
await publisher.WithQueueDeclare(queue)
.WithConfirm(acker, nacker)
.SendAsync(new TestMessage()
{
Text = "Confirm-2nd"
});
Assert.True(isAcked);
Assert.True(isNacked);
bunny.Dispose();
}
public async Task PublisherSimplySendsWithoutQueueReturnsFailure()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
IPublish <TestMessage> publisher = bunny.Publisher <TestMessage>(Exchange);
OperationResult <TestMessage> result = await publisher.SendAsync(new TestMessage());
Assert.True(result.IsSuccess);
bunny.Dispose();
}
public async Task ForceCreatesTheExchangeIfNotExists()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
IPublish <TestMessage> publisher = bunny.Publisher <TestMessage>("test-exchange");
OperationResult <TestMessage> result = await publisher.SendAsync(new TestMessage(), force : true);
Assert.True(result.IsSuccess);
bool removed_exchange = await bunny.Setup().DeleteExchangeAsync("test-exchange", force: true);
Assert.True(removed_exchange);
bunny.Dispose();
}
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 async Task PublisherSimplySendsWitQueueReturnsSuccess()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
IPublish <TestMessage> publisher = bunny.Publisher <TestMessage>(Exchange);
OperationResult <TestMessage> result = await publisher
.WithQueueDeclare()
.SendAsync(new TestMessage());
bool success = await bunny.Setup().DeleteQueueAsync(typeof(TestMessage).FullName, force: true);
Assert.True(result.IsSuccess);
Assert.True(success);
bunny.Dispose();
}
public async Task MandatoryFailsWithoutQueue()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
bool isReturned = false;
var publisher = bunny.Publisher <TestMessage>("amq.direct");
Func <BasicReturnEventArgs, Task> nacker = ea => { isReturned = true; return(Task.CompletedTask); };
await publisher.AsMandatory(nacker)
.WithRoutingKey("not-any-bound-queue")
.SendAsync(new TestMessage());
await Task.Delay(500);
Assert.True(isReturned);
bunny.Dispose();
}
public async Task MultiplePublishOnSinglePublisher()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var publisher = bunny.Publisher <TestMessage>("amq.direct");
string queueName = "polymorph-queue";
await publisher.WithQueueDeclare(queueName, "poly")
.SendAsync(new OtherMessage());
await publisher.SendAsync(new YetAnotherMessage());
await Task.Delay(150);
uint count = bunny.Channel().MessageCount(queueName);
Assert.Equal(2, (int)count);
await bunny.Setup().DeleteQueueAsync(queueName, force: true);
}
public async Task MandatoryWorksWithQueue()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
bool isReturned = true;
var publisher = bunny.Publisher <TestMessage>("amq.direct");
Func <BasicReturnEventArgs, Task> nacker = ea => { isReturned = false; return(Task.CompletedTask); };
await publisher.AsMandatory(nacker)
.WithQueueDeclare()
.SendAsync(new TestMessage()
{
Text = "Mandatory-succeeds"
});
bool removed = await bunny.Setup().DeleteQueueAsync(typeof(TestMessage).FullName, force: true);
Assert.True(isReturned);
bunny.Dispose();
}
public async Task OverWriteRoutingKeySendsToDifferentQueuesEachTime()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var publisher = bunny.Publisher <TestMessage>("amq.direct");
string queueName = "polymorph-queue-other";
string queueNameYetOther = "polymorph-queue-yet-another";
await publisher.WithQueueDeclare(queueName, "poly")
.SendAsync(new OtherMessage());
await publisher.WithQueueDeclare(queueNameYetOther, "poly-2")
.WithRoutingKey("poly-2")
.SendAsync(new YetAnotherMessage());
uint otherCount = bunny.Channel().MessageCount(queueName);
uint yetOtherCount = bunny.Channel().MessageCount(queueNameYetOther);
Assert.Equal(1, (int)otherCount);
Assert.Equal(1, (int)yetOtherCount);
await bunny.Setup().DeleteQueueAsync(queueName, force: true);
await bunny.Setup().DeleteQueueAsync(queueNameYetOther, force: true);
}
