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

hpcflow/tests/unit/test_resources.py

@@ -1,16 +1,18 @@
+from __future__ import annotations
 import os
+from pathlib import Path
 import pytest
 from hpcflow.app import app as hf
 from hpcflow.sdk.core.errors import UnsupportedSchedulerError
 
 
-def test_init_scope_equivalence_simple():
+def test_init_scope_equivalence_simple() -> None:
     rs1 = hf.ResourceSpec(scope=hf.ActionScope.any(), num_cores=1)
     rs2 = hf.ResourceSpec(scope="any", num_cores=1)
     assert rs1 == rs2
 
 
-def test_init_scope_equivalence_with_kwargs():
+def test_init_scope_equivalence_with_kwargs() -> None:
     rs1 = hf.ResourceSpec(
         scope=hf.ActionScope.input_file_generator(file="my_file"), num_cores=1
     )
@@ -18,32 +20,32 @@ def test_init_scope_equivalence_with_kwargs():
     assert rs1 == rs2
 
 
-def test_init_no_args():
+def test_init_no_args() -> None:
     rs1 = hf.ResourceSpec()
     rs2 = hf.ResourceSpec(scope="any")
     assert rs1 == rs2
 
 
-def test_resource_list_raise_on_identical_scopes():
+def test_resource_list_raise_on_identical_scopes() -> None:
     with pytest.raises(ValueError):
         hf.ResourceList.normalise([{"scope": "any"}, {"scope": "any"}])
 
 
-def test_merge_other_same_scope():
+def test_merge_other_same_scope() -> None:
     res_lst_1 = hf.ResourceList.from_json_like({"any": {"num_cores": 1}})
     res_lst_2 = hf.ResourceList.from_json_like({"any": {}})
     res_lst_2.merge_other(res_lst_1)
     assert res_lst_2 == hf.ResourceList.from_json_like({"any": {"num_cores": 1}})
 
 
-def test_merge_other_same_scope_no_overwrite():
+def test_merge_other_same_scope_no_overwrite() -> None:
     res_lst_1 = hf.ResourceList.from_json_like({"any": {"num_cores": 1}})
     res_lst_2 = hf.ResourceList.from_json_like({"any": {"num_cores": 2}})
     res_lst_2.merge_other(res_lst_1)
     assert res_lst_2 == hf.ResourceList.from_json_like({"any": {"num_cores": 2}})
 
 
-def test_merge_other_multi_scope():
+def test_merge_other_multi_scope() -> None:
     res_lst_1 = hf.ResourceList.from_json_like({"any": {"num_cores": 1}})
     res_lst_2 = hf.ResourceList.from_json_like({"any": {}, "main": {"num_cores": 3}})
     res_lst_2.merge_other(res_lst_1)
