Beispiel #1
0
        public async Task ItemReplayedWithSnapshot()
        {
            var provider = new ServiceCollection()
                           .AddLogging()
                           .AddMemoryCache()
                           .BuildServiceProvider();

            var config = new ConfigurationBuilder()
                         .AddInMemoryCollection(new[] { new KeyValuePair <string, string>("MemoryCache:Local:Duration", "00:00:10") })
                         .Build();

            var logger   = provider.GetRequiredService <ILogger <DomainObjectStore> >();
            var memCache = provider.GetRequiredService <IMemoryCache>();

            var eventStore = new Mock <IEventStore>(MockBehavior.Strict);

            eventStore.Setup(es => es.ReplayEventsAsStream(
                                 It.IsAny <Func <(StoredEvent, DomainEvent), bool> >(),
                                 It.IsAny <int>(),
                                 It.IsAny <StreamDirection>(),
                                 It.IsAny <long>()))
            .Returns(Task.CompletedTask)
            .Verifiable();

            var item = new ConfigEnvironmentList();

            item.ApplyEvent(new ReplayedEvent
            {
                DomainEvent = new EnvironmentCreated(new EnvironmentIdentifier("Foo", "Bar")),
                UtcTime     = DateTime.UtcNow,
                Version     = 1
            });
            var snapshot = item.CreateSnapshot();

            var snapshotStore = new Mock <ISnapshotStore>(MockBehavior.Strict);

            snapshotStore.Setup(s => s.GetSnapshot <ConfigEnvironmentList>(It.IsAny <string>(), It.IsAny <long>()))
            .ReturnsAsync(Result.Success(snapshot));

            var store = new DomainObjectStore(eventStore.Object,
                                              snapshotStore.Object,
                                              memCache,
                                              config,
                                              logger);

            var result = await store.ReplayObject <ConfigEnvironmentList>();

            Assert.False(result.IsError, "result.IsError");
            Assert.NotNull(result.Data);

            eventStore.Verify();
            snapshotStore.Verify();
        }
        public void CreateValidSnapshot()
        {
            var item = new ConfigEnvironmentList();

            item.ApplyEvent(new ReplayedEvent
            {
                DomainEvent = new EnvironmentCreated(new EnvironmentIdentifier("Foo", "Bar")),
                UtcTime     = DateTime.UtcNow,
                Version     = 4711
            });

            var snapshot = item.CreateSnapshot();

            Assert.Equal(item.CurrentVersion, snapshot.Version);
            Assert.Equal(item.MetaVersion, snapshot.MetaVersion);
            Assert.False(string.IsNullOrWhiteSpace(snapshot.Identifier));
            Assert.False(string.IsNullOrWhiteSpace(snapshot.JsonData));
            Assert.False(string.IsNullOrWhiteSpace(snapshot.DataType));
        }
        public void SnapshotAppliesAllProperties()
        {
            var snapshotSource = new ConfigEnvironmentList();

            snapshotSource.ApplyEvent(new ReplayedEvent
            {
                DomainEvent = new EnvironmentCreated(new EnvironmentIdentifier("Foo", "Bar")),
                UtcTime     = DateTime.UtcNow,
                Version     = 4711
            });
            var snapshot = snapshotSource.CreateSnapshot();

            var target = new ConfigEnvironmentList();

            target.ApplySnapshot(snapshot);

            Assert.Equal(snapshotSource.Identifiers, target.Identifiers);
            Assert.Equal(snapshotSource.CurrentVersion, target.CurrentVersion);
            Assert.Equal(snapshotSource.MetaVersion, target.MetaVersion);
        }