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