def test_as_observable_isnoteager(self): scheduler = TestScheduler() subscribed = [False] def subscribe(obs, scheduler=None): subscribed[0] = True disp = scheduler.create_hot_observable( on_next(150, 1), on_next(220, 2), on_completed(250) ).subscribe(obs) def func(): return disp.dispose() return func xs = reactivex.create(subscribe) xs.pipe(ops.as_observable()) assert not subscribed[0] def create(): return xs.pipe(ops.as_observable()) scheduler.start(create) assert subscribed[0]
def _create(): def subscribe(o, scheduler=None): o.on_next(1) o.on_next(2) return lambda: None return reactivex.create(subscribe)
def test_retry_observable_retry_count_throws(self): scheduler1 = TestScheduler() xs = reactivex.return_value(1).pipe(ops.retry(3)) xs.subscribe(lambda x: _raise("ex"), scheduler=scheduler1) self.assertRaises(RxException, scheduler1.start) scheduler2 = TestScheduler() ys = reactivex.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 = reactivex.return_value(1).pipe(ops.retry(100)) zs.subscribe(on_completed=lambda: _raise("ex"), scheduler=scheduler3) with pytest.raises(RxException): scheduler3.start() xss = reactivex.create(lambda o: _raise("ex")).pipe(ops.retry(100)) with pytest.raises(Exception): xss.subscribe()
def test_concat_forward_none_scheduler(self): subscribe_schedulers = {"e1": "unknown", "e2": "unknown"} def subscribe_e1(observer, scheduler="not_set"): subscribe_schedulers["e1"] = scheduler observer.on_completed() def subscribe_e2(observer, scheduler="not_set"): subscribe_schedulers["e2"] = scheduler observer.on_completed() e1 = reactivex.create(subscribe_e1) e2 = reactivex.create(subscribe_e2) stream = e1.pipe(ops.concat(e2)) stream.subscribe() assert subscribe_schedulers["e1"] is None assert subscribe_schedulers["e2"] is None
def test_map_throws(self): mapper = map(lambda x: x) with self.assertRaises(RxException): return_value(1).pipe(mapper).subscribe(lambda x: _raise("ex")) with self.assertRaises(RxException): throw("ex").pipe(mapper).subscribe(on_error=lambda ex: _raise(ex)) with self.assertRaises(RxException): empty().pipe(mapper).subscribe( lambda x: x, lambda ex: ex, lambda: _raise("ex") ) def subscribe(observer, scheduler=None): _raise("ex") with self.assertRaises(RxException): create(subscribe).pipe(map(lambda x: x)).subscribe()
def _create(): def subscribe(o, scheduler=None): o.on_error(ex) o.on_next(100) o.on_error("foo") o.on_completed() return lambda: None return reactivex.create(subscribe)
def test_join_op_forward_scheduler(self): scheduler = TestScheduler() subscribe_schedulers = { "x": "unknown", "y": "unknown", "duration_x": "unknown", "duration_y": "unknown", } def subscribe_x(observer, scheduler="not_set"): subscribe_schedulers["x"] = scheduler # need to push one element to trigger duration mapper observer.on_next("foo") def subscribe_y(observer, scheduler="not_set"): subscribe_schedulers["y"] = scheduler # need to push one element to trigger duration mapper observer.on_next("bar") def subscribe_duration_x(observer, scheduler="not_set"): subscribe_schedulers["duration_x"] = scheduler def subscribe_duration_y(observer, scheduler="not_set"): subscribe_schedulers["duration_y"] = scheduler xs = reactivex.create(subscribe_x) ys = reactivex.create(subscribe_y) duration_x = reactivex.create(subscribe_duration_x) duration_y = reactivex.create(subscribe_duration_y) def create(): return xs.pipe( ops.join( ys, lambda x: duration_x, lambda y: duration_y, ), ) results = scheduler.start(create=create) assert subscribe_schedulers["x"] is scheduler assert subscribe_schedulers["y"] is scheduler assert subscribe_schedulers["duration_x"] is scheduler assert subscribe_schedulers["duration_y"] is scheduler
def factory(scheduler): count[0] += 1 def create(obs, scheduler=None): def func(): disconnected[0] = True return func return reactivex.create(create)
def test_join_op_forward_scheduler_None(self): subscribe_schedulers = { "x": "unknown", "y": "unknown", "duration_x": "unknown", "duration_y": "unknown", } def subscribe_x(observer, scheduler="not_set"): subscribe_schedulers["x"] = scheduler # need to push one element to trigger duration mapper observer.on_next("foo") def subscribe_y(observer, scheduler="not_set"): subscribe_schedulers["y"] = scheduler # need to push one element to trigger duration mapper observer.on_next("bar") def subscribe_duration_x(observer, scheduler="not_set"): subscribe_schedulers["duration_x"] = scheduler def subscribe_duration_y(observer, scheduler="not_set"): subscribe_schedulers["duration_y"] = scheduler xs = reactivex.create(subscribe_x) ys = reactivex.create(subscribe_y) duration_x = reactivex.create(subscribe_duration_x) duration_y = reactivex.create(subscribe_duration_y) stream = xs.pipe( ops.join( ys, lambda x: duration_x, lambda y: duration_y, ), ) stream.subscribe() assert subscribe_schedulers["x"] is None assert subscribe_schedulers["y"] is None assert subscribe_schedulers["duration_x"] is None assert subscribe_schedulers["duration_y"] is None
def test_concat_forward_scheduler(self): scheduler = TestScheduler() subscribe_schedulers = {"e1": "unknown", "e2": "unknown"} def subscribe_e1(observer, scheduler="not_set"): subscribe_schedulers["e1"] = scheduler observer.on_completed() def subscribe_e2(observer, scheduler="not_set"): subscribe_schedulers["e2"] = scheduler observer.on_completed() e1 = reactivex.create(subscribe_e1) e2 = reactivex.create(subscribe_e2) stream = e1.pipe(ops.concat(e2)) stream.subscribe(scheduler=scheduler) scheduler.advance_to(1000) assert subscribe_schedulers["e1"] is scheduler assert subscribe_schedulers["e2"] is scheduler
def create(): def predicate(x): n[0] += 1 return n[0] < 100 def subscribe(o, scheduler=None): o.on_next(1) o.on_completed() return lambda: None return reactivex.create(subscribe).pipe(ops.while_do(predicate))
def test_connectable_observable_forward_scheduler(self): scheduler = TestScheduler() subscribe_scheduler = "unknown" def subscribe(observer, scheduler=None): nonlocal subscribe_scheduler subscribe_scheduler = scheduler xs = reactivex.create(subscribe) subject = MySubject() conn = ConnectableObservable(xs, subject) conn.connect(scheduler) assert subscribe_scheduler is scheduler
def test_observe_on_forward_subscribe_scheduler(self): scheduler = ImmediateScheduler() expected_subscribe_scheduler = ImmediateScheduler() actual_subscribe_scheduler = None def subscribe(observer, scheduler): nonlocal actual_subscribe_scheduler actual_subscribe_scheduler = scheduler observer.on_completed() xs = reactivex.create(subscribe) xs.pipe(ops.observe_on(scheduler)).subscribe( scheduler=expected_subscribe_scheduler) assert expected_subscribe_scheduler == actual_subscribe_scheduler
def test_map_with_index_throws(self): with self.assertRaises(RxException): mapper = map_indexed(lambda x, index: x) return return_value(1).pipe(mapper).subscribe(lambda x: _raise("ex")) with self.assertRaises(RxException): return ( throw("ex").pipe(mapper).subscribe(lambda x: x, lambda ex: _raise(ex)) ) with self.assertRaises(RxException): return ( empty() .pipe(mapper) .subscribe(lambda x: x, lambda ex: None, lambda: _raise("ex")) ) with self.assertRaises(RxException): return create(lambda o, s: _raise("ex")).pipe(mapper).subscribe()
def _create(): def subscribe(o, scheduler=None): is_stopped = [False] o.on_next(1) o.on_next(2) def action1(scheduler, state): if not is_stopped[0]: return o.on_next(3) scheduler.schedule_relative(600, action1) def action2(scheduler, state): if not is_stopped[0]: return o.on_next(4) scheduler.schedule_relative(700, action2) def action3(scheduler, state): if not is_stopped[0]: return o.on_next(5) scheduler.schedule_relative(900, action3) def action4(scheduler, state): if not is_stopped[0]: return o.on_next(6) scheduler.schedule_relative(1100, action4) def dispose(): is_stopped[0] = True return dispose return reactivex.create(subscribe)
def test_create_observer_throws(self): def subscribe(o, scheduler=None): o.on_next(1) return lambda: None with self.assertRaises(RxException): reactivex.create(subscribe).subscribe(lambda x: _raise("ex")) def subscribe2(o, scheduler=None): o.on_error("exception") return lambda: None with self.assertRaises(RxException): reactivex.create(subscribe2).subscribe( on_error=lambda ex: _raise("ex")) def subscribe3(o, scheduler=None): o.on_completed() return lambda: None with self.assertRaises(RxException): reactivex.create(subscribe3).subscribe( on_completed=lambda: _raise("ex"))
def test_create_exception(self): with self.assertRaises(RxException): reactivex.create(lambda o, s: _raise("ex")).subscribe()