Пример #1
0
        public async Task Publish_MessageStreamProviderOfEnvelopes_OnlyAutoUnwrapMessagesReceived()
        {
            var receivedEvents = new List <IEvent>();

            var streamPublisher = new StreamPublisher(
                PublisherTestsHelper.GetPublisher(
                    builder => builder
                    .AddDelegateSubscriber(
                        (IMessageStreamEnumerable <IEvent> enumerable) =>
            {
                foreach (var envelope in enumerable)
                {
                    receivedEvents.Add(envelope);
                }
            })));

            var streamProvider = new MessageStreamProvider <IEnvelope>();
            await streamPublisher.PublishAsync(streamProvider);

            await streamProvider.PushAsync(new TestEnvelope(new TestEventOne(), false), false);

            await streamProvider.PushAsync(new TestEnvelope(new TestEventTwo()));

            await AsyncTestingUtil.WaitAsync(() => receivedEvents.Count >= 1);

            receivedEvents.Should().HaveCount(1);
            receivedEvents[0].Should().BeOfType <TestEventTwo>();
        }
Пример #2
0
        public async Task Publish_MessageStreamProvider_MessagesNotAutomaticallyEnumerated()
        {
            var receivedEnumeratedStreams = 0;

            var streamPublisher = new StreamPublisher(
                PublisherTestsHelper.GetPublisher(
                    builder => builder
                    .AddDelegateSubscriber(
                        (IReadOnlyCollection <IEvent> enumerable) =>
            {
                Interlocked.Increment(ref receivedEnumeratedStreams);
            })
                    .AddDelegateSubscriber(
                        (List <TestEventOne> list) => { Interlocked.Increment(ref receivedEnumeratedStreams); })));

            var streamProvider = new MessageStreamProvider <IEvent>();

            await streamPublisher.PublishAsync(streamProvider);

            await streamProvider.PushAsync(new TestEventOne(), false);

            await streamProvider.PushAsync(new TestEventTwo(), false);

            await streamProvider.CompleteAsync();

            await AsyncTestingUtil.WaitAsync(() => receivedEnumeratedStreams >= 1, TimeSpan.FromMilliseconds(500));

            receivedEnumeratedStreams.Should().Be(0);
        }
        public async Task Publish_MessageStreamProvidePlusBehavior_StreamedMessagesReceived()
        {
            var receivedStreams = 0;
            var receivedEvents  = 0;

            var testBehavior    = new TestBehavior();
            var streamPublisher = new StreamPublisher(
                PublisherTestsHelper.GetPublisher(
                    builder => builder
                    .AddDelegateSubscriber(
                        (IMessageStreamEnumerable <IEvent> enumerable) =>
            {
                Interlocked.Increment(ref receivedStreams);
                foreach (var dummy in enumerable)
                {
                    Interlocked.Increment(ref receivedEvents);
                }
            }),
                    new IBehavior[] { testBehavior }));

            var streamProvider = new MessageStreamProvider <IEvent>();

            await streamPublisher.PublishAsync(streamProvider);

            await streamProvider.PushAsync(new TestEventOne());

            await streamProvider.PushAsync(new TestEventTwo());

            await AsyncTestingUtil.WaitAsync(() => receivedEvents >= 2);

            receivedStreams.Should().Be(1);
            receivedEvents.Should().Be(2);
        }
Пример #4
0
        public async Task Publish_MessageStreamProviderOfEnvelopes_OnlyMatchingUnwrappedMessagesReceived()
        {
            var receivedStreamsOfOnes = 0;
            var receivedTestEventOnes = 0;
            var receivedStreamsOfTwos = 0;
            var receivedTestEventTwos = 0;

            var streamPublisher = new StreamPublisher(
                PublisherTestsHelper.GetPublisher(
                    builder => builder
                    .AddDelegateSubscriber(
                        (IMessageStreamEnumerable <TestEventOne> enumerable) =>
            {
                Interlocked.Increment(ref receivedStreamsOfOnes);
                foreach (var dummy in enumerable)
                {
                    Interlocked.Increment(ref receivedTestEventOnes);
                }
            })
                    .AddDelegateSubscriber(
                        (IMessageStreamEnumerable <TestEventTwo> enumerable) =>
            {
                Interlocked.Increment(ref receivedStreamsOfTwos);
                foreach (var dummy in enumerable)
                {
                    Interlocked.Increment(ref receivedTestEventTwos);
                }
            })));

            var stream = new MessageStreamProvider <IEnvelope>();
            await streamPublisher.PublishAsync(stream);

            await stream.PushAsync(new TestEnvelope(new TestEventTwo()));

            await stream.PushAsync(new TestEnvelope(new TestEventTwo()));

            await AsyncTestingUtil.WaitAsync(() => receivedTestEventTwos >= 2);

            receivedStreamsOfOnes.Should().Be(0);
            receivedTestEventOnes.Should().Be(0);
            receivedStreamsOfTwos.Should().Be(1);
            receivedTestEventTwos.Should().Be(2);

            await stream.PushAsync(new TestEnvelope(new TestEventOne()));

            await stream.PushAsync(new TestEnvelope(new TestEventTwo()));

            await stream.PushAsync(new TestEnvelope(new TestEventOne()));

            await stream.PushAsync(new TestEnvelope(new TestEventTwo()));

            await AsyncTestingUtil.WaitAsync(() => receivedTestEventTwos >= 4);

            receivedStreamsOfOnes.Should().Be(1);
            receivedTestEventOnes.Should().Be(2);
            receivedStreamsOfTwos.Should().Be(1);
            receivedTestEventTwos.Should().Be(4);
        }
