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)