public void event_publisher_failed_test()
{
var command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
((MockDomainEventPublisher)_domainEventPublisher).SetExpectFailedCount(FailedType.UnKnownException, 5);
var commandResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
((MockDomainEventPublisher)_domainEventPublisher).Reset();
command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
((MockDomainEventPublisher)_domainEventPublisher).SetExpectFailedCount(FailedType.IOException, 5);
commandResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
((MockDomainEventPublisher)_domainEventPublisher).Reset();
}
public void change_multiple_aggregates_test()
{
var command1 = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note1"
};
_commandService.ExecuteAsync(command1).Wait();
var command2 = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note2"
};
_commandService.ExecuteAsync(command2).Wait();
var command3 = new ChangeMultipleAggregatesCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
AggregateRootId1 = command1.AggregateRootId,
AggregateRootId2 = command2.AggregateRootId
};
var commandResult = _commandService.ExecuteAsync(command3).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
}
public void domain_exception_publisher_throw_exception_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
_commandService.ExecuteAsync(command).Wait();
var command1 = new AggregateThrowExceptionCommand
{
AggregateRootId = aggregateId,
IsDomainException = true
};
((MockDomainExceptionPublisher)_domainExceptionPublisher).SetExpectFailedCount(FailedType.UnKnownException, 5);
var commandResult = _commandService.ExecuteAsync(command1).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
((MockDomainExceptionPublisher)_domainExceptionPublisher).Reset();
((MockDomainExceptionPublisher)_domainExceptionPublisher).SetExpectFailedCount(FailedType.IOException, 5);
commandResult = _commandService.ExecuteAsync(command1).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
((MockDomainExceptionPublisher)_domainExceptionPublisher).Reset();
}
public void create_and_update_aggregate_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var commandResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//执行修改聚合根的命令
var command2 = new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note"
};
commandResult = _commandService.ExecuteAsync(command2).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Changed Note", note.Title);
Assert.AreEqual(2, ((IAggregateRoot)note).Version);
}
public void aggregate_throw_exception_command_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
_commandService.ExecuteAsync(command).Wait();
var command1 = new AggregateThrowExceptionCommand
{
AggregateRootId = aggregateId,
IsDomainException = false
};
var commandResult = _commandService.ExecuteAsync(command1).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
var command2 = new AggregateThrowExceptionCommand
{
AggregateRootId = aggregateId,
IsDomainException = true
};
commandResult = _commandService.ExecuteAsync(command2).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
}
public void event_handler_priority_test()
{
var noteId = ObjectId.GenerateNewStringId();
var command1 = new CreateTestAggregateCommand {
AggregateRootId = noteId, Title = "Sample Title1"
};
var command2 = new TestEventPriorityCommand {
AggregateRootId = noteId
};
_commandService.ExecuteAsync(command1, CommandReturnType.EventHandled).Wait();
_commandService.ExecuteAsync(command2, CommandReturnType.EventHandled).Wait();
Assert.AreEqual(9, HandlerTypes.Count);
Assert.AreEqual(typeof(Handler3).Name, HandlerTypes[0]);
Assert.AreEqual(typeof(Handler2).Name, HandlerTypes[1]);
Assert.AreEqual(typeof(Handler1).Name, HandlerTypes[2]);
Assert.AreEqual(typeof(Handler122).Name, HandlerTypes[3]);
Assert.AreEqual(typeof(Handler121).Name, HandlerTypes[4]);
Assert.AreEqual(typeof(Handler123).Name, HandlerTypes[5]);
Assert.AreEqual(typeof(Handler1232).Name, HandlerTypes[6]);
Assert.AreEqual(typeof(Handler1231).Name, HandlerTypes[7]);
Assert.AreEqual(typeof(Handler1233).Name, HandlerTypes[8]);
HandlerTypes.Clear();
}
public void published_version_store_failed_test()
{
var mockPublishedVersionStore = _publishedVersionStore as MockPublishedVersionStore;
var command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
mockPublishedVersionStore.SetExpectFailedCount(FailedType.UnKnownException, 5);
var commandResult = _commandService.ExecuteAsync(command, CommandReturnType.EventHandled).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
mockPublishedVersionStore.Reset();
command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
mockPublishedVersionStore.SetExpectFailedCount(FailedType.IOException, 5);
commandResult = _commandService.ExecuteAsync(command, CommandReturnType.EventHandled).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
mockPublishedVersionStore.Reset();
}
public void event_handler_priority_test()
{
var noteId = ObjectId.GenerateNewStringId();
var command1 = new CreateTestAggregateCommand {
AggregateRootId = noteId, Title = "Sample Title1"
};
var command2 = new TestEventPriorityCommand {
AggregateRootId = noteId
};
var commandResult1 = _commandService.ExecuteAsync(command1, CommandReturnType.EventHandled).Result;
var commandResult2 = _commandService.ExecuteAsync(command2, CommandReturnType.EventHandled).Result;
Thread.Sleep(3000);
Assert.AreEqual(CommandStatus.Success, commandResult1.Status);
Assert.AreEqual(CommandStatus.Success, commandResult2.Status);
Assert.AreEqual(3, HandlerTypes[1].Count);
Assert.AreEqual(typeof(Handler3).Name, HandlerTypes[1][0]);
Assert.AreEqual(typeof(Handler2).Name, HandlerTypes[1][1]);
Assert.AreEqual(typeof(Handler1).Name, HandlerTypes[1][2]);
Assert.AreEqual(3, HandlerTypes[2].Count);
Assert.AreEqual(typeof(Handler122).Name, HandlerTypes[2][0]);
Assert.AreEqual(typeof(Handler121).Name, HandlerTypes[2][1]);
Assert.AreEqual(typeof(Handler123).Name, HandlerTypes[2][2]);
Assert.AreEqual(3, HandlerTypes[3].Count);
Assert.AreEqual(typeof(Handler1232).Name, HandlerTypes[3][0]);
Assert.AreEqual(typeof(Handler1231).Name, HandlerTypes[3][1]);
Assert.AreEqual(typeof(Handler1233).Name, HandlerTypes[3][2]);
HandlerTypes.Clear();
}
public void create_and_update_dirty_aggregate_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var commandResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
var directUpdateEventStoreCommandId = ObjectId.GenerateNewStringId();
var eventStore = ObjectContainer.Resolve <IEventStore>();
var publishedVersionStore = ObjectContainer.Resolve <IPublishedVersionStore>();
var eventStreamList = new List <DomainEventStream>();
var evnts = new List <IDomainEvent>();
var evnt = new TestAggregateTitleChanged("Note Title2")
{
AggregateRootId = aggregateId,
AggregateRootTypeName = typeof(TestAggregate).FullName,
CommandId = directUpdateEventStoreCommandId,
Version = 2
};
evnts.Add(evnt);
var eventStream = new DomainEventStream(ObjectId.GenerateNewStringId(), aggregateId, typeof(TestAggregate).FullName, DateTime.UtcNow, evnts);
eventStreamList.Add(eventStream);
eventStore.BatchAppendAsync(eventStreamList).Wait();
var eventProcessorName = ENodeConfiguration.Instance.Setting.DomainEventProcessorName;
publishedVersionStore.UpdatePublishedVersionAsync(eventProcessorName, typeof(TestAggregate).FullName, aggregateId, 2).Wait();
//执行修改聚合根的命令
var command2 = new ChangeTestAggregateTitleWhenDirtyCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note",
IsFirstExecute = true
};
commandResult = _commandService.ExecuteAsync(command2, CommandReturnType.EventHandled).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Changed Note", note.Title);
Assert.AreEqual(3, ((IAggregateRoot)note).Version);
}
public void create_and_concurrent_update_aggregate_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//并发执行修改聚合根的命令
var totalCount = 100;
var finishedCount = 0;
var waitHandle = new ManualResetEvent(false);
for (var i = 0; i < totalCount; i++)
{
var updateCommand = new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note"
};
_commandService.ExecuteAsync(updateCommand).ContinueWith(t =>
{
var result = t.Result;
Assert.IsNotNull(result);
Assert.AreEqual(AsyncTaskStatus.Success, result.Status);
Assert.IsNotNull(result.Data);
Assert.AreEqual(CommandStatus.Success, result.Data.Status);
var current = Interlocked.Increment(ref finishedCount);
if (current == totalCount)
{
note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Changed Note", note.Title);
Assert.AreEqual(totalCount + 1, ((IAggregateRoot)note).Version);
waitHandle.Set();
}
});
}
waitHandle.WaitOne();
}
public void duplicate_create_aggregate_command_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//用同一个命令再次执行创建聚合根的命令
asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//用另一个命令再次执行创建相同聚合根的命令
command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
}
public void event_store_failed_test()
{
var mockEventStore = _eventStore as MockEventStore;
var command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
mockEventStore.SetExpectFailedCount(FailedType.UnKnownException, 5);
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
mockEventStore.Reset();
command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
mockEventStore.SetExpectFailedCount(FailedType.IOException, 5);
asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
mockEventStore.Reset();
command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
mockEventStore.SetExpectFailedCount(FailedType.TaskIOException, 5);
asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
mockEventStore.Reset();
}
public void duplicate_update_aggregate_command_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command1 = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//先创建一个聚合根
var status = _commandService.ExecuteAsync(command1).Result.Data.Status;
Assert.AreEqual(CommandStatus.Success, status);
var command2 = new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note"
};
//执行修改聚合根的命令
var asyncResult = _commandService.ExecuteAsync(command2, CommandReturnType.EventHandled).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Changed Note", note.Title);
Assert.AreEqual(2, ((IAggregateRoot)note).Version);
//在重复执行该命令
asyncResult = _commandService.ExecuteAsync(command2).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Changed Note", note.Title);
Assert.AreEqual(2, ((IAggregateRoot)note).Version);
}
public void published_version_store_failed_test()
{
var mockPublishedVersionStore = _publishedVersionStore as MockPublishedVersionStore;
var command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
mockPublishedVersionStore.SetExpectFailedCount(FailedType.UnKnownException, 5);
var asyncResult = _commandService.ExecuteAsync(command, CommandReturnType.EventHandled).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
mockPublishedVersionStore.Reset();
command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
mockPublishedVersionStore.SetExpectFailedCount(FailedType.IOException, 5);
asyncResult = _commandService.ExecuteAsync(command, CommandReturnType.EventHandled).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
mockPublishedVersionStore.Reset();
command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
mockPublishedVersionStore.SetExpectFailedCount(FailedType.TaskIOException, 5);
asyncResult = _commandService.ExecuteAsync(command, CommandReturnType.EventHandled).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
mockPublishedVersionStore.Reset();
}
public void event_publisher_failed_test()
{
var command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
((MockDomainEventPublisher)_domainEventPublisher).SetExpectFailedCount(FailedType.UnKnownException, 5);
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
((MockDomainEventPublisher)_domainEventPublisher).Reset();
command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
((MockDomainEventPublisher)_domainEventPublisher).SetExpectFailedCount(FailedType.IOException, 5);
asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
((MockDomainEventPublisher)_domainEventPublisher).Reset();
command = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note"
};
((MockDomainEventPublisher)_domainEventPublisher).SetExpectFailedCount(FailedType.TaskIOException, 5);
asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
((MockDomainEventPublisher)_domainEventPublisher).Reset();
}
public void publishable_exception_publisher_throw_exception_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
_commandService.ExecuteAsync(command).Wait();
var command1 = new AggregateThrowExceptionCommand
{
AggregateRootId = aggregateId,
PublishableException = true
};
((MockPublishableExceptionPublisher)_publishableExceptionPublisher).SetExpectFailedCount(FailedType.UnKnownException, 5);
var asyncResult = _commandService.ExecuteAsync(command1).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
((MockPublishableExceptionPublisher)_publishableExceptionPublisher).Reset();
((MockPublishableExceptionPublisher)_publishableExceptionPublisher).SetExpectFailedCount(FailedType.IOException, 5);
asyncResult = _commandService.ExecuteAsync(command1).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
((MockPublishableExceptionPublisher)_publishableExceptionPublisher).Reset();
((MockPublishableExceptionPublisher)_publishableExceptionPublisher).SetExpectFailedCount(FailedType.TaskIOException, 5);
asyncResult = _commandService.ExecuteAsync(command1).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
((MockPublishableExceptionPublisher)_publishableExceptionPublisher).Reset();
}
public void command_sync_execute_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note",
SleepMilliseconds = 3000
};
//执行创建聚合根的命令
var commandResult = _commandService.Execute(command, 5000);
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.Get<TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
}
public void event_handler_priority_test()
{
var noteId = ObjectId.GenerateNewStringId();
var command1 = new CreateTestAggregateCommand { AggregateRootId = noteId, Title = "Sample Title1" };
var command2 = new TestEventPriorityCommand { AggregateRootId = noteId };
_commandService.ExecuteAsync(command1, CommandReturnType.EventHandled).Wait();
_commandService.ExecuteAsync(command2, CommandReturnType.EventHandled).Wait();
Assert.AreEqual(9, HandlerTypes.Count);
Assert.AreEqual(typeof(Handler3).Name, HandlerTypes[0]);
Assert.AreEqual(typeof(Handler2).Name, HandlerTypes[1]);
Assert.AreEqual(typeof(Handler1).Name, HandlerTypes[2]);
Assert.AreEqual(typeof(Handler122).Name, HandlerTypes[3]);
Assert.AreEqual(typeof(Handler121).Name, HandlerTypes[4]);
Assert.AreEqual(typeof(Handler123).Name, HandlerTypes[5]);
Assert.AreEqual(typeof(Handler1232).Name, HandlerTypes[6]);
Assert.AreEqual(typeof(Handler1231).Name, HandlerTypes[7]);
Assert.AreEqual(typeof(Handler1233).Name, HandlerTypes[8]);
HandlerTypes.Clear();
}
public void command_sync_execute_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note",
SleepMilliseconds = 3000
};
//执行创建聚合根的命令
var commandResult = _commandService.Execute(command, 5000);
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.Get <TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
}
public async Task send_concurrent_command_test()
{
ThreadPool.SetMinThreads(1, 1);
ThreadPool.SetMaxThreads(2, 2);
var tasks = new List <Task <CommandResult> >();
for (int i = 0; i < 1000; i++)
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
tasks.Add(_commandService.ExecuteAsync(command, CommandReturnType.EventHandled));
}
await Task.WhenAll(tasks);
}
public void aggregate_throw_exception_command_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
_commandService.ExecuteAsync(command).Wait();
var command1 = new AggregateThrowExceptionCommand
{
AggregateRootId = aggregateId,
PublishableException = false
};
var asyncResult = _commandService.ExecuteAsync(command1).Result;
Assert.NotNull(asyncResult);
Assert.Equal(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.NotNull(commandResult);
Assert.Equal(CommandStatus.Failed, commandResult.Status);
var command2 = new AggregateThrowExceptionCommand
{
AggregateRootId = aggregateId,
PublishableException = true
};
asyncResult = _commandService.ExecuteAsync(command2).Result;
Assert.NotNull(asyncResult);
Assert.Equal(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.NotNull(commandResult);
Assert.Equal(CommandStatus.Failed, commandResult.Status);
}
public async Task command_sync_execute_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note",
SleepMilliseconds = 3000
};
//执行创建聚合根的命令
var commandResult = await _commandService.ExecuteAsync(command);
Assert.NotNull(commandResult);
Assert.Equal(CommandStatus.Success, commandResult.Status);
var note = await _memoryCache.GetAsync <TestAggregate>(aggregateId);
Assert.NotNull(note);
Assert.Equal("Sample Note", note.Title);
Assert.Equal(1, ((IAggregateRoot)note).Version);
//执行修改聚合根的命令
var command2 = new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note"
};
commandResult = await _commandService.ExecuteAsync(command2);
Assert.NotNull(commandResult);
Assert.Equal(CommandStatus.Success, commandResult.Status);
note = await _memoryCache.GetAsync <TestAggregate>(aggregateId);
Assert.NotNull(note);
Assert.Equal("Changed Note", note.Title);
Assert.Equal(2, ((IAggregateRoot)note).Version);
}
public void create_and_update_aggregate_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.Get<TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//执行修改聚合根的命令
var command2 = new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note"
};
asyncResult = _commandService.ExecuteAsync(command2).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
note = _memoryCache.Get<TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual("Changed Note", note.Title);
Assert.AreEqual(2, ((IAggregateRoot)note).Version);
}
public void command_sync_execute_timeout_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note",
SleepMilliseconds = 5000
};
//执行创建聚合根的命令
var isTimeout = false;
try
{
var commandResult = _commandService.Execute(command, 3000);
}
catch (CommandExecuteTimeoutException)
{
isTimeout = true;
}
Assert.IsTrue(isTimeout);
}
public void create_concurrent_conflict_and_then_update_many_times_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var commandId = ObjectId.GenerateNewStringId();
//往EventStore直接插入事件，用于模拟并发冲突的情况
var eventStream = new DomainEventStream(
commandId,
aggregateId,
typeof(TestAggregate).FullName,
1,
DateTime.Now,
new IDomainEvent[] { new TestAggregateTitleChanged("Note Title")
{
AggregateRootId = aggregateId, Version = 1
} },
null);
var result = _eventStore.AppendAsync(eventStream).Result;
Assert.IsNotNull(result);
Assert.AreEqual(AsyncTaskStatus.Success, result.Status);
Assert.AreEqual(EventAppendResult.Success, result.Data);
_logger.Info("----create_concurrent_conflict_and_then_update_many_times_test, _eventStore.AppendAsync success");
var result2 = _publishedVersionStore.UpdatePublishedVersionAsync("DefaultEventProcessor", typeof(TestAggregate).FullName, aggregateId, 1).Result;
Assert.IsNotNull(result2);
Assert.AreEqual(AsyncTaskStatus.Success, result2.Status);
_logger.Info("----create_concurrent_conflict_and_then_update_many_times_test, UpdatePublishedVersionAsync success");
//执行创建聚合根的命令
var command = new CreateTestAggregateCommand
{
Id = commandId,
AggregateRootId = aggregateId,
Title = "Sample Note"
};
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
_logger.Info("----create_concurrent_conflict_and_then_update_many_times_test, _commandService.ExecuteAsync create success");
var commandList = new List <ICommand>();
for (var i = 0; i < 50; i++)
{
commandList.Add(new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note Title"
});
}
var waitHandle = new ManualResetEvent(false);
var count = 0L;
foreach (var updateCommand in commandList)
{
_commandService.ExecuteAsync(updateCommand).ContinueWith(t =>
{
Assert.IsNotNull(t.Result);
Assert.AreEqual(AsyncTaskStatus.Success, t.Result.Status);
var updateCommandResult = t.Result.Data;
Assert.IsNotNull(updateCommandResult);
Assert.AreEqual(CommandStatus.Success, updateCommandResult.Status);
var totalCount = Interlocked.Increment(ref count);
_logger.InfoFormat("----create_concurrent_conflict_and_then_update_many_times_test, updateCommand finished, count: {0}", totalCount);
if (totalCount == commandList.Count)
{
waitHandle.Set();
}
});
}
waitHandle.WaitOne();
var note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual(commandList.Count + 1, ((IAggregateRoot)note).Version);
}
public void update_concurrent_conflict_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var commandResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//往EventStore直接插入事件，用于模拟并发冲突的情况
var eventStream = new DomainEventStream(
ObjectId.GenerateNewStringId(),
aggregateId,
typeof(TestAggregate).FullName,
DateTime.Now,
new IDomainEvent[] { new TestAggregateTitleChanged("Changed Title")
{
AggregateRootId = aggregateId, Version = 2
} },
null);
var result = _eventStore.BatchAppendAsync(new DomainEventStream[] { eventStream }).Result;
Assert.IsNotNull(result);
Assert.AreEqual(aggregateId, result.SuccessAggregateRootIdList[0]);
_publishedVersionStore.UpdatePublishedVersionAsync("DefaultEventProcessor", typeof(TestAggregate).FullName, aggregateId, 2).Wait();
var commandList = new List <ICommand>();
for (var i = 0; i < 50; i++)
{
commandList.Add(new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note2"
});
}
var waitHandle = new ManualResetEvent(false);
var count = 0L;
foreach (var updateCommand in commandList)
{
_commandService.ExecuteAsync(updateCommand).ContinueWith(t =>
{
Assert.IsNotNull(t.Result);
var currentCommandResult = t.Result;
Assert.IsNotNull(currentCommandResult);
Assert.AreEqual(CommandStatus.Success, currentCommandResult.Status);
var totalCount = Interlocked.Increment(ref count);
if (totalCount == commandList.Count)
{
waitHandle.Set();
}
});
}
waitHandle.WaitOne();
note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual(2 + commandList.Count, ((IAggregateRoot)note).Version);
Assert.AreEqual("Changed Note2", note.Title);
}
public void update_concurrent_conflict_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.Get <TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//往EventStore直接插入事件，用于模拟并发冲突的情况
var eventStream = new DomainEventStream(
ObjectId.GenerateNewStringId(),
aggregateId,
typeof(TestAggregate).FullName,
2,
DateTime.Now,
new IDomainEvent[] { new TestAggregateTitleChanged("Changed Title")
{
AggregateRootId = aggregateId, Version = 2
} },
null);
var result = _eventStore.AppendAsync(eventStream).Result;
Assert.IsNotNull(result);
Assert.AreEqual(AsyncTaskStatus.Success, result.Status);
Assert.AreEqual(EventAppendResult.Success, result.Data);
var result2 = _publishedVersionStore.UpdatePublishedVersionAsync("DefaultEventProcessor", typeof(TestAggregate).FullName, aggregateId, 2).Result;
Assert.IsNotNull(result2);
Assert.AreEqual(AsyncTaskStatus.Success, result2.Status);
//执行修改聚合根的命令
var command2 = new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note2"
};
asyncResult = _commandService.ExecuteAsync(command2).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
note = _memoryCache.Get <TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual(3, ((IAggregateRoot)note).Version);
Assert.AreEqual("Changed Note2", note.Title);
}
public void update_concurrent_conflict_not_enable_batch_insert_test()
{
_eventStore.SupportBatchAppendEvent = false;
try
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.Get<TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//往EventStore直接插入事件，用于模拟并发冲突的情况
var eventStream = new DomainEventStream(
ObjectId.GenerateNewStringId(),
aggregateId,
typeof(TestAggregate).FullName,
2,
DateTime.Now,
new IDomainEvent[] { new TestAggregateTitleChanged("Changed Title") { AggregateRootId = aggregateId, Version = 2 } },
null);
var result = _eventStore.AppendAsync(eventStream).Result;
Assert.IsNotNull(result);
Assert.AreEqual(AsyncTaskStatus.Success, result.Status);
Assert.AreEqual(EventAppendResult.Success, result.Data);
var result2 = _publishedVersionStore.UpdatePublishedVersionAsync("DefaultEventProcessor", typeof(TestAggregate).FullName, aggregateId, 2).Result;
Assert.IsNotNull(result2);
Assert.AreEqual(AsyncTaskStatus.Success, result2.Status);
//执行修改聚合根的命令
var command2 = new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note2"
};
asyncResult = _commandService.ExecuteAsync(command2).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
note = _memoryCache.Get<TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual(3, ((IAggregateRoot)note).Version);
Assert.AreEqual("Changed Note2", note.Title);
}
finally
{
_eventStore.SupportBatchAppendEvent = true;
}
}
public void create_concurrent_conflict_and_then_update_many_times_not_enable_batch_insert_test()
{
_eventStore.SupportBatchAppendEvent = false;
try
{
var aggregateId = ObjectId.GenerateNewStringId();
var commandId = ObjectId.GenerateNewStringId();
//往EventStore直接插入事件，用于模拟并发冲突的情况
var eventStream = new DomainEventStream(
commandId,
aggregateId,
typeof(TestAggregate).FullName,
1,
DateTime.Now,
new IDomainEvent[] { new TestAggregateTitleChanged("Note Title") { AggregateRootId = aggregateId, Version = 1 } },
null);
var result = _eventStore.AppendAsync(eventStream).Result;
Assert.IsNotNull(result);
Assert.AreEqual(AsyncTaskStatus.Success, result.Status);
Assert.AreEqual(EventAppendResult.Success, result.Data);
var result2 = _publishedVersionStore.UpdatePublishedVersionAsync("DefaultEventProcessor", typeof(TestAggregate).FullName, aggregateId, 1).Result;
Assert.IsNotNull(result2);
Assert.AreEqual(AsyncTaskStatus.Success, result2.Status);
//执行创建聚合根的命令
var command = new CreateTestAggregateCommand
{
Id = commandId,
AggregateRootId = aggregateId,
Title = "Sample Note"
};
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var commandList = new List<ICommand>();
for (var i = 0; i < 5000; i++)
{
commandList.Add(new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note Title"
});
}
var waitHandle = new ManualResetEvent(false);
var count = 0L;
foreach (var updateCommand in commandList)
{
_commandService.ExecuteAsync(updateCommand).ContinueWith(t =>
{
Assert.IsNotNull(t.Result);
Assert.AreEqual(AsyncTaskStatus.Success, t.Result.Status);
var updateCommandResult = t.Result.Data;
Assert.IsNotNull(updateCommandResult);
Assert.AreEqual(CommandStatus.Success, updateCommandResult.Status);
var totalCount = Interlocked.Increment(ref count);
if (totalCount == commandList.Count)
{
waitHandle.Set();
}
});
}
waitHandle.WaitOne();
var note = _memoryCache.Get<TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual(commandList.Count + 1, ((IAggregateRoot)note).Version);
}
finally
{
_eventStore.SupportBatchAppendEvent = true;
}
}
public void aggregate_throw_exception_command_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
_commandService.ExecuteAsync(command).Wait();
var command1 = new AggregateThrowExceptionCommand
{
AggregateRootId = aggregateId,
PublishableException = false
};
var asyncResult = _commandService.ExecuteAsync(command1).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
var command2 = new AggregateThrowExceptionCommand
{
AggregateRootId = aggregateId,
PublishableException = true
};
asyncResult = _commandService.ExecuteAsync(command2).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
}
public void change_multiple_aggregates_test()
{
var command1 = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note1"
};
_commandService.ExecuteAsync(command1).Wait();
var command2 = new CreateTestAggregateCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Title = "Sample Note2"
};
_commandService.ExecuteAsync(command2).Wait();
var command3 = new ChangeMultipleAggregatesCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
AggregateRootId1 = command1.AggregateRootId,
AggregateRootId2 = command2.AggregateRootId
};
var asyncResult = _commandService.ExecuteAsync(command3).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
}
public void create_concurrent_conflict_not_enable_batch_insert_test()
{
_eventStore.SupportBatchAppendEvent = false;
try
{
var aggregateId = ObjectId.GenerateNewStringId();
var commandId = ObjectId.GenerateNewStringId();
//往EventStore直接插入事件，用于模拟并发冲突的情况
var eventStream = new DomainEventStream(
commandId,
aggregateId,
typeof(TestAggregate).FullName,
1,
DateTime.Now,
new IDomainEvent[] { new TestAggregateTitleChanged("Note Title")
{
AggregateRootId = aggregateId, Version = 1
} },
null);
var result = _eventStore.AppendAsync(eventStream).Result;
Assert.IsNotNull(result);
Assert.AreEqual(AsyncTaskStatus.Success, result.Status);
Assert.AreEqual(EventAppendResult.Success, result.Data);
var result2 = _publishedVersionStore.UpdatePublishedVersionAsync("DefaultEventProcessor", typeof(TestAggregate).FullName, aggregateId, 1).Result;
Assert.IsNotNull(result2);
Assert.AreEqual(AsyncTaskStatus.Success, result2.Status);
//执行创建聚合根的命令
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Failed, commandResult.Status);
Assert.AreEqual("Duplicate aggregate creation.", commandResult.Result);
var note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Note Title", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//执行创建聚合根的命令
command = new CreateTestAggregateCommand
{
Id = commandId,
AggregateRootId = aggregateId,
Title = "Sample Note"
};
asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
note = _memoryCache.GetAsync <TestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Note Title", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
}
finally
{
_eventStore.SupportBatchAppendEvent = true;
}
}
public void command_sync_execute_timeout_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note",
SleepMilliseconds = 5000
};
//执行创建聚合根的命令
var isTimeout = false;
try
{
var commandResult = _commandService.Execute(command, 3000);
}
catch (CommandExecuteTimeoutException)
{
isTimeout = true;
}
Assert.IsTrue(isTimeout);
}
public void duplicate_update_aggregate_command_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command1 = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//先创建一个聚合根
var status = _commandService.ExecuteAsync(command1).Result.Data.Status;
Assert.AreEqual(CommandStatus.Success, status);
var command2 = new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note"
};
//执行修改聚合根的命令
var asyncResult = _commandService.ExecuteAsync(command2, CommandReturnType.EventHandled).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.Get<TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual("Changed Note", note.Title);
Assert.AreEqual(2, ((IAggregateRoot)note).Version);
//在重复执行该命令
asyncResult = _commandService.ExecuteAsync(command2).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
note = _memoryCache.Get<TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual("Changed Note", note.Title);
Assert.AreEqual(2, ((IAggregateRoot)note).Version);
}
public void create_and_concurrent_update_aggregate_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.Get<TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//并发执行修改聚合根的命令
var totalCount = 100;
var finishedCount = 0;
var waitHandle = new ManualResetEvent(false);
for (var i = 0; i < totalCount; i++)
{
var updateCommand = new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note"
};
_commandService.ExecuteAsync(updateCommand).ContinueWith(t =>
{
var result = t.Result;
Assert.IsNotNull(result);
Assert.AreEqual(AsyncTaskStatus.Success, result.Status);
Assert.IsNotNull(result.Data);
Assert.AreEqual(CommandStatus.Success, result.Data.Status);
var current = Interlocked.Increment(ref finishedCount);
if (current == totalCount)
{
note = _memoryCache.Get<TestAggregate>(aggregateId);
Assert.IsNotNull(note);
Assert.AreEqual("Changed Note", note.Title);
Assert.AreEqual(totalCount + 1, ((IAggregateRoot)note).Version);
waitHandle.Set();
}
});
}
waitHandle.WaitOne();
}
