def test_input_in_substate() -> None:
@inputstep("Input Name", assignee=Assignee.SYSTEM)
def input_action(state: State) -> FormGenerator:
class SubForm(FormPage):
a: int
class TestForm(FormPage):
sub: SubForm
user_input = yield TestForm
return user_input.dict()
wf = workflow("Workflow with user interaction")(
lambda: begin >> input_action >> purestep("process inputs")(Success))
log: List[Tuple[str, Process]] = []
pid = uuid4()
p = ProcessStat(pid=pid,
workflow=wf,
state=Suspend({"sub": {
"a": 1,
"b": 2
}}),
log=wf.steps[1:],
current_user="******")
result = runwf(p, logstep=store(log))
assert_success(result)
assert_state(result, {"sub": {"a": 1, "b": 2}})
def test_focus_state():
@step("Step that works on substate")
def substep():
return {"result": "substep"}
subwf = focussteps("sub")
wf = workflow("Workflow with sub workflow that focuses on sub state")(
lambda: subwf(substep) >> done)
log = []
pstat = create_new_process_stat(wf, {"sub": {}})
result = runwf(pstat, store(log))
assert_complete(result)
assert_state(result, {"sub": {"result": "substep"}})
# Test on empty key
subwf = focussteps("sub")
wf = workflow("Workflow with sub workflow that focuses on sub state")(
lambda: subwf(substep) >> done)
log = []
pstat = create_new_process_stat(wf, {})
result = runwf(pstat, store(log))
assert_complete(result)
assert_state(result, {"sub": {"result": "substep"}})
def test_exec_through_all_steps():
log = []
pstat = create_new_process_stat(sample_workflow, {})
result = runwf(pstat, store(log))
assert_success(result)
assert_state(result, {"steps": [1, 2, 3]})
def test_complete():
wf = workflow("WF")(lambda: init >> done)
log = []
pstat = create_new_process_stat(wf, {"name": "completion"})
result = runwf(pstat, store(log))
assert_complete(result)
assert_state(result, {"name": "completion"})
def test_abort():
wf = workflow("Aborting workflow")(lambda: init >> abort)
log = []
pstat = create_new_process_stat(wf, {"name": "aborting"})
result = runwf(pstat, store(log))
assert_aborted(result)
assert_state(result, {"name": "aborting"})
def test_recover():
log = []
p = ProcessStat(
pid=1,
workflow=sample_workflow,
state=Success({"steps": [4]}),
log=sample_workflow.steps[1:],
current_user="******",
)
result = runwf(p, store(log))
assert_success(result)
assert_state(result, {"steps": [4, 2, 3]})
def test_remove_tasks(task):
result, process, step_log = run_workflow("task_clean_up_tasks", {})
assert_complete(result)
res = extract_state(result)
state = {
"process_id": res["process_id"],
"reporter": "john.doe",
"tasks_removed": 1
}
assert_state(result, state)
processes = ProcessTable.query.all()
assert len(processes) == 3
assert sorted(p.workflow for p in processes) == sorted(
["nice and new task", "nice process", "task_clean_up_tasks"])
def test_resume_workflow(waiting_process):
with mock.patch("orchestrator.services.processes.resume_process") as m:
result, process, step_log = run_workflow("task_resume_workflows", {})
assert_complete(result)
#
res = extract_state(result)
state = {
"process_id": res["process_id"],
"reporter": "john.doe",
"number_of_waiting_processes": 1,
"number_of_resumed_pids": 1,
"waiting_pids": [str(PID)],
"resumed_pids": [str(PID)],
}
assert_state(result, state)
m.assert_called_once()
def test_conditionally_skip_a_step():
@step("Inc N")
def inc_n(n=0):
return {"n": n + 1}
limit_to_10 = conditional(lambda s: s.get("n", 0) < 10)
incs = [limit_to_10(inc_n) for _ in range(0, 25)]
wf = workflow("Limit the number of increments")(
lambda: init >> reduce(lambda acc, e: acc >> e, incs) >> done)
log = []
pstat = create_new_process_stat(wf, {})
result = runwf(pstat, store(log))
assert_complete(result)
# from ipdb import set_trace; set_trace()
assert_state(result, {"n": 10})
assert len([x for x in log
if x[1].isskipped()]) == 15, "15 steps should be skipped"