toil 8.0.0__py3-none-any.whl → 8.2.0__py3-none-any.whl

toil/test/lib/test_history.py

@@ -0,0 +1,236 @@
+# Copyright (C) 2015-2025 Regents of the University of California
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections.abc import Generator
+from pathlib import Path
+import logging
+import time
+
+from toil.lib.history import HistoryManager
+
+import pytest
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.DEBUG)
+
+
+class TestHistory:
+    """
+    Tests for Toil history tracking.
+
+    Each test gets its own history database.
+    """
+
+    @pytest.fixture(autouse=True, scope="function")
+    def private_history_manager(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> Generator[None]:
+        try:
+            with monkeypatch.context() as m:
+                m.setattr(
+                    HistoryManager,
+                    "database_path_override",
+                    str(tmp_path / "test-db.sqlite"),
+                )
+                m.setattr(HistoryManager, "enabled", lambda: True)
+                m.setattr(HistoryManager, "enabled_job", lambda: True)
+                yield
+        finally:
+            pass  # no cleanup needed
+
+    def make_fake_workflow(self, workflow_id: str) -> None:
+        # Make a fake workflow
+        workflow_jobstore_spec = "file:/tmp/tree"
+        HistoryManager.record_workflow_creation(workflow_id, workflow_jobstore_spec)
+        workflow_name = "SuperCoolWF"
+        workflow_trs_spec = "#wf:v1"
+        HistoryManager.record_workflow_metadata(
+            workflow_id, workflow_name, workflow_trs_spec
+        )
+
+        # Give it a job
+        workflow_attempt_number = 1
+        job_name = "DoThing"
+        succeeded = True
+        start_time = time.time()
+        runtime = 0.1
+        HistoryManager.record_job_attempt(
+            workflow_id,
+            workflow_attempt_number,
+            job_name,
+            succeeded,
+            start_time,
+            runtime,
+        )
+
+        # Give it a workflow attempt with the same details.
+        HistoryManager.record_workflow_attempt(
+            workflow_id,
+            workflow_attempt_number,
+            succeeded,
+            start_time,
+            runtime,
+        )
+
+    def test_history_submittable_detection(self) -> None:
+        """
+        Make sure that a submittable workflow shows up as such before
+        submission and doesn't afterward.
+        """
+        workflow_id = "123"
+        self.make_fake_workflow(workflow_id)
+        workflow_attempt_number = 1
+
+        # Make sure we have data
+        assert HistoryManager.count_workflows() == 1
+        assert HistoryManager.count_workflow_attempts() == 1
+        assert HistoryManager.count_job_attempts() == 1
+
+        # Make sure we see it as submittable
+        submittable_workflow_attempts = (
+            HistoryManager.get_submittable_workflow_attempts()
+        )
+        assert len(submittable_workflow_attempts) == 1
+
+        # Make sure we see its jobs as submittable
+        with_submittable_job_attempts = (
+            HistoryManager.get_workflow_attempts_with_submittable_job_attempts()
+        )
+        assert len(with_submittable_job_attempts) == 1
+
+        # Make sure we actually see the job
+        submittable_job_attempts = HistoryManager.get_unsubmitted_job_attempts(
+            workflow_id, workflow_attempt_number
+        )
+        assert len(submittable_job_attempts) == 1
+
+        # Pretend we submitted them.
+        HistoryManager.mark_job_attempts_submitted(
+            [j.id for j in submittable_job_attempts]
+        )
+        HistoryManager.mark_workflow_attempt_submitted(
+            workflow_id, workflow_attempt_number
+        )
+
+        # Make sure they are no longer matching
+        assert len(HistoryManager.get_submittable_workflow_attempts()) == 0
+        assert (
+            len(HistoryManager.get_workflow_attempts_with_submittable_job_attempts())
+            == 0
+        )
+        assert (
+            len(
+                HistoryManager.get_unsubmitted_job_attempts(
+                    workflow_id, workflow_attempt_number
+                )
+            )
+            == 0
+        )
+
+        # Make sure we still have data
+        assert HistoryManager.count_workflows() == 1
+        assert HistoryManager.count_workflow_attempts() == 1
+        assert HistoryManager.count_job_attempts() == 1
+
+    def test_history_deletion(self) -> None:
+        workflow_id = "123"
+        self.make_fake_workflow(workflow_id)
+        workflow_attempt_number = 1
+
+        # Make sure we can see the workflow for deletion by age but not by done-ness
+        assert len(HistoryManager.get_oldest_workflow_ids()) == 1
+        assert len(HistoryManager.get_fully_submitted_workflow_ids()) == 0
+
+        # Pretend we submitted the workflow.
+        HistoryManager.mark_job_attempts_submitted(
+            [
+                j.id
+                for j in HistoryManager.get_unsubmitted_job_attempts(
+                    workflow_id, workflow_attempt_number
+                )
+            ]
+        )
+        HistoryManager.mark_workflow_attempt_submitted(
+            workflow_id, workflow_attempt_number
+        )
+
+        # Make sure we can see the workflow for deletion by done-ness
+        assert len(HistoryManager.get_fully_submitted_workflow_ids()) == 1
+
+        # Add a new workflow
+        other_workflow_id = "456"
+        self.make_fake_workflow(other_workflow_id)
+
+        # Make sure we can see the both for deletion by age but only one by done-ness
+        assert len(HistoryManager.get_oldest_workflow_ids()) == 2
+        assert len(HistoryManager.get_fully_submitted_workflow_ids()) == 1
+
+        # Make sure the older workflow is first.
+        assert HistoryManager.get_oldest_workflow_ids() == [
+            workflow_id,
+            other_workflow_id,
+        ]
+
+        # Delete the new workflow
+        HistoryManager.delete_workflow(other_workflow_id)
+
+        # Make sure we can see the old one
+        assert HistoryManager.get_oldest_workflow_ids() == [workflow_id]
+        assert HistoryManager.get_fully_submitted_workflow_ids() == [workflow_id]
+
+        # Delete the old workflow
+        HistoryManager.delete_workflow(workflow_id)
+
+        # Make sure we have no data
+        assert HistoryManager.count_workflows() == 0
+        assert HistoryManager.count_workflow_attempts() == 0
+        assert HistoryManager.count_job_attempts() == 0
+
+    def test_history_size_limit(self) -> None:
+        """
+        Make sure the database size can be controlled.
+        """
+
+        for workflow_id in (
+            "WorkflowThatTakesUpSomeSpace,ActuallyMoreThanTheLaterOnesTake" + str(i)
+            for i in range(10)
+        ):
+            self.make_fake_workflow(workflow_id)
+
+        # We should see the workflows.
+        assert HistoryManager.count_workflows() == 10
+        # And they take up space.
+        small_size = HistoryManager.get_database_byte_size()
+        assert small_size > 0
+
+        # Add a bunch more
+        for workflow_id in ("WorkflowThatTakesUpSpace" + str(i) for i in range(50)):
+            self.make_fake_workflow(workflow_id)
+
+        # We should see that this is now a much larger database
+        large_size = HistoryManager.get_database_byte_size()
+        logger.info("Increased database size from %s to %s", small_size, large_size)
+        large_size > small_size
+
+        # We should be able to shrink it back down
+        HistoryManager.enforce_byte_size_limit(small_size)
+
+        reduced_size = HistoryManager.get_database_byte_size()
+        logger.info("Decreased database size from %s to %s", large_size, reduced_size)
+        # The database should be small enough
+        reduced_size <= small_size
+        # There should still be some workflow attempts left in the smaller database (though probably not the first ones)
+        remaining_workflows = HistoryManager.count_workflows()
+        logger.info("Still have %s workflows", remaining_workflows)
+        assert remaining_workflows > 0

toil/test/lib/test_trs.py

@@ -0,0 +1,161 @@
+# Copyright (C) 2015-2024 Regents of the University of California
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import io
+import logging
+import pytest
+from typing import IO
+import urllib.request
+from urllib.error import URLError
+
+from toil.lib.retry import retry
+from toil.lib.trs import find_workflow, fetch_workflow
+from toil.test import ToilTest, needs_online
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.DEBUG)
+
+@pytest.mark.integrative
+@needs_online
+class DockstoreLookupTest(ToilTest):
+    """
+    Make sure we can look up workflows on Dockstore.
+    """
+
+    @retry(errors=[URLError, RuntimeError])
+    def read_result(self, url_or_path: str) -> IO[bytes]:
+        """
+        Read a file or URL.
+
+        Binary mode to allow testing for binary file support.
+
+        This lets us test that we have the right workflow contents and not care
+        how we are being shown them.
+        """
+        if url_or_path.startswith("http://") or url_or_path.startswith("https://"):
+            response = urllib.request.urlopen(url_or_path)
+            if response.status != 200:
+                raise RuntimeError(f"HTTP error response: {response}")
+            return response
+        else:
+            return open(url_or_path, "rb")
+
+    # TODO: Tests that definitely test a clear cache
+
+    def test_lookup_from_page_url(self) -> None:
+        PAGE_URL = "https://dockstore.org/workflows/github.com/dockstore/bcc2020-training/HelloWorld:master?tab=info"
+        trs_id, trs_version, language = find_workflow(PAGE_URL)
+
+        self.assertEqual(trs_id, "#workflow/github.com/dockstore/bcc2020-training/HelloWorld")
+        self.assertEqual(trs_version, "master")
+        self.assertEqual(language, "WDL")
+
+    def test_lookup_from_trs_with_version(self) -> None:
+        TRS_ID = "#workflow/github.com/dockstore-testing/md5sum-checker"
+        TRS_VERSION = "master"
+        trs_id, trs_version, language = find_workflow(f"{TRS_ID}:{TRS_VERSION}")
+        
+        self.assertEqual(trs_id, TRS_ID)
+        self.assertEqual(trs_version, TRS_VERSION)
+        self.assertEqual(language, "CWL")
+
+    def test_lookup_from_trs_no_version(self) -> None:
+        TRS_ID = "#workflow/github.com/dockstore-testing/md5sum-checker"
+        with pytest.raises(ValueError):
+            # We don't yet have a way to read Dockstore's default version info,
+            # so it's not safe to apply any default version when multiple
+            # versions exist.
+            trs_id, trs_version, language = find_workflow(TRS_ID)
+
+    # TODO: Add a test with a workflow that we know has and will only ever
+    # have one version, to test version auto-detection in that case.
+
+    def test_get(self) -> None:
+        TRS_ID = "#workflow/github.com/dockstore-testing/md5sum-checker"
+        TRS_VERSION = "master"
+        LANGUAGE = "CWL"
+        # Despite "-checker" in the ID, this actually refers to the base md5sum
+        # workflow that just happens to have a checker *available*, not to the
+        # checker workflow itself.
+        WORKFLOW_URL = "https://raw.githubusercontent.com/dockstore-testing/md5sum-checker/master/md5sum/md5sum-workflow.cwl"
+        looked_up = fetch_workflow(TRS_ID, TRS_VERSION, LANGUAGE)
+        
+        data_from_lookup = self.read_result(looked_up).read()
+        data_from_source = self.read_result(WORKFLOW_URL).read()
+        self.assertEqual(data_from_lookup, data_from_source)
+
+    def test_get_from_trs_cached(self) -> None:
+        TRS_ID = "#workflow/github.com/dockstore-testing/md5sum-checker"
+        TRS_VERSION = "master"
+        LANGUAGE = "CWL"
+        WORKFLOW_URL = "https://raw.githubusercontent.com/dockstore-testing/md5sum-checker/master/md5sum/md5sum-workflow.cwl"
+        # This lookup may or may not be cached
+        fetch_workflow(TRS_ID, TRS_VERSION, LANGUAGE)
+        # This lookup is definitely cached
+        looked_up = fetch_workflow(TRS_ID, TRS_VERSION, LANGUAGE)
+        
+        data_from_lookup = self.read_result(looked_up).read()
+        data_from_source = self.read_result(WORKFLOW_URL).read()
+        self.assertEqual(data_from_lookup, data_from_source)
+
+    def test_lookup_from_trs_with_version(self) -> None:
+        TRS_VERSIONED_ID = "#workflow/github.com/dockstore-testing/md5sum-checker:workflowWithHTTPImport"
+        trs_id, trs_version, language = find_workflow(TRS_VERSIONED_ID)
+        
+        parts = TRS_VERSIONED_ID.split(":")
+
+        self.assertEqual(trs_id, parts[0])
+        self.assertEqual(trs_version, parts[1])
+        self.assertEqual(language, "CWL")
+
+    def test_lookup_from_trs_nonexistent_workflow(self) -> None:
+        TRS_VERSIONED_ID = "#workflow/github.com/adamnovak/veryfakerepo:notARealVersion"
+        with self.assertRaises(FileNotFoundError):
+            looked_up = find_workflow(TRS_VERSIONED_ID)
+
+    def test_lookup_from_trs_nonexistent_workflow_bad_format(self) -> None:
+        TRS_VERSIONED_ID = "#workflow/AbsoluteGarbage:notARealVersion"
+        with self.assertRaises(FileNotFoundError):
+            looked_up = find_workflow(TRS_VERSIONED_ID)
+
+    def test_lookup_from_trs_nonexistent_version(self) -> None:
+        TRS_VERSIONED_ID = "#workflow/github.com/dockstore-testing/md5sum-checker:notARealVersion"
+        with self.assertRaises(FileNotFoundError):
+            looked_up = find_workflow(TRS_VERSIONED_ID)
+    
+    def test_get_nonexistent_workflow(self) -> None:
+        TRS_ID = "#workflow/github.com/adamnovak/veryfakerepo"
+        TRS_VERSION = "notARealVersion"
+        LANGUAGE = "CWL"
+        with self.assertRaises(FileNotFoundError):
+            looked_up = fetch_workflow(TRS_ID, TRS_VERSION, LANGUAGE)
+
+    def test_get_nonexistent_version(self) -> None:
+        TRS_ID = "#workflow/github.com/dockstore-testing/md5sum-checker"
+        TRS_VERSION = "notARealVersion"
+        LANGUAGE = "CWL"
+        with self.assertRaises(FileNotFoundError):
+            looked_up = fetch_workflow(TRS_ID, TRS_VERSION, LANGUAGE)
+
+    def test_get_nonexistent_workflow_bad_format(self) -> None:
+        # Dockstore enforces an ID pattern and blames your request if you ask
+        # about something that doesn't follow it. So don't follow it.
+        TRS_ID = "#workflow/AbsoluteGarbage"
+        TRS_VERSION = "notARealVersion"
+        LANGUAGE = "CWL"
+        with self.assertRaises(FileNotFoundError):
+            looked_up = fetch_workflow(TRS_ID, TRS_VERSION, LANGUAGE)
+
+
+

