private Notifications.Notification[] NotificationsFrom(StoredEvent[] storedEvents)
        {
            Notifications.Notification[] notifications = new Notifications.Notification[storedEvents.Length];

            for(int i = 0; i < storedEvents.Length; i++) {
                IDomainEvent domainEvent = storedEvents[i].ToDomainEvent();
                Notifications.Notification notification = new Notifications.Notification(storedEvents[i].EventId,
                    domainEvent);

                notifications[i] = notification;
            }

            return notifications;
        }
Example #2
0
        public async Task Should_ignore_old_events()
        {
            A.CallTo(() => formatter.Parse(eventData))
            .Throws(new TypeNameNotFoundException());

            var @event = new StoredEvent("Stream", Guid.NewGuid().ToString(), 123, eventData);

            await sut.ActivateAsync(consumerName);

            await sut.ActivateAsync();

            await OnEventAsync(eventSubscription, @event);

            grainState.Value.Should().BeEquivalentTo(new EventConsumerState {
                IsStopped = false, Position = @event.EventPosition, Error = null
            });

            A.CallTo(() => grainState.WriteAsync())
            .MustHaveHappened(1, Times.Exactly);

            A.CallTo(() => eventConsumer.On(envelope))
            .MustNotHaveHappened();
        }
        public async Task Should_stop_if_handling_failed()
        {
            var ex = new InvalidOperationException();

            A.CallTo(() => eventConsumer.On(envelope))
            .Throws(ex);

            var @event = new StoredEvent(Guid.NewGuid().ToString(), 123, eventData);

            await OnSubscribeAsync();
            await OnEventAsync(eventSubscription, @event);

            sut.Dispose();

            A.CallTo(() => eventConsumer.On(envelope))
            .MustHaveHappened();

            A.CallTo(() => eventConsumerInfoRepository.SetAsync(consumerName, consumerInfo.Position, true, ex.ToString()))
            .MustHaveHappened(Repeated.Exactly.Once);

            A.CallTo(() => eventSubscription.StopAsync())
            .MustHaveHappened(Repeated.Exactly.Once);
        }
Example #4
0
        public async Task Should_not_invoke_but_update_position_when_consumer_does_not_want_to_handle()
        {
            var @event = new StoredEvent("Stream", Guid.NewGuid().ToString(), 123, eventData);

            A.CallTo(() => eventConsumer.Handles(@event))
            .Returns(false);

            await sut.ActivateAsync(consumerName);

            await sut.ActivateAsync();

            await OnEventAsync(eventSubscription, @event);

            grainState.Value.Should().BeEquivalentTo(new EventConsumerState {
                IsStopped = false, Position = @event.EventPosition, Error = null
            });

            A.CallTo(() => grainState.WriteAsync())
            .MustHaveHappened(1, Times.Exactly);

            A.CallTo(() => eventConsumer.On(envelope))
            .MustNotHaveHappened();
        }
