lsst-ctrl-bps 29.2025.4600__tar.gz → 29.2025.4900__tar.gz

{lsst_ctrl_bps-29.2025.4600/python/lsst_ctrl_bps.egg-info → lsst_ctrl_bps-29.2025.4900}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-bps
-Version: 29.2025.4600
+Version: 29.2025.4900
 Summary: Pluggable execution of workflow graphs from Rubin pipelines.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License-Expression: BSD-3-Clause OR GPL-3.0-or-later
@@ -23,7 +23,7 @@ License-File: gpl-v3.0.txt
 Requires-Dist: astropy>=4.0
 Requires-Dist: pyyaml>=5.1
 Requires-Dist: click>=7.0
-Requires-Dist: networkx
+Requires-Dist: networkx<3.6
 Requires-Dist: lsst-daf-butler
 Requires-Dist: lsst-pipe-base
 Requires-Dist: lsst-ctrl-mpexec

{lsst_ctrl_bps-29.2025.4600 → lsst_ctrl_bps-29.2025.4900}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
     "astropy >=4.0",
     "pyyaml >=5.1",
     "click >= 7.0",
-    "networkx",
+    "networkx <3.6",
     "lsst-daf-butler",
     "lsst-pipe-base",
     "lsst-ctrl-mpexec",

{lsst_ctrl_bps-29.2025.4600 → lsst_ctrl_bps-29.2025.4900}/python/lsst/ctrl/bps/drivers.py

@@ -55,6 +55,7 @@ from lsst.utils.timer import time_this
 from lsst.utils.usage import get_peak_mem_usage
 
 from . import BPS_DEFAULTS, BPS_SEARCH_ORDER, DEFAULT_MEM_FMT, DEFAULT_MEM_UNIT, BpsConfig
+from .bps_reports import compile_code_summary, compile_job_summary
 from .bps_utils import _dump_env_info, _dump_pkg_info, _make_id_link
 from .cancel import cancel
 from .construct import construct
