def test_status_legacy_finished_cb(): st = StatusBase() state1, cb1 = _setup_state_and_cb() state2, cb2 = _setup_state_and_cb() # The old setter works for adding one callback. with pytest.warns(UserWarning): st.finished_cb = cb1 # The new getter works. st.callbacks == set([cb1]) # And the old getter works so long as there is just one callback set. with pytest.warns(UserWarning): assert st.finished_cb is cb1 # As before, the old setter cannot be updated once set. with pytest.raises(UseNewProperty): st.finished_cb = cb2 # But, using the new method, we can add another callback. st.add_callback(cb2) # Once we have two callbacks, the getter does not work. with pytest.raises(UseNewProperty): st.finished_cb # But the new getter does. st.callbacks == set([cb1, cb2]) assert 'done' not in state1 assert 'done' not in state2 st.set_finished() st.wait(1) time.sleep(0.1) # Wait for callbacks to run. assert 'done' in state1 assert 'done' in state2
def test_old_signature_on_finished_status(): st = StatusBase() state, cb = _setup_state_and_cb(new_signature=False) st.set_finished() st.wait(1) with pytest.warns(DeprecationWarning, match="signature"): st.add_callback(cb) assert state
def test_old_signature(): st = StatusBase() state, cb = _setup_state_and_cb(new_signature=False) with pytest.warns(DeprecationWarning, match="signature"): st.add_callback(cb) assert not state st.set_finished() st.wait(1) time.sleep(0.1) # Wait for callbacks to run. assert state
def test_set_finished_after_timeout(): """ If an external callback (e.g. pyepics) calls set_finished after the status has timed out, ignore it. """ st = StatusBase(timeout=0) time.sleep(0.1) assert isinstance(st.exception(), StatusTimeoutError) # External callback fires, too late. st.set_finished() assert isinstance(st.exception(), StatusTimeoutError)
def test_status_callback(): "The new way, with add_callback and the callbacks property" st = StatusBase() cb = Mock() st.add_callback(cb) assert st.callbacks[0] is cb st.set_finished() st.wait(1) time.sleep(0.1) # Wait for callbacks to run. cb.assert_called_once_with(st)
def test_status_pre(): st = StatusBase() state, cb = _setup_state_and_cb() st.set_finished() st.wait(1) time.sleep(0.1) # Wait for callbacks to run. assert 'done' not in state st.add_callback(cb) assert 'done' in state assert state['done']
def test_race_settle_time_and_timeout(): """ A StatusTimeoutError should NOT occur here because that is only invoked after (timeout + settle_time) has elapsed. """ st = StatusBase(timeout=1, settle_time=3) st.set_finished() # starts a threading.Timer with the settle_time time.sleep(1.5) # We should still be settling.... with pytest.raises(WaitTimeoutError): st.wait(1) # Now we should be done successfully. st.wait(3)
def test_status_callback_deprecated(): "The old way, with finished_cb" st = StatusBase() cb = Mock() with pytest.warns(UserWarning): st.finished_cb = cb with pytest.warns(UserWarning): assert st.finished_cb is cb with pytest.raises(RuntimeError): st.finished_cb = None st.set_finished() st.wait(1) time.sleep(0.1) # Wait for callbacks to run. cb.assert_called_once_with(st)
def test_direct_done_setting(): st = StatusBase() state, cb = _setup_state_and_cb() with pytest.raises(RuntimeError): st.done = True # changing isn't allowed with pytest.warns(UserWarning): st.done = False # but for now no-ops warn st.set_finished() st.wait(1) time.sleep(0.1) # Wait for callbacks to run. with pytest.raises(RuntimeError): st.done = False # changing isn't allowed with pytest.warns(UserWarning): st.done = True # but for now no-ops warn
def test_and(): st1 = StatusBase() st2 = StatusBase() st3 = st1 & st2 # make sure deep recursion works st4 = st1 & st3 st5 = st3 & st4 state1, cb1 = _setup_state_and_cb() state2, cb2 = _setup_state_and_cb() state3, cb3 = _setup_state_and_cb() state4, cb4 = _setup_state_and_cb() state5, cb5 = _setup_state_and_cb() st1.add_callback(cb1) st2.add_callback(cb2) st3.add_callback(cb3) st4.add_callback(cb4) st5.add_callback(cb5) st1.set_finished() st1.wait(1) time.sleep(0.1) # Wait for callbacks to run. assert 'done' in state1 assert 'done' not in state2 assert 'done' not in state3 assert 'done' not in state4 assert 'done' not in state5 st2.set_finished() st3.wait(1) st4.wait(1) st5.wait(1) time.sleep(0.1) # Wait for callbacks to run. assert 'done' in state3 assert 'done' in state4 assert 'done' in state5 assert st3.left is st1 assert st3.right is st2 assert st4.left is st1 assert st4.right is st3 assert st5.left is st3 assert st5.right is st4
def test_status_wait(): st = StatusBase() st.set_finished() wait(st)
def test_status_basic(): st = StatusBase() st.set_finished()
def trigger(self): print('Triggered the sequencer!') status = StatusBase() status.set_finished() return status
def test_exception_success_path(): st = StatusBase() st.set_finished() assert st.wait(1) is None assert st.exception() is None
def test_set_finished_twice(): st = StatusBase() st.set_finished() with pytest.raises(InvalidState): st.set_finished()