public void Publish <T>(T[] events, string trackingId = null) where T : DomainEvent
{
if (!events.Any())
{
return;
}
;
_logger.InfoFormat("Publishing {0} events", events.Count());
var commands = new ICommand[events.Length];
for (var eventCount = 0; eventCount < events.Length; eventCount++)
{
var messagingCommand = DomainMessageTranslator.TranslateCommand(events[eventCount],
new CommandType(events[eventCount].GetType().Name));
_logger.DebugFormat("Translated {0} ", events[eventCount].GetType().Name);
messagingCommand.TrackingId = trackingId;
var json = JsonConvert.SerializeObject(events[eventCount], Formatting.Indented, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All
});
_logger.InfoFormat("{0} Id:{1}, Tracking: {2}", events[eventCount].GetType().Name, events[eventCount].Id, trackingId);
_logger.Debug(json);
_resultPublisher.Publish(new DomainResult(events[eventCount], ResultCode.Unknown));
commands[eventCount] = messagingCommand;
}
_commandQueue.QueueCommand(commands);
}
public void CommandsWithSameIdAreQueued()
{
var concurrentCommands = 100;
var commands = new List <TrackedCommand>();
for (var count = 0; count < concurrentCommands; count++)
{
commands.Add(DomainMessageTranslator.TranslateCommand(new TestDomainCommand(),
new CommandType("TestDomainCommand")));
}
Parallel.For(0, concurrentCommands, count =>
{
_eventHandler.Dispatch(commands[count]);
});
Thread.Sleep(100);
Assert.AreEqual(concurrentCommands, _handleCommandInstance.Handled.Count);
Assert.AreEqual("TestDomainCommand", _handleCommandInstance.Handled.First());
var times = _handleCommandInstance.Times.OrderBy(x => x.Item1.Ticks).ToArray();
for (var count = 0; count < concurrentCommands - 1; count++)
{
Assert.IsTrue(times[count].Item1.Ticks < times[count].Item2.Ticks);
Assert.IsTrue(times[count + 1].Item1.Ticks < times[count + 1].Item2.Ticks);
Assert.IsTrue(times[count].Item2.Ticks <= times[count + 1].Item1.Ticks);
}
}
public void CommandHandlerIsCalled()
{
var testCommand = DomainMessageTranslator.TranslateCommand(new TestDomainCommand(), new CommandType("TestDomainCommand"));
Assert.IsTrue(_eventHandler.Dispatch(testCommand));
Assert.AreEqual(1, _handleCommandInstance.Handled.Count);
Assert.AreEqual("TestDomainCommand", _handleCommandInstance.Handled.First());
}
public void EventHandlerIsCalled()
{
var testEvent = DomainMessageTranslator.TranslateCommand(new TestDomainEvent(Guid.NewGuid()), new CommandType("TestDomainEvent"));
Assert.IsTrue(_eventHandler.Dispatch(testEvent));
Assert.AreEqual(1, _eventInstance.Handled.Count);
Assert.AreEqual("TestDomainEvent", _eventInstance.Handled.First());
}
private TrackedCommand SendCommand <T>(T command) where T : IDomainCommand
{
var messagingCommand = DomainMessageTranslator.TranslateCommand(command, new CommandType(command.GetType().Name));
_resultPublisher.Publish(new DomainResult(command, ResultCode.Unknown));
_logger.InfoFormat("Queuing {0}", command.GetType());
_commandQueue.QueueCommand(messagingCommand);
return(messagingCommand);
}
public void ProperlyHandleCommandThrowingException()
{
DomainResult result = null;
_resultPublisherMock.Setup(x => x.Publish(It.IsAny <DomainResult>())).Callback <DomainResult>(r => result = r);
var testCommand = DomainMessageTranslator.TranslateCommand(new TestDomainEvent4(Guid.NewGuid()),
new CommandType("TestDomainEvent4"));
Assert.IsTrue(_eventHandler.Dispatch(testCommand));
Assert.IsFalse(_handleCommandInstance.Handled.Any());
Assert.AreEqual(ResultCode.Failed, result.ResultCode);
}
public bool Dispatch(ICommand message)
{
_logger.InfoFormat("Dispatching message {0}", message.Type.Value);
InitCache();
HandlerStore handlerStore;
_handlersCache.TryGetValue(message.Type.Value, out handlerStore);
if (handlerStore != null)
{
var cqrsMessage = DomainMessageTranslator.TranslateCommand(message, handlerStore.CqrsMessageType);
if (cqrsMessage is IDomainCommand)
{
_logger.DebugFormat("Handling command");
HandleCommand(handlerStore, cqrsMessage as IDomainCommand);
}
else
{
_logger.DebugFormat("Handling event");
HandleMessage(handlerStore, cqrsMessage);
}
}
else
{
var cqrsMessage = DomainMessageTranslator.TranslateCommand(message, typeof(GenericDomainMessage));
_logger.DebugFormat("No known handler for {0}, returning", message.Type.Value);
var cqrsResult = new DomainResult
{
Id = message.Id,
TrackingId = cqrsMessage.TrackingId,
ResultCode = ResultCode.OK
};
_resultPublisher.Publish(cqrsResult);
}
return(true);
}
