public async Task event_type_concurrently(EventTypeFilterCases.Case testCase)
        {
            var eventTypePrefix = $"{GetStreamName()}_{testCase.FilterType}";

            var eventAppearedSource1 = new TaskCompletionSource <ResolvedEvent>();
            var eventAppearedSource2 = new TaskCompletionSource <ResolvedEvent>();
            var connection           = _fixture.Connection;
            var filter = testCase.CreateFilter(eventTypePrefix);

            using (await connection
                   .FilteredSubscribeToAllAsync(false, filter, EventAppeared1, subscriptionDropped: SubscriptionDropped1)
                   .WithTimeout())
                using (await connection
                       .FilteredSubscribeToAllAsync(false, filter, EventAppeared2, subscriptionDropped: SubscriptionDropped2)
                       .WithTimeout()) {
                    var testEvents = _fixture.CreateTestEvents(10)
                                     .Select(e =>
                                             new EventData(e.EventId, $"{eventTypePrefix}-{Guid.NewGuid():n}", e.IsJson, e.Data, e.Metadata))
                                     .ToArray();
                    await connection.AppendToStreamAsync(Guid.NewGuid().ToString("n"), ExpectedVersion.NoStream, testEvents).WithTimeout();

                    var resolvedEvents =
                        await Task.WhenAll(eventAppearedSource1.Task, eventAppearedSource2.Task).WithTimeout();

                    Assert.Equal(testEvents[0].EventId, resolvedEvents[0].OriginalEvent.EventId);
                    Assert.Equal(testEvents[0].EventId, resolvedEvents[1].OriginalEvent.EventId);
                }

            Task EventAppeared1(EventStoreSubscription s, ResolvedEvent e)
            {
                eventAppearedSource1.TrySetResult(e);

                return(Task.CompletedTask);
            }

            Task EventAppeared2(EventStoreSubscription s, ResolvedEvent e)
            {
                eventAppearedSource2.TrySetResult(e);

                return(Task.CompletedTask);
            }

            void SubscriptionDropped1(EventStoreSubscription s, SubscriptionDropReason reason, Exception ex) =>
            eventAppearedSource1.TrySetException(ex ?? new ObjectDisposedException(nameof(s)));

            void SubscriptionDropped2(EventStoreSubscription s, SubscriptionDropReason reason, Exception ex) =>
            eventAppearedSource2.TrySetException(ex ?? new ObjectDisposedException(nameof(s)));
        }
Ejemplo n.º 2
0
        public async Task event_type_filter_returns_expected_result(EventTypeFilterCases.Case @case)
        {
            var eventTypePrefix = $"{GetStreamName()}_{@case.FilterType}";

            var testEvents = _fixture.CreateTestEvents(10)
                             .Select(e =>
                                     new EventData(e.EventId, $"{eventTypePrefix}-{Guid.NewGuid():n}", e.IsJson, e.Data, e.Metadata))
                             .ToArray();

            var connection = _fixture.Connection;

            foreach (var e in testEvents)
            {
                await connection.AppendToStreamAsync(Guid.NewGuid().ToString("n"), ExpectedVersion.NoStream, e);
            }

            var result = await connection.FilteredReadAllEventsForwardAsync(
                Position.Start, 4096, false, @case.CreateFilter(eventTypePrefix)).WithTimeout();

            Assert.Equal(ReadDirection.Forward, result.ReadDirection);
            Assert.Equal(testEvents.Select(x => x.EventId), result.Events
                         .Select(x => x.OriginalEvent.EventId));
        }