def test_retry_observable_retry_count_throws(self): scheduler1 = TestScheduler() xs = reactivex.return_value(1).pipe(ops.retry(3)) xs.subscribe(lambda x: _raise("ex"), scheduler=scheduler1) self.assertRaises(RxException, scheduler1.start) scheduler2 = TestScheduler() ys = reactivex.throw("ex").pipe(ops.retry(100)) d = ys.subscribe(on_error=lambda ex: _raise("ex"), scheduler=scheduler2) def dispose(_, __): d.dispose() scheduler2.schedule_absolute(0, dispose) scheduler2.start() scheduler3 = TestScheduler() zs = reactivex.return_value(1).pipe(ops.retry(100)) zs.subscribe(on_completed=lambda: _raise("ex"), scheduler=scheduler3) with pytest.raises(RxException): scheduler3.start() xss = reactivex.create(lambda o: _raise("ex")).pipe(ops.retry(100)) with pytest.raises(Exception): xss.subscribe()
def test_return_observer_throws(self): scheduler1 = TestScheduler() xs = reactivex.return_value(1) xs.subscribe(lambda x: _raise("ex"), scheduler=scheduler1) self.assertRaises(RxException, scheduler1.start) scheduler2 = TestScheduler() ys = reactivex.return_value(1) ys.subscribe(lambda x: x, lambda ex: ex, lambda: _raise("ex"), scheduler=scheduler2) self.assertRaises(RxException, scheduler2.start)
def mapper(ys, i): def proj(y): return "%s %s" % (i, y) return ys.pipe( ops.map(proj), ops.concat(reactivex.return_value("%s end" % i)))
async def go(): source = reactivex.return_value(42) fut = next(source.__await__()) # This used to raise an InvalidStateError before we got # support for cancellation. fut.cancel() await fut
def test_return_disposed_after_next(self): scheduler = TestScheduler() d = SerialDisposable() xs = reactivex.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_map_throws(self): mapper = map(lambda x: x) with self.assertRaises(RxException): return_value(1).pipe(mapper).subscribe(lambda x: _raise("ex")) with self.assertRaises(RxException): throw("ex").pipe(mapper).subscribe(on_error=lambda ex: _raise(ex)) with self.assertRaises(RxException): empty().pipe(mapper).subscribe( lambda x: x, lambda ex: ex, lambda: _raise("ex") ) def subscribe(observer, scheduler=None): _raise("ex") with self.assertRaises(RxException): create(subscribe).pipe(map(lambda x: x)).subscribe()
def test_retry_observable_throws(self): scheduler1 = TestScheduler() xs = reactivex.return_value(1).pipe(ops.retry()) xs.subscribe(lambda x: _raise("ex"), scheduler=scheduler1) with pytest.raises(RxException): scheduler1.start() scheduler2 = TestScheduler() ys = reactivex.throw("ex").pipe(ops.retry()) d = ys.subscribe(on_error=lambda ex: _raise("ex"), scheduler=scheduler2) scheduler2.schedule_absolute(210, lambda sc, st: d.dispose()) scheduler2.start() scheduler3 = TestScheduler() zs = reactivex.return_value(1).pipe(ops.retry()) zs.subscribe(on_completed=lambda: _raise("ex"), scheduler=scheduler3) with pytest.raises(RxException): scheduler3.start()
def test_connectable_observable_creation(self): y = [0] s2 = Subject() co2 = ConnectableObservable(reactivex.return_value(1), s2) def on_next(x): y[0] = x co2.subscribe(on_next=on_next) self.assertNotEqual(1, y[0]) co2.connect() self.assertEqual(1, y[0])
def test_repeat_observable_repeat_count_throws(self): scheduler1 = TestScheduler() xs = reactivex.return_value(1).pipe(ops.repeat(3)) xs.subscribe(lambda x: _raise("ex"), scheduler=scheduler1) with self.assertRaises(RxException): scheduler1.start() scheduler2 = TestScheduler() ys = reactivex.throw("ex1").pipe(ops.repeat(3)) ys.subscribe(on_error=lambda ex: _raise("ex2"), scheduler=scheduler2) with self.assertRaises(RxException): scheduler2.start()
def test_map_with_index_throws(self): with self.assertRaises(RxException): mapper = map_indexed(lambda x, index: x) return return_value(1).pipe(mapper).subscribe(lambda x: _raise("ex")) with self.assertRaises(RxException): return ( throw("ex").pipe(mapper).subscribe(lambda x: x, lambda ex: _raise(ex)) ) with self.assertRaises(RxException): return ( empty() .pipe(mapper) .subscribe(lambda x: x, lambda ex: None, lambda: _raise("ex")) ) with self.assertRaises(RxException): return create(lambda o, s: _raise("ex")).pipe(mapper).subscribe()
def repeat_value_(value: _T, repeat_count: Optional[int] = None) -> Observable[_T]: """Generates an observable sequence that repeats the given element the specified number of times. Examples: 1 - res = repeat_value(42) 2 - res = repeat_value(42, 4) Args: value: Element to repeat. repeat_count: [Optional] Number of times to repeat the element. If not specified, repeats indefinitely. Returns: An observable sequence that repeats the given element the specified number of times. """ if repeat_count == -1: repeat_count = None xs = reactivex.return_value(value) return xs.pipe(ops.repeat(repeat_count))
async def go(): nonlocal result source = reactivex.return_value(42).pipe(ops.delay(0.1)) result = await source
async def go(): nonlocal result source = reactivex.return_value(42) result = await source
def factory(): return reactivex.return_value(42)