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