def test_using_null(self):
disp = [None]
xs = [None]
_d = [None]
scheduler = TestScheduler()
dispose_invoked = [0]
create_invoked = [0]
def create():
def create_resources():
dispose_invoked[0] += 1
disp[0] = None
return disp[0]
def create_observable(d):
_d[0] = d
create_invoked[0] += 1
xs[0] = scheduler.create_cold_observable(
on_next(100, scheduler.clock), on_completed(200))
return xs[0]
return rx.using(create_resources, create_observable)
results = scheduler.start(create)
assert (disp[0] == _d[0])
assert results.messages == [on_next(300, 200), on_completed(400)]
assert (1 == create_invoked[0])
assert (1 == dispose_invoked[0])
assert xs[0].subscriptions == [subscribe(200, 400)]
assert (disp[0] is None)
def test_timeout_duration_simple_never(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(310, 1),
on_next(350, 2),
on_next(420, 3),
on_completed(450)
)
ys = scheduler.create_cold_observable()
def create():
return xs.timeout_with_selector(ys, lambda _: ys)
results = scheduler.start(create)
results.messages.assert_equal(
on_next(310, 1),
on_next(350, 2),
on_next(420, 3),
on_completed(450)
)
xs.subscriptions.assert_equal(
subscribe(200, 450)
)
ys.subscriptions.assert_equal(
subscribe(200, 310),
subscribe(310, 350),
subscribe(350, 420),
subscribe(420, 450)
)
def test_min_by_comparer_never(self):
scheduler = TestScheduler()
msgs = [
on_next(150, {
"key": 1,
"value": 'z'
})
]
def reverse_comparer(a, b):
if a > b:
return -1
if a == b:
return 0
return 1
xs = scheduler.create_hot_observable(msgs)
def create():
return xs.pipe(ops.min_by(lambda x: x["key"], reverse_comparer))
res = scheduler.start(create=create).messages
assert res == []
def test_retry_observable_infinite(self):
scheduler = TestScheduler()
xs = scheduler.create_cold_observable(on_next(100, 1), on_next(150, 2), on_next(200, 3))
results = scheduler.start(lambda: xs.retry())
results.messages.assert_equal(on_next(300, 1), on_next(350, 2), on_next(400, 3))
return xs.subscriptions.assert_equal(subscribe(200, 1000))
def test_min_by_comparer_return(self):
scheduler = TestScheduler()
msgs = [
on_next(150, {
"key": 1,
"value": 'z'
}), on_next(210, {
"key": 2,
"value": 'a'
}), on_completed(250)
]
def reverse_comparer(a, b):
if a > b:
return -1
if a == b:
return 0
return 1
xs = scheduler.create_hot_observable(msgs)
def create():
return xs.pipe(ops.min_by(lambda x: x["key"], reverse_comparer))
res = scheduler.start(create=create).messages
self.assertEqual(2, len(res))
assert(res[0].value.kind == 'N')
self.assertEqual(1, len(res[0].value.value))
self.assertEqual(2, res[0].value.value[0]["key"])
self.assertEqual('a', res[0].value.value[0]["value"])
assert(res[1].value.kind == 'C' and res[1].time == 250)
def test_using_error(self):
scheduler = TestScheduler()
dispose_invoked = [0]
create_invoked = [0]
ex = 'ex'
disp = [None]
xs = [None]
_d = [None]
def create():
def create_resource():
dispose_invoked[0] += 1
disp[0] = MockDisposable(scheduler)
return disp[0]
def create_observable(d):
_d[0] = d
create_invoked[0] += 1
xs[0] = scheduler.create_cold_observable(
on_next(100, scheduler.clock), on_error(200, ex))
return xs[0]
return rx.using(create_resource, create_observable)
results = scheduler.start(create)
assert disp[0] == _d[0]
assert results.messages == [on_next(300, 200), on_error(400, ex)]
assert create_invoked[0] == 1
assert dispose_invoked[0] == 1
assert xs[0].subscriptions == [subscribe(200, 400)]
assert disp[0].disposes == [200, 400]
def test_catch_throw_from_nested_catch(self):
ex = 'ex'
ex2 = 'ex'
first_handler_called = [False]
second_handler_called = [False]
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_next(210, 2), on_error(215, ex)]
msgs2 = [on_next(220, 3), on_error(225, ex2)]
msgs3 = [on_next(230, 4), on_completed(235)]
o1 = scheduler.create_hot_observable(msgs1)
o2 = scheduler.create_hot_observable(msgs2)
o3 = scheduler.create_hot_observable(msgs3)
def create():
def handler1(e):
first_handler_called[0] = True
assert(e == ex)
return o2
def handler2(e):
second_handler_called[0] = True
assert(e == ex2)
return o3
return o1.catch_exception(handler1).catch_exception(handler2)
results = scheduler.start(create)
results.messages.assert_equal(on_next(210, 2), on_next(220, 3), on_next(230, 4), on_completed(235))
assert(first_handler_called[0])
assert(second_handler_called[0])
def test_throw_disposed(self):
scheduler = TestScheduler()
def factory():
return Observable.throw_exception('ex', scheduler)
results = scheduler.start(factory, disposed=200)
results.messages.assert_equal()
def test_retry_observable_basic(self):
scheduler = TestScheduler()
xs = scheduler.create_cold_observable(on_next(100, 1), on_next(150, 2), on_next(200, 3), on_completed(250))
results = scheduler.start(lambda: xs.retry())
results.messages.assert_equal(on_next(300, 1), on_next(350, 2), on_next(400, 3), on_completed(450))
xs.subscriptions.assert_equal(subscribe(200, 450))
def test_to_dict_error(self):
scheduler = TestScheduler()
ex = Exception()
xs = scheduler.create_hot_observable(
on_next(110, 1),
on_next(220, 2),
on_next(330, 3),
on_next(440, 4),
on_next(550, 5),
on_error(660, ex)
)
def create():
return xs.to_dict(lambda x: x * 2, lambda x: x * 4)
res = scheduler.start(create)
res.messages.assert_equal(
on_error(660, ex)
)
xs.subscriptions.assert_equal(
subscribe(200, 660)
)
def test_to_dict_keyselectorthrows(self):
scheduler = TestScheduler()
ex = Exception()
xs = scheduler.create_hot_observable(
on_next(110, 1),
on_next(220, 2),
on_next(330, 3),
on_next(440, 4),
on_next(550, 5),
on_completed(600)
)
def create():
def key_selector(x):
if x < 4:
return x * 2
else:
raise ex
return xs.to_dict(key_selector, lambda x: x * 4)
res = scheduler.start(create)
res.messages.assert_equal(
on_error(440, ex)
)
xs.subscriptions.assert_equal(
subscribe(200, 440)
)
def test_retry_observable_retry_count_dispose(self):
scheduler = TestScheduler()
ex = 'ex'
xs = scheduler.create_cold_observable(on_next(5, 1), on_next(10, 2), on_next(15, 3), on_error(20, ex))
results = scheduler.start(lambda: xs.retry(3), disposed=231)
results.messages.assert_equal(on_next(205, 1), on_next(210, 2), on_next(215, 3), on_next(225, 1), on_next(230, 2))
xs.subscriptions.assert_equal(subscribe(200, 220), subscribe(220, 231))
def test_to_dict_completed(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(110, 1),
on_next(220, 2),
on_next(330, 3),
on_next(440, 4),
on_next(550, 5),
on_completed(660)
)
def create():
return xs.to_dict(lambda x: x * 2, lambda x: x * 4)
res = scheduler.start(create)
print(res.messages)
res.messages.assert_equal(
on_next(660, {4: 8, 6: 12, 8: 16, 10: 20}),
on_completed(660)
)
xs.subscriptions.assert_equal(
subscribe(200, 660)
)
def test_pairwise_error(self):
error = Exception()
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(180, 5),
on_next(210, 4),
on_next(240, 3),
on_error(290, error),
on_next(350, 1),
on_completed(360)
)
def create():
return xs.pairwise()
results = scheduler.start(create)
results.messages.assert_equal(
on_next(240, (4,3)),
on_error(290, error)
)
xs.subscriptions.assert_equal(
subscribe(200, 290)
)
def test_pairwise_not_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)
)
def create():
return xs.pairwise()
results = scheduler.start(create)
results.messages.assert_equal(
on_next(240, (4,3)),
on_next(290, (3, 2)),
on_next(350, (2, 1))
)
xs.subscriptions.assert_equal(
subscribe(200, 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)
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_pluck_attr_completed(self):
scheduler = TestScheduler()
class DummyClass:
def __init__(self, prop):
self.prop = prop
xs = scheduler.create_hot_observable(
on_next(180, DummyClass(1)),
on_next(210, DummyClass(2)),
on_next(240, DummyClass(3)),
on_next(290, DummyClass(4)),
on_next(350, DummyClass(5)),
on_completed(400),
on_next(410, DummyClass(-1)),
on_completed(420),
on_error(430, Exception('ex'))
)
results = scheduler.start(create=lambda: xs.pipe(ops.pluck_attr('prop')))
assert results.messages == [
on_next(210, 2),
on_next(240, 3),
on_next(290, 4),
on_next(350, 5),
on_completed(400)]
assert xs.subscriptions == [subscribe(200, 400)]
def test_ignore_values_completed(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(180, 1), on_next(210, 2), on_next(250, 3), on_next(270, 4), on_next(310, 5), on_next(360, 6), on_next(380, 7), on_next(410, 8), on_next(590, 9), on_completed(610))
results = scheduler.start(create=lambda: xs.ignore_elements())
results.messages.assert_equal(on_completed(610))
xs.subscriptions.assert_equal(subscribe(200, 610))
def test_catch_nested_outer_catches(self):
ex = 'ex'
first_handler_called = [False]
second_handler_called = [False]
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_next(210, 2), on_error(215, ex)]
msgs2 = [on_next(220, 3), on_completed(225)]
msgs3 = [on_next(220, 4), on_completed(225)]
o1 = scheduler.create_hot_observable(msgs1)
o2 = scheduler.create_hot_observable(msgs2)
o3 = scheduler.create_hot_observable(msgs3)
def create():
def handler1(e, source):
first_handler_called[0] = True
return o2
def handler2(e, source):
second_handler_called[0] = True
return o3
return o1.pipe(ops.catch(handler1), ops.catch(handler2))
results = scheduler.start(create)
assert results.messages == [on_next(210, 2), on_next(220, 3), on_completed(225)]
assert first_handler_called[0]
assert not second_handler_called[0]
def test_timeout_duration_simple_timeoutbycompletion(self):
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(310, 1), on_next(350, 2), on_next(420, 3), on_completed(450))
ys = scheduler.create_cold_observable()
zs = scheduler.create_cold_observable()
def create():
def selector(x):
if x < 3:
return zs
else:
raise Exception(ex)
return xs.timeout_with_selector(ys, selector)
results = scheduler.start(create)
results.messages.assert_equal(
on_next(310, 1),
on_next(350, 2),
on_next(420, 3),
on_error(420, ex)
)
xs.subscriptions.assert_equal(subscribe(200, 420))
ys.subscriptions.assert_equal(subscribe(200, 310))
zs.subscriptions.assert_equal(subscribe(310, 350), subscribe(350, 420))
def test_create_with_disposable_dispose(self):
scheduler = TestScheduler()
def create():
def subscribe(o):
d = BooleanDisposable()
o.on_next(1)
o.on_next(2)
def action1(scheduler, state):
if not d.is_disposed:
o.on_next(3)
scheduler.schedule_relative(600, action1)
def action2(scheduler, state):
if not d.is_disposed:
o.on_next(4)
scheduler.schedule_relative(700, action2)
def action3(scheduler, state):
if not d.is_disposed:
o.on_next(5)
scheduler.schedule_relative(900, action3)
def action4(scheduler, state):
if not d.is_disposed:
o.on_next(6)
scheduler.schedule_relative(1100, action4)
return d
return Observable.create_with_disposable(subscribe)
results = scheduler.start(create)
results.messages.assert_equal(on_next(200, 1), on_next(200, 2), on_next(800, 3), on_next(900, 4))
def test_throttle_first_no_end(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(150, 1),
on_next(210, 2),
on_next(250, 3),
on_next(310, 4),
on_next(350, 5),
on_next(410, 6),
on_next(450, 7)
)
def create():
return xs.throttle_first(200, scheduler)
results = scheduler.start(create=create)
results.messages.assert_equal(
on_next(210, 2),
on_next(410, 6)
)
xs.subscriptions.assert_equal(
subscribe(200, 1000)
)
def test_throttle_first_error(self):
error = RxException()
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(150, 1),
on_next(210, 2),
on_next(250, 3),
on_next(310, 4),
on_next(350, 5),
on_error(410, error),
on_next(450, 7),
on_completed(500)
)
def create():
return xs.throttle_first(200, scheduler)
results = scheduler.start(create=create)
results.messages.assert_equal(
on_next(210, 2),
on_error(410, error)
)
xs.subscriptions.assert_equal(
subscribe(200, 410)
)
def test_interval_timespan_observer_throws(self):
scheduler = TestScheduler()
xs = Observable.interval(1, scheduler=scheduler)
xs.subscribe(lambda x: _raise("ex"))
with self.assertRaises(RxException):
scheduler.start()
def test_many_select_error(self):
scheduler = TestScheduler()
ex = Exception()
xs = scheduler.create_hot_observable(
on_next(100, 1),
on_next(220, 2),
on_next(270, 3),
on_next(410, 4),
on_error(500, ex)
)
def create():
return xs.many_select(lambda ys: ys.first(), scheduler).merge_all()
res = scheduler.start(create)
res.messages.assert_equal(
on_next(221, 2),
on_next(271, 3),
on_next(411, 4),
on_error(501, ex)
)
xs.subscriptions.assert_equal(
subscribe(200, 500)
)
def test_retry_observable_error(self):
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_cold_observable(on_next(100, 1), on_next(150, 2), on_next(200, 3), on_error(250, ex))
results = scheduler.start(lambda: xs.retry(), disposed=1100)
results.messages.assert_equal(on_next(300, 1), on_next(350, 2), on_next(400, 3), on_next(550, 1), on_next(600, 2), on_next(650, 3), on_next(800, 1), on_next(850, 2), on_next(900, 3), on_next(1050, 1))
return xs.subscriptions.assert_equal(subscribe(200, 450), subscribe(450, 700), subscribe(700, 950), subscribe(950, 1100))
def test_maxby_comparerthrows(self):
ex = 'ex'
scheduler = TestScheduler()
msgs = [
on_next(150, {
"key": 1,
"value": 'z'
}), on_next(210, {
"key": 3,
"value": 'b'
}), on_next(220, {
"key": 2,
"value": 'c'
}), on_next(230, {
"key": 4,
"value": 'a'
}), on_completed(250)
]
def reverse_comparer(a, b):
raise Exception(ex)
xs = scheduler.create_hot_observable(msgs)
def create():
return xs.max_by(lambda x: x["key"], reverse_comparer)
res = scheduler.start(create=create).messages
res.assert_equal(on_error(220, ex))
def test_min_by_comparer_throws(self):
ex = 'ex'
scheduler = TestScheduler()
msgs = [
on_next(150, {
"key": 1,
"value": 'z'
}), on_next(210, {
"key": 3,
"value": 'b'
}), on_next(220, {
"key": 2,
"value": 'c'
}), on_next(230, {
"key": 4,
"value": 'a'
}), on_completed(250)
]
def reverse_comparer(a, b):
_raise(ex)
xs = scheduler.create_hot_observable(msgs)
def create():
return xs.pipe(ops.min_by(lambda x: x["key"], reverse_comparer))
res = scheduler.start(create=create).messages
assert res == [on_error(220, ex)]
def test_min_by_some(self):
scheduler = TestScheduler()
msgs = [
on_next(150, {
"key": 1,
"value": 'z'
}), on_next(210, {
"key": 3,
"value": 'b'
}), on_next(220, {
"key": 2,
"value": 'c'
}), on_next(230, {
"key": 4,
"value": 'a'
}), on_completed(250)
]
xs = scheduler.create_hot_observable(msgs)
def create():
return xs.pipe(ops.min_by(lambda x: x["key"]))
res = scheduler.start(create=create).messages
self.assertEqual(2, len(res))
assert(res[0].value.kind == 'N')
self.assertEqual(1, len(res[0].value.value))
self.assertEqual(2, res[0].value.value[0]["key"])
self.assertEqual('c', res[0].value.value[0]["value"])
assert(res[1].value.kind == 'C' and res[1].time == 250)
def test_interval_timespan_negative(self):
scheduler = TestScheduler()
def create():
return Observable.interval(-1, scheduler=scheduler)
results = scheduler.start(create, disposed=210)
results.messages.assert_equal(on_next(201, 0), on_next(202, 1), on_next(203, 2), on_next(204, 3), on_next(205, 4), on_next(206, 5), on_next(207, 6), on_next(208, 7), on_next(209, 8))
def test_expand_basic(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(550, 1), on_next(850, 2),
on_completed(950))
def create():
def selector(x):
return scheduler.create_cold_observable(
on_next(100, 2 * x), on_next(200, 3 * x),
on_completed(300))
return xs.expand(selector, scheduler)
results = scheduler.start(create)
results.messages.assert_equal(on_next(550, 1), on_next(651, 2),
on_next(751, 3), on_next(752, 4),
on_next(850, 2), on_next(852, 6),
on_next(852, 6), on_next(853, 8),
on_next(951, 4), on_next(952, 9),
on_next(952, 12), on_next(953, 12),
on_next(953, 12), on_next(954, 16))
xs.subscriptions.assert_equal(subscribe(201, 950))
def test_filter_indexed_false(self):
scheduler = TestScheduler()
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))
def create():
def predicate(x, index):
invoked[0] += 1
return False
return xs.pipe(filter_indexed(predicate))
results = scheduler.start(create)
assert results.messages == [on_completed(600)]
assert xs.subscriptions == [subscribe(200, 600)]
assert (invoked[0] == 9)
def test_buffer_with_count_disposed(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(100, 1),
on_next(210, 2),
on_next(240, 3),
on_next(280, 4),
on_next(320, 5),
on_next(350, 6),
on_next(380, 7),
on_next(420, 8),
on_next(470, 9),
on_completed(600))
def create():
return xs.buffer_with_count(3, 2).map(lambda x: str(x))
results = scheduler.start(create, disposed=370)
assert results.messages == [
on_next(280, str([2, 3, 4])),
on_next(350, str([4, 5, 6]))]
assert xs.subscriptions == [subscribe(200, 370)]
def test_select_many_then_error_complete(self):
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_cold_observable(on_next(100, 4), on_next(200, 2),
on_next(300, 3), on_next(400, 1),
on_error(500, ex))
ys = scheduler.create_cold_observable(on_next(50, "foo"),
on_next(100, "bar"),
on_next(150, "baz"),
on_next(200, "qux"),
on_completed(250))
results = scheduler.start(lambda: xs.select_many(ys))
results.messages.assert_equal(on_next(350, "foo"), on_next(400, "bar"),
on_next(450, "baz"), on_next(450, "foo"),
on_next(500, "qux"), on_next(500, "bar"),
on_next(550, "baz"), on_next(550, "foo"),
on_next(600, "qux"), on_next(600, "bar"),
on_next(650, "baz"), on_next(650, "foo"),
on_error(700, ex))
xs.subscriptions.assert_equal(subscribe(200, 700))
ys.subscriptions.assert_equal(subscribe(300, 550), subscribe(400, 650),
subscribe(500, 700), subscribe(600, 700))
def test_select_many_use_function(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(210, 4), on_next(220, 3),
on_next(250, 5), on_next(270, 1),
on_completed(290))
def factory():
def projection(x):
return Observable.interval(
10, scheduler).map(lambda a, b: x).take(x)
return xs.select_many(projection)
results = scheduler.start(factory)
results.messages.assert_equal(on_next(220, 4), on_next(230, 3),
on_next(230, 4), on_next(240, 3),
on_next(240, 4), on_next(250, 3),
on_next(250, 4), on_next(260, 5),
on_next(270, 5), on_next(280, 1),
on_next(280, 5), on_next(290, 5),
on_next(300, 5), on_completed(300))
xs.subscriptions.assert_equal(subscribe(200, 290))
def test_delay_duration_simple1(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(150, 1), on_next(210, 10),
on_next(220,
30), on_next(230, 50),
on_next(240,
35), on_next(250, 20),
on_completed(260))
def create():
def selector(x):
return scheduler.create_cold_observable(on_next(x, '!'))
return xs.delay_with_selector(selector)
results = scheduler.start(create)
results.messages.assert_equal(on_next(210 + 10, 10),
on_next(220 + 30, 30),
on_next(250 + 20, 20),
on_next(240 + 35, 35),
on_next(230 + 50, 50), on_completed(280))
xs.subscriptions.assert_equal(subscribe(200, 260))
def test_min_by_comparer_throw(self):
ex = 'ex'
scheduler = TestScheduler()
msgs = [
on_next(150, {
"key": 1,
"value": 'z'
}), on_error(210, ex)
]
def reverse_comparer(a, b):
if a > b:
return -1
if a == b:
return 0
return 1
def create():
return xs.min_by(lambda x: x["key"], reverse_comparer)
xs = scheduler.create_hot_observable(msgs)
res = scheduler.start(create=create).messages
res.assert_equal(on_error(210, ex))
def test_buffer_with_time_basic_same(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(100, 1), on_next(210, 2),
on_next(240, 3), on_next(280, 4),
on_next(320, 5), on_next(350, 6),
on_next(380, 7), on_next(420, 8),
on_next(470, 9),
on_completed(600))
def create():
return xs.pipe(ops.buffer_with_time(100),
ops.map(lambda x: ",".join([str(a) for a in x])))
results = scheduler.start(create)
assert results.messages == [
on_next(300, "2,3,4"),
on_next(400, "5,6,7"),
on_next(500, "8,9"),
on_next(600, ""),
on_completed(600)
]
assert xs.subscriptions == [subscribe(200, 600)]
def test_catch_error(self):
ex = 'ex'
scheduler = TestScheduler()
msgs1 = [
on_next(150, 1),
on_next(210, 2),
on_next(220, 3),
on_error(230, ex)
]
msgs2 = [on_next(240, 5), on_completed(250)]
o1 = scheduler.create_hot_observable(msgs1)
o2 = scheduler.create_hot_observable(msgs2)
def create():
return o1.catch_exception(o2)
results = scheduler.start(create)
assert results.messages == [
on_next(210, 2),
on_next(220, 3),
on_next(240, 5),
on_completed(250)
]
def test_min_of_t_comparer_empty_ii(self):
scheduler = TestScheduler()
def comparer(a, b):
if a > b:
return -1
if a == b:
return 0
return 1
xs = scheduler.create_hot_observable(on_next(150, 'z'),
on_next(210, "b"),
on_next(220, "c"),
on_next(230, "a"),
on_completed(250))
def create():
return xs.pipe(ops.min(comparer))
res = scheduler.start(create=create).messages
assert res == [on_next(250, "c"), on_completed(250)]
def test_combine_latest_consecutive_end_with_error_left(self):
ex = 'ex'
scheduler = TestScheduler()
msgs1 = [
on_next(150, 1),
on_next(215, 2),
on_next(225, 4),
on_error(230, ex)
]
msgs2 = [
on_next(150, 1),
on_next(235, 6),
on_next(240, 7),
on_completed(250)
]
e1 = scheduler.create_hot_observable(msgs1)
e2 = scheduler.create_hot_observable(msgs2)
def create():
return e1.combine_latest(e2, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal(on_error(230, ex))
def test_take_while_zero():
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(90, -1), on_next(110, -1),
on_next(205, 100), on_next(210, 2),
on_next(260, 5), on_next(290, 13),
on_next(320, 3), on_next(350, 7),
on_next(390, 4), on_next(410, 17),
on_next(450, 8), on_next(500, 23),
on_completed(600))
invoked = 0
def create():
def predicate(x):
nonlocal invoked
invoked += 1
return is_prime(x)
return xs.take_while(predicate)
results = scheduler.start(create, disposed=300)
results.messages.assert_equal(on_completed(205))
xs.subscriptions.assert_equal(subscribe(200, 205))
assert (invoked == 1)
def test_WhenMultipleDataAsymmetric(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(210, 1), on_next(220, 2),
on_next(230, 3),
on_completed(240))
ys = scheduler.create_hot_observable(on_next(240, 4), on_next(250, 5),
on_completed(270))
def create():
def mapper(x, y):
return x + y
return Observable.when(xs.and_(ys).then_do(mapper))
results = scheduler.start(create)
assert results.messages == [
on_next(240, 1 + 4),
on_next(250, 2 + 5),
on_completed(270)
]
def test_max_of_t_comparer_empty(self):
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_completed(250)]
def reverse_comparer(a, b):
if a > b:
return -1
if a < b:
return 1
return 0
xs = scheduler.create_hot_observable(msgs)
def create():
return xs.pipe(ops.max(reverse_comparer))
res = scheduler.start(create=create).messages
self.assertEqual(1, len(res))
assert (res[0].value.kind == 'E'
and res[0].value.exception is not None)
assert (res[0].time == 250)
def test_min_of_t_comparer_empty(self):
scheduler = TestScheduler()
def comparer(a, b):
if a > b:
return -1
if a == b:
return 0
return 1
xs = scheduler.create_hot_observable(on_next(150, 'a'),
on_completed(250))
def create():
return xs.pipe(ops.min(comparer))
res = scheduler.start(create=create).messages
self.assertEqual(1, len(res))
assert (res[0].value.kind == 'E'
and res[0].value.exception is not None)
assert (res[0].time == 250)
def test_case_with_default_throw(self):
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(210, 1), on_next(240, 2),
on_next(270, 3),
on_completed(300))
ys = scheduler.create_hot_observable(on_next(220,
11), on_next(250, 12),
on_next(280, 13),
on_completed(310))
map = {1: xs, 2: ys}
def create():
def selector():
raise Exception(ex)
return Observable.switch_case(selector, map, scheduler=scheduler)
results = scheduler.start(create)
results.messages.assert_equal(on_error(200, ex))
xs.subscriptions.assert_equal()
ys.subscriptions.assert_equal()
def test_skip_while_dispose_before(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(90, -1), on_next(110, -1),
on_next(210, 2), on_next(260, 5),
on_next(290, 13), on_next(320, 3),
on_next(350, 7), on_next(390, 4),
on_next(410, 17), on_next(450, 8),
on_next(500, 23),
on_completed(600))
invoked = [0]
def create():
def predicate(x):
invoked[0] += 1
return is_prime(x)
return xs.skip_while(predicate)
results = scheduler.start(create, disposed=300)
results.messages.assert_equal()
xs.subscriptions.assert_equal(subscribe(200, 300))
assert (invoked[0] == 3)
def test_group_by_with_key_comparer():
scheduler = TestScheduler()
key_invoked = 0
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'))
def factory():
def key_selector(x):
nonlocal key_invoked
key_invoked += 1
return x.lower().strip()
return xs.group_by(key_selector, lambda x: x).select(lambda g: g.key)
results = scheduler.start(factory)
results.messages.assert_equal(on_next(220, "foo"), on_next(270, "bar"),
on_next(350, "baz"), on_next(360, "qux"),
on_completed(570))
xs.subscriptions.assert_equal(subscribe(200, 570))
assert (key_invoked == 12)
def test_min_by_comparer_some(self):
scheduler = TestScheduler()
msgs = [
on_next(150, {
"key": 1,
"value": 'z'
}), on_next(210, {
"key": 3,
"value": 'b'
}), on_next(220, {
"key": 20,
"value": 'c'
}), on_next(230, {
"key": 4,
"value": 'a'
}), on_completed(250)
]
def reverse_comparer(a, b):
if a > b:
return -1
if a == b:
return 0
return 1
xs = scheduler.create_hot_observable(msgs)
def create():
return xs.min_by(lambda x: x["key"], reverse_comparer)
res = scheduler.start(create=create).messages
self.assertEqual(2, len(res))
assert(res[0].value.kind == 'N')
self.assertEqual(1, len(res[0].value.value))
self.assertEqual(20, res[0].value.value[0]["key"])
self.assertEqual('c', res[0].value.value[0]["value"])
assert(res[1].value.kind == 'C' and res[1].time == 250)
def test_merge_lots3(self):
scheduler = TestScheduler()
msgs1 = [
on_next(150, 1),
on_next(210, 2),
on_next(225, 5),
on_next(240, 8),
on_completed(245)
]
msgs2 = [
on_next(150, 1),
on_next(215, 3),
on_next(230, 6),
on_next(245, 9),
on_completed(250)
]
msgs3 = [
on_next(150, 1),
on_next(220, 4),
on_next(235, 7),
on_completed(240)
]
o1 = scheduler.create_hot_observable(msgs1)
o2 = scheduler.create_hot_observable(msgs2)
o3 = scheduler.create_hot_observable(msgs3)
def create():
return rx.merge(o1, o2, o3)
results = scheduler.start(create).messages
assert (len(results) == 9)
for i, result in enumerate(results[:-1]):
assert (results[i].value.kind == 'N'
and results[i].time == 210 + i * 5
and results[i].value.value == i + 2)
assert (results[8].value.kind == 'C' and results[8].time == 250)
def test_zip_some_data_asymmetric2(self):
scheduler = TestScheduler()
def msgs1_factory():
results = []
for i in range(10):
results.append(on_next(205 + i * 5, i))
return results
msgs1 = msgs1_factory()
def msgs2_factory():
results = []
for i in range(5):
results.append(on_next(205 + i * 8, i))
return results
msgs2 = msgs2_factory()
length = min(len(msgs1), len(msgs2))
e1 = scheduler.create_hot_observable(msgs1)
e2 = scheduler.create_hot_observable(msgs2)
def create():
return e1.pipe(
ops.zip(e2),
ops.map(sum))
results = scheduler.start(create).messages
assert (length == len(results))
for i in range(length):
_sum = msgs1[i].value.value + msgs2[i].value.value
time = max(msgs1[i].time, msgs2[i].time)
assert (results[i].value.kind == 'N'
and results[i].time == time
and results[i].value.value == _sum)
def test_publish_lambda_zip_complete(self):
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))
def create():
def mapper(_xs):
return _xs.pipe(
ops.zip(_xs.pipe(ops.skip(1))),
ops.map(sum),
)
return xs.pipe(ops.publish(mapper))
results = scheduler.start(create)
assert results.messages == [
on_next(280, 7),
on_next(290, 5),
on_next(340, 9),
on_next(360, 13),
on_next(370, 11),
on_next(390, 13),
on_next(410, 20),
on_next(430, 15),
on_next(450, 11),
on_next(520, 20),
on_next(560, 31),
on_completed(600)
]
assert xs.subscriptions == [subscribe(200, 600)]
def test_flat_map_iterable_complete(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(210, 2),
on_next(340, 4),
on_next(420, 3),
on_next(510, 2),
on_completed(600)
)
inners = []
def create():
def mapper(x):
ys = [x] * x
inners.append(ys)
return ys
return xs.flat_map(mapper)
res = scheduler.start(create)
assert res.messages == [
on_next(210, 2),
on_next(210, 2),
on_next(340, 4),
on_next(340, 4),
on_next(340, 4),
on_next(340, 4),
on_next(420, 3),
on_next(420, 3),
on_next(420, 3),
on_next(510, 2),
on_next(510, 2),
on_completed(600)]
assert xs.subscriptions == [
subscribe(200, 600)]
assert(4 == len(inners))
def test_debounce_duration_early_completion(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(150, -1),
on_next(250, 0),
on_next(280, 1),
on_next(310, 2),
on_next(350, 3),
on_next(400, 4),
on_completed(410))
ys = [
scheduler.create_cold_observable(
on_next(20, 42),
on_next(25, 99)),
scheduler.create_cold_observable(
on_next(40, 42),
on_next(45, 99)),
scheduler.create_cold_observable(
on_next(20, 42),
on_next(25, 99)),
scheduler.create_cold_observable(
on_next(60, 42),
on_next(65, 99)),
scheduler.create_cold_observable(
on_next(20, 42),
on_next(25, 99))
]
def create():
def mapper(x):
return ys[x]
return xs.pipe(_.throttle_with_mapper(mapper))
results = scheduler.start(create)
assert results.messages == [on_next(250 + 20, 0), on_next(310 + 20, 2), on_next(410, 4), on_completed(410)]
assert xs.subscriptions == [subscribe(200, 410)]
assert ys[0].subscriptions == [subscribe(250, 250 + 20)]
assert ys[1].subscriptions == [subscribe(280, 310)]
assert ys[2].subscriptions == [subscribe(310, 310 + 20)]
assert ys[3].subscriptions == [subscribe(350, 400)]
assert ys[4].subscriptions == [subscribe(400, 410)]
def test_group_join_op_error_i(self):
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(210, TimeInterval(0, TimeSpan.from_ticks(10))),
on_next(219, TimeInterval(1, TimeSpan.from_ticks(5))),
on_next(240, TimeInterval(2, TimeSpan.from_ticks(10))),
on_next(300, TimeInterval(3, TimeSpan.from_ticks(100))),
on_error(310, ex))
ys = scheduler.create_hot_observable(
on_next(215, TimeInterval("hat", TimeSpan.from_ticks(20))),
on_next(217, TimeInterval("bat", TimeSpan.from_ticks(1))),
on_next(290, TimeInterval("wag", TimeSpan.from_ticks(200))),
on_next(300, TimeInterval("pig", TimeSpan.from_ticks(10))),
on_next(305, TimeInterval("cup", TimeSpan.from_ticks(50))),
on_next(600, TimeInterval("yak", TimeSpan.from_ticks(90))),
on_next(702, TimeInterval("tin", TimeSpan.from_ticks(20))),
on_next(712, TimeInterval("man", TimeSpan.from_ticks(10))),
on_next(722, TimeInterval("rat", TimeSpan.from_ticks(200))),
on_next(732, TimeInterval("wig", TimeSpan.from_ticks(5))),
on_completed(800))
def create():
return xs.group_join(
ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
lambda x, yy: yy.select(lambda y: str(x.value) + y.value
)).merge_observable()
results = scheduler.start(create=create)
results.messages.assert_equal(on_next(215,
"0hat"), on_next(217, "0bat"),
on_next(219,
"1hat"), on_next(300, "3wag"),
on_next(300, "3pig"),
on_next(305, "3cup"), on_error(310, ex))
def test_join_op_error_i(self):
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(210, TimeInterval(0, 10)),
on_next(219, TimeInterval(1, 5)),
on_next(240, TimeInterval(2, 10)),
on_next(300, TimeInterval(3, 100)),
on_error(310, ex))
ys = scheduler.create_hot_observable(
on_next(215, TimeInterval("hat", 20)),
on_next(217, TimeInterval("bat", 1)),
on_next(290, TimeInterval("wag", 200)),
on_next(300, TimeInterval("pig", 10)),
on_next(305, TimeInterval("cup", 50)),
on_next(600, TimeInterval("yak", 90)),
on_next(702, TimeInterval("tin", 20)),
on_next(712, TimeInterval("man", 10)),
on_next(722, TimeInterval("rat", 200)),
on_next(732, TimeInterval("wig", 5)),
on_completed(800))
def create():
return xs.join(ys,
lambda x: Observable.timer(x.interval, scheduler=scheduler),
lambda y: Observable.timer(y.interval, scheduler=scheduler),
lambda x, y: str(x.value) + y.value
)
results = scheduler.start(create=create, disposed=713)
results.messages.assert_equal(
on_next(215, "0hat"),
on_next(217, "0bat"),
on_next(219, "1hat"),
on_next(300, "3wag"),
on_next(300, "3pig"),
on_next(305, "3cup"),
on_error(310, ex))
def test_window_opening_closings_basic(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(90, 1), on_next(180, 2),
on_next(250, 3), on_next(260, 4),
on_next(310, 5), on_next(340, 6),
on_next(410, 7), on_next(420, 8),
on_next(470, 9), on_next(550, 10),
on_completed(590))
ys = scheduler.create_hot_observable(on_next(255,
50), on_next(330, 100),
on_next(350,
50), on_next(400, 90),
on_completed(900))
def create():
def closing(x):
return Observable.timer(x)
def mapper(w, i):
return w.map(lambda x: str(i) + ' ' + str(x))
return xs.window(ys,
closing).map(mapper_indexed=mapper).merge_all()
results = scheduler.start(create=create)
assert results.messages == [
on_next(260, "0 4"),
on_next(340, "1 6"),
on_next(410, "1 7"),
on_next(410, "3 7"),
on_next(420, "1 8"),
on_next(420, "3 8"),
on_next(470, "3 9"),
on_completed(900)
]
assert xs.subscriptions == [subscribe(200, 900)]
assert ys.subscriptions == [subscribe(200, 900)]
def test_publish_with_initial_value_lambda_zip_error(self):
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))
def create():
def mapper(_xs):
return _xs.zip(_xs.skip(1),
result_mapper=lambda prev, cur: cur + prev)
return xs.publish_value(1979, mapper)
results = scheduler.start(create)
assert results.messages == [
on_next(220, 1982),
on_next(280, 7),
on_next(290, 5),
on_next(340, 9),
on_next(360, 13),
on_next(370, 11),
on_next(390, 13),
on_next(410, 20),
on_next(430, 15),
on_next(450, 11),
on_next(520, 20),
on_next(560, 31),
on_error(600, ex)
]
assert xs.subscriptions == [subscribe(200, 600)]
def test_window_with_count_error(self):
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(100, 1), on_next(210, 2),
on_next(240, 3), on_next(280, 4),
on_next(320, 5), on_next(350, 6),
on_next(380, 7), on_next(420, 8),
on_next(470, 9),
on_error(600, ex))
def create():
def mapper(w, i):
def mapping(x):
return "%s %s" % (i, x)
return w.pipe(ops.map(mapping))
return xs.pipe(ops.window_with_count(3, 2),
ops.map_indexed(mapper), ops.merge_all())
results = scheduler.start(create)
assert results.messages == [
on_next(210, "0 2"),
on_next(240, "0 3"),
on_next(280, "0 4"),
on_next(280, "1 4"),
on_next(320, "1 5"),
on_next(350, "1 6"),
on_next(350, "2 6"),
on_next(380, "2 7"),
on_next(420, "2 8"),
on_next(420, "3 8"),
on_next(470, "3 9"),
on_error(600, ex)
]
assert xs.subscriptions == [subscribe(200, 600)]
def test_window_time_basic(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(150, 1), on_next(210, 2),
on_next(240, 3), on_next(270, 4),
on_next(320, 5), on_next(360, 6),
on_next(390, 7), on_next(410, 8),
on_next(460, 9), on_next(470, 10),
on_completed(490))
def create():
def mapper(ys, i):
def proj(y):
return "%s %s" % (i, y)
return ys.map(proj).concat(
Observable.return_value('%s end' % i))
return xs.window_with_time(100).mapi(mapper).merge_all()
results = scheduler.start(create)
assert results.messages == [
on_next(210, "0 2"),
on_next(240, "0 3"),
on_next(270, "0 4"),
on_next(300, "0 end"),
on_next(320, "1 5"),
on_next(360, "1 6"),
on_next(390, "1 7"),
on_next(400, "1 end"),
on_next(410, "2 8"),
on_next(460, "2 9"),
on_next(470, "2 10"),
on_next(490, "2 end"),
on_completed(490)
]
assert xs.subscriptions == [subscribe(200, 490)]
