def test_select_disposeinsideselector(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(100, 1), on_next(200, 2), on_next(500, 3), on_next(600, 4)) results = scheduler.create_observer() d = SerialDisposable() invoked = [0] def projection(x, *args, **kw): invoked[0] += 1 if scheduler.clock > 400: #print("*** Dispose ****") d.dispose() return x d.disposable = xs.select(projection).subscribe(results) def action(scheduler, state): return d.dispose() scheduler.schedule_absolute(ReactiveTest.disposed, action) scheduler.start() results.messages.assert_equal(on_next(100, 1), on_next(200, 2)) xs.subscriptions.assert_equal(ReactiveTest.subscribe(0, 500)) assert invoked[0] == 3
def test_interval_timespan_observer_throws(self): scheduler = TestScheduler() xs = Observable.interval(1, scheduler=scheduler) xs.subscribe(lambda x: _raise("ex")) with self.assertRaises(RxException): scheduler.start()
def test_multicast_hot_21(self): c = [None] d1 = [None] d2 = [None] scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(40, 0), on_next(90, 1), on_next(150, 2), on_next(210, 3), on_next(240, 4), on_next(270, 5), on_next(330, 6), on_next(340, 7), on_completed(390)) s = Subject() o = scheduler.create_observer() def action0(scheduler, state): c[0] = xs.multicast(s) scheduler.schedule_absolute(50, action0) def action1(scheduler, state): d2[0] = c[0].connect() scheduler.schedule_absolute(100, action1) def action2(scheduler, state): d1[0] = c[0].subscribe(o) scheduler.schedule_absolute(200, action2) def action3(scheduler, state): return d1[0].dispose() scheduler.schedule_absolute(300, action3) scheduler.start() o.messages.assert_equal(on_next(210, 3), on_next(240, 4), on_next(270, 5)) xs.subscriptions.assert_equal(subscribe(100, 390))
def test_multicast_hot_6(self): c = [None] d1 = [None] d2 = [None] ex = 'ex' scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(40, 0), on_next(90, 1), on_next(150, 2), on_next(210, 3), on_next(240, 4), on_next(270, 5), on_next(330, 6), on_next(340, 7), on_completed(390)) s = Subject() o = scheduler.create_observer() def action0(scheduler, state): c[0] = xs.pipe(ops.multicast(s)) scheduler.schedule_absolute(50, action0) def action1(scheduler, state): d2[0] = c[0].connect(scheduler) scheduler.schedule_absolute(100, action1) def action2(scheduler, state): d1[0] = c[0].subscribe(o, scheduler) scheduler.schedule_absolute(400, action2) scheduler.start() assert o.messages == [on_completed(400)] assert xs.subscriptions == [subscribe(100, 390)]
def test_select_with_index_dispose_inside_selector(): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(100, 4), on_next(200, 3), on_next(500, 2), on_next(600, 1)) invoked = 0 results = scheduler.create_observer() d = SerialDisposable() def projection(x, index): nonlocal invoked invoked += 1 if scheduler.clock > 400: d.dispose() return x + index * 10 d.disposable = xs.select(projection).subscribe(results) def action(scheduler, state): return d.dispose() scheduler.schedule_absolute(disposed, action) scheduler.start() results.messages.assert_equal(on_next(100, 4), on_next(200, 13)) xs.subscriptions.assert_equal(subscribe(0, 500)) assert invoked == 3
def test_where_index_dispose_in_predicate(self): scheduler = TestScheduler() ys = [None] invoked = [0] xs = scheduler.create_hot_observable(on_next(110, 1), on_next(180, 2), on_next(230, 3), on_next(270, 4), on_next(340, 5), on_next(380, 6), on_next(390, 7), on_next(450, 8), on_next(470, 9), on_next(560, 10), on_next(580, 11), on_completed(600), on_next(610, 12), on_error(620, 'ex'), on_completed(630)) results = scheduler.create_observer() d = SerialDisposable() def action1(scheduler, state): def predicate(x, index): invoked[0] += 1 if x == 8: d.dispose() return is_prime(x + index * 10) ys[0] = xs.filter(predicate) scheduler.schedule_absolute(created, action1) def action2(scheduler, state): d.disposable = ys[0].subscribe(results) scheduler.schedule_absolute(subscribed, action2) def action3(scheduler, state): d.dispose() scheduler.schedule_absolute(disposed, action3) scheduler.start() results.messages.assert_equal(on_next(230, 3), on_next(390, 7)) xs.subscriptions.assert_equal(subscribe(200, 450)) assert(invoked[0] == 6)
def test_retry_observable_retry_count_throws(self): scheduler1 = TestScheduler() xs = rx.return_value(1).pipe(ops.retry(3)) xs.subscribe(lambda x: _raise('ex'), scheduler=scheduler1) self.assertRaises(RxException, scheduler1.start) scheduler2 = TestScheduler() ys = rx.throw('ex').pipe(ops.retry(100)) d = ys.subscribe(on_error=lambda ex: _raise('ex'), scheduler=scheduler2) def dispose(_, __): d.dispose() scheduler2.schedule_absolute(0, dispose) scheduler2.start() scheduler3 = TestScheduler() zs = rx.return_value(1).pipe(ops.retry(100)) zs.subscribe(on_completed=lambda: _raise('ex'), scheduler=scheduler3) with pytest.raises(RxException): scheduler3.start() xss = rx.create(lambda o: _raise('ex')).pipe(ops.retry(100)) with pytest.raises(Exception): xss.subscribe()
def test_map_disposeinsidemapper(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(100, 1), on_next(200, 2), on_next(500, 3), on_next(600, 4)) results = scheduler.create_observer() d = SerialDisposable() invoked = [0] def projection(x, *args, **kw): invoked[0] += 1 if scheduler.clock > 400: d.dispose() return x d.disposable = xs.pipe( map(projection) ).subscribe(results, scheduler) def action(scheduler, state): return d.dispose() scheduler.schedule_absolute(ReactiveTest.disposed, action) scheduler.start() assert results.messages == [on_next(100, 1), on_next(200, 2)] assert xs.subscriptions == [ReactiveTest.subscribe(0, 500)] assert invoked[0] == 3
def test_multicast_hot_5(self): c = [None] d1 = [None] d2 = [None] ex = 'ex' scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(40, 0), on_next(90, 1), on_next(150, 2), on_next(210, 3), on_next(240, 4), on_next(270, 5), on_next(330, 6), on_next(340, 7), on_error(390, ex)) s = Subject() o = scheduler.create_observer() def action0(scheduler, state): c[0] = xs.multicast(s) scheduler.schedule_absolute(50, action0) def action1(scheduler, state): d2[0] = c[0].connect() scheduler.schedule_absolute(100, action1) def action2(scheduler, state): d1[0] = c[0].subscribe(o) scheduler.schedule_absolute(400, action2) scheduler.start() o.messages.assert_equal(on_error(400, ex)) xs.subscriptions.assert_equal(subscribe(100, 390))
def test_paused_with_immediate_unpause(self): subscription = [None] scheduler = TestScheduler() results = scheduler.create_observer() xs = scheduler.create_hot_observable( on_next(150, 1), on_next(210, 2), on_completed(500) ) controller = Observable.just(True) pausable_buffered = xs.pausable_buffered(controller) def action1(scheduler, state): subscription[0] = pausable_buffered.subscribe(results) scheduler.schedule_absolute(200, action1) scheduler.start() results.messages.assert_equal( on_next(210, 2), on_completed(500) )
def test_paused_skip_initial_elements(self): subscription = [None] scheduler = TestScheduler() controller = Subject() results = scheduler.create_observer() xs = scheduler.create_hot_observable(on_next(150, 1), on_next(230, 2), on_next(270, 3), on_completed(400)) def action1(scheduler, state): subscription[0] = xs.pausable_buffered(controller).subscribe(results) controller.on_next(False) scheduler.schedule_absolute(200, action1) def action2(scheduler, state): controller.on_next(True) scheduler.schedule_absolute(280, action2) def action3(scheduler, state): subscription[0].dispose() scheduler.schedule_absolute(1000, action3) scheduler.start() results.messages.assert_equal(on_next(280, 2), on_next(280, 3), on_completed(400))
def test_never_basic(self): scheduler = TestScheduler() xs = Observable.never() results = scheduler.create_observer() xs.subscribe(results) scheduler.start() results.messages.assert_equal()
def test_paused_with_state_change_in_subscriber(self): scheduler = TestScheduler() results = scheduler.create_observer() xs = scheduler.create_hot_observable( on_next(150, 1), on_next(210, 2), on_next(250, 3), on_next(270, 4), on_next(330, 5), on_completed(500) ) controller = Subject() pausable_buffered = xs.pausable_buffered(controller) def action1(scheduler, state): def on_next(value): results.on_next(value) controller.on_next(False) def action2(scheduler, state): controller.on_next(True) scheduler.schedule_relative(100, action2) subscription = pausable_buffered.subscribe(on_next, results.on_error, results.on_completed) controller.on_next(True) scheduler.schedule_absolute(200, action1) scheduler.start() results.messages.assert_equal( on_next(210, 2), on_next(310, 3), on_next(310, 4), on_next(410, 5), on_completed(500) )
def test_group_by_with_merge(self): scheduler = TestScheduler() xs = [None] results = [None] def action1(scheduler, state): xs[0] = rx.from_iterable(["alpha", "apple", "beta", "bat", "gamma"]) \ .pipe(ops.group_by(lambda s: s[0]), ops.map(lambda xs: xs.pipe(ops.to_iterable(), ops.map(list))), ops.merge_all(), ) scheduler.schedule_absolute(created, action1) def action2(scheduler, state): results[0] = scheduler.create_observer() xs[0].subscribe(results[0], scheduler) scheduler.schedule_absolute(subscribed, action2) scheduler.start() assert results[0].messages == [ on_next(200, ["alpha", "apple"]), on_next(200, ["beta", "bat"]), on_next(200, ["gamma"]), on_completed(200)]
def test_repeat_observable_repeat_count_throws(): scheduler1 = TestScheduler() xs = Observable.return_value(1, scheduler1).repeat(3) xs.subscribe(lambda x: _raise('ex')) try: return scheduler1.start() except RxException: pass scheduler2 = TestScheduler() ys = Observable.throwException('ex1', scheduler2).repeat(3) ys.subscribe(lambda ex: _raise('ex2')) try: return scheduler2.start() except RxException: pass scheduler3 = TestScheduler() zs = Observable.return_value(1, scheduler3).repeat(100) d = zs.subscribe(on_complete=lambda: _raise('ex3')) scheduler3.schedule_absolute(10, lambda: d.dispose()) scheduler3.start() xss = Observable.create(lambda o: _raise('ex4')).repeat(3) try: return xss.subscribe() except RxException: pass
def test_retry_observable_throws(self): scheduler1 = TestScheduler() xs = Observable.return_value(1, scheduler1).retry() xs.subscribe(lambda x: _raise('ex')) try: return scheduler1.start() except RxException: pass scheduler2 = TestScheduler() ys = Observable.throw_exception('ex', scheduler2).retry() d = ys.subscribe(on_error=lambda ex: _raise('ex')) scheduler2.schedule_absolute(210, lambda: d.dispose()) scheduler2.start() scheduler3 = TestScheduler() zs = Observable.return_value(1, scheduler3).retry() zs.subscribe(on_completed=lambda: _raise('ex')) try: return scheduler3.start() except RxException: pass xss = Observable.create(lambda o: _raise('ex')).retry() try: return xss.subscribe() except RxException: pass
def test_empty_observer_throw_exception(self): scheduler = TestScheduler() xs = empty() xs.subscribe(lambda x: None, lambda ex: None, lambda: _raise('ex'), scheduler=scheduler) with self.assertRaises(RxException): scheduler.start()
def test_group_by_with_merge(self): scheduler = TestScheduler() xs = [None] results = [None] def action1(scheduler, state): xs[0] = Observable.from_(["alpha", "apple", "beta", "bat", "gamma"]) \ .group_by(lambda s: s[0]) \ .map(lambda group: group.to_list()) \ .merge_all() scheduler.schedule_absolute(created, action1) def action2(scheduler, state): results[0] = scheduler.create_observer() xs[0].subscribe(results[0]) scheduler.schedule_absolute(subscribed, action2) scheduler.start() results[0].messages.assert_equal( on_next(200, ["alpha", "apple"]), on_next(200, ["beta", "bat"]), on_next(200, ["gamma"]), on_completed(200))
def test_range_double_subscribe(self): scheduler = TestScheduler() obs = Observable.range(1, 3) results = scheduler.start(lambda: obs) results.messages.assert_equal(on_next(200, 1), on_next(200, 2), on_next(200, 3), on_completed(200)) results = scheduler.start(lambda: obs) results.messages.assert_equal(on_next(1001, 1), on_next(1001, 2), on_next(1001, 3), on_completed(1001))
def test_double_subscribe_to_iterable(self): iterable_finite = [1, 2, 3] scheduler = TestScheduler() obs = Observable.from_(iterable_finite) results = scheduler.start(lambda: obs) results.messages.assert_equal(on_next(200, 1), on_next(200, 2), on_next(200, 3), on_completed(200)) results = scheduler.start(lambda: obs) results.messages.assert_equal(on_next(1001, 1), on_next(1001, 2), on_next(1001, 3), on_completed(1001))
def test_paused_with_observable_controller_and_pause_and_unpause(self): subscription = [None] scheduler = TestScheduler() results = scheduler.create_observer() xs = scheduler.create_hot_observable( on_next(150, 1), on_next(210, 2), on_next(230, 3), on_next(301, 4), on_next(350, 5), on_next(399, 6), on_next(450, 7), on_next(470, 8), on_completed(500), ) controller = scheduler.create_hot_observable(on_next(201, True), on_next(300, False), on_next(400, True)) pausable_buffered = xs.pausable_buffered(controller) def action1(scheduler, state): subscription[0] = pausable_buffered.subscribe(results) scheduler.schedule_absolute(200, action1) def action2(scheduler, state): pausable_buffered.pause() scheduler.schedule_absolute(460, action2) def action3(scheduler, state): pausable_buffered.resume() scheduler.schedule_absolute(480, action3) def action4(scheduler, state): subscription[0].dispose() scheduler.schedule_absolute(1000, action4) scheduler.start() results.messages.assert_equal( on_next(210, 2), on_next(230, 3), on_next(400, 4), on_next(400, 5), on_next(400, 6), on_next(450, 7), on_next(480, 8), on_completed(500), )
def test_do_action_without_next(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(150, 1), on_next(210, 2), on_completed(250)) completed = [False] def create(): def on_completed(): completed[0] = True return xs.do_action(on_completed=on_completed) scheduler.start(create) assert(completed[0])
def test_group_by_inner_error(): ex = 'ex1' scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(90, "error"), on_next(110, "error"), on_next(130, "error"), on_next(220, " foo"), on_next(240, " FoO "), on_next(270, "baR "), on_next(310, "foO "), on_next(350, " Baz "), on_next(360, " qux "), on_next(390, " bar"), on_next(420, " BAR "), on_next(470, "FOO "), on_next(480, "baz "), on_next(510, " bAZ "), on_next(530, " fOo "), on_error(570, ex), on_next(580, "error"), on_completed(600), on_error(650, 'ex')) outer_subscription = None inner_subscriptions = {} inners = {} outer = None results = {} result = None def action1(scheduler, state): nonlocal outer outer = xs.group_by( lambda x: x.lower().strip(), lambda x: x[::-1] ) return outer scheduler.schedule_absolute(created, action1) def action2(scheduler, state): nonlocal outer_subscription def on_next(group): nonlocal result, inners, results result = scheduler.create_observer() inners[group.key] = group results[group.key] = result def action3(scheduler, state): nonlocal inner_subscriptions inner_subscriptions[group.key] = group.subscribe(result) scheduler.schedule_relative(100, action3) outer_subscription = outer.subscribe(on_next, lambda e: None) return outer_subscription scheduler.schedule_absolute(subscribed, action2) def action4(scheduler, state): outer_subscription.dispose(); for sub in inner_subscriptions.values(): sub.dispose() scheduler.schedule_absolute(disposed, action4) scheduler.start() assert(len(inners) == 4) #results['foo'].messages.assert_equal(on_next(470, " OOF"), on_next(530, " oOf "), on_error(570, ex)) #results['bar'].messages.assert_equal(on_next(390, "rab "), on_next(420, " RAB "), on_error(570, ex)) #results['baz'].messages.assert_equal(on_next(480, " zab"), on_next(510, " ZAb "), on_error(570, ex)) #results['qux'].messages.assert_equal(on_error(570, ex)) xs.subscriptions.assert_equal(subscribe(200, 570))
def test_do_plain_action(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(150, 1), on_next(210, 2), on_next(220, 3), on_next(230, 4), on_next(240, 5), on_completed(250)) i = [0] def create(): def action(x): i[0] += 1 return i[0] return xs.do_action(action) scheduler.start(create) self.assertEqual(4, i[0])
def test_partition_completed(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_next(180, 5), on_next(210, 4), on_next(240, 3), on_next(290, 2), on_next(350, 1), on_completed(360) ) observables = [] subscription1 = [None] subscription2 = [None] results1 = scheduler.create_observer() results2 = scheduler.create_observer() def action0(scheduler, state): observables.extend(xs.partition(is_even)) scheduler.schedule_absolute(ReactiveTest.created, action0) def action1(scheduler, state): subscription1[0] = observables[0].subscribe(results1) subscription2[0] = observables[1].subscribe(results2) scheduler.schedule_absolute(ReactiveTest.subscribed, action1) def action2(scheduler, state): subscription1[0].dispose() subscription2[0].dispose() scheduler.schedule_absolute(ReactiveTest.disposed, action2) scheduler.start() results1.messages.assert_equal( on_next(210, 4), on_next(290, 2), on_completed(360) ) results2.messages.assert_equal( on_next(240, 3), on_next(350, 1), on_completed(360) ) xs.subscriptions.assert_equal( subscribe(200, 360) )
def test_repeat_observable_repeat_count_throws(self): scheduler1 = TestScheduler() xs = rx.return_value(1).pipe(ops.repeat(3)) xs.subscribe(lambda x: _raise('ex'), scheduler=scheduler1) with self.assertRaises(RxException): scheduler1.start() scheduler2 = TestScheduler() ys = rx.throw('ex1').pipe(ops.repeat(3)) ys.subscribe(on_error=lambda ex: _raise('ex2'), scheduler=scheduler2) with self.assertRaises(RxException): scheduler2.start()
def test_replay_time_basic(self): subscription = [None] connection = [None] ys = [None] scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(110, 7), on_next(220, 3), on_next(280, 4), on_next(290, 1), on_next(340, 8), on_next(360, 5), on_next( 370, 6), on_next(390, 7), on_next(410, 13), on_next(430, 2), on_next(450, 9), on_next(520, 11), on_next(560, 20), on_completed(600)) results = scheduler.create_observer() def action0(scheduler, state): ys[0] = xs.pipe(ops.replay(window=150, scheduler=scheduler)) scheduler.schedule_absolute(created, action0) def action1(scheduler, state): subscription[0] = ys[0].subscribe(results) scheduler.schedule_absolute(450, action1) def action2(scheduler, state): subscription[0].dispose() scheduler.schedule_absolute(disposed, action2) def action3(scheduler, state): connection[0] = ys[0].connect(scheduler) scheduler.schedule_absolute(300, action3) def action4(scheduler, state): connection[0].dispose() scheduler.schedule_absolute(400, action4) def action5(scheduler, state): connection[0] = ys[0].connect(scheduler) scheduler.schedule_absolute(500, action5) def action6(scheduler, state): connection[0].dispose() scheduler.schedule_absolute(550, action6) def action7(scheduler, state): connection[0] = ys[0].connect(scheduler) scheduler.schedule_absolute(650, action7) def action8(scheduler, state): connection[0].dispose() scheduler.schedule_absolute(800, action8) scheduler.start() assert results.messages == [on_next(450, 8), on_next( 450, 5), on_next(450, 6), on_next(450, 7), on_next(520, 11)] assert xs.subscriptions == [subscribe(300, 400), subscribe(500, 550), subscribe(650, 800)]
def test_timeout_duration_simple_never(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_next(310, 1), on_next(350, 2), on_next(420, 3), on_completed(450) ) ys = scheduler.create_cold_observable() def create(): return xs.timeout_with_selector(ys, lambda _: ys) results = scheduler.start(create) results.messages.assert_equal( on_next(310, 1), on_next(350, 2), on_next(420, 3), on_completed(450) ) xs.subscriptions.assert_equal( subscribe(200, 450) ) ys.subscriptions.assert_equal( subscribe(200, 310), subscribe(310, 350), subscribe(350, 420), subscribe(420, 450) )
def test_timeout_duration_simple_timeoutbycompletion(self): ex = 'ex' scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(310, 1), on_next(350, 2), on_next(420, 3), on_completed(450)) ys = scheduler.create_cold_observable() zs = scheduler.create_cold_observable() def create(): def selector(x): if x < 3: return zs else: raise Exception(ex) return xs.timeout_with_selector(ys, selector) results = scheduler.start(create) results.messages.assert_equal( on_next(310, 1), on_next(350, 2), on_next(420, 3), on_error(420, ex) ) xs.subscriptions.assert_equal(subscribe(200, 420)) ys.subscriptions.assert_equal(subscribe(200, 310)) zs.subscriptions.assert_equal(subscribe(310, 350), subscribe(350, 420))
def test_interval_timespan_negative(self): scheduler = TestScheduler() def create(): return Observable.interval(-1, scheduler=scheduler) results = scheduler.start(create, disposed=210) results.messages.assert_equal(on_next(201, 0), on_next(202, 1), on_next(203, 2), on_next(204, 3), on_next(205, 4), on_next(206, 5), on_next(207, 6), on_next(208, 7), on_next(209, 8))
def test_group_join_op_normal_ii(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_next(210, TimeInterval(0, 10)), on_next(219, TimeInterval(1, 5)), on_next(240, TimeInterval(2, 10)), on_next(300, TimeInterval(3, 100)), on_next(310, TimeInterval(4, 80)), on_next(500, TimeInterval(5, 90)), on_next(700, TimeInterval(6, 25)), on_next(710, TimeInterval(7, 200)), on_next(720, TimeInterval(8, 100)), on_completed(721)) ys = scheduler.create_hot_observable( on_next(215, TimeInterval("hat", (20))), on_next(217, TimeInterval("bat", (1))), on_next(290, TimeInterval("wag", (200))), on_next(300, TimeInterval("pig", (10))), on_next(305, TimeInterval("cup", (50))), on_next(600, TimeInterval("yak", (90))), on_next(702, TimeInterval("tin", (20))), on_next(712, TimeInterval("man", (10))), on_next(722, TimeInterval("rat", (200))), on_next(732, TimeInterval("wig", (5))), on_completed(990)) xsd = [] ysd = [] def create(): def mapper(x_yy): x, yy = x_yy return yy.pipe( ops.map(lambda y: '{}{}'.format(x.value, y.value))) return xs.pipe( ops.group_join( ys, lambda x: new_timer(xsd, x.interval, scheduler), lambda y: new_timer(ysd, y.interval, scheduler), ), ops.flat_map(mapper), ) res = scheduler.start(create=create) assert res.messages == [ on_next(215, "0hat"), on_next(217, "0bat"), on_next(219, "1hat"), on_next(300, "3wag"), on_next(300, "3pig"), on_next(305, "3cup"), on_next(310, "4wag"), on_next(310, "4pig"), on_next(310, "4cup"), on_next(702, "6tin"), on_next(710, "7tin"), on_next(712, "6man"), on_next(712, "7man"), on_next(720, "8tin"), on_next(720, "8man"), on_next(722, "6rat"), on_next(722, "7rat"), on_next(722, "8rat"), on_next(732, "7wig"), on_next(732, "8wig"), on_completed(910) ] assert xs.subscriptions == [subscribe(200, 721)] assert ys.subscriptions == [subscribe(200, 910)]
def test_infinite(): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(70, 1), on_next(110, 2), on_next(220, 3), on_next(270, 4), on_next(340, 5), on_next(410, 6), on_next(520, 7), on_next(630, 8), on_next(710, 9), on_next(870, 10), on_next(940, 11), on_next(1020, 12)) subject = None subscription = None subscription1 = None subscription2 = None subscription3 = None results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action1(scheduler, state=None): nonlocal subject subject = BehaviorSubject(100) scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): nonlocal subscription subscription = xs.subscribe(subject) scheduler.schedule_absolute(200, action2) def action3(scheduler, state=None): subscription.dispose() scheduler.schedule_absolute(1000, action3) def action4(scheduler, state=None): nonlocal subscription1 subscription1 = subject.subscribe(results1) scheduler.schedule_absolute(300, action4) def action5(scheduler, state=None): nonlocal subscription2 subscription2 = subject.subscribe(results2) scheduler.schedule_absolute(400, action5) def action6(scheduler, state=None): nonlocal subscription3 subscription3 = subject.subscribe(results3) scheduler.schedule_absolute(900, action6) def action7(scheduler, state=None): subscription1.dispose() scheduler.schedule_absolute(600, action7) def action8(scheduler, state=None): subscription2.dispose() scheduler.schedule_absolute(700, action8) def action9(scheduler, state=None): subscription1.dispose() scheduler.schedule_absolute(800, action9) def action10(scheduler, state=None): subscription3.dispose() scheduler.schedule_absolute(950, action10) scheduler.start() results1.messages.assert_equal(on_next(300, 4), on_next(340, 5), on_next(410, 6), on_next(520, 7)) results2.messages.assert_equal(on_next(400, 5), on_next(410, 6), on_next(520, 7), on_next(630, 8)) results3.messages.assert_equal(on_next(900, 10), on_next(940, 11))
def test_connectable_observable_multiple_non_overlapped_connections(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(210, 1), on_next(220, 2), on_next(230, 3), on_next(240, 4), on_next(250, 5), on_next(260, 6), on_next(270, 7), on_next(280, 8), on_next(290, 9), on_completed(300)) subject = Subject() conn = xs.multicast(subject) c1 = [None] def action10(scheduler, state): c1[0] = conn.connect(scheduler) scheduler.schedule_absolute(225, action10) def action11(scheduler, state): c1[0].dispose() scheduler.schedule_absolute(241, action11) def action12(scheduler, state): c1[0].dispose() # idempotency test scheduler.schedule_absolute(245, action12) def action13(scheduler, state): c1[0].dispose() # idempotency test scheduler.schedule_absolute(251, action13) def action14(scheduler, state): c1[0].dispose() # idempotency test scheduler.schedule_absolute(260, action14) c2 = [None] def action20(scheduler, state): c2[0] = conn.connect(scheduler) scheduler.schedule_absolute(249, action20) def action21(scheduler, state): c2[0].dispose() scheduler.schedule_absolute(255, action21) def action22(scheduler, state): c2[0].dispose() # idempotency test scheduler.schedule_absolute(265, action22) def action23(scheduler, state): c2[0].dispose() # idempotency test scheduler.schedule_absolute(280, action23) c3 = [None] def action30(scheduler, state): c3[0] = conn.connect(scheduler) scheduler.schedule_absolute(275, action30) def action31(scheduler, state): c3[0].dispose() scheduler.schedule_absolute(295, action31) res = scheduler.start(lambda: conn) assert res.messages == [ on_next(230, 3), on_next(240, 4), on_next(250, 5), on_next(280, 8), on_next(290, 9) ] assert xs.subscriptions == [ subscribe(225, 241), subscribe(249, 255), subscribe(275, 295) ]
def test_subject_disposed(): scheduler = TestScheduler() subject = None results1 = scheduler.create_observer() subscription1 = None results2 = scheduler.create_observer() subscription2 = None results3 = scheduler.create_observer() subscription3 = None def action1(scheduler, state=None): nonlocal subject subject = BehaviorSubject(0) scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): nonlocal subscription1 subscription1 = subject.subscribe(results1) scheduler.schedule_absolute(200, action2) def action3(scheduler, state=None): nonlocal subscription2 subscription2 = subject.subscribe(results2) scheduler.schedule_absolute(300, action3) def action4(scheduler, state=None): nonlocal subscription3 subscription3 = subject.subscribe(results3) scheduler.schedule_absolute(400, action4) def action5(scheduler, state=None): subscription1.dispose() scheduler.schedule_absolute(500, action5) def action6(scheduler, state=None): subject.dispose() scheduler.schedule_absolute(600, action6) def action7(scheduler, state=None): subscription2.dispose() scheduler.schedule_absolute(700, action7) def action8(scheduler, state=None): subscription3.dispose() scheduler.schedule_absolute(800, action8) def action9(scheduler, state=None): subject.on_next(1) scheduler.schedule_absolute(150, action9) def action10(scheduler, state=None): subject.on_next(2) scheduler.schedule_absolute(250, action10) def action11(scheduler, state=None): subject.on_next(3) scheduler.schedule_absolute(350, action11) def action12(scheduler, state=None): subject.on_next(4) scheduler.schedule_absolute(450, action12) def action13(scheduler, state=None): subject.on_next(5) scheduler.schedule_absolute(550, action13) @raises(DisposedException) def action14(scheduler, state=None): subject.on_next(6) scheduler.schedule_absolute(650, action14) @raises(DisposedException) def action15(scheduler, state=None): subject.on_completed() scheduler.schedule_absolute(750, action15) @raises(DisposedException) def action16(scheduler, state=None): subject.on_error(RxException()) scheduler.schedule_absolute(850, action16) @raises(DisposedException) def action17(scheduler, state=None): subject.subscribe(None) scheduler.schedule_absolute(950, action17) scheduler.start() results1.messages.assert_equal(on_next(200, 1), on_next(250, 2), on_next(350, 3), on_next(450, 4)) results2.messages.assert_equal(on_next(300, 2), on_next(350, 3), on_next(450, 4), on_next(550, 5)) results3.messages.assert_equal(on_next(400, 3), on_next(450, 4), on_next(550, 5))
def test_canceled(): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_completed(630), on_next(640, 9), on_completed(650), on_error(660, RxException())) subject = [None] subscription = [None] subscription1 = [None] subscription2 = [None] subscription3 = [None] results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action1(scheduler, state=None): subject[0] = ReplaySubject(3, 100, scheduler) scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): subscription[0] = xs.subscribe(subject[0]) scheduler.schedule_absolute(200, action2) def action3(scheduler, state=None): subscription[0].dispose() scheduler.schedule_absolute(1000, action3) def action4(scheduler, state=None): subscription1[0] = subject[0].subscribe(results1) scheduler.schedule_absolute(300, action4) def action5(scheduler, state=None): subscription2[0] = subject[0].subscribe(results2) scheduler.schedule_absolute(400, action5) def action6(scheduler, state=None): subscription3[0] = subject[0].subscribe(results3) scheduler.schedule_absolute(900, action6) def action7(scheduler, state=None): subscription1[0].dispose() scheduler.schedule_absolute(600, action7) def action8(scheduler, state=None): subscription2[0].dispose() scheduler.schedule_absolute(700, action8) def action9(scheduler, state=None): subscription1[0].dispose() scheduler.schedule_absolute(800, action9) def action10(scheduler, state=None): subscription3[0].dispose() scheduler.schedule_absolute(950, action10) scheduler.start() assert results1.messages == [] assert results2.messages == [on_completed(630)] assert results3.messages == [on_completed(900)]
def test_flat_map_dispose(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_next(5, scheduler.create_cold_observable(on_error(1, 'ex1'))), on_next(105, scheduler.create_cold_observable(on_error(1, 'ex2'))), on_next( 300, scheduler.create_cold_observable(on_next(10, 102), on_next(90, 103), on_next(110, 104), on_next(190, 105), on_next(440, 106), on_completed(460))), on_next( 400, scheduler.create_cold_observable(on_next(180, 202), on_next(190, 203), on_completed(205))), on_next( 550, scheduler.create_cold_observable(on_next(10, 301), on_next(50, 302), on_next(70, 303), on_next(260, 304), on_next(310, 305), on_completed(410))), on_next(750, scheduler.create_cold_observable(on_completed(40))), on_next( 850, scheduler.create_cold_observable(on_next(80, 401), on_next(90, 402), on_completed(100))), on_completed(900)) def create(): return xs.pipe(ops.flat_map(lambda x: x)) results = scheduler.start(create, disposed=700) assert results.messages == [ on_next(310, 102), on_next(390, 103), on_next(410, 104), on_next(490, 105), on_next(560, 301), on_next(580, 202), on_next(590, 203), on_next(600, 302), on_next(620, 303) ] assert xs.subscriptions == [subscribe(200, 700)] assert xs.messages[2].value.value.subscriptions == [ subscribe(300, 700) ] assert xs.messages[3].value.value.subscriptions == [ subscribe(400, 605) ] assert xs.messages[4].value.value.subscriptions == [ subscribe(550, 700) ] assert xs.messages[5].value.value.subscriptions == [] assert xs.messages[6].value.value.subscriptions == []
def test_replay_subject_dies_out(): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(70, 1), on_next(110, 2), on_next(220, 3), on_next(270, 4), on_next(340, 5), on_next(410, 6), on_next(520, 7), on_completed(580)) subject = [None] results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() results4 = scheduler.create_observer() def action1(scheduler, state=None): subject[0] = ReplaySubject(sys.maxsize, 100, scheduler) scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): xs.subscribe(subject[0]) scheduler.schedule_absolute(200, action2) def action3(scheduler, state=None): subject[0].subscribe(results1) scheduler.schedule_absolute(300, action3) def action4(scheduler, state=None): subject[0].subscribe(results2) scheduler.schedule_absolute(400, action4) def action5(scheduler, state=None): subject[0].subscribe(results3) scheduler.schedule_absolute(600, action5) def action6(scheduler, state=None): subject[0].subscribe(results4) scheduler.schedule_absolute(900, action6) scheduler.start() assert results1.messages == [ on_next(300, 3), on_next(300, 4), on_next(340, 5), on_next(410, 6), on_next(520, 7), on_completed(580) ] assert results2.messages == [ on_next(400, 5), on_next(410, 6), on_next(520, 7), on_completed(580) ] assert results3.messages == [on_next(600, 7), on_completed(600)] assert results4.messages == [on_completed(900)]
def test_subject_disposed(): scheduler = TestScheduler() subject = [None] subscription1 = [None] subscription2 = [None] subscription3 = [None] results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action1(scheduler, state=None): subject[0] = ReplaySubject(scheduler=scheduler) scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): subscription1[0] = subject[0].subscribe(results1) scheduler.schedule_absolute(200, action2) def action3(scheduler, state=None): subscription2[0] = subject[0].subscribe(results2) scheduler.schedule_absolute(300, action3) def action4(scheduler, state=None): subscription3[0] = subject[0].subscribe(results3) scheduler.schedule_absolute(400, action4) def action5(scheduler, state=None): subscription1[0].dispose() scheduler.schedule_absolute(500, action5) def action6(scheduler, state=None): subject[0].dispose() scheduler.schedule_absolute(600, action6) def action7(scheduler, state=None): subscription2[0].dispose() scheduler.schedule_absolute(700, action7) def action8(scheduler, state=None): subscription3[0].dispose() scheduler.schedule_absolute(800, action8) def action9(scheduler, state=None): subject[0].on_next(1) scheduler.schedule_absolute(150, action9) def action10(scheduler, state=None): subject[0].on_next(2) scheduler.schedule_absolute(250, action10) def action11(scheduler, state=None): subject[0].on_next(3) scheduler.schedule_absolute(350, action11) def action12(scheduler, state=None): subject[0].on_next(4) scheduler.schedule_absolute(450, action12) def action13(scheduler, state=None): subject[0].on_next(5) scheduler.schedule_absolute(550, action13) def action14(scheduler, state=None): with pytest.raises(DisposedException): subject[0].on_next(6) scheduler.schedule_absolute(650, action14) def action15(scheduler, state=None): with pytest.raises(DisposedException): subject[0].on_completed() scheduler.schedule_absolute(750, action15) def action16(scheduler, state=None): with pytest.raises(DisposedException): subject[0].on_error(Exception()) scheduler.schedule_absolute(850, action16) def action17(scheduler, state=None): with pytest.raises(DisposedException): subject[0].subscribe(None) scheduler.schedule_absolute(950, action17) scheduler.start() assert results1.messages == [ on_next(200, 1), on_next(250, 2), on_next(350, 3), on_next(450, 4) ] assert results2.messages == [ on_next(300, 1), on_next(300, 2), on_next(350, 3), on_next(450, 4), on_next(550, 5) ] assert results3.messages == [ on_next(400, 1), on_next(400, 2), on_next(400, 3), on_next(450, 4), on_next(550, 5) ]
def test_count_empty(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(150, 1), on_completed(250)) res = scheduler.start(create=lambda: xs.count()).messages res.assert_equal(on_next(250, 0), on_completed(250))
def test_min_int32_return(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(150, 1), on_next(210, 2), on_completed(250)) res = scheduler.start(create=lambda: xs.min()).messages res.assert_equal(on_next(250, 2), on_completed(250))
def test_min_int32_never(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(150, 1)) res = scheduler.start(create=lambda: xs.min()).messages res.assert_equal()
def test_publish_with_initial_value_dispose(self): connection = [None] subscription = [None] ys = [None] scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(110, 7), on_next(220, 3), on_next(280, 4), on_next(290, 1), on_next(340, 8), on_next(360, 5), on_next(370, 6), on_next(390, 7), on_next(410, 13), on_next(430, 2), on_next(450, 9), on_next(520, 11), on_next(560, 20), on_completed(600)) results = scheduler.create_observer() def action0(scheduler, state): ys[0] = xs.publish_value(1979) scheduler.schedule_absolute(created, action0) def action1(scheduler, state): subscription[0] = ys[0].subscribe(results) scheduler.schedule_absolute(subscribed, action1) def action2(scheduler, state): subscription[0].dispose() scheduler.schedule_absolute(350, action2) def action3(scheduler, state): connection[0] = ys[0].connect() scheduler.schedule_absolute(300, action3) def action4(scheduler, state): connection[0].dispose() scheduler.schedule_absolute(400, action4) def action5(scheduler, state): connection[0] = ys[0].connect() scheduler.schedule_absolute(500, action5) def action6(scheduler, state): connection[0].dispose() scheduler.schedule_absolute(550, action6) def action7(scheduler, state): connection[0] = ys[0].connect() scheduler.schedule_absolute(650, action7) def action8(scheduler, state): connection[0].dispose() scheduler.schedule_absolute(800, action8) scheduler.start() results.messages.assert_equal(on_next(200, 1979), on_next(340, 8)) xs.subscriptions.assert_equal(subscribe(300, 400), subscribe(500, 550), subscribe(650, 800))
def test_infinite(): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(70, 1), on_next(110, 2), on_next(220, 3), on_next(270, 4), on_next(340, 5), on_next(410, 6), on_next(520, 7), on_next(630, 8), on_next(710, 9), on_next(870, 10), on_next(940, 11), on_next(1020, 12)) subject = [None] subscription = [None] subscription1 = [None] subscription2 = [None] subscription3 = [None] results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action1(scheduler, state=None): subject[0] = ReplaySubject(3, 100, scheduler) scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): subscription[0] = xs.subscribe(subject[0]) scheduler.schedule_absolute(200, action2) def action3(scheduler, state=None): subscription[0].dispose() scheduler.schedule_absolute(1000, action3) def action4(scheduler, state=None): subscription1[0] = subject[0].subscribe(results1) scheduler.schedule_absolute(300, action4) def action5(scheduler, state=None): subscription2[0] = subject[0].subscribe(results2) scheduler.schedule_absolute(400, action5) def action6(scheduler, state=None): subscription3[0] = subject[0].subscribe(results3) scheduler.schedule_absolute(900, action6) def action7(scheduler, state=None): subscription1[0].dispose() scheduler.schedule_absolute(600, action7) def action8(scheduler, state=None): subscription2[0].dispose() scheduler.schedule_absolute(700, action8) def action9(scheduler, state=None): subscription1[0].dispose() scheduler.schedule_absolute(800, action9) def action10(scheduler, state=None): subscription3[0].dispose() scheduler.schedule_absolute(950, action10) scheduler.start() assert results1.messages == [ on_next(300, 3), on_next(300, 4), on_next(340, 5), on_next(410, 6), on_next(520, 7) ] assert results2.messages == [ on_next(400, 5), on_next(410, 6), on_next(520, 7), on_next(630, 8) ] assert results3.messages == [on_next(900, 10), on_next(940, 11)]
def test_flat_map_on_error(self): invoked = [0] ex = 'ex' scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_next(5, scheduler.create_cold_observable(on_error(1, 'ex1'))), on_next(105, scheduler.create_cold_observable(on_error(1, 'ex2'))), on_next( 300, scheduler.create_cold_observable(on_next(10, 102), on_next(90, 103), on_next(110, 104), on_next(190, 105), on_next(440, 106), on_completed(460))), on_next( 400, scheduler.create_cold_observable(on_next(180, 202), on_next(190, 203), on_completed(205))), on_next( 550, scheduler.create_cold_observable(on_next(10, 301), on_next(50, 302), on_next(70, 303), on_next(260, 304), on_next(310, 305), on_completed(410))), on_next(750, scheduler.create_cold_observable(on_completed(40))), on_next( 850, scheduler.create_cold_observable(on_next(80, 401), on_next(90, 402), on_completed(100))), on_completed(900)) def factory(): def projection(x): invoked[0] += 1 if invoked[0] == 3: raise Exception(ex) return x return xs.pipe(ops.flat_map(projection)) results = scheduler.start(factory) assert results.messages == [ on_next(310, 102), on_next(390, 103), on_next(410, 104), on_next(490, 105), on_error(550, ex) ] assert xs.subscriptions == [subscribe(200, 550)] assert xs.messages[2].value.value.subscriptions == [ subscribe(300, 550) ] assert xs.messages[3].value.value.subscriptions == [ subscribe(400, 550) ] assert xs.messages[4].value.value.subscriptions == [] assert xs.messages[5].value.value.subscriptions == [] assert xs.messages[6].value.value.subscriptions == []
wwt_test_scheduler = TestScheduler() Observable.interval(50, wwt_test_scheduler).take_until( Observable.timer(100)).window_with_time(10).subscribe( lambda observable: observable.count().subscribe(print_value)) # test_scheduler.start() print('-- Combine Latest') cl_test_scheduler = TestScheduler() Observable.combine_latest( Observable.interval(1, cl_test_scheduler).map(lambda x: 'a: {}'.format(x)), Observable.interval(2, cl_test_scheduler).map(lambda x: 'b: {}'.format(x)), lambda a, b: '{}; {}'.format(a, b)).take_until( Observable.timer(1)).subscribe(print_value) # cl_test_scheduler.start() print('-- Zip') zip_test_scheduler = TestScheduler() Observable.zip( Observable.interval(1, zip_test_scheduler).map(lambda x: 'a: {}'.format(x)), Observable.interval(2, zip_test_scheduler).map(lambda x: 'b: {}'.format(x)), lambda a, b: '{}; {}'.format(a, b)).take_until( Observable.timer(1)).subscribe(print_value) zip_test_scheduler.start()
def test_group_join_op_normal_i(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_next(210, TimeInterval(0, 10)), on_next(219, TimeInterval(1, 5)), on_next(240, TimeInterval(2, 10)), on_next(300, TimeInterval(3, 100)), on_next(310, TimeInterval(4, 80)), on_next(500, TimeInterval(5, 90)), on_next(700, TimeInterval(6, 25)), on_next(710, TimeInterval(7, 280)), on_next(720, TimeInterval(8, 100)), on_next(830, TimeInterval(9, 10)), on_completed(900)) ys = scheduler.create_hot_observable( on_next(215, TimeInterval("hat", 20)), on_next(217, TimeInterval("bat", 1)), on_next(290, TimeInterval("wag", 200)), on_next(300, TimeInterval("pig", 10)), on_next(305, TimeInterval("cup", 50)), on_next(600, TimeInterval("yak", 90)), on_next(702, TimeInterval("tin", 20)), on_next(712, TimeInterval("man", 10)), on_next(722, TimeInterval("rat", 200)), on_next(732, TimeInterval("wig", 5)), on_completed(800)) xsd = [] ysd = [] def create(): return xs.group_join( ys, lambda x: new_timer(xsd, x.interval, scheduler), lambda y: new_timer(ysd, y.interval, scheduler), lambda x, yy: yy.map(lambda y: str(x.value) + y.value)).merge_all() res = scheduler.start(create=create) assert res.messages == [ on_next(215, "0hat"), on_next(217, "0bat"), on_next(219, "1hat"), on_next(300, "3wag"), on_next(300, "3pig"), on_next(305, "3cup"), on_next(310, "4wag"), on_next(310, "4pig"), on_next(310, "4cup"), on_next(702, "6tin"), on_next(710, "7tin"), on_next(712, "6man"), on_next(712, "7man"), on_next(720, "8tin"), on_next(720, "8man"), on_next(722, "6rat"), on_next(722, "7rat"), on_next(722, "8rat"), on_next(732, "7wig"), on_next(732, "8wig"), on_next(830, "9rat"), on_completed(990) ] assert xs.subscriptions == [subscribe(200, 990)] assert ys.subscriptions == [subscribe(200, 990)]
def test_error(): scheduler = TestScheduler() ex = RxException() xs = scheduler.create_hot_observable(on_next(70, 1), on_next(110, 2), on_next(220, 3), on_next(270, 4), on_next(340, 5), on_next(410, 6), on_next(520, 7), on_error(630, ex), on_next(640, 9), on_completed(650), on_error(660, RxException())) subject = [None] subscription = [None] subscription1 = [None] subscription2 = [None] subscription3 = [None] results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action1(scheduler, state=None): subject[0] = BehaviorSubject(100) scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): subscription[0] = xs.subscribe(subject[0]) scheduler.schedule_absolute(200, action2) def action3(scheduler, state=None): subscription[0].dispose() scheduler.schedule_absolute(1000, action3) def action4(scheduler, state=None): subscription1[0] = subject[0].subscribe(results1) scheduler.schedule_absolute(300, action4) def action5(scheduler, state=None): subscription2[0] = subject[0].subscribe(results2) scheduler.schedule_absolute(400, action5) def action6(scheduler, state=None): subscription3[0] = subject[0].subscribe(results3) scheduler.schedule_absolute(900, action6) def action7(scheduler, state=None): subscription1[0].dispose() scheduler.schedule_absolute(600, action7) def action8(scheduler, state=None): subscription2[0].dispose() scheduler.schedule_absolute(700, action8) def action9(scheduler, state=None): subscription1[0].dispose() scheduler.schedule_absolute(800, action9) def action10(scheduler, state=None): subscription3[0].dispose() scheduler.schedule_absolute(950, action10) scheduler.start() assert results1.messages == [ on_next(300, 4), on_next(340, 5), on_next(410, 6), on_next(520, 7) ] assert results2.messages == [ on_next(400, 5), on_next(410, 6), on_next(520, 7), on_error(630, ex) ] assert results3.messages == [on_error(900, ex)]
def test_group_by_inner_error(): ex = 'ex1' scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(90, "error"), on_next(110, "error"), on_next(130, "error"), on_next(220, " foo"), on_next(240, " FoO "), on_next(270, "baR "), on_next(310, "foO "), on_next(350, " Baz "), on_next(360, " qux "), on_next(390, " bar"), on_next(420, " BAR "), on_next(470, "FOO "), on_next(480, "baz "), on_next(510, " bAZ "), on_next(530, " fOo "), on_error(570, ex), on_next(580, "error"), on_completed(600), on_error(650, 'ex')) outer_subscription = None inner_subscriptions = {} inners = {} outer = None results = {} result = None def action1(scheduler, state): nonlocal outer outer = xs.group_by(lambda x: x.lower().strip(), lambda x: x[::-1]) return outer scheduler.schedule_absolute(created, action1) def action2(scheduler, state): nonlocal outer_subscription def on_next(group): nonlocal result, inners, results result = scheduler.create_observer() inners[group.key] = group results[group.key] = result def action3(scheduler, state): nonlocal inner_subscriptions inner_subscriptions[group.key] = group.subscribe(result) scheduler.schedule_relative(100, action3) outer_subscription = outer.subscribe(on_next, lambda e: None) return outer_subscription scheduler.schedule_absolute(subscribed, action2) def action4(scheduler, state): outer_subscription.dispose() for sub in inner_subscriptions.values(): sub.dispose() scheduler.schedule_absolute(disposed, action4) scheduler.start() assert (len(inners) == 4) #results['foo'].messages.assert_equal(on_next(470, " OOF"), on_next(530, " oOf "), on_error(570, ex)) #results['bar'].messages.assert_equal(on_next(390, "rab "), on_next(420, " RAB "), on_error(570, ex)) #results['baz'].messages.assert_equal(on_next(480, " zab"), on_next(510, " ZAb "), on_error(570, ex)) #results['qux'].messages.assert_equal(on_error(570, ex)) xs.subscriptions.assert_equal(subscribe(200, 570))
def test_count_never(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(150, 1)) res = scheduler.start(create=lambda: xs.pipe(_.count())).messages assert res == []
def test_canceled(): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_completed(630), on_next(640, 9), on_completed(650), on_error(660, RxException())) subject = None subscription = None subscription1 = None subscription2 = None subscription3 = None results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action1(scheduler, state=None): nonlocal subject subject = BehaviorSubject(100) scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): nonlocal subscription subscription = xs.subscribe(subject) scheduler.schedule_absolute(200, action2) def action3(scheduler, state=None): subscription.dispose() scheduler.schedule_absolute(1000, action3) def action4(scheduler, state=None): nonlocal subscription1 subscription1 = subject.subscribe(results1) scheduler.schedule_absolute(300, action4) def action5(scheduler, state=None): nonlocal subscription2 subscription2 = subject.subscribe(results2) scheduler.schedule_absolute(400, action5) def action6(scheduler, state=None): nonlocal subscription3 subscription3 = subject.subscribe(results3) scheduler.schedule_absolute(900, action6) def action7(scheduler, state=None): subscription1.dispose() scheduler.schedule_absolute(600, action7) def action8(scheduler, state=None): subscription2.dispose() scheduler.schedule_absolute(700, action8) def action9(scheduler, state=None): subscription1.dispose() scheduler.schedule_absolute(800, action9) def action10(scheduler, state=None): subscription3.dispose() scheduler.schedule_absolute(950, action10) scheduler.start() results1.messages.assert_equal(on_next(300, 100)) results2.messages.assert_equal(on_next(400, 100), on_completed(630)) results3.messages.assert_equal(on_completed(900))
def test_count_on_error(self): ex = 'ex' scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(150, 1), on_error(210, ex)) res = scheduler.start(create=lambda: xs.pipe(_.count())).messages assert res == [on_error(210, ex)]
def test_finite(): scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_next(70, 1), on_next(110, 2), on_next(220, 3), on_next(270, 4), on_next(340, 5), on_next(410, 6), on_next(520, 7), on_completed(630), on_next(640, 9), on_completed(650), on_error(660, 'ex') ) subject = [None] subscription = [None] subscription1 = [None] subscription2 = [None] subscription3 = [None] results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action1(scheduler, state=None): subject[0] = ReplaySubject(3, 100, scheduler) scheduler.schedule_absolute(100, action1) def action3(scheduler, state=None): subscription[0] = xs.subscribe(subject[0]) scheduler.schedule_absolute(200, action3) def action4(scheduler, state=None): subscription[0].dispose() scheduler.schedule_absolute(1000, action4) def action5(scheduler, state=None): subscription1[0] = subject[0].subscribe(results1) scheduler.schedule_absolute(300, action5) def action6(scheduler, state=None): subscription2[0] = subject[0].subscribe(results2) scheduler.schedule_absolute(400, action6) def action7(scheduler, state=None): subscription3[0] = subject[0].subscribe(results3) scheduler.schedule_absolute(900, action7) def action8(scheduler, state=None): subscription1[0].dispose() scheduler.schedule_absolute(600, action8) def action9(scheduler, state=None): subscription2[0].dispose() scheduler.schedule_absolute(700, action9) def action10(scheduler, state=None): subscription1[0].dispose() scheduler.schedule_absolute(800, action10) def action11(scheduler, state=None): subscription3[0].dispose() scheduler.schedule_absolute(950, action11) scheduler.start() results1.messages.assert_equal( on_next(301, 3), on_next(302, 4), on_next(341, 5), on_next(411, 6), on_next(521, 7) ) results2.messages.assert_equal( on_next(401, 5), on_next(411, 6), on_next(521, 7), on_completed(631) ) results3.messages.assert_equal( on_completed(901) )
def test_group_by_inner_error(self): ex = 'ex1' scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(90, "error"), on_next(110, "error"), on_next(130, "error"), on_next(220, " foo"), on_next(240, " FoO "), on_next(270, "baR "), on_next(310, "foO "), on_next(350, " Baz "), on_next(360, " qux "), on_next(390, " bar"), on_next(420, " BAR "), on_next(470, "FOO "), on_next(480, "baz "), on_next(510, " bAZ "), on_next(530, " fOo "), on_error(570, ex), on_next(580, "error"), on_completed(600), on_error(650, 'ex')) inner_subscriptions = {} inners = {} results = {} c = {"outer_subscription": None, "outer": None} def action1(scheduler, state): c["outer"] = xs.group_by(lambda x: x.lower().strip(), lambda x: x[::-1]) return c["outer"] scheduler.schedule_absolute(created, action1) def action2(scheduler, state): def on_next(group): result = scheduler.create_observer() inners[group.key] = group results[group.key] = result def action3(scheduler, state): inner_subscriptions[group.key] = group.subscribe( result, scheduler) scheduler.schedule_relative(100, action3) c["outer_subscription"] = c["outer"].subscribe_( on_next, lambda e: None, scheduler=scheduler) return c["outer_subscription"] scheduler.schedule_absolute(subscribed, action2) def action4(scheduler, state): c["outer_subscription"].dispose() for sub in inner_subscriptions.values(): sub.dispose() scheduler.schedule_absolute(disposed, action4) scheduler.start() assert len(inners) == 4 assert results['foo'].messages == [ on_next(470, " OOF"), on_next(530, " oOf "), on_error(570, ex) ] assert results['bar'].messages == [ on_next(390, "rab "), on_next(420, " RAB "), on_error(570, ex) ] assert results['baz'].messages == [ on_next(480, " zab"), on_next(510, " ZAb "), on_error(570, ex) ] assert results['qux'].messages == [on_error(570, ex)] assert xs.subscriptions == [subscribe(200, 570)]
def test_group_by_inner_complete(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_next(90, "error"), on_next(110, "error"), on_next(130, "error"), on_next(220, " foo"), on_next(240, " FoO "), on_next(270, "baR "), on_next(310, "foO "), on_next(350, " Baz "), on_next(360, " qux "), on_next(390, " bar"), on_next(420, " BAR "), on_next(470, "FOO "), on_next(480, "baz "), on_next(510, " bAZ "), on_next(530, " fOo "), on_completed(570), on_next(580, "error"), on_completed(600), on_error(650, 'ex')) c = { "outer_subscription": None, "inner_subscriptions": {}, "inners": {}, "results": {}, "outer": None } def action1(scheduler, state): c["outer"] = xs.pipe( ops.group_by(lambda x: x.lower().strip(), lambda x: x[::-1]), ) scheduler.schedule_absolute(created, action1) def action2(scheduler, state): def next(group): result = scheduler.create_observer() c["inners"][group.key] = group c["results"][group.key] = result def action21(scheduler, state): c["inner_subscriptions"][group.key] = group.subscribe(result, scheduler) scheduler.schedule_relative(100, action21) c["outer_subscription"] = c["outer"].subscribe(next, scheduler=scheduler) scheduler.schedule_absolute(subscribed, action2) def action3(scheduler, state): c["outer_subscription"].dispose() for sub in c["inner_subscriptions"].values(): sub.dispose() scheduler.schedule_absolute(disposed, action3) scheduler.start() assert(len(c["inners"]) == 4) assert c["results"]['foo'].messages == [ on_next(470, " OOF"), on_next(530, " oOf "), on_completed(570)] assert c["results"]['bar'].messages == [ on_next(390, "rab "), on_next(420, " RAB "), on_completed(570)] assert c["results"]['baz'].messages == [ on_next(480, " zab"), on_next(510, " ZAb "), on_completed(570)] assert c["results"]['qux'].messages == [ on_completed(570)] assert xs.subscriptions == [ subscribe(200, 570)]
def test_publish_with_initial_value_error(self): connection = [None] subscription = [None] ys = [None] ex = 'ex' scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(110, 7), on_next(220, 3), on_next(280, 4), on_next(290, 1), on_next(340, 8), on_next(360, 5), on_next(370, 6), on_next(390, 7), on_next(410, 13), on_next(430, 2), on_next(450, 9), on_next(520, 11), on_next(560, 20), on_error(600, ex)) results = scheduler.create_observer() def action0(scheduler, state): ys[0] = xs.pipe(ops.publish_value(1979)) scheduler.schedule_absolute(created, action0) def action1(scheduler, state): subscription[0] = ys[0].subscribe(results) scheduler.schedule_absolute(subscribed, action1) def action2(scheduler, state): subscription[0].dispose() scheduler.schedule_absolute(disposed, action2) def action3(scheduler, state): connection[0] = ys[0].connect() scheduler.schedule_absolute(300, action3) def action4(scheduler, state): connection[0].dispose() scheduler.schedule_absolute(400, action4) def action5(scheduler, state): connection[0] = ys[0].connect() scheduler.schedule_absolute(500, action5) def action6(scheduler, state): connection[0].dispose() scheduler.schedule_absolute(800, action6) scheduler.start() assert results.messages == [ on_next(200, 1979), on_next(340, 8), on_next(360, 5), on_next(370, 6), on_next(390, 7), on_next(520, 11), on_next(560, 20), on_error(600, ex) ] assert xs.subscriptions == [subscribe(300, 400), subscribe(500, 600)]
def test_subject_disposed(): subject = [None] subscription1 = [None] subscription2 = [None] subscription3 = [None] scheduler = TestScheduler() results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action1(scheduler, state=None): subject[0] = AsyncSubject() scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): subscription1[0] = subject[0].subscribe(results1) scheduler.schedule_absolute(200, action2) def action3(scheduler, state=None): subscription2[0] = subject[0].subscribe(results2) scheduler.schedule_absolute(300, action3) def action4(scheduler, state=None): subscription3[0] = subject[0].subscribe(results3) scheduler.schedule_absolute(400, action4) def action5(scheduler, state=None): subscription1[0].dispose() scheduler.schedule_absolute(500, action5) def action6(scheduler, state=None): subject[0].dispose() scheduler.schedule_absolute(600, action6) def action7(scheduler, state=None): subscription2[0].dispose() scheduler.schedule_absolute(700, action7) def action8(scheduler, state=None): subscription3[0].dispose() scheduler.schedule_absolute(800, action8) def action9(scheduler, state=None): subject[0].on_next(1) scheduler.schedule_absolute(150, action9) def action10(scheduler, state=None): subject[0].on_next(2) scheduler.schedule_absolute(250, action10) def action11(scheduler, state=None): subject[0].on_next(3) scheduler.schedule_absolute(350, action11) def action12(scheduler, state=None): subject[0].on_next(4) scheduler.schedule_absolute(450, action12) def action13(scheduler, state=None): subject[0].on_next(5) scheduler.schedule_absolute(550, action13) @raises(DisposedException) def action14(scheduler, state=None): subject[0].on_next(6) scheduler.schedule_absolute(650, action14) @raises(DisposedException) def action15(scheduler, state=None): subject[0].on_completed() scheduler.schedule_absolute(750, action15) @raises(DisposedException) def action16(scheduler, state=None): subject[0].on_error('ex') scheduler.schedule_absolute(850, action16) @raises(DisposedException) def action17(scheduler, state=None): subject[0].subscribe(None) scheduler.schedule_absolute(950, action17) scheduler.start() results1.messages.assert_equal() results2.messages.assert_equal() results3.messages.assert_equal()
print('-- window_with_count | FlatMap') rx.from_(range(3)).pipe(ops.window_with_count(2), ops.flat_map(lambda x: x)).subscribe(print_value) # flatmap 은 # flat 하면 리스트를 푼다. # [[1,2], [3]] -> [1,2,3] # 그리고 나서 map 한다. x -> x # [1, 2, 3] -> [1, 2, 3] print('-- window_with_time') test_scheduler = TestScheduler() rx.interval(0.05, test_scheduler).pipe(ops.take_until( rx.timer(0.1)), ops.window_with_time(0.01)).subscribe( lambda observable: observable.pipe(ops.count()).subscribe(print_value)) test_scheduler.start() time.sleep(0.5) # 결과가 이게 맞나?? 단위가 뭐지? print('-- combine_latest') rx.combine_latest( rx.interval(0.1).pipe(ops.map(lambda x: 'a- {}'.format(x))), rx.interval(0.2).pipe(ops.map(lambda x: 'b- {}'.format(x)))).pipe( ops.take_until(rx.timer(0.5))).subscribe(print_value) time.sleep(1) # 누가 먼저 결과를 배출할지 예상 불가 print('-- zip') rx.zip( rx.interval(0.1).pipe(ops.map(lambda x: 'a- {}'.format(x))), rx.interval(0.2).pipe(ops.map(lambda x: 'b- {}'.format(x)))).pipe(