Example #5
0
        public async Task <IEnumerable <StoredEvent> > ObterEventos(Guid aggregateId)
        {
            var eventos = await _eventStoreService.GetConnection()
                          .ReadStreamEventsForwardAsync(aggregateId.ToString(), 0, 500, false);

            var listaEventos = new List <StoredEvent>();

            foreach (var resolvedEvent in eventos.Events)
            {
                var dataEncoded = Encoding.UTF8.GetString(resolvedEvent.Event.Data);
                var jsonData    = JsonConvert.DeserializeObject <BaseEvent>(dataEncoded);

                var evento = new StoredEvent(
                    resolvedEvent.Event.EventId,
                    resolvedEvent.Event.EventType,
                    jsonData.Timestamp,
                    dataEncoded);

                listaEventos.Add(evento);
            }

            return(listaEventos.OrderBy(e => e.DataOcorrencia));
        }
        public async Task Should_start_after_stop_when_handling_failed()
        {
            var exception = new InvalidOperationException();

            A.CallTo(() => eventConsumer.On(envelope))
            .Throws(exception);

            var @event = new StoredEvent("Stream", Guid.NewGuid().ToString(), 123, eventData);

            await sut.OnActivateAsync(consumerName);

            await sut.ActivateAsync();

            await OnEventAsync(eventSubscription, @event);

            await sut.StopAsync();

            await sut.StartAsync();

            await sut.StartAsync();

            state.Should().BeEquivalentTo(new EventConsumerState {
                IsStopped = false, Position = initialPosition, Error = null
            });

            A.CallTo(() => eventConsumer.On(envelope))
            .MustHaveHappened();

            A.CallTo(() => persistence.WriteSnapshotAsync(A <EventConsumerState> .Ignored))
            .MustHaveHappened(Repeated.Exactly.Twice);

            A.CallTo(() => eventSubscription.StopAsync())
            .MustHaveHappened(Repeated.Exactly.Once);

            A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> .Ignored, A <string> .Ignored, A <string> .Ignored))
            .MustHaveHappened(Repeated.Exactly.Twice);
        }
        public async Task Should_start_after_stop_when_handling_failed()
        {
            var exception = new InvalidOperationException();

            A.CallTo(() => eventConsumer.On(envelope))
            .Throws(exception);

            var @event = new StoredEvent("Stream", Guid.NewGuid().ToString(), 123, eventData);

            await sut.ActivateAsync(consumerName);

            await sut.ActivateAsync();

            await OnEventAsync(eventSubscription, @event);

            await sut.StopAsync();

            await sut.StartAsync();

            await sut.StartAsync();

            AssetGrainState(new EventConsumerState {
                IsStopped = false, Position = initialPosition, Error = null
            });

            A.CallTo(() => eventConsumer.On(envelope))
            .MustHaveHappened();

            A.CallTo(() => grainState.WriteAsync())
            .MustHaveHappened(2, Times.Exactly);

            A.CallTo(() => eventSubscription.StopAsync())
            .MustHaveHappened(1, Times.Exactly);

            A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> ._, A <string> ._, A <string> ._))
            .MustHaveHappened(2, Times.Exactly);
        }
Example #8
0
        public async Task Should_ignore_old_events()
        {
            sut.ActivateAsync(consumerName, store).Wait();
            sut.Activate(eventConsumer);

            A.CallTo(() => formatter.Parse(eventData, true))
            .Throws(new TypeNameNotFoundException());

            var @event = new StoredEvent(Guid.NewGuid().ToString(), 123, eventData);

            await OnEventAsync(eventSubscription, @event);

            sut.Dispose();

            state.ShouldBeEquivalentTo(new EventConsumerState {
                IsStopped = false, Position = @event.EventPosition, Error = null
            });

            A.CallTo(() => persistence.WriteSnapshotAsync(A <EventConsumerState> .Ignored))
            .MustHaveHappened(Repeated.Exactly.Once);

            A.CallTo(() => eventConsumer.On(envelope))
            .MustNotHaveHappened();
        }
Example #9
0
        public void Add(StoredEvent entidade)
        {
            var sb = new System.Text.StringBuilder(277);

            sb.AppendLine(@"INSERT INTO [dbo].[StoredEvent]");
            sb.AppendLine(@"           ([Id]");
            sb.AppendLine(@"           ,[Dados]");
            sb.AppendLine(@"           ,[Usuario]");
            sb.AppendLine(@"           ,[MensagemTipo]");
            sb.AppendLine(@"           ,[AggregateId]");
            sb.AppendLine(@"           ,[DataCadastro])");
            sb.AppendLine(@"     VALUES");
            sb.AppendLine(@"           (@Id");
            sb.AppendLine(@"           ,@Dados");
            sb.AppendLine(@"           ,@Usuario");
            sb.AppendLine(@"           ,@MensagemTipo");
            sb.AppendLine(@"           ,@AggregateId");
            sb.AppendLine(@"           ,@DataCadastro)");

            connection.Query(sb.ToString()
                             , param: new
            {
                Id = entidade.Id
                ,
                Dados = entidade.Dados
                ,
                Usuario = entidade.Usuario
                ,
                MensagemTipo = entidade.MensagemTipo
                ,
                AggregateId = entidade.AggregateId
                ,
                DataCadastro = entidade.DataCadastro
            }
                             , transaction: transaction);
        }
 public void Store(StoredEvent theEvent)
 {
     eventStore.InsertOne(theEvent);
 }
Example #11
0
 /// <summary>
 /// Upgrades an event to the latest version.
 /// </summary>
 /// <remarks>
 /// <para>This checks to see if an <see cref="IEventConverter"/> has been added for <see cref="StoredEvent{T}.EventName"/>.</para>
 /// <para>If there is an event converter for this event then that converter will be used to upgrade the event.</para>
 /// <para>If no converter has been added for this event then the event will be left un-modified.</para>
 /// </remarks>
 /// <param name="theEvent">The event to be upgraded.</param>
 /// <exception cref="ArgumentNullException">If <paramref name="theEvent"/> is <value>null</value>.</exception>
 /// <seealso cref="AddConverter"/>
 public void Upgrade(StoredEvent<JObject> theEvent)
 {
     IEventConverter converter;
     if (_converters.TryGetValue(theEvent.EventName, out converter))
         converter.Upgrade(theEvent);
 }
