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()
