private static SampleAggregate WhenRaiseAsyncEvents()
{
var aggregate = new SampleAggregate(Guid.NewGuid(), null);
aggregate.ChangeStateAsync(42, TimeSpan.FromMilliseconds(500));
return(aggregate);
}
public Guid When(StartCommand cmd)
{
var sampleId = CombGuid.Generate();
var agg = new SampleAggregate(null);
agg.Start(sampleId, cmd.Name);
_repository.Save(agg);
return sampleId;
}
public void Given_SyncExecute_until_projection_build_event_wait_by_caller()
{
_syncCommand = new LongOperationCommand(1000, Guid.NewGuid());
var expectedMessage = Expect.Message <AggregateChangedEventNotification>(e => e.AggregateId, _syncCommand.AggregateId);
_changedEvent = GridNode.Execute(CommandPlan.New(_syncCommand, Timeout, expectedMessage)).Result;
_aggregate = LoadAggregate <SampleAggregate>(_syncCommand.AggregateId);
}
public void Test()
{
_aggregate = new SampleAggregate(Guid.NewGuid(), "test");
_aggregate.ChangeState(10);
_aggregate.ClearEvents();
var jsonString = JsonConvert.SerializeObject(_aggregate, DomainSerializer.GetDefaultSettings());
_restoredAggregate = JsonConvert.DeserializeObject <SampleAggregate>(jsonString, DomainSerializer.GetDefaultSettings());
}
public void Test()
{
_aggregate = new SampleAggregate(Guid.NewGuid(), "test");
_aggregate.ChangeState(10);
_aggregate.ClearEvents();
var repo = new AggregateSnapshotRepository(AkkaConf.Persistence.JournalConnectionString, GridNode.AggregateFromSnapshotsFactory);
repo.Add(_aggregate);
_restoredAggregate = LoadAggregate <SampleAggregate>(_aggregate.Id);
}
public async Task command_handler_should_pass_if_modified_since_check_is_ok()
{
SampleAggregate aggregate = await CreateAndSaveAggregate().ConfigureAwait(false);
var cmd = new TouchSampleAggregate(new SampleAggregateId(1));
var startVersion = aggregate.Version;
cmd.SetContextData(MessagesConstants.IfVersionEqualsTo, startVersion.ToString());
await _sut.HandleAsync(cmd).ConfigureAwait(false);
Assert.That(_sut.Aggregate.Version, Is.EqualTo(startVersion + 1));
}
public async Task command_handler_should_throw_if_modified_since_check_fails()
{
SampleAggregate aggregate = await CreateAndSaveAggregate().ConfigureAwait(false);
var cmd = new TouchSampleAggregate(new SampleAggregateId(1));
cmd.SetContextData(MessagesConstants.IfVersionEqualsTo, aggregate.Version.ToString());
//now simulate another change of the entity
aggregate.Touch();
await _repositoryEx.SaveAsync(aggregate, Guid.NewGuid().ToString(), null).ConfigureAwait(false);
Assert.ThrowsAsync <AggregateModifiedException>(async() => await _sut.HandleAsync(cmd).ConfigureAwait(false));
}
public void Given_command_executes_with_waiter_When_fetching_results()
{
_syncCommand = new LongOperationCommand(1000, Guid.NewGuid());
_results = GridNode.NewCommandWaiter(Timeout)
.Expect <AggregateChangedEventNotification>(e => e.AggregateId == _syncCommand.AggregateId)
.Create()
.Execute(_syncCommand)
.Result;
_changedEvent = _results.Message <AggregateChangedEventNotification>();
_aggregate = LoadAggregate <SampleAggregate>(_syncCommand.AggregateId);
}
public void Given_persisted_aggreate()
{
_aggregateId = Guid.NewGuid();
_agregateValue = "initial";
var aggregate = new SampleAggregate(_aggregateId, _agregateValue);
using (var repo = new AggregateRepository(ActorSystemEventRepository.New(new AutoTestAkkaConfiguration(), new EventsAdaptersCatalog())))
{
repo.Save(aggregate);
}
using (var repo = new AggregateRepository(ActorSystemEventRepository.New(new AutoTestAkkaConfiguration(), new EventsAdaptersCatalog())))
{
_aggregate = repo.LoadAggregate <SampleAggregate>(aggregate.Id);
}
}
public void Given_only_aggregate_events_persisted_it_can_be_loaded(IRepository <DomainEvent> eventRepo, AggregateRepository aggrRepo)
{
try
{
_sourceId = Guid.NewGuid();
_createdEvent = new SampleAggregateCreatedEvent("initial value", _sourceId);
_changedEvent = new SampleAggregateChangedEvent("changed value", _sourceId);
string persistenceId = AggregateActorName.New <SampleAggregate>(_sourceId).ToString();
eventRepo.Save(persistenceId, _createdEvent, _changedEvent);
_aggregate = aggrRepo.LoadAggregate <SampleAggregate>(_sourceId);
Assert.AreEqual(_sourceId, _aggregate.Id);
Assert.AreEqual(_changedEvent.Value, _aggregate.Value);
}
finally
{
eventRepo.Dispose();
aggrRepo.Dispose();
}
}
public AggregateExpression Sample(SparqlExpression expression)
{
var aggregate = new SampleAggregate(expression.Expression);
return(new AggregateExpression(aggregate));
}
public AggregateExpression Sample(VariableTerm variable)
{
var aggregate = new SampleAggregate(variable);
return(new AggregateExpression(aggregate));
}
protected override void Given()
{
Sut = new SampleAggregate(null);
}
protected override void Given()
{
Sut = new SampleAggregate(null);
}
