public void SnapshotStoreShouldNotThrowExceptionWhenNoSnapshotIsAvailable()
{
var persistentSnapshotStore = new InMemorySnapshotStore();
var snapshotStore = new SnapshotStore(persistentSnapshotStore);
Action act = () => snapshotStore.GetSnapshot(Guid.NewGuid());
act.ShouldNotThrow();
}
public async Task ShouldCreateAndGetSnapshots()
{
var snaphotRepository = new InMemorySnapshotStore <SomeDataAggregate>();
var eventFilterOne = new[] { "a", "b", "c" };
var entityA = $"{Guid.NewGuid()}";
var someDataAggregate = new SomeDataAggregate(entityA);
var snapshots = await snaphotRepository.GetByVersionOrLast(eventFilterOne);
Assert.NotNull(snapshots);
Assert.True(snapshots.Length == 0);
someDataAggregate.ApplyEvent(new SomeData(entityA, Guid.NewGuid())
{
EventNumber = 0
}, saveAsPendingEvent: false);
await snaphotRepository.Save(eventFilterOne, someDataAggregate);
snapshots = await snaphotRepository.GetByVersionOrLast(eventFilterOne);
Assert.NotNull(snapshots);
Assert.True(snapshots.Length == 1);
Assert.AreEqual(entityA, snapshots[0].EntityId);
snapshots = await snaphotRepository.GetByVersionOrLast(eventFilterOne, 0);
Assert.NotNull(snapshots);
Assert.True(snapshots.Length == 1);
Assert.AreEqual(entityA, snapshots[0].EntityId);
snapshots = await snaphotRepository.GetByVersionOrLast(eventFilterOne, 1);
Assert.NotNull(snapshots);
Assert.True(snapshots.Length == 0);
someDataAggregate.ApplyEvent(new SomeData(entityA, Guid.NewGuid())
{
EventNumber = 1
}, saveAsPendingEvent: false);
Assert.True(someDataAggregate.Version == 1);
await snaphotRepository.Save(eventFilterOne, someDataAggregate);
snapshots = await snaphotRepository.GetByVersionOrLast(eventFilterOne, 1);
Assert.NotNull(snapshots);
Assert.True(snapshots.Length == 1);
Assert.AreEqual(entityA, snapshots[0].EntityId);
}
public void SnapshotStoreLoadsSnapshotFromPersistentStore()
{
var persistentSnapshotStore = new InMemorySnapshotStore();
var snapshotStore = new SnapshotStore(persistentSnapshotStore);
var guid = Guid.NewGuid();
var aggregate = new TestSnapshotAggregate(guid, "Test aggregate");
snapshotStore.SaveSnapshot(aggregate);
snapshotStore.GetSnapshot(guid).Should().NotBeNull();
snapshotStore.GetSnapshot(guid).AggregateId.Should().Be(guid);
}
public void SnapshotStoreSavesSnapshotToPersistentStore()
{
var persistentSnapshotStore = new InMemorySnapshotStore();
var snapshotStore = new SnapshotStore(persistentSnapshotStore);
var guid = Guid.NewGuid();
var aggregate = new TestSnapshotAggregate(guid, "Test aggregate");
snapshotStore.SaveSnapshot(aggregate);
persistentSnapshotStore.Find(guid).FirstOrDefault().Should().NotBeNull();
persistentSnapshotStore.Find(guid).FirstOrDefault().AggregateId.Should().Be(guid);
}
public void SnapshotStoreShouldReturnTheCorrectAggregateType()
{
var persistentSnapshotStore = new InMemorySnapshotStore();
var snapshotStore = new SnapshotStore(persistentSnapshotStore);
var guid = Guid.NewGuid();
var aggregate = new TestSnapshotAggregate(guid, "Test aggregate");
snapshotStore.SaveSnapshot(aggregate);
var snapshot = snapshotStore.GetSnapshot(guid) as TestAggregateSnapshot;
snapshot.Should().NotBeNull();
}
public void SnapshotShouldBeSuccessfullyAppliedToAggregate()
{
var persistentSnapshotStore = new InMemorySnapshotStore();
var snapshotStore = new SnapshotStore(persistentSnapshotStore);
var guid = Guid.NewGuid();
const string name = "Test aggregate";
var aggregate = new TestSnapshotAggregate(guid, name);
snapshotStore.SaveSnapshot(aggregate);
var snapshot = snapshotStore.GetSnapshot(guid) as TestAggregateSnapshot;
var newAggregate = new TestSnapshotAggregate(Guid.NewGuid(), String.Empty);
newAggregate.SetSnapshot(snapshot);
newAggregate.Id.Should().Be(guid);
newAggregate.ReturnNameForTest().Should().Be(name);
}
public async Task ShouldCreateAndGetSnapshotsForSeveralStreams()
{
var snaphotRepository = new InMemorySnapshotStore <SomeDataAggregate>();
var eventFilterOne = new[] { "d", "e", "f" };
var eventFilterTwo = new[] { "g", "h", "i" };
var entityA = $"{Guid.NewGuid()}";
var entityB = $"{Guid.NewGuid()}";
var entityC = $"{Guid.NewGuid()}";
var someDataAggregateA = new SomeDataAggregate(entityA);
var someDataAggregateB = new SomeDataAggregate(entityB);
var someDataAggregateC = new SomeDataAggregate(entityC);
someDataAggregateA.ApplyEvent(new SomeData(entityA, Guid.NewGuid()), saveAsPendingEvent: false);
someDataAggregateB.ApplyEvent(new SomeData(entityB, Guid.NewGuid()), saveAsPendingEvent: false);
someDataAggregateC.ApplyEvent(new SomeData(entityC, Guid.NewGuid()), saveAsPendingEvent: false);
await snaphotRepository.Save(eventFilterOne, someDataAggregateA);
await snaphotRepository.Save(eventFilterOne, someDataAggregateB);
await snaphotRepository.Save(eventFilterTwo, someDataAggregateC);
var snapshots = await snaphotRepository.GetByVersionOrLast(eventFilterOne);
Assert.NotNull(snapshots);
Assert.True(snapshots.Length == 2);
snapshots = await snaphotRepository.GetByVersionOrLast(eventFilterTwo);
Assert.NotNull(snapshots);
Assert.True(snapshots.Length == 1);
var snapshot = await snaphotRepository.GetByVersionOrLast($"{entityA}", eventFilterTwo);
Assert.Null(snapshot);
snapshot = await snaphotRepository.GetByVersionOrLast($"{entityA}", eventFilterOne);
Assert.NotNull(snapshot);
}
public async Task VerionAppliedToSnapshot()
{
var id = Guid.NewGuid();
var store = new InMemoryEventStore();
var snapshotStore = new InMemorySnapshotStore();
var streamName = typeof(TestState).Name.AsStreamName(id).StreamName;
var arrangeVersion = await store.AppendToStreamAsync(streamName, 0, new IEvent[] { new AggregateId(id).Pipe(x => new TestEvent(x).AddTestMetaData <string>(x)) });
await ApplicationService.ExecuteAsync <TestState>
(store, new TestCommand(id),
state => new EventRecord[] { new TestEventRecord("test") }, e => Task.CompletedTask, snapshotStore, s => s.Version, (v, s) => s.Tap(x => x.Version = v));
var result = await store.LoadEventStreamAsync(streamName, 0);
var state = await snapshotStore.Get <TestState>(streamName);
Assert.Equal(1, arrangeVersion);
Assert.Equal(2, result.Version);
Assert.Equal(2, state.Version);
Assert.Equal(2, state.Applied.Count());
}
public static AggregateRepository <TAggregate> CreateEnvironment <TAggregate>(
out EventBus eventBus,
out EventStore eventStore,
out SnapshotStore snapshotStore,
out SnapshotProcessor snapshotProcessor,
out InMemorySnapshotStore memorySnapshotStore,
int snapshotThreashold = 10)
where TAggregate : IAggregateRoot, new()
{
TestDatabase.Items.Clear();
var savedHandler = new TestAggregateSavedEventHandler();
DependencyServiceMock.SetMock(new List <DependencyDescriptor>()
{
new DependencyDescriptor(typeof(IEventHandler <TestAggregateCreatedEvent>),
new TestAggregateCreatedEventHandler()),
new DependencyDescriptor(typeof(IEventHandler <TestAggregateChangedEvent>),
new TestAggregateChangedEventHandler()),
new DependencyDescriptor(typeof(IEventHandler <AggregateSavedEvent>), savedHandler)
});
eventBus = new EventBus();
eventStore = new EventStore(eventBus, new InMemoryEventStore(), PerformanceCounterMock.GetMock());
memorySnapshotStore = new InMemorySnapshotStore();
snapshotStore = new SnapshotStore(memorySnapshotStore);
var repository = new AggregateRepository <TAggregate>(eventStore, snapshotStore);
snapshotProcessor = new SnapshotProcessor(snapshotStore, new List <ISnapshotableRepository>()
{
repository
},
snapshotThreashold, PerformanceCounterMock.GetMock());
savedHandler.Processor = snapshotProcessor;
return(repository);
}
static void ArbitraryConfigurationStep(string container, InMemorySnapshotStore store)
{
Console.WriteLine("This ran after creation {2} built {0}. The hash code is {1}",
store.GetType(), store.GetHashCode(), container);
}
static void ArbitraryConfigurationStep(string container, InMemorySnapshotStore store)
{
Console.WriteLine("This ran after creation {2} built {0}. The hash code is {1}",
store.GetType(), store.GetHashCode(), container);
}