@@ -53,7 +55,7 @@ def test_merge_other_multi_scope():
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_merge_other_persistent_workflow_reload(null_config, tmp_path, store):
+def test_merge_other_persistent_workflow_reload(null_config, tmp_path: Path, store: str):
     wkt = hf.WorkflowTemplate(
         name="test_load",
         resources={"any": {"num_cores": 2}},
@@ -70,7 +72,7 @@ def test_merge_other_persistent_workflow_reload(null_config, tmp_path, store):
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_use_persistent_resource_spec(null_config, tmp_path, store):
+def test_use_persistent_resource_spec(null_config, tmp_path: Path, store: str):
     # create a workflow from which we can use a resource spec in a new workflow:
     num_cores_check = 2
     wk_base = hf.Workflow.from_template_data(
@@ -104,7 +106,7 @@ def test_use_persistent_resource_spec(null_config, tmp_path, store):
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_use_persistent_resource_list(null_config, tmp_path, store):
+def test_use_persistent_resource_list(null_config, tmp_path: Path, store: str):
     # create a workflow from which we can use the resource list in a new workflow:
     num_cores_check = 2
     wk_base = hf.Workflow.from_template_data(
@@ -138,7 +140,7 @@ def test_use_persistent_resource_list(null_config, tmp_path, store):
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_default_scheduler_set(new_null_config, tmp_path, store):
+def test_default_scheduler_set(new_null_config, tmp_path: Path, store: str):
     wk = hf.Workflow.from_template_data(
         template_name="wk",
         path=tmp_path,
@@ -154,21 +156,21 @@ def test_default_scheduler_set(new_null_config, tmp_path, store):
     assert wk.submissions[0].jobscripts[0].scheduler_name == hf.config.default_scheduler
 
 
-def test_scheduler_case_insensitive(null_config):
+def test_scheduler_case_insensitive(null_config) -> None:
     rs1 = hf.ResourceSpec(scheduler="direct")
     rs2 = hf.ResourceSpec(scheduler="dIrEcT")
     assert rs1 == rs2
     assert rs1.scheduler == rs2.scheduler == "direct"
 
 
-def test_scheduler_strip(null_config):
+def test_scheduler_strip(null_config) -> None:
     rs1 = hf.ResourceSpec(scheduler="  direct ")
     rs2 = hf.ResourceSpec(scheduler="direct")
     assert rs1 == rs2
     assert rs1.scheduler == rs2.scheduler == "direct"
 
 
-def test_shell_case_insensitive(null_config):
+def test_shell_case_insensitive(null_config) -> None:
     shell_name = "bash" if os.name == "posix" else "powershell"
     shell_name_title = shell_name
     n = shell_name_title[0]
@@ -180,7 +182,7 @@ def test_shell_case_insensitive(null_config):
     assert rs1.shell == rs2.shell == shell_name
 
 
-def test_shell_strip(null_config):
+def test_shell_strip(null_config) -> None:
     shell_name = "bash" if os.name == "posix" else "powershell"
     rs1 = hf.ResourceSpec(shell=f"  {shell_name} ")
     rs2 = hf.ResourceSpec(shell=shell_name)
@@ -195,14 +197,14 @@ def test_os_name_case_insensitive(null_config):
     assert rs1.os_name == rs2.os_name == "nt"
 
 
-def test_os_name_strip(null_config):
+def test_os_name_strip(null_config) -> None:
     rs1 = hf.ResourceSpec(os_name="  nt ")
     rs2 = hf.ResourceSpec(os_name="nt")
     assert rs1 == rs2
     assert rs1.os_name == rs2.os_name == "nt"
 
 
-def test_raise_on_unsupported_scheduler(new_null_config, tmp_path):
+def test_raise_on_unsupported_scheduler(new_null_config, tmp_path: Path):
     # slurm not supported by default config file:
     wk = hf.Workflow.from_template_data(
         template_name="wk1",
@@ -219,7 +221,7 @@ def test_raise_on_unsupported_scheduler(new_null_config, tmp_path):
         wk.add_submission()
 
 
-def test_can_use_non_default_scheduler(new_null_config, tmp_path):
+def test_can_use_non_default_scheduler(new_null_config, tmp_path: Path):
     # for either OS choose a compatible scheduler not set by default:
     if os.name == "nt":
         opt_scheduler = "direct_posix"  # i.e for WSL

hpcflow/tests/unit/test_run.py

@@ -1,7 +1,16 @@
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from pathlib import Path
 from hpcflow.app import app as hf
+from hpcflow.sdk.core.actions import SkipReason
+from hpcflow.sdk.core.test_utils import make_workflow_to_run_command
 
 
-def test_compose_commands_no_shell_var(null_config, tmp_path):
+def test_compose_commands_no_shell_var(null_config, tmp_path: Path):
     ts = hf.TaskSchema(
         objective="test_compose_commands",
         actions=[hf.Action(commands=[hf.Command(command="Start-Sleep 10")])],
@@ -12,13 +21,14 @@ def test_compose_commands_no_shell_var(null_config, tmp_path):
         tasks=[hf.Task(schema=ts)],
     )
     sub = wk.add_submission()
+    assert sub is not None
     js = sub.jobscripts[0]
     run = wk.tasks[0].elements[0].iterations[0].action_runs[0]
-    _, shell_vars = run.compose_commands(jobscript=js, JS_action_idx=0)
+    _, shell_vars = run.compose_commands(environments=sub.environments, shell=js.shell)
     assert shell_vars == {0: []}
 
 
-def test_compose_commands_single_shell_var(null_config, tmp_path):
+def test_compose_commands_single_shell_var(null_config, tmp_path: Path):
     ts = hf.TaskSchema(
         objective="test_compose_commands",
         inputs=[hf.SchemaInput("p1")],
@@ -40,13 +50,14 @@ def test_compose_commands_single_shell_var(null_config, tmp_path):
         tasks=[hf.Task(schema=ts, inputs={"p1": 101})],
     )
     sub = wk.add_submission()
+    assert sub is not None
     js = sub.jobscripts[0]
     run = wk.tasks[0].elements[0].iterations[0].action_runs[0]
-    _, shell_vars = run.compose_commands(jobscript=js, JS_action_idx=0)
+    _, shell_vars = run.compose_commands(environments=sub.environments, shell=js.shell)
     assert shell_vars == {0: [("outputs.p1", "parameter_p1", "stdout")]}
 
 
-def test_compose_commands_multi_single_shell_var(null_config, tmp_path):
+def test_compose_commands_multi_single_shell_var(null_config, tmp_path: Path):
     ts = hf.TaskSchema(
         objective="test_compose_commands",
         inputs=[hf.SchemaInput("p1")],
@@ -69,7 +80,107 @@ def test_compose_commands_multi_single_shell_var(null_config, tmp_path):
         tasks=[hf.Task(schema=ts, inputs={"p1": 101})],
     )
     sub = wk.add_submission()
+    assert sub is not None
     js = sub.jobscripts[0]
     run = wk.tasks[0].elements[0].iterations[0].action_runs[0]
-    _, shell_vars = run.compose_commands(jobscript=js, JS_action_idx=0)
+    _, shell_vars = run.compose_commands(environments=sub.environments, shell=js.shell)
     assert shell_vars == {0: [], 1: [("outputs.p1", "parameter_p1", "stdout")]}
+
+
+@pytest.mark.integration
+def test_run_dir_diff_new_file(null_config, tmp_path):
+    if os.name == "nt":
+        command = "New-Item -Path 'new_file.txt' -ItemType File"
+    else:
+        command = "touch new_file.txt"
+    wk = make_workflow_to_run_command(
+        command=command,
+        requires_dir=True,
+        path=tmp_path,
+        name="w2",
+        overwrite=True,
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+    assert wk.get_all_EARs()[0].dir_diff.files_created == ["new_file.txt"]
+
+
+@pytest.mark.integration
+def test_run_skip_reason_upstream_failure(null_config, tmp_path):
+    ts = hf.TaskSchema(
+        objective="t1",
+        inputs=[hf.SchemaInput("p1")],
+        outputs=[hf.SchemaInput("p2")],
+        actions=[
+            hf.Action(
+                commands=[
+                    hf.Command(
+                        command="echo $(( <<parameter:p1>> + 100 ))",
+                        stdout="<<parameter:p2>>",
+                    ),
+                    hf.Command(command="exit 1"),
+                ]
+            ),
+            hf.Action(
+                commands=[
+                    hf.Command(
+                        command="echo $(( <<parameter:p2>> + 100 ))",
+                        stdout="<<parameter:p2>>",
+                    ),
+                ]
+            ),  # should be skipped due to failure of action 0
+        ],
+    )
+    wk = hf.Workflow.from_template_data(
+        template_name="test_skip_reason",
+        path=tmp_path,
+        tasks=[hf.Task(schema=ts, inputs={"p1": 100})],
+    )
+    wk.submit(wait=True, add_to_known=False, status=False)
+    runs = wk.get_all_EARs()
+    assert not runs[0].success
+    assert not runs[1].success
+    assert runs[0].skip_reason is SkipReason.NOT_SKIPPED
+    assert runs[1].skip_reason is SkipReason.UPSTREAM_FAILURE
+
+
+@pytest.mark.integration
+def test_run_skip_reason_loop_termination(null_config, tmp_path):
+    ts = hf.TaskSchema(
+        objective="t1",
+        inputs=[hf.SchemaInput("p1")],
+        outputs=[hf.SchemaInput("p1")],
+        actions=[
+            hf.Action(
+                commands=[
+                    hf.Command(
+                        command="echo $(( <<parameter:p1>> + 100 ))",
+                        stdout="<<int(parameter:p1)>>",
+                    ),
+                ]
+            ),
+        ],
+    )
+    loop_term = hf.Rule(path="outputs.p1", condition={"value.equal_to": 300})
+    wk = hf.Workflow.from_template_data(
+        template_name="test_skip_reason",
+        path=tmp_path,
+        tasks=[hf.Task(schema=ts, inputs={"p1": 100})],
+        loops=[
+            hf.Loop(name="my_loop", tasks=[0], termination=loop_term, num_iterations=3)
+        ],
+    )
+    # loop should terminate after the second iteration
+    wk.submit(wait=True, add_to_known=False, status=False)
+    runs = wk.get_all_EARs()
+
+    assert runs[0].get("outputs.p1") == 200
+    assert runs[1].get("outputs.p1") == 300
+    assert not runs[2].get("outputs.p1")
+
+    assert runs[0].success
+    assert runs[1].success
+    assert not runs[2].success
+
+    assert runs[0].skip_reason is SkipReason.NOT_SKIPPED
+    assert runs[1].skip_reason is SkipReason.NOT_SKIPPED
+    assert runs[2].skip_reason is SkipReason.LOOP_TERMINATION

hpcflow/tests/unit/test_run_directories.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+import pytest
+from hpcflow.app import app as hf
+from hpcflow.sdk.core.test_utils import make_workflow
+
+
+@pytest.mark.parametrize("store", ["json", "zarr"])
+def test_run_directories(null_config, tmp_path, store):
+    wk = make_workflow(
+        schemas_spec=[
+            [{"p1": None}, ("p1",), "t1"],
+            [{"p2": None}, ("p2",), "t2", {"requires_dir": True}],
+        ],
+        local_inputs={0: ("p1",)},
+        local_sequences={1: [("inputs.p2", 2, 0)]},
+        path=tmp_path,
+        store=store,
+    )
+    lp_0 = hf.Loop(name="my_loop", tasks=[1], num_iterations=2)
+    wk.add_loop(lp_0)
+    sub = wk.add_submission()  # populates run directories
+
+    run_dirs = wk.get_run_directories()
+
+    assert run_dirs[0] is None
+    assert str(run_dirs[1]) == str(Path(wk.path).joinpath("execute/t_1/e_0/i_0"))
+    assert str(run_dirs[2]) == str(Path(wk.path).joinpath("execute/t_1/e_1/i_0"))
+    assert str(run_dirs[3]) == str(Path(wk.path).joinpath("execute/t_1/e_0/i_1"))
+    assert str(run_dirs[4]) == str(Path(wk.path).joinpath("execute/t_1/e_1/i_1"))

hpcflow/tests/unit/test_runtime.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
 from hpcflow.app import app as hf
 
 
-def test_in_pytest_if_not_frozen():
+def test_in_pytest_if_not_frozen() -> None:
     """This is to check we can get the correct invocation command when running non-frozen
     tests (when frozen the invocation command is just the executable file)."""
     if not hf.run_time_info.is_frozen:

hpcflow/tests/unit/test_schema_input.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+from pathlib import Path
 import pytest
 
 from hpcflow.app import app as hf
@@ -11,19 +13,19 @@ def null_config(tmp_path):
         hf.load_config(config_dir=tmp_path)
 
 
-def test_null_default_value(null_config):
+def test_null_default_value(null_config) -> None:
     p1 = hf.Parameter("p1")
     p1_inp = hf.SchemaInput(parameter=p1)
     assert "default_value" not in p1_inp.labels[""]
 
 
-def test_null_default_value_property(null_config):
+def test_null_default_value_property(null_config) -> None:
     p1 = hf.Parameter("p1")
     p1_inp = hf.SchemaInput(parameter=p1)
     assert p1_inp.default_value is NullDefault.NULL
 
 
-def test_none_default_value(null_config):
+def test_none_default_value(null_config) -> None:
     """A `None` default value is set with a value of `None`"""
     p1 = hf.Parameter("p1")
     p1_inp = hf.SchemaInput(parameter=p1, default_value=None)
@@ -32,7 +34,7 @@ def test_none_default_value(null_config):
     assert p1_inp.labels[""]["default_value"].value == def_val_exp.value
 
 
-def test_from_json_like_labels_and_default(null_config):
+def test_from_json_like_labels_and_default(null_config) -> None:
     json_like = {
         "parameter": "p1",
         "labels": {"0": {}},
@@ -45,7 +47,7 @@ def test_from_json_like_labels_and_default(null_config):
     assert inp.labels["0"]["default_value"].value == None
 
 
-def test_element_get_removes_schema_param_trivial_label(null_config, tmp_path):
+def test_element_get_removes_schema_param_trivial_label(null_config, tmp_path: Path):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -61,7 +63,7 @@ def test_element_get_removes_schema_param_trivial_label(null_config, tmp_path):
     assert wk.tasks[0].elements[0].get("inputs") == {"p1": p1_val}
 
 
-def test_element_inputs_removes_schema_param_trivial_label(null_config, tmp_path):
+def test_element_inputs_removes_schema_param_trivial_label(null_config, tmp_path: Path):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -91,7 +93,9 @@ def test_element_inputs_removes_schema_param_trivial_label(null_config, tmp_path
     assert element.iterations[0].action_runs[0].inputs._get_prefixed_names() == ["p1"]
 
 
-def test_element_get_does_not_removes_multiple_schema_param_label(null_config, tmp_path):
+def test_element_get_does_not_removes_multiple_schema_param_label(
+    null_config, tmp_path: Path
+):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -109,7 +113,7 @@ def test_element_get_does_not_removes_multiple_schema_param_label(null_config, t
 
 
 def test_element_inputs_does_not_remove_multiple_schema_param_label(
-    null_config, tmp_path
+    null_config, tmp_path: Path
 ):
     p1_val = 101
     label = "my_label"
@@ -142,7 +146,9 @@ def test_element_inputs_does_not_remove_multiple_schema_param_label(
     ]
 
 
-def test_get_input_values_for_multiple_schema_input_single_label(null_config, tmp_path):
+def test_get_input_values_for_multiple_schema_input_single_label(
+    null_config, tmp_path: Path
+):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -170,7 +176,7 @@ def test_get_input_values_for_multiple_schema_input_single_label(null_config, tm
     assert run.get_input_values() == {"p2": 201, "p1": 101}
 
 
-def test_get_input_values_subset(null_config, tmp_path):
+def test_get_input_values_subset(null_config, tmp_path: Path):
     p1_val = 101
     s1 = hf.TaskSchema(
         objective="t1",
@@ -195,7 +201,7 @@ def test_get_input_values_subset(null_config, tmp_path):
     assert run.get_input_values(inputs=("p1",)) == {"p1": 101}
 
 
-def test_get_input_values_subset_labelled_label_dict_False(null_config, tmp_path):
+def test_get_input_values_subset_labelled_label_dict_False(null_config, tmp_path: Path):
     p1_val = 101
     s1 = hf.TaskSchema(
         objective="t1",
@@ -229,7 +235,7 @@ def test_get_input_values_subset_labelled_label_dict_False(null_config, tmp_path
     assert run.get_input_values(inputs=("p1[one]",), label_dict=False) == {"p1[one]": 101}
 
 
-def test_get_input_values_subset_labelled_label_dict_True(null_config, tmp_path):
+def test_get_input_values_subset_labelled_label_dict_True(null_config, tmp_path: Path):
     p1_val = 101
     s1 = hf.TaskSchema(
         objective="t1",
@@ -265,7 +271,7 @@ def test_get_input_values_subset_labelled_label_dict_True(null_config, tmp_path)
     }
 
 
-def test_get_input_values_for_multiple_schema_input(null_config, tmp_path):
+def test_get_input_values_for_multiple_schema_input(null_config, tmp_path: Path):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -293,7 +299,9 @@ def test_get_input_values_for_multiple_schema_input(null_config, tmp_path):
     assert run.get_input_values() == {"p2": 201, "p1": {label: 101}}
 
 
-def test_get_input_values_for_multiple_schema_input_with_object(null_config, tmp_path):
+def test_get_input_values_for_multiple_schema_input_with_object(
+    null_config, tmp_path: Path
+):
     p1_val = P1(a=101)
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -324,7 +332,7 @@ def test_get_input_values_for_multiple_schema_input_with_object(null_config, tmp
 
 
 @pytest.mark.integration
-def test_get_input_values_all_iterations(null_config, tmp_path):
+def test_get_input_values_all_iterations(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],

hpcflow/tests/unit/test_shell.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
 from hpcflow.sdk.submission.shells import ALL_SHELLS
 
 
-def test_process_JS_header_args_app_invoc_windows_powershell():
+def test_process_JS_header_args_app_invoc_windows_powershell() -> None:
     """
     Three types of invocation commands exist:
       1. the frozen app executable
@@ -40,7 +41,7 @@ def test_process_JS_header_args_app_invoc_windows_powershell():
         assert processed["app_invoc"] == j
 
 
-def test_process_JS_header_args_app_invoc_bash():
+def test_process_JS_header_args_app_invoc_bash() -> None:
     """
     Three types of invocation commands exist:
       1. the frozen app executable
@@ -76,3 +77,23 @@ def test_process_JS_header_args_app_invoc_bash():
     for i, j in zip(app_invocs, expected):
         processed = shell.process_JS_header_args({"app_invoc": i})
         assert processed["app_invoc"] == j
+
+
+def test_format_array_powershell():
+    shell = ALL_SHELLS["powershell"]["nt"]()
+    assert shell.format_array([1, 2, 3]) == "@(1, 2, 3)"
+
+
+def test_format_array_get_item_powershell():
+    shell = ALL_SHELLS["powershell"]["nt"]()
+    assert shell.format_array_get_item("my_arr", 3) == "$my_arr[3]"
+
+
+def test_format_array_bash():
+    shell = ALL_SHELLS["bash"]["posix"]()
+    assert shell.format_array([1, 2, 3]) == "(1 2 3)"
+
+
+def test_format_array_get_item_bash():
+    shell = ALL_SHELLS["bash"]["posix"]()
+    assert shell.format_array_get_item("my_arr", 3) == r"${my_arr[3]}"

hpcflow/tests/unit/test_slurm.py

@@ -1,37 +1,38 @@
+from __future__ import annotations
 from hpcflow.sdk.submission.schedulers.slurm import SlurmPosix
 
 
-def test_parse_job_ID_simple():
+def test_parse_job_ID_simple() -> None:
     assert SlurmPosix._parse_job_IDs("123") == ("123", None)
 
 
-def test_parse_job_ID_simple_array_item():
+def test_parse_job_ID_simple_array_item() -> None:
     assert SlurmPosix._parse_job_IDs("123_10") == ("123", [9])
 
 
-def test_parse_job_ID_array_simple_range():
+def test_parse_job_ID_array_simple_range() -> None:
     assert SlurmPosix._parse_job_IDs("3397752_[9-11]") == ("3397752", [8, 9, 10])
 
 
-def test_parse_job_ID_array_simple_multiple_range():
+def test_parse_job_ID_array_simple_multiple_range() -> None:
     assert SlurmPosix._parse_job_IDs("49203_[3-5,9-11]") == (
         "49203",
         [2, 3, 4, 8, 9, 10],
     )
 
 
-def test_parse_job_ID_array_simple_mixed_range():
+def test_parse_job_ID_array_simple_mixed_range() -> None:
     assert SlurmPosix._parse_job_IDs("30627658_[5,8-10]") == (
         "30627658",
         [4, 7, 8, 9],
     )
 
 
-def test_parse_job_ID_array_simple_range_with_max_concurrent():
+def test_parse_job_ID_array_simple_range_with_max_concurrent() -> None:
     assert SlurmPosix._parse_job_IDs("3397752_[9-11%2]") == ("3397752", [8, 9, 10])
 
 
-def test_parse_job_ID_array_simple_multiple_range_max_concurrent():
+def test_parse_job_ID_array_simple_multiple_range_max_concurrent() -> None:
     assert SlurmPosix._parse_job_IDs("49203_[3-5%1,9-11%2]") == (
         "49203",
         [2, 3, 4, 8, 9, 10],