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_multicast_hot_3(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.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.schedule_absolute(200, action2) def action3(scheduler, state): d2[0].dispose() scheduler.schedule_absolute(300, action3) def action4(scheduler, state): d2[0] = c[0].connect(scheduler) scheduler.schedule_absolute(335, action4) scheduler.start() assert o.messages == [on_next(210, 3), on_next(240, 4), on_next(270, 5), on_next(340, 7), on_completed(390)] assert xs.subscriptions == [subscribe(100, 300), subscribe(335, 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_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_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_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_repeat_observable_repeat_count_throws(self): scheduler1 = TestScheduler() xs = Observable.return_value(1, scheduler1).repeat(3) xs.subscribe(lambda x: _raise('ex')) with self.assertRaises(RxException): scheduler1.start() scheduler2 = TestScheduler() ys = Observable.throw_exception('ex1', scheduler2).repeat(3) ys.subscribe(on_error=lambda ex: _raise('ex2')) with self.assertRaises(RxException): scheduler2.start() scheduler3 = TestScheduler() zs = Observable.return_value(1, scheduler3).repeat(100) d = zs.subscribe(on_completed=lambda: _raise('ex3')) scheduler3.schedule_absolute(10, lambda sc, st: d.dispose()) scheduler3.start() xss = Observable.create(lambda o: _raise('ex4')).repeat(3) with self.assertRaises(RxException): xss.subscribe()
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_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_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_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_multicast_hot_4(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(200, action2) def action3(scheduler, state): d2[0].dispose() scheduler.schedule_absolute(300, action3) def action4(scheduler, state): d2[0] = c[0].connect() scheduler.schedule_absolute(335, action4) scheduler.start() o.messages.assert_equal(on_next(210, 3), on_next(240, 4), on_next(270, 5), on_next(340, 7), on_error(390, ex)) xs.subscriptions.assert_equal(subscribe(100, 300), subscribe(335, 390))
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_if_default_completed(self): b = [False] scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(110, 1), on_next(220, 2), on_next(330, 3), on_completed(440)) def action(scheduler, state): b[0] = True scheduler.schedule_absolute(150, action) def create(): def condition(): return b[0] return rx.if_then(condition, xs) results = scheduler.start(create) assert results.messages == [on_next(220, 2), on_next(330, 3), on_completed(440)] assert xs.subscriptions == [subscribe(200, 440)]
def test_if_default_other(self): b = [True] scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(110, 1), on_next(220, 2), on_next(330, 3), on_error(440, 'ex')) def action(scheduler, state): b[0] = False scheduler.schedule_absolute(150, action) def create(): def condition(): return b[0] return Observable.if_then(condition, xs) results = scheduler.start(create) results.messages.assert_equal(on_completed(200)) xs.subscriptions.assert_equal()
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_retry_observable_throws(self): scheduler1 = TestScheduler() xs = Observable.return_value(1, scheduler1).retry() xs.subscribe(lambda x: _raise('ex')) self.assertRaises(RxException, scheduler1.start) scheduler2 = TestScheduler() ys = Observable.throw_exception('ex', scheduler2).retry() d = ys.subscribe(on_error=lambda ex: _raise('ex')) scheduler2.schedule_absolute(210, lambda sc, st: d.dispose()) scheduler2.start() scheduler3 = TestScheduler() zs = Observable.return_value(1, scheduler3).retry() zs.subscribe(on_completed=lambda: _raise('ex')) self.assertRaises(RxException, scheduler3.start)
def test_repeat_observable_throws(self): scheduler1 = TestScheduler() xs = rx.return_value(11).pipe(ops.repeat()) xs.subscribe(lambda x: _raise('ex'), scheduler=scheduler1) with self.assertRaises(RxException): scheduler1.start() scheduler2 = TestScheduler() ys = rx.throw('ex').pipe(ops.repeat()) ys.subscribe(lambda ex: _raise('ex'), scheduler=scheduler2) with self.assertRaises(Exception): scheduler2.start() scheduler3 = TestScheduler() zs = rx.return_value(1).pipe(ops.repeat()) d = zs.subscribe(on_completed=lambda: _raise('ex'), scheduler=scheduler3) scheduler3.schedule_absolute(210, lambda sc, st: d.dispose()) scheduler3.start()
def test_return_disposed_after_next(self): scheduler = TestScheduler() d = SerialDisposable() xs = Observable.return_value(42, scheduler) results = scheduler.create_observer() def action(scheduler, state): def on_next(x): d.dispose() results.on_next(x) def on_error(e): results.on_error(e) def on_completed(): results.on_completed() d.disposable = xs.subscribe(on_next, on_error, on_completed) return d.disposable scheduler.schedule_absolute(100, action) scheduler.start() results.messages.assert_equal(on_next(101, 42))
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.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_error(400, ex)] assert xs.subscriptions == [subscribe(100, 390)]
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_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_windowedobservalbe_simple(self): scheduler = TestScheduler() windowed = [None] subject = [None] results1 = scheduler.create_observer() results2 = 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_completed(500) ) def action1(scheduler, state=None): subject[0] = ControlledSubject(enable_queue=False, scheduler=scheduler) xs.subscribe(subject[0]) scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): windowed[0] = WindowedObservable(subject[0], 2, scheduler=scheduler) scheduler.schedule_absolute(120, action2) def action3(scheduler, state=None): windowed[0].subscribe(results1) scheduler.schedule_absolute(220, action3) def action4(scheduler, state=None): windowed[0].subscribe(results2) scheduler.schedule_absolute(355, action4) scheduler.start() results1.messages.assert_equal( on_next(230, 3), on_next(301, 4), on_next(350, 5), on_next(399, 6), on_completed(500) ) results2.messages.assert_equal( on_next(399, 6), on_completed(500) )
def test_map_with_index_dispose_inside_mapper(self): 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): invoked[0] += 1 if scheduler.clock > 400: d.dispose() return x + index * 10 d.disposable = xs.pipe(map_indexed(projection)).subscribe(results) def action(scheduler, state): return d.dispose() scheduler.schedule_absolute(disposed, action) scheduler.start() assert results.messages == [on_next(100, 4), on_next(200, 13)] assert xs.subscriptions == [subscribe(0, 500)] assert invoked[0] == 3
def test_starmap_dispose_inside_mapper(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable( # 100 create on_next(110, (1, 10)), # 200 subscribe on_next(210, (2, 20)), on_next(310, (3, 30)), on_next(410, (4, 40))) results = scheduler.create_observer() d = SerialDisposable() invoked = [0] def mapper(x, y): invoked[0] += 1 if scheduler._clock > 250: d.dispose() return x + y d.disposable = xs.pipe( ops.starmap(mapper) ).subscribe(results, scheduler) def action(scheduler, state): return d.dispose() scheduler.schedule_absolute(ReactiveTest.disposed, action) scheduler.start() assert results.messages == [ on_next(110, 11), on_next(210, 22)] assert xs.subscriptions == [ReactiveTest.subscribe(0, 310)] assert invoked[0] == 3
def test_paused_no_skip(self): subscription = [None] scheduler = TestScheduler() controller = Subject() 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_completed(500), ) def action0(scheduler, state): subscription[0] = xs.pausable_buffered(controller).subscribe(results) controller.on_next(True) scheduler.schedule_absolute(200, action0) def action1(scheduler, state): controller.on_next(False) scheduler.schedule_absolute(205, action1) def action2(scheduler, state): controller.on_next(True) scheduler.schedule_absolute(209, action2) def action3(scheduler, state): subscription[0].dispose() scheduler.schedule_absolute(1000, action3) scheduler.start() results.messages.assert_equal( on_next(210, 2), on_next(230, 3), on_next(301, 4), on_next(350, 5), on_next(399, 6), on_completed(500) )
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_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_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.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_completed(400)) xs.subscriptions.assert_equal(subscribe(100, 390))
def test_filter_dispose_in_predicate(self): scheduler = TestScheduler() invoked = [0] ys = [None] 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 action(scheduler, state): def predicate(x): invoked[0] += 1 if x == 8: d.dispose() return is_prime(x) ys[0] = xs.pipe(filter(predicate)) return ys[0] scheduler.schedule_absolute(created, action) def action1(scheduler, state): d.disposable = ys[0].subscribe(results) scheduler.schedule_absolute(subscribed, action1) def action2(scheduler, state): d.dispose() scheduler.schedule_absolute(disposed, action2) scheduler.start() assert results.messages == [ on_next(230, 3), on_next(340, 5), on_next(390, 7)] assert xs.subscriptions == [subscribe(200, 450)] assert(invoked[0] == 6)
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.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() results.messages.assert_equal(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)) xs.subscriptions.assert_equal(subscribe(300, 400), subscribe(500, 600))
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.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.schedule_relative(100, action21) c["outer_subscription"] = c["outer"].subscribe(next) 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) c["results"]['foo'].messages.assert_equal( on_next(470, " OOF"), on_next(530, " oOf "), on_completed(570)) c["results"]['bar'].messages.assert_equal( on_next(390, "rab "), on_next(420, " RAB "), on_completed(570)) c["results"]['baz'].messages.assert_equal( on_next(480, " zab"), on_next(510, " ZAb "), on_completed(570)) c["results"]['qux'].messages.assert_equal( on_completed(570)) xs.subscriptions.assert_equal( subscribe(200, 570))
def test_replay_time_dispose(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.replay(window=100, scheduler=scheduler) scheduler.schedule_absolute(created, action0) def action1(scheduler, state): subscription[0] = ys[0].subscribe(results, scheduler) scheduler.schedule_absolute(450, action1) def action2(scheduler, state): subscription[0].dispose() scheduler.schedule_absolute(475, 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, 5), on_next(450, 6), on_next(450, 7) ] assert xs.subscriptions == [ subscribe(300, 400), subscribe(500, 550), subscribe(650, 800) ]
def test_replay_count_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.replay(buffer_size=3, 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(800, action6) scheduler.start() assert results.messages == [ on_next(450, 5), on_next(450, 6), on_next(450, 7), on_next(520, 11), on_next(560, 20), on_error(600, ex) ] assert xs.subscriptions == [subscribe(300, 400), subscribe(500, 600)]
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.pipe( ops.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_all(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')) inners = {} inner_subscriptions = {} results = {} c = { "outer": None, "outer_subscription": None, "result": 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): c["result"] = scheduler.create_observer() inners[group.key] = group results[group.key] = c["result"] inner_subscriptions[group.key] = group.subscribe(c["result"]) c["outer_subscription"] = c["outer"].subscribe(on_next) return c["outer_subscription"] scheduler.schedule_absolute(subscribed, action2) def action3(scheduler, state): c["outer_subscription"].dispose() for sub in inner_subscriptions.values(): sub.dispose() scheduler.schedule_absolute(disposed, action3) scheduler.start() assert(len(inners) == 4) results['foo'].messages.assert_equal( on_next(220, "oof "), on_next(240, " OoF "), on_next(310, " Oof"), on_next(470, " OOF"), on_next(530, " oOf "), on_completed(570)) results['bar'].messages.assert_equal( on_next(270, " Rab"), on_next(390, "rab "), on_next(420, " RAB "), on_completed(570)) results['baz'].messages.assert_equal( on_next(350, " zaB "), on_next(480, " zab"), on_next(510, " ZAb "), on_completed(570)) results['qux'].messages.assert_equal( on_next(360, " xuq "), on_completed(570)) xs.subscriptions.assert_equal( subscribe(200, 570))
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_error(): subject = [None] subscription = [None] subscription1 = [None] subscription2 = [None] subscription3 = [None] ex = 'ex' 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_error(630, ex), on_next(640, 9), on_completed(650), on_error(660, 'ex2') ) results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action(scheduler, state=None): subject[0] = AsyncSubject() scheduler.schedule_absolute(100, action) def action1(scheduler, state=None): subscription[0] = xs.subscribe(subject[0]) scheduler.schedule_absolute(200, action1) def action2(scheduler, state=None): subscription[0].dispose() scheduler.schedule_absolute(1000, action2) def action3(scheduler, state=None): subscription1[0] = subject[0].subscribe(results1) scheduler.schedule_absolute(300, action3) def action4(scheduler, state=None): subscription2[0] = subject[0].subscribe(results2) scheduler.schedule_absolute(400, action4) def action5(scheduler, state=None): subscription3[0] = subject[0].subscribe(results3) scheduler.schedule_absolute(900, action5) def action6(scheduler, state=None): subscription1[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): subscription1[0].dispose() scheduler.schedule_absolute(800, action8) def action9(scheduler, state=None): subscription3[0].dispose() scheduler.schedule_absolute(950, action9) scheduler.start() assert results1.messages == [] assert results2.messages == [on_error(630, ex)] assert results3.messages == [on_error(900, ex)]
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): nonlocal subject subject = ReplaySubject(scheduler=scheduler) 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(Exception()) 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(201, 1), on_next(251, 2), on_next(351, 3), on_next(451, 4)) results2.messages.assert_equal(on_next(301, 1), on_next(302, 2), on_next(351, 3), on_next(451, 4), on_next(551, 5)) results3.messages.assert_equal(on_next(401, 1), on_next(402, 2), on_next(403, 3), on_next(451, 4), on_next(551, 5))
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): nonlocal subject subject = ReplaySubject(sys.maxsize, 100, scheduler) scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): xs.subscribe(subject) scheduler.schedule_absolute(200, action2) def action3(scheduler, state=None): subject.subscribe(results1) scheduler.schedule_absolute(300, action3) def action4(scheduler, state=None): subject.subscribe(results2) scheduler.schedule_absolute(400, action4) def action5(scheduler, state=None): subject.subscribe(results3) scheduler.schedule_absolute(600, action5) def action6(scheduler, state=None): subject.subscribe(results4) scheduler.schedule_absolute(900, action6) 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), on_completed(581)) results2.messages.assert_equal(on_next(401, 5), on_next(411, 6), on_next(521, 7), on_completed(581)) results3.messages.assert_equal(on_next(601, 7), on_completed(602)) results4.messages.assert_equal(on_completed(901))
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 = ReplaySubject(3, 100, scheduler) 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() results2.messages.assert_equal(on_completed(631)) results3.messages.assert_equal(on_completed(901))
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): nonlocal subject subject = ReplaySubject(3, 100, scheduler) scheduler.schedule_absolute(100, action1) def action3(scheduler, state=None): nonlocal subscription subscription = xs.subscribe(subject) scheduler.schedule_absolute(200, action3) def action4(scheduler, state=None): subscription.dispose() scheduler.schedule_absolute(1000, action4) def action5(scheduler, state=None): nonlocal subscription1 subscription1 = subject.subscribe(results1) scheduler.schedule_absolute(300, action5) def action6(scheduler, state=None): nonlocal subscription2 subscription2 = subject.subscribe(results2) scheduler.schedule_absolute(400, action6) def action7(scheduler, state=None): nonlocal subscription3 subscription3 = subject.subscribe(results3) scheduler.schedule_absolute(900, action7) def action8(scheduler, state=None): subscription1.dispose() scheduler.schedule_absolute(600, action8) def action9(scheduler, state=None): subscription2.dispose() scheduler.schedule_absolute(700, action9) def action10(scheduler, state=None): subscription1.dispose() scheduler.schedule_absolute(800, action10) def action11(scheduler, state=None): subscription3.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_publish_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() 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(340, 8)) xs.subscriptions.assert_equal(subscribe(300, 400), subscribe(500, 550), subscribe(650, 800))
def test_error(): scheduler = TestScheduler() ex = RxException('ex') 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('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 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() 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_error(631, ex)) results3.messages.assert_equal(on_error(901, ex))
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) @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(Exception()) scheduler.schedule_absolute(850, action16) @raises(DisposedException) def action17(scheduler, state=None): 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_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_error(): s = None subscription = None subscription1 = None subscription2 = None subscription3 = None ex = 'ex' 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_error(630, ex), on_next(640, 9), on_completed(650), on_error(660, 'foo')) results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action(scheduler, state=None): nonlocal s s = Subject() scheduler.schedule_absolute(100, action) def action1(scheduler, state=None): nonlocal subscription subscription = xs.subscribe(s) scheduler.schedule_absolute(200, action1) def action2(scheduler, state=None): subscription.dispose() scheduler.schedule_absolute(1000, action2) def action3(scheduler, state=None): nonlocal subscription1 subscription1 = s.subscribe(results1) scheduler.schedule_absolute(300, action3) def action4(scheduler, state=None): nonlocal subscription2 subscription2 = s.subscribe(results2) scheduler.schedule_absolute(400, action4) def action5(scheduler, state=None): nonlocal subscription3 subscription3 = s.subscribe(results3) scheduler.schedule_absolute(900, action5) def action6(scheduler, state=None): subscription1.dispose() scheduler.schedule_absolute(600, action6) def action7(scheduler, state=None): subscription2.dispose() scheduler.schedule_absolute(700, action7) def action8(scheduler, state=None): subscription1.dispose() scheduler.schedule_absolute(800, action8) def action9(scheduler, state=None): subscription3.dispose() scheduler.schedule_absolute(950, action9) scheduler.start() results1.messages.assert_equal(on_next(340, 5), on_next(410, 6), on_next(520, 7)) results2.messages.assert_equal(on_next(410, 6), on_next(520, 7), on_error(630, ex)) results3.messages.assert_equal(on_error(900, ex))
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_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.pipe(ops.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_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_replay_count_complete(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.replay(None, 3, None, scheduler) scheduler.schedule_absolute(created, action0) def action1(scehduler, 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.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 action(scheduler, state): connection[0].dispose() scheduler.schedule_absolute(800, action) scheduler.start() results.messages.assert_equal(on_next(451, 5), on_next(452, 6), on_next(453, 7), on_next(521, 11), on_next(561, 20), on_completed(601)) xs.subscriptions.assert_equal(subscribe(300, 400), subscribe(500, 600))
def test_infinite(): subject = None subscription = None subscription1 = None subscription2 = None subscription3 = None 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)) results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action1(scheduler, state=None): nonlocal subject subject = AsyncSubject() 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() results2.messages.assert_equal() results3.messages.assert_equal()
def test_finite(): scheduler = TestScheduler() subscription = [None] subscription1 = [None] subscription2 = [None] subscription3 = [None] s = [None] 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, 'error') ) results1 = scheduler.create_observer() results2 = scheduler.create_observer() results3 = scheduler.create_observer() def action1(scheduler, state=None): s[0] = Subject() scheduler.schedule_absolute(100, action1) def action2(scheduler, state=None): subscription[0] = xs.subscribe(s[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] = s[0].subscribe(results1) scheduler.schedule_absolute(300, action4) def action5(scheduler, state=None): subscription2[0] = s[0].subscribe(results2) scheduler.schedule_absolute(400, action5) def action6(scheduler, state=None): subscription3[0] = s[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() results1.messages.assert_equal( on_next(340, 5), on_next(410, 6), on_next(520, 7) ) results2.messages.assert_equal( on_next(410, 6), on_next(520, 7), on_completed(630) ) results3.messages.assert_equal( on_completed(900) )