hpcflow-new2 0.2.0a190__py3-none-any.whl → 0.2.0a199__py3-none-any.whl

hpcflow/tests/unit/utils/test_hashing.py

@@ -0,0 +1,65 @@
+from hpcflow.sdk.utils.hashing import get_hash
+
+
+def test_get_hash_simple_types_is_int():
+    assert isinstance(get_hash(1), int)
+    assert isinstance(get_hash(3.2), int)
+    assert isinstance(get_hash("a"), int)
+    assert isinstance(get_hash("abc"), int)
+
+
+def test_get_hash_compound_types_is_int():
+    assert isinstance(get_hash([1, 2, 3]), int)
+    assert isinstance(get_hash((1, 2, 3)), int)
+    assert isinstance(get_hash({1, 2, 3}), int)
+    assert isinstance(get_hash({"a": 1, "b": 2, "c": 3}), int)
+
+
+def test_get_hash_nested_dict_is_int():
+    assert isinstance(get_hash({"a": {"b": {"c": [1, 2, 3, ("4", 5, 6)]}}}), int)
+
+
+def test_get_hash_distinct_simple_types():
+    assert get_hash(1) != get_hash(2)
+    assert get_hash(2.2) != get_hash(2.3)
+    assert get_hash("a") != get_hash("b")
+    assert get_hash("abc") != get_hash("ABC")
+
+
+def test_get_hash_distinct_compound_types():
+    assert get_hash([1, 2, 3]) != get_hash([1, 2, 4])
+    assert get_hash((1, 2, 3)) != get_hash((1, 2, 4))
+    assert get_hash({1, 2, 3}) != get_hash({1, 2, 4})
+    assert get_hash({"a": 1, "b": 2, "c": 3}) != get_hash({"a": 1, "b": 2, "c": 4})
+    assert get_hash({"a": {"b": {"c": [1, 2, 3, ("4", 5, 7)]}}}) == get_hash(
+        {"a": {"b": {"c": [1, 2, 3, ("4", 5, 7)]}}}
+    )
+    assert get_hash({"a": 1}) != get_hash(1) != get_hash("a")
+
+
+def test_get_hash_equal_simple_types():
+    assert get_hash(1) == get_hash(1)
+    assert get_hash(2.2) == get_hash(2.2)
+    assert get_hash("a") == get_hash("a")
+    assert get_hash("abc") == get_hash("abc")
+
+
+def test_get_hash_equal_compound_types():
+    assert get_hash([1, 2, 3]) == get_hash([1, 2, 3])
+    assert get_hash((1, 2, 3)) == get_hash((1, 2, 3))
+    assert get_hash({1, 2, 3}) == get_hash({1, 2, 3})
+    assert get_hash({"a": 1, "b": 2, "c": 3}) == get_hash({"a": 1, "b": 2, "c": 3})
+    assert get_hash({"a": {"b": {"c": [1, 2, 3, ("4", 5, 6)]}}}) == get_hash(
+        {"a": {"b": {"c": [1, 2, 3, ("4", 5, 6)]}}}
+    )
+
+
+def test_get_hash_order_insensitivity():
+    assert get_hash({"a": 1, "b": 2}) == get_hash({"b": 2, "a": 1})
+    assert get_hash({1, 2, 3}) == get_hash({2, 3, 1})
+
+
+def test_get_hash_order_sensitivity():
+    assert get_hash([1, 2, 3]) != get_hash([2, 3, 1])
+    assert get_hash((1, 2, 3)) != get_hash((2, 3, 1))
+    assert get_hash("abc") != get_hash("cba")

hpcflow/tests/unit/utils/test_patches.py

@@ -0,0 +1,5 @@
+from hpcflow.sdk.utils.patches import resolve_path
+
+
+def test_absolute_path():
+    assert resolve_path("my_file_path").is_absolute()

hpcflow/tests/unit/utils/test_redirect_std.py