@@ -68,7 +69,7 @@ from .initialize import (
 from .ping import ping
 from .pre_transform import acquire_quantum_graph, cluster_quanta
 from .prepare import prepare
-from .report import BPS_POSTPROCESSORS, display_report, retrieve_report
+from .report import display_report, retrieve_report
 from .restart import restart
 from .status import status
 from .submit import submit
@@ -400,20 +401,31 @@ def restart_driver(wms_service, run_id):
             print("Restart failed: Unknown error")
 
 
-def report_driver(wms_service, run_id, user, hist_days, pass_thru, is_global=False, return_exit_codes=False):
-    """Print out summary of jobs submitted for execution.
+def report_driver(
+    wms_service: str | None = None,
+    run_id: str | None = None,
+    user: str | None = None,
+    hist_days: float = 0.0,
+    pass_thru: str | None = None,
+    is_global: bool = False,
+    return_exit_codes: bool = False,
+):
+    """Print out the summary of jobs submitted for execution.
 
     Parameters
     ----------
-    wms_service : `str`
+    wms_service : `str`, optional
         Name of the class.
-    run_id : `str`
+    run_id : `str`, optional
         A run id the report will be restricted to.
-    user : `str`
+    user : `str`, optional
         A user the report will be restricted to.
-    hist_days : `float`
-        Number of days.
-    pass_thru : `str`
+    hist_days : `float`, optional
+        Number of past days to consider while preparing the report. By default,
+        only the currently running workflows are included in the report.
+        If the report is restricted to a single run (i.e., ``run_id`` is set),
+        the history search will be limited by default to two past days.
+    pass_thru : `str`, optional
         A string to pass directly to the WMS service class.
     is_global : `bool`, optional
         If set, all available job queues will be queried for job information.
@@ -430,17 +442,19 @@ def report_driver(wms_service, run_id, user, hist_days, pass_thru, is_global=Fal
         Only applicable in the context of a WMS with associated
         handlers to return exit codes from jobs.
     """
-    if wms_service is None:
+    if not wms_service:
         default_config = BpsConfig(BPS_DEFAULTS)
         wms_service = os.environ.get("BPS_WMS_SERVICE_CLASS", default_config["wmsServiceClass"])
 
-    # When reporting on single run:
-    # * increase history until better mechanism for handling completed jobs is
-    #   available.
+    # When reporting on a single run:
+    # * increase history until a better mechanism for handling completed jobs
+    #   is available.
     # * massage the retrieved reports using BPS report postprocessors.
     if run_id:
         hist_days = max(hist_days, 2)
-        postprocessors = BPS_POSTPROCESSORS
+        postprocessors = [compile_job_summary]
+        if return_exit_codes:
+            postprocessors.append(compile_code_summary)
     else:
         postprocessors = None
 

{lsst_ctrl_bps-29.2025.4600 → lsst_ctrl_bps-29.2025.4900}/python/lsst/ctrl/bps/report.py

@@ -31,7 +31,7 @@ Note: Expectations are that future reporting effort will revolve around LSST
 oriented database tables.
 """
 
-__all__ = ["BPS_POSTPROCESSORS", "display_report", "retrieve_report"]
+__all__ = ["display_report", "retrieve_report"]
 
 import logging
 import sys
@@ -40,20 +40,9 @@ from typing import TextIO
 
 from lsst.utils import doImportType
 
-from .bps_reports import (
-    DetailedRunReport,
-    ExitCodesReport,
-    SummaryRunReport,
-    compile_code_summary,
-    compile_job_summary,
-)
+from .bps_reports import DetailedRunReport, ExitCodesReport, SummaryRunReport
 from .wms_service import BaseWmsService, WmsRunReport, WmsStates
 
-BPS_POSTPROCESSORS = (compile_job_summary, compile_code_summary)
-"""Postprocessors for massaging run reports
-(`tuple` [`Callable` [[`WmsRunReport`], None]).
-"""
-
 _LOG = logging.getLogger(__name__)
 
 
@@ -167,7 +156,7 @@ def retrieve_report(
     pass_thru: str | None = None,
     is_global: bool = False,
     return_exit_codes: bool = False,
-    postprocessors: Sequence[Callable[[WmsRunReport], None]] | None = None,
+    postprocessors: Sequence[Callable[[WmsRunReport], list[str]]] | None = None,
 ) -> tuple[list[WmsRunReport], list[str]]:
     """Retrieve summary of jobs submitted for execution.
 

lsst_ctrl_bps-29.2025.4900/python/lsst/ctrl/bps/version.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "29.2025.4900"

{lsst_ctrl_bps-29.2025.4600 → lsst_ctrl_bps-29.2025.4900/python/lsst_ctrl_bps.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-bps
-Version: 29.2025.4600
+Version: 29.2025.4900
 Summary: Pluggable execution of workflow graphs from Rubin pipelines.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License-Expression: BSD-3-Clause OR GPL-3.0-or-later
@@ -23,7 +23,7 @@ License-File: gpl-v3.0.txt
 Requires-Dist: astropy>=4.0
 Requires-Dist: pyyaml>=5.1
 Requires-Dist: click>=7.0
-Requires-Dist: networkx
+Requires-Dist: networkx<3.6
 Requires-Dist: lsst-daf-butler
 Requires-Dist: lsst-pipe-base
 Requires-Dist: lsst-ctrl-mpexec

{lsst_ctrl_bps-29.2025.4600 → lsst_ctrl_bps-29.2025.4900}/python/lsst_ctrl_bps.egg-info/requires.txt

@@ -1,7 +1,7 @@
 astropy>=4.0
 pyyaml>=5.1
 click>=7.0
-networkx
+networkx<3.6
 lsst-daf-butler
 lsst-pipe-base
 lsst-ctrl-mpexec

lsst_ctrl_bps-29.2025.4900/tests/test_drivers.py

@@ -0,0 +1,329 @@
+# This file is part of ctrl_bps.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This software is dual licensed under the GNU General Public License and also
+# under a 3-clause BSD license. Recipients may choose which of these licenses
+# to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
+# respectively.  If you choose the GPL option then the following text applies
+# (but note that there is still no warranty even if you opt for BSD instead):
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""Unit tests for drivers.py."""
+
+import logging
+import os
+import shutil
+import tempfile
+import unittest
+
+import yaml
+
+from lsst.ctrl.bps import WmsRunReport, WmsStates
+from lsst.ctrl.bps.bps_reports import compile_code_summary, compile_job_summary
+from lsst.ctrl.bps.drivers import _init_submission_driver, ping_driver, report_driver, status_driver
+
+TESTDIR = os.path.abspath(os.path.dirname(__file__))
+
+
+class TestInitSubmissionDriver(unittest.TestCase):
+    """Test submission."""
+
+    def setUp(self):
+        self.cwd = os.getcwd()
+        self.tmpdir = tempfile.mkdtemp(dir=TESTDIR)
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir, ignore_errors=True)
+
+    @unittest.mock.patch("lsst.ctrl.bps.initialize.BPS_DEFAULTS", {})
+    def testDeprecatedOutCollection(self):
+        config = {
+            "submitPath": "bad",
+            "payload": {
+                "outCollection": "bad",
+                "outputRun": "bad",
+            },
+        }
+        with tempfile.NamedTemporaryFile(mode="w+", suffix=".yaml") as file:
+            yaml.dump(config, stream=file)
+            with self.assertRaisesRegex(KeyError, "outCollection"):
+                _init_submission_driver(file.name)
+
+    @unittest.mock.patch("lsst.ctrl.bps.initialize.BPS_DEFAULTS", {})
+    def testMissingOutputRun(self):
+        config = {"submitPath": "bad"}
+        with tempfile.NamedTemporaryFile(mode="w+", suffix=".yaml") as file:
+            yaml.dump(config, stream=file)
+            with self.assertRaisesRegex(KeyError, "outputRun"):
+                _init_submission_driver(file.name)
+
+    @unittest.mock.patch("lsst.ctrl.bps.initialize.BPS_DEFAULTS", {})
+    def testMissingSubmitPath(self):
+        config = {"payload": {"outputRun": "bad"}}
+        with tempfile.NamedTemporaryFile(mode="w+", suffix=".yaml") as file:
+            yaml.dump(config, stream=file)
+            with self.assertRaisesRegex(KeyError, "submitPath"):
+                _init_submission_driver(file.name)
+
+
+class TestPingDriver(unittest.TestCase):
+    """Test ping."""
+
+    def testWmsServiceSuccess(self):
+        retval = ping_driver("wms_test_utils.WmsServiceSuccess")
+        self.assertEqual(retval, 0)
+
+    def testWmsServiceFailure(self):
+        with self.assertLogs(level=logging.ERROR) as cm:
+            retval = ping_driver("wms_test_utils.WmsServiceFailure")
+            self.assertNotEqual(retval, 0)
+            self.assertEqual(cm.records[0].getMessage(), "Couldn't contact service X")
+
+    def testWmsServiceEnvVar(self):
+        with unittest.mock.patch.dict(
+            os.environ, {"BPS_WMS_SERVICE_CLASS": "wms_test_utils.WmsServiceSuccess"}
+        ):
+            retval = ping_driver()
+            self.assertEqual(retval, 0)
+
+    @unittest.mock.patch(
+        "lsst.ctrl.bps.drivers.BPS_DEFAULTS", {"wmsServiceClass": "wms_test_utils.WmsServiceDefault"}
+    )
+    def testWmsServiceNone(self):
+        with unittest.mock.patch.dict(os.environ, {}):
+            with self.assertLogs(level=logging.INFO) as cm:
+                retval = ping_driver()
+                self.assertEqual(retval, 0)
+                self.assertEqual(cm.records[0].getMessage(), "DEFAULT None")
+
+    def testWmsServicePassThru(self):
+        with self.assertLogs(level=logging.INFO) as cm:
+            retval = ping_driver("wms_test_utils.WmsServicePassThru", "EXTRA_VALUES")
+            self.assertEqual(retval, 0)
+            self.assertRegex(cm.output[0], "INFO.+EXTRA_VALUES")
+
+
+class TestStatusDriver(unittest.TestCase):
+    """Test status_driver function."""
+
+    def testWmsServiceSuccess(self):
+        with self.assertLogs(level=logging.INFO) as cm:
+            retval = status_driver("wms_test_utils.WmsServiceSuccess", run_id="/dummy/path", hist_days=3)
+            self.assertEqual(retval, WmsStates.SUCCEEDED.value)
+            self.assertEqual(cm.records[0].getMessage(), "status: SUCCEEDED")
+
+    def testWmsServiceFailure(self):
+        with self.assertLogs(level=logging.WARNING) as cm:
+            retval = status_driver("wms_test_utils.WmsServiceFailure", run_id="/dummy/path", hist_days=3)
+            self.assertEqual(retval, WmsStates.FAILED.value)
+            self.assertEqual(cm.records[0].getMessage(), "Dummy error message.")
+
+    @unittest.mock.patch(
+        "lsst.ctrl.bps.drivers.BPS_DEFAULTS", {"wmsServiceClass": "wms_test_utils.WmsServiceDefault"}
+    )
+    def testWmsServiceNone(self):
+        with unittest.mock.patch.dict(os.environ, {}):
+            retval = status_driver(None, run_id="/dummy/path", hist_days=3)
+            self.assertEqual(retval, WmsStates.RUNNING.value)
+
+
+class TestReportDriver(unittest.TestCase):
+    """Test report_driver function."""
+
+    @unittest.mock.patch(
+        "lsst.ctrl.bps.drivers.BPS_DEFAULTS", new={"wmsServiceClass": "wms_test_utils.WmsServiceSuccess"}
+    )
+    def testWmsServiceFromDefaults(self):
+        # Should not raise an exception and use default from BPS_DEFAULTS.
+        with unittest.mock.patch.dict(os.environ, {}, clear=True):
+            report_driver(
+                wms_service=None,
+                run_id=None,
+                user=None,
+                hist_days=0,
+                pass_thru=None,
+            )
+
+    def testWmsServiceFromEnvVar(self):
+        # Should not raise an exception.
+        with unittest.mock.patch.dict(
+            os.environ, {"BPS_WMS_SERVICE_CLASS": "wms_test_utils.WmsServiceSuccess"}
+        ):
+            report_driver(
+                wms_service=None,
+                run_id=None,
+                user=None,
+                hist_days=0.0,
+                pass_thru=None,
+            )
+
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.retrieve_report")
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.display_report")
+    def testHistDefault(self, mock_display, mock_retrieve):
+        mock_retrieve.return_value = ([], [])
+
+        report_driver(
+            wms_service="wms_test_utils.WmsServiceSuccess",
+            run_id="123",
+            user=None,
+            hist_days=0.0,
+            pass_thru=None,
+        )
+
+        # Verify retrieve_report was called with the default hist setting.
+        _, kwargs = mock_retrieve.call_args
+        self.assertAlmostEqual(kwargs["hist"], 2.0)
+
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.retrieve_report")
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.display_report")
+    def testHistCustom(self, mock_display, mock_retrieve):
+        mock_retrieve.return_value = ([], [])
+
+        report_driver(
+            wms_service="wms_test_utils.WmsServiceSuccess",
+            run_id="123",
+            user=None,
+            hist_days=4.0,
+            pass_thru=None,
+        )
+
+        # Verify retrieve_report was called with a custom hist setting.
+        _, kwargs = mock_retrieve.call_args
+        self.assertAlmostEqual(kwargs["hist"], 4.0)
+
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.retrieve_report")
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.display_report")
+    def testPostprocessorsWithoutExitCodes(self, mock_display, mock_retrieve):
+        mock_retrieve.return_value = ([], [])
+
+        report_driver(
+            wms_service="wms_test_utils.WmsServiceSuccess",
+            run_id="123",
+            user=None,
+            hist_days=0.0,
+            pass_thru=None,
+            return_exit_codes=False,
+        )
+
+        # Verify the postprocessors list contains only one postprocessor.
+        args, kwargs = mock_retrieve.call_args
+        self.assertEqual(len(kwargs["postprocessors"]), 1)
+        self.assertIn(compile_job_summary, kwargs["postprocessors"])
+
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.retrieve_report")
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.display_report")
+    def testPostprocessorsWithExitCodes(self, mock_display, mock_retrieve):
+        mock_retrieve.return_value = ([], [])
+
+        report_driver(
+            wms_service="wms_test_utils.WmsServiceSuccess",
+            run_id="123",
+            user=None,
+            hist_days=0.0,
+            pass_thru=None,
+            return_exit_codes=True,
+        )
+
+        # Verify the postprocessors list contains both postprocessors.
+        _, kwargs = mock_retrieve.call_args
+        self.assertEqual(len(kwargs["postprocessors"]), 2)
+        self.assertIn(compile_code_summary, kwargs["postprocessors"])
+        self.assertIn(compile_job_summary, kwargs["postprocessors"])
+
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.retrieve_report")
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.display_report")
+    def testPostprocessorsNoRunId(self, mock_display, mock_retrieve):
+        mock_retrieve.return_value = ([], [])
+
+        report_driver(
+            wms_service="wms_test_utils.WmsServiceSuccess",
+            run_id=None,
+            user=None,
+            hist_days=0.0,
+            pass_thru=None,
+        )
+
+        # Verify postprocessors contains compile_job_summary
+        _, kwargs = mock_retrieve.call_args
+        self.assertIsNone(kwargs["postprocessors"])
+
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.retrieve_report")
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.display_report")
+    def testDisplayCalledIfRuns(self, mock_display, mock_retrieve):
+        mock_runs = [WmsRunReport(wms_id="1", state=WmsStates.SUCCEEDED)]
+        mock_retrieve.return_value = (mock_runs, [])
+
+        report_driver(
+            wms_service="wms_test_utils.WmsServiceSuccess",
+            run_id=None,
+            user=None,
+            hist_days=0,
+            pass_thru=None,
+        )
+
+        # Verify display_report was called with the runs
+        mock_display.assert_called_once()
+        args, kwargs = mock_display.call_args
+        self.assertEqual(args[0], mock_runs)
+
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.retrieve_report")
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.display_report")
+    def testDisplayCalledIfMessages(self, mock_display, mock_retrieve):
+        mock_messages = ["Warning message 1", "Warning message 2"]
+        mock_retrieve.return_value = ([], mock_messages)
+
+        report_driver(
+            wms_service="wms_test_utils.WmsServiceSuccess",
+            run_id=None,
+            user=None,
+            hist_days=0,
+            pass_thru=None,
+        )
+
+        # Verify display_report was called with messages
+        mock_display.assert_called_once()
+        args, kwargs = mock_display.call_args
+        self.assertEqual(args[1], mock_messages)
+
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.retrieve_report")
+    @unittest.mock.patch("lsst.ctrl.bps.drivers.display_report")
+    @unittest.mock.patch("builtins.print")
+    def testNoRecordsFoundMessage(self, mock_print, mock_display, mock_retrieve):
+        mock_retrieve.return_value = ([], [])
+
+        report_driver(
+            wms_service="wms_test_utils.WmsServiceSuccess",
+            run_id="123",
+            user=None,
+            hist_days=1.5,
+            pass_thru=None,
+        )
+
+        # Verify display_report() was NOT called.
+        mock_display.assert_not_called()
+
+        # Verify that a helpful message was printed.
+        mock_print.assert_called_once()
+        call_args = mock_print.call_args[0][0]
+        self.assertIn("No records found", call_args)
+        self.assertIn("123", call_args)
+
+
+if __name__ == "__main__":
+    unittest.main()

{lsst_ctrl_bps-29.2025.4600 → lsst_ctrl_bps-29.2025.4900}/tests/test_pre_transform.py

@@ -194,7 +194,8 @@ class TestClusterQuanta(unittest.TestCase):
             "validateClusteredQgraph": True,
         }
         config = BpsConfig(settings, search_order=[])
