public async Task StoredEventsAreAppliedIfThereAreMissingEvents()
        {
            // Arrange
            var thingyId      = A <ThingyId>();
            var emittedEvents = new[]
            {
                ToDomainEvent(thingyId, A <ThingyPingEvent>(), 3),
                ToDomainEvent(thingyId, A <ThingyPingEvent>(), 4),
            };
            var missingEvents = new[]
            {
                ToDomainEvent(thingyId, A <ThingyPingEvent>(), 2)
            };
            var storedEvents = Enumerable.Empty <IDomainEvent <ThingyAggregate, ThingyId> >()
                               .Concat(missingEvents)
                               .Concat(emittedEvents)
                               .ToArray();

            Arrange_ReadModelStore_UpdateAsync(ReadModelEnvelope <TestReadModel> .With(
                                                   thingyId.Value,
                                                   A <TestReadModel>(),
                                                   1));
            _eventStoreMock.Arrange_LoadEventsAsync(storedEvents);

            // Act
            await Sut.UpdateReadStoresAsync(emittedEvents, CancellationToken.None).ConfigureAwait(false);

            // Assert
            AppliedDomainEvents.Should().HaveCount(storedEvents.Length);
            AppliedDomainEvents.Should().BeEquivalentTo(storedEvents);
        }
        public async Task AlreadyAppliedEventsAreNotApplied()
        {
            // Arrange
            var thingyId      = A <ThingyId>();
            var emittedEvents = new[]
            {
                ToDomainEvent(thingyId, A <ThingyPingEvent>(), 3),
            };
            var resultingReadModelUpdates = Arrange_ReadModelStore_UpdateAsync(ReadModelEnvelope <TestReadModel> .With(
                                                                                   thingyId.Value,
                                                                                   A <TestReadModel>(),
                                                                                   3));

            // Act
            await Sut.UpdateReadStoresAsync(emittedEvents, CancellationToken.None).ConfigureAwait(false);

            // Assert
            AppliedDomainEvents.Should().BeEmpty();
            resultingReadModelUpdates.Single().IsModified.Should().BeFalse();
        }
        public async Task OutdatedEventsAreNotApplied()
        {
            // Arrange
            var thingyId      = A <ThingyId>();
            var emittedEvents = new[]
            {
                ToDomainEvent(thingyId, A <ThingyPingEvent>(), 1),
            };

            Arrange_ReadModelStore_UpdateAsync(ReadModelEnvelope <TestReadModel> .With(
                                                   thingyId.Value,
                                                   A <TestReadModel>(),
                                                   3));

            // Act
            await Sut.UpdateReadStoresAsync(emittedEvents, CancellationToken.None);

            // Assert
            AppliedDomainEvents.Should().BeEmpty();
        }
        public async Task EventsAreApplied()
        {
            // Arrange
            var thingyId      = A <ThingyId>();
            var emittedEvents = new[]
            {
                ToDomainEvent(thingyId, A <ThingyPingEvent>(), 3),
            };

            Arrange_ReadModelStore_UpdateAsync(ReadModelEnvelope <TestReadModel> .With(
                                                   thingyId.Value,
                                                   A <TestReadModel>(),
                                                   2));

            // Act
            await Sut.UpdateReadStoresAsync(emittedEvents, CancellationToken.None).ConfigureAwait(false);

            // Assert
            AppliedDomainEvents.Should().HaveCount(emittedEvents.Length);
            AppliedDomainEvents.Should().BeEquivalentTo(emittedEvents);
        }