public void GivenConnectionWhenPublishShouldConfigureBasicPropertiesForRetry()
{
const string notification = "test";
var exchange = Exchange.Create("test", ExchangeType.Direct);
var queue = Queue.Create("test.requested");
var routingKey = RoutingKey.Create("test.route");
var body = Encoding.UTF8.GetBytes("test");
_busSerializerMock.Setup(x => x.Serialize(It.IsAny <object>()))
.Returns(body)
.Verifiable();
_basicPropertiesMock.SetupSet(x => x.Headers = new Dictionary <string, object>
{
{ "AttemptCount", 0 },
{ "MaxAttempts", 5 }
})
.Verifiable();
var autoResetEvent = new AutoResetEvent(false);
_publishBatchMock.Setup(x => x.Publish())
.Callback(() => autoResetEvent.Set())
.Verifiable();
var busConnection = GetBusConnection();
busConnection.Publish(exchange, queue, routingKey, notification);
autoResetEvent.WaitOne(TimeSpan.FromSeconds(10));
_publishBatchMock.VerifyAll();
_channelMock.Verify(x => x.CreateBasicProperties(), Times.Once());
_basicPropertiesMock.VerifyAll();
}
public void GivenRoutingKeysWhenValuesAreSameShouldBeEquals()
{
var routingKey1 = RoutingKey.Create("seedwork.cqrs");
var routingKey2 = RoutingKey.Create("seedwork.cqrs");
routingKey1.Should().Be(routingKey2);
}
public void GivenConnectionWhenPublishSuccessedShouldExecuteSuccessedCallback()
{
const string notification = "test";
var exchange = Exchange.Create("test", ExchangeType.Direct);
var queue = Queue.Create("test.requested");
var routingKey = RoutingKey.Create("test.route");
var body = Encoding.UTF8.GetBytes("test");
var headersMock = new Mock <IDictionary <string, object> >();
_busSerializerMock.Setup(x => x.SerializeAsync(It.IsAny <object>()))
.ReturnsAsync(body)
.Verifiable();
_basicPropertiesMock.Setup(x => x.Headers)
.Returns(headersMock.Object)
.Verifiable();
var autoResetEvent = new AutoResetEvent(false);
List <BatchItem> callbackItems = null;
_busConnection.PublishSuccessed += items =>
{
callbackItems = items.ToList();
autoResetEvent.Set();
};
_busConnection.Publish(exchange, queue, routingKey, notification);
autoResetEvent.WaitOne(TimeSpan.FromSeconds(5));
_publishBatchMock.VerifyAll();
callbackItems.Should().NotBeNull();
callbackItems.Should().NotBeEmpty();
}
public async Task GivenConnectionWhenPublishShouldDeclareExchangePublishMessageCloseAndDisposeChannel()
{
const string notification = "test";
var exchange = Exchange.Create("test", ExchangeType.Direct);
var routingKey = RoutingKey.Create("test.route");
var body = Encoding.UTF8.GetBytes("test");
_busSerializerMock.Setup(x => x.Serialize(It.IsAny <object>()))
.ReturnsAsync(body)
.Verifiable();
await _busConnection.Publish(exchange, routingKey, notification);
_connectionFactoryMock.Verify(x => x.CreateConnection(), Times.Once());
_connectionMock.Verify(x => x.CreateModel(), Times.Once());
_channelMock.Verify(x => x.ExchangeDeclare(
exchange.Name.Value,
exchange.Type.Value,
exchange.Durability.IsDurable,
exchange.IsAutoDelete,
It.IsAny <IDictionary <string, object> >()), Times.Once());
_channelMock.Verify(
x => x.BasicPublish(
exchange.Name.Value,
routingKey.Value,
false,
null,
body), Times.Once());
_channelMock.Verify(x => x.Close(), Times.Once());
_channelMock.Verify(x => x.Dispose(), Times.Once());
}
public void GivenConnectionWhenSubscribeAndThrowAndMaxAttemptsAchievedShouldQueueOnFailedQueue()
{
var exchange = Exchange.Create("seedwork-cqrs-bus.integration-tests", ExchangeType.Direct);
var queue = Queue.Create($"seedwork-cqrs-bus.integration-tests.queue-{Guid.NewGuid()}");
var routingKey = RoutingKey.Create(queue.Name.Value);
var message = new TestMessage <string>(null, 1, 1, null, null);
var autoResetEvent = new AutoResetEvent(false);
_connectionFixture.Connection.PublishSuccessed += items =>
{
if (items.Any(x => x.Queue.Name.Value.EndsWith("-failed")))
{
autoResetEvent.Set();
}
};
_connectionFixture.Connection.Publish(exchange, queue, routingKey, message);
_connectionFixture.Connection.Subscribe <string>(exchange, queue, routingKey, 1, (scope, m) =>
{
autoResetEvent.Set();
throw new Exception();
});
autoResetEvent.WaitOne(); // Wait for subscribe to execute.
autoResetEvent.WaitOne(); // Wait for failed message publishing.
var failedQueue = Queue.Create($"{queue.Name.Value}-failed");
_connectionFixture.Connection.MessageCount(failedQueue).Should().Be(1);
}
public void GivenConnectionWhenPublishShouldDeclareExchangePublishMessageCloseAndDisposeChannel()
{
const string notification = "test";
var exchange = Exchange.Create("test", ExchangeType.Direct);
var routingKey = RoutingKey.Create("test.route");
var body = Encoding.UTF8.GetBytes("test");
_busSerializerMock.Setup(x => x.SerializeAsync(It.IsAny <object>()))
.ReturnsAsync(body)
.Verifiable();
var autoResetEvent = new AutoResetEvent(false);
_publishBatchMock.Setup(x => x.Publish())
.Callback(() => autoResetEvent.Set())
.Verifiable();
_busConnection.Publish(exchange, routingKey, notification);
autoResetEvent.WaitOne(TimeSpan.FromSeconds(5));
_publishBatchMock.VerifyAll();
_connectionFactoryMock.Verify(x => x.CreateConnection(), Times.Once());
_connectionMock.Verify(x => x.CreateModel(), Times.Once());
_channelMock.Verify(x => x.ExchangeDeclare(
exchange.Name.Value,
exchange.Type.Value,
exchange.Durability.IsDurable,
exchange.IsAutoDelete,
It.IsAny <IDictionary <string, object> >()), Times.Once());
_channelMock.Verify(x => x.Close(), Times.Once());
_channelMock.Verify(x => x.Dispose(), Times.Once());
}
public async Task Invoke(HttpContext context)
{
try
{
totalCounter.Add();
log.Debug($"Request {context.Request.Method} {context.Request.Path}");
if (HttpMethods.IsGet(context.Request.Method))
{
await context.Response.WriteAsync("Frontier is running");
}
else if (HttpMethods.IsPost(context.Request.Method))
{
var requestPath = context.Request.Path.Value;
if (string.IsNullOrEmpty(requestPath))
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
var streamReader = new StreamReader(context.Request.Body);
var body = await streamReader.ReadToEndAsync();
try
{
var reportHandler = reportHandlers.FirstOrDefault(x => x.CanHandle(requestPath));
if (reportHandler == null)
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
var report = await reportHandler.Handle(context, body);
var logEventData = report.ToLogEventData();
var routingKey = RoutingKey.Create(report.GetProject(), environment, "frontier_" + reportHandler.Name, RoutingKey.LogsSuffix);
log.Debug("Send data via airlock to " + routingKey);
airlockClient.Push(routingKey, logEventData, logEventData.Timestamp);
context.Response.StatusCode = (int)HttpStatusCode.NoContent;
}
finally
{
if (resendTo != null)
{
await ResendRequest(context, body);
}
}
}
else if (HttpMethods.IsOptions(context.Request.Method))
{
context.Response.StatusCode = (int)HttpStatusCode.NoContent;
}
}
catch (Exception e)
{
errorCounter.Add();
log.Error(e);
}
}
public void GivenConnectionWhenSubscribeShouldExecuteCallback()
{
var exchange = Exchange.Create("seedwork-cqrs-bus.integration-tests", ExchangeType.Direct);
var queue = Queue.Create($"seedwork-cqrs-bus.integration-tests.queue-{Guid.NewGuid()}")
.WithAutoDelete();
var routingKey = RoutingKey.Create(queue.Name.Value);
const string notification = "Notification message";
_connectionFixture.Connection.Publish(exchange, queue, routingKey, notification);
IServiceScope callbackScope = null;
string callbackMessage = null;
var autoResetEvent = new AutoResetEvent(false);
_connectionFixture.Connection.Subscribe <string>(exchange, queue, routingKey, 1, (scope, message) =>
{
callbackScope = scope;
callbackMessage = message;
autoResetEvent.Set();
return(Task.CompletedTask);
});
autoResetEvent.WaitOne();
callbackScope.Should().NotBeNull();
callbackMessage.Should().Be(notification);
}
public void GivenConnectionWhenPublishShouldConfigureBasicPropertiesForRetry()
{
const string notification = "test";
var exchange = Exchange.Create("test", ExchangeType.Direct);
var queue = Queue.Create("test.requested");
var routingKey = RoutingKey.Create("test.route");
var body = Encoding.UTF8.GetBytes("test");
var headersMock = new Mock <IDictionary <string, object> >();
_busSerializerMock.Setup(x => x.SerializeAsync(It.IsAny <object>()))
.ReturnsAsync(body)
.Verifiable();
_basicPropertiesMock.Setup(x => x.Headers)
.Returns(headersMock.Object)
.Verifiable();
var autoResetEvent = new AutoResetEvent(false);
_publishBatchMock.Setup(x => x.Publish())
.Callback(() => autoResetEvent.Set())
.Verifiable();
_busConnection.Publish(exchange, queue, routingKey, notification);
autoResetEvent.WaitOne();
_publishBatchMock.VerifyAll();
_channelMock.Verify(x => x.CreateBasicProperties(), Times.Once());
_basicPropertiesMock.VerifySet(x => x.Headers = new Dictionary <string, object>());
headersMock.Verify(x => x.Add(nameof(ConsumerMessage.Options.MaxAttempts), It.IsAny <object>()));
headersMock.Verify(x => x.Add(nameof(ConsumerMessage.AttemptCount), It.IsAny <object>()));
}
public void PushLogEventsToAirlock()
{
var routingKey = RoutingKey.Create("vostok", "ci", "core", RoutingKey.LogsSuffix);
var events = GenerateLogEvens(count: 10);
PushToAirlock(routingKey, events, e => e.Timestamp);
}
internal static Queue CreateRetryQueue(this Queue queue, TimeSpan ttl)
{
return(Queue.Create($"{queue.Name.Value}-retry")
.WithDurability(Durability.Durable)
.MessagesExpiresIn(ttl)
.SendExpiredMessagesTo(Exchange.Default, RoutingKey.Create(queue.Name.Value)));
}
public void GivenRoutingKeyShouldCreate(string routing)
{
var routingKey = RoutingKey.Create(routing);
routingKey.Should().NotBeNull();
routingKey.Value.Should().Be(routing);
}
public void GivenRoutingKeyWhenSpaceAroundShouldTrim(string routing, string expected)
{
var routingKey = RoutingKey.Create(routing);
routingKey.Should().NotBeNull();
routingKey.Value.Should().Be(expected);
}
public void GivenConnectionWhenSubscribeAndThrowShouldRequeueOnRetryQueue()
{
var exchange = Exchange.Create("seedwork-cqrs-bus.integration-tests", ExchangeType.Direct);
var queue = Queue.Create($"seedwork-cqrs-bus.integration-tests.queue-{Guid.NewGuid()}");
var routingKey = RoutingKey.Create(queue.Name.Value);
const string notification = "Notification message";
var autoResetEvent = new AutoResetEvent(false);
_connectionFixture.Connection.PublishSuccessed += items =>
{
if (items.Any(x => x.Queue.Name.Value.EndsWith("-retry-1m")))
{
autoResetEvent.Set();
}
};
_connectionFixture.Connection.Publish(exchange, queue, routingKey, notification);
_connectionFixture.Connection.Subscribe <string>(exchange, queue, routingKey, 1, (scope, message) =>
{
autoResetEvent.Set();
throw new Exception();
});
autoResetEvent.WaitOne(); // Wait for subscribe to execute.
autoResetEvent.WaitOne(); // Wait for retry message publishing.
var retryQueue = Queue.Create($"{queue.Name.Value}-retry-1m");
_connectionFixture.Connection.MessageCount(retryQueue).Should().Be(1);
}
public void Init()
{
AutoScaleConsumer = new Consumer(Adapter, Exchange.AUTOSCALEX, RoutingKey.Create(ScalableConsumer.GetQueueName()).ToList());
AutoScaleConsumer.Init();
AutoScaleConsumer.MessageReceived += OnMessageReceived;
Adapter.ConsumeAsync(AutoScaleConsumer);
}
public void GivenConnectionWhenSubscribeShouldExecuteCallbackLogAndNackOnFailure()
{
var exchange = Exchange.Create("test", ExchangeType.Direct);
var queue = Queue.Create("test.requested");
var routingKey = RoutingKey.Create("test.route");
var body = Encoding.UTF8.GetBytes("test");
const ushort deliveryTag = 1;
var loggerMock = new Mock <IBusLogger>();
_busSerializerMock.Setup(x => x.Deserialize <string>(body))
.ReturnsAsync("test")
.Verifiable();
_serviceProviderMock.Setup(x => x.GetService(typeof(IBusLogger)))
.Returns(loggerMock.Object)
.Verifiable();
_channelMock.Setup(x => x.BasicConsume(
queue.Name.Value,
false,
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <IDictionary <string, object> >(),
It.IsAny <IBasicConsumer>()))
.Callback((string queueName, bool autoAck, string consumerTag, bool noLocal, bool exclusive,
IDictionary <string, object> _, IBasicConsumer consumer) =>
{
((EventingBasicConsumer)consumer).HandleBasicDeliver(
consumerTag,
deliveryTag,
false,
exchange.Name.Value,
routingKey.Value,
new BasicProperties(),
body);
})
.Returns(Guid.NewGuid().ToString());
_busConnection.Subscribe <string>(
exchange,
queue,
routingKey,
10,
(scope, @event) => throw new Exception());
_channelMock.Verify(x => x.BasicQos(0, 10, false), Times.Once());
_channelMock.Verify(x => x.BasicConsume(
queue.Name.Value,
false,
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <IDictionary <string, object> >(),
It.IsAny <IBasicConsumer>()), Times.Once());
_channelMock.Verify(x => x.BasicNack(deliveryTag, false, true), Times.Once());
loggerMock.Verify(x => x.WriteException(It.IsAny <string>(), It.IsAny <Exception>(),
It.IsAny <KeyValuePair <string, object>[]>()));
}
public void GivenConnectionWhenSubscribeShouldExecuteCallbackLogOnFailure()
{
var exchange = Exchange.Create("test", ExchangeType.Direct);
var queue = Queue.Create("test.requested");
var routingKey = RoutingKey.Create("test.route");
var body = Encoding.UTF8.GetBytes("test");
const ushort deliveryTag = 1;
_busSerializerMock.Setup(x => x.Deserialize <string>(body))
.Returns("test")
.Verifiable();
var autoResetEvent = new AutoResetEvent(false);
_channelMock.Setup(x => x.BasicConsume(
queue.Name.Value,
false,
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <IDictionary <string, object> >(),
It.IsAny <IBasicConsumer>()))
.Callback((string queueName, bool autoAck, string consumerTag, bool noLocal, bool exclusive,
IDictionary <string, object> _, IBasicConsumer consumer) =>
{
((AsyncEventingBasicConsumer)consumer).HandleBasicDeliver(
consumerTag,
deliveryTag,
false,
exchange.Name.Value,
routingKey.Value,
_basicPropertiesMock.Object,
body).Wait();
})
.Returns(Guid.NewGuid().ToString());
_loggerMock.Setup(x => x.WriteException(
It.IsAny <string>(),
It.IsAny <Exception>(),
It.IsAny <KeyValuePair <string, object>[]>()))
.Callback((string name, Exception exception, KeyValuePair <string, Object>[] properties) =>
autoResetEvent.Set())
.Verifiable();
var busConnection = GetBusConnection();
busConnection.Subscribe <string>(
exchange,
queue,
routingKey,
10,
(scope, @event) => throw new Exception());
autoResetEvent.WaitOne(TimeSpan.FromSeconds(10));
_loggerMock.Verify(x => x.WriteException(It.IsAny <string>(), It.IsAny <Exception>(),
It.IsAny <KeyValuePair <string, object>[]>()));
}
public void GivenQueueWhenConfigureToSendExpiredMessagesToTwiceShouldNotThrow()
{
var exchangeName = ExchangeName.Create("seedwork");
var routingKey = RoutingKey.Create("seedwork.cqrs");
var queue = Queue.Create("seedwork.cqrs");
Func <Queue> action = () => queue.SendExpiredMessagesTo(exchangeName, routingKey)
.SendExpiredMessagesTo(exchangeName, routingKey);
action.Should().NotThrow();
}
protected override void AddListeningRoutingKeys(ref List <RoutingKey> routingKeys)
{
//Set the message(s) that this service is interested in receiving
//e.g. Listen for OnTick
routingKeys.Add(RoutingKey.Create(Source.WILDCARD, Messaging.RabbitMQ.Action.WILDCARD, Event.ONTICK));
//e.g. Listen for Service Notification success messages from OnOpenForTrading
routingKeys.Add(RoutingKey.Create(nameof(OnOpenForTrading), Messaging.RabbitMQ.Action.NOTIFY, Event.WILDCARD));
}
public async Task GivenConnectionWhenPublishQueueShouldHaveCountOne()
{
var exchange = Exchange.Create("seedwork-cqrs-bus.integration-tests", ExchangeType.Direct);
var queue = Queue.Create($"seedwork-cqrs-bus.integration-tests.queue-{Guid.NewGuid()}")
.WithAutoDelete();
var routingKey = RoutingKey.Create(queue.Name.Value);
const string notification = "Notification message";
await _connectionFixture.Connection.Publish(exchange, queue, routingKey, notification);
_connectionFixture.Connection.MessageCount(queue).Should().Be(1);
}
protected override List <RoutingKey> SetListeningRoutingKeys()
{
List <RoutingKey> routingKeys = RoutingKey.Create(Messaging.RabbitMQ.Action.NOTIFY).ToList();
routingKeys.Add(RoutingKey.Create(Event.ONPOSITIONCLOSED));
routingKeys.Add(RoutingKey.Create(Event.ONPOSITIONOPENED));
routingKeys.Add(RoutingKey.Create(Event.ONORDERPLACED));
routingKeys.Add(RoutingKey.Create(Event.ONORDERCANCELLED));
routingKeys.Add(RoutingKey.Create(Event.ONERROR));
return(routingKeys);
}
public void GivenConnectionWhenSubscribeShouldExecuteCallbackAndAckOnSuccess()
{
var exchange = Exchange.Create("test", ExchangeType.Direct);
var queue = Queue.Create("test.requested");
var routingKey = RoutingKey.Create("test.route");
var body = Encoding.UTF8.GetBytes("test");
const ushort deliveryTag = 1;
_busSerializerMock.Setup(x => x.Deserialize <string>(body))
.ReturnsAsync("test")
.Verifiable();
_channelMock.Setup(x => x.BasicConsume(
queue.Name.Value,
false,
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <IDictionary <string, object> >(),
It.IsAny <IBasicConsumer>()))
.Callback((string queueName, bool autoAck, string consumerTag, bool noLocal, bool exclusive,
IDictionary <string, object> _, IBasicConsumer consumer) =>
{
((EventingBasicConsumer)consumer).HandleBasicDeliver(
consumerTag,
deliveryTag,
false,
exchange.Name.Value,
routingKey.Value,
new BasicProperties(),
body);
})
.Returns(Guid.NewGuid().ToString());
var isExecuted = false;
_busConnection.Subscribe <string>(exchange, queue, routingKey, 10, (scope, @event) =>
{
isExecuted = true;
return(Task.CompletedTask);
});
isExecuted.Should().BeTrue();
_channelMock.Verify(x => x.BasicQos(0, 10, false), Times.Once());
_channelMock.Verify(x => x.BasicConsume(
queue.Name.Value,
false,
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <IDictionary <string, object> >(),
It.IsAny <IBasicConsumer>()), Times.Once());
_channelMock.Verify(x => x.BasicAck(deliveryTag, false), Times.Once());
}
protected override List <RoutingKey> SetListeningRoutingKeys()
{
List <RoutingKey> routingKeys = RoutingKey.Create(Niffler.Messaging.RabbitMQ.Event.ONORDERCANCELLED).ToList();
routingKeys.Add(RoutingKey.Create(Niffler.Messaging.RabbitMQ.Event.ONORDERMODIFIED));
routingKeys.Add(RoutingKey.Create(Niffler.Messaging.RabbitMQ.Event.ONORDERPLACED));
routingKeys.Add(RoutingKey.Create(Niffler.Messaging.RabbitMQ.Event.ONPOSITIONCLOSED));
routingKeys.Add(RoutingKey.Create(Niffler.Messaging.RabbitMQ.Event.ONPOSITIONMODIFIED));
routingKeys.Add(RoutingKey.Create(Niffler.Messaging.RabbitMQ.Event.ONPOSITIONOPENED));
routingKeys.Add(RoutingKey.Create(Niffler.Messaging.RabbitMQ.Action.TRADEMANAGEMENT));
return(routingKeys);
}
protected override List <RoutingKey> SetListeningRoutingKeys()
{
//Listen for OnTick
List <RoutingKey> routingKeys = RoutingKey.Create(Source.WILDCARD, Messaging.RabbitMQ.Action.WILDCARD, Event.ONTICK).ToList();
//Listen for Update State Notification from OnOpenForTrading
routingKeys.Add(RoutingKey.Create(nameof(OnOpenForTrading), Messaging.RabbitMQ.Action.UPDATESTATE, Event.WILDCARD));
//Listen for Update State Notification from StateManager for the Open Time
routingKeys.Add(RoutingKey.Create(nameof(OnOpenForTrading), Messaging.RabbitMQ.Action.UPDATESTATE, Event.WILDCARD));
return(routingKeys);
}
public void GivenConnectionWhenRetryShouldUseConfiguredBehavior()
{
var configuration = new ConfigurationBuilder()
.Build();
var retryBehaviorMock = new Mock <IRetryBehavior>();
var serviceProvider = new ServiceCollection()
.AddBusCore(configuration, builder =>
{
builder.SetConnectionString("amqp://*****:*****@localhost:5672/")
.IgnoreCertificate()
.SetSerializer <BusSerializer>()
.UseRetryBehabior(retryBehaviorMock.Object);
})
.BuildServiceProvider();
var connection = serviceProvider.GetService <BusConnection>();
var exchange = Exchange.Default;
var queue = Queue.Create(Guid.NewGuid().ToString());
var routingKey = RoutingKey.Create(queue.Name.Value);
BatchItem item = null;
connection.Publish(exchange, queue, routingKey, "Message");
var autoResetEvent = new AutoResetEvent(false);
connection.PublishSuccessed += items =>
{
item = items.First();
autoResetEvent.Set();
};
autoResetEvent.WaitOne();
retryBehaviorMock.Setup(x => x.ShouldRetry(1, 5))
.Returns(true)
.Verifiable();
retryBehaviorMock.Setup(x => x.GetWaitTime(1))
.Returns(TimeSpan.FromMinutes(5))
.Verifiable();
connection.Subscribe <string>(exchange, queue, routingKey, 1, (scope, message) =>
{
throw new Exception("Test");
});
autoResetEvent.WaitOne();
item.Should().NotBeNull();
item.Queue.Name.Value.Should().EndWith("5m");
retryBehaviorMock.VerifyAll();
}
public void GivenConnectionWhenPublishShouldDeclareExchangeQueueAndBindRoutingKey()
{
const string notification = "test";
var exchange = Exchange.Create("test", ExchangeType.Direct);
var queue = Queue.Create("test.requested");
var routingKey = RoutingKey.Create("test.route");
var body = Encoding.UTF8.GetBytes("test");
var headersMock = new Mock <IDictionary <string, object> >();
_busSerializerMock.Setup(x => x.Serialize(It.IsAny <object>()))
.Returns(body)
.Verifiable();
_basicPropertiesMock.Setup(x => x.Headers)
.Returns(headersMock.Object)
.Verifiable();
var autoResetEvent = new AutoResetEvent(false);
_publishBatchMock.Setup(x => x.Publish())
.Callback(() => autoResetEvent.Set())
.Verifiable();
var busConnection = GetBusConnection();
busConnection.Publish(exchange, queue, routingKey, notification);
autoResetEvent.WaitOne(TimeSpan.FromSeconds(10));
_publishBatchMock.VerifyAll();
_connectionFactoryMock.Verify(x => x.CreateConnection(), Times.Once());
_connectionMock.Verify(x => x.CreateModel(), Times.Once());
_channelMock.Verify(x => x.ExchangeDeclare(
exchange.Name.Value,
exchange.Type.Value,
exchange.Durability.IsDurable,
exchange.IsAutoDelete,
It.IsAny <IDictionary <string, object> >()), Times.Once());
_channelMock.Verify(x => x.QueueDeclare(
queue.Name.Value,
queue.Durability.IsDurable,
false,
queue.IsAutoDelete,
It.IsAny <IDictionary <string, object> >()));
_channelMock.Verify(x => x.QueueBind(
queue.Name.Value,
exchange.Name.Value,
routingKey.Value,
It.IsAny <IDictionary <string, object> >()));
}
public void GivenQueueWhenConfigureToSendExpiredMessagesToShouldAddArgument()
{
var exchangeName = ExchangeName.Create("seedwork");
var routingKey = RoutingKey.Create("seedwork.cqrs");
var queue = Queue.Create("seedwork.cqrs");
queue = queue.SendExpiredMessagesTo(exchangeName, routingKey);
queue.Should().NotBeNull();
queue.Arguments.ContainsKey("x-dead-letter-exchange").Should().BeTrue();
queue.Arguments.ContainsKey("x-dead-letter-routing-key").Should().BeTrue();
queue.Arguments["x-dead-letter-exchange"].Should().Be(exchangeName.Value);
queue.Arguments["x-dead-letter-routing-key"].Should().Be(routingKey.Value);
}
public override Task HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey,
IBasicProperties properties, byte[] body)
{
var @event = new BasicDeliverEventArgs(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body);
try
{
var task = new Task(() =>
{
try
{
var message = Message <T> .Create(_channel, _options.Exchange, _options.Queue, RoutingKey.Create(routingKey), _options.Serializer, @event,
(OnDone, OnFail));
using var scope = _scopeFactory.CreateScope();
try
{
_options.OnNext(scope, message).GetAwaiter().GetResult();
if (_options.AutoAck)
{
message.Complete();
}
}
catch (Exception exception)
{
message.Fail(exception);
}
}
catch (Exception exception)
{
_logger?.WriteException(nameof(Consumer <T>), exception,
new KeyValuePair <string, object>("Event", Encoding.UTF8.GetString(@event.Body)));
var failedQueue = _options.Queue.CreateFailedQueue();
var failedRoutingKey = RoutingKey.Create(failedQueue.Name.Value);
_connection.Publish(Exchange.Default, failedQueue, failedRoutingKey,
ErrorMessage.Create(@event.Body, @event.BasicProperties));
_channel.BasicNack(@event.DeliveryTag, false, false);
}
});
_tasks.Add(task);
}
catch (Exception ex)
{
_logger?.WriteException(typeof(T).Name, ex,
new KeyValuePair <string, object>("args", @event));
_channel.BasicNack(@event.DeliveryTag, false, true);
}
return(Task.CompletedTask);
}
public void GivenConnectionWhenPublishMessageShouldQueueHaveCountOne()
{
var exchange = Exchange.Create("seedwork-cqrs-bus.integration-tests", ExchangeType.Direct);
var queue = Queue.Create($"seedwork-cqrs-bus.integration-tests.queue-{Guid.NewGuid()}")
.WithAutoDelete();
var routingKey = RoutingKey.Create(queue.Name.Value);
const string notification = "Notification message";
var autoResetEvent = new AutoResetEvent(false);
_connectionFixture.Connection.PublishSuccessed += _ => autoResetEvent.Set();
_connectionFixture.Connection.Publish(exchange, queue, routingKey, notification);
autoResetEvent.WaitOne();
_connectionFixture.Connection.MessageCount(queue).Should().Be(1);
}
public void GivenConnectionWhenSubscribeAndFailShouldRequeueOnRetryQueueWithRequestKey()
{
var exchange = Exchange.Create("seedwork-cqrs-bus.integration-tests", ExchangeType.Direct);
var queue = Queue.Create($"seedwork-cqrs-bus.integration-tests.queue-{Guid.NewGuid()}");
var routingKey = RoutingKey.Create(queue.Name.Value);
const string notification = "Notification message";
string requestKey = $"Request-Key-{Guid.NewGuid()}";
var autoResetEvent = new AutoResetEvent(false);
_connectionFixture.Connection.PublishSuccessed += items =>
{
if (items.Any(x => x.Queue.Name.Value.EndsWith("-retry-1m")))
{
autoResetEvent.Set();
}
};
_connectionFixture.Connection.Publish(exchange, queue, routingKey, Message.Create(notification, 5, requestKey));
Message <string> consumerMessage = null;
_connectionFixture.Connection.Subscribe <string>(exchange, queue, routingKey, 1, (scope, m) =>
{
autoResetEvent.Set();
consumerMessage = m;
return(Task.CompletedTask);
}, false);
autoResetEvent.WaitOne(); // Wait for subscribe to execute.
consumerMessage.Fail(new Exception());
autoResetEvent.WaitOne(); // Wait for retry message publishing.
var retryQueue = Queue.Create($"{queue.Name.Value}-retry-1m");
_connectionFixture.Connection.MessageCount(retryQueue).Should().Be(1);
var message = _connectionFixture.Connection.GetMessage(retryQueue);
message.Should().NotBeNull();
message.RequestKey.Should().Be(requestKey);
}
