예제 #1
0
    def test_group_by_with_ReplaySubject(self):
        scheduler = TestScheduler()
        xs = scheduler.create_hot_observable(
            on_next(300, 1),
            on_next(310, 2),
            on_next(320, 3),
            on_next(320, 4),
            on_next(320, 5),
            on_next(320, 6),
            on_completed(1000),
            )

        observer_groups = scheduler.create_observer()
        observer_odd = scheduler.create_observer()
        observer_even = scheduler.create_observer()

        def subscription(scheduler, state):
            source = xs.pipe(
                ops.group_by(
                    key_mapper=lambda x: x % 2,
                    element_mapper=None,
                    subject_mapper=lambda: rx.subject.ReplaySubject(2),
                    )
                )
            return source.subscribe(observer_groups, scheduler=scheduler)

        scheduler.schedule_absolute(290, subscription)
        scheduler.advance_to(500)

        # extract grouped observables from messages list
        groups = {m.value.value.key: m.value.value for m in observer_groups.messages if m.value.kind =='N'}

        def subscription_odd(scheduler, state):
            source = groups[1]
            return source.subscribe(observer_odd, scheduler=scheduler)

        def subscription_even(scheduler, state):
            source = groups[0]
            return source.subscribe(observer_even, scheduler=scheduler)

        scheduler.schedule_absolute(500, subscription_odd)
        scheduler.schedule_absolute(600, subscription_even)
        scheduler.advance_to(1100)

        # only the last 2 items of odd/even are received because the
        # ReplaySubject has been configured with a buffer size of 2
        assert observer_odd.messages == [
            on_next(500, 3),
            on_next(500, 5),
            on_completed(1000),
            ]

        assert observer_even.messages == [
            on_next(600, 4),
            on_next(600, 6),
            on_completed(1000),
            ]
예제 #2
0
    def test_concat_forward_scheduler(self):
        scheduler = TestScheduler()
        subscribe_schedulers = {'e1': 'unknown', 'e2': 'unknown'}

        def subscribe_e1(observer, scheduler='not_set'):
            subscribe_schedulers['e1'] = scheduler
            observer.on_completed()

        def subscribe_e2(observer, scheduler='not_set'):
            subscribe_schedulers['e2'] = scheduler
            observer.on_completed()

        e1 = rx.create(subscribe_e1)
        e2 = rx.create(subscribe_e2)

        stream = e1.pipe(ops.concat(e2))
        stream.subscribe(scheduler=scheduler)
        scheduler.advance_to(1000)
        assert subscribe_schedulers['e1'] is scheduler
        assert subscribe_schedulers['e2'] is scheduler