Example #12
0
 private Task OnEventAsync(IEventSubscription subscription, StoredEvent ev)
 {
     return(sut.OnEventAsync(subscription, ev));
 }
Example #13
0
 public Task OnEventAsync(IEventSubscription subscription, StoredEvent storedEvent)
 {
     return(Dispatch(() => grain.OnEventAsync(subscription.AsImmutable(), storedEvent.AsImmutable())));
 }
Example #14
0
        public Task PersistAsync(Is4Event evt)
        {
            var es = new StoredEvent(
                evt.Category,
                (EventTypes)(int)evt.EventType,
                evt.Name,
                evt.LocalIpAddress,
                evt.RemoteIpAddress,
                evt.ToString()
                ).ReplaceTimeStamp(evt.TimeStamp);

            if (_user.IsAuthenticated())
            {
                es.SetUser(_user.Username);
            }

            switch (evt)
            {
            case ApiAuthenticationFailureEvent apiAuthenticationFailureEvent:
                es.SetAggregate(apiAuthenticationFailureEvent.ApiName);
                break;

            case ApiAuthenticationSuccessEvent apiAuthenticationSuccessEvent:
                es.SetAggregate(apiAuthenticationSuccessEvent.ApiName);
                break;

            case ClientAuthenticationFailureEvent clientAuthenticationFailureEvent:
                es.SetAggregate(clientAuthenticationFailureEvent.ClientId);
                break;

            case ClientAuthenticationSuccessEvent clientAuthenticationSuccessEvent:
                es.SetAggregate(clientAuthenticationSuccessEvent.ClientId);
                break;

            case ConsentDeniedEvent consentDeniedEvent:
                es.SetAggregate(consentDeniedEvent.ClientId);
                break;

            case ConsentGrantedEvent consentGrantedEvent:
                es.SetAggregate(consentGrantedEvent.ClientId);
                break;

            case DeviceAuthorizationFailureEvent deviceAuthorizationFailureEvent:
                es.SetAggregate(deviceAuthorizationFailureEvent.ClientId);
                break;

            case DeviceAuthorizationSuccessEvent deviceAuthorizationSuccessEvent:
                es.SetAggregate(deviceAuthorizationSuccessEvent.ClientId);
                break;

            case GrantsRevokedEvent grantsRevokedEvent:
                es.SetAggregate(grantsRevokedEvent.ClientId);
                break;

            case InvalidClientConfigurationEvent invalidClientConfigurationEvent:
                es.SetAggregate(invalidClientConfigurationEvent.ClientId);
                break;

            case TokenIntrospectionFailureEvent tokenIntrospectionFailureEvent:
                es.SetAggregate(tokenIntrospectionFailureEvent.ApiName);
                break;

            case TokenIntrospectionSuccessEvent tokenIntrospectionSuccessEvent:
                es.SetAggregate(tokenIntrospectionSuccessEvent.ApiName);
                break;

            case TokenIssuedFailureEvent tokenIssuedFailureEvent:
                es.SetAggregate(tokenIssuedFailureEvent.ClientId);
                break;

            case TokenIssuedSuccessEvent tokenIssuedSuccessEvent:
                es.SetAggregate(tokenIssuedSuccessEvent.ClientId);
                break;

            case TokenRevokedSuccessEvent tokenRevokedSuccessEvent:
                es.SetAggregate(tokenRevokedSuccessEvent.ClientId);
                break;

            case UnhandledExceptionEvent unhandledExceptionEvent:
                break;

            case UserLoginFailureEvent userLoginFailureEvent:
                es.SetUser(userLoginFailureEvent.Username).SetAggregate(userLoginFailureEvent.ClientId);
                break;

            case UserLoginSuccessEvent userLoginSuccessEvent:
                es.SetUser(userLoginSuccessEvent.Username).SetAggregate(userLoginSuccessEvent.ClientId);
                break;

            case UserLogoutSuccessEvent userLogoutSuccessEvent:
                es.SetAggregate(userLogoutSuccessEvent.SubjectId);
                break;
            }

            return(_eventStoreRepository.Store(es));
        }