Пример #5
0
        public async Task Publish_MessageStreamProvider_OnlyRequiredStreamsPublished()
        {
            var receivedStreams = 0;

            var streamPublisher = new StreamPublisher(
                PublisherTestsHelper.GetPublisher(
                    builder => builder
                    .AddDelegateSubscriber(
                        (IMessageStreamEnumerable <IEvent> enumerable) =>
            {
                Interlocked.Increment(ref receivedStreams);
                var dummy = enumerable.ToList();
            })
                    .AddDelegateSubscriber(
                        (IMessageStreamEnumerable <TestEventOne> enumerable) =>
            {
                Interlocked.Increment(ref receivedStreams);
                var dummy = enumerable.ToList();
            })
                    .AddDelegateSubscriber(
                        (IMessageStreamEnumerable <TestCommandOne> enumerable) =>
            {
                Interlocked.Increment(ref receivedStreams);
                var dummy = enumerable.ToList();
            })));

            var streamProvider1 = new MessageStreamProvider <IEvent>();
            var streamProvider2 = new MessageStreamProvider <IEvent>();

            await Task.Delay(100);

            receivedStreams.Should().Be(0);

            streamPublisher.Publish(streamProvider1);
            await streamPublisher.PublishAsync(streamProvider2);

            await streamProvider1.PushAsync(new TestEventTwo());

            await Task.Delay(100);

            receivedStreams.Should().Be(1);

            await streamProvider1.PushAsync(new TestEventOne());

            await AsyncTestingUtil.WaitAsync(() => receivedStreams >= 2);

            receivedStreams.Should().Be(2);

            await streamProvider2.PushAsync(new TestEventOne());

            await AsyncTestingUtil.WaitAsync(() => receivedStreams >= 4);

            receivedStreams.Should().Be(4);
        }
        public void Publish_Envelope_CastedEnvelopeReceived()
        {
            var messages  = new List <object>();
            var publisher = PublisherTestsHelper.GetPublisher(
                builder => builder
                .AddDelegateSubscriber((ITestRawEnvelope envelope) => messages.Add(envelope)));

            publisher.Publish(new TestEnvelope(new TestCommandOne()));

            messages.OfType <TestEnvelope>().Should().HaveCount(1);
        }
        public async Task PublishAsync_EnvelopeWithoutAutoUnwrap_EnvelopeOnlyIsReceived()
        {
            var messages  = new List <object>();
            var publisher = PublisherTestsHelper.GetPublisher(
                builder => builder
                .AddDelegateSubscriber((ICommand message) => messages.Add(message))
                .AddDelegateSubscriber((IEnvelope envelope) => messages.Add(envelope)));

            await publisher.PublishAsync(new TestEnvelope(new TestCommandOne(), false));

            messages.OfType <TestEnvelope>().Should().HaveCount(1);
            messages.OfType <TestCommandOne>().Should().BeEmpty();
        }
        public async Task PublishAsync_Envelope_EnvelopeAndUnwrappedReceived()
        {
            var messages  = new List <object>();
            var publisher = PublisherTestsHelper.GetPublisher(
                builder => builder
                .AddDelegateSubscriber((object message) => messages.Add(message))
                .AddDelegateSubscriber((IEnvelope envelope) => messages.Add(envelope)));

            await publisher.PublishAsync(new TestEnvelope(new TestCommandOne()));

            messages.OfType <TestEnvelope>().Should().HaveCount(1);
            messages.OfType <TestCommandOne>().Should().HaveCount(1);
        }
        public async Task Publish_MessagesWithFilter_FilteredMessagesReceived()
        {
            var filteredSubscriber = new TestFilteredSubscriber();
            var publisher          = PublisherTestsHelper.GetPublisher(filteredSubscriber);

            publisher.Publish(new TestEventOne {
                Message = "yes"
            });
            publisher.Publish(new TestEventOne {
                Message = "no"
            });
            await publisher.PublishAsync(new TestEventOne { Message = "yes" });

            await publisher.PublishAsync(new TestEventOne { Message = "no" });

            filteredSubscriber.ReceivedMessagesCount.Should().Be(2);
        }