public void Parse_EventIdFieldIsNotGuid_ErrorShouldBeReturned()
{
//prepare
var bookingCreatedEvent = new IntergrationEventWithNonGuidEventId <BookingCreated>()
{
EventId = 123,
CorrelationId = Guid.NewGuid(),
EventCreationDate = DateTime.UtcNow,
EventType = "bookingCreated",
Version = "0.1",
Content = new BookingCreated()
{
BookingName = "bookingName"
}
};
//act
IntergrationEventParsingResult result =
DefaultIntergrationEventParser.Parse(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(bookingCreatedEvent)));
//check
result.Success.Should().BeFalse();
result.IntegrationEvent.Should().BeNull();
result.Errors.First().Should().Be("EventId is not GUID");
}
public void Parse_CorrelationIdFieldIsMissedEventCreationDateIsNotDateTime_ErrorShouldBeReturned()
{
//prepare
var bookingCreatedEvent =
new IntergrationEventWithoutCorrelationIdAndWrongEventCreationDate <BookingCreated>()
{
EventId = Guid.NewGuid(),
EventCreationDate = 13,
EventType = "bookingcreated",
Version = "0.1",
Content = new BookingCreated()
{
BookingName = "bookingName"
}
};
//act
IntergrationEventParsingResult result =
DefaultIntergrationEventParser.Parse(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(bookingCreatedEvent)));
//check
result.Success.Should().BeFalse();
result.IntegrationEvent.Should().BeNull();
result.Errors.Count.Should().Be(2);
result.Errors[0].Should().Be("CorrelationId token is missed");
result.Errors[1].Should().Be("EventCreationDate is not DateTime");
}
public void Parse_CorrelationIdFieldIsEmpty_SuccessShouldBeReturned()
{
//prepare
var bookingCreatedEvent = new IntegrationEvent <BookingCreated>()
{
EventId = Guid.NewGuid(),
CorrelationId = null,
EventCreationDate = DateTime.UtcNow,
EventType = "bookingCreated",
Version = "0.1",
Content = new BookingCreated()
{
BookingName = "bookingName"
}
};
//act
IntergrationEventParsingResult result =
DefaultIntergrationEventParser.Parse(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(bookingCreatedEvent)));
//check
result.Success.Should().BeTrue();
result.IntegrationEvent.ShouldBeEquivalentTo(bookingCreatedEvent);
result.Errors.Count.Should().Be(0);
}
public void Subscribe(IDictionary <string, ISubscription> subscriptions)
{
lock (_threadguard)
{
if (_alreadyDisposed)
{
throw new
ObjectDisposedException("EasyNetQSubscriber",
"Called Subscribe Method on Disposed object");
}
if (_subscribed == false)
{
_subscriptions = new ConcurrentDictionary <string, ISubscription>(subscriptions);
_consumerDisposable = _bus.Consume(_queue, async(body, properties, info) =>
{
MessageExecutionContext messageExecutionContext = new MessageExecutionContext(body, properties, info);
try
{
messageExecutionContext.IntergrationEventParsingResult = DefaultIntergrationEventParser.Parse(body);
if (messageExecutionContext.IntergrationEventParsingResult.Success)
{
using (LogContext.PushProperty("CorrelationId", messageExecutionContext.IntergrationEventParsingResult.IntegrationEvent.CorrelationId))
{
messageExecutionContext.Subscription = _subscriptionSelector.Select(_subscriptions,
messageExecutionContext.IntergrationEventParsingResult.IntegrationEvent.EventType);
if (messageExecutionContext.Subscription != null)
{
messageExecutionContext.SerializedMessage = Encoding.UTF8.GetString(body);
_logger.Debug("Subscriber received message: {@body}", messageExecutionContext.SerializedMessage);
await messageExecutionContext.Subscription.InvokeAsync(messageExecutionContext.SerializedMessage);
await _successHandlingStrategy.HandleSuccessAsync(
messageExecutionContext.IntergrationEventParsingResult.IntegrationEvent);
}
else
{
throw new DiscardEventException(
$"The consumer for {messageExecutionContext.IntergrationEventParsingResult.IntegrationEvent.EventType} event type is not matched");
}
}
}
else
{
throw new MalformedEventException(messageExecutionContext.IntergrationEventParsingResult.Errors);
}
}
catch (Exception e)
{
messageExecutionContext.Exception = e;
await _errorHandlingStrategy.HandleErrorAsync(messageExecutionContext);
}
}, configuration => configuration.WithPrefetchCount(_prefetchcount));
_subscribed = true;
}
else
{
foreach (var subscription in subscriptions)
{
_subscriptions.AddOrUpdate(
subscription.Key, subscription.Value,
(key, oldValue) => subscription.Value);
}
}
}
}
public async void Subscribe_CorrectlyFormedEvent_ProcessingWithoutErrors_NoExceptionsShouldBeThrown()
{
//prepare
IntegrationEvent <BookingCreated> integrationEvent =
new IntegrationEvent <BookingCreated>()
{
CorrelationId = Guid.NewGuid(),
EventCreationDate = DateTime.UtcNow,
EventId = Guid.NewGuid(),
EventType = _bookingEventType,
Version = _version,
Content = new BookingCreated
{
BookingName = _bookingName
}
};
var messagebytes = SerializeEvent(integrationEvent);
EventEmulator eventEmulator = null;
_mockBus.Setup(x => x.Consume(_mockQueue.Object,
It.IsAny <Func <byte[], MessageProperties, MessageReceivedInfo, Task> >(), It.IsAny <Action <IConsumerConfiguration> >()))
.Returns((IQueue queue, Func <byte[],
MessageProperties, MessageReceivedInfo, Task> func, Action <IConsumerConfiguration> configure) =>
{
eventEmulator = new EventEmulator(func);
return(_consumerDisposable.Object);
});
var mockSubscription = new Mock <ISubscription>();
mockSubscription.Setup(x => x.InvokeAsync(Encoding.UTF8.GetString(messagebytes))).Returns(Task.FromResult(true));
Dictionary <string, ISubscription> subscriptions = new Dictionary <string, ISubscription> {
{ "bookingcreated", mockSubscription.Object }
};
_subsciptionSelector.Setup(x => x.Select(subscriptions, "bookingcreated"))
.Returns((IDictionary <string, ISubscription> subs, string eventType) => mockSubscription.Object);
_easyNetQSubscriber.Subscribe(subscriptions);
//Act
MessageProperties messageProperties = new MessageProperties();
await eventEmulator.Execute(messagebytes, messageProperties, null);
//check
eventEmulator.RaisedException.Should().BeNull();
mockSubscription.Verify(x => x.InvokeAsync(Encoding.UTF8.GetString(messagebytes)), Times.Once);
mockSubscription.Verify(x => x.NotifyAboutDeadLetterAsync(It.IsAny <string>(), It.IsAny <Exception>()), Times.Never);
var parsedMessage = DefaultIntergrationEventParser.Parse(messagebytes);
var expectedEvent = parsedMessage.IntegrationEvent
.AsSource()
.OfLikeness <IntegrationEvent>()
.CreateProxy();
_successHandlingStrategy.Verify(x => x.HandleSuccessAsync(expectedEvent));
}
public async void Subscribe_DiscardEventException_WhenProcessed_ExceptionShouldBeThrown()
{
//prepare
var content = new BookingCreated()
{
BookingName = _bookingName
};
IntegrationEvent <BookingCreated> integrationEvent =
new IntegrationEvent <BookingCreated>
{
CorrelationId = Guid.NewGuid(),
EventCreationDate = DateTime.UtcNow,
EventId = Guid.NewGuid(),
EventType = _bookingEventType,
Version = _version,
Content = content
};
var messagebytes = SerializeEvent(integrationEvent);
EventEmulator eventEmulator = null;
_mockBus.Setup(x => x.Consume(_mockQueue.Object,
It.IsAny <Func <byte[], MessageProperties, MessageReceivedInfo, Task> >(),
It.IsAny <Action <IConsumerConfiguration> >()))
.Returns((IQueue queue, Func <byte[],
MessageProperties, MessageReceivedInfo, Task> func,
Action <IConsumerConfiguration> configure) =>
{
eventEmulator = new EventEmulator(func);
return(_consumerDisposable.Object);
});
DiscardEventException discardEventException = new DiscardEventException();
var mockSubscription = new Mock <ISubscription>();
mockSubscription.Setup(x => x.InvokeAsync(Encoding.UTF8.GetString(messagebytes)))
.Returns <string>(
(serilizedmessage) =>
{
return(Task.FromException <DiscardEventException>(discardEventException));
});
Dictionary <string, ISubscription> subscriptions = new Dictionary <string, ISubscription> {
{ "bookingcreated", mockSubscription.Object }
};
_subsciptionSelector.Setup(x => x.Select(subscriptions, "bookingcreated"))
.Returns((IDictionary <string, ISubscription> subs, string eventType) => mockSubscription.Object);
MessageProperties messageProperties = new MessageProperties();
MessageExecutionContext actualMessageExecutionContext = null;
_errorHandlingStrategy.Setup(x => x.HandleErrorAsync(It.IsAny <MessageExecutionContext>()))
.Returns <MessageExecutionContext>(
(messageExecutionContext) =>
{
actualMessageExecutionContext = messageExecutionContext;
return(Task.FromException <DiscardEventException>(messageExecutionContext.Exception));
});
_easyNetQSubscriber.Subscribe(subscriptions);
//Act
await eventEmulator.Execute(messagebytes, messageProperties, null);
//check
eventEmulator.RaisedException.GetType().Should().Be(typeof(DiscardEventException));
_successHandlingStrategy.Verify(x => x.HandleSuccessAsync(It.IsAny <IntegrationEvent>()), Times.Never);
_errorHandlingStrategy.Verify(x => x.HandleErrorAsync(It.IsAny <MessageExecutionContext>()), Times.Once);
actualMessageExecutionContext.BodyBytes.ShouldBeEquivalentTo(messagebytes);
actualMessageExecutionContext.Exception.Should().Be(eventEmulator.RaisedException);
actualMessageExecutionContext.MessageProperties.Should().Be(messageProperties);
actualMessageExecutionContext.IntergrationEventParsingResult.ShouldBeEquivalentTo(DefaultIntergrationEventParser.Parse(messagebytes));
actualMessageExecutionContext.SerializedMessage.Should().Be(Encoding.UTF8.GetString(messagebytes));
actualMessageExecutionContext.DeadLetterIntegrationEvent.Should().BeNull();
actualMessageExecutionContext.Subscription.Should().Be(mockSubscription.Object);
}
public async void Subscribe_MalformedEvent_ExceptionShouldBeThrown()
{
//prepare
var messagebytes = Encoding.UTF8.GetBytes(@"{
""Version"": ""0.1""
}");
EventEmulator eventEmulator = null;
_mockBus.Setup(x => x.Consume(_mockQueue.Object,
It.IsAny <Func <byte[], MessageProperties, MessageReceivedInfo, Task> >(),
It.IsAny <Action <IConsumerConfiguration> >()))
.Returns((IQueue queue, Func <byte[],
MessageProperties, MessageReceivedInfo, Task> func,
Action <IConsumerConfiguration> configure) =>
{
eventEmulator = new EventEmulator(func);
return(_consumerDisposable.Object);
});
Dictionary <string, ISubscription> subscriptions = new Dictionary <string, ISubscription>();
MessageProperties messageProperties = new MessageProperties();
MessageExecutionContext actualMessageExecutionContext = null;
_errorHandlingStrategy.Setup(x => x.HandleErrorAsync(
It.IsAny <MessageExecutionContext>()))
.Returns <MessageExecutionContext>(
(executionContext) =>
{
actualMessageExecutionContext = executionContext;
return(Task.FromException <MalformedEventException>(executionContext.Exception));
});
_easyNetQSubscriber.Subscribe(subscriptions);
//Act
await eventEmulator.Execute(messagebytes, messageProperties, null);
//check
((MalformedEventException)eventEmulator.RaisedException).
Errors.First().ShouldBeEquivalentTo("EventId token is missed");
_successHandlingStrategy.Verify(x => x.HandleSuccessAsync(It.IsAny <IntegrationEvent>()), Times.Never);
_errorHandlingStrategy.Verify(x => x.HandleErrorAsync(It.IsAny <MessageExecutionContext>()), Times.Once);
actualMessageExecutionContext.BodyBytes.ShouldBeEquivalentTo(messagebytes);
actualMessageExecutionContext.Exception.Should().Be(eventEmulator.RaisedException);
actualMessageExecutionContext.MessageProperties.Should().Be(messageProperties);
actualMessageExecutionContext.IntergrationEventParsingResult.ShouldBeEquivalentTo(DefaultIntergrationEventParser.Parse(messagebytes));
actualMessageExecutionContext.SerializedMessage.Should().BeNull();
actualMessageExecutionContext.DeadLetterIntegrationEvent.Should().BeNull();
actualMessageExecutionContext.Subscription.Should().BeNull();
}
public async void Subscribe_CorrectlyFormedEvent_NoConsumerForEventTypeMatched()
{
//prepare
IntegrationEvent <BookingCreated> integrationEvent =
new IntegrationEvent <BookingCreated>()
{
CorrelationId = Guid.NewGuid(),
EventCreationDate = DateTime.UtcNow,
EventId = Guid.NewGuid(),
EventType = _bookingEventType,
Version = _version,
Content = new BookingCreated
{
BookingName = _bookingName
}
};
var messagebytes = SerializeEvent(integrationEvent);
EventEmulator eventEmulator = null;
_mockBus.Setup(x => x.Consume(_mockQueue.Object,
It.IsAny <Func <byte[], MessageProperties, MessageReceivedInfo, Task> >(),
It.IsAny <Action <IConsumerConfiguration> >()))
.Returns((IQueue queue, Func <byte[],
MessageProperties, MessageReceivedInfo, Task> func, Action <IConsumerConfiguration> configure) =>
{
eventEmulator = new EventEmulator(func);
return(_consumerDisposable.Object);
});
Dictionary <string, ISubscription> subscriptions = new Dictionary <string, ISubscription>();
_subsciptionSelector.Setup(x => x.Select(subscriptions, _bookingEventType))
.Returns((IDictionary <string, ISubscription> subs, string eventType) => null);
MessageProperties messageProperties = new MessageProperties();
MessageExecutionContext actualMessageExecutionContext = null;
_errorHandlingStrategy.Setup(x => x.HandleErrorAsync(It.IsAny <MessageExecutionContext>()))
.Returns <MessageExecutionContext>(
(messageExecutionContext) =>
{
actualMessageExecutionContext = messageExecutionContext;
return(Task.FromException <DiscardEventException>(messageExecutionContext.Exception));
});
_easyNetQSubscriber.Subscribe(subscriptions);
//Act
await eventEmulator.Execute(messagebytes, messageProperties, null);
//check
_successHandlingStrategy.Verify(x => x.HandleSuccessAsync(It.IsAny <IntegrationEvent>()), Times.Never);
_errorHandlingStrategy.Verify(x => x.HandleErrorAsync(It.IsAny <MessageExecutionContext>()), Times.Once);
actualMessageExecutionContext.BodyBytes.ShouldBeEquivalentTo(messagebytes);
actualMessageExecutionContext.Exception.Should().Be(eventEmulator.RaisedException);
actualMessageExecutionContext.MessageProperties.Should().Be(messageProperties);
actualMessageExecutionContext.IntergrationEventParsingResult.ShouldBeEquivalentTo(DefaultIntergrationEventParser.Parse(messagebytes));
actualMessageExecutionContext.SerializedMessage.Should().BeNull();
actualMessageExecutionContext.DeadLetterIntegrationEvent.Should().BeNull();
actualMessageExecutionContext.Subscription.Should().BeNull();
eventEmulator.RaisedException.Should().BeOfType <DiscardEventException>().Which.Message
.ShouldBeEquivalentTo("The consumer for bookingcreated event type is not matched");
}