Example #15
0
 public void Store(StoredEvent theEvent)
 {
     context.Set <StoredEvent>().Add(theEvent);
     context.SaveChanges();
 }
Example #16
0
        public void Initialize_Identity()
        {
            var storedEvent = new StoredEvent(Guid.NewGuid().ToString(), new DepositedMoney(new Money(123m)), 1);

            Assert.IsNotNull(storedEvent.Id);
        }
 public void Upgrade(StoredEvent<JObject> theEvent)
 {
     //do nothing
 }
Example #18
0
 private static BsonDocument ToBsonDocument(StoredEvent<string> rawEvent)
 {
     var doc = rawEvent.ToBsonDocument();
     return doc;
 }
        /// <summary>Saves the event to the data store.</summary>
        /// <param name="uncommittedEvent">The event to save.</param>
        /// <param name="transaction">The transaction.</param>
        private void SaveEvent(UncommittedEvent uncommittedEvent, SqlTransaction transaction)
        {
            Contract.Requires<ArgumentNullException>(uncommittedEvent != null, "The argument uncommittedEvent could not be null.");
            Contract.Requires<ArgumentNullException>(transaction != null, "The argument transaction could not be null.");

            string eventName;
            var document = _formatter.Serialize(uncommittedEvent.Payload, out eventName);
            var storedEvent = new StoredEvent<JObject>(uncommittedEvent.EventIdentifier, uncommittedEvent.EventTimeStamp,
                                                      eventName, uncommittedEvent.EventVersion, uncommittedEvent.EventSourceId,
                                                      uncommittedEvent.EventSequence, document);
            var raw = _translator.TranslateToRaw(storedEvent);

            using (var command = new SqlCommand(Queries.InsertNewEventQuery, transaction.Connection))
            {
                command.Transaction = transaction;
                command.Parameters.AddWithValue("EventId", raw.EventIdentifier);
                command.Parameters.AddWithValue("TimeStamp", raw.EventTimeStamp);
                command.Parameters.AddWithValue("EventSourceId", raw.EventSourceId);
                command.Parameters.AddWithValue("Name", raw.EventName);
                command.Parameters.AddWithValue("Version", raw.EventVersion.ToString());
                command.Parameters.AddWithValue("Sequence", raw.EventSequence);
                command.Parameters.AddWithValue("Data", raw.Data);
                command.ExecuteNonQuery();
            }
        }
        /// <summary>
        /// Saves the event to the data store.
        /// </summary>
        /// <param name="evnt">The event to save.</param>
        /// <param name="transaction">The transaction.</param>
        private void SaveEvent(UncommittedEvent evnt, NpgsqlTransaction transaction)
        {
            string eventName;
            var document = _formatter.Serialize(evnt.Payload, out eventName);
            var storedEvent = new StoredEvent<JObject>(evnt.EventIdentifier, evnt.EventTimeStamp,
                                                      eventName, evnt.EventVersion, evnt.EventSourceId,
                                                      evnt.EventSequence, document);
            var raw = _translator.TranslateToRaw(storedEvent);

            using (var command = new NpgsqlCommand(Queries.InsertNewEventQuery, transaction.Connection))
            {
                command.Transaction = transaction;
                command.Parameters.AddWithValue("EventId", raw.EventIdentifier);
                command.Parameters.AddWithValue("TimeStamp", raw.EventTimeStamp);
                command.Parameters.AddWithValue("EventSourceId", raw.EventSourceId);
                command.Parameters.AddWithValue("Name", raw.EventName);
                command.Parameters.AddWithValue("Version", raw.EventVersion.ToString());
                command.Parameters.AddWithValue("Sequence", raw.EventSequence);
                command.Parameters.AddWithValue("Data", raw.Data);
                command.ExecuteNonQuery();
            }
        }
 public void StoreData(StoredEvent data)
 {
     _context.Data.Add(data);
     _context.SaveChanges();
 }
Example #22
0
 public bool Handles(StoredEvent @event)
 {
     return(true);
 }
Example #23
0
        private static BsonDocument ToBsonDocument(StoredEvent <string> rawEvent)
        {
            var doc = rawEvent.ToBsonDocument();

            return(doc);
        }
        public void Store(StoredEvent theEvent)
        {
            var events = cacheService.Get <IEnumerable <StoredEvent> >(eventStorePrefix + theEvent.EventId) ?? Enumerable.Empty <StoredEvent>();

            cacheService.Store(theEvent.EventId, events.Concat(new[] { theEvent }));
        }
 public bool Handles(StoredEvent @event)
 {
     return(@event.Data.Type == typeAssetDeleted || @event.Data.Type == typeContentDeleted);
 }
