public void handler_throw_exception_command_test()
{
var command = new ThrowExceptionCommand
{
AggregateRootId = ObjectId.GenerateNewStringId()
};
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);
}
public void change_nothing_test()
{
var command = new ChangeNothingCommand
{
AggregateRootId = ObjectId.GenerateNewStringId()
};
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.NothingChanged, commandResult.Status);
}
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 async Task <ActionResult> Create(CreateSectionModel model)
{
if (_contextService.GetCurrentAccount(HttpContext).AccountName != "admin")
{
return(Json(new { success = false, errorMsg = "只有系统管理员才能新建版块。" }));
}
var result = await _commandService.ExecuteAsync(new CreateSectionCommand(ObjectId.GenerateNewStringId(), model.Name, model.Description));
if (result.Status == CommandStatus.Failed)
{
return(Json(new { success = false, errorMsg = result.Result }));
}
return(Json(new { success = true }));
}
public async Task <ActionResult> Create(CreateSectionModel model)
{
if (_contextService.CurrentAccount.AccountName != "admin")
{
return(Json(new { success = false, errorMsg = "只有系统管理员才能新建版块。" }));
}
var result = await _commandService.SendAsync(new CreateSectionCommand(ObjectId.GenerateNewStringId(), model.Name));
if (result.Status != AsyncTaskStatus.Success)
{
return(Json(new { success = false, errorMsg = result.ErrorMessage }));
}
return(Json(new { success = true }));
}
public async Task Should_Insert_Published_Version()
{
//Arrange
var processName = "test1";
var aggregateId = ObjectId.GenerateNewStringId();
var aggregateTypeName = _typeNameProvider.GetTypeName(typeof(Product));
var version = 1;
//Act
await _store.UpdatePublishedVersionAsync(processName, aggregateTypeName, aggregateId, version);
//Assert
var publishedVersion = await _store.GetPublishedVersionAsync(processName, aggregateTypeName, aggregateId);
publishedVersion.ShouldBe(version);
}
// POST: api/User
public async Task <HandleResult> Post([FromBody] CreateUserDto dto)
{
var command = new CreateUser(
ObjectId.GenerateNewStringId(),
ObjectId.GenerateNewStringId(),
dto.AppSystemId,
dto.UserName,
dto.ReMark);
var result = await ExecuteCommandAsync(command);
if (result.IsSuccess())
{
return(HandleResult.FromSuccess("创建成功", command.Code));
}
return(HandleResult.FromFail(result.GetErrorMessage()));
}
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 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 create_reply_test1()
{
//创建账号
var name = ObjectId.GenerateNewStringId();
var password = ObjectId.GenerateNewStringId();
var result = ExecuteCommand(new RegisterNewAccountCommand(name, password));
Assert.AreEqual(CommandStatus.Success, result.Status);
//发表帖子
var authorId = result.AggregateRootId;
var subject = ObjectId.GenerateNewStringId();
var body = ObjectId.GenerateNewStringId();
var sectionId = ObjectId.GenerateNewStringId();
result = ExecuteCommand(new CreatePostCommand(subject, body, sectionId, authorId));
Assert.AreEqual(CommandStatus.Success, result.Status);
Assert.IsNotNull(result.AggregateRootId);
//发表回复
var postId = result.AggregateRootId;
result = ExecuteCommand(new CreateReplyCommand(postId, null, body, authorId));
//验证回复信息
Assert.AreEqual(CommandStatus.Success, result.Status);
Assert.IsNotNull(result.AggregateRootId);
var replyId = result.AggregateRootId;
var reply = _replyQueryService.FindDynamic(replyId, "simple");
Assert.NotNull(reply);
Assert.AreEqual(replyId, reply.id);
Assert.AreEqual(postId, reply.postId);
Assert.AreEqual(authorId, reply.authorId);
Assert.AreEqual(body, reply.body);
//停顿3s后验证帖子统计信息
Thread.Sleep(3000);
var postInfo = _postQueryService.Find(postId);
Assert.NotNull(postInfo);
Assert.AreEqual(replyId, postInfo.MostRecentReplyId);
Assert.AreEqual(authorId, postInfo.MostRecentReplierId);
Assert.AreEqual(name, postInfo.MostRecentReplierName);
Assert.AreEqual(reply.createdOn, postInfo.LastUpdateTime);
Assert.AreEqual(1, postInfo.ReplyCount);
}
static void PublishEventAsync(int eventCount)
{
var printSize = eventCount / 10;
var eventPublisher = ObjectContainer.Resolve <IMessagePublisher <DomainEventStreamMessage> >();
var eventStreams = new List <DomainEventStreamMessage>();
var commandId = ObjectId.GenerateNewStringId();
var note = new Note(ObjectId.GenerateNewStringId(), "Sample Note");
var evnt = new TestEvent
{
AggregateRootId = note.Id,
Title = "Sample Note",
Version = 1
};
var evnts = new List <IDomainEvent> {
evnt
};
var waitHandle = new ManualResetEvent(false);
for (var i = 1; i <= eventCount; i++)
{
eventStreams.Add(new DomainEventStreamMessage(commandId, note.Id, 1, note.GetType().FullName, evnts, new Dictionary <string, string>()));
}
var watch = Stopwatch.StartNew();
var publishedEventCount = 0;
var asyncAction = new Action <DomainEventStreamMessage>(async eventStream =>
{
await eventPublisher.PublishAsync(eventStream).ConfigureAwait(false);
var currentCount = Interlocked.Increment(ref publishedEventCount);
if (currentCount % printSize == 0)
{
Console.WriteLine("----Published {0} events async, time spent: {1}ms", publishedEventCount, watch.ElapsedMilliseconds);
}
if (currentCount == eventCount)
{
waitHandle.Set();
}
});
Console.WriteLine("--Start to publish event async, total count: {0}.", eventCount);
foreach (var eventStream in eventStreams)
{
asyncAction(eventStream);
}
waitHandle.WaitOne();
Console.WriteLine("--Event publish async completed, throughput: {0}/s", eventCount * 1000 / watch.ElapsedMilliseconds);
}
static void Main(string[] args)
{
InitializeENodeFramework();
var aggreagateRootId = ObjectId.GenerateNewStringId();
var count = int.Parse(ConfigurationManager.AppSettings["count"]);
var eventStore = ObjectContainer.Resolve <IEventStore>();
var watch = Stopwatch.StartNew();
var createEventStream = new Func <int, DomainEventStream>(version =>
{
var evnt = new TestEvent
{
AggregateRootId = aggreagateRootId,
Version = version
};
var eventStream = new DomainEventStream(ObjectId.GenerateNewStringId(), aggreagateRootId, "SampleAggregateRootTypeName", version, DateTime.Now, new IDomainEvent[] { evnt });
return(eventStream);
});
var current = 0;
for (var i = 1; i <= count; i++)
{
eventStore.AppendAsync(createEventStream(i)).ContinueWith(t =>
{
if (t.Result.Data == EventAppendResult.DuplicateEvent)
{
Console.WriteLine("duplicated event stream.");
return;
}
else if (t.Result.Data == EventAppendResult.DuplicateCommand)
{
Console.WriteLine("duplicated command execution.");
return;
}
var local = Interlocked.Increment(ref current);
if (local % 1000 == 0)
{
Console.WriteLine("{0}, time:{1}", local, watch.ElapsedMilliseconds);
}
});
}
Console.ReadLine();
}
public void set_result_command_test()
{
var command = new SetResultCommand
{
AggregateRootId = ObjectId.GenerateNewStringId(),
Result = "CommandResult"
};
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);
Assert.AreEqual("CommandResult", commandResult.Result);
}
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 async Task <ActionResult> Create(CreatePostModel model)
{
var result = await _commandService.SendAsync(
new CreatePostCommand(
ObjectId.GenerateNewStringId(),
model.Subject,
model.Body,
model.SectionId,
_contextService.CurrentAccount.AccountId));
if (result.Status != AsyncTaskStatus.Success)
{
return(Json(new { success = false, errorMsg = result.ErrorMessage }));
}
return(Json(new { success = true }));
}
public async Task <ActionResult> Create(CreateReplyModel model)
{
var result = await _commandService.ExecuteAsync(
new CreateReplyCommand(
ObjectId.GenerateNewStringId(),
model.PostId,
model.ParentId,
model.Body,
_contextService.CurrentAccount.AccountId), CommandReturnType.EventHandled);
if (result.Status != AsyncTaskStatus.Success)
{
return(Json(new { success = false, errorMsg = result.ErrorMessage }));
}
return(Json(new { success = true }));
}
static void create_and_update_aggregate_test()
{
Console.WriteLine("");
Console.WriteLine("----create_and_update_aggregate_test start.");
var noteId = ObjectId.GenerateNewStringId();
var command = new CreateNoteCommand
{
AggregateRootId = noteId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var asyncResult = _commandService.ExecuteAsync(command).Result;
Assert.NotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.NotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
var note = _memoryCache.Get <Note>(noteId);
Assert.NotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//执行修改聚合根的命令
var command2 = new ChangeNoteTitleCommand
{
AggregateRootId = noteId,
Title = "Changed Note"
};
asyncResult = _commandService.ExecuteAsync(command2).Result;
Assert.NotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.NotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
note = _memoryCache.Get <Note>(noteId);
Assert.NotNull(note);
Assert.AreEqual("Changed Note", note.Title);
Assert.AreEqual(2, ((IAggregateRoot)note).Version);
Console.WriteLine("----create_and_update_aggregate_test end.");
}
static void Main(string[] args)
{
InitializeENodeFramework();
var commandService = ObjectContainer.Resolve <ICommandService>();
for (var index = 1; index <= 10; index++)
{
commandService.SendAsync(new CreateNoteCommand {
AggregateRootId = ObjectId.GenerateNewStringId(), Title = "Sample Note" + index
}).ContinueWith(task =>
{
_logger.InfoFormat("Sent command{0}", Interlocked.Increment(ref _count));
});
}
Console.ReadLine();
}
public void Insert_LotteryData_Test()
{
var lotteryId = "ACB89F4E-7C71-4785-BA09-D7E73084B467";
var id = ObjectId.GenerateNewStringId();
var lotteryData = "1,2,3,4,5,6,7,8,9,10";
var insertTime = DateTime.Now;
var period = 1000;
var result = ExecuteCommand(new AddLotteryDataCommand(Guid.NewGuid().ToString(), new LotteryDataDto()
{
Data = lotteryData,
LotteryId = lotteryId,
LotteryTime = DateTime.Now,
Period = 1000,
}));
Assert.AreEqual(CommandStatus.Success, result.Status);
}
public async Task Should_Append_Same_EventStream()
{
//Arrange
var eventStream = GetTestDomainEventStream(ObjectId.GenerateNewStringId());
await _store.BatchAppendAsync(new List <DomainEventStream> {
eventStream
});
//Act
await _store.BatchAppendAsync(new List <DomainEventStream> {
eventStream
});
//Assert
var result = await _store.FindAsync(eventStream.AggregateRootId, eventStream.Version);
result.ShouldNotBeNull();
}
public QueueMessage StoreMessage(int queueId, long messageOffset, long queueOffset, Message message, string routingKey)
{
var queueMessage = new QueueMessage(
ObjectId.GenerateNewStringId(),
message.Topic,
message.Code,
message.Body,
messageOffset,
queueId,
queueOffset,
message.CreatedTime,
DateTime.Now,
DateTime.Now,
routingKey);
_messageDict[messageOffset] = queueMessage;
return(queueMessage);
}
public async Task <ActionResult> Create(CreatePostModel model)
{
var currentAccount = _contextService.GetCurrentAccount(HttpContext);
var result = await _commandService.ExecuteAsync(
new CreatePostCommand(
ObjectId.GenerateNewStringId(),
model.Subject,
model.Body,
model.SectionId,
currentAccount.AccountId));
if (result.Status == CommandStatus.Failed)
{
return(Json(new { success = false, errorMsg = result.Result }));
}
return(Json(new { success = true }));
}
static void Main(string[] args)
{
ConfigSettings.Initialize();
InitializeENodeFramework();
var commandService = ObjectContainer.Resolve <ICommandService>();
var noteId = ObjectId.GenerateNewStringId();
var command1 = new CreateNoteCommand {
AggregateRootId = noteId, Title = "Sample Title1"
};
var command2 = new ChangeNoteTitleCommand {
AggregateRootId = noteId, Title = "Sample Title2"
};
System.Console.WriteLine(string.Empty);
_logger.Info("Creating Note...");
commandService.ExecuteAsync(command1, CommandReturnType.EventHandled).Wait();
_logger.Info("Note create success.");
System.Console.WriteLine(string.Empty);
_logger.Info("Updating Note");
commandService.ExecuteAsync(command2, CommandReturnType.EventHandled).Wait();
_logger.Info("Note update success.");
System.Console.WriteLine(string.Empty);
using (var connection = new SqlConnection(ConfigSettings.ConnectionString))
{
var note = connection.QueryList(new { Id = noteId }, ConfigSettings.NoteTable).Single();
_logger.InfoFormat("Note from ReadDB, id: {0}, title: {1}, version: {2}", note.Id, note.Title, note.Version);
}
System.Console.WriteLine(string.Empty);
_logger.Info("Press Enter to exit...");
System.Console.ReadLine();
//_configuration.ShutdownEQueue();
System.Console.ReadKey();
}
public void async_command_application_message_publish_failed_test()
{
((MockApplicationMessagePublisher)_applicationMessagePublisher).SetExpectFailedCount(FailedType.UnKnownException, 5);
var asyncResult = _commandService.ExecuteAsync(new AsyncHandlerCommand()
{
AggregateRootId = ObjectId.GenerateNewStringId(),
ShouldGenerateApplicationMessage = true
}).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
var commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
((MockApplicationMessagePublisher)_applicationMessagePublisher).Reset();
((MockApplicationMessagePublisher)_applicationMessagePublisher).SetExpectFailedCount(FailedType.IOException, 5);
asyncResult = _commandService.ExecuteAsync(new AsyncHandlerCommand()
{
AggregateRootId = ObjectId.GenerateNewStringId(),
ShouldGenerateApplicationMessage = true
}).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
((MockApplicationMessagePublisher)_applicationMessagePublisher).Reset();
((MockApplicationMessagePublisher)_applicationMessagePublisher).SetExpectFailedCount(FailedType.TaskIOException, 5);
asyncResult = _commandService.ExecuteAsync(new AsyncHandlerCommand()
{
AggregateRootId = ObjectId.GenerateNewStringId(),
ShouldGenerateApplicationMessage = true
}).Result;
Assert.IsNotNull(asyncResult);
Assert.AreEqual(AsyncTaskStatus.Success, asyncResult.Status);
commandResult = asyncResult.Data;
Assert.IsNotNull(commandResult);
Assert.AreEqual(CommandStatus.Success, commandResult.Status);
((MockApplicationMessagePublisher)_applicationMessagePublisher).Reset();
}
static void CreateChunks(string root, string path, ChunkManager chunkManager, int singleFileIndexCount, int dataUnitSize, int totalAggNumber, int indexCountForSingleAgg)
{
if (Directory.Exists(root))
{
Directory.Delete(root, true);
}
Directory.CreateDirectory(root);
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
var chunkWriter = new ChunkWriter(chunkManager);
chunkWriter.Open();
var watch = Stopwatch.StartNew();
var format = "{0}{1:00000000000000}";
var aggPrefix = "aggregate_";
for (var i = 0; i < totalAggNumber; i++)
{
var sourceId = string.Format(format, aggPrefix, i);
for (var j = 0; j < indexCountForSingleAgg; j++)
{
var record = new StreamIndex()
{
SourceId = sourceId,
CommandId = ObjectId.GenerateNewStringId(),
Version = j + 1,
BodyPosition = 10000L
};
chunkWriter.Write(record);
}
}
chunkWriter.Close();
Console.WriteLine("Create event index success, aggCount: {0}, totalEventIndexCount: {1}, timeSpent: {2}ms", totalAggNumber, totalAggNumber * indexCountForSingleAgg, watch.ElapsedMilliseconds);
}
public void create_and_update_inherit_aggregate_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateInheritTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var asyncResult = _commandService.ExecuteAsync(command).Result;
NUnit.Framework.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 <InheritTestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Sample Note", note.Title);
Assert.AreEqual(1, ((IAggregateRoot)note).Version);
//执行修改聚合根的命令
var command2 = new ChangeInheritTestAggregateTitleCommand
{
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.GetAsync <InheritTestAggregate>(aggregateId).Result;
Assert.IsNotNull(note);
Assert.AreEqual("Changed Note", note.Title);
Assert.AreEqual(2, ((IAggregateRoot)note).Version);
}
public void update_post_test()
{
var authorId = ObjectId.GenerateNewStringId();
var subject = ObjectId.GenerateNewStringId();
var body = ObjectId.GenerateNewStringId();
var sectionId = ObjectId.GenerateNewStringId();
var postId = ExecuteCommand(new CreatePostCommand(ObjectId.GenerateNewStringId(), subject, body, sectionId, authorId)).AggregateRootId;
var subject2 = ObjectId.GenerateNewStringId();
var body2 = ObjectId.GenerateNewStringId();
ExecuteCommand(new UpdatePostCommand(postId, subject2, body2));
var post = _postQueryService.Find(postId);
Assert.IsNotNull(post);
Assert.AreEqual(subject2, post.Subject);
Assert.AreEqual(body2, post.Body);
}
public void create_post_test()
{
var authorId = ObjectId.GenerateNewStringId();
var subject = ObjectId.GenerateNewStringId();
var body = ObjectId.GenerateNewStringId();
var sectionId = ObjectId.GenerateNewStringId();
var result = ExecuteCommand(new CreatePostCommand(ObjectId.GenerateNewStringId(), subject, body, sectionId, authorId));
Assert.AreEqual(CommandStatus.Success, result.Status);
Assert.IsNotNull(result.AggregateRootId);
var post = _postQueryService.Find(result.AggregateRootId);
Assert.IsNotNull(post);
Assert.AreEqual(subject, post.Subject);
Assert.AreEqual(body, post.Body);
Assert.AreEqual(authorId, post.AuthorId);
Assert.AreEqual(sectionId, post.SectionId);
}
public void update_reply_body_test()
{
var postId = ObjectId.GenerateNewStringId();
var authorId = ObjectId.GenerateNewStringId();
var body = ObjectId.GenerateNewStringId();
var id = ExecuteCommand(new CreateReplyCommand(postId, null, body, authorId)).AggregateRootId;
var body2 = ObjectId.GenerateNewStringId();
ExecuteCommand(new ChangeReplyBodyCommand(id, body2));
var reply = _replyQueryService.FindDynamic(id, "simple");
Assert.NotNull(reply);
Assert.AreEqual(id, reply.id);
Assert.AreEqual(postId, reply.postId);
Assert.AreEqual(authorId, reply.authorId);
Assert.AreEqual(body2, reply.body);
}
public PullRequest(
RemotingRequest remotingRequest,
PullMessageRequest pullMessageRequest,
IRequestHandlerContext requestHandlerContext,
DateTime suspendStartTime,
long suspendMilliseconds,
Action <PullRequest> newMessageArrivedAction,
Action <PullRequest> timeoutAction,
Action <PullRequest> replacedAction)
{
Id = ObjectId.GenerateNewStringId();
RemotingRequest = remotingRequest;
PullMessageRequest = pullMessageRequest;
RequestHandlerContext = requestHandlerContext;
SuspendStartTime = suspendStartTime;
SuspendMilliseconds = suspendMilliseconds;
NewMessageArrivedAction = newMessageArrivedAction;
TimeoutAction = timeoutAction;
ReplacedAction = replacedAction;
}
