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