public async Task When_execute_aggregate_command_with_metadata()
{
_command = new InflateNewBallonCommand(1, Guid.NewGuid().ToString());
_commandMetadata = MessageMetadata.New(_command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(_command, _commandMetadata)
.Expect <BalloonCreated>()
.And <BalloonCreatedNotification>()
.Execute();
_answer = res.MessageWithMetadata <BalloonCreatedNotification>();
_aggregateEvent = res.MessageWithMetadata <BalloonCreated>();
//Result_contains_metadata()
Assert.NotNull(_answer.Metadata);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <BalloonCreatedNotification>(_answer.Message);
//Result_message_has_expected_id()
Assert.Equal(_command.AggregateId, _answer.Message.BallonId);
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal(_aggregateEvent.Metadata.MessageId, _answer.Metadata.CasuationId);
//Result_metadata_has_correlation_id_same_as_command_metadata()
Assert.Equal(_commandMetadata.CorrelationId, _answer.Metadata.CorrelationId);
// Result_metadata_has_processed_history_filled_from_aggregate()
//Assert.Equal(1, _answer.Metadata.History?.Steps.Count);
////Result_metadata_has_processed_correct_filled_history_step()
//var step = _answer.Metadata.History.Steps.First();
//Assert.Equal(nameof(BalloonCreatedNotificator), step.Who);
//Assert.Equal(BalloonCreatedNotificator.Why, step.Why);
//Assert.Equal(BalloonCreatedNotificator.MessageProcessed, step.What);
}
public async Task Given_timeout_only_default_policy()
{
var aggregateId = Guid.NewGuid().ToString();
var cmd = new InflateNewBallonCommand(1, aggregateId);
await Node.Prepare(cmd).Expect <BalloonCreated>().Execute();
//checking "time-out" rule for policy, snapshots should be saved once on second command
await Task.Delay(1000);
var changedParameter = 2;
var changeSampleAggregateCommand = new WriteTitleCommand(changedParameter, aggregateId);
await Node.Prepare(changeSampleAggregateCommand).Expect <BalloonTitleChanged>().Execute();
await Task.Delay(1000);
var snapshots =
await
new AggregateSnapshotRepository(AutoTestNodeDbConfiguration.Default.JournalConnectionString,
new BalloonAggregateFactory(),
new BalloonAggregateFactory()).Load <Balloon>(aggregateId);
//Snapshots_should_be_saved_one_time()
Assert.Empty(snapshots);
}
public async Task When_execute_aggregate_command_with_metadata()
{
var command = new InflateNewBallonCommand(1, Guid.NewGuid().ToString());
var commandMetadata = MessageMetadata.New(command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(command, commandMetadata)
.Expect <BalloonCreated>()
.And <Fault <BalloonCreated> >()
.Execute(null, false);
var answer = res.MessageWithMetadata <IFault <BalloonCreated> >();
var aggregateEvent = res.MessageWithMetadata <BalloonCreated>();
//Result_contains_metadata()
Assert.NotNull(answer.Metadata);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <IFault <BalloonCreated> >(answer.Message);
//Produced_fault_produced_by_projection_builder()
Assert.Equal(typeof(BalloonCreatedFaultyProjection), answer.Message.Processor);
//Result_message_has_expected_id()
Assert.Equal(command.AggregateId, answer.Message.Message.SourceId);
//Result_metadata_has_aggregate_event_id_as_casuation_id()
Assert.Equal(aggregateEvent.Metadata.MessageId, answer.Metadata.CasuationId);
//Result_metadata_has_correlation_id_same_as_command_metadata()
Assert.Equal(commandMetadata.CorrelationId, answer.Metadata.CorrelationId);
//Result_metadata_has_processed_history_filled_from_aggregate()
//Assert.Equal(1, answer.Metadata.History?.Steps.Count);
////Result_metadata_has_processed_correct_filled_history_step()
//var step = answer.Metadata.History.Steps.First();
//
//Assert.Equal(nameof(BalloonCreatedFaultyProjection), step.Who);
//Assert.Equal(MessageHandlingConstants.MessageProcessCasuedAnError, step.Why);
//Assert.Equal(MessageHandlingConstants.PublishingFault, step.What);
}
public async Task When_Executing_command_events_should_be_projected()
{
var autoTestDb = ConnectionStrings.AutoTestDb;
var dbOptions = new DbContextOptionsBuilder <BalloonContext>().UseSqlServer(autoTestDb).Options;
//warm up EF
using (var context = new BalloonContext(dbOptions))
{
context.BalloonCatalog.Add(new BalloonCatalogItem()
{
BalloonId = Guid.NewGuid().ToString(), LastChanged = DateTime.UtcNow, Title = "WarmUp"
});
await context.SaveChangesAsync();
}
await TestDbTools.Truncate(autoTestDb, "BalloonCatalog");
var cmd = new InflateNewBallonCommand(123, Guid.NewGuid().ToString());
await Node.Prepare(cmd)
.Expect <BalloonCreatedNotification>()
.Execute(TimeSpan.FromSeconds(30));
using (var context = new BalloonContext(dbOptions))
{
var catalogItem = await context.BalloonCatalog.FindAsync(cmd.AggregateId);
Assert.Equal(cmd.Title.ToString(), catalogItem.Title);
}
}
public async Task When_execute_aggregate_command_with_metadata()
{
_command = new InflateNewBallonCommand(1, Guid.NewGuid().ToString());
_commandMetadata = MessageMetadata.New(_command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(_command, _commandMetadata)
.Expect <BalloonCreated>()
.Execute();
var messageMetadata = res.ReceivedMetadata;
var balloonCreated = res.Received;
Assert.NotNull(messageMetadata);
//Result_contains_message()
Assert.NotNull(balloonCreated);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <BalloonCreated>(balloonCreated);
//Result_message_has_expected_id()
Assert.Equal(_command.AggregateId, balloonCreated.SourceId);
//Result_message_has_expected_value()
Assert.Equal(_command.Title.ToString(), balloonCreated.Value);
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal(_command.Id, messageMetadata.CasuationId);
//Result_metadata_has_correlation_id_same_as_command_metadata()
Assert.Equal(_commandMetadata.CorrelationId, messageMetadata.CorrelationId);
//Result_metadata_has_processed_history_filled_from_aggregate()
//Assert.Equal(1, messageMetadata.History?.Steps.Count);
////Result_metadata_has_processed_correct_filled_history_step()
//var step = messageMetadata.History.Steps.First();
//
//Assert.Equal(AggregateActorName.New<Balloon>(_command.AggregateId).Name, step.Who);
//Assert.Equal(AggregateActorConstants.CommandExecutionCreatedAnEvent, step.Why);
//Assert.Equal(AggregateActorConstants.PublishingEvent, step.What);
}
public async Task Given_default_policy()
{
var aggregateId = Guid.NewGuid().ToString();
var initialParameter = 1;
var cmd = new InflateNewBallonCommand(initialParameter, aggregateId);
await Node.Prepare(cmd)
.Expect <BalloonCreated>()
.Execute();
var changedParameter = 2;
var changeSampleAggregateCommand = new WriteTitleCommand(changedParameter, aggregateId);
await Node.Prepare(changeSampleAggregateCommand)
.Expect <BalloonTitleChanged>()
.Execute();
Thread.Sleep(1000);
var aggregates = await AggregateSnapshotRepository.New(AutoTestNodeDbConfiguration.Default.JournalConnectionString,
BalloonAggregateFactory.Default)
.Load <Balloon>(aggregateId);
//Snapshots_should_be_saved_two_times()
Assert.Equal(2, aggregates.Length);
//Restored_aggregates_should_have_same_ids()
Assert.True(aggregates.All(s => s.Payload.Id == aggregateId));
//First_snapshot_should_have_parameters_from_first_command()
Assert.Equal(initialParameter.ToString(), aggregates.First().Payload.Title);
//Second_snapshot_should_have_parameters_from_second_command()
Assert.Equal(changedParameter.ToString(), aggregates.Skip(1).First().Payload.Title);
}
public Isolated_Console_can_execute_commands()
{
var connector = new GridNodeConnector(new ServerConfiguration(),
new NodeConfiguration("Console", new NodeNetworkAddress()));
connector.Connect().Wait();
var command = new InflateNewBallonCommand(42, Guid.NewGuid().ToString());
connector.Execute(command).Wait();
Success = true;
}
public async Task Then_domain_events_should_be_upgraded_by_json_custom_adapter()
{
var cmd = new InflateNewBallonCommand(1, Guid.NewGuid().ToString());
await Node.Prepare(cmd).
Expect <BalloonCreated>().
Execute();
var aggregate = await Node.LoadAggregate <Balloon>(cmd.AggregateId);
Assert.Equal("101", aggregate.Title);
}
public ClientLaunch_wait_for_command_produced_events()
{
var connector = new GridNodeConnector(new ServerConfiguration(),
new NodeConfiguration("Console", new NodeNetworkAddress()));
connector.Connect().Wait();
var command = new InflateNewBallonCommand(42, Guid.NewGuid().ToString());
connector.Prepare(command)
.Expect <BalloonCreated>()
.Execute().Wait();
Success = true;
}
