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

hpcflow/tests/unit/test_action_rule.py

@@ -1,16 +1,21 @@
+from __future__ import annotations
+from typing import cast, TYPE_CHECKING
 from hpcflow.app import app as hf
 
+if TYPE_CHECKING:
+    from hpcflow.sdk.core.types import RuleArgs
 
-def test_equivalent_init_with_rule_args():
-    rule_args = {
+
+def test_equivalent_init_with_rule_args() -> None:
+    rule_args: RuleArgs = {
         "path": "resources.os_name",
         "condition": {"value.equal_to": "posix"},
     }
     assert hf.ActionRule(rule=hf.Rule(**rule_args)) == hf.ActionRule(**rule_args)
 
 
-def test_equivalent_init_json_like_with_rule_args():
-    rule_args = {
+def test_equivalent_init_json_like_with_rule_args() -> None:
+    rule_args: dict = {
         "path": "resources.os_name",
         "condition": {"value.equal_to": "posix"},
     }

hpcflow/tests/unit/test_app.py

@@ -1,37 +1,45 @@
+from __future__ import annotations
+from pathlib import Path
 import sys
+from typing import TYPE_CHECKING
 import pytest
 import requests
 
 from hpcflow.app import app as hf
 
+if TYPE_CHECKING:
+    from hpcflow.sdk.core.actions import Action, ActionEnvironment
+
 
 @pytest.fixture
-def act_env_1():
+def act_env_1() -> ActionEnvironment:
     return hf.ActionEnvironment(environment="env_1")
 
 
 @pytest.fixture
-def act_1(act_env_1):
+def act_1(act_env_1) -> Action:
     return hf.Action(
         commands=[hf.Command("<<parameter:p1>>")],
         environments=[act_env_1],
     )
 
 
-def test_shared_data_from_json_like_with_shared_data_dependency(act_1):
+def test_shared_data_from_json_like_with_shared_data_dependency(act_1: Action):
     """Check we can generate some shared data objects where one depends on another."""
 
     p1 = hf.Parameter("p1")
     p1._set_hash()
     p1_hash = p1._hash_value
+    assert p1_hash is not None
 
     ts1 = hf.TaskSchema(objective="ts1", actions=[act_1], inputs=[p1])
     ts1._set_hash()
     ts1_hash = ts1._hash_value
+    assert ts1_hash is not None
 
     env_label = ts1.actions[0].environments[0].environment
 
-    shared_data_json = {
+    shared_data_json: dict[str, dict] = {
         "parameters": {
             p1_hash: {
                 "is_file": p1.is_file,
@@ -85,7 +93,7 @@ def test_shared_data_from_json_like_with_shared_data_dependency(act_1):
     ] == hf.TaskSchemasList([ts1])
 
 
-def test_get_demo_data_manifest(null_config):
+def test_get_demo_data_manifest(null_config) -> None:
     hf.get_demo_data_files_manifest()
 
 
@@ -97,9 +105,28 @@ def test_get_demo_data_manifest(null_config):
         "retrieving demo data from GitHub."
     ),
 )
-def test_get_demo_data_cache(null_config):
+def test_get_demo_data_cache(null_config) -> None:
     hf.clear_demo_data_cache_dir()
     hf.cache_demo_data_file("text_file.txt")
     with hf.demo_data_cache_dir.joinpath("text_file.txt").open("rt") as fh:
         contents = fh.read()
     assert contents == "\n".join(f"{i}" for i in range(1, 11)) + "\n"
+
+
+def test_list_demo_workflows():
+    # sanity checks
+    lst = hf.list_demo_workflows()
+    assert isinstance(lst, tuple)
+    assert all(isinstance(i, str) and "." not in i for i in lst)  # no extension included
+
+
+def test_get_demo_workflows():
+    # sanity checks
+    lst = hf.list_demo_workflows()
+    demo_paths = hf._get_demo_workflows()
+    # keys should be those in the list:
+    assert sorted(list(lst)) == sorted(list(demo_paths.keys()))
+
+    # values should be distinct, absolute paths:
+    assert all(isinstance(i, Path) and i.is_absolute() for i in demo_paths.values())
+    assert len(set(demo_paths.values())) == len(demo_paths)

hpcflow/tests/unit/test_cache.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+from hpcflow.sdk.core.cache import ObjectCache
+from hpcflow.sdk.core.test_utils import make_workflow
+
+
+def test_object_cache_dependencies_simple(tmp_path: Path):
+    wk = make_workflow(
+        schemas_spec=[
+            ({"p1": None}, ("p2",), "t1"),
+            ({"p2": None}, ("p3",), "t2"),
+            ({"p3": None}, ("p4",), "t3"),
+            ({"p4": None}, ("p5",), "t4"),
+        ],
+        path=tmp_path,
+        local_inputs={0: ("p1",)},
+        overwrite=True,
+    )
+    obj_cache = ObjectCache.build(wk, dependencies=True)
+    assert obj_cache.run_dependencies == {0: set(), 1: {0}, 2: {1}, 3: {2}}
+    assert obj_cache.run_dependents == {0: {1}, 1: {2}, 2: {3}, 3: set()}
+    assert obj_cache.iter_run_dependencies == {0: set(), 1: {0}, 2: {1}, 3: {2}}
+    assert obj_cache.iter_iter_dependencies == {
+        0: set(),
+        1: {0},
+        2: {1},
+        3: {2},
+    }
+    assert obj_cache.elem_iter_dependencies == {
+        0: set(),
+        1: {0},
+        2: {1},
+        3: {2},
+    }
+    assert obj_cache.elem_elem_dependencies == {
+        0: set(),
+        1: {0},
+        2: {1},
+        3: {2},
+    }
+    assert obj_cache.elem_elem_dependents == {0: {1}, 1: {2}, 2: {3}, 3: set()}
+    assert obj_cache.elem_elem_dependents_rec == {
+        0: {1, 2, 3},
+        1: {2, 3},
+        2: {3},
+        3: set(),
+    }

hpcflow/tests/unit/test_cli.py

@@ -1,12 +1,145 @@
 import pytest
 
 from click.testing import CliRunner
+import click.exceptions
 
 from hpcflow import __version__
 from hpcflow.app import app as hf
+from hpcflow.sdk.cli import ErrorPropagatingClickContext
+from hpcflow.sdk.cli_common import BoolOrString
 
 
-def test_version():
+def test_version() -> None:
     runner = CliRunner()
     result = runner.invoke(hf.cli, args="--version")
     assert result.output.strip() == f"hpcFlow, version {__version__}"
+
+
+def test_BoolOrString_convert():
+    param_type = BoolOrString(["a"])
+    assert param_type.convert(True, None, None) == True
+    assert param_type.convert(False, None, None) == False
+    assert param_type.convert("yes", None, None) == True
+    assert param_type.convert("no", None, None) == False
+    assert param_type.convert("on", None, None) == True
+    assert param_type.convert("off", None, None) == False
+    assert param_type.convert("a", None, None) == "a"
+    with pytest.raises(click.exceptions.BadParameter):
+        param_type.convert("b", None, None)
+
+
+def test_error_propagated_with_custom_context_class():
+    class MyException(ValueError):
+        pass
+
+    class MyContextManager:
+
+        # set to True when MyException is raised within this context manager
+        raised = False
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            if exc_type == MyException:
+                self.__class__.raised = True
+
+    @click.group()
+    @click.pass_context
+    def cli(ctx):
+        ctx.with_resource(MyContextManager())
+
+    cli.context_class = ErrorPropagatingClickContext  # use custom click Context
+
+    @cli.command()
+    def my_command():
+        raise MyException()
+
+    runner = CliRunner()
+    runner.invoke(cli, args="my-command")
+
+    assert MyContextManager.raised
+
+
+def test_error_not_propagated_without_custom_context_class():
+    class MyException(ValueError):
+        pass
+
+    class MyContextManager:
+
+        # set to True when MyException is raised within this context manager
+        raised = False
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            if exc_type == MyException:
+                self.__class__.raised = True
+
+    @click.group()
+    @click.pass_context
+    def cli(ctx):
+        ctx.with_resource(MyContextManager())
+
+    @cli.command()
+    def my_command():
+        raise MyException()
+
+    runner = CliRunner()
+    runner.invoke(cli, args="my-command")
+
+    assert not MyContextManager.raised
+
+
+def test_std_stream_file_created(tmp_path):
+    """Test exception is intercepted and printed to the specified --std-stream file."""
+    error_file = tmp_path / "std_stream.txt"
+    runner = CliRunner()
+    result = runner.invoke(
+        hf.cli, args=f'--std-stream "{str(error_file)}" internal noop --raise'
+    )
+    assert error_file.is_file()
+    std_stream_contents = error_file.read_text()
+    assert "ValueError: internal noop raised!" in std_stream_contents
+    assert result.exit_code == 1
+    assert result.exc_info[0] == SystemExit
+
+
+def test_std_stream_file_not_created(null_config, tmp_path):
+    """Test std stream file is not created when no ouput/errors/exceptions"""
+    error_file = tmp_path / "std_stream.txt"
+    runner = CliRunner()
+    result = runner.invoke(hf.cli, args=f'--std-stream "{str(error_file)}" internal noop')
+    assert not error_file.is_file()
+    assert result.exit_code == 0
+
+
+def test_cli_exception():
+    """Test exception is passed to click"""
+    runner = CliRunner()
+    result = runner.invoke(hf.cli, args="internal noop --raise")
+    assert result.exit_code == 1
+    assert result.exc_info[0] == ValueError
+
+
+def test_cli_click_exit_code_zero(tmp_path):
+    """Test Click's `Exit` exception is ignored by the `redirect_std_to_file` context manager when the exit code is zero."""
+    error_file = tmp_path / "std_stream.txt"
+    runner = CliRunner()
+    result = runner.invoke(
+        hf.cli, args=f'--std-stream "{str(error_file)}" internal noop --click-exit-code 0'
+    )
+    assert result.exit_code == 0
+    assert not error_file.is_file()
+
+
+def test_cli_click_exit_code_non_zero(tmp_path):
+    """Test Click's `Exit` exception is not ignored by the `redirect_std_to_file` context manager when the exit code is non-zero."""
+    error_file = tmp_path / "std_stream.txt"
+    runner = CliRunner()
+    result = runner.invoke(
+        hf.cli, args=f'--std-stream "{str(error_file)}" internal noop --click-exit-code 2'
+    )
+    assert result.exit_code == 2
+    assert error_file.is_file()