toil/test/provisioners/aws/awsProvisionerTest.py

@@ -28,6 +28,7 @@ from toil.provisioners import cluster_factory
 from toil.provisioners.aws.awsProvisioner import AWSProvisioner
 from toil.test import (
     ToilTest,
+    get_data,
     integrative,
     needs_aws_ec2,
     needs_fetchable_appliance,
@@ -135,7 +136,7 @@ class AbstractAWSAutoscaleTest(AbstractClusterTest):
         """
         return os.path.join(self.dataDir, filename)
 
-    def rsyncUtil(self, src, dest):
+    def rsyncUtil(self, src: str, dest: str) -> None:
         subprocess.check_call(
             [
                 "toil",
@@ -285,10 +286,11 @@ class AWSAutoscaleTest(AbstractAWSAutoscaleTest):
         with open(fileToSort, "w") as f:
             # Fixme: making this file larger causes the test to hang
             f.write("01234567890123456789012345678901")
-        self.rsyncUtil(
-            os.path.join(self._projectRootPath(), "src/toil/test/sort/sort.py"),
-            ":" + self.script(),
-        )
+        with get_data("test/sort/sort.py") as sort_py:
+            self.rsyncUtil(
+                sort_py,
+                ":" + self.script(),
+            )
         self.rsyncUtil(fileToSort, ":" + self.data("sortFile"))
         os.unlink(fileToSort)
 
@@ -501,10 +503,11 @@ class AWSAutoscaleTestMultipleNodeTypes(AbstractAWSAutoscaleTest):
         sseKeyFile = os.path.join(os.getcwd(), "keyFile")
         with open(sseKeyFile, "w") as f:
             f.write("01234567890123456789012345678901")
-        self.rsyncUtil(
-            os.path.join(self._projectRootPath(), "src/toil/test/sort/sort.py"),
-            ":" + self.script(),
-        )
+        with get_data("test/sort/sort.py") as sort_py:
+            self.rsyncUtil(
+                sort_py,
+                ":" + self.script(),
+            )
         self.rsyncUtil(sseKeyFile, ":" + self.data("keyFile"))
         os.unlink(sseKeyFile)
 

toil/test/provisioners/clusterTest.py

@@ -39,7 +39,7 @@ log = logging.getLogger(__name__)
 class AbstractClusterTest(ToilTest):
     def __init__(self, methodName: str) -> None:
         super().__init__(methodName=methodName)
-        self.keyName = os.getenv("TOIL_AWS_KEYNAME").strip() or "id_rsa"
+        self.keyName = os.getenv("TOIL_AWS_KEYNAME", "id_rsa").strip()
         self.clusterName = f"aws-provisioner-test-{uuid4()}"
         self.leaderNodeType = "t2.medium"
         self.clusterType = "mesos"
@@ -276,12 +276,12 @@ class CWLOnARMTest(AbstractClusterTest):
             ]
         )
 
-        # Runs the CWLv12Test on an ARM instance
+        # Runs the TestCWLv12 on an ARM instance
         self.sshUtil(
             [
                 "bash",
                 "-c",
-                f". .{self.venvDir}/bin/activate && cd {self.cwl_test_dir}/toil && pytest --log-cli-level DEBUG -r s src/toil/test/cwl/cwlTest.py::CWLv12Test::test_run_conformance",
+                f". .{self.venvDir}/bin/activate && cd {self.cwl_test_dir}/toil && pytest --log-cli-level DEBUG -r s src/toil/test/cwl/cwlTest.py::TestCWLv12::test_run_conformance",
             ]
         )
 
@@ -289,5 +289,5 @@ class CWLOnARMTest(AbstractClusterTest):
         # Bring it back to be an artifact.
         self.rsync_util(
             f":{self.cwl_test_dir}/toil/conformance-1.2.junit.xml",
-            os.path.join(self._projectRootPath(), "arm-conformance-1.2.junit.xml"),
+            str(self._rootpath / "arm-conformance-1.2.junit.xml"),
         )

toil/test/provisioners/gceProvisionerTest.py

@@ -21,6 +21,7 @@ import pytest
 
 from toil.test import (
     ToilTest,
+    get_data,
     integrative,
     needs_fetchable_appliance,
     needs_google_project,
@@ -214,10 +215,11 @@ class GCEAutoscaleTest(AbstractGCEAutoscaleTest):
         with open(fileToSort, "w") as f:
             # Fixme: making this file larger causes the test to hang
             f.write("01234567890123456789012345678901")
-        self.rsyncUtil(
-            os.path.join(self._projectRootPath(), "src/toil/test/sort/sort.py"),
-            ":/home/sort.py",
-        )
+        with get_data("test/sort/sort.py") as sort_py:
+            self.rsyncUtil(
+                sort_py,
+                ":/home/sort.py",
+            )
         self.rsyncUtil(fileToSort, ":/home/sortFile")
         os.unlink(fileToSort)
 
@@ -324,10 +326,11 @@ class GCEAutoscaleTestMultipleNodeTypes(AbstractGCEAutoscaleTest):
         sseKeyFile = os.path.join(os.getcwd(), "keyFile")
         with open(sseKeyFile, "w") as f:
             f.write("01234567890123456789012345678901")
-        self.rsyncUtil(
-            os.path.join(self._projectRootPath(), "src/toil/test/sort/sort.py"),
-            ":/home/sort.py",
-        )
+        with get_data("test/sort/sort.py") as sort_py:
+            self.rsyncUtil(
+                sort_py,
+                ":/home/sort.py",
+            )
         self.rsyncUtil(sseKeyFile, ":/home/keyFile")
         os.unlink(sseKeyFile)
 
@@ -376,12 +379,11 @@ class GCERestartTest(AbstractGCEAutoscaleTest):
         self.jobStore = f"google:{self.projectID}:restart-{uuid4()}"
 
     def _getScript(self):
-        self.rsyncUtil(
-            os.path.join(
-                self._projectRootPath(), "src/toil/test/provisioners/restartScript.py"
-            ),
-            ":" + self.scriptName,
-        )
+        with get_data("test/provisioners/restartScript.py") as restartScript:
+            self.rsyncUtil(
+                restartScript,
+                ":" + self.scriptName,
+            )
 
     def _runScript(self, toilOptions):
         # clean = onSuccess

toil/test/sort/sort.py

@@ -23,6 +23,7 @@ from configargparse import ArgumentParser
 
 from toil.common import Toil
 from toil.job import Job
+from toil.lib.misc import StrPath
 from toil.realtimeLogger import RealtimeLogger
 
 defaultLines = 1000
@@ -207,7 +208,9 @@ def getMidPoint(file, fileStart, fileEnd):
     return len(line) + fileStart - 1
 
 
-def makeFileToSort(fileName, lines=defaultLines, lineLen=defaultLineLen):
+def makeFileToSort(
+    fileName: StrPath, lines: int = defaultLines, lineLen: int = defaultLineLen
+) -> None:
     with open(fileName, "w") as f:
         for _ in range(lines):
             line = (

toil/test/src/busTest.py

@@ -14,7 +14,9 @@
 
 import logging
 import os
+from pathlib import Path
 from threading import Thread, current_thread
+from typing import NoReturn
 
 from toil.batchSystems.abstractBatchSystem import BatchJobExitReason
 from toil.bus import (
@@ -26,18 +28,17 @@ from toil.bus import (
 from toil.common import Toil
 from toil.exceptions import FailedJobsException
 from toil.job import Job
-from toil.test import ToilTest, get_temp_file
 
 logger = logging.getLogger(__name__)
 
 
-class MessageBusTest(ToilTest):
+class TestMessageBus:
 
-    def test_enum_ints_in_file(self) -> None:
+    def test_enum_ints_in_file(self, tmp_path: Path) -> None:
         """
         Make sure writing bus messages to files works with enums.
         """
-        bus_file = get_temp_file()
+        bus_file = tmp_path / "bus"
 
         bus = MessageBus()
         # Connect the handler and hold the result to protect it from GC
@@ -73,7 +74,7 @@ class MessageBusTest(ToilTest):
             # Message should always arrive in the main thread.
             nonlocal message_count
             logger.debug("Got message: %s", received)
-            self.assertEqual(current_thread(), main_thread)
+            assert current_thread() == main_thread
             message_count += 1
 
         bus.subscribe(JobIssuedMessage, handler)
@@ -101,28 +102,27 @@ class MessageBusTest(ToilTest):
             t.join()
 
         # We should ge tone message per thread, plus our own
-        self.assertEqual(box.count(JobIssuedMessage), 11)
+        assert box.count(JobIssuedMessage) == 11
         # And having polled for those, our handler should have run
-        self.assertEqual(message_count, 11)
+        assert message_count == 11
 
-    def test_restart_without_bus_path(self) -> None:
+    def test_restart_without_bus_path(self, tmp_path: Path) -> None:
         """
         Test the ability to restart a workflow when the message bus path used
         by the previous attempt is gone.
         """
-        temp_dir = self._createTempDir(purpose="tempDir")
-        job_store = self._getTestJobStorePath()
+        temp_dir = tmp_path / "tempDir"
+        temp_dir.mkdir()
+        job_store = tmp_path / "jobstore"
 
-        bus_holder_dir = os.path.join(temp_dir, "bus_holder")
-        os.mkdir(bus_holder_dir)
+        bus_holder_dir = temp_dir / "bus_holder"
+        bus_holder_dir.mkdir()
 
         start_options = Job.Runner.getDefaultOptions(job_store)
         start_options.logLevel = "DEBUG"
         start_options.retryCount = 0
         start_options.clean = "never"
-        start_options.write_messages = os.path.abspath(
-            os.path.join(bus_holder_dir, "messagebus.txt")
-        )
+        start_options.write_messages = str(bus_holder_dir / "messagebus.txt")
 
         root = Job.wrapJobFn(failing_job_fn)
 
@@ -137,7 +137,7 @@ class MessageBusTest(ToilTest):
 
         # Get rid of the bus
         os.unlink(start_options.write_messages)
-        os.rmdir(bus_holder_dir)
+        bus_holder_dir.rmdir()
 
         logger.info("Making second attempt")
 
@@ -158,7 +158,7 @@ class MessageBusTest(ToilTest):
         logger.info("Second attempt successfully failed")
 
 
-def failing_job_fn(job: Job) -> None:
+def failing_job_fn(job: Job) -> NoReturn:
     """
     This function is guaranteed to fail.
     """