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_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_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_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)]
