junifer 0.0.3.dev188__py3-none-any.whl → 0.0.4__py3-none-any.whl

junifer/api/tests/test_api_utils.py

@@ -32,32 +32,50 @@ def test_get_python_information() -> None:
 def test_get_dependency_information_short() -> None:
     """Test short version of _get_dependency_information()."""
     dependency_information = _get_dependency_information(long_=False)
-    assert list(dependency_information.keys()) == [
+    dependency_list = [
         "click",
         "numpy",
+        "scipy",
         "datalad",
         "pandas",
         "nibabel",
         "nilearn",
         "sqlalchemy",
         "ruamel.yaml",
+        "httpx",
+        "tqdm",
+        "templateflow",
+        "looseversion",
     ]
 
+    python_minor_version = int(pl.python_version_tuple()[1])
+    if python_minor_version < 10:
+        dependency_list.append("importlib_metadata")
+
+    assert frozenset(dependency_information.keys()) == frozenset(
+        dependency_list
+    )
+
 
 def test_get_dependency_information_long() -> None:
     """Test long version of _get_dependency_information()."""
     dependency_information = _get_dependency_information(long_=True)
     dependency_information_keys = list(dependency_information.keys())
-    for key in [
+    dependency_list = [
         "click",
         "numpy",
+        "scipy",
         "datalad",
         "pandas",
         "nibabel",
         "nilearn",
         "sqlalchemy",
         "ruamel.yaml",
-    ]:
+        "httpx",
+        "tqdm",
+        "templateflow",
+    ]
+    for key in dependency_list:
         assert key in dependency_information_keys
 
 

junifer/api/tests/test_cli.py

@@ -5,13 +5,21 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import Tuple
+from typing import Callable, List, Tuple
 
 import pytest
 from click.testing import CliRunner
 from ruamel.yaml import YAML
 
-from junifer.api.cli import collect, run, selftest, wtf
+from junifer.api.cli import (
+    _parse_elements_file,
+    collect,
+    queue,
+    reset,
+    run,
+    selftest,
+    wtf,
+)
 
 
 # Configure YAML class
@@ -35,18 +43,24 @@ runner = CliRunner()
 def test_run_and_collect_commands(
     tmp_path: Path, elements: Tuple[str, ...]
 ) -> None:
-    """Test run and collect commands."""
+    """Test run and collect commands.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    elements : tuple of str
+        The parametrized elements to operate on.
+
+    """
     # Get test config
-    infile = Path(__file__).parent / "data" / "gmd_mean.yaml"
+    infile = Path(__file__).parent / "data" / "partly_cloudy_agg_mean_tian.yml"
     # Read test config
     contents = yaml.load(infile)
     # Working directory
-    workdir = tmp_path / "workdir"
-    contents["workdir"] = str(workdir.resolve())
-    # Output directory
-    outdir = tmp_path / "outdir"
+    contents["workdir"] = str(tmp_path.resolve())
     # Storage
-    contents["storage"]["uri"] = str(outdir.resolve())
+    contents["storage"]["uri"] = str((tmp_path / "out.hdf5").resolve())
     # Write new test config
     outfile = tmp_path / "in.yaml"
     yaml.dump(contents, stream=outfile)
@@ -74,6 +88,215 @@ def test_run_and_collect_commands(
     assert collect_result.exit_code == 0
 
 
+@pytest.mark.parametrize(
+    "elements",
+    [
+        "sub-01",
+        "sub-01\nsub-02",
+        "    sub-01    ",
+        "sub-01\n    sub-02",
+    ],
+)
+def test_run_using_element_file(tmp_path: Path, elements: str) -> None:
+    """Test run command using element file.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    elements : str
+        The parametrized elements to write to the element file.
+
+    """
+    # Create test file
+    test_file_path = tmp_path / "elements.txt"
+    with open(test_file_path, "w") as f:
+        f.write(elements)
+
+    # Get test config
+    infile = Path(__file__).parent / "data" / "partly_cloudy_agg_mean_tian.yml"
+    # Read test config
+    contents = yaml.load(infile)
+    # Working directory
+    contents["workdir"] = str(tmp_path.resolve())
+    # Storage
+    contents["storage"]["uri"] = str((tmp_path / "out.hdf5").resolve())
+    # Write new test config
+    outfile = tmp_path / "in.yaml"
+    yaml.dump(contents, stream=outfile)
+    # Run command arguments
+    run_args = [
+        str(outfile.absolute()),
+        "--verbose",
+        "debug",
+        "--element",
+        str(test_file_path.resolve()),
+    ]
+    # Invoke run command
+    run_result = runner.invoke(run, run_args)
+    # Check
+    assert run_result.exit_code == 0
+
+
+@pytest.mark.parametrize(
+    "elements, expected_list",
+    [
+        ("sub-01,ses-01", [("sub-01", "ses-01")]),
+        (
+            "sub-01,ses-01\nsub-02,ses-01",
+            [("sub-01", "ses-01"), ("sub-02", "ses-01")],
+        ),
+        ("sub-01, ses-01", [("sub-01", "ses-01")]),
+        (
+            "sub-01, ses-01\nsub-02, ses-01",
+            [("sub-01", "ses-01"), ("sub-02", "ses-01")],
+        ),
+        (" sub-01 , ses-01 ", [("sub-01", "ses-01")]),
+        (
+            " sub-01 , ses-01 \n sub-02, ses-01 ",
+            [("sub-01", "ses-01"), ("sub-02", "ses-01")],
+        ),
+        ("001,01", [("001", "01")]),
+        (
+            "001,01\n002,02",
+            [("001", "01"), ("002", "02")],
+        ),
+        ("001, 01", [("001", "01")]),
+        (
+            "001, 01\n002, 02",
+            [("001", "01"), ("002", "02")],
+        ),
+        (" 001 , 01 ", [("001", "01")]),
+        (
+            " 001 , 01 \n 002, 02 ",
+            [("001", "01"), ("002", "02")],
+        ),
+    ],
+)
+def test_multi_element_access(
+    tmp_path: Path, elements: str, expected_list: List[Tuple[str, ...]]
+) -> None:
+    """Test mulit-element parsing.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    elements : str
+        The parametrized elements to write to the element file.
+    expected_list : list of tuple of str
+        The parametrized list of element tuples to expect.
+
+    """
+    # Create test file
+    test_file_path = tmp_path / "elements_multi.txt"
+    with open(test_file_path, "w") as f:
+        f.write(elements)
+    # Load element file
+    read_elements = _parse_elements_file(test_file_path)
+    # Check
+    assert read_elements == expected_list
+
+
+def test_queue(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test queue command.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    monkeypatch : pytest.MonkeyPatch
+        The pytest.MonkeyPatch object.
+
+    """
+    with monkeypatch.context() as m:
+        m.chdir(tmp_path)
+        # Get test config
+        infile = Path(__file__).parent / "data" / "gmd_mean_htcondor.yaml"
+        # Read test config
+        contents = yaml.load(infile)
+        # Working directory
+        contents["workdir"] = str(tmp_path.resolve())
+        # Storage
+        contents["storage"]["uri"] = str((tmp_path / "out.sqlite").resolve())
+        # Write new test config
+        outfile = tmp_path / "in.yaml"
+        yaml.dump(contents, stream=outfile)
+        # Queue command arguments
+        queue_args = [
+            str(outfile.resolve()),
+            "--verbose",
+            "debug",
+        ]
+        # Invoke queue command
+        queue_result = runner.invoke(queue, queue_args)
+        # Check
+        assert queue_result.exit_code == 0
+
+
+@pytest.mark.parametrize(
+    "action, action_file",
+    [
+        (run, "partly_cloudy_agg_mean_tian.yml"),
+        (queue, "gmd_mean_htcondor.yaml"),
+    ],
+)
+def test_reset(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    action: Callable,
+    action_file: str,
+) -> None:
+    """Test reset command.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    monkeypatch : pytest.MonkeyPatch
+        The pytest.MonkeyPatch object.
+    action : callable
+        The parametrized action to perform.
+    action_file : str
+        The parametrized file for the action.
+
+    """
+    with monkeypatch.context() as m:
+        m.chdir(tmp_path)
+        # Get test config
+        infile = Path(__file__).parent / "data" / action_file
+        # Read test config
+        contents = yaml.load(infile)
+        # Working directory
+        contents["workdir"] = str(tmp_path.resolve())
+        # Storage
+        contents["storage"]["uri"] = str((tmp_path / "out.sqlite").resolve())
+        # Write new test config
+        outfile = tmp_path / "in.yaml"
+        yaml.dump(contents, stream=outfile)
+        # Command arguments
+        action_args = [
+            str(outfile.resolve()),
+            "--verbose",
+            "debug",
+        ]
+        # Invoke command
+        result = runner.invoke(action, action_args)
+        # Check
+        assert result.exit_code == 0
+
+        # Reset arguments
+        reset_args = [
+            str(outfile.resolve()),
+            "--verbose",
+            "debug",
+        ]
+        # Run reset
+        reset_result = runner.invoke(reset, reset_args)
+        # Check
+        assert reset_result.exit_code == 0
+
+
 def test_wtf_short() -> None:
     """Test short version of wtf command."""
     # Invoke wtf command