def setUp(self) -> None:
self.source = TestFlowable()
self.scheduler = TScheduler()
self.composite_disposable = CompositeDisposable()
self.sink1 = TObserver()
self.sink2 = TObserver()
self.sink3 = TObserver()
def setUp(self):
self.scheduler = TScheduler()
self.source = TObservable()
self.subject = CacheServeFirstObservableSubject(
scheduler=self.scheduler)
self.source.observe(init_observer_info(self.subject))
self.exc = Exception()
class TestEmptySource(unittest.TestCase):
def setUp(self) -> None:
self.multicast_scheduler = TScheduler()
self.source_scheduler = TScheduler()
self.info = MultiCastInfo(
multicast_scheduler=self.multicast_scheduler,
source_scheduler=self.source_scheduler,
)
self.o = MockObserver(self.source_scheduler)
def test_initialize(self):
rxbp.multicast.empty()
def test_send_item_on_subscribe_scheduler(self):
mc = rxbp.multicast.empty()
source = mc.get_source(self.info)
source.subscribe(self.o)
self.assertEqual(0, len(self.o.messages))
self.multicast_scheduler.advance_by(1)
assert self.o.messages == [
on_completed(0),
]
def setUp(self) -> None:
self.scheduler = TScheduler()
self.sources = [TestFlowable(), TestFlowable(), TestFlowable()]
self.subscriber = init_subscriber(
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler,
)
class TestFromIterable(unittest.TestCase):
def setUp(self) -> None:
self.scheduler = TScheduler()
self.subscriber = init_subscriber(
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler,
)
def test_base(self):
test_list = [1, 2, 3]
base = ObjectRefBase("test")
subscription = rxbp.from_iterable(test_list).unsafe_subscribe(
self.subscriber)
self.assertEqual(base, subscription.info.base)
def test_from_list(self):
test_list = [1, 2, 3]
sink = TObserver(immediate_continue=0)
subscription = rxbp.from_iterable(test_list).unsafe_subscribe(
Subscriber(scheduler=self.scheduler,
subscribe_scheduler=self.scheduler))
subscription.observable.observe(init_observer_info(observer=sink))
self.scheduler.advance_by(1)
self.assertEqual(test_list, sink.received)
class TestToIterator(unittest.TestCase):
def setUp(self) -> None:
self.scheduler = TScheduler()
self.source = TestFlowable()
def test_immediate_yield(self):
iterator = to_iterator(
source=init_flowable(self.source),
scheduler=self.scheduler,
)
ack = self.source.on_next_single(1)
val = next(iterator)
self.assertIsInstance(ack, ContinueAck)
self.assertEqual(1, val)
def test_scheduled_yield(self):
iterator = to_iterator(
source=init_flowable(self.source),
scheduler=self.scheduler,
)
def action(_, __):
self.source.on_next_single(1)
self.scheduler.schedule(action)
self.scheduler.sleep(1)
val = next(iterator)
self.assertEqual(1, val)
def setUp(self) -> None:
self.multicast_scheduler = TScheduler()
self.source_scheduler = TScheduler()
self.info = MultiCastInfo(
multicast_scheduler=self.multicast_scheduler,
source_scheduler=self.source_scheduler,
)
self.o = MockObserver(self.source_scheduler)
def setUp(self) -> None:
self.scheduler = TScheduler()
self.source = TObservable()
self.source1 = TObservable()
self.source2 = TObservable()
self.source3 = TObservable()
self.composite_disposable = CompositeDisposable()
class TestFromRange(unittest.TestCase):
def setUp(self) -> None:
self.scheduler = TScheduler()
def test_base(self):
subscription = rxbp.from_range(1, 4).unsafe_subscribe(
Subscriber(scheduler=self.scheduler,
subscribe_scheduler=self.scheduler))
self.assertEqual(NumericalBase(3), subscription.info.base)
def test_use_case(self):
sink = TObserver(immediate_continue=0)
subscription = rxbp.from_range(1, 4).unsafe_subscribe(
Subscriber(scheduler=self.scheduler,
subscribe_scheduler=self.scheduler))
subscription.observable.observe(ObserverInfo(observer=sink))
self.scheduler.advance_by(1)
self.assertEqual([1, 2, 3], sink.received)
self.assertTrue(sink.is_completed)
def test_from_list_batch_size_of_one(self):
sink = TObserver(immediate_continue=0)
subscription = rxbp.from_range(1, 4, batch_size=1).unsafe_subscribe(
Subscriber(scheduler=self.scheduler,
subscribe_scheduler=self.scheduler))
subscription.observable.observe(ObserverInfo(observer=sink))
self.scheduler.advance_by(1)
self.assertEqual([1], sink.received)
self.assertFalse(sink.is_completed)
sink.ack.on_next(continue_ack)
self.scheduler.advance_by(1)
self.assertEqual([1, 2], sink.received)
def test_from_list_batch_size_of_two(self):
sink = TObserver(immediate_continue=0)
subscription = rxbp.from_range(1, 4, batch_size=2).unsafe_subscribe(
Subscriber(scheduler=self.scheduler,
subscribe_scheduler=self.scheduler))
subscription.observable.observe(ObserverInfo(observer=sink))
self.scheduler.advance_by(1)
self.assertEqual([1, 2], sink.received)
sink.ack.on_next(continue_ack)
self.scheduler.advance_by(1)
self.assertEqual([1, 2, 3], sink.received)
self.assertTrue(sink.is_completed)
class TestFromList(unittest.TestCase):
def setUp(self) -> None:
self.scheduler = TScheduler()
self.subscriber = init_subscriber(
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler,
)
def test_from_list(self):
test_list = [1, 2, 3]
sink = TObserver(immediate_continue=0)
subscription = rxbp.from_list(test_list).unsafe_subscribe(
self.subscriber)
subscription.observable.observe(init_observer_info(observer=sink))
self.scheduler.advance_by(1)
self.assertEqual(test_list, sink.received)
self.assertTrue(sink.is_completed)
def test_from_list_batch_size_of_one(self):
test_list = [1, 2, 3]
sink = TObserver(immediate_continue=0)
subscription = rxbp.from_list(
test_list, batch_size=1).unsafe_subscribe(self.subscriber)
subscription.observable.observe(init_observer_info(observer=sink))
self.scheduler.advance_by(1)
self.assertEqual(test_list[:1], sink.received)
self.assertFalse(sink.is_completed)
sink.ack.on_next(continue_ack)
self.scheduler.advance_by(1)
self.assertEqual(test_list[:2], sink.received)
def test_from_list_batch_size_of_two(self):
test_list = [1, 2, 3]
sink = TObserver(immediate_continue=0)
subscription = rxbp.from_list(
test_list, batch_size=2).unsafe_subscribe(self.subscriber)
subscription.observable.observe(init_observer_info(observer=sink))
self.scheduler.advance_by(1)
self.assertEqual(test_list[:2], sink.received)
sink.ack.on_next(continue_ack)
self.scheduler.advance_by(1)
self.assertEqual(test_list, sink.received)
self.assertTrue(sink.is_completed)
def setUp(self):
self.source = TObservable()
self.inner_source_1 = TObservable()
self.inner_source_2 = TObservable()
self.sink = TObserver()
self.scheduler = TScheduler()
self.composite_disposable = CompositeDisposable()
self.exc = Exception()
self.lock = threading.RLock()
def setUp(self) -> None:
self.multicast_scheduler = TScheduler()
self.source_scheduler = TScheduler()
self.info = MultiCastInfo(
multicast_scheduler=self.multicast_scheduler,
source_scheduler=self.source_scheduler,
)
self.source_multicast = TestMultiCast()
self.rx_sink = TestMultiCastObserver()
self.source1 = TestFlowable()
self.source2 = TestFlowable()
class TestLoopFlowablesMultiCast(unittest.TestCase):
def setUp(self) -> None:
self.multicast_scheduler = TScheduler()
self.source_scheduler = TScheduler()
self.info = MultiCastInfo(
multicast_scheduler=self.multicast_scheduler,
source_scheduler=self.source_scheduler,
)
self.source_multicast = TestMultiCast()
self.rx_sink = TestMultiCastObserver()
self.source1 = TestFlowable()
self.source2 = TestFlowable()
def test_send_single_flowable(self):
reduce_multicast = LoopFlowableMultiCast(
source=self.source_multicast,
func=lambda m: MultiCast(m).pipe(
rxbp.multicast.op.map(lambda t: t[0]), ),
initial=[0],
)
reduce_multicast.get_source(self.info).subscribe(self.rx_sink)
self.source_multicast.on_next(Flowable(self.source1))
self.assertEqual(1, len(self.rx_sink.received))
def test_subscribe_single_flowable(self):
reduce_multicast = LoopFlowableMultiCast(
source=self.source_multicast,
func=lambda m: MultiCast(m).pipe(
rxbp.multicast.op.map(lambda t: t[0]), ),
initial=[10],
)
reduce_multicast.get_source(self.info).subscribe(self.rx_sink)
self.source_multicast.on_next(Flowable(self.source1))
sink = TObserver(immediate_continue=0)
subscription = self.rx_sink.received[0].unsafe_subscribe(
Subscriber(
scheduler=self.source_scheduler,
subscribe_scheduler=self.source_scheduler,
))
subscription.observable.observe(init_observer_info(sink))
self.multicast_scheduler.advance_by(1)
self.source_scheduler.advance_by(1)
# self.source1.on_next_single(0)
print(sink.received)
self.assertEqual([10], sink.received)
def setUp(self):
self.source = TestMultiCastObservable()
self.sink = TestMultiCastObserver()
self.scheduler = TScheduler()
def func(obs: rx.typing.Observable, first):
return obs
self.disposable = LiftObservable(
self.source,
func=func,
scheduler=self.scheduler,
).pipe(rxop.flat_map(lambda s: s)).subscribe(self.sink)
def setUp(self) -> None:
self.scheduler = TScheduler()
self.left_base = ObjectRefBase('left')
self.right_base = ObjectRefBase('right')
self.left = TestFlowable(base=self.left_base)
self.right = TestFlowable(base=self.right_base)
self.subscriber = init_subscriber(self.scheduler, self.scheduler)
class TestReturnValue(unittest.TestCase):
def setUp(self) -> None:
self.scheduler = TScheduler()
self.subscriber = init_subscriber(
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler,
)
def test_use_case(self):
sink = TObserver(immediate_continue=0)
subscription = rxbp.return_value(1).unsafe_subscribe(self.subscriber)
subscription.observable.observe(init_observer_info(observer=sink))
self.scheduler.advance_by(1)
self.assertEqual([1], sink.received)
def setUp(self) -> None:
self.scheduler = TScheduler()
self.sources = [TObservable(), TObservable()]
self.obs = ConcatObservable(
sources=self.sources,
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler,
)
self.exception = Exception('dummy')
class TestFromRange(unittest.TestCase):
def setUp(self):
self.scheduler = TScheduler()
def test_happy_case(self):
sink = TObserver(immediate_continue=0)
subscription = rxbp.empty().unsafe_subscribe(
Subscriber(
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler,
))
disposable = subscription.observable.observe(
init_observer_info(observer=sink))
self.scheduler.advance_by(1)
self.assertEqual([], sink.received)
self.assertTrue(sink.is_completed)
def setUp(self) -> None:
self.left = TObservable()
self.right = TObservable()
self.scheduler = TScheduler()
self.obs = MergeSelectorObservable(
left=self.left,
right=self.right,
# scheduler=self.scheduler,
)
self.exception = Exception()
class TestZip(unittest.TestCase):
def setUp(self) -> None:
self.scheduler = TScheduler()
self.sources = [TestFlowable(), TestFlowable(), TestFlowable()]
def test_use_case(self):
sink = TObserver()
subscription = rxbp.merge(
*[Flowable(e) for e in self.sources]).unsafe_subscribe(
Subscriber(scheduler=self.scheduler,
subscribe_scheduler=self.scheduler))
subscription.observable.observe(init_observer_info(observer=sink))
self.sources[0].observable.on_next_single(1)
self.sources[1].observable.on_next_single(2)
self.sources[2].observable.on_next_single(3)
self.scheduler.advance_by(1)
self.assertEqual([1, 2, 3], sink.received)
class TestEvictingBufferedObserver(TestCaseBase):
def setUp(self):
self.scheduler = TScheduler()
self.sink = TObserver(immediate_continue=0)
def test_should_block_onnext_until_connected(self):
s: TScheduler = self.scheduler
strategy = DropOld(4)
evicting_obs = EvictingBufferedObserver(self.sink,
scheduler=s,
strategy=strategy,
subscribe_scheduler=s)
s1 = TObservable(observer=evicting_obs)
s1.on_next_single(1)
s1.on_next_single(2)
ack = s1.on_next_single(3)
self.assertIsInstance(ack, ContinueAck)
ack = s1.on_next_single(4)
self.assertIsInstance(ack, ContinueAck)
ack = s1.on_next_single(5)
self.assertIsInstance(ack, ContinueAck)
self.assertEqual(len(self.sink.received), 0)
self.scheduler.advance_by(1)
self.assertEqual([2], self.sink.received)
self.sink.ack.on_next(continue_ack)
self.scheduler.advance_by(1)
self.assertEqual(self.sink.received, [2, 3])
def setUp(self) -> None:
self.scheduler = TScheduler()
self.source = TestFlowable()
class TestObserver(Observer):
def __init__(self):
self.on_next_buffer = []
self.on_completed_buffer = []
self.on_error_buffer = []
def on_next(self, value):
self.on_next_buffer.append(value)
def on_error(self, error):
self.on_error_buffer.append(error)
def on_completed(self):
self.on_completed_buffer.append(True)
self.sink = TestObserver()
class TestFromRange(unittest.TestCase):
def setUp(self):
self.scheduler = TScheduler()
def test_happy_case(self):
sink = TObserver(immediate_continue=0)
subscription = rxbp.from_range(1, 4).unsafe_subscribe(Subscriber(
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler,
))
disposable = subscription.observable.observe(ObserverInfo(
observer=sink
))
self.scheduler.advance_by(1)
self.assertEqual([1, 2, 3], sink.received)
self.assertTrue(sink.is_completed)
def test_batch_size(self):
sink = TObserver(immediate_continue=0)
subscription = rxbp.from_range(1, 4, batch_size=2).unsafe_subscribe(Subscriber(
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler,
))
disposable = subscription.observable.observe(ObserverInfo(
observer=sink
))
self.scheduler.advance_by(1)
self.assertEqual([1, 2], sink.received)
self.assertFalse(sink.is_completed)
sink.ack.on_next(continue_ack)
self.scheduler.advance_by(1)
self.assertEqual([1, 2, 3], sink.received)
self.assertTrue(sink.is_completed)
def setUp(self) -> None:
self.scheduler = TScheduler()
class TestIteratorAsObservable(unittest.TestCase):
def setUp(self) -> None:
self.scheduler = TScheduler()
def test_initialize(self):
FromIteratorObservable(iterator=iter([]),
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler)
def test_empty_iterable(self):
obs = FromIteratorObservable(iterator=iter([]),
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler)
sink = TObserver()
obs.observe(init_observer_info(sink))
self.scheduler.advance_by(1)
self.assertEqual([], sink.received)
self.assertTrue(sink.is_completed)
def test_single_elem(self):
obs = FromIteratorObservable(iterator=iter([[1]]),
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler)
sink = TObserver(immediate_continue=0)
obs.observe(init_observer_info(sink))
self.scheduler.advance_by(1)
self.assertEqual([1], sink.received)
self.assertTrue(sink.is_completed)
def test_batch(self):
obs = FromIteratorObservable(iterator=iter([[1, 2, 3]]),
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler)
sink = TObserver(immediate_continue=0)
obs.observe(init_observer_info(sink))
self.scheduler.advance_by(1)
self.assertEqual([1, 2, 3], sink.received)
self.assertTrue(sink.is_completed)
def test_multiple_elem_sync_ack(self):
obs = FromIteratorObservable(iterator=iter([[1], [2, 3], [4]]),
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler)
sink = TObserver()
obs.observe(init_observer_info(sink))
self.scheduler.advance_by(1)
self.assertEqual([1, 2, 3, 4], sink.received)
self.assertTrue(sink.is_completed)
def test_multiple_elem_async_ack(self):
obs = FromIteratorObservable(iterator=iter([[1], [2]]),
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler)
sink = TObserver(immediate_continue=0)
obs.observe(init_observer_info(sink))
self.scheduler.advance_by(1)
self.assertEqual([1], sink.received)
self.assertFalse(sink.is_completed)
def test_multiple_elem_async_ack_2nd_part(self):
obs = FromIteratorObservable(iterator=iter([[1], [2]]),
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler)
sink = TObserver(immediate_continue=0)
obs.observe(init_observer_info(sink))
self.scheduler.advance_by(1)
sink.ack.on_next(continue_ack)
self.scheduler.advance_by(1)
self.assertEqual([1, 2], sink.received)
self.assertTrue(sink.is_completed)
def setUp(self) -> None:
self.scheduler = TScheduler()
self.composite_disposable = CompositeDisposable()
self.sink = TObserver()
self.exception = Exception()
class TestLiftObservable(unittest.TestCase):
def setUp(self):
self.source = TestMultiCastObservable()
self.sink = TestMultiCastObserver()
self.scheduler = TScheduler()
def func(obs: rx.typing.Observable, first):
return obs
self.disposable = LiftObservable(
self.source,
func=func,
scheduler=self.scheduler,
).pipe(rxop.flat_map(lambda s: s)).subscribe(self.sink)
def test_scheduled_on_next(self):
self.source.on_next(1)
self.source.on_next(2)
self.scheduler.advance_by(1)
self.assertEqual([1, 2], self.sink.received)
self.assertFalse(self.sink.is_completed)
def test_non_scheduled_on_next(self):
self.source.on_next(1)
self.source.on_next(2)
self.scheduler.advance_by(1)
self.source.on_next(3)
self.source.on_next(4)
self.assertEqual([1, 2, 3, 4], self.sink.received)
self.assertFalse(self.sink.is_completed)
def test_on_completed(self):
self.source.on_completed()
self.assertTrue(self.source.is_disposed)
self.assertTrue(self.sink.is_completed)
def test_on_completed_after_on_next(self):
self.source.on_next(1)
self.source.on_next(2)
self.source.on_completed()
self.scheduler.advance_by(1)
self.assertEqual([1, 2], self.sink.received)
self.assertTrue(self.sink.is_completed)
# def test_dispose(self):
# self.source.on_next(1)
# self.source.on_next(2)
#
# self.disposable.dispose()
#
# self.assertEqual([], self.sink.received)
# self.assertTrue(self.source.is_disposed)
def test_dispose_without_subscriber(self):
self.disposable.dispose()
self.assertTrue(self.source.is_disposed)
def setUp(self) -> None:
self.scheduler = TScheduler()
self.subscriber = init_subscriber(
scheduler=self.scheduler,
subscribe_scheduler=self.scheduler,
)
def setUp(self):
self.scheduler = TScheduler()
self.exception = Exception()
class TestImperativeMultiCastBuilder(unittest.TestCase):
def setUp(self) -> None:
self.source = TestFlowable()
self.scheduler = TScheduler()
self.composite_disposable = CompositeDisposable()
self.sink1 = TObserver()
self.sink2 = TObserver()
self.sink3 = TObserver()
def test_common_case(self):
s1 = [None]
s2 = [None]
s3 = [None]
def func(builder: ImperativeMultiCastBuilder):
builder = ImperativeMultiCastBuilder(
source_scheduler=self.scheduler,
composite_disposable=self.composite_disposable,
)
s1[0] = builder.create_multicast_subject()
s2[0] = builder.create_flowable_subject()
s3[0] = builder.create_flowable_subject()
# s1[0].to_flowable().subscribe(observer=self.sink1, scheduler=self.scheduler)
s2[0].subscribe(observer=self.sink2, scheduler=self.scheduler)
blocking_flowable = Flowable(self.source)
def output_selector(flowable: Flowable):
return rxbp.multicast.return_flowable(flowable)
return builder.return_(
blocking_flowable=blocking_flowable,
output_selector=output_selector,
)
rxbp.multicast.build_imperative_multicast(
func=func, ).to_flowable().subscribe(observer=self.sink3,
scheduler=self.scheduler)
self.scheduler.advance_by(1)
s2[0].on_next(1)
self.assertEqual([1], self.sink2.received)
s1[0].on_next(s3[0])
s3[0].on_next(10)
self.assertEqual([1], self.sink2.received)
self.source.on_next_single(20)
self.assertEqual([20], self.sink3.received)
# self.assertFalse(self.sink1.is_completed)
self.assertFalse(self.sink2.is_completed)
self.assertFalse(self.sink3.is_completed)
self.source.on_completed()
# self.assertTrue(self.sink1.is_completed)
self.assertTrue(self.sink2.is_completed)
self.assertTrue(self.sink3.is_completed)
