public async Task ShouldBeAbleToSendAndReceive() { if (enabled) { var @event = NewTestEvent(); var correlationId = Guid.NewGuid().ToString(); try { await publisher.PublishAsync(@event, correlationId).ConfigureAwait(false); } finally { Assert.Null(publisher.Error); } EventMessage message; var logger = new MockLogger <DomainEventReceiver>(); using (var receiver = new DomainEventReceiver(receiverSettings, serviceProvider, logger)) { receiver.Start(eventTypes); message = receiver.Receive(TimeSpan.FromSeconds(1)); if (message != null) { message.Accept(); } } Assert.DoesNotContain(logger.LogEvents, x => x.LogLevel == LogLevel.Error); Assert.NotNull(message); Assert.NotNull(message); Assert.Equal(correlationId, message.Message.CorrelationId); Assert.NotNull(message.Message.MessageId); Assert.NotNull(message.Message.MessageTypeName); Assert.Equal(@event.StringValue, ((TestEvent)message.Message.Data).StringValue); Assert.Equal(@event.IntValue, ((TestEvent)message.Message.Data).IntValue); } }
public async Task ShouldBeAbleToSendAndReceive() { var receiverLoggerMock = new Mock <ILogger <DomainEventReceiver> >(); var receiverSection = configRoot.GetSection("Receiver.Settings"); var receiverSettings = GetSettings(receiverSection); var receiver = new DomainEventReceiver(receiverSettings, serviceProvider, receiverLoggerMock.Object); var publisherLoggerMock = new Mock <ILogger <DomainEventPublisher> >(); var publisherSection = configRoot.GetSection("Publisher.Settings"); var publisherSettings = GetSettings(publisherSection); var publisher = new DomainEventPublisher(publisherSettings, publisherLoggerMock.Object); var @event = new TestEvent { TheInt = r.Next(), TheString = Guid.NewGuid().ToString() }; await publisher.SendAsync(@event); receiver.Receive(new Dictionary <string, Type> { { typeof(TestEvent).FullName, typeof(TestEvent) } }); var start = DateTime.Now; while (TestEvent.Instance == null && (DateTime.Now - start) < new TimeSpan(0, 0, 30)) { Thread.Sleep(1000); } // run for 30 seconds Assert.Equal(@event.TheString, TestEvent.Instance.TheString); Assert.Equal(@event.TheInt, TestEvent.Instance.TheInt); }
public async Task ShouldBeAbleToScheduleAndReceive() { var tokenSource = new CancellationTokenSource(); var token = tokenSource.Token; var receiverLoggerMock = new Mock <ILogger <DomainEventReceiver> >(); var receiverSection = configRoot.GetSection("Receiver.Settings"); var receiverSettings = GetSettings <ServiceBusReceiverSettings>(receiverSection); var receiver = new DomainEventReceiver(receiverSettings, serviceProvider, receiverLoggerMock.Object); receiver.Closed += (r, e) => tokenSource.Cancel(); var publisherLoggerMock = new Mock <ILogger <DomainEventPublisher> >(); var publisherSection = configRoot.GetSection("Publisher.Settings"); var publisherSettings = GetSettings <ServiceBusPublisherSettings>(publisherSection); var publisher = new DomainEventPublisher(publisherSettings, publisherLoggerMock.Object); var @event = new TestEvent { TheInt = r.Next(), TheString = Guid.NewGuid().ToString() }; var correlationId = Guid.NewGuid().ToString(); try { await publisher.ScheduleMessageAsync(@event, correlationId, DateTime.UtcNow.AddSeconds(20)); } finally { Assert.Null(publisher.Error); } receiver.Receive(new Dictionary <string, Type> { { typeof(TestEvent).FullName, typeof(TestEvent) } }); var start = DateTime.Now; var elapsed = DateTime.Now.Subtract(start); while (!TestEvent.Instances.ContainsKey(correlationId) && (DateTime.Now - start) < new TimeSpan(0, 0, 30)) { if (token.IsCancellationRequested) { if (receiver.Error != null) { Assert.Equal(string.Empty, receiver.Error.Description); Assert.Equal(string.Empty, receiver.Error.Condition); } Assert.True(receiver.Error == null); } Thread.Sleep(1000); elapsed = DateTime.Now.Subtract(start); } // run for 30 seconds Assert.True(elapsed.TotalSeconds >= 20); Assert.True(TestEvent.Instances.Any()); Assert.True(TestEvent.Instances.ContainsKey(correlationId)); Assert.NotNull(TestEvent.Instances[correlationId]); Assert.Equal(@event.TheString, TestEvent.Instances[correlationId].TheString); Assert.Equal(@event.TheInt, TestEvent.Instances[correlationId].TheInt); }
public async Task ShouldReceiveMessage_RejectAsync() { receiverSettings.Queue = Guid.NewGuid().ToString(); List <Message> messages = new List <Message>(); host.RegisterMessageProcessor(receiverSettings.Queue + "TestEvent", new TestMessageProcessor(50, messages)); linkProcessor = new TestLinkProcessor(); host.RegisterLinkProcessor(linkProcessor); int count = 1; publisterSettings.Topic = receiverSettings.Queue; var publisher = new DomainEventPublisher(publisterSettings, new NullLogger <DomainEventPublisher>()); for (int i = 0; i < count; i++) { var @event = new TestEvent() { IntValue = random.Next(), StringValue = Guid.NewGuid().ToString() }; await publisher.PublishAsync(@event).ConfigureAwait(false); } var source = new TestMessageSource(new Queue <Message>(messages)); host.RegisterMessageSource(receiverSettings.Queue, source); using (var receiver = new DomainEventReceiver(receiverSettings, provider, new NullLogger <DomainEventReceiver>())) { receiver.Start(eventTypes); int waits = 0; do { await Task.Delay(1000).ConfigureAwait(false); if (receiver.Link.LinkState == LinkState.Attached) { break; } waits++; }while (waits < 20); for (int i = 0; i < count; i++) { var message = receiver.Receive(TimeSpan.FromSeconds(10)); message.Reject(); await Task.Delay(1000).ConfigureAwait(false); } } Assert.Equal(count, source.DeadLetterCount); Assert.Equal(0, source.Count); }
public async Task ShouldReceiveMessage_Accept() { receiverSettings.Queue = Guid.NewGuid().ToString(); List <Message> messages = new List <Message>(); host.RegisterMessageProcessor(receiverSettings.Queue + "TestEvent", new TestMessageProcessor(50, messages)); linkProcessor = new TestLinkProcessor(); host.RegisterLinkProcessor(linkProcessor); int count = 1; publisterSettings.Topic = receiverSettings.Queue; var publisher = new DomainEventPublisher(publisterSettings, new NullLogger <DomainEventPublisher>()); for (int i = 0; i < count; i++) { var @event = new TestEvent() { IntValue = random.Next(), StringValue = Guid.NewGuid().ToString() }; await publisher.PublishAsync(@event).ConfigureAwait(false); } var source = new TestMessageSource(new Queue <Message>(messages)); host.RegisterMessageSource(receiverSettings.Queue, source); using (var receiver = new DomainEventReceiver(receiverSettings, provider, new NullLogger <DomainEventReceiver>())) { receiver.Start(eventTypes); for (int i = 0; i < count; i++) { var message = receiver.Receive(TimeSpan.FromSeconds(1)); Assert.NotNull(message.GetData <TestEvent>()); message.Accept(); } } Assert.Equal(0, source.DeadLetterCount); Assert.Equal(0, source.Count); }
public async Task ShouldUseTransactionScope() { var s = Guid.NewGuid().ToString(); if (enabled) { int nMsgs = 10; var ids = new List <int>(); for (int i = 0; i < nMsgs; i++) { var @event = new TestEvent() { IntValue = i, StringValue = s }; ids.Add(i); await publisher.PublishAsync(@event).ConfigureAwait(false); } var receiver = new DomainEventReceiver(receiverSettings, serviceProvider, new NullLogger <DomainEventReceiver>()); receiver.Start(eventTypes); var message1 = receiver.Receive(); var message2 = receiver.Receive(); // ack message1 and send a new message in a txn using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { message1.Accept(); ids.Remove(message1.GetData <TestEvent>().IntValue); var @event = new TestEvent() { IntValue = nMsgs + 1, StringValue = s }; await publisher.PublishAsync(@event).ConfigureAwait(false); ids.Add(@event.IntValue); ts.Complete(); } // ack message2 and send a new message in a txn but abort the txn using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { message2.Accept(); await publisher.PublishAsync(message2.GetData <TestEvent>()).ConfigureAwait(false); } // release the message, since it shouldn't have been accepted above message2.Release(); // receive all messages. should see the effect of the first txn for (int i = 1; i <= nMsgs; i++) { var message = receiver.Receive(); message.Accept(); Assert.Contains(message.GetData <TestEvent>().IntValue, ids); ids.Remove(message.GetData <TestEvent>().IntValue); } // at this point, the queue should have zero messages. // If there are messages, it is a bug in the broker. Assert.Empty(ids); // shouldn't be any messages left var empty = receiver.Receive(TimeSpan.FromSeconds(2)); Assert.Null(empty); receiver.Close(); } }