@@ -0,0 +1,50 @@
+import sys
+
+import pytest
+from hpcflow.sdk.core.utils import redirect_std_to_file
+
+
+def test_stdout_redirect(tmp_path):
+    file_name = tmp_path / "test.txt"
+    expected = "stdout"
+    with redirect_std_to_file(file_name, mode="w"):
+        print(expected)
+    with file_name.open("r") as fp:
+        contents = fp.read().strip()
+    assert contents == expected
+
+
+def test_stderr_redirect(tmp_path):
+    file_name = tmp_path / "test.txt"
+    expected = "stderr"
+    with redirect_std_to_file(file_name, mode="w"):
+        print(expected, file=sys.stderr)
+    with file_name.open("r") as fp:
+        contents = fp.read().strip()
+    assert contents == expected
+
+
+def test_exception_exits_with_code(tmp_path):
+    file_name = tmp_path / "test.txt"
+    with pytest.raises(SystemExit) as exc:
+        with redirect_std_to_file(file_name, mode="w"):
+            raise ValueError("oh no!")
+    assert exc.value.code == 1
+
+
+def test_exception_prints_to_file(tmp_path):
+    file_name = tmp_path / "test.txt"
+    with pytest.raises(SystemExit):
+        with redirect_std_to_file(file_name, mode="w"):
+            raise ValueError("oh no!")
+    with file_name.open("r") as fp:
+        contents = fp.read().strip()
+    assert 'ValueError("oh no!")' in contents
+
+
+def test_file_not_created(tmp_path):
+    file_name = tmp_path / "test.txt"
+    assert not file_name.is_file()
+    with redirect_std_to_file(file_name, mode="w"):
+        pass
+    assert not file_name.is_file()

hpcflow/tests/workflows/test_directory_structure.py

@@ -0,0 +1,31 @@
+"""Tests concerning the directory structure of a created or submitted workflow"""
+
+import os
+from pathlib import Path
+import pytest
+
+from hpcflow.sdk.core.test_utils import (
+    make_test_data_YAML_workflow,
+    make_workflow_to_run_command,
+)
+
+
+@pytest.mark.integration
+def test_std_stream_file_not_created(tmp_path, new_null_config):
+    """Normally, the app standard stream file should not be written."""
+    wk = make_test_data_YAML_workflow("workflow_1.yaml", path=tmp_path)
+    wk.submit(wait=True, add_to_known=False)
+    run = wk.get_all_EARs()[0]
+    std_stream_path = run.get_app_std_path()
+    assert not std_stream_path.is_file()
+
+
+@pytest.mark.integration
+def test_std_stream_file_created_on_exception_raised(tmp_path, new_null_config):
+    command = 'wkflow_app --std-stream "$HPCFLOW_RUN_STD_PATH" internal noop --raise'
+    wk = make_workflow_to_run_command(command=command, path=tmp_path)
+    wk.submit(wait=True, add_to_known=False)
+    run = wk.get_all_EARs()[0]
+    std_stream_path = run.get_app_std_path()
+    assert std_stream_path.is_file()
+    assert "ValueError: internal noop raised!" in std_stream_path.read_text()

hpcflow/tests/workflows/test_jobscript.py

@@ -1,8 +1,11 @@
 import os
+import sys
 from pathlib import Path
 import pytest
 
 from hpcflow.app import app as hf
+from hpcflow.sdk.core import SKIPPED_EXIT_CODE
+from hpcflow.sdk.core.skip_reason import SkipReason
 
 
 @pytest.mark.integration
@@ -21,3 +24,332 @@ def test_action_exit_code_parsing(null_config, tmp_path: Path, exit_code: int):
         # exit code from bash wraps around:
         exit_code %= 256
     assert recorded_exit == exit_code
