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);