public async Task Should_Clean_Everything() { /* Setup */ var connectionFactory = new ConnectionFactory { HostName = "localhost", UserName = "******", Password = "******" }; var connection = connectionFactory.CreateConnection(); var channel = connection.CreateModel(); channel.QueueDeclare("my_queue", true, false, false, null); channel.ExchangeDeclare("my_exchange", ExchangeType.Direct, true); var client = RawRabbitFactory.Create(); /* Test */ await client.CleanAsync(cfg => cfg .RemoveQueues() .RemoveExchanges() ); /* Assert */ Assert.True(true, "Needs to be fixed."); }
public MessageSequenceTests() { _client = RawRabbitFactory.Create(); TestChannel.QueueDelete("basicrequest_dnx"); TestChannel.QueueDelete("firstmessage_dnx"); TestChannel.QueueDelete("secondmessage_dnx"); TestChannel.QueueDelete("thirdmessage_dnx"); }
public async Task Should_Honor_Timeout() { /* Setup */ var cfg = RawRabbitConfiguration.Local; cfg.RequestTimeout = TimeSpan.FromMilliseconds(200); var client = RawRabbitFactory.Create(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_Use_Routing_Key_Transformer_If_Present() { /* Setup */ var legacyClient = RawRabbitFactory.Create(ioc => ioc.AddSingleton(s => RawRabbitConfiguration.Local.AsLegacy())); var currentClient = RawRabbitFactory.Create(); 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_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.Create(); await client.PublishAsync(secondBasicMsg); await client.PublishAsync(firstBasicMsg); await client.PublishAsync(thridBasicMsg); await 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(expected: 4, actual: basics.Count); Assert.Equal(expected: 1, actual: simple.Count); }
public async Task Should_Not_Interupt_Existing_Subscribers_When_Using_Conventions() { /* Setup */ var cfg = RawRabbitConfiguration.Local.AsLegacy(); var client = RawRabbitFactory.Create(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 .UseConventionForExchange <BasicMessage>() ); // 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 */ var client = RawRabbitFactory.Create(); 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_Update_Exhange_Type() { /* Setup */ const string exchangeName = "topology"; TestChannel.ExchangeDelete(exchangeName); TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Direct); var client = RawRabbitFactory.Create(); /* 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 static RawRabbit.Extensions.Disposable.IBusClient CreateExtendable(Action <IServiceCollection> custom = null) { custom = AddTestConfig(custom); return(RawRabbitFactory.Create(custom)); }
public MailingService(ILogger logger, IMailService mailer) { _logger = logger; _mailer = mailer; client = RawRabbitFactory.Create(); }