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

junifer/api/tests/test_functions.py

@@ -6,15 +6,14 @@
 # License: AGPL
 
 import logging
-import stat
 from pathlib import Path
-from typing import List, Tuple, Union
+from typing import Dict, List, Tuple, Union
 
 import pytest
 from ruamel.yaml import YAML
 
 import junifer.testing.registry  # noqa: F401
-from junifer.api.functions import collect, queue, run
+from junifer.api.functions import collect, queue, reset, run
 from junifer.datagrabber.base import BaseDataGrabber
 from junifer.pipeline.registry import build
 
@@ -25,195 +24,217 @@ yaml.default_flow_style = False
 yaml.allow_unicode = True
 yaml.indent(mapping=2, sequence=4, offset=2)
 
-# Define datagrabber
-datagrabber = {
-    "kind": "OasisVBMTestingDataGrabber",
-}
-
-# Define markers
-markers = [
-    {
-        "name": "Schaefer1000x7_Mean",
-        "kind": "ParcelAggregation",
-        "parcellation": "Schaefer1000x7",
-        "method": "mean",
-    },
-    {
-        "name": "Schaefer1000x7_Std",
-        "kind": "ParcelAggregation",
-        "parcellation": "Schaefer1000x7",
-        "method": "std",
-    },
-]
-
-# Define storage
-storage = {
-    "kind": "SQLiteFeatureStorage",
-}
-
-
-def test_run_single_element(tmp_path: Path) -> None:
+
+@pytest.fixture
+def datagrabber() -> Dict[str, str]:
+    """Return a datagrabber as a dictionary."""
+    return {
+        "kind": "PartlyCloudyTestingDataGrabber",
+    }
+
+
+@pytest.fixture
+def markers() -> List[Dict[str, str]]:
+    """Return markers as a list of dictionary."""
+    return [
+        {
+            "name": "tian-s1-3T_mean",
+            "kind": "ParcelAggregation",
+            "parcellation": "TianxS1x3TxMNInonlinear2009cAsym",
+            "method": "mean",
+        },
+        {
+            "name": "tian-s1-3T_std",
+            "kind": "ParcelAggregation",
+            "parcellation": "TianxS1x3TxMNInonlinear2009cAsym",
+            "method": "std",
+        },
+    ]
+
+
+@pytest.fixture
+def storage() -> Dict[str, str]:
+    """Return a storage as a dictionary."""
+    return {
+        "kind": "SQLiteFeatureStorage",
+    }
+
+
+def test_run_single_element(
+    tmp_path: Path,
+    datagrabber: Dict[str, str],
+    markers: List[Dict[str, str]],
+    storage: Dict[str, str],
+) -> None:
     """Test run function with single element.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
+    datagrabber : dict
+        Testing datagrabber as dictionary.
+    markers : list of dict
+        Testing markers as list of dictionary.
+    storage : dict
+        Testing storage as dictionary.
 
     """
-    # Create working directory
-    workdir = tmp_path / "workdir_single"
-    workdir.mkdir()
-    # Create output directory
-    outdir = tmp_path / "out"
-    outdir.mkdir()
-    # Create storage
-    uri = outdir / "test.sqlite"
-    storage["uri"] = uri  # type: ignore
+    # Set storage
+    storage["uri"] = str((tmp_path / "out.sqlite").resolve())
     # Run operations
     run(
-        workdir=workdir,
+        workdir=tmp_path,
         datagrabber=datagrabber,
         markers=markers,
         storage=storage,
         elements=["sub-01"],
     )
     # Check files
-    files = list(outdir.glob("*.sqlite"))
+    files = list(tmp_path.glob("*.sqlite"))
     assert len(files) == 1
 
 
-def test_run_single_element_with_preprocessing(tmp_path: Path) -> None:
+def test_run_single_element_with_preprocessing(
+    tmp_path: Path,
+    markers: List[Dict[str, str]],
+    storage: Dict[str, str],
+) -> None:
     """Test run function with single element and pre-processing.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
+    markers : list of dict
+        Testing markers as list of dictionary.
+    storage : dict
+        Testing storage as dictionary.
 
     """
