public async Task Should_Be_Able_To_Recieve_Different_Types_Of_Messages() { /* Setup */ var publisher = BusClientFactory.CreateDefault(); var subscriber = BusClientFactory.CreateDefault(); var basicMsg = new BasicMessage {Prop = "Hello, world!"}; var simpleMsg = new SimpleMessage {IsSimple = true}; var basicMsgTcs = new TaskCompletionSource<BasicMessage>(); var simpleMsgTcs = new TaskCompletionSource<SimpleMessage>(); subscriber.SubscribeAsync<BasicMessage>((msg, i) => { basicMsgTcs.SetResult(msg); return basicMsgTcs.Task; }); subscriber.SubscribeAsync<SimpleMessage>((msg, i) => { simpleMsgTcs.SetResult(msg); return basicMsgTcs.Task; }); /* Test */ publisher.PublishAsync(basicMsg); publisher.PublishAsync(simpleMsg); Task.WaitAll(basicMsgTcs.Task, simpleMsgTcs.Task); /* Assert */ Assert.Equal(basicMsgTcs.Task.Result.Prop, basicMsg.Prop); Assert.Equal(simpleMsgTcs.Task.Result.IsSimple, simpleMsg.IsSimple); }
public async Task Should_Support_The_Hello_World_Tutorial() { /* Setup */ using (var sender = TestClientFactory.CreateNormal()) using (var reciever = TestClientFactory.CreateNormal()) { var sent = new BasicMessage { Prop = "Hello, world!" }; var recieved = new TaskCompletionSource<BasicMessage>(); reciever.SubscribeAsync<BasicMessage>((message, info) => { recieved.SetResult(message); return Task.FromResult(true); }, configuration => configuration .WithQueue(queue => queue .WithName("hello") .WithExclusivity(false) .WithAutoDelete(false) ) .WithRoutingKey("hello") ); /* Test */ await sender.PublishAsync(sent, configuration: builder => builder .WithRoutingKey("hello") ); await recieved.Task; /* Assert */ Assert.Equal(expected: sent.Prop, actual: recieved.Task.Result.Prop); } }
public async Task Should_Be_Able_To_Subscribe_Without_Any_Additional_Config() { /* Setup */ using (var publisher = TestClientFactory.CreateNormal()) using (var subscriber = TestClientFactory.CreateNormal()) { var message = new BasicMessage {Prop = "Hello, world!"}; var recievedTcs = new TaskCompletionSource<BasicMessage>(); subscriber.SubscribeAsync<BasicMessage>((msg, info) => { if (msg.Prop == message.Prop) { recievedTcs.SetResult(msg); } return Task.FromResult(true); }); /* Test */ publisher.PublishAsync(message); await recievedTcs.Task; /* Assert */ Assert.Equal(expected: message.Prop, actual: recievedTcs.Task.Result.Prop); } }
public async Task Should_Support_The_Worker_Queues_Tutorial() { /* Setup */ var sent = new BasicMessage { Prop = "Hello, world!" }; var recieved = new TaskCompletionSource<BasicMessage>(); var sender = BusClientFactory.CreateDefault(); var reciever = BusClientFactory.CreateDefault(); reciever.SubscribeAsync<BasicMessage>((message, info) => { recieved.SetResult(message); return Task.FromResult(true); }, configuration => configuration .WithPrefetchCount(1) .WithQueue(queue => queue .WithName("task_queue") .WithDurability() ) .WithRoutingKey("task_queue") ); /* Test */ await sender.PublishAsync(sent, configuration: builder => builder .WithRoutingKey("task_queue") ); await recieved.Task; /* Assert */ Assert.Equal(sent.Prop, recieved.Task.Result.Prop); }
public async Task Should_Be_Able_To_Bulk_Get_Messages() { var firstBasicMsg = new BasicMessage { Prop = "This is the first message" }; var secondBasicMsg = new BasicMessage { Prop = "This is the second message" }; var thridBasicMsg = new BasicMessage { Prop = "This is the thrid message" }; var firstSimpleMsg = new SimpleMessage { IsSimple = true }; using (var client = TestClientFactory.CreateExtendable()) { await client.PublishAsync(secondBasicMsg); await client.PublishAsync(firstBasicMsg); await client.PublishAsync(thridBasicMsg); await client.PublishAsync(firstSimpleMsg); await Task.Delay(500); var bulk = client.GetMessages(cfg => cfg .ForMessage<BasicMessage>(msg => msg .FromQueues(_firstBasicQueue, _secondBasicQueue) .WithBatchSize(4)) .ForMessage<SimpleMessage>(msg => msg .FromQueues(_firstSimpleQueue) .GetAll() .WithNoAck() )); var basics = bulk.GetMessages<BasicMessage>().ToList(); var simple = bulk.GetMessages<SimpleMessage>().ToList(); bulk.AckAll(); Assert.Equal(expected: 4, actual: basics.Count); Assert.Equal(expected: 1, actual: simple.Count); } }
public void Should_Be_Able_To_Bulk_Get_Messages() { var firstBasicMsg = new BasicMessage { Prop = "This is the first message" }; var secondBasicMsg = new BasicMessage { Prop = "This is the second message" }; var thridBasicMsg = new BasicMessage { Prop = "This is the thrid message" }; var firstSimpleMsg = new SimpleMessage { IsSimple = true }; var client = RawRabbitFactory.GetExtendableClient() as ExtendableBusClient<MessageContext>; client.PublishAsync(secondBasicMsg); client.PublishAsync(firstBasicMsg); client.PublishAsync(thridBasicMsg); client.PublishAsync(firstSimpleMsg); var bulk = client.GetMessages(cfg => cfg .ForMessage<BasicMessage>(msg => msg .FromQueues(_firstBasicQueue, _secondBasicQueue) .WithBatchSize(4)) .ForMessage<SimpleMessage>(msg => msg .FromQueues(_firstSimpleQueue) .GetAll() .WithNoAck() )); var basics = bulk.GetMessages<BasicMessage>().ToList(); var simple = bulk.GetMessages<SimpleMessage>().ToList(); bulk.AckAll(); Assert.Equal(basics.Count, 4); Assert.Equal(simple.Count, 1); }
public async Task Should_Be_Able_To_Subscribe_Without_Any_Additional_Config() { /* Setup */ var message = new BasicMessage { Prop = "Hello, world!" }; var recievedTcs = new TaskCompletionSource<BasicMessage>(); var publisher = BusClientFactory.CreateDefault(); var subscriber = BusClientFactory.CreateDefault(); subscriber.SubscribeAsync<BasicMessage>((msg, info) => { recievedTcs.SetResult(msg); return recievedTcs.Task; }); /* Test */ publisher.PublishAsync(message); await recievedTcs.Task; /* Assert */ Assert.Equal(recievedTcs.Task.Result.Prop, message.Prop); }
public async Task Should_Publish_Message_On_Error_Exchange_If_Subscribe_Throws_Exception() { /* Setup */ var conventions = new NamingConventions(); var client = BusClientFactory.CreateDefault(null, ioc => ioc.AddSingleton(c => conventions)); var recieveTcs = new TaskCompletionSource<HandlerExceptionMessage>(); MessageContext firstRecieved = null; MessageContext secondRecieved = null; client.SubscribeAsync<HandlerExceptionMessage>((message, context) => { secondRecieved = context; recieveTcs.TrySetResult(message); return Task.FromResult(true); }, c => c .WithExchange(e => e.WithName(conventions.ErrorExchangeNamingConvention())) .WithQueue(q => q.WithArgument(QueueArgument.MessageTtl, (int)TimeSpan.FromSeconds(1).TotalMilliseconds)) .WithRoutingKey("#")); client.SubscribeAsync<BasicMessage>((message, context) => { firstRecieved = context; throw new Exception("Oh oh!"); }); var originalMsg = new BasicMessage { Prop = "Hello, world" }; /* Test */ client.PublishAsync(originalMsg); await recieveTcs.Task; /* Assert */ Assert.Equal(((BasicMessage)recieveTcs.Task.Result.Message).Prop, originalMsg.Prop); Assert.NotNull(firstRecieved); Assert.NotNull(secondRecieved); Assert.Equal(firstRecieved.GlobalRequestId, secondRecieved.GlobalRequestId); }
public async Task Should_Stop_Subscribe_When_Subscription_Is_Disposed() { /* Setup */ var publisher = BusClientFactory.CreateDefault(); var subscriber = BusClientFactory.CreateDefault(); var firstMessage = new BasicMessage {Prop = "Value"}; var secondMessage = new BasicMessage {Prop = "AnotherValue"}; var firstRecievedTcs = new TaskCompletionSource<BasicMessage>(); var secondRecievedTcs = new TaskCompletionSource<BasicMessage>(); var recievedCount = 0; var subscription = subscriber.SubscribeAsync<BasicMessage>((message, context) => { recievedCount++; firstRecievedTcs.SetResult(message); return Task.FromResult(true); }); /* Test */ await publisher.PublishAsync(firstMessage); await firstRecievedTcs.Task; subscription.Dispose(); var recievedAfterFirstPublish = recievedCount; await publisher.PublishAsync(secondMessage); await Task.Delay(20); publisher.SubscribeAsync<BasicMessage>((message, context) => { secondRecievedTcs.SetResult(message); return Task.FromResult(true); }); await secondRecievedTcs.Task; /* Assert */ Assert.Equal(recievedAfterFirstPublish, recievedCount); Assert.Equal(firstRecievedTcs.Task.Result.Prop, firstMessage.Prop); Assert.Equal(secondRecievedTcs.Task.Result.Prop, secondMessage.Prop); }
public async Task Should_Stop_Subscribe_When_Subscription_Is_Disposed() { /* Setup */ using (var publisher = TestClientFactory.CreateNormal()) using (var subscriber = TestClientFactory.CreateNormal()) { var firstMessage = new BasicMessage {Prop = "Value"}; var secondMessage = new BasicMessage {Prop = "AnotherValue"}; var firstRecievedTcs = new TaskCompletionSource<BasicMessage>(); var secondRecievedTcs = new TaskCompletionSource<BasicMessage>(); var recievedCount = 0; var subscription = subscriber.SubscribeAsync<BasicMessage>((message, context) => { recievedCount++; if (!firstRecievedTcs.Task.IsCompleted) { firstRecievedTcs.SetResult(message); } return Task.FromResult(true); }, cfg => cfg.WithQueue(q => q.WithAutoDelete(false))); /* Test */ publisher.PublishAsync(firstMessage); await firstRecievedTcs.Task; subscription.Dispose(); var recievedAfterFirstPublish = recievedCount; publisher.PublishAsync(secondMessage); await Task.Delay(20); publisher.SubscribeAsync<BasicMessage>((message, context) => { secondRecievedTcs.SetResult(message); return Task.FromResult(true); }, cfg => cfg.WithQueue(q => q.WithAutoDelete(false))); await secondRecievedTcs.Task; TestChannel.QueueDelete(subscription.QueueName); /* Assert */ Assert.Equal(recievedAfterFirstPublish, recievedCount); Assert.Equal(firstRecievedTcs.Task.Result.Prop, firstMessage.Prop); Assert.Equal(secondRecievedTcs.Task.Result.Prop, secondMessage.Prop); } }