public async void start_then_rebuild()
{
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(1));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(2));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
Thread.Sleep(50);
await Engine.UpdateAndWait();
Assert.AreEqual(2, _reader1.AllSortedById.Count());
Assert.That(_reader1.AllSortedById.Count(r => r.IsInRebuild), Is.EqualTo(0));
//now rebuild.
ReInitAndRebuild(2);
Assert.AreEqual(2, _reader1.AllSortedById.Count());
Assert.That(_reader1.AllSortedById.Count(r => r.IsInRebuild), Is.EqualTo(2));
var checkpoint = _checkpoints.FindOneById("Projection");
Assert.That(checkpoint.Value, Is.EqualTo(2), "Checkpoint Value is not written after rebuild.");
Assert.That(checkpoint.Current, Is.EqualTo(2), "Checkpoint Current is written after rebuild.");
}
public async void verify_basic_rebuild_with_new_projection_different_slot()
{
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(1));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(2));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
Thread.Sleep(50);
await Engine.UpdateAndWait();
Assert.AreEqual(2, _reader1.AllSortedById.Count());
Assert.That(_reader1.AllSortedById.Count(r => r.IsInRebuild), Is.EqualTo(0));
Assert.AreEqual(0, _reader3.AllSortedById.Count(), "Third projection should not be enabled!!");
//now rebuild.
returnTwoProjection = true;
ReInitAndRebuild(2);
Assert.AreEqual(2, _reader1.AllSortedById.Count());
Assert.That(_reader1.AllSortedById.Count(r => r.IsInRebuild), Is.EqualTo(2));
var checkpoint = _checkpoints.FindOneById("Projection");
Assert.That(checkpoint.Value, Is.EqualTo(2), "Checkpoint is written after rebuild.");
Assert.That(checkpoint.Current, Is.EqualTo(2), "Checkpoint is written after rebuild.");
Assert.AreEqual(2, _reader3.AllSortedById.Count());
Assert.That(_reader3.AllSortedById.Count(r => r.IsInRebuild), Is.EqualTo(0), "New projection in new slot does not undergo rebuilding");
checkpoint = _checkpoints.FindOneById("Projection3");
Assert.That(checkpoint.Value, Is.EqualTo(2), "Checkpoint is written after rebuild.");
Assert.That(checkpoint.Current, Is.EqualTo(2), "Checkpoint is written after rebuild.");
}
public void can_serialize_access_to_the_same_entity()
{
//create an aggregate.
var sampleAggregateId = new SampleAggregateId(1);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregate.State(), sampleAggregateId);
aggregate.Create();
_sut.Save(aggregate, new Guid("135E4E5F-3D65-43AC-9D8D-8A8B0EFF8501"), null);
NeventStoreExGlobalConfiguration.SetLockThreadSleepCount(100);
using (var repo1 = CreateRepository())
using (var repo2 = CreateRepository())
{
aggregate = repo1.GetById <SampleAggregate>(sampleAggregateId);
aggregate.Touch();
//now create another thread that loads and change the same entity
var task = Task <Boolean> .Factory.StartNew(() =>
{
var aggregate2 = repo2.GetById <SampleAggregate>(sampleAggregateId);
aggregate2.Touch();
repo2.Save(aggregate2, Guid.NewGuid(), null);
return(true);
});
Thread.Sleep(100); //Let be sure the other task is started doing something.
repo1.Save(aggregate, Guid.NewGuid(), null); //should not throw
Assert.IsTrue(task.Result); //inner should not throw.
}
}
public async void stop_and_restart_polling_should_work()
{
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(1));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
Boolean checkpointPassed = WaitForCheckpoint("1");
Assert.IsTrue(checkpointPassed, "Automatic poller does not work.");
Engine.Stop();
aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(2));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
checkpointPassed = WaitForCheckpoint("2");
Assert.IsFalse(checkpointPassed, "Automatic poller is still working after stop.");
Engine.Start();
checkpointPassed = WaitForCheckpoint("2");
Assert.IsTrue(checkpointPassed, "Automatic poller is not restarted correctly.");
}
public void verify_persistence_honor_database_version_when_threshold_passed()
{
var sampleAggregateId = new SampleAggregateId(_counter++);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregate.State(), sampleAggregateId);
var memento = new AggregateSnapshot <SampleAggregate.State>()
{
Id = sampleAggregateId, Version = 30, State = new SampleAggregate.State()
};
var snapshot = new Snapshot("Jarvis", sampleAggregateId, 30, memento);
_persister.Load(null, 0, null).ReturnsForAnyArgs(snapshot);
//Simulate the flow of a repository, first operation load the snapshot
_sut.Load(sampleAggregateId, Int32.MaxValue, typeof(SampleAggregate));
//then the repository restored the snapshot
((ISnapshotable)aggregate).Restore(memento);
//now iterate
_persister.DidNotReceiveWithAnyArgs().Persist(null, null);
for (int i = 0; i < NumberOfCommitsBeforeSnapshot; i++)
{
aggregate.Touch();
}
_sut.Snapshot(aggregate, "Jarvis", NumberOfCommitsBeforeSnapshot);
//should be persisted, becauase it is loaded at version 30, but then another snapshotthreshold count of event were raised
_persister.ReceivedWithAnyArgs().Persist(null, aggregate.GetType().FullName);
}
public async void verify_projection_removed()
{
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(1));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(2));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
var stream = _eventStore.Advanced.GetFrom(0);
var lastCommit = stream.Last();
await Engine.UpdateAndWait();
Assert.That(_statusChecker.IsCheckpointProjectedByAllProjection(lastCommit.CheckpointToken), Is.True);
//now projection 3 is not returned anymore, it simulates a projection that is no more active
returnProjection3 = false;
ConfigureEventStore();
ConfigureProjectionEngine();
aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(3));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
stream = _eventStore.Advanced.GetFrom(0);
lastCommit = stream.Last();
await Engine.UpdateAndWait();
Assert.That(_statusChecker.IsCheckpointProjectedByAllProjection(lastCommit.CheckpointToken), Is.True);
}
protected void CreateAggregate(Int64 id = 1)
{
var aggregateId = new SampleAggregateId(id);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(aggregateId);
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
}
public void verify_snapshot_on_new_aggregate_not_call_persistence()
{
var sampleAggregateId = new SampleAggregateId(_counter++);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregate.State(), sampleAggregateId);
aggregate.Create();
_sut.Snapshot(aggregate, "Jarvis", 1);
_persister.DidNotReceiveWithAnyArgs().Persist(null, null);
}
public async void run_poll_and_wait()
{
var reader = new MongoReader <SampleReadModel, string>(Database);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(1));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
Thread.Sleep(50);
await Engine.UpdateAndWait();
Assert.AreEqual(1, reader.AllSortedById.Count());
}
public void can_save_and_load()
{
var sampleAggregateId = new SampleAggregateId(1);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregate.State(), sampleAggregateId);
aggregate.Create();
_sut.Save(aggregate, new Guid("135E4E5F-3D65-43AC-9D8D-8A8B0EFF8501"), null);
var loaded = _sut.GetById <SampleAggregate>(sampleAggregateId);
Assert.IsTrue(loaded.HasBeenCreated);
}
public async void run_poller()
{
var projected = _statusChecker.IsCheckpointProjectedByAllProjection(2);
if (projected)
{
var allProjected = _checkpoints.FindAll().ToList();
foreach (var checkpoint in allProjected)
{
Console.WriteLine("Projection {0} at checkpoint {1}",
checkpoint.Signature, checkpoint.Current);
}
}
Console.WriteLine("FIRST CHECK DONE");
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(1));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(2));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
var stream = _eventStore.Advanced.GetFrom(0);
var lastCommit = stream.Last();
//need to wait for at least one checkpoint written to database.
DateTime startTime = DateTime.Now;
while (!_checkpoints.FindAll().Any() &&
DateTime.Now.Subtract(startTime).TotalMilliseconds < 2000) //2 seconds timeout is fine
{
Thread.Sleep(100);
}
projected = _statusChecker.IsCheckpointProjectedByAllProjection(lastCommit.CheckpointToken);
if (projected)
{
var allProjected = _checkpoints.FindAll().ToList();
foreach (var checkpoint in allProjected)
{
Console.WriteLine("Projection {0} at checkpoint {1}",
checkpoint.Signature, checkpoint.Current);
}
}
Assert.That(projected, Is.False);
await Engine.UpdateAndWait();
Assert.That(_statusChecker.IsCheckpointProjectedByAllProjection(lastCommit.CheckpointToken), Is.True);
}
public void FactoryTest()
{
// Arrange
var creater = new TestAggregateFactory();
var id = Guid.NewGuid();
// Act
var aggregate = creater.Create(id);
// Assert
Assert.Equal(0, aggregate.Version);
Assert.Equal(id, aggregate.Id);
Assert.False(aggregate.IsEnabled);
Assert.Null(aggregate.TestProp);
}
public async void start_with_rebuild_then_stop_rebuild()
{
var reader = new MongoReader <SampleReadModel, string>(Database);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(1));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
Thread.Sleep(50);
await Engine.UpdateAndWait();
Assert.AreEqual(1, reader.AllSortedById.Count());
var checkpoint = _checkpoints.FindOneById("Projection");
Assert.That(checkpoint.Value, Is.EqualTo("1"), "Checkpoint is written after rebuild.");
}
public void verify_saving_snapshot()
{
//create an aggregate.
var sampleAggregateId = new SampleAggregateId(1);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregate.State(), sampleAggregateId);
aggregate.Create();
for (int i = 0; i < NumberOfCommitsBeforeSnapshot; i++)
{
((IAggregateEx)aggregate).ApplyEvent(new SampleAggregateTouched());
}
var events = _sut.Save(aggregate, new Guid("135E4E5F-3D65-43AC-9D8D-8A8B0EFF8501"), null);
_sut.SnapshotManager.Received().Snapshot(aggregate, "Jarvis", events);
}
public async void verify_priority_is_maintained()
{
var reader = new MongoReader <SampleReadModel, string>(Database);
var reader2 = new MongoReader <SampleReadModel2, string>(Database);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(1));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
Thread.Sleep(100);
await Engine.UpdateAndWait();
var rm = reader.AllUnsorted.Single();
var rm2 = reader2.AllUnsorted.Single();
Assert.That(rm2.Timestamp, Is.LessThan(rm.Timestamp));
}
public void can_save_with_aggregate_identity()
{
var sampleAggregateId = new SampleAggregateId(1);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(
new SampleAggregate.State(),
sampleAggregateId
);
aggregate.Create();
_sut.Save(aggregate, new Guid("135E4E5F-3D65-43AC-9D8D-8A8B0EFF8501"), null);
var stream = _eventStore.OpenStream("Jarvis", sampleAggregateId, int.MinValue, int.MaxValue);
Assert.IsNotNull(stream);
Assert.AreEqual(1, stream.CommittedEvents.Count);
}
public void verify_persistence_called_after_threshold_new_aggregate()
{
var sampleAggregateId = new SampleAggregateId(_counter++);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregate.State(), sampleAggregateId);
aggregate.Create();
_sut.Snapshot(aggregate, "Jarvis", 1);
_persister.DidNotReceiveWithAnyArgs().Persist(null, null);
for (int i = 0; i < NumberOfCommitsBeforeSnapshot; i++)
{
aggregate.Touch();
}
_sut.Snapshot(aggregate, "Jarvis", NumberOfCommitsBeforeSnapshot);
//should be persisted because it has more events than snapshotreshold
_persister.ReceivedWithAnyArgs().Persist(null, aggregate.GetType().FullName);
}
public void CreateTest()
{
// Arrange
var creater = new TestAggregateFactory();
var id = Guid.NewGuid();
// Act
var aggregate = creater.Create(id);
aggregate.AddEvent(new CreateTestEvent(Guid.NewGuid(), id, 0));
aggregate.CommitEvents();
// Assert
Assert.Equal(1, aggregate.Version);
Assert.Equal(id, aggregate.Id);
Assert.True(aggregate.IsEnabled);
Assert.NotNull(aggregate.TestProp);
}
public void profile_snapshot_opt_out()
{
var sampleAggregateId = new SampleAggregateId(1);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregate.State(), sampleAggregateId);
aggregate.Create();
_sut.Save(aggregate, Guid.NewGuid(), null);
int max = 20;
for (int t = 1; t < max; t++)
{
aggregate.Touch();
_sut.Save(aggregate, Guid.NewGuid(), null);
if (t == max - 5)
{
var snap = ((ISnapshotable)aggregate).GetSnapshot();
_eventStore.Advanced.AddSnapshot(new Snapshot("Jarvis", sampleAggregateId.AsString(), aggregate.Version, snap));
}
}
SnapshotsSettings.OptOut(typeof(SampleAggregate));
var sw = new Stopwatch();
sw.Start();
for (int c = 1; c <= 100; c++)
{
using (var repo = new RepositoryEx(
_eventStore,
_aggregateFactory,
new ConflictDetector(),
_identityConverter,
NSubstitute.Substitute.For <NEventStore.Logging.ILog>()))
{
var loaded = repo.GetById <SampleAggregate>(sampleAggregateId);
}
}
sw.Stop();
SnapshotsSettings.ClearOptOut();
Debug.WriteLine("Read time {0} ms", sw.ElapsedMilliseconds);
}
public void save_stream()
{
var eventStore = _factory.BuildEventStore(_connectionString);
var repo = new RepositoryEx(
eventStore,
new AggregateFactory(),
new ConflictDetector(),
new IdentityManager(new InMemoryCounterService())
);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregate.State(), new SampleAggregateId(1));
aggregate.Create();
repo.Save(
aggregate,
new Guid("{7A63A302-5575-4148-A86D-4421AAFF2019}"),
null
);
}
public void can_reuse_repository_with_same_aggregate()
{
var sampleAggregateId = new SampleAggregateId(1);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(
new SampleAggregate.State(),
sampleAggregateId
);
aggregate.Create();
_sut.Save(aggregate, Guid.NewGuid(), null);
aggregate.Touch();
_sut.Save(aggregate, Guid.NewGuid(), null);
var stream = _eventStore.OpenStream("Jarvis", sampleAggregateId, int.MinValue, int.MaxValue);
Assert.IsNotNull(stream);
Assert.AreEqual(2, stream.CommittedEvents.Count);
}
public void verify_basic_unwinding_with_headers()
{
var aggregateId = new SampleAggregateId(1);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(aggregateId);
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { h.Add("test.with.dot", "BLAH"); });
sut.Unwind();
var allEvents = sut.UnwindedCollection.FindAll();
Assert.That(allEvents.Count(), Is.EqualTo(1));
var evt = allEvents.Single();
Assert.That(evt.EventType, Is.EqualTo("SampleAggregateCreated"));
Assert.That(evt.GetEvent().AggregateId, Is.EqualTo(aggregateId));
Assert.That(evt.GetEvent().Context["test.with.dot"], Is.EqualTo("BLAH"));
}
public async void run_poller()
{
var reader = new MongoReader <SampleReadModel, string>(Database);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(1));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(2));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
var stream = _eventStore.Advanced.GetFrom("0");
var lastCommit = stream.Last();
Assert.That(_statusChecker.IsCheckpointProjectedByAllProjection(lastCommit.CheckpointToken), Is.False);
await Engine.UpdateAndWait();
Assert.That(_statusChecker.IsCheckpointProjectedByAllProjection(lastCommit.CheckpointToken), Is.True);
}
public void raise_exception_if_invariants_are_not_satisfied()
{
var sampleAggregateId = new SampleAggregateId(1);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregate.State(), sampleAggregateId);
aggregate.Create();
aggregate.InvalidateState();
try
{
_sut.Save(aggregate, new Guid("135E4E5F-3D65-43AC-9D8D-8A8B0EFF8501"), null);
Assert.Fail("We expect an exception");
}
catch (InvariantNotSatifiedException ex)
{
Assert.That(ex.AggregateId, Is.EqualTo(sampleAggregateId.AsString()));
}
catch (Exception ex)
{
Assert.Fail("We expect an exception of type InvariantNotSatifiedException but we catched " + ex.GetType().Name);
}
}
public void UpdateTest()
{
// Arrange
var creater = new TestAggregateFactory();
var id = Guid.NewGuid();
var expectedValue = "test";
// Act
var aggregate = creater.Create(id);
aggregate.AddEvents(new List <IEvent>
{
new UpdateTestEvent(Guid.NewGuid(), id, 1, expectedValue),
new CreateTestEvent(Guid.NewGuid(), id, 0)
});
aggregate.CommitEvents();
// Assert
Assert.Equal(2, aggregate.Version);
Assert.Equal(id, aggregate.Id);
Assert.True(aggregate.IsEnabled);
Assert.Equal(expectedValue, aggregate.TestProp);
}
public async void Verify_aggregation_call()
{
ProjectionStatusLoader sut = new ProjectionStatusLoader(Database, Database, 5);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(1));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregateId(2));
aggregate.Create();
Repository.Save(aggregate, Guid.NewGuid(), h => { });
var stream = _eventStore.Advanced.GetFrom(0);
var lastCommit = stream.Last();
await Engine.UpdateAndWait();
var result = sut.GetSlotMetrics();
Assert.That(result.Count(), Is.EqualTo(2));
Assert.That(result.ElementAt(0).CommitBehind, Is.EqualTo(0));
Assert.That(result.ElementAt(0).CommitBehind, Is.EqualTo(0));
}
public void verify_reloading_with_snapshot()
{
//create an aggregate.
var sampleAggregateId = new SampleAggregateId(1);
var aggregate = TestAggregateFactory.Create <SampleAggregate, SampleAggregate.State>(new SampleAggregate.State(), sampleAggregateId);
aggregate.Create();
for (int i = 0; i < NumberOfCommitsBeforeSnapshot; i++)
{
((IAggregateEx)aggregate).ApplyEvent(new SampleAggregateTouched());
}
_sut.SnapshotManager = new CachedSnapshotManager(
new MongoSnapshotPersisterProvider(_db, NullLogger.Instance),
new NullSnapshotPersistenceStrategy());
//this will save the snapshot
_sut.Save(aggregate, new Guid("135E4E5F-3D65-43AC-9D8D-8A8B0EFF8501"), null);
var discriminated = BsonSerializer.IsTypeDiscriminated(typeof(AggregateSnapshot <>));
Console.WriteLine("Discriminated: {0}", discriminated);
//now reload the aggregate
var reloaded = _sut.GetById <SampleAggregate>(sampleAggregateId);
Assert.That(reloaded.SnapshotRestoreVersion, Is.EqualTo(51));
}
