def check_task_trigger(self, state: State, upstream_states: Dict[Edge, State]) -> State: """ Checks if the task's trigger function passes. Args: - state (State): the current state of this task - upstream_states (Dict[Edge, Union[State, List[State]]]): the upstream states Returns: - State: the state of the task after running the check Raises: - ENDRUN: if the trigger raises an error """ all_states = set() # type: Set[State] for upstream_state in upstream_states.values(): if isinstance(upstream_state, Mapped): all_states.update(upstream_state.map_states) else: all_states.add(upstream_state) try: if not self.task.trigger(all_states): raise signals.TRIGGERFAIL(message="Trigger failed") except signals.PrefectStateSignal as exc: self.logger.debug( "Task '{name}': {signal} signal raised during execution.". format( name=prefect.context.get("task_full_name", self.task.name), signal=type(exc).__name__, )) if prefect.context.get("raise_on_exception"): raise exc raise ENDRUN(exc.state) # Exceptions are trapped and turned into TriggerFailed states except Exception as exc: self.logger.exception( "Task '{name}': unexpected error while evaluating task trigger: {exc}" .format( exc=repr(exc), name=prefect.context.get("task_full_name", self.task.name), )) if prefect.context.get("raise_on_exception"): raise exc raise ENDRUN( TriggerFailed( "Unexpected error while checking task trigger: {}".format( repr(exc)), result=exc, )) return state
async def test_trigger_failed_state_does_not_set_end_time( self, flow_run_id): # there is no logic in Prefect that would create this sequence of # events, but a user could manually do this await states.set_flow_run_state(flow_run_id=flow_run_id, state=TriggerFailed()) flow_run_info = await models.FlowRun.where(id=flow_run_id).first( {"id", "start_time", "end_time"}) assert not flow_run_info.start_time assert not flow_run_info.end_time
def test_children_method_on_leaf_state_returns_hierarchy(): assert set(TriggerFailed.parents()) == {Finished, Failed, State}
def test_children_method_on_leaf_state_returns_empty(): assert TriggerFailed.children() == []
dict(state=Mapped(), assert_true={"is_finished", "is_mapped", "is_successful"}), dict(state=Paused(), assert_true={"is_pending", "is_scheduled"}), dict(state=Pending(), assert_true={"is_pending"}), dict(state=Queued(), assert_true={"is_meta_state", "is_queued"}), dict(state=Resume(), assert_true={"is_pending", "is_scheduled"}), dict(state=Retrying(), assert_true={"is_pending", "is_scheduled", "is_retrying"}), dict(state=Running(), assert_true={"is_running"}), dict(state=Scheduled(), assert_true={"is_pending", "is_scheduled"}), dict(state=Skipped(), assert_true={"is_finished", "is_successful", "is_skipped"}), dict(state=Submitted(), assert_true={"is_meta_state", "is_submitted"}), dict(state=Success(), assert_true={"is_finished", "is_successful"}), dict(state=TimedOut(), assert_true={"is_finished", "is_failed"}), dict(state=TriggerFailed(), assert_true={"is_finished", "is_failed"}), ], ) def test_state_is_methods(state_check): """ Iterates over all of the "is_*()" methods of the state, asserting that each one is False, unless the name of that method is provided as `assert_true`. For example, if `state_check == (Pending(), {'is_pending'})`, then this method will assert that `state.is_running()` is False, `state.is_successful()` is False, etc. but `state.is_pending()` is True. """ state = state_check["state"] assert_true = state_check["assert_true"] for attr in dir(state):
def test_children_method_on_leaf_state_returns_hierarchy(include_self): expected = {Finished, Failed, State} if include_self: expected.add(TriggerFailed) assert set(TriggerFailed.parents(include_self=include_self)) == expected
def test_children_method_names_only_returns_strings(): assert TriggerFailed.children(include_self=True, names_only=True) == ["TriggerFailed"]
def test_state_type_methods_with_trigger_failed_state(self): state = TriggerFailed(message="") assert not state.is_cached() assert not state.is_pending() assert not state.is_retrying() assert not state.is_running() assert state.is_finished() assert not state.is_skipped() assert not state.is_scheduled() assert not state.is_successful() assert state.is_failed() assert not state.is_mapped() assert not state.is_meta_state()