-    # Create working directory
-    workdir = tmp_path / "workdir_single_with_preprocess"
-    workdir.mkdir()
-    # Create output directory
-    outdir = tmp_path / "out"
-    outdir.mkdir()
-    # Create storage
-    uri = outdir / "test.sqlite"
-    storage["uri"] = uri  # type: ignore
+    # Set storage
+    storage["uri"] = str((tmp_path / "out.sqlite").resolve())
     # Run operations
     run(
-        workdir=workdir,
+        workdir=tmp_path,
         datagrabber={
             "kind": "PartlyCloudyTestingDataGrabber",
             "reduce_confounds": False,
         },
-        markers=[
+        markers=markers,
+        storage=storage,
+        preprocessors=[
             {
-                "name": "Schaefer100x17_mean_FC",
-                "kind": "FunctionalConnectivityParcels",
-                "parcellation": "Schaefer100x17",
-                "agg_method": "mean",
+                "kind": "fMRIPrepConfoundRemover",
             }
         ],
-        storage=storage,
-        preprocessor={
-            "kind": "fMRIPrepConfoundRemover",
-        },
-        elements=["sub-001"],
+        elements=["sub-01"],
     )
     # Check files
-    files = list(outdir.glob("*.sqlite"))
+    files = list(tmp_path.glob("*.sqlite"))
     assert len(files) == 1
 
 
-def test_run_multi_element(tmp_path: Path) -> None:
-    """Test run function with multi element.
+def test_run_multi_element_multi_output(
+    tmp_path: Path,
+    datagrabber: Dict[str, str],
+    markers: List[Dict[str, str]],
+    storage: Dict[str, str],
+) -> None:
+    """Test run function with multi element and multi output.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
+    datagrabber : dict
+        Testing datagrabber as dictionary.
+    markers : list of dict
+        Testing markers as list of dictionary.
+    storage : dict
+        Testing storage as dictionary.
 
     """
-    # Create working directory
-    workdir = tmp_path / "workdir_multi"
-    workdir.mkdir()
-    # Create output directory
-    outdir = tmp_path / "out"
-    outdir.mkdir()
-    # Create storage
-    uri = outdir / "test.sqlite"
-    storage["uri"] = uri  # type: ignore
+    # Set storage
+    storage["uri"] = str((tmp_path / "out.sqlite").resolve())
     storage["single_output"] = False  # type: ignore
     # Run operations
     run(
-        workdir=workdir,
+        workdir=tmp_path,
         datagrabber=datagrabber,
         markers=markers,
         storage=storage,
         elements=["sub-01", "sub-03"],
     )
     # Check files
-    files = list(outdir.glob("*.sqlite"))
+    files = list(tmp_path.glob("*.sqlite"))
     assert len(files) == 2
 
 
-def test_run_multi_element_single_output(tmp_path: Path) -> None:
-    """Test run function with multi element.
+def test_run_multi_element_single_output(
+    tmp_path: Path,
+    datagrabber: Dict[str, str],
+    markers: List[Dict[str, str]],
+    storage: Dict[str, str],
+) -> None:
+    """Test run function with multi element and single output.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
+    datagrabber : dict
+        Testing datagrabber as dictionary.
+    markers : list of dict
+        Testing markers as list of dictionary.
+    storage : dict
+        Testing storage as dictionary.
 
     """
-    # Create working directory
-    workdir = tmp_path / "workdir_multi"
-    workdir.mkdir()
-    # Create output directory
-    outdir = tmp_path / "out"
-    outdir.mkdir()
-    # Create storage
-    uri = outdir / "test.sqlite"
-    storage["uri"] = uri  # type: ignore
+    # Set storage
+    storage["uri"] = str((tmp_path / "out.sqlite").resolve())
     storage["single_output"] = True  # type: ignore
     # Run operations
     run(
-        workdir=workdir,
+        workdir=tmp_path,
         datagrabber=datagrabber,
         markers=markers,
         storage=storage,
         elements=["sub-01", "sub-03"],
     )
     # Check files
-    files = list(outdir.glob("*.sqlite"))
+    files = list(tmp_path.glob("*.sqlite"))
     assert len(files) == 1
-    assert files[0].name == "test.sqlite"
+    assert files[0].name == "out.sqlite"
 
 
-def test_run_and_collect(tmp_path: Path) -> None:
+def test_run_and_collect(
+    tmp_path: Path,
+    datagrabber: Dict[str, str],
+    markers: List[Dict[str, str]],
+    storage: Dict[str, str],
+) -> None:
     """Test run and collect functions.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
+    datagrabber : dict
+        Testing datagrabber as dictionary.
+    markers : list of dict
+        Testing markers as list of dictionary.
+    storage : dict
+        Testing storage as dictionary.
 
     """
-    # Create working directory
-    workdir = tmp_path / "workdir"
-    workdir.mkdir()
-    # Create output directory
-    outdir = tmp_path / "out"
-    outdir.mkdir()
-    # Create storage
-    uri = outdir / "test.sqlite"
-    storage["uri"] = uri  # type: ignore
+    # Set storage
+    uri = tmp_path / "out.sqlite"
+    storage["uri"] = str(uri.resolve())
     storage["single_output"] = False  # type: ignore
     # Run operations
     run(
-        workdir=workdir,
+        workdir=tmp_path,
         datagrabber=datagrabber,
         markers=markers,
         storage=storage,
@@ -224,7 +245,7 @@ def test_run_and_collect(tmp_path: Path) -> None:
     )
     elements = dg.get_elements()  # type: ignore
     # This should create 10 files
-    files = list(outdir.glob("*.sqlite"))
+    files = list(tmp_path.glob("*.sqlite"))
     assert len(files) == len(elements)
     # But the test.sqlite file should not exist
     assert not uri.exists()
@@ -238,6 +259,9 @@ def test_queue_correct_yaml_config(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
     caplog: pytest.LogCaptureFixture,
+    datagrabber: Dict[str, str],
+    markers: List[Dict[str, str]],
+    storage: Dict[str, str],
 ) -> None:
     """Test proper YAML config generation for queueing.
 
@@ -249,6 +273,12 @@ def test_queue_correct_yaml_config(
         The pytest.MonkeyPatch object.
     caplog : pytest.LogCaptureFixture
         The pytest.LogCaptureFixture object.
+    datagrabber : dict
+        Testing datagrabber as dictionary.
+    markers : list of dict
+        Testing markers as list of dictionary.
+    storage : dict
+        Testing storage as dictionary.
 
     """
     with monkeypatch.context() as m:
@@ -260,7 +290,7 @@ def test_queue_correct_yaml_config(
                     "workdir": str(tmp_path.resolve()),
                     "datagrabber": datagrabber,
                     "markers": markers,
-                    "storage": {"kind": "SQLiteFeatureStorage"},
+                    "storage": storage,
                     "env": {
                         "kind": "conda",
                         "name": "junifer",
@@ -270,7 +300,7 @@ def test_queue_correct_yaml_config(
                 kind="HTCondor",
                 jobname="yaml_config_gen_check",
             )
-            assert "Creating job in" in caplog.text
+            assert "Creating job directory at" in caplog.text
             assert "Writing YAML config to" in caplog.text
             assert "Queue done" in caplog.text
 
@@ -308,7 +338,7 @@ def test_queue_invalid_job_queue(
         The pytest.MonkeyPatch object.
 
     """
-    with pytest.raises(ValueError, match="Unknown queue kind"):
+    with pytest.raises(ValueError, match="Invalid value for `kind`"):
         with monkeypatch.context() as m:
             m.chdir(tmp_path)
             queue(
@@ -478,6 +508,7 @@ def test_queue_without_elements(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
     caplog: pytest.LogCaptureFixture,
+    datagrabber: Dict[str, str],
 ) -> None:
     """Test queue without elements.
 
@@ -489,6 +520,8 @@ def test_queue_without_elements(
         The pytest.MonkeyPatch object.
     caplog : pytest.LogCaptureFixture
         The pytest.LogCaptureFixture object.
+    datagrabber : dict
+        Testing datagrabber as dictionary.
 
     """
     with monkeypatch.context() as m:
@@ -496,181 +529,63 @@ def test_queue_without_elements(
         with caplog.at_level(logging.INFO):
             queue(
                 config={"datagrabber": datagrabber},
-                kind="SLURM",
-            )
-            assert "Queue done" in caplog.text
-
-
-def test_queue_condor_invalid_python_env(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """Test invalid Python environment check for HTCondor.
-
-    Parameters
-    ----------
-    tmp_path : pathlib.Path
-        The path to the test directory.
-    monkeypatch : pytest.MonkeyPatch
-        The pytest.MonkeyPatch object.
-
-    """
-    with pytest.raises(ValueError, match="Unknown env kind"):
-        with monkeypatch.context() as m:
-            m.chdir(tmp_path)
-            queue(
-                config={"elements": "sub-001"},
                 kind="HTCondor",
-                env={"kind": "galaxy"},
             )
+            assert "Queue done" in caplog.text
 
 
-def test_queue_condor_conda_python(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """Test conda Python environment check for HTCondor.
-
-    Parameters
-    ----------
-    tmp_path : pathlib.Path
-        The path to the test directory.
-    monkeypatch : pytest.MonkeyPatch
-        The pytest.MonkeyPatch object.
-    caplog : pytest.LogCaptureFixture
-        The pytest.LogCaptureFixture object.
-
-    """
-    with monkeypatch.context() as m:
-        m.chdir(tmp_path)
-        with caplog.at_level(logging.INFO):
-            queue(
-                config={"elements": "sub-001"},
-                kind="HTCondor",
-                jobname="conda_env_check",
-                env={"kind": "conda", "name": "conda-env"},
-            )
-            assert "Copying" in caplog.text
-            fname = (
-                tmp_path / "junifer_jobs" / "conda_env_check" / "run_conda.sh"
-            )
-            assert fname.is_file()
-            assert stat.S_IMODE(fname.stat().st_mode) & stat.S_IEXEC != 0
-
-
-def test_queue_condor_conda_pre_run_python(
+def test_reset_run(
     tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    caplog: pytest.LogCaptureFixture,
+    datagrabber: Dict[str, str],
+    markers: List[Dict[str, str]],
+    storage: Dict[str, str],
 ) -> None:
-    """Test conda Python environment check for HTCondor.
+    """Test reset function for run.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
-    monkeypatch : pytest.MonkeyPatch
-        The pytest.MonkeyPatch object.
-    caplog : pytest.LogCaptureFixture
-        The pytest.LogCaptureFixture object.
+    datagrabber : dict
+        Testing datagrabber as dictionary.
+    markers : list of dict
+        Testing markers as list of dictionary.
+    storage : dict
+        Testing storage as dictionary.
 
     """
-    with monkeypatch.context() as m:
-        m.chdir(tmp_path)
-        with caplog.at_level(logging.INFO):
-            queue(
-                config={"elements": "sub-001"},
-                kind="HTCondor",
-                jobname="conda_env_check",
-                env={"kind": "conda", "name": "conda-env"},
-                pre_run="echo testing",
-            )
-            assert "Copying" in caplog.text
-
-            fname = (
-                tmp_path / "junifer_jobs" / "conda_env_check" / "run_conda.sh"
-            )
-            assert fname.is_file()
-            assert stat.S_IMODE(fname.stat().st_mode) & stat.S_IEXEC != 0
-
-            fname = (
-                tmp_path / "junifer_jobs" / "conda_env_check" / "pre_run.sh"
-            )
-            assert fname.is_file()
-            assert stat.S_IMODE(fname.stat().st_mode) & stat.S_IEXEC != 0
-
-
-def test_queue_condor_venv_python(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """Test venv Python environment check for HTCondor.
-
-    Parameters
-    ----------
-    tmp_path : pathlib.Path
-        The path to the test directory.
-    monkeypatch : pytest.MonkeyPatch
-        The pytest.MonkeyPatch object.
-    caplog : pytest.LogCaptureFixture
-        The pytest.LogCaptureFixture object.
+    # Create storage
+    storage["uri"] = tmp_path / "test_reset_run.sqlite"  # type: ignore
+    # Run operation to generate files
+    run(
+        workdir=tmp_path,
+        datagrabber=datagrabber,
+        markers=markers,
+        storage=storage,
+        elements=["sub-01"],
+    )
+    # Reset operation
+    reset(config={"storage": storage})
 
-    """
-    with monkeypatch.context() as m:
-        m.chdir(tmp_path)
-        with caplog.at_level(logging.INFO):
-            queue(
-                config={"elements": "sub-001"},
-                kind="HTCondor",
-                env={"kind": "venv", "name": "venv-env"},
-            )
-            # TODO: needs implementation for testing
+    assert not Path(storage["uri"]).exists()
 
 
 @pytest.mark.parametrize(
-    "elements, env, mem, cpus, disk, collect",
-    [
-        (
-            ["sub-001"],
-            {"kind": "conda", "name": "conda-env"},
-            "4G",
-            4,
-            "4G",
-            "yes",
-        ),
-        (
-            ["sub-001"],
-            {"kind": "conda", "name": "conda-env"},
-            "4G",
-            4,
-            "4G",
-            "on_success_only",
-        ),
-        (
-            ["sub-001"],
-            {"kind": "venv", "name": "venv-env"},
-            "8G",
-            8,
-            "8G",
-            "no",
-        ),
-        (["sub-001"], {"kind": "local"}, "12G", 12, "12G", "yes"),
-    ],
+    "job_name",
+    (
+        "job",
+        None,
+    ),
 )
-def test_queue_condor_assets_generation(
+def test_reset_queue(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
-    caplog: pytest.LogCaptureFixture,
-    elements: str,
-    env: str,
-    mem: str,
-    cpus: int,
-    disk: str,
-    collect: str,
+    datagrabber: Dict[str, str],
+    markers: List[Dict[str, str]],
+    storage: Dict[str, str],
+    job_name: str,
 ) -> None:
-    """Test HTCondor generated assets.
+    """Test reset function for queue.
 
     Parameters
     ----------
@@ -678,190 +593,47 @@ def test_queue_condor_assets_generation(
         The path to the test directory.
     monkeypatch : pytest.MonkeyPatch
         The pytest.MonkeyPatch object.
-    caplog : pytest.LogCaptureFixture
-        The pytest.LogCaptureFixture object.
-    elements : str
-        The parametrized element names.
-    env : dict
-        The parametrized env names.
-    mem : str
-        The parametrized memory size.
-    cpus : int
-        The parametrized CPUs.
-    disk : str
-        The parametrized disk size.
-    collect : str
-        The parametrized collect option.
+    datagrabber : dict
+        Testing datagrabber as dictionary.
+    markers : list of dict
+        Testing markers as list of dictionary.
+    storage : dict
+        Testing storage as dictionary.
+    job_name : str
+        The parametrized job name.
 
     """
-    jobname = "condor_assets_gen_check"
-    with monkeypatch.context() as m:
-        m.chdir(tmp_path)
-        with caplog.at_level(logging.INFO):
-            queue(
-                config={"elements": elements},
-                kind="HTCondor",
-                jobname=jobname,
-                env=env,
-                mem=mem,
-                cpus=cpus,
-                disk=disk,
-                collect=collect,
-            )
-
-            # Check log directory creation
-            assert Path(tmp_path / "junifer_jobs" / jobname / "logs").is_dir()
-
-            run_submit_file_path = Path(
-                tmp_path / "junifer_jobs" / jobname / f"run_{jobname}.submit"
-            )
-            # Check junifer run submit file
-            assert run_submit_file_path.is_file()
-            # Read run submit file to check if resources are correct
-            with open(run_submit_file_path) as f:
-                for line in f.read().splitlines():
-                    if "request_cpus" in line:
-                        assert int(line.split("=")[1].strip()) == cpus
-                    if "request_memory" in line:
-                        assert line.split("=")[1].strip() == mem
-                    if "request_disk" in line:
-                        assert line.split("=")[1].strip() == disk
-
-            # Check junifer collect submit file
-            assert Path(
-                tmp_path
-                / "junifer_jobs"
-                / jobname
-                / f"collect_{jobname}.submit"
-            ).is_file()
-
-            dag_file_path = Path(
-                tmp_path / "junifer_jobs" / jobname / f"{jobname}.dag"
-            )
-            # Check junifer dag file
-            assert dag_file_path.is_file()
-            # Read dag file to check if collect job is found
-            element_count = 0
-            has_collect_job = False
-            has_final_collect_job = False
-            with open(dag_file_path) as f:
-                for line in f.read().splitlines():
-                    if "JOB" in line:
-                        element_count += 1
-                    if "collect" in line:
-                        has_collect_job = True
-                    if "FINAL" in line:
-                        has_final_collect_job = True
-
-            if collect == "yes":
-                assert len(elements) == element_count
-                assert has_collect_job is True
-                assert has_final_collect_job is True
-            elif collect == "on_success_only":
-                assert len(elements) == element_count - 1
-                assert has_collect_job is True
-                assert has_final_collect_job is False
-            else:
-                assert len(elements) == element_count
-                assert has_collect_job is False
-
-            if has_final_collect_job is True:
-                pre_collect_fname = Path(
-                    tmp_path / "junifer_jobs" / jobname / "collect_pre.sh"
-                )
-                assert pre_collect_fname.exists()
-                assert (
-                    stat.S_IMODE(pre_collect_fname.stat().st_mode)
-                    & stat.S_IEXEC
-                    != 0
-                )
-
-            # Check submit log
-            assert (
-                "HTCondor job files created, to submit the job, run"
-                in caplog.text
-            )
-
-
-def test_queue_condor_extra_preamble(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """Test HTCondor extra preamble addition.
-
-    Parameters
-    ----------
-    tmp_path : pathlib.Path
-        The path to the test directory.
-    monkeypatch : pytest.MonkeyPatch
-        The pytest.MonkeyPatch object.
-
-    """
-    jobname = "condor_extra_preamble_check"
-    extra_preamble = "FOO = BAR"
     with monkeypatch.context() as m:
         m.chdir(tmp_path)
+        # Create storage
+        storage["uri"] = "test_reset_queue.sqlite"
+        # Set job name
+        if job_name is None:
+            job_name = "junifer_job"
+        # Queue operation to generate files
         queue(
-            config={"elements": ["sub-001"]},
-            kind="HTCondor",
-            jobname=jobname,
-            extra_preamble=extra_preamble,
-        )
-
-        # Check extra preamble in run submit file
-        run_submit_file_path = Path(
-            tmp_path / "junifer_jobs" / jobname / f"run_{jobname}.submit"
+            config={
+                "with": "junifer.testing.registry",
+                "workdir": str(tmp_path.resolve()),
+                "datagrabber": datagrabber,
+                "markers": markers,
+                "storage": storage,
+                "env": {
+                    "kind": "conda",
+                    "name": "junifer",
+                },
+                "mem": "8G",
+            },
+            kind="GNUParallelLocal",
+            jobname=job_name,
         )
-        with open(run_submit_file_path) as f:
-            for line in f.read().splitlines():
-                if "FOO" in line:
-                    assert line.strip() == extra_preamble
-
-        # Check extra preamble in collect submit file
-        collect_submit_file_path = Path(
-            tmp_path / "junifer_jobs" / jobname / f"collect_{jobname}.submit"
+        # Reset operation
+        reset(
+            config={
+                "storage": storage,
+                "queue": {"kind": "GNUParallelLocal", "jobname": job_name},
+            }
         )
-        with open(collect_submit_file_path) as f:
-            for line in f.read().splitlines():
-                if "FOO" in line:
-                    assert line.strip() == extra_preamble
 
-
-def test_queue_condor_submission_fail(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """Test HTCondor job submission failure.
-
-    Parameters
-    ----------
-    tmp_path : pathlib.Path
-        The path to the test directory.
-    monkeypatch : pytest.MonkeyPatch
-        The pytest.MonkeyPatch object.
-    caplog : pytest.LogCaptureFixture
-        The pytest.LogCaptureFixture object.
-
-    """
-    with pytest.raises(
-        FileNotFoundError,
-        match="No such file or directory: 'condor_submit_dag'",
-    ):
-        with monkeypatch.context() as m:
-            m.chdir(tmp_path)
-            with caplog.at_level(logging.INFO):
-                queue(
-                    config={"elements": ["sub-001"]},
-                    kind="HTCondor",
-                    jobname="condor_job_submission_fail",
-                    submit=True,
-                )
-            # Check submit log
-            assert "Submitting HTCondor job" in caplog.text
-
-
-@pytest.mark.skip(reason="SLURM not installed on system.")
-def test_queue_slurm() -> None:
-    """Test job queueing in SLURM."""
-    pass
+        assert not Path(storage["uri"]).exists()
+        assert not (tmp_path / "junifer_jobs" / job_name).exists()