hpcflow 0.1.15__py3-none-any.whl → 0.2.0a271__py3-none-any.whl

hpcflow/tests/unit/test_action_rule.py

@@ -0,0 +1,24 @@
+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() -> 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() -> None:
+    rule_args: dict = {
+        "path": "resources.os_name",
+        "condition": {"value.equal_to": "posix"},
+    }
+    assert hf.ActionRule.from_json_like(
+        {"rule": rule_args}
+    ) == hf.ActionRule.from_json_like(rule_args)

hpcflow/tests/unit/test_app.py

@@ -0,0 +1,132 @@
+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() -> ActionEnvironment:
+    return hf.ActionEnvironment(environment="env_1")
+
+
+@pytest.fixture
+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: 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: dict[str, dict] = {
+        "parameters": {
+            p1_hash: {
+                "is_file": p1.is_file,
+                "sub_parameters": [],
+                "type": p1.typ,
+            }
+        },
+        "task_schemas": {
+            ts1_hash: {
+                "method": ts1.method,
+                "implementation": ts1.implementation,
+                "version": ts1.version,
+                "objective": ts1.objective.name,
+                "inputs": [{"parameter": f"hash:{p1_hash}", "labels": {"": {}}}],
+                "outputs": [],
+                "actions": [
+                    {
+                        "_from_expand": False,
+                        "script": None,
+                        "commands": [
+                            {
+                                "command": "<<parameter:p1>>",
+                                "executable": None,
+                                "arguments": None,
+                                "stdout": None,
+                                "stderr": None,
+                                "stdin": None,
+                            }
+                        ],
+                        "input_files": [],
+                        "output_files": [],
+                        "input_file_generators": [],
+                        "output_file_parsers": [],
+                        "environments": [
+                            {
+                                "scope": {"kwargs": {}, "type": "ANY"},
+                                "environment": env_label,
+                            }
+                        ],
+                        "rules": [],
+                    }
+                ],
+            }
+        },
+    }
+
+    sh = hf.template_components_from_json_like(shared_data_json)
+
+    assert sh["parameters"] == hf.ParametersList([p1]) and sh[
+        "task_schemas"
+    ] == hf.TaskSchemasList([ts1])
+
+
+def test_get_demo_data_manifest(null_config) -> None:
+    hf.get_demo_data_files_manifest()
+
+
+@pytest.mark.xfail(
+    condition=sys.platform == "darwin",
+    raises=requests.exceptions.HTTPError,
+    reason=(
+        "GHA MacOS runners use the same IP address, so we get rate limited when "
+        "retrieving demo data from GitHub."
+    ),
+)
+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

@@ -0,0 +1,172 @@
+from pathlib import Path
+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() -> 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(
+        name="my-command"
+    )  # explicit, because Click 8.2.0+ removes suffixes like "command" for some reason
+    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()
+
+
+def test_cli_make_demo_workflow(new_null_config, tmp_path):
+    """Check the demo workflow directory is generated."""
+    runner = CliRunner()
+    result = runner.invoke(
+        hf.cli, args=f'demo-workflow make workflow_1 --path "{str(tmp_path)}"'
+    )
+    assert result.exit_code == 0
+    assert Path(result.stdout_bytes.decode().strip()).is_dir()
+
+
+def test_cli_make_demo_workflow_add_sub(new_null_config, tmp_path):
+    """Check the demo workflow directory is generated, and a submission is added."""
+    runner = CliRunner()
+    result = runner.invoke(
+        hf.cli,
+        args=f'demo-workflow make workflow_1 --path "{str(tmp_path)}" --add-submission',
+    )
+    assert result.exit_code == 0
+    wk_path = Path(result.stdout_bytes.decode().strip())
+    assert wk_path.is_dir()
+    wk = hf.Workflow(wk_path)
+    assert len(wk.submissions) == 1