def setUp(self):
scheduler = TestScheduler()
s1 = TestObservable()
s2 = TestObservable()
o1 = TestObserverSubscribeInner(inner_selector=lambda v: v[1],
scheduler=scheduler)
o2 = TestObserver()
left, right = window(s1, s2, lambda v1, v2: v2 < v1,
lambda v1, v2: v1 < v2)
left.subscribe(o1, scheduler, CurrentThreadScheduler())
right.subscribe(o2, scheduler, CurrentThreadScheduler())
self.scheduler = scheduler
self.left_in = s1
self.right_in = s2
self.left_out = o1
self.right_out = o2
def subscribe(self,
observer: Observer,
scheduler: Scheduler = None,
subscribe_scheduler: Scheduler = None):
subscribe_scheduler_ = subscribe_scheduler or CurrentThreadScheduler()
scheduler_ = scheduler or subscribe_scheduler_
def action(_, __):
return self.unsafe_subscribe(observer, scheduler_,
subscribe_scheduler_)
return subscribe_scheduler_.schedule(action)
def stream_on_done(buffer: Iterable,
error_thrown: Exception = None) -> Disposable:
class TObserver(Observer):
def on_next(self, v):
ack = observer.on_next(v)
return ack
def on_error(self, err):
observer.on_error(err)
def on_completed(self):
if error_thrown is not None:
observer.on_error(error_thrown)
else:
observer.on_completed()
return IteratorAsObservable(iter(buffer)) \
.subscribe(TObserver(), scheduler, CurrentThreadScheduler())
def test_should_emit_from_the_point_of_subscription_forward(self):
subject = PublishSubject()
self.assertIsInstance(subject.on_next(1), Continue)
self.assertIsInstance(subject.on_next(2), Continue)
self.assertIsInstance(subject.on_next(3), Continue)
o1 = TestObserver()
o1.immediate_continue = 5
subject.unsafe_subscribe(o1, self.scheduler, CurrentThreadScheduler())
self.assertIsInstance(subject.on_next(4), Continue)
self.assertIsInstance(subject.on_next(5), Continue)
self.assertIsInstance(subject.on_next(6), Continue)
subject.on_completed()
self.assertEqual(sum(o1.received), 15)
self.assertTrue(o1.is_completed)
def on_next(self, v):
self.received.append(v)
self.ack = Ack()
self.inner_obs = TestObserver()
self.inner_selector(v).subscribe(self.inner_obs, self.scheduler, CurrentThreadScheduler())
return self.ack
def test_right_first_left_empty(self):
s: TestScheduler = self.scheduler
class TestObserver(Observer):
def __init__(self):
self.received = []
self.was_completed = False
self.ack = None
def on_next(self, v):
self.received.append(v)
self.ack = Ack()
return self.ack
def on_error(self, err):
pass
def on_completed(self):
self.was_completed = True
class TestObservable(Observable):
def __init__(self):
self.observer = None
def on_next(self, v):
return self.observer.on_next(v)
def on_completed(self):
return self.observer.on_completed()
def unsafe_subscribe(self, observer: Observer,
scheduler: SchedulerBase,
subscribe_scheduler: SchedulerBase):
self.observer = observer
return Disposable.empty()
s1 = TestObservable()
s2 = TestObservable()
s3 = TestObservable()
o1 = TestObserver()
obs = FlatZipObservable(s1, s2, lambda v: v)
obs.subscribe(o1, s, CurrentThreadScheduler())
ack2 = s2.on_next(100)
self.assertListEqual(o1.received, [])
self.assertFalse(ack2.has_value)
ack1 = s1.on_next(s3)
self.assertListEqual(o1.received, [])
self.assertFalse(ack1.has_value)
s3.on_completed()
self.assertListEqual(o1.received, [])
self.assertTrue(ack1.has_value)
self.assertTrue(ack2.has_value)
ack1 = s1.on_next(s3)
ack2 = s2.on_next(200)
s3.on_completed()
self.assertTrue(ack1.has_value)
self.assertTrue(ack2.has_value)
self.assertIsInstance(ack1.value, Continue)
self.assertIsInstance(ack2.value, Continue)
def connect(self):
with self.lock:
if not self.is_connected and not self.is_connected_started:
self.is_connected_started = True
buffer_was_drained = Ack()
def on_next(v):
if isinstance(v, Continue):
self.root_ack.on_next(Continue())
self.root_ack.on_completed()
source.is_connected = True
source.queue = None
# source.connected_ack = None
# todo: fill in
elif isinstance(v, Stop):
raise NotImplementedError
else:
raise NotImplementedError
buffer_was_drained.subscribe(on_next=on_next)
source = self
class CustomObserver(Observer):
def __init__(self):
self.ack = None
def on_next(self, v):
ack = source.underlying.on_next(v)
self.ack = ack
def on_next(v):
if isinstance(v, Stop):
buffer_was_drained.on_next(v)
buffer_was_drained.on_completed()
ack.subscribe(on_next=on_next)
return ack
def on_error(self, err):
raise NotImplementedError
def on_completed(self):
if not source.scheduled_done:
if self.ack is None:
buffer_was_drained.on_next(Continue())
buffer_was_drained.on_completed()
else:
def on_next(v):
if isinstance(v, Continue):
buffer_was_drained.on_next(Continue())
buffer_was_drained.on_completed()
self.ack.subscribe(on_next)
elif source.schedule_error is not None:
raise NotImplementedError
else:
source.underlying.on_completed()
class EmptyObject:
pass
self.queue.put(EmptyObject)
disposable = IteratorAsObservable(iter(self.queue.get, EmptyObject)) \
.subscribe(CustomObserver(), self.scheduler, CurrentThreadScheduler())
self.connected_ref = buffer_was_drained, disposable
return self.connected_ref