public void TestEventMultipleEmitSourcing_AfterManyMultiCommand_TestStateSignalled()
{
var aggregateId = TestAggregateId.New;
var commandId = SourceId.New;
var command = new CreateTestCommand(aggregateId).WithSourceId(commandId);
var test = new TestEntity(TestId.New);
var testSourceId = SourceId.New;
var testCommand = new AddFourTestsCommand(aggregateId, test).WithSourceId(testSourceId);
var poisonCommand = new PoisonTestAggregateCommand(aggregateId);
var fixture = new AggregateFixture <TestAggregateId, TestAggregate,
ITestAggregateState, TestAggregateState>(this);
fixture.For(aggregateId)
.GivenNothing()
.When(command, testCommand, poisonCommand)
.ThenExpectDomainEvent <TestCreatedEvent>()
.ThenExpectDomainEvent <TestAddedEvent>()
.ThenExpectDomainEvent <TestAddedEvent>()
.ThenExpectDomainEvent <TestAddedEvent>()
.ThenExpectDomainEvent <TestAddedEvent>()
.ThenExpectState(
x => x.TestCollection.Count == 4);
}
public void EventContainerMetadata_AfterAggregateCreation_TestCreatedEventEmitted()
{
var eventProbe = CreateTestProbe("event-probe");
Sys.EventStream.Subscribe(eventProbe, typeof(DomainEvent <TestAggregate, TestAggregateId, TestCreatedEvent>));
var aggregateManager = Sys.ActorOf(Props.Create(() => new TestAggregateManager()), "test-aggregatemanager");
var aggregateId = TestAggregateId.New;
var commandId = CommandId.New;
var command = new CreateTestCommand(aggregateId, commandId);
aggregateManager.Tell(command);
eventProbe
.ExpectMsg <DomainEvent <TestAggregate, TestAggregateId, TestCreatedEvent> >(
x => x.AggregateIdentity.Equals(aggregateId) &&
x.IdentityType == typeof(TestAggregateId) &&
x.AggregateType == typeof(TestAggregate) &&
x.EventType == typeof(TestCreatedEvent) &&
x.Metadata.EventName == "TestCreated" &&
x.Metadata.AggregateId == aggregateId.Value &&
x.Metadata.EventVersion == 1 &&
x.Metadata.SourceId.Value == commandId.Value &&
x.Metadata.AggregateSequenceNumber == 1);
}
public void TestEventMultipleEmitSourcing_AfterManyMultiCommand_TestStateSignalled()
{
var eventProbe = CreateTestProbe("event-probe");
Sys.EventStream.Subscribe(eventProbe, typeof(DomainEvent <TestAggregate, TestAggregateId, TestStateSignalEvent>));
var aggregateManager = Sys.ActorOf(Props.Create(() => new TestAggregateManager()), "test-aggregatemanager");
var aggregateId = TestAggregateId.New;
var commandId = CommandId.New;
var command = new CreateTestCommand(aggregateId, commandId);
aggregateManager.Tell(command);
var test = new Test(TestId.New);
var testSourceId = CommandId.New;
var testCommand = new AddFourTestsCommand(aggregateId, testSourceId, test);
aggregateManager.Tell(testCommand);
var poisonCommand = new PoisonTestAggregateCommand(aggregateId);
aggregateManager.Tell(poisonCommand);
var reviveCommand = new PublishTestStateCommand(aggregateId);
aggregateManager.Tell(reviveCommand);
eventProbe
.ExpectMsg <DomainEvent <TestAggregate, TestAggregateId, TestStateSignalEvent> >(
x => x.AggregateEvent.LastSequenceNr == 5 &&
x.AggregateEvent.Version == 5 &&
x.AggregateEvent.AggregateState.TestCollection.Count == 4);
}
public bool UpdateTrainingTest(int id, [FromBody] CreateTestCommand request)
{
TestContext context = HttpContext.RequestServices.GetService(typeof(TestContext)) as TestContext;
UpdateTestHandler handler = new UpdateTestHandler(context);
return(handler.Handle(id, request));
}
public void TestSnapShotting_AfterManyTests_TestStateSignalled()
{
var eventProbe = CreateTestProbe("event-probe");
Sys.EventStream.Subscribe(eventProbe, typeof(DomainEvent <TestAggregate, TestAggregateId, TestStateSignalEvent>));
var aggregateManager = Sys.ActorOf(Props.Create(() => new TestAggregateManager()), "test-aggregatemanager");
var aggregateId = TestAggregateId.New;
var commandId = CommandId.New;
var command = new CreateTestCommand(aggregateId, commandId);
aggregateManager.Tell(command);
for (var i = 0; i < 10; i++)
{
var test = new Test(TestId.New);
var testCommandId = CommandId.New;
var testCommand = new AddTestCommand(aggregateId, testCommandId, test);
aggregateManager.Tell(testCommand);
}
eventProbe
.ExpectMsg <DomainEvent <TestAggregate, TestAggregateId, TestStateSignalEvent> >(
x => x.AggregateEvent.LastSequenceNr == 11 &&
x.AggregateEvent.Version == 11 &&
x.AggregateEvent.AggregateState.TestCollection.Count == 10 &&
x.AggregateEvent.AggregateState.FromHydration);
}
public void TestCommandTwice_AfterAggregateCreation_TestEventEmitted()
{
var aggregateId = TestAggregateId.New;
var commandId = SourceId.New;
var command = new CreateTestCommand(aggregateId).WithSourceId(commandId);
var testId = TestId.New;
var test = new TestEntity(testId);
var nextCommandId = SourceId.New;
var nextCommand = new AddTestCommand(aggregateId, test).WithSourceId(nextCommandId);
var test2Id = TestId.New;
var test2 = new TestEntity(test2Id);
var nextCommandId2 = SourceId.New;
var nextCommand2 = new AddTestCommand(aggregateId, test2).WithSourceId(nextCommandId2);
var fixture = new AggregateFixture <TestAggregateId, TestAggregate,
ITestAggregateState, TestAggregateState>(this);
fixture.For(aggregateId)
.GivenNothing()
.When(command, nextCommand, nextCommand2)
.ThenExpectDomainEvent <TestCreatedEvent>()
.ThenExpectDomainEvent <TestAddedEvent>(
x => x.AggregateEvent.Test.Equals(test))
.ThenExpectDomainEvent <TestAddedEvent>(
x => x.AggregateEvent.Test.Equals(test2));
}
public void TestSnapShotting_AfterManyTests_TestStateSignalled()
{
var eventProbe = CreateTestProbe("event-probe");
Sys.EventStream.Subscribe(eventProbe, typeof(IDomainEvent <TestAggregateId, TestStateSignalEvent>));
var aggregateId = TestAggregateId.New;
var commandId = CommandId.New;
var bus = Sys.GetExtension <ServiceProviderHolder>().ServiceProvider.GetRequiredService <ICommandBus>();
var command = new CreateTestCommand(aggregateId, commandId);
bus.Publish(command).GetAwaiter().GetResult();
for (var i = 0; i < 10; i++)
{
var test = new Test(TestId.New);
var testCommandId = CommandId.New;
var testCommand = new AddTestCommand(aggregateId, testCommandId, test);
bus.Publish(testCommand).GetAwaiter().GetResult();
}
eventProbe.ExpectMsg <IDomainEvent <TestAggregateId, TestStateSignalEvent> >(
x => x.AggregateEvent.LastSequenceNr == 11 &&
x.AggregateEvent.Version == 11 &&
x.AggregateEvent.AggregateState.TestCollection.Count == 10 &&
x.AggregateEvent.AggregateState.FromHydration);
}
public void TestEventSourcing_AfterManyTests_TestStateSignalled()
{
var probe = CreateTestActor("probe");
Sys.EventStream.Subscribe(probe, typeof(DomainEvent <TestAggregate, TestAggregateId, TestStateSignalEvent>));
var aggregateManager = Sys.ActorOf(Props.Create(() => new TestAggregateManager()), "test-aggregatemanager");
var aggregateId = TestAggregateId.New;
var command = new CreateTestCommand(aggregateId);
aggregateManager.Tell(command);
for (var i = 0; i < 5; i++)
{
var test = new Test(TestId.New);
var testCommand = new AddTestCommand(aggregateId, test);
aggregateManager.Tell(testCommand);
}
var poisonCommand = new PoisonTestAggregateCommand(aggregateId);
aggregateManager.Tell(poisonCommand);
var reviveCommand = new PublishTestStateCommand(aggregateId);
aggregateManager.Tell(reviveCommand);
ExpectMsg <DomainEvent <TestAggregate, TestAggregateId, TestStateSignalEvent> >(
x => x.AggregateEvent.LastSequenceNr == 6 &&
x.AggregateEvent.Version == 6 &&
x.AggregateEvent.AggregateState.TestCollection.Count == 5);
}
public void TestCommandTwice_AfterAggregateCreation_TestEventEmitted()
{
var eventProbe = CreateTestProbe("event-probe");
Sys.EventStream.Subscribe(eventProbe, typeof(IDomainEvent <TestAggregateId, TestAddedEvent>));
var bus = Sys.GetExtension <ServiceProviderHolder>().ServiceProvider.GetRequiredService <ICommandBus>();
var aggregateId = TestAggregateId.New;
var commandId = CommandId.New;
var command = new CreateTestCommand(aggregateId, commandId);
var testId = TestId.New;
var test = new Test(testId);
var nextCommandId = CommandId.New;
var nextCommand = new AddTestCommand(aggregateId, nextCommandId, test);
var test2Id = TestId.New;
var test2 = new Test(test2Id);
var nextCommandId2 = CommandId.New;
var nextCommand2 = new AddTestCommand(aggregateId, nextCommandId2, test2);
bus.Publish(command).GetAwaiter().GetResult();
bus.Publish(nextCommand).GetAwaiter().GetResult();
bus.Publish(nextCommand2).GetAwaiter().GetResult();
eventProbe.ExpectMsg <IDomainEvent <TestAggregateId, TestAddedEvent> >(x => x.AggregateEvent.Test.Equals(test) && x.AggregateSequenceNumber == 2);
eventProbe.ExpectMsg <IDomainEvent <TestAggregateId, TestAddedEvent> >(x => x.AggregateEvent.Test.Equals(test2) && x.AggregateSequenceNumber == 3);
}
public bool Handle(CreateTestCommand request)
{
var test = request.Adapt <TrainingTest>();
try
{
using (MySqlConnection conn = _context.GetConnection())
{
conn.Open();
string query = string.Format("insert into Training_Tests(date, result, Specialists_specialist_id, Topics_topic_id, topics_courses_course_id) " +
"values ('{0}', {1}, {2}, {3}, {4})",
test.Date.ToString("yyyy-MM-dd HH:mm:ss"),
test.Result,
test.SpecialistId,
test.TopicId,
test.CourseId);
MySqlCommand cmd = new MySqlCommand(query, conn);
cmd.ExecuteNonQuery();
conn.CloseAsync();
}
return(true);
}
catch (Exception ex)
{
string s = ex.Message;
return(false);
}
}
public void TestCommandTwice_AfterAggregateCreation_TestEventEmitted()
{
var probe = CreateTestActor("probeActor");
Sys.EventStream.Subscribe(probe, typeof(DomainEvent <TestAggregate, TestAggregateId, TestAddedEvent>));
var aggregateManager = Sys.ActorOf(Props.Create(() => new TestAggregateManager()), "test-aggregatemanager");
var aggregateId = TestAggregateId.New;
var command = new CreateTestCommand(aggregateId);
var testId = TestId.New;
var test = new Test(testId);
var nextCommand = new AddTestCommand(aggregateId, test);
var test2Id = TestId.New;
var test2 = new Test(test2Id);
var nextCommand2 = new AddTestCommand(aggregateId, test2);
aggregateManager.Tell(command);
aggregateManager.Tell(nextCommand);
aggregateManager.Tell(nextCommand2);
ExpectMsg <DomainEvent <TestAggregate, TestAggregateId, TestAddedEvent> >(
x => x.AggregateEvent.Test.Equals(test) &&
x.AggregateSequenceNumber == 2);
ExpectMsg <DomainEvent <TestAggregate, TestAggregateId, TestAddedEvent> >(
x => x.AggregateEvent.Test.Equals(test2) &&
x.AggregateSequenceNumber == 3);
}
public async Task <ApiResult <CreateTestCommand> > GetTestByIdAsync(long id)
{
try
{
if (_unit.Context.Tblusersubmitedanswer.Where(t => t.TestId == id).Any())
{
return(new ApiResult <CreateTestCommand>(new ApiResultCode(ApiResultType.Error, messageText: "Exist edit will not delete from record. user have already tacken test.")));
}
var result = await _unit.GetRepository <Tbltest>().GetByID(id);
if (result.HasSuccess)
{
var testview = new CreateTestCommand();
testview.Id = result.UserObject.Id;
testview.CatetoryId = result.UserObject.CategoryId;
testview.Name = result.UserObject.Name;
testview.Description = result.UserObject.Description;
testview.NoOfQuestion = result.UserObject.NoOfQuestion.HasValue ? result.UserObject.NoOfQuestion.Value : 0;
return(new ApiResult <CreateTestCommand>(new ApiResultCode(ApiResultType.Success), testview));
}
}
catch (Exception ex)
{
ErrorTrace.Logger(LogArea.RepositoryLayer, ex);
return(new ApiResult <CreateTestCommand>(new ApiResultCode(ApiResultType.Error, messageText: "Error while geting data")));
}
return(new ApiResult <CreateTestCommand>(new ApiResultCode(ApiResultType.Error, messageText: "no data found")));
}
public void AggregateIdentityExtractor_InValidObject_ThrowsArgumentNullException()
{
CreateTestCommand message = null;
// ReSharper disable once ExpressionIsAlwaysNull
this.Invoking(test => ShardIdentityExtractors.AggregateIdentityExtractor <TestAggregate, TestAggregateId>(message))
.Should().Throw <ArgumentNullException>();
}
public void AggregateEventTagger_TaggingNonEvent_ShouldBeLeftAlone()
{
var aggregateEventTagger = new AggregateEventTagger();
var command = new CreateTestCommand(TestAggregateId.New, CommandId.New);
var untagged = aggregateEventTagger.ToJournal(command);
command.Should().Be(untagged);
}
public void AggregateIdentityExtractor_ValidObject_ExtractsObject()
{
var aggregateId = TestAggregateId.New;
var message = new CreateTestCommand(aggregateId);
var extractedObject = ShardIdentityExtractors.AggregateIdentityExtractor <TestAggregate, TestAggregateId>(message).Item2;
extractedObject.GetHashCode().Should().Be(message.GetHashCode());
}
public void AggregateSagaIdentityExtractor_InValidMessage_ExceptionIsThrown()
{
var aggregateId = TestAggregateId.New;
var commandId = CommandId.New;
var message = new CreateTestCommand(aggregateId, commandId);
this.Invoking(test => ShardIdentityExtractors.AggregateSagaIdentityExtractor <TestSagaManager, TestSaga, TestSagaId, TestSagaLocator>(message))
.Should().Throw <ArgumentException>();
}
public void InstantiatingCommand_WithValidInput_ThrowsException()
{
var aggregateId = TestAggregateId.New;
var sourceId = CommandId.New;
var command = new CreateTestCommand(aggregateId, sourceId);
command.GetSourceId().Should().Be(sourceId);
}
public void NonCommittedEvent_WhenRead_IsReturnedUnchanged()
{
var message = new CreateTestCommand(TestAggregateId.New, CommandId.New);
var eventUpcaster = new TestAggregateEventUpcaster();
var unchanged = eventUpcaster.FromJournal(message, string.Empty);
unchanged.Events.Single().As <CreateTestCommand>().GetSourceId().Should().Be(message.GetSourceId());
unchanged.Events.Single().As <CreateTestCommand>().AggregateId.Should().Be(message.AggregateId);
}
public void AggregateSagaIdentityExtractor_ValidMessage_ExtractsIdentity()
{
var aggregateId = TestAggregateId.New;
var message = new CreateTestCommand(aggregateId);
var extractedIdentity =
ShardIdentityExtractors.AggregateIdentityExtractor <TestAggregate, TestAggregateId>(message).Item1;
extractedIdentity.Should().BeEquivalentTo(message.AggregateId.Value);
}
public void NonCommittedEvent_WhenRead_IsReturnedUnchanged()
{
var message = new CreateTestCommand(TestAggregateId.New, CommandId.New);
var domainEventReadAdapter = new DomainEventReadAdapter();
var unchanged = domainEventReadAdapter.FromJournal(message, String.Empty);
unchanged.Events.Single().As <CreateTestCommand>().Metadata.SourceId.Should().Be(message.Metadata.SourceId);
unchanged.Events.Single().As <CreateTestCommand>().AggregateId.Should().Be(message.AggregateId);
}
public void InstantiatingCommand_WithValidInput_ThrowsException()
{
var aggregateId = TestAggregateId.New;
var sourceId = SourceId.New;
var command = new CreateTestCommand(aggregateId)
.WithMetadata(new CommandMetadata(sourceId));
command.Metadata.SourceId.Value.Should().Be(sourceId.Value);
}
public void AggregateCommandIdentityExtractor_ValidMessage_ExtractsIdentity(int shardSize)
{
var aggregateId = TestAggregateId.New;
var message = new CreateTestCommand(aggregateId);
var shardResolver = new ShardResolvers(shardSize);
var extractedShard = shardResolver.AggregateShardResolver <TestAggregate, TestAggregateId>(message);
var extractedShardValue = int.Parse(extractedShard);
extractedShardValue.Should().BeInRange(0, shardSize);
}
public void SendingTest_FromTestAggregate_CompletesSaga()
{
var eventProbe = CreateTestProbe("event-probe");
Sys.EventStream.Subscribe(eventProbe, typeof(DomainEvent <TestSaga, TestSagaId, TestSagaStartedEvent>));
Sys.EventStream.Subscribe(eventProbe, typeof(DomainEvent <TestSaga, TestSagaId, TestSagaCompletedEvent>));
Sys.EventStream.Subscribe(eventProbe, typeof(DomainEvent <TestSaga, TestSagaId, TestSagaTransactionCompletedEvent>));
Sys.EventStream.Subscribe(eventProbe, typeof(DomainEvent <TestSaga, TestSagaId, TestSagaTimeoutOccurred>));
var aggregateManager = Sys.ActorOf(Props.Create(() => new TestAggregateManager()), "test-aggregatemanager");
Sys.ActorOf(Props.Create(() => new TestSagaManager(() => new TestSaga(aggregateManager))), "test-sagaaggregatemanager");
var senderAggregateId = TestAggregateId.New;
var senderCreateAggregateCommand = new CreateTestCommand(senderAggregateId, CommandId.New);
aggregateManager.Tell(senderCreateAggregateCommand);
var receiverAggregateId = TestAggregateId.New;
var receiverCreateAggregateCommand = new CreateTestCommand(receiverAggregateId, CommandId.New);
aggregateManager.Tell(receiverCreateAggregateCommand);
var senderTestId = TestId.New;
var senderTest = new Test(senderTestId);
var nextAggregateCommand = new AddTestCommand(senderAggregateId, CommandId.New, senderTest);
aggregateManager.Tell(nextAggregateCommand);
var sagaStartingCommand = new GiveTestCommand(senderAggregateId, CommandId.New, receiverAggregateId, senderTest);
aggregateManager.Tell(sagaStartingCommand);
eventProbe.
ExpectMsg <DomainEvent <TestSaga, TestSagaId, TestSagaStartedEvent> >(
x => x.AggregateEvent.Sender.Equals(senderAggregateId) &&
x.AggregateEvent.Receiver.Equals(receiverAggregateId) &&
x.AggregateEvent.SentTest.Equals(senderTest), new TimeSpan(0, 0, 20));
eventProbe.
ExpectMsg <DomainEvent <TestSaga, TestSagaId, TestSagaTransactionCompletedEvent> >(new TimeSpan(0, 0, 20));
eventProbe.
ExpectMsg <DomainEvent <TestSaga, TestSagaId, TestSagaCompletedEvent> >(new TimeSpan(0, 0, 20));
eventProbe.ExpectMsg <DomainEvent <TestSaga, TestSagaId, TestSagaTimeoutOccurred> >(
timeoutMsg => timeoutMsg.AggregateEvent.TimeoutMessage.Equals("First timeout test"),
TimeSpan.FromSeconds(15));
eventProbe.ExpectMsg <DomainEvent <TestSaga, TestSagaId, TestSagaTimeoutOccurred> >(
timeoutMsg => timeoutMsg.AggregateEvent.TimeoutMessage.StartsWith("Second timeout test"),
TimeSpan.FromSeconds(15));
}
public async Task CreateTest(long userId, ResultStatus expectedResult)
{
var handler = new CreateTestHandler(uow);
var command = new CreateTestCommand()
{
UserId = OwnerId,
Title = "Roberto Carlos",
OwnerId = userId
};
var result = await handler.Handle(command, default);
Assert.AreEqual(expectedResult, result.Status);
}
private bool Execute(CreateTestCommand command)
{
if (IsNew)
{
Emit(new TestCreatedEvent(command.AggregateId));
}
else
{
TestErrors++;
Throw(new TestedErrorEvent(TestErrors));
}
return(true);
}
public void SendingCommand_ToAggregateRoot_ShouldReplyWithProperMessage()
{
var aggregateId = TestAggregateId.New;
var commandId = SourceId.New;
var command = new CreateTestCommand(aggregateId).WithSourceId(commandId);
var fixture = new AggregateFixture <TestAggregateId, TestAggregate,
ITestAggregateState, TestAggregateState>(this);
fixture.For(aggregateId)
.GivenNothing()
.When(command)
.ThenExpectResult(result => result.IsSuccess);
}
public async Task <Result> Do(CreateTestCommand command)
{
if (IsNew)
{
await Emit(new TestCreatedEvent(command.Id), new EventMetadata { { "some-key", "some-value" } });
return(Result.Success);
}
TestErrors++;
await Emit(new TestedErrorEvent(Id, TestErrors));
return(Result.Fail("TestedErrorEvent"));
}
public async Task <ApiResultCode> CreateTestAsync(CreateTestCommand request)
{
try
{
string filter = _unit.Context.Tbltest.Where(t => t.CategoryId == request.CatetoryId).Select(t => t.Name).FirstOrDefault();
var modeldto = new Tbltest();
modeldto.Name = request.Name;
modeldto.Description = request.Description;
modeldto.NoOfQuestion = request.NoOfQuestion;
modeldto.CategoryId = request.CatetoryId;
modeldto.InsertDate = DateTime.Now;
modeldto.LastUpdateDate = DateTime.Now;
modeldto.Status = 1;
modeldto.InsertedBy = request.CurrentUserId;
modeldto.LastUpdatedBy = request.CurrentUserId;
modeldto.ClientId = request.CurrentCientId;
if (request.Id > 0)
{
modeldto.Id = request.Id;
_unit.Context.Tbltest.Attach(modeldto);
_unit.Context.Entry(modeldto).Property(t => t.Name).IsModified = true;
_unit.Context.Entry(modeldto).Property(t => t.Description).IsModified = true;
_unit.Context.Entry(modeldto).Property(t => t.NoOfQuestion).IsModified = true;
_unit.Context.Entry(modeldto).Property(t => t.CategoryId).IsModified = true;
_unit.Context.Entry(modeldto).Property(t => t.LastUpdateDate).IsModified = true;
_unit.Context.Entry(modeldto).Property(t => t.LastUpdatedBy).IsModified = true;
}
else
{
if (filter != null && filter.ToLower() == request.Name.ToLower())
{
return(new ApiResultCode(ApiResultType.Error, messageText: " Duplicate Test can not be Allowed"));
}
_ = _unit.GetRepository <Tbltest>().Add(modeldto);
}
var result = await _unit.SaveChangesAsync();
if (result.ResultType == ApiResultType.Success)
{
return(new ApiResultCode(ApiResultType.Success, messageText: "Added"));
}
return(new ApiResultCode(ApiResultType.Error, messageText: " Can not be Added"));
}
catch (Exception ex)
{
ErrorTrace.Logger(LogArea.RepositoryLayer, ex);
return(new ApiResultCode(ApiResultType.Error, messageText: " Can not be Added"));
}
}
public void InitialState_AfterAggregateCreation_TestCreatedEventEmitted()
{
var probe = CreateTestActor("probeActor");
Sys.EventStream.Subscribe(probe, typeof(DomainEvent <TestAggregate, TestAggregateId, TestCreatedEvent>));
var aggregateManager = Sys.ActorOf(Props.Create(() => new TestAggregateManager()), "test-aggregatemanager");
var aggregateId = TestAggregateId.New;
var command = new CreateTestCommand(aggregateId);
aggregateManager.Tell(command);
ExpectMsg <DomainEvent <TestAggregate, TestAggregateId, TestCreatedEvent> >(
x => x.AggregateEvent.TestAggregateId.Equals(aggregateId));
}
public async Task SendingCommand_ToAggregateRoot_ShouldReplyWithProperMessage()
{
var eventProbe = CreateTestProbe("event-probe");
Sys.EventStream.Subscribe(eventProbe, typeof(IDomainEvent <TestAggregateId, TestCreatedEvent>));
var bus = Sys.GetExtension <ServiceProviderHolder>().ServiceProvider.GetRequiredService <ICommandBus>();
var aggregateId = TestAggregateId.New;
var commandId = CommandId.New;
var command = new CreateTestCommand(aggregateId, commandId);
var result = (ITestExecutionResult)await bus.Publish(command);
result.IsSuccess.Should().BeTrue();
result.SourceId.Should().Be(command.Metadata.SourceId);
}
