public async Task Should_Use_Routing_Key_Transformer_If_Present() { /* Setup */ using (var legacyClient = TestClientFactory.CreateExtendable(ioc => ioc.AddSingleton(s => RawRabbitConfiguration.Local.AsLegacy()))) using (var currentClient = TestClientFactory.CreateExtendable()) { var legacyTcs = new TaskCompletionSource <BasicMessage>(); var currentTcs = new TaskCompletionSource <BasicMessage>(); currentClient.SubscribeAsync <BasicMessage>((message, context) => { if (!currentTcs.Task.IsCompleted) { currentTcs.SetResult(message); return(currentTcs.Task); } if (!legacyTcs.Task.IsCompleted) { legacyTcs.SetResult(message); return(legacyTcs.Task); } return(Task.FromResult(true)); }); /* Test */ // 1. Verify subscriber currentClient.PublishAsync <BasicMessage>(); await currentTcs.Task; // 2. Change Type await currentClient.UpdateTopologyAsync(c => c .ExchangeForMessage <BasicMessage>() .UseConfiguration( exchange => exchange.WithType(ExchangeType.Direct), bindingKey => bindingKey.Replace(".#", string.Empty)) ); // 3. Verify subscriber legacyClient.PublishAsync <BasicMessage>(); await legacyTcs.Task; /* Assert */ Assert.True(true); } }
public async Task Should_Honor_Timeout() { /* Setup */ var cfg = RawRabbitConfiguration.Local; cfg.RequestTimeout = TimeSpan.FromMilliseconds(200); using (var client = TestClientFactory.CreateExtendable(ioc => ioc.AddSingleton(c => cfg))) { /* Test */ var chain = client.ExecuteSequence(c => c .PublishAsync <FirstMessage>() .Complete <SecondMessage>() ); /* Assert */ await Assert.ThrowsAsync <TimeoutException>(async() => await chain.Task); } }
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 async Task Should_Not_Interupt_Existing_Subscribers_When_Using_Custom_Config() { /* Setup */ var cfg = RawRabbitConfiguration.Local.AsLegacy(); using (var client = TestClientFactory.CreateExtendable(ioc => ioc.AddSingleton(s => cfg))) { var firstTcs = new TaskCompletionSource <BasicMessage>(); var secondTcs = new TaskCompletionSource <BasicMessage>(); client.SubscribeAsync <BasicMessage>((message, context) => { if (!firstTcs.Task.IsCompleted) { firstTcs.SetResult(message); return(firstTcs.Task); } if (!secondTcs.Task.IsCompleted) { secondTcs.SetResult(message); return(secondTcs.Task); } return(Task.FromResult(true)); }); /* Test */ // 1. Verify subscriber client.PublishAsync <BasicMessage>(); await firstTcs.Task; // 2. Change Type await client.UpdateTopologyAsync(c => c .ExchangeForMessage <BasicMessage>() .UseConfiguration(e => e.WithType(ExchangeType.Topic))); // 3. Verify subscriber client.PublishAsync <BasicMessage>(); await secondTcs.Task; /* Assert */ Assert.True(true, "First and second message was delivered."); } }
public async Task Should_Honor_Last_Configuration() { /* Setup */ using (var client = TestClientFactory.CreateExtendable()) { const string exchangeName = "topology"; TestChannel.ExchangeDelete(exchangeName); /* Test */ var result = await client.UpdateTopologyAsync(c => c .ForExchange(exchangeName) .UseConfiguration(e => e.WithType(ExchangeType.Headers)) .ForExchange(exchangeName) .UseConfiguration(e => e.WithType(ExchangeType.Topic)) .ForExchange(exchangeName) .UseConfiguration(e => e.WithType(ExchangeType.Direct)) .ForExchange(exchangeName) .UseConfiguration(e => e.WithType(ExchangeType.Fanout))); /* Assert */ Assert.Equal(result.Exchanges[0].Exchange.ExchangeType, ExchangeType.Fanout.ToString().ToLower()); } }
public async Task Should_Call_Message_Handler_In_Correct_Order() { /* Setup */ using (var publisher = TestClientFactory.CreateExtendable()) { publisher.SubscribeAsync <FirstMessage>((message, context) => publisher.PublishAsync(new SecondMessage(), context.GlobalRequestId)); publisher.SubscribeAsync <SecondMessage>((message, context) => publisher.PublishAsync(new ThirdMessage(), context.GlobalRequestId)); publisher.SubscribeAsync <ThirdMessage>((message, context) => publisher.PublishAsync(new ForthMessage(), context.GlobalRequestId)); var recieveIndex = 0; var secondMsgDate = DateTime.MinValue; var thirdMsgDate = DateTime.MinValue; /* Test */ var chain = _client.ExecuteSequence(c => c .PublishAsync(new FirstMessage()) .When <SecondMessage>((message, context) => { secondMsgDate = DateTime.Now; return(Task.FromResult(true)); }) .When <ThirdMessage>((message, context) => { thirdMsgDate = DateTime.Now; return(Task.FromResult(true)); }) .Complete <ForthMessage>() ); await chain.Task; /* Assert */ Assert.True(secondMsgDate < thirdMsgDate); } }
public async Task Should_Update_Exhange_Type() { /* Setup */ const string exchangeName = "topology"; TestChannel.ExchangeDelete(exchangeName); TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Direct); using (var client = TestClientFactory.CreateExtendable()) { /* Test */ await client.UpdateTopologyAsync(t => t .ForExchange(exchangeName) .UseConfiguration(e => e .WithType(ExchangeType.Topic) .WithDurability(false)) ); /* Assert */ TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Topic); Assert.True(true, "Did not throw"); Assert.Throws <OperationInterruptedException>(() => TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Direct)); } }
public MessageSequenceTests() { _client = TestClientFactory.CreateExtendable(); }