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

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() -> 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()

hpcflow/tests/unit/test_config.py

@@ -1,9 +1,15 @@
 from __future__ import annotations
 import os
+import time
 import pytest
 
 from hpcflow.app import app as hf
-from hpcflow.sdk.config.errors import ConfigFileValidationError, ConfigItemCallbackError
+from hpcflow.sdk.config.errors import (
+    ConfigFileValidationError,
+    ConfigItemCallbackError,
+    ConfigNonConfigurableError,
+    ConfigReadOnlyError,
+)
 
 
 def test_reset_config(new_null_config) -> None:
@@ -72,3 +78,118 @@ def test_without_callbacks_ctx_manager(null_config) -> None:
 
     # unload the modified config so it's not reused by other tests
     hf.unload_config()
+
+
+@pytest.mark.xfail(reason="Might occasionally fail.")
+def test_cache_faster_than_no_cache(null_config):
+    n = 10_000
+    tic = time.perf_counter()
+    for _ in range(n):
+        _ = hf.config.machine
+    toc = time.perf_counter()
+    elapsed_no_cache = toc - tic
+
+    with hf.config.cached_config():
+        tic = time.perf_counter()
+        for _ in range(n):
+            _ = hf.config.machine
+        toc = time.perf_counter()
+    elapsed_cache = toc - tic
+
+    assert elapsed_cache < elapsed_no_cache
+
+
+def test_cache_read_only(new_null_config):
+    """Check we cannot modify the config when using the cache"""
+
+    # check we can set an item first:
+    hf.machine = "abc"
+    assert hf.machine == "abc"
+
+    with pytest.raises(ConfigReadOnlyError):
+        with hf.config.cached_config():
+            hf.config.set("machine", "123")
+
+    with pytest.raises(ConfigReadOnlyError):
+        with hf.config.cached_config():
+            hf.config.machine = "456"
+
+
+def test_workflow_template_config_validation(new_null_config, tmp_path):
+    wkt = hf.WorkflowTemplate(
+        tasks=[],
+        config={"log_file_level": "debug"},
+        name="test_workflow_config_validation",
+    )
+    assert wkt.config == {"log_file_level": "debug"}
+
+
+def test_workflow_template_config_validation_raises(unload_config, tmp_path):
+    with pytest.raises(ConfigNonConfigurableError):
+        hf.WorkflowTemplate(
+            tasks=[],
+            config={"bad_key": "debug"},
+            name="test_workflow_config_validation_raises",
+        )
+
+    # workflow template config validation should not need to load the whole config:
+    assert not hf.is_config_loaded
+
+
+def test_config_with_updates(new_null_config):
+    level_1 = hf.config.get("log_console_level")
+    with hf.config._with_updates({"log_console_level": "debug"}):
+        level_2 = hf.config.get("log_console_level")
+    level_3 = hf.config.get("log_console_level")
+    assert level_1 == level_3 != level_2
+    hf.reload_config()
+
+
+@pytest.mark.integration
+def test_workflow_template_config_set(new_null_config, tmp_path):
+    """Test we can set a workflow-level config item and that it is correctly applied
+    during execution."""
+
+    t1 = hf.Task(
+        schema=hf.task_schemas.test_t1_conditional_OS,
+        inputs={"p1": 101},
+    )
+    log_path = tmp_path / "log.log"
+    hf.config.set("log_file_level", "warning")
+    hf.config.set("log_file_path", log_path)
+
+    log_str_1 = "this should not appear in the log file"
+    hf.submission_logger.debug(log_str_1)
+
+    log_str_2 = "this should appear in the log file"
+    hf.submission_logger.warning(log_str_2)
+
+    assert log_path.is_file()
+    log_file_contents = log_path.read_text()
+    assert log_str_1 not in log_file_contents
+    assert log_str_2 in log_file_contents
+
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1],
+        config={"log_file_level": "debug"},
+        resources={"any": {"write_app_logs": True}},
+        workflow_name="test_workflow_config",
+        template_name="test_workflow_config",
+        path=tmp_path,
+    )
+    wk.submit(wait=True, status=False, add_to_known=False)
+
+    # check some DEBUG messages present in the run logs
+    debug_str = " DEBUG hpcflow.persistence:"
+
+    run = wk.get_EARs_from_IDs([0])[0]
+    run_log_path = run.get_app_log_path()
+    assert run_log_path.is_file()
+
+    run_log_contents = run_log_path.read_text()
+    assert debug_str in run_log_contents
+
+    # log file level should not have changed:
+    assert hf.config.get("log_file_level") == "warning"
+
+    hf.reload_config()

hpcflow/tests/unit/test_element_iteration.py

@@ -39,3 +39,50 @@ def test_decode(null_config, tmp_path: Path, store: str):
     assert sorted(iter_i.schema_parameters) == sorted(
         ["resources.any", "inputs.p1", "outputs.p2"]
     )
+
+
+@pytest.mark.integration
+def test_loop_skipped_true_single_action_elements(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_loop_skipped",
+        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; third iteration should
+    # be loop-skipped
+    wk.submit(wait=True, add_to_known=False, status=False)
+    iters = wk.get_all_element_iterations()
+
+    assert not iters[0].loop_skipped
+    assert not iters[1].loop_skipped
+    assert iters[2].loop_skipped
+
+    # check latest iteration is the latest non-loop-skipped iteration:
+    assert wk.tasks[0].elements[0].latest_iteration_non_skipped.id_ == iters[1].id_
+
+    # check element inputs are from latest non-loop-skipped iteration:
+    assert wk.tasks[0].elements[0].inputs.p1.value == 200
+    assert wk.tasks[0].elements[0].get("inputs.p1") == 200
+
+    # check element outputs are from latest non-loop-skipped iteration:
+    assert wk.tasks[0].elements[0].outputs.p1.value == 300
+    assert wk.tasks[0].elements[0].get("outputs.p1") == 300