protected void SetupQueueAndSenderAndListener(string connectionString)
{
connectionManager = SetupRabbitMqConnectionManager(connectionString);
EnsureRabbitQueueExists(QueueName);
SetupMessageSender();
SetupQueueListener(QueueName);
}
public void Stop_WhenConnectionCloseRaisesNonEndOfStreamException_DoesBubbleException()
{
var dateTimeProvider = new Mock <IDateTimeProvider>();
var logger = new Mock <ILogger>();
var configurationManager = new Mock <IConfigurationManager>();
configurationManager.Setup(x => x.Get <string>("QueueUri")).Returns("amqp://*****:*****@localhost:5672");
var model = new Mock <IModel>();
var connection = new Mock <IConnection>();
connection.Setup(x => x.CreateModel()).Returns(model.Object);
connection.Setup(x => x.Dispose()).Throws <Exception>();
var connectionFactory = new Mock <IConnectionFactory>();
connectionFactory.Setup(x => x.Uri).Returns(new Uri("amqp://*****:*****@localhost:5672"));
connectionFactory.Setup(x => x.CreateConnection()).Returns(connection.Object);
var rabbitMqConnectionManager = new RabbitMqConnectionManager(connectionFactory.Object, configurationManager.Object);
var rabbitMqWrapper = new RabbitMqWrapper(dateTimeProvider.Object, logger.Object, configurationManager.Object, rabbitMqConnectionManager, _metrics);
rabbitMqWrapper.Start();
rabbitMqWrapper.Stop();
rabbitMqConnectionManager.Dispose();
}
public void Stop_WhenCalledAfterStart_CallsModelDispose()
{
var dateTimeProvider = new Mock <IDateTimeProvider>();
var logger = new Mock <ILogger>();
var configurationManager = new Mock <IConfigurationManager>();
configurationManager.Setup(x => x.Get <string>("QueueUri")).Returns("amqp://*****:*****@localhost:5672");
var model = new Mock <IModel>();
var connection = new Mock <IConnection>();
connection.Setup(x => x.CreateModel()).Returns(model.Object);
var connectionFactory = new Mock <IConnectionFactory>();
connectionFactory.Setup(x => x.Uri).Returns(new Uri("amqp://*****:*****@localhost:5672"));
connectionFactory.Setup(x => x.CreateConnection()).Returns(connection.Object);
var mqConnectionManager = new RabbitMqConnectionManager(connectionFactory.Object, configurationManager.Object);
var rabbitMqWrapper = new RabbitMqWrapper(dateTimeProvider.Object, logger.Object, configurationManager.Object, mqConnectionManager, _metrics);
rabbitMqWrapper.Start();
rabbitMqWrapper.Stop();
model.Verify(x => x.Dispose(), Times.Once);
}
public static async Task Main()
{
var rabbitMqConnectionManager = new RabbitMqConnectionManager(new Uri("amqp://localhost"), "test", TimeSpan.FromSeconds(30));
const string queueName = "some-queue-name";
var options = new RabbitMqServiceOptionsBuilder()
.WithRetry(TimeSpan.FromSeconds(15), null, TimeSpan.FromSeconds(1))
.WithDeliveryMode(DeliveryMode.Persistent)
.WithConnectionManager(rabbitMqConnectionManager)
.WithDefaultSerializer(message => Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)), "application/json")
.Build();
var serviceClient = new RabbitMqServiceClient(options);
// Create a queue
await serviceClient.CreateQueueAsync(queueName + "-Error", true);
// Create a queue with options builder
var createQueueOption = new CreateQueueOptionsBuilder(QueueType.Classic)
.Durable()
.WithDeadLetterExchange(RabbitMqConstants.DefaultExchangeName)
.WithDeadLetterRoutingKey(queueName + "-Error")
.Build();
await serviceClient.CreateQueueAsync(queueName, createQueueOption);
// Listen to queue (Auto reconnect is enabled)
var consumerOptions = new ConsumerOptionsBuilder <string>()
.WithDefaultDeSerializer(message => JsonConvert.DeserializeObject <string>(Encoding.UTF8.GetString(message.Span)))
.WithSimpleMessageAck()
.WithCustomPipe(async(context, next) =>
{
Console.WriteLine("Some logging message before processing");
await next();
Console.WriteLine("Some logging message after processing");
})
.Build();
var activeConsumer = await serviceClient.StartListeningQueueAsync(queueName, consumerOptions, (message, items, ct) =>
{
Console.WriteLine(message);
return(Task.CompletedTask);
});
// Enqueue a message
await serviceClient.EnqueueMessageAsync(queueName, "some-message");
await Task.Delay(100);
// Enqueue using EnqueueQueueClient
var queueClient = serviceClient.CreateQueueClient(queueName);
await queueClient.EnqueueMessageAsync("some-other-message");
// Cancel listening
activeConsumer.Cancel();
// Purge the queue
await serviceClient.PurgeQueueAsync(queueName);
// Delete a queue
await serviceClient.DeleteQueueAsync(queueName, false, false);
await serviceClient.DeleteQueueAsync(queueName + "-Error", false, false);
}
public void SetUp()
{
routingTopology = new ConventionalRoutingTopology();
receivedMessages = new BlockingCollection <TransportMessage>();
var config = new ConnectionConfiguration();
config.ParseHosts("localhost:5672");
var selectionStrategy = new DefaultClusterHostSelectionStrategy <ConnectionFactoryInfo>();
var connectionFactory = new ConnectionFactoryWrapper(config, selectionStrategy);
connectionManager = new RabbitMqConnectionManager(connectionFactory, config);
unitOfWork = new RabbitMqUnitOfWork
{
ConnectionManager = connectionManager,
UsePublisherConfirms = true,
MaxWaitTimeForConfirms = TimeSpan.FromSeconds(10)
};
sender = new RabbitMqMessageSender
{
UnitOfWork = unitOfWork,
RoutingTopology = routingTopology
};
dequeueStrategy = new RabbitMqDequeueStrategy
{
ConnectionManager = connectionManager,
PurgeOnStartup = true
};
MakeSureQueueAndExchangeExists(ReceiverQueue);
MessagePublisher = new RabbitMqMessagePublisher
{
UnitOfWork = unitOfWork,
RoutingTopology = routingTopology
};
subscriptionManager = new RabbitMqSubscriptionManager
{
ConnectionManager = connectionManager,
EndpointQueueName = ReceiverQueue,
RoutingTopology = routingTopology
};
dequeueStrategy.Init(Address.Parse(ReceiverQueue), TransactionSettings.Default, m =>
{
receivedMessages.Add(m);
return(true);
}, (s, exception) => { });
dequeueStrategy.Start(MaximumConcurrency);
}
static RabbitMqConnectionManager SetupRabbitMqConnectionManager(string connectionString)
{
var config = new ConnectionStringParser(new SettingsHolder()).Parse(connectionString);
// config.OverrideClientProperties();
var connectionFactory = new RabbitMqConnectionFactory(config);
var newConnectionManager = new RabbitMqConnectionManager(connectionFactory, config);
return(newConnectionManager);
}
static RabbitMqConnectionManager SetupRabbitMqConnectionManager(string connectionString)
{
var config = new ConnectionStringParser().Parse(connectionString);
// config.OverrideClientProperties();
var selectionStrategy = new DefaultClusterHostSelectionStrategy <ConnectionFactoryInfo>();
var connectionFactory = new ConnectionFactoryWrapper(config, selectionStrategy);
var newConnectionManager = new RabbitMqConnectionManager(connectionFactory, config);
return(newConnectionManager);
}
public void SetUp()
{
routingTopology = new ConventionalRoutingTopology();
receivedMessages = new BlockingCollection<TransportMessage>();
var config = new ConnectionConfiguration();
config.ParseHosts("localhost:5672");
var selectionStrategy = new DefaultClusterHostSelectionStrategy<ConnectionFactoryInfo>();
var connectionFactory = new ConnectionFactoryWrapper(config, selectionStrategy);
connectionManager = new RabbitMqConnectionManager(connectionFactory, config);
unitOfWork = new RabbitMqUnitOfWork
{
ConnectionManager = connectionManager,
UsePublisherConfirms = true,
MaxWaitTimeForConfirms = TimeSpan.FromSeconds(10)
};
sender = new RabbitMqMessageSender
{
UnitOfWork = unitOfWork,
RoutingTopology = routingTopology
};
dequeueStrategy = new RabbitMqDequeueStrategy
{
ConnectionManager = connectionManager,
PurgeOnStartup = true
};
MakeSureQueueAndExchangeExists(ReceiverQueue);
MessagePublisher = new RabbitMqMessagePublisher
{
UnitOfWork = unitOfWork,
RoutingTopology = routingTopology
};
subscriptionManager = new RabbitMqSubscriptionManager
{
ConnectionManager = connectionManager,
EndpointQueueName = ReceiverQueue,
RoutingTopology = routingTopology
};
dequeueStrategy.Init(Address.Parse(ReceiverQueue), TransactionSettings.Default, m =>
{
receivedMessages.Add(m);
return true;
}, (s, exception) => { });
dequeueStrategy.Start(MaximumConcurrency);
}
public void Setup()
{
_rabbitMqConnectionManager = new RabbitMqConnectionManager(InitRabbitMqDocker.RabbitMqUri, nameof(RabbitMqServiceClientTests), TimeSpan.FromSeconds(20));
_baseOptionBuilder = new RabbitMqServiceOptionsBuilder()
.WithRetry(TimeSpan.FromSeconds(15), null, TimeSpan.FromSeconds(1))
.WithConnectionManager(_rabbitMqConnectionManager)
.WithDefaultSerializer(message => Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)), "application/json");
var options = _baseOptionBuilder.Build();
_serviceClient = new RabbitMqServiceClient(options);
_queueName = BaseQueueName + Guid.NewGuid();
}
public void SetUp()
{
routingTopology = new ConventionalRoutingTopology(true);
receivedMessages = new BlockingCollection <TransportMessage>();
var config = new ConnectionConfiguration();
config.ParseHosts("localhost:5672");
var connectionFactory = new RabbitMqConnectionFactory(config);
connectionManager = new RabbitMqConnectionManager(connectionFactory, config);
publishChannel = connectionManager.GetPublishConnection().CreateModel();
var channelProvider = new FakeChannelProvider(publishChannel);
sender = new RabbitMqMessageSender(routingTopology, channelProvider, new IncomingContext(null, null));
dequeueStrategy = new RabbitMqDequeueStrategy(connectionManager, new RepeatedFailuresOverTimeCircuitBreaker("UnitTest", TimeSpan.FromMinutes(2), e => {}),
new ReceiveOptions(s => SecondaryReceiveSettings.Enabled(CallbackQueue, 1), new MessageConverter(), 1, 1000, false, "Unit test"));
MakeSureQueueAndExchangeExists(ReceiverQueue);
MessagePublisher = new RabbitMqMessagePublisher
{
ChannelProvider = channelProvider,
RoutingTopology = routingTopology
};
subscriptionManager = new RabbitMqSubscriptionManager
{
ConnectionManager = connectionManager,
EndpointQueueName = ReceiverQueue,
RoutingTopology = routingTopology
};
dequeueStrategy.Init(Address.Parse(ReceiverQueue), new TransactionSettings(true, TimeSpan.FromSeconds(30), IsolationLevel.ReadCommitted, 5, false, false), m =>
{
receivedMessages.Add(m);
return(true);
}, (s, exception) => { });
dequeueStrategy.Start(MaximumConcurrency);
}
public MqConnection(MqConnectionConfig config)
{
if ((config.RabbitMqConfig == null && config.AzureServiceBusConfig == null) ||
(config.RabbitMqConfig != null && config.AzureServiceBusConfig != null))
{
throw new ArgumentException("One (only!) config must be not null");
}
if (config.RabbitMqConfig != null)
{
RabbitMqConnectionManager = new RabbitMqConnectionManager(config.RabbitMqConfig);
}
if (config.AzureServiceBusConfig != null)
{
AzureServiceBusConnectionManager = new AzureServiceBusConnectionManager(config.AzureServiceBusConfig);
}
}
public void Setup()
{
_rabbitMqConnectionManager = new RabbitMqConnectionManager(InitRabbitMqDocker.RabbitMqUri, nameof(RabbitMqServiceClientTests), TimeSpan.FromSeconds(20));
var options = new RabbitMqServiceOptionsBuilder()
.WithRetry(TimeSpan.FromSeconds(15), null, TimeSpan.FromSeconds(1))
.WithConnectionManager(_rabbitMqConnectionManager)
.WithDefaultSerializer(message => Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)), "application/json")
.Build();
_serviceClient = new RabbitMqServiceClient(options);
_queueName = BaseQueueName + Guid.NewGuid();
_errorQueueName = _queueName + "-Error";
_consumerOptions = new ConsumerOptionsBuilder <string>()
.WithSimpleMessageAck()
.WithDefaultDeSerializer(message => JsonConvert.DeserializeObject <string>(Encoding.UTF8.GetString(message.Span)))
.Build();
}
public void Start_WhenCalledWithoutQueueUri_RaisesException()
{
var dateTimeProvider = new Mock <IDateTimeProvider>();
var logger = new Mock <ILogger>();
var configurationManager = new Mock <IConfigurationManager>();
configurationManager.Setup(x => x.Get <string>("QueueUri")).Returns((string)null);
var connection = new Mock <IConnection>();
var connectionFactory = new Mock <IConnectionFactory>();
connectionFactory.Setup(x => x.CreateConnection()).Returns(connection.Object);
var rabbitMqConnectionManager = new RabbitMqConnectionManager(connectionFactory.Object, configurationManager.Object);
var rabbitMqWrapper = new RabbitMqWrapper(dateTimeProvider.Object, logger.Object, configurationManager.Object, rabbitMqConnectionManager, _metrics);
rabbitMqWrapper.Start();
}
static RabbitMqConnectionManager SetupRabbitMqConnectionManager(string connectionString) {
var config = new ConnectionStringParser().Parse(connectionString);
// config.OverrideClientProperties();
var selectionStrategy = new DefaultClusterHostSelectionStrategy<ConnectionFactoryInfo>();
var connectionFactory = new ConnectionFactoryWrapper(config, selectionStrategy);
var newConnectionManager = new RabbitMqConnectionManager(connectionFactory, config);
return newConnectionManager;
}
protected void SetupQueueAndSenderAndListener(string connectionString) {
connectionManager = SetupRabbitMqConnectionManager(connectionString);
EnsureRabbitQueueExists(QueueName);
SetupMessageSender();
SetupQueueListener(QueueName);
}
static RabbitMqConnectionManager SetupRabbitMqConnectionManager(string connectionString)
{
var config = new ConnectionStringParser(new SettingsHolder()).Parse(connectionString);
// config.OverrideClientProperties();
var connectionFactory = new RabbitMqConnectionFactory(config);
var newConnectionManager = new RabbitMqConnectionManager(connectionFactory, config);
return newConnectionManager;
}
public void Setup()
{
_rabbitMqConnectionManager = new RabbitMqConnectionManager(InitRabbitMqDocker.RabbitMqUri, nameof(RabbitMqServiceClientTests), TimeSpan.FromSeconds(20));
_queueName = BaseQueueName + Guid.NewGuid();
}