-        qgraph = InMemoryRepo().make_quantum_graph()
+        with InMemoryRepo() as repo:
+            qgraph = repo.make_quantum_graph()
         with self.assertRaisesRegex(RuntimeError, "Fake error"):
             _ = cluster_quanta(config, qgraph, "a_name")
 
@@ -208,7 +209,8 @@ class TestClusterQuanta(unittest.TestCase):
             "validateClusteredQgraph": False,
         }
         config = BpsConfig(settings, search_order=[])
-        qgraph = InMemoryRepo().make_quantum_graph()
+        with InMemoryRepo() as repo:
+            qgraph = repo.make_quantum_graph()
         _ = cluster_quanta(config, qgraph, "a_name")
 
 

lsst_ctrl_bps-29.2025.4600/python/lsst/ctrl/bps/version.py

@@ -1,2 +0,0 @@
-__all__ = ["__version__"]
-__version__ = "29.2025.4600"

lsst_ctrl_bps-29.2025.4600/tests/test_drivers.py

@@ -1,146 +0,0 @@
-# This file is part of ctrl_bps.
-#
-# Developed for the LSST Data Management System.
-# This product includes software developed by the LSST Project
-# (https://www.lsst.org).
-# See the COPYRIGHT file at the top-level directory of this distribution
-# for details of code ownership.
-#
-# This software is dual licensed under the GNU General Public License and also
-# under a 3-clause BSD license. Recipients may choose which of these licenses
-# to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
-# respectively.  If you choose the GPL option then the following text applies
-# (but note that there is still no warranty even if you opt for BSD instead):
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-"""Unit tests for drivers.py."""
-
-import logging
-import os
-import shutil
-import tempfile
-import unittest
-
-import yaml
-
-from lsst.ctrl.bps import WmsStates
-from lsst.ctrl.bps.drivers import _init_submission_driver, ping_driver, status_driver
-
-TESTDIR = os.path.abspath(os.path.dirname(__file__))
-
-
-class TestInitSubmissionDriver(unittest.TestCase):
-    """Test submission."""
-
-    def setUp(self):
-        self.cwd = os.getcwd()
-        self.tmpdir = tempfile.mkdtemp(dir=TESTDIR)
-
-    def tearDown(self):
-        shutil.rmtree(self.tmpdir, ignore_errors=True)
-
-    @unittest.mock.patch("lsst.ctrl.bps.initialize.BPS_DEFAULTS", {})
-    def testDeprecatedOutCollection(self):
-        config = {
-            "submitPath": "bad",
-            "payload": {
-                "outCollection": "bad",
-                "outputRun": "bad",
-            },
-        }
-        with tempfile.NamedTemporaryFile(mode="w+", suffix=".yaml") as file:
-            yaml.dump(config, stream=file)
-            with self.assertRaisesRegex(KeyError, "outCollection"):
-                _init_submission_driver(file.name)
-
-    @unittest.mock.patch("lsst.ctrl.bps.initialize.BPS_DEFAULTS", {})
-    def testMissingOutputRun(self):
-        config = {"submitPath": "bad"}
-        with tempfile.NamedTemporaryFile(mode="w+", suffix=".yaml") as file:
-            yaml.dump(config, stream=file)
-            with self.assertRaisesRegex(KeyError, "outputRun"):
-                _init_submission_driver(file.name)
-
-    @unittest.mock.patch("lsst.ctrl.bps.initialize.BPS_DEFAULTS", {})
-    def testMissingSubmitPath(self):
-        config = {"payload": {"outputRun": "bad"}}
-        with tempfile.NamedTemporaryFile(mode="w+", suffix=".yaml") as file:
-            yaml.dump(config, stream=file)
-            with self.assertRaisesRegex(KeyError, "submitPath"):
-                _init_submission_driver(file.name)
-
-
-class TestPingDriver(unittest.TestCase):
-    """Test ping."""
-
-    def testWmsServiceSuccess(self):
-        retval = ping_driver("wms_test_utils.WmsServiceSuccess")
-        self.assertEqual(retval, 0)
-
-    def testWmsServiceFailure(self):
-        with self.assertLogs(level=logging.ERROR) as cm:
-            retval = ping_driver("wms_test_utils.WmsServiceFailure")
-            self.assertNotEqual(retval, 0)
-            self.assertEqual(cm.records[0].getMessage(), "Couldn't contact service X")
-
-    def testWmsServiceEnvVar(self):
-        with unittest.mock.patch.dict(
-            os.environ, {"BPS_WMS_SERVICE_CLASS": "wms_test_utils.WmsServiceSuccess"}
-        ):
-            retval = ping_driver()
-            self.assertEqual(retval, 0)
-
-    @unittest.mock.patch(
-        "lsst.ctrl.bps.drivers.BPS_DEFAULTS", {"wmsServiceClass": "wms_test_utils.WmsServiceDefault"}
-    )
-    def testWmsServiceNone(self):
-        with unittest.mock.patch.dict(os.environ, {}):
-            with self.assertLogs(level=logging.INFO) as cm:
-                retval = ping_driver()
-                self.assertEqual(retval, 0)
-                self.assertEqual(cm.records[0].getMessage(), "DEFAULT None")
-
-    def testWmsServicePassThru(self):
-        with self.assertLogs(level=logging.INFO) as cm:
-            retval = ping_driver("wms_test_utils.WmsServicePassThru", "EXTRA_VALUES")
-            self.assertEqual(retval, 0)
-            self.assertRegex(cm.output[0], "INFO.+EXTRA_VALUES")
-
-
-class TestStatusDriver(unittest.TestCase):
-    """Test status_driver function."""
-
-    def testWmsServiceSuccess(self):
-        with self.assertLogs(level=logging.INFO) as cm:
-            retval = status_driver("wms_test_utils.WmsServiceSuccess", run_id="/dummy/path", hist_days=3)
-            self.assertEqual(retval, WmsStates.SUCCEEDED.value)
-            self.assertEqual(cm.records[0].getMessage(), "status: SUCCEEDED")
-
-    def testWmsServiceFailure(self):
-        with self.assertLogs(level=logging.WARNING) as cm:
-            retval = status_driver("wms_test_utils.WmsServiceFailure", run_id="/dummy/path", hist_days=3)
-            self.assertEqual(retval, WmsStates.FAILED.value)
-            self.assertEqual(cm.records[0].getMessage(), "Dummy error message.")
-
-    @unittest.mock.patch(
-        "lsst.ctrl.bps.drivers.BPS_DEFAULTS", {"wmsServiceClass": "wms_test_utils.WmsServiceDefault"}
-    )
-    def testWmsServiceNone(self):
-        with unittest.mock.patch.dict(os.environ, {}):
-            retval = status_driver(None, run_id="/dummy/path", hist_days=3)
-            self.assertEqual(retval, WmsStates.RUNNING.value)
-
-
-if __name__ == "__main__":
-    unittest.main()