Example #26
0
 public void SaveEvent(StoredEvent storedEvent)
 {
     _context.StoredEvents.Add(storedEvent);
     _context.SaveChanges();
 }
 private Task OnEventAsync(IEventSubscription subscriber, StoredEvent ev)
 {
     return(sut.OnEventAsync(subscriber.AsImmutable(), ev.AsImmutable()));
 }
Example #28
0
 public async Task OnEventAsync(IEventSubscription subscription, StoredEvent storedEvent)
 {
     await eventSubscriber.OnEventAsync(subscription, storedEvent);
 }
Example #29
0
 public void Store(StoredEvent eventObj)
 {
     _context.StoredEvents.Add(eventObj);
     _context.SaveChanges();
 }
Example #30
0
 public Task OnEventAsync(IEventSubscription subscription, StoredEvent storedEvent)
 {
     return(currentSubscriber !.OnEventAsync(subscription, storedEvent));
 }
Example #31
0
 public bool Store(StoredEvent @event)
 {
     _context.EventStores.Add(@event);
     return(_context.SaveChanges() > 0);
 }
Example #32
0
 protected void Add(StoredEvent @event)
 {
     Events.TryAdd(@event.StoredEventId, new DeserializedStoredEvent(@event));
     Persist(@event);
 }
Example #33
0
 public void Upgrade(StoredEvent<JObject> theEvent)
 {
     Contract.Requires<ArgumentNullException>(theEvent != null, "theEvent");
 }
Example #34
0
 public static CompatibleStoredEvent V2(StoredEvent stored)
 {
     return(new CompatibleStoredEvent {
         NewEvent = NewEvent.V2(stored)
     });
 }
Example #35
0
        public async Task Should_write_and_read_events_to_backup(BackupVersion version)
        {
            var stream = new MemoryStream();

            var random      = new Random();
            var randomGuids = new List <Guid>();

            for (var i = 0; i < 100; i++)
            {
                randomGuids.Add(Guid.NewGuid());
            }

            Guid RandomGuid()
            {
                return(randomGuids[random.Next(randomGuids.Count)]);
            }

            var sourceEvents = new List <(string Stream, Envelope <IEvent> Event)>();

            for (var i = 0; i < 200; i++)
            {
                var @event = new MyEvent
                {
                    GuidNamed = NamedId.Of(RandomGuid(), $"name{i}"),
                    GuidRaw   = RandomGuid(),
                    Values    = new Dictionary <Guid, string>
                    {
                        [RandomGuid()] = "Key"
                    }
                };

                var envelope = Envelope.Create <IEvent>(@event);

                envelope.Headers.Add(RandomGuid().ToString(), i);
                envelope.Headers.Add("Id", RandomGuid().ToString());
                envelope.Headers.Add("Index", i);

                sourceEvents.Add(($"My-{RandomGuid()}", envelope));
            }

            using (var writer = new BackupWriter(serializer, stream, true, version))
            {
                foreach (var(_, envelope) in sourceEvents)
                {
                    var eventData   = formatter.ToEventData(envelope, Guid.NewGuid(), true);
                    var eventStored = new StoredEvent("S", "1", 2, eventData);

                    var index = int.Parse(envelope.Headers["Index"].ToString());

                    if (index % 17 == 0)
                    {
                        await writer.WriteBlobAsync(index.ToString(), innerStream =>
                        {
                            innerStream.WriteByte((byte)index);

                            return(TaskHelper.Done);
                        });
                    }
                    else if (index % 37 == 0)
                    {
                        await writer.WriteJsonAsync(index.ToString(), $"JSON_{index}");
                    }

                    writer.WriteEvent(eventStored);
                }
            }

            stream.Position = 0;

            var targetEvents = new List <(string Stream, Envelope <IEvent> Event)>();

            using (var reader = new BackupReader(serializer, stream))
            {
                await reader.ReadEventsAsync(streamNameResolver, formatter, async @event =>
                {
                    var index = int.Parse(@event.Event.Headers["Index"].ToString());

                    if (index % 17 == 0)
                    {
                        await reader.ReadBlobAsync(index.ToString(), innerStream =>
                        {
                            var byteRead = innerStream.ReadByte();

                            Assert.Equal((byte)index, byteRead);

                            return(TaskHelper.Done);
                        });
                    }
                    else if (index % 37 == 0)
                    {
                        var json = await reader.ReadJsonAttachmentAsync <string>(index.ToString());

                        Assert.Equal($"JSON_{index}", json);
                    }

                    targetEvents.Add(@event);
                });

                void CompareGuid(Guid source, Guid target)
                {
                    Assert.Equal(source, reader.OldGuid(target));
                    Assert.NotEqual(source, target);
                }

                for (var i = 0; i < targetEvents.Count; i++)
                {
                    var target = targetEvents[i].Event.To <MyEvent>();

                    var source = sourceEvents[i].Event.To <MyEvent>();

                    CompareGuid(source.Payload.Values.First().Key, target.Payload.Values.First().Key);
                    CompareGuid(source.Payload.GuidRaw, target.Payload.GuidRaw);
                    CompareGuid(source.Payload.GuidNamed.Id, target.Payload.GuidNamed.Id);
                    CompareGuid(source.Headers.GetGuid("Id"), target.Headers.GetGuid("Id"));

                    Assert.Equal(Guid.Empty, target.Payload.GuidEmpty);
                }
            }
        }
