public void Given_timeout_only_default_policy()
{
_aggregateId = Guid.NewGuid();
_initialParameter = 1;
var cmd = new CreateSampleAggregateCommand(_initialParameter, _aggregateId);
GridNode.NewCommandWaiter(Timeout)
.Expect <SampleAggregateCreatedEvent>()
.Create()
.Execute(cmd)
.Wait();
//checking "time-out" rule for policy, snapshots should be saved once on second command
Thread.Sleep(1000);
_changedParameter = 2;
var changeCmds = new[]
{
new ChangeSampleAggregateCommand(_changedParameter, _aggregateId)
};
GridNode.NewCommandWaiter(Timeout)
.Expect <SampleAggregateChangedEvent>()
.Create()
.Execute(changeCmds)
.Wait();
Thread.Sleep(TimeSpan.FromSeconds(1));
_snapshots = new AggregateSnapshotRepository(AkkaConf.Persistence.JournalConnectionString, GridNode.AggregateFromSnapshotsFactory).Load <SampleAggregate>(_aggregateId);
}
private static Task <IWaitResults> WaitAggregateCommands(int changeNumber, Random random, GridDomainNode node)
{
var commands = new List <ICommand>(changeNumber + 1);
var createCmd = new CreateSampleAggregateCommand(random.Next(), Guid.NewGuid());
commands.Add(createCmd);
var expectBuilder = node.NewCommandWaiter()
.Expect <SampleAggregateCreatedEvent>(e => e.SourceId == createCmd.AggregateId);
var changeCmds = Enumerable.Range(0, changeNumber)
.Select(n => new ChangeSampleAggregateCommand(random.Next(), createCmd.AggregateId))
.ToArray();
commands.AddRange(changeCmds);
foreach (var cmd in changeCmds)
{
expectBuilder.And <SampleAggregateChangedEvent>(e => e.SourceId == cmd.AggregateId && e.Value == cmd.Parameter.ToString());
}
return(expectBuilder.Create()
.Execute(commands.ToArray()));
}
public void Start()
{
var cmd = new CreateSampleAggregateCommand(1, Guid.NewGuid());
GridNode.NewCommandWaiter()
.Expect <SampleAggregateCreatedEvent>()
.Create()
.Execute(cmd);
var aggregate = LookupAggregateActor <SampleAggregate>(cmd.AggregateId);
Watch(aggregate);
ExpectMsg <Terminated>(t => t.ActorRef.Path == aggregate.Path, Timeout);
ExpectNoMsg(TimeSpan.FromSeconds(5));
//wait until next clear childs message
Thread.Sleep(6);
//hubs does not close after child terminates
char pooledLetter = 'a';
for (int n = 0; n < Environment.ProcessorCount; n++)
{
var pooledHub = LookupAggregateHubActor <SampleAggregate>("$" + pooledLetter++);
pooledHub.Ask <HealthStatus>(new CheckHealth("123")).Wait();
}
}
public void Given_default_policy()
{
_aggregateId = Guid.NewGuid();
_initialParameter = 1;
var cmd = new CreateSampleAggregateCommand(_initialParameter, _aggregateId);
GridNode.NewCommandWaiter(Timeout)
.Expect <SampleAggregateCreatedEvent>()
.Create()
.Execute(cmd)
.Wait();
_changedParameter = 2;
var changeCmds = new[]
{
new ChangeSampleAggregateCommand(_changedParameter, _aggregateId)
};
GridNode.NewCommandWaiter(Timeout)
.Expect <SampleAggregateChangedEvent>()
.Create()
.Execute(changeCmds)
.Wait();
Thread.Sleep(100);
_snapshots = new AggregateSnapshotRepository(AkkaConf.Persistence.JournalConnectionString, GridNode.AggregateFromSnapshotsFactory).Load <SampleAggregate>(_aggregateId);
}
public async Task Console_commands_are_executed_by_remote_node()
{
var command = new CreateSampleAggregateCommand(42, Guid.NewGuid());
var evt = await _connector.PrepareCommand(command)
.Expect <SampleAggregateCreatedEvent>()
.Execute();
Assert.AreEqual(command.Parameter.ToString(), evt.Message <SampleAggregateCreatedEvent>().Value);
}
public async Task Then_domain_events_should_be_upgraded_by_json_custom_adapter()
{
var cmd = new CreateSampleAggregateCommand(1, Guid.NewGuid());
await GridNode.PrepareCommand(cmd)
.Expect <SampleAggregateCreatedEvent>()
.Execute();
var aggregate = LoadAggregate <SampleAggregate>(cmd.AggregateId);
Assert.AreEqual("101", aggregate.Value);
}
public void When_execute_aggregate_command_with_metadata()
{
_command = new CreateSampleAggregateCommand(1, Guid.NewGuid());
_commandMetadata = new MessageMetadata(_command.Id, BusinessDateTime.Now, Guid.NewGuid());
var res = GridNode.NewCommandWaiter()
.Expect <IMessageMetadataEnvelop <SampleAggregateCreatedEvent> >()
.Create()
.Execute(_command, _commandMetadata)
.Result;
_answer = res.Message <IMessageMetadataEnvelop <SampleAggregateCreatedEvent> >();
}
public async Task When_execute_aggregate_command_with_metadata()
{
_command = new CreateSampleAggregateCommand(1, Guid.NewGuid());
_commandMetadata = new MessageMetadata(_command.Id, BusinessDateTime.Now, Guid.NewGuid());
var res = await GridNode.NewCommandWaiter(null, false)
.Expect <IMessageMetadataEnvelop <SampleAggregateCreatedEvent> >()
.And <IMessageMetadataEnvelop <IFault <SampleAggregateCreatedEvent> > >()
.Create()
.Execute(_command, _commandMetadata);
_answer = res.Message <IMessageMetadataEnvelop <IFault <SampleAggregateCreatedEvent> > >();
_aggregateEvent = res.Message <IMessageMetadataEnvelop <SampleAggregateCreatedEvent> >();
}
public void Given_save_on_each_message_policy_and_keep_2_snapshots()
{
_aggregateId = Guid.NewGuid();
var cmd = new CreateSampleAggregateCommand(1, _aggregateId);
GridNode.NewCommandWaiter()
.Expect <SampleAggregateCreatedEvent>()
.Create()
.Execute(cmd)
.Wait();
var aggregateActorRef = LookupAggregateActor <SampleAggregate>(_aggregateId);
aggregateActorRef.Tell(new NotifyOnPersistenceEvents(TestActor), TestActor);
var commands = new List <ICommand>();
var waiter = GridNode.NewCommandWaiter(TimeSpan.FromMinutes(5))
.Expect <object>();
for (var cmdNum = 0; cmdNum < 5; cmdNum++)
{
var changeCmd = new ChangeSampleAggregateCommand(cmdNum, _aggregateId);
waiter.And <SampleAggregateChangedEvent>(e => e.Value == changeCmd.Parameter.ToString());
commands.Add(changeCmd);
_parameters[cmdNum] = cmdNum;
}
waiter.Create()
.Execute(commands.ToArray())
.Wait();
Watch(aggregateActorRef);
aggregateActorRef.Tell(GracefullShutdownRequest.Instance, TestActor);
FishForMessage <Terminated>(m => true, TimeSpan.FromMinutes(10));
_snapshots = new AggregateSnapshotRepository(AkkaConf.Persistence.JournalConnectionString, GridNode.AggregateFromSnapshotsFactory).Load <SampleAggregate>(_aggregateId);
}
