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 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);
}
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();
}
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 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 DeclareAndBindDefaultAmqDirectSucceeds()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var declare = bunny.Setup()
.Queue("bind-test")
.Bind("amq.direct", "bind-test-key")
.AsDurable()
.QueueExpiry(1500)
.WithTTL(500)
.MaxLength(10);
await declare.DeclareAsync();
Assert.Equal(1, 1);
}
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 DeclareAndDeleteQueueNotExistsAfterWards()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
IQueue declare = bunny.Setup()
.Queue("to-delete");
await declare.DeclareAsync();
bool exists = await declare.QueueExistsAsync(declare.Name);
Assert.True(exists);
await declare.DeleteQueueAsync(declare.Name);
exists = await declare.QueueExistsAsync(declare.Name);
Assert.False(exists);
}
public async Task DeclareAndDeleteExchangeNotExistsAfterWards()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
IExchange declare = bunny.Setup()
.Exchange("to-delete-ex", "fanout");
await declare.DeclareAsync();
bool exists = await declare.ExchangeExistsAsync(declare.Name);
Assert.True(exists);
await declare.DeleteExchangeAsync(declare.Name);
exists = await declare.ExchangeExistsAsync(declare.Name);
Assert.False(exists);
}
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 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 WithTemporaryQueueWorksAlso()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
string rpcExchange = "rpc-exchange";
await bunny.Respond <MyRequest, MyResponse>(rpcExchange, rq =>
{
return(Task.FromResult(new MyResponse()));
})
.StartRespondingAsync();
OperationResult <MyResponse> result = await bunny.Request <MyRequest, MyResponse>(rpcExchange)
.RequestAsync(new MyRequest(), force: true);
await Task.Delay(500);
Assert.True(result.IsSuccess);
Assert.NotNull(result.Message);
}
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 IBunny Connect()
{
if (string.IsNullOrWhiteSpace(_user))
{
AuthenticatePlain();
}
if (string.IsNullOrWhiteSpace(_host))
{
_host = "localhost";
}
if (string.IsNullOrWhiteSpace(_vHost))
{
ToVirtualHost();
}
if (_port == 0)
{
ToPort();
}
return(Bunny.ConnectSingle(this.ToString("amqp", null)));
}
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());
}
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);
}
public void ConnectToSingleNodeViaAmqp()
{
IBunny bunny = Bunny.ConnectSingle(BasicAmqp);
Assert.NotNull(bunny);
}
internal static IBunny Connect() => Bunny.ConnectSingle(BasicAmqp);
