def test_asynchronous_ack_from_selectors(self):
"""
ack.on_next
WaitOnLeftRight ------------> WaitOnLeftRight
"""
sink = TObserver(immediate_continue=0)
left_sel_sink = TObserver(immediate_continue=0)
right_sel_sink = TObserver(immediate_continue=0)
obs = ControlledZipObservable(
left=self.left, right=self.right, scheduler=self.scheduler,
request_left=lambda left, right: left <= right,
request_right=lambda left, right: right <= left,
match_func=lambda left, right: left == right,
)
obs.observe(init_observer_info(sink))
obs.left_selector.observe(init_observer_info(left_sel_sink))
obs.right_selector.observe(init_observer_info(right_sel_sink))
ack1 = AckSubject()
ack2 = AckSubject()
self.left.on_next_single(1).subscribe(ack1)
self.right.on_next_single(1).subscribe(ack2)
sink.ack.on_next(continue_ack)
self.assertFalse(ack1.has_value)
left_sel_sink.ack.on_next(continue_ack)
self.assertTrue(ack1.has_value)
self.assertFalse(ack2.has_value)
right_sel_sink.ack.on_next(continue_ack)
self.assertTrue(ack1.has_value)
self.assertTrue(ack2.has_value)
def test_select_message_if_no_two_elements_match(self):
"""
ack.on_next
WaitOnLeftRight ------------> WaitOnLeft
"""
sink = TObserver(immediate_continue=0)
left_sel_sink = TObserver(immediate_continue=0)
right_sel_sink = TObserver(immediate_continue=0)
ack1 = AckSubject()
ack2 = AckSubject()
obs = ControlledZipObservable(
left=self.left, right=self.right, scheduler=self.scheduler,
request_left=lambda left, right: left <= right,
request_right=lambda left, right: right <= left,
match_func=lambda left, right: left == right,
)
obs.observe(init_observer_info(sink))
obs.left_selector.observe(init_observer_info(left_sel_sink))
obs.right_selector.observe(init_observer_info(right_sel_sink))
self.left.on_next_single(1).subscribe(ack1)
self.right.on_next_single(2).subscribe(ack2)
self.assertIsInstance(self.measure_state(obs), ControlledZipStates.WaitOnLeft)
self.assertIsInstance(left_sel_sink.received[0], SelectCompleted)
self.left.on_next_single(2).subscribe(ack1)
self.assertIsInstance(self.measure_state(obs), ControlledZipStates.WaitOnLeftRight)
for instance_obj, class_obj in zip(left_sel_sink.received, [SelectCompleted, SelectNext, SelectCompleted]):
self.assertIsInstance(instance_obj, class_obj)
def test_init_state(self):
sink = TObserver()
obs = ControlledZipObservable(
left=self.left, right=self.right, scheduler=self.scheduler,
request_left=lambda left, right: left <= right,
request_right=lambda left, right: right <= left,
match_func=lambda left, right: left == right,
)
obs.observe(init_observer_info(sink))
self.assertIsInstance(self.measure_termination_state(obs), TerminationStates.InitState)
self.assertIsInstance(self.measure_state(obs), ControlledZipStates.WaitOnLeftRight)
def test_exception(self):
"""
ack.on_next
WaitOnRight ------------> Stopped
"""
sink = TObserver(immediate_continue=0)
obs = ControlledZipObservable(
left=self.left, right=self.right, scheduler=self.scheduler,
request_left=lambda left, right: left <= right,
request_right=lambda left, right: right <= left,
match_func=lambda left, right: left == right,
)
obs.observe(init_observer_info(sink))
ack1 = self.left.on_next_list([1])
self.right.on_error(self.exception)
self.assertIsInstance(self.measure_state(obs), ControlledZipStates.Stopped)
self.assertEqual(self.exception, sink.exception)
def test_left_complete(self):
"""
s1.on_completed
WaitOnLeftRight -----------------> Stopped
InitState LeftCompletedState
"""
sink = TObserver()
obs = ControlledZipObservable(
left=self.left, right=self.right, scheduler=self.scheduler,
request_left=lambda left, right: left <= right,
request_right=lambda left, right: right <= left,
match_func=lambda left, right: left == right,
)
obs.observe(init_observer_info(sink))
self.left.on_completed()
self.assertIsInstance(self.measure_state(obs), ControlledZipStates.Stopped)
self.assertIsInstance(self.measure_termination_state(obs), TerminationStates.LeftCompletedState)
self.assertTrue(sink.is_completed)
def test_wait_on_right_to_wait_on_left_right_with_synchronous_ack(self):
"""
s2.on_next
WaitOnRight ------------> WaitOnLeftRight
"""
sink = TObserver()
obs = ControlledZipObservable(
left=self.left, right=self.right, scheduler=self.scheduler,
request_left=lambda left, right: left <= right,
request_right=lambda left, right: right <= left,
match_func=lambda left, right: left == right,
)
obs.observe(init_observer_info(sink))
ack1 = self.left.on_next_single(1)
ack2 = self.right.on_next_single(1)
self.assertIsInstance(self.measure_state(obs), ControlledZipStates.WaitOnLeftRight)
self.assertIsInstance(ack1.value, ContinueAck)
self.assertIsInstance(ack2, ContinueAck)
self.assertListEqual(sink.received, [(1, 1)])
def test_wait_on_left_right_to_wait_on_right_with_synchronous_ack(self):
"""
s1.on_next
WaitOnLeftRight ------------> WaitOnRight
InitState InitState
"""
sink = TObserver()
obs = ControlledZipObservable(
left=self.left, right=self.right, scheduler=self.scheduler,
request_left=lambda left, right: left <= right,
request_right=lambda left, right: right <= left,
match_func=lambda left, right: left == right,
)
obs.observe(init_observer_info(sink))
ack1 = self.left.on_next_single(1)
self.assertIsInstance(self.measure_state(obs), ControlledZipStates.WaitOnRight)
self.assertIsInstance(self.measure_termination_state(obs), TerminationStates.InitState)
self.assertFalse(ack1.has_value)
self.assertListEqual(sink.received, [])
def test_left_complete_to_stopped(self):
"""
s2.on_next
WaitOnRight ------------> Stopped
LeftComplete BothCompletedState
"""
sink = TObserver(immediate_continue=0)
obs = ControlledZipObservable(
left=self.left, right=self.right, scheduler=self.scheduler,
request_left=lambda left, right: left <= right,
request_right=lambda left, right: right <= left,
match_func=lambda left, right: left == right,
)
obs.observe(init_observer_info(sink))
self.left.on_next_list([1])
self.left.on_completed()
self.right.on_next_list([1])
self.assertIsInstance(self.measure_termination_state(obs), TerminationStates.LeftCompletedState)
self.assertIsInstance(self.measure_state(obs), ControlledZipStates.Stopped)
self.assertListEqual(sink.received, [(1, 1)])
def test_acknowledge_both(self):
"""
ack.on_next
WaitOnRightLeft ------------> WaitOnRightLeft
"""
sink = TObserver(immediate_continue=0)
obs = ControlledZipObservable(
left=self.left, right=self.right, scheduler=self.scheduler,
request_left=lambda left, right: left <= right,
request_right=lambda left, right: right <= left,
match_func=lambda left, right: left == right,
)
obs.observe(init_observer_info(sink))
ack1 = self.left.on_next_list([1])
ack2 = self.right.on_next_list([1])
sink.ack.on_next(continue_ack)
self.assertIsInstance(self.measure_state(obs), ControlledZipStates.WaitOnLeftRight)
self.assertIsInstance(ack1.value, ContinueAck)
self.assertIsInstance(ack2.value, ContinueAck)
self.assertListEqual(sink.received, [(1, 1)])
def unsafe_subscribe(self, subscriber: Subscriber) -> Subscription:
left_subscription = self.left.unsafe_subscribe(subscriber=subscriber)
right_subscription = self.right.unsafe_subscribe(subscriber=subscriber)
observable = ControlledZipObservable(
left=left_subscription.observable,
right=right_subscription.observable,
request_left=self.request_left,
request_right=self.request_right,
match_func=self.match_func,
scheduler=subscriber.scheduler,
stack=self.stack,
)
return init_subscription(observable=observable)
def select_observable(
obs: Observable,
selector: Observable,
scheduler: Scheduler,
stack: List[FrameSummary],
):
def request_left(left, right):
return isinstance(right, SelectCompleted)
result = MapObservable(
source=ControlledZipObservable(
left=obs,
right=selector,
request_left=request_left,
request_right=lambda l, r: True,
match_func=lambda l, r: isinstance(r, SelectNext),
scheduler=scheduler,
stack=stack,
),
func=lambda t2: t2[0],
)
return result