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);
}
}
private TimeSpan ReceiveAndWait(string correlationId)
{
var tokenSource = new CancellationTokenSource();
var start = DateTime.Now;
using (var receiver = new DomainEventReceiver(receiverSettings, serviceProvider, new NullLogger <DomainEventReceiver>())) {
receiver.Closed += (r, e) => tokenSource.Cancel();
receiver.StartAndListen(eventTypes);
while (!TestEvent.Instances.ContainsKey(correlationId) && (DateTime.Now - start) < new TimeSpan(0, 0, 30))
{
if (tokenSource.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);
} // run for 30 seconds
}
return(DateTime.Now.Subtract(start));
}
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();
}
}