Example #36
0
 public void Store(StoredEvent theEvent)
 {
     _context.StoredEvent.Add(theEvent);
     _context.SaveChanges();
 }
Example #37
0
        public async Task Should_write_and_read_events_to_backup(BackupVersion version)
        {
            var randomGenerator = new Random();
            var randomDomainIds = new List <DomainId>();

            for (var i = 0; i < 100; i++)
            {
                randomDomainIds.Add(DomainId.NewGuid());
            }

            DomainId RandomDomainId()
            {
                return(randomDomainIds[randomGenerator.Next(randomDomainIds.Count)]);
            }

            var sourceEvents = new List <(string Stream, Envelope <MyEvent> Event)>();

            for (var i = 0; i < 200; i++)
            {
                var @event = new MyEvent();

                var envelope = Envelope.Create(@event);

                envelope.Headers.Add("Id", JsonValue.Create(@event.Id));
                envelope.Headers.Add("Index", JsonValue.Create(i));

                sourceEvents.Add(($"My-{RandomDomainId()}", envelope));
            }

            await TestReaderWriterAsync(version, async writer =>
            {
                foreach (var(stream, envelope) in sourceEvents)
                {
                    var eventData   = formatter.ToEventData(envelope, Guid.NewGuid(), true);
                    var eventStored = new StoredEvent(stream, "1", 2, eventData);

                    var index = int.Parse(envelope.Headers["Index"].ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture);

                    if (index % 17 == 0)
                    {
                        await WriteGuidAsync(writer, index.ToString(CultureInfo.InvariantCulture), envelope.Payload.Id);
                    }
                    else if (index % 37 == 0)
                    {
                        await WriteJsonGuidAsync(writer, index.ToString(CultureInfo.InvariantCulture), envelope.Payload.Id);
                    }

                    writer.WriteEvent(eventStored);
                }
            }, async reader =>
            {
                var targetEvents = new List <(string Stream, Envelope <IEvent> Event)>();

                await foreach (var @event in reader.ReadEventsAsync(streamNameResolver, formatter))
                {
                    var index = int.Parse(@event.Event.Headers["Index"].ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture);

                    var id = Guid.Parse(@event.Event.Headers["Id"].ToString());

                    if (index % 17 == 0)
                    {
                        var guid = await ReadGuidAsync(reader, index.ToString(CultureInfo.InvariantCulture));

                        Assert.Equal(id, guid);
                    }
                    else if (index % 37 == 0)
                    {
                        var guid = await ReadJsonGuidAsync(reader, index.ToString(CultureInfo.InvariantCulture));

                        Assert.Equal(id, guid);
                    }

                    targetEvents.Add(@event);
                }

                for (var i = 0; i < targetEvents.Count; i++)
                {
                    var targetEvent  = targetEvents[i].Event.To <MyEvent>();
                    var targetStream = targetEvents[i].Stream;

                    var sourceEvent  = sourceEvents[i].Event.To <MyEvent>();
                    var sourceStream = sourceEvents[i].Stream;

                    Assert.Equal(sourceEvent.Payload.Id, targetEvent.Payload.Id);
                    Assert.Equal(sourceStream, targetStream);
                }
            });
        }