+
+
+@pytest.mark.integration
+def test_bad_action_py_script_exit_code(null_config, tmp_path):
+    s1 = hf.TaskSchema(
+        objective="t1",
+        actions=[
+            hf.Action(
+                script="<<script:bad_script.py>>",  # raises SyntaxError
+                script_exe="python_script",
+                environments=[hf.ActionEnvironment(environment="python_env")],
+            )
+        ],
+    )
+    t1 = hf.Task(schema=[s1])
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1], template_name="bad_script_test", path=tmp_path
+    )
+    wk.submit(wait=True, add_to_known=False)
+    recorded_exit = wk.get_EARs_from_IDs([0])[0].exit_code
+    assert recorded_exit == 1
+
+
+@pytest.mark.integration
+@pytest.mark.parametrize("exit_code", [0, 1, 98, -1, -123124])
+def test_action_py_script_specified_exit_code(null_config, tmp_path, exit_code):
+    s1 = hf.TaskSchema(
+        objective="t1",
+        inputs=[hf.SchemaInput("exit_code")],
+        actions=[
+            hf.Action(
+                script="<<script:script_exit_test.py>>",
+                script_exe="python_script",
+                script_data_in="direct",
+                environments=[hf.ActionEnvironment(environment="python_env")],
+            )
+        ],
+    )
+    t1 = hf.Task(schema=[s1], inputs={"exit_code": exit_code})
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1], template_name="script_exit_test", path=tmp_path
+    )
+    wk.submit(wait=True, add_to_known=False)
+    recorded_exit = wk.get_EARs_from_IDs([0])[0].exit_code
+    if os.name == "posix":
+        # exit code from bash wraps around:
+        exit_code %= 256
+    assert recorded_exit == exit_code
+
+
+@pytest.mark.integration
+def test_skipped_action_same_element(null_config, tmp_path):
+    s1 = hf.TaskSchema(
+        objective="t1",
+        inputs=[hf.SchemaInput("p1")],
+        outputs=[hf.SchemaOutput("p2"), hf.SchemaOutput("p3")],
+        actions=[
+            hf.Action(
+                commands=[
+                    hf.Command(
+                        command=f"echo <<parameter:p1>>", stdout="<<parameter:p2>>"
+                    ),
+                    hf.Command(command=f"exit 1"),
+                ],
+            ),
+            hf.Action(  # should be skipped
+                commands=[
+                    hf.Command(
+                        command=f"echo <<parameter:p2>>", stdout="<<parameter:p3>>"
+                    ),
+                    hf.Command(command=f"exit 0"),  # exit code should be ignored
+                ],
+            ),
+        ],
+    )
+    t1 = hf.Task(schema=s1, inputs={"p1": 101})
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1], template_name="test_skip", path=tmp_path
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+
+    runs = wk.get_EARs_from_IDs([0, 1])
+    exit_codes = [i.exit_code for i in runs]
+    is_skipped = [i.skip for i in runs]
+
+    assert exit_codes == [1, SKIPPED_EXIT_CODE]
+    assert is_skipped == [0, 1]
+
+
+@pytest.mark.integration
+def test_two_skipped_actions_same_element(null_config, tmp_path):
+    s1 = hf.TaskSchema(
+        objective="t1",
+        inputs=[hf.SchemaInput("p1")],
+        outputs=[hf.SchemaOutput("p2"), hf.SchemaOutput("p3"), hf.SchemaOutput("p4")],
+        actions=[
+            hf.Action(
+                commands=[
+                    hf.Command(
+                        command=f"echo <<parameter:p1>>", stdout="<<parameter:p2>>"
+                    ),
+                    hf.Command(command=f"exit 1"),
+                ],
+            ),
+            hf.Action(  # should be skipped
+                commands=[
+                    hf.Command(
+                        command=f"echo <<parameter:p2>>", stdout="<<parameter:p3>>"
+                    ),
+                    hf.Command(command=f"exit 0"),  # exit code should be ignored
+                ],
+            ),
+            hf.Action(  # should be skipped
+                commands=[
+                    hf.Command(
+                        command=f"echo <<parameter:p3>>", stdout="<<parameter:p4>>"
+                    ),
+                    hf.Command(command=f"exit 0"),  # exit code should be ignored
+                ],
+            ),
+        ],
+    )
+    t1 = hf.Task(schema=s1, inputs={"p1": 101})
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1], template_name="test_skip_two_actions", path=tmp_path
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+
+    runs = wk.get_EARs_from_IDs([0, 1, 2])
+    exit_codes = [i.exit_code for i in runs]
+    skip_reasons = [i.skip_reason for i in runs]
+
+    assert exit_codes == [1, SKIPPED_EXIT_CODE, SKIPPED_EXIT_CODE]
+    assert skip_reasons == [
+        SkipReason.NOT_SKIPPED,
+        SkipReason.UPSTREAM_FAILURE,
+        SkipReason.UPSTREAM_FAILURE,
+    ]
+
+
+@pytest.mark.integration
+@pytest.mark.skipif(
+    condition=sys.platform == "win32",
+    reason="`combine_jobscript_std` not implemented on Windows.",
+)
+def test_combine_jobscript_std_true(null_config, tmp_path):
+    out_msg = "hello stdout!"
+    err_msg = "hello stderr!"
+    s1 = hf.TaskSchema(
+        objective="t1",
+        actions=[
+            hf.Action(
+                commands=[
+                    hf.Command(command=f'echo "{out_msg}"'),
+                    hf.Command(command=f'>&2 echo "{err_msg}"'),
+                ],
+            )
+        ],
+    )
+    t1 = hf.Task(schema=s1)
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1],
+        template_name="test_combine_jobscript_std",
+        path=tmp_path,
+        resources={"any": {"combine_jobscript_std": True}},
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+
+    jobscript = wk.submissions[0].jobscripts[0]
+
+    assert jobscript.resources.combine_jobscript_std
+
+    out_err_path = jobscript.get_std_out_err_path()
+    out_path = jobscript._get_stdout_path()
+    err_path = jobscript._get_stderr_path()
+
+    assert out_err_path.is_file()
+    assert not out_path.is_file()
+    assert not err_path.is_file()
+
+    assert out_err_path.read_text().strip() == f"{out_msg}\n{err_msg}"
+
+
+@pytest.mark.integration
+def test_combine_jobscript_std_false(null_config, tmp_path):
+    out_msg = "hello stdout!"
+    err_msg = "hello stderr!"
+    s1 = hf.TaskSchema(
+        objective="t1",
+        actions=[
+            hf.Action(
+                commands=[
+                    hf.Command(command=f'echo "{out_msg}"'),
+                    hf.Command(command=f'>&2 echo "{err_msg}"'),
+                ],
+                rules=[
+                    hf.ActionRule(
+                        rule=hf.Rule(
+                            path="resources.os_name",
+                            condition={"value.equal_to": "posix"},
+                        )
+                    )
+                ],
+            ),
+            hf.Action(
+                commands=[
+                    hf.Command(command=f'Write-Output "{out_msg}"'),
+                    hf.Command(command=f'$host.ui.WriteErrorLine("{err_msg}")'),
+                ],
+                rules=[
+                    hf.ActionRule(
+                        rule=hf.Rule(
+                            path="resources.os_name",
+                            condition={"value.equal_to": "nt"},
+                        )
+                    )
+                ],
+            ),
+        ],
+    )
+    t1 = hf.Task(schema=s1)
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1],
+        template_name="test_combine_jobscript_std",
+        path=tmp_path,
+        resources={"any": {"combine_jobscript_std": False}},
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+
+    jobscript = wk.submissions[0].jobscripts[0]
+
+    assert not jobscript.resources.combine_jobscript_std
+
+    out_err_path = jobscript.direct_std_out_err_path
+    out_path = jobscript.direct_stdout_path
+    err_path = jobscript.direct_stderr_path
+
+    assert not out_err_path.is_file()
+    assert out_path.is_file()
+    assert err_path.is_file()
+
+    assert out_path.read_text().strip() == out_msg
+    assert err_path.read_text().strip() == err_msg
+
+
+@pytest.mark.integration
+def test_write_app_logs_true(null_config, tmp_path):
+
+    p1_vals = [101, 102]
+    t1 = hf.Task(
+        schema=hf.task_schemas.test_t1_conditional_OS,
+        sequences=[hf.ValueSequence("inputs.p1", values=p1_vals)],
+    )
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1],
+        template_name="test_write_app_logs",
+        path=tmp_path,
+        config={
+            "log_file_level": "debug"
+        },  # ensure there is something to write to the log
+        resources={"any": {"write_app_logs": True}},
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+
+    run_0 = wk.tasks[0].elements[0].action_runs[0]
+    run_1 = wk.tasks[0].elements[1].action_runs[0]
+
+    run_0_log_path = run_0.get_app_log_path()
+    run_1_log_path = run_1.get_app_log_path()
+
+    assert run_0_log_path.is_file()
+    assert run_1_log_path.is_file()
+
+
+@pytest.mark.integration
+def test_write_app_logs_false(null_config, tmp_path):
+
+    p1_vals = [101, 102]
+    t1 = hf.Task(
+        schema=hf.task_schemas.test_t1_conditional_OS,
+        sequences=[hf.ValueSequence("inputs.p1", values=p1_vals)],
+    )
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1],
+        template_name="test_write_app_logs",
+        path=tmp_path,
+        config={
+            "log_file_level": "debug"
+        },  # ensure there is something to write to the log
+        resources={"any": {"write_app_logs": False}},
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+
+    run_0 = wk.tasks[0].elements[0].action_runs[0]
+    run_1 = wk.tasks[0].elements[1].action_runs[0]
+
+    run_0_log_path = run_0.get_app_log_path()
+    run_1_log_path = run_1.get_app_log_path()
+
+    assert not wk.submissions[0].app_log_path.is_dir()
+    assert not run_0_log_path.is_file()
+    assert not run_1_log_path.is_file()
+
+
+@pytest.mark.integration
+def test_jobscript_start_end_times_equal_to_first_and_last_run_start_end_times(
+    null_config, tmp_path
+):
+
+    t1 = hf.Task(
+        schema=hf.task_schemas.test_t1_conditional_OS,
+        sequences=[hf.ValueSequence(path="inputs.p1", values=list(range(2)))],
+    )
+    wk = hf.Workflow.from_template_data(
+        template_name="test_jobscript_start_end_times",
+        path=tmp_path,
+        tasks=[t1],
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+
+    js = wk.submissions[0].jobscripts[0]
+    runs = wk.get_all_EARs()
+    assert len(runs) == 2
+
+    # jobsript has two runs, so start time should be start time of first run:
+    assert js.start_time == runs[0].start_time
+
+    # ...and end time should be end time of second run:
+    assert js.end_time == runs[1].end_time

hpcflow/tests/workflows/test_run_status.py

@@ -0,0 +1,198 @@
+import os
+from textwrap import dedent
+
+import pytest
+
+from hpcflow.app import app as hf
+from hpcflow.sdk.core.actions import EARStatus
+
+
+@pytest.mark.integration
+@pytest.mark.parametrize("combine_scripts", [True, False])
+def test_run_status_fail_when_missing_script_output_data_file(
+    null_config, tmp_path, combine_scripts
+):
+
+    s1 = hf.TaskSchema(
+        objective="t1",
+        outputs=[hf.SchemaOutput(parameter=hf.Parameter("p1"))],
+        actions=[
+            hf.Action(
+                script="<<script:main_script_test_json_out_FAIL.py>>",
+                script_data_out="json",
+                script_exe="python_script",
+                environments=[hf.ActionEnvironment(environment="python_env")],
+                requires_dir=True,
+            )
+        ],
+    )
+
+    tasks = [
+        hf.Task(s1),  # will fail due to not generaing an output data file
+    ]
+
+    wk = hf.Workflow.from_template_data(
+        template_name="test_run_status_fail_missing_script_output_file",
+        path=tmp_path,
+        tasks=tasks,
+        resources={
+            "any": {
+                "write_app_logs": True,
+                "skip_downstream_on_failure": False,
+                "combine_scripts": combine_scripts,
+            }
+        },
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+    runs = wk.get_all_EARs()
+    assert runs[0].status is EARStatus.error
+
+
+@pytest.mark.integration
+@pytest.mark.parametrize("combine_scripts", [True, False])
+def test_run_status_fail_when_missing_script_output_data_file_OFP_fail(
+    null_config, tmp_path, combine_scripts
+):
+
+    out_file_name = "my_output_file.txt"
+    out_file = hf.FileSpec(label="my_output_file", name=out_file_name)
+
+    if os.name == "nt":
+        cmd = f"Set-Content -Path {out_file_name} -Value (<<parameter:p1>> + 100)"
+    else:
+        cmd = f"echo $(( <<parameter:p1>> + 100 )) > {out_file_name}"
+
+    # this script parses the output file but then deletes this file so it can't be saved!
+    act = hf.Action(
+        commands=[hf.Command(cmd)],
+        output_file_parsers=[
+            hf.OutputFileParser(
+                output_files=[out_file],
+                output=hf.Parameter("p2"),
+                script="<<script:output_file_parser_basic_FAIL.py>>",
+                save_files=True,
+            ),
+        ],
+        environments=[hf.ActionEnvironment(environment="python_env")],
+    )
+
+    s1 = hf.TaskSchema(
+        objective="t1",
+        inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
+        outputs=[hf.SchemaInput(parameter=hf.Parameter("p2"))],
+        actions=[act],
+    )
+    t1 = hf.Task(schema=s1, inputs={"p1": 100})
+
+    wk = hf.Workflow.from_template_data(
+        template_name="test_run_status_fail_missing_OFP_save_file",
+        path=tmp_path,
+        tasks=[t1],
+        resources={
+            "any": {
+                "write_app_logs": True,
+                "skip_downstream_on_failure": False,
+                "combine_scripts": combine_scripts,
+            }
+        },
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+    runs = wk.get_all_EARs()
+    assert runs[0].status is EARStatus.success
+    assert runs[1].status is EARStatus.error
+
+
+@pytest.mark.integration
+@pytest.mark.parametrize("combine_scripts", [True, False])
+def test_run_status_fail_when_missing_IFG_input_file(
+    null_config, tmp_path, combine_scripts
+):
+
+    inp_file = hf.FileSpec(label="my_input_file", name="my_input_file.txt")
+
+    if os.name == "nt":
+        cmd = dedent(
+            """\
+            try {
+                Get-Content "<<file:my_input_file>>" -ErrorAction Stop
+            } catch {
+                Write-Host "File does not exist."
+                exit 1 
+            }
+        """
+        )
+    else:
+        cmd = "cat <<file:my_input_file>>"
+
+    # this script silently fails to generate the input file!
+    s1 = hf.TaskSchema(
+        objective="t1",
+        inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
+        actions=[
+            hf.Action(
+                commands=[hf.Command(cmd)],
+                input_file_generators=[
+                    hf.InputFileGenerator(
+                        input_file=inp_file,
+                        inputs=[hf.Parameter("p1")],
+                        script="<<script:input_file_generator_basic_FAIL.py>>",
+                    ),
+                ],
+                environments=[hf.ActionEnvironment(environment="python_env")],
+            )
+        ],
+    )
+    t1 = hf.Task(schema=s1, inputs={"p1": 100})
+    wk = hf.Workflow.from_template_data(
+        template_name="test_run_status_fail_missing_IFG_save_file",
+        path=tmp_path,
+        tasks=[t1],
+        resources={
+            "any": {
+                "write_app_logs": True,
+                "skip_downstream_on_failure": False,
+                "combine_scripts": combine_scripts,
+            }
+        },
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+    runs = wk.get_all_EARs()
+    assert runs[0].status is EARStatus.error  # no input file to save
+    assert runs[1].status is EARStatus.error  # no input file to consume
+
+
+@pytest.mark.integration
+@pytest.mark.parametrize("combine_scripts", [True, False])
+def test_run_status_fail_when_action_save_file(null_config, tmp_path, combine_scripts):
+
+    my_file = hf.FileSpec(label="my_file", name="my_file.txt")
+
+    # this script does not generate a file that can be saved:
+    s1 = hf.TaskSchema(
+        objective="t1",
+        actions=[
+            hf.Action(
+                script="<<script:do_nothing.py>>",
+                script_exe="python_script",
+                environments=[hf.ActionEnvironment(environment="python_env")],
+                requires_dir=True,
+                save_files=[my_file],
+            )
+        ],
+    )
+    t1 = hf.Task(schema=s1)
+    wk = hf.Workflow.from_template_data(
+        template_name="test_run_status_fail_missing_action_save_file",
+        path=tmp_path,
+        tasks=[t1],
+        resources={
+            "any": {
+                "write_app_logs": True,
+                "skip_downstream_on_failure": False,
+                "combine_scripts": combine_scripts,
+            }
+        },
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+    runs = wk.get_all_EARs()
+    assert runs[0].status is EARStatus.error  # no file to save