Esempio n. 1
0
        public void An_ObservableSink_subscriber_must_be_disposable()
        {
            var probe = new TestObserver <int>(this);
            var tuple = Source.Queue <int>(1, OverflowStrategy.DropHead)
                        .ToMaterialized(Sink.AsObservable <int>(), Keep.Both)
                        .Run(Materializer);
            var queue      = tuple.Item1;
            var observable = tuple.Item2;

            var d1 = observable.Subscribe(probe);

            var t = queue.OfferAsync(1);

            t.Wait(TimeSpan.FromSeconds(1)).ShouldBeTrue();
            t.Result.ShouldBe(QueueOfferResult.Enqueued.Instance);

            probe.ExpectEvent(1);

            t = queue.OfferAsync(2);
            t.Wait(TimeSpan.FromSeconds(1)).ShouldBeTrue();
            t.Result.ShouldBe(QueueOfferResult.Enqueued.Instance);

            probe.ExpectEvent(2);

            d1.Dispose();

            t = queue.OfferAsync(3);
            t.Wait(TimeSpan.FromSeconds(1)).ShouldBeTrue();

            probe.ExpectCompleted();
            probe.ExpectNoMsg();
        }
Esempio n. 2
0
        public void An_ObservableSink_must_allow_the_same_observer_to_be_subscribed_only_once()
        {
            this.AssertAllStagesStopped(() =>
            {
                var probe      = new TestObserver <int>(this);
                var observable = Source.From(new[] { 1, 2, 3 })
                                 .RunWith(Sink.AsObservable <int>(), Materializer);

                var d1 = observable.Subscribe(probe);
                var d2 = observable.Subscribe(probe);

                d1.ShouldBe(d2);

                probe.ExpectEvent(1);
                probe.ExpectEvent(2);
                probe.ExpectEvent(3);
                probe.ExpectCompleted();
                probe.ExpectNoMsg();
            }, Materializer);
        }
Esempio n. 3
0
        public void An_ObservableSink_must_propagate_error_to_all_observers()
        {
            this.AssertAllStagesStopped(() =>
            {
                var e          = new Exception("boom");
                var probe1     = new TestObserver <int>(this);
                var probe2     = new TestObserver <int>(this);
                var observable = Source.Failed <int>(e)
                                 .RunWith(Sink.AsObservable <int>(), Materializer);

                var d1 = observable.Subscribe(probe1);
                var d2 = observable.Subscribe(probe2);

                probe1.ExpectError(e);
                probe1.ExpectNoMsg();

                probe2.ExpectError(e);
                probe2.ExpectNoMsg();
            }, Materializer);
        }
Esempio n. 4
0
        public void An_ObservableSink_must_propagate_events_to_all_observers()
        {
            this.AssertAllStagesStopped(() =>
            {
                var probe1     = new TestObserver <int>(this);
                var probe2     = new TestObserver <int>(this);
                var observable = Source.From(new[] { 1, 2 })
                                 .RunWith(Sink.AsObservable <int>(), Materializer);

                var d1 = observable.Subscribe(probe1);
                var d2 = observable.Subscribe(probe2);

                probe1.ExpectEvent(1);
                probe1.ExpectEvent(2);
                probe1.ExpectCompleted();
                probe1.ExpectNoMsg();

                probe2.ExpectEvent(1);
                probe2.ExpectEvent(2);
                probe2.ExpectCompleted();
                probe2.ExpectNoMsg();
            }, Materializer);
        }