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_group_by_with_ReplaySubject(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_next(300, 1), on_next(310, 2), on_next(320, 3), on_next(320, 4), on_next(320, 5), on_next(320, 6), on_completed(1000), ) observer_groups = scheduler.create_observer() observer_odd = scheduler.create_observer() observer_even = scheduler.create_observer() def subscription(scheduler, state): source = xs.pipe( ops.group_by( key_mapper=lambda x: x % 2, element_mapper=None, subject_mapper=lambda: rx.subject.ReplaySubject(2), ) ) return source.subscribe(observer_groups, scheduler=scheduler) scheduler.schedule_absolute(290, subscription) scheduler.advance_to(500) # extract grouped observables from messages list groups = {m.value.value.key: m.value.value for m in observer_groups.messages if m.value.kind =='N'} def subscription_odd(scheduler, state): source = groups[1] return source.subscribe(observer_odd, scheduler=scheduler) def subscription_even(scheduler, state): source = groups[0] return source.subscribe(observer_even, scheduler=scheduler) scheduler.schedule_absolute(500, subscription_odd) scheduler.schedule_absolute(600, subscription_even) scheduler.advance_to(1100) # only the last 2 items of odd/even are received because the # ReplaySubject has been configured with a buffer size of 2 assert observer_odd.messages == [ on_next(500, 3), on_next(500, 5), on_completed(1000), ] assert observer_even.messages == [ on_next(600, 4), on_next(600, 6), on_completed(1000), ]
def test_paused_with_observable_controller_and_pause_and_unpause_after_end( self): 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(600, True)) def create(): return xs.pausable_buffered(controller) results = scheduler.start(create) assert results.messages == [ on_next(210, 2), on_next(230, 3), on_next(600, 4), on_next(600, 5), on_next(600, 6), on_next(600, 7), on_next(600, 8), on_completed(600) ]
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_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_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_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.map(mapper_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_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: #print("*** Dispose ****") d.dispose() return x d.disposable = xs.map(projection).subscribe(results) 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_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_never_basic(self): scheduler = TestScheduler() xs = Observable.never() results = scheduler.create_observer() xs.subscribe(results) scheduler.start() assert results.messages == []
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
class ConcurrentModification(unittest.TestCase): def setUp(self): self.ol = ObservableList([1, 2, 3, 4]) self.scheduler = TestScheduler() def test_try_making_multiple_ops_in_concurrent_futures(self): # Not sure if this is testing thread safety of the collection # arrange obs = self.scheduler.create_observer() self.ol.when_collection_changes() \ .map(lambda x: x.Items) \ .subscribe(obs) # act with ThreadPoolExecutor(max_workers=4) as executor: executor.submit(self.ol.append, 5) executor.submit(self.ol.remove, 4) executor.submit(self.ol.insert, 7, 0) executor.submit(self.ol.extend, [8, 9, 10]) # assert self.assertEqual(4, len(obs.messages)) def test_observableList_with_stress_append(self): # Write similar test cases to stress test the collections performance. setup = '''from reactive.ObservableList import ObservableList from random import randrange ol = ObservableList()''' cmd = 'ol.append(randrange(0, 2000))' result = timeit(cmd, setup=setup, number=20000) self.assertIsNotNone(result)
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) 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_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_paused_with_observable_controller_and_pause_and_unpause_after_error( self): error = Exception() 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_error(500, error)) controller = scheduler.create_hot_observable(on_next(201, True), on_next(300, False), on_next(600, True)) def create(): return xs.pausable_buffered(controller) results = scheduler.start(create=create) results.messages.assert_equal(on_next(210, 2), on_next(230, 3), on_next(600, 4), on_next(600, 5), on_next(600, 6), on_next(600, 7), on_next(600, 8), on_error(600, error))
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_select_disposeinsideselector(): 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): nonlocal invoked invoked += 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 == 3
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_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_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.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(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_error(390, ex)] 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_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(buffer_size=3, scheduler=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) 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 action(scheduler, state): connection[0].dispose() scheduler.schedule_absolute(800, action) 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_completed(600) ] assert xs.subscriptions == [subscribe(300, 400), subscribe(500, 600)]
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_return_disposed_after_next(self): scheduler = TestScheduler() d = SerialDisposable() xs = rx.return_value(42) 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, scheduler=scheduler) return d.disposable scheduler.schedule_absolute(100, action) scheduler.start() assert results.messages == [on_next(100, 42)]
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_paused_with_observable_controller_and_pause_and_unpause_after_end(self): 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(600, True)) def create(): return xs.pausable_buffered(controller) results = scheduler.start(create) results.messages.assert_equal( on_next(210, 2), on_next(230, 3), on_next(600, 4), on_next(600, 5), on_next(600, 6), on_next(600, 7), on_next(600, 8), on_completed(600), )
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_replay_time_error(self): subscription = [None] connection = [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(window=75, 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(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, 7), on_next(520, 11), on_next(560, 20), on_error(600, ex) ] assert xs.subscriptions == [subscribe(300, 400), subscribe(500, 600)]
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_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_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() assert results.messages == [ 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_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_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_replay_count_basic(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(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.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(451, 5), on_next(452, 6), on_next(453, 7), on_next(521, 11)) xs.subscriptions.assert_equal(subscribe(300, 400), subscribe(500, 550), subscribe(650, 800))
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_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.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_replay_count_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.replay(None, 3, None, 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(475, 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(451, 5), on_next(452, 6), on_next(453, 7)) xs.subscriptions.assert_equal(subscribe(300, 400), subscribe(500, 550), subscribe(650, 800))
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() assert results1.messages == [ on_next(230, 3), on_next(301, 4), on_next(350, 5), on_next(399, 6), on_completed(500) ] assert results2.messages == [on_next(399, 6), on_completed(500)]
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() assert results.messages == [ 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_controlledobservable_simple(self): scheduler = TestScheduler() controlled = [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): controlled[0] = xs.controlled(scheduler=scheduler) scheduler.schedule_absolute(200, action1) def action2(scheduler, state=None): controlled[0].subscribe(results1) scheduler.schedule_absolute(300, action2) def action3(scheduler, state=None): controlled[0].request(2) scheduler.schedule_absolute(380, action3) def action4(scheduler, state=None): controlled[0].subscribe(results2) scheduler.schedule_absolute(400, action4) def action3(scheduler, state=None): controlled[0].request(1) scheduler.schedule_absolute(410, action3) scheduler.start() assert results1.messages == [ on_next(380, 4), on_next(380, 5), on_next(410, 6), on_completed(500) ] assert results2.messages == [on_next(410, 6), on_completed(500)]
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_multicast_hot_1(self): scheduler = TestScheduler() s = Subject() 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)) obv = scheduler.create_observer() d1 = [None] d2 = [None] c = [None] def action(scheduler, state): c[0] = xs.pipe(ops.multicast(s)) scheduler.schedule_absolute(50, action) def action0(scheduler, state): d1[0] = c[0].subscribe(obv, scheduler) scheduler.schedule_absolute(100, action0) def action1(scheduler, state): d2[0] = c[0].connect(scheduler) scheduler.schedule_absolute(200, action1) def action2(scheduler, state): d1[0].dispose() scheduler.schedule_absolute(300, action2) scheduler.start() assert obv.messages == [ on_next(210, 3), on_next(240, 4), on_next(270, 5)] assert xs.subscriptions == [subscribe(200, 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.where(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_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.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_completed(390)) xs.subscriptions.assert_equal(subscribe(100, 300), subscribe(335, 390))
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.pipe(ops.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_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_replay_time_error(self): subscription = [None] connection = [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(None, None, 75, 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.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(451, 7), on_next(521, 11), on_next(561, 20), on_error(601, ex)) xs.subscriptions.assert_equal(subscribe(300, 400), subscribe(500, 600))
def test_paused_error(self): subscription = [None] err = Exception() scheduler = TestScheduler() controller = Subject() results = scheduler.create_observer() xs = scheduler.create_hot_observable(on_next(150, 1), on_next(210, 2), on_error(230, err), on_next(301, 4), on_next(350, 5), on_next(399, 6), on_completed(500)) def action0(scheduler, state): subscription[0] = xs.pausable(controller).subscribe(results) controller.on_next(True) scheduler.schedule_absolute(200, action0) def action1(scheduler, state): controller.on_next(False) scheduler.schedule_absolute(300, action1) def action2(scheduler, state): controller.on_next(True) scheduler.schedule_absolute(400, action2) def action3(scheduler, state): subscription[0].dispose() scheduler.schedule_absolute(1000, action3) scheduler.start() results.messages.assert_equal(on_next(210, 2), on_error(230, err))
def test_where_dispose_in_predicate(): 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): nonlocal ys def predicate(x): nonlocal invoked invoked += 1 if x == 8: d.dispose() return is_prime(x) ys = xs.where(predicate) return ys scheduler.schedule_absolute(created, action) def action1(scheduler, state): d.disposable = ys.subscribe(results) scheduler.schedule_absolute(subscribed, action1) def action2(scheduler, state): d.dispose() scheduler.schedule_absolute(disposed, action2) scheduler.start() results.messages.assert_equal(on_next(230, 3), on_next(340, 5), on_next(390, 7)) xs.subscriptions.assert_equal(subscribe(200, 450)) assert invoked == 6
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_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_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_canceled(): s = [None] subscription = [None] subscription1 = [None] subscription2 = [None] subscription3 = [None] scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_completed(630), on_next(640, 9), on_completed(650), on_error(660, 'ex') ) 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() assert results1.messages == [] assert results2.messages == [on_completed(630)] assert results3.messages == [on_completed(900)]
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): s[0] = Subject() scheduler.schedule_absolute(100, action) def action1(scheduler, state=None): subscription[0] = xs.subscribe(s[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] = s[0].subscribe(results1) scheduler.schedule_absolute(300, action3) def action4(scheduler, state=None): subscription2[0] = s[0].subscribe(results2) scheduler.schedule_absolute(400, action4) def action5(scheduler, state=None): subscription3[0] = s[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 == [on_next(340, 5), on_next(410, 6), on_next(520, 7)] assert results2.messages == [on_next(410, 6), on_next(520, 7), on_error(630, ex)] assert results3.messages == [on_error(900, ex)]
def test_infinite(): subscription = [None] subscription1 = [None] subscription2 = [None] subscription3 = [None] s = [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): 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() assert results1.messages == [ on_next(340, 5), on_next(410, 6), on_next(520, 7)] assert results2.messages == [ on_next(410, 6), on_next(520, 7), on_next(630, 8)] assert results3.messages == [ on_next(940, 11)]
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)]