public void GivenAnEventStoreAFactoryAndAProxyThenAnInstanceIsCreated()
 {
     _ = new DefaultSnapshotProvider <SequencedEvents>(
         store.Object,
         factory.Object,
         () => type => proxy.Object);
 }
コード例 #2
0
        public async Task GivenAStreamThenTheSnapshotContainsTheAggregatesThatComprizeThatStreamAsync()
        {
            SerializableEventCentricAggregateRoot expected = CreateAggregate(out IEnumerable <DomainEvent> events);
            var other = new SerializableEventCentricAggregateRoot(expected.Id);

            _ = factory
                .Setup(factory => factory.CreateAsync(
                           It.IsAny <Reference>(),
                           It.IsAny <CancellationToken?>()))
                .ReturnsAsync(other);

            _ = proxy
                .Setup(proxy => proxy.GetAsync(
                           It.IsAny <Reference>(),
                           It.IsAny <CancellationToken?>()))
                .ReturnsAsync(default(EventCentricAggregateRoot) !);

            _ = proxy
                .Setup(proxy => proxy.GetAllAsync(It.IsAny <CancellationToken?>()))
                .ReturnsAsync(new[] { other });

            _ = store
                .Setup(store => store.ReadAsync(
                           It.Is <ulong>(lastIndex => lastIndex == ulong.MinValue),
                           It.IsAny <CancellationToken?>(),
                           It.IsAny <ushort>()))
                .ReturnsAsync(new[] { new SequencedEvents(1, events.ToArray()) });

            _ = store
                .Setup(store => store.ReadAsync(
                           It.Is <ulong>(lastIndex => lastIndex > ulong.MinValue),
                           It.IsAny <CancellationToken?>(),
                           It.IsAny <ushort>()))
                .ReturnsAsync(Enumerable.Empty <SequencedEvents>());

            var instance = new DefaultSnapshotProvider <SequencedEvents>(
                store.Object,
                factory.Object,
                () => type => proxy.Object);

            ISnapshot?snapshot = await instance.GenerateAsync();

            Assert.NotNull(snapshot);

            EventCentricAggregateRoot actual = Assert.Single(snapshot !.Aggregates);

            Assert.Equal(expected, actual);

            factory.Verify(
                factory => factory.CreateAsync(
                    It.IsAny <Reference>(),
                    It.IsAny <CancellationToken?>()),
                times: Times.Once);

            factory.Verify(
                factory => factory.CreateAsync(
                    It.Is <Reference>(reference => reference.Id == expected.Id),
                    It.IsAny <CancellationToken?>()),
                times: Times.Once);

            proxy.Verify(
                proxy => proxy.GetAsync(
                    It.IsAny <Reference>(),
                    It.IsAny <CancellationToken?>()),
                times: Times.Once);

            proxy.Verify(
                proxy => proxy.GetAllAsync(It.IsAny <CancellationToken?>()),
                times: Times.Once);
        }