public void QuartzJob_should_be_deserialized_from_new_wire_format()
{
var cmd = new ChangeSampleAggregateCommand(1, Guid.NewGuid());
var evt = new SampleAggregateCreatedEvent("1", cmd.AggregateId);
var scheduleKey = ScheduleKey.For(cmd);
var oldSerializer = new Serializer(new SerializerOptions(true, true, null, null));
var streamEvent = new MemoryStream();
oldSerializer.Serialize(evt, streamEvent);
var serializedEvent = streamEvent.ToArray();
var streamKey = new MemoryStream();
oldSerializer.Serialize(scheduleKey, streamKey);
var serializedKey = streamKey.ToArray();
var jobDataMap = new JobDataMap
{
{ "EventKey", serializedEvent },
{ "ScheduleKey", serializedKey }
};
var job = QuartzJob.CreateJob(scheduleKey, jobDataMap);
var trigger = TriggerBuilder.Create()
.WithIdentity(job.Key.Name, job.Key.Group)
.WithSimpleSchedule(x => x.WithMisfireHandlingInstructionFireNow()
.WithRepeatCount(0))
.StartAt(BusinessDateTime.Now.AddSeconds(1))
.Build();
var scheduler = GridNode.Container.Resolve <IScheduler>();
scheduler.ScheduleJob(job, trigger);
var waiter = GridNode.NewWaiter(Timeout)
.Expect <SampleAggregateCreatedEvent>(e => e.SourceId == evt.SourceId)
.Create();
waiter.Wait();
}
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);
}
public async Task When_async_method_is_called_other_commands_can_be_executed_before_async_results()
{
var aggregateId = Guid.NewGuid();
var asyncCommand = new AsyncMethodCommand(43, Guid.NewGuid(), Guid.NewGuid(), TimeSpan.FromSeconds(3));
var syncCommand = new ChangeSampleAggregateCommand(42, aggregateId);
var asyncCommandTask = GridNode.PrepareCommand(asyncCommand)
.Expect <SampleAggregateChangedEvent>()
.Execute();
await GridNode.Execute(CommandPlan.New(syncCommand,
TimeSpan.FromSeconds(1),
Expect.Message <SampleAggregateChangedEvent>(e => e.SourceId,
syncCommand.AggregateId)));
var sampleAggregate = LoadAggregate <SampleAggregate>(syncCommand.AggregateId);
Assert.AreEqual(syncCommand.Parameter.ToString(), sampleAggregate.Value);
var waitResults = await asyncCommandTask;
Assert.AreEqual(asyncCommand.Parameter.ToString(), waitResults.Message <SampleAggregateChangedEvent>().Value);
}
