toil 8.1.0b1__py3-none-any.whl → 8.2.0__py3-none-any.whl

toil/test/src/miscTests.py

@@ -14,39 +14,42 @@
 import inspect
 import logging
 import os
+import re
+from pathlib import Path
 import random
 import sys
+from types import FrameType
 from uuid import uuid4
+from typing import cast, Union
 
 from toil.common import getNodeID
 from toil.lib.exceptions import panic, raise_
 from toil.lib.io import AtomicFileCreate, atomic_install, atomic_tmp_file, mkdtemp
-from toil.lib.misc import CalledProcessErrorStderr, call_command
-from toil.test import ToilTest, slow
+from toil.lib.misc import CalledProcessErrorStderr, StrPath, call_command
+from toil.test import pslow as slow
+
+import pytest
 
 log = logging.getLogger(__name__)
 logging.basicConfig()
 
 
-class MiscTests(ToilTest):
+class TestMisc:
     """
     This class contains miscellaneous tests that don't have enough content to be their own test
     file, and that don't logically fit in with any of the other test suites.
     """
 
-    def setUp(self):
-        super().setUp()
-        self.testDir = self._createTempDir()
-
-    def testIDStability(self):
+    def testIDStability(self) -> None:
         prevNodeID = None
         for i in range(10, 1):
             nodeID = getNodeID()
-            self.assertEqual(nodeID, prevNodeID)
+            assert nodeID == prevNodeID
             prevNodeID = nodeID
 
     @slow
-    def testGetSizeOfDirectoryWorks(self):
+    @pytest.mark.slow
+    def testGetSizeOfDirectoryWorks(self, tmp_path: Path) -> None:
         """A test to make sure toil.common.getDirSizeRecursively does not
         underestimate the amount of disk space needed.
 
@@ -58,9 +61,9 @@ class MiscTests(ToilTest):
         from toil.common import getDirSizeRecursively
 
         # a list of the directories used in the test
-        directories = [self.testDir]
-        # A dict of {FILENAME: FILESIZE} for all files used in the test
-        files = {}
+        directories: list[StrPath] = [tmp_path]
+        # A dict of {FILENAME: FILESIZE or FILELINK} for all files used in the test
+        files: dict[Path, Union[int, str]] = {}
         # Create a random directory structure
         for i in range(0, 10):
             directories.append(mkdtemp(dir=random.choice(directories), prefix="test"))
@@ -68,11 +71,11 @@ class MiscTests(ToilTest):
         # these are fresh files of size [1, 10] MB and 25% of the time they are hard links to old
         # files.
         while len(files) <= 50:
-            fileName = os.path.join(random.choice(directories), self._getRandomName())
+            fileName = Path(random.choice(directories)) / self._getRandomName()
             if random.randint(0, 100) < 75:
                 # Create a fresh file in the range of 1-10 MB
                 fileSize = int(round(random.random(), 2) * 10 * 1024 * 1024)
-                with open(fileName, "wb") as fileHandle:
+                with fileName.open("wb") as fileHandle:
                     fileHandle.write(os.urandom(fileSize))
                 files[fileName] = fileSize
             else:
@@ -83,94 +86,96 @@ class MiscTests(ToilTest):
                 os.link(linkSrc, fileName)
                 files[fileName] = "Link to %s" % linkSrc
 
-        computedDirectorySize = getDirSizeRecursively(self.testDir)
+        computedDirectorySize = getDirSizeRecursively(tmp_path)
         totalExpectedSize = sum(x for x in list(files.values()) if isinstance(x, int))
-        self.assertGreaterEqual(computedDirectorySize, totalExpectedSize)
+        assert computedDirectorySize >= totalExpectedSize
 
     @staticmethod
-    def _getRandomName():
-        return uuid4().hex
+    def _getRandomName() -> str:
+        return str(uuid4().hex)
 
-    def _get_test_out_file(self, tail):
-        outf = os.path.join(self.testDir, self.id() + "." + tail)
-        if os.path.exists(outf):
-            os.unlink(outf)
+    def _get_test_out_file(self, testDir: Path, tail: str) -> Path:
+        outf = testDir / f"test.{tail}"
+        if outf.exists():
+            outf.unlink()
         return outf
 
-    def _write_test_file(self, outf_tmp):
+    def _write_test_file(self, outf_tmp: str) -> None:
         with open(outf_tmp, "w") as fh:
-            fh.write(self.id() + "\n")
+            fh.write(Path(outf_tmp).as_uri() + "\n")
 
-    def test_atomic_install(self):
-        outf = self._get_test_out_file(".foo.gz")
+    def test_atomic_install(self, tmp_path: Path) -> None:
+        outf = self._get_test_out_file(tmp_path, ".foo.gz")
         outf_tmp = atomic_tmp_file(outf)
         self._write_test_file(outf_tmp)
         atomic_install(outf_tmp, outf)
-        self.assertTrue(os.path.exists(outf))
+        assert outf.exists()
 
-    def test_atomic_install_dev(self):
+    def test_atomic_install_dev(self) -> None:
         devn = "/dev/null"
         tmp = atomic_tmp_file(devn)
-        self.assertEqual(tmp, devn)
+        assert tmp == devn
         atomic_install(tmp, devn)
 
-    def test_atomic_context_ok(self):
-        outf = self._get_test_out_file(".tar")
+    def test_atomic_context_ok(self, tmp_path: Path) -> None:
+        outf = self._get_test_out_file(tmp_path, ".tar")
         with AtomicFileCreate(outf) as outf_tmp:
             self._write_test_file(outf_tmp)
-        self.assertTrue(os.path.exists(outf))
+        assert outf.exists()
 
-    def test_atomic_context_error(self):
-        outf = self._get_test_out_file(".tar")
+    def test_atomic_context_error(self, tmp_path: Path) -> None:
+        outf = self._get_test_out_file(tmp_path, ".tar")
         try:
             with AtomicFileCreate(outf) as outf_tmp:
                 self._write_test_file(outf_tmp)
                 raise Exception("stop!")
         except Exception as ex:
-            self.assertEqual(str(ex), "stop!")
-        self.assertFalse(os.path.exists(outf))
+            assert str(ex) == "stop!"
+        assert not os.path.exists(outf)
 
-    def test_call_command_ok(self):
+    def test_call_command_ok(self) -> None:
         o = call_command(["echo", "Fred"])
-        self.assertEqual("Fred\n", o)
-        self.assertTrue(isinstance(o, str), str(type(o)))
+        assert "Fred\n" == o
+        assert isinstance(o, str), str(type(o))
 
-    def test_call_command_err(self):
-        with self.assertRaisesRegex(
+    def test_call_command_err(self) -> None:
+        with pytest.raises(
             CalledProcessErrorStderr,
-            "^Command '\\['cat', '/dev/Frankenheimer']' exit status 1: cat: /dev/Frankenheimer: No such file or directory\n$",
+            match=re.escape(
+                "Command '['cat', '/dev/Frankenheimer']' exit status 1: cat: /dev/Frankenheimer: No such file or directory"
+            ),
         ):
             call_command(["cat", "/dev/Frankenheimer"])
 
 
-class TestPanic(ToilTest):
-    def test_panic_by_hand(self):
+class TestPanic:
+    def test_panic_by_hand(self) -> None:
         try:
             self.try_and_panic_by_hand()
         except:
             self.__assert_raised_exception_is_primary()
 
-    def test_panic(self):
+    def test_panic(self) -> None:
         try:
             self.try_and_panic()
         except:
             self.__assert_raised_exception_is_primary()
 
-    def test_panic_with_secondary(self):
+    def test_panic_with_secondary(self) -> None:
         try:
             self.try_and_panic_with_secondary()
         except:
             self.__assert_raised_exception_is_primary()
 
-    def test_nested_panic(self):
+    def test_nested_panic(self) -> None:
         try:
             self.try_and_nested_panic_with_secondary()
         except:
             self.__assert_raised_exception_is_primary()
 
-    def try_and_panic_by_hand(self):
+    def try_and_panic_by_hand(self) -> None:
         try:
-            self.line_of_primary_exc = inspect.currentframe().f_lineno + 1
+            self.line_of_primary_exc = (inspect.currentframe()).f_lineno + 1  # type: ignore[union-attr]
             raise ValueError("primary")
         except Exception:
             exc_type, exc_value, traceback = sys.exc_info()
@@ -180,35 +185,36 @@ class TestPanic(ToilTest):
                 pass
             raise_(exc_type, exc_value, traceback)
 
-    def try_and_panic(self):
+    def try_and_panic(self) -> None:
         try:
-            self.line_of_primary_exc = inspect.currentframe().f_lineno + 1
+            self.line_of_primary_exc = (inspect.currentframe()).f_lineno + 1  # type: ignore[union-attr]
             raise ValueError("primary")
         except:
             with panic(log):
                 pass
 
-    def try_and_panic_with_secondary(self):
+    def try_and_panic_with_secondary(self) -> None:
         try:
-            self.line_of_primary_exc = inspect.currentframe().f_lineno + 1
+            self.line_of_primary_exc = (inspect.currentframe()).f_lineno + 1  # type: ignore[union-attr]
             raise ValueError("primary")
         except:
             with panic(log):
                 raise RuntimeError("secondary")
 
-    def try_and_nested_panic_with_secondary(self):
+    def try_and_nested_panic_with_secondary(self) -> None:
         try:
-            self.line_of_primary_exc = inspect.currentframe().f_lineno + 1
+            self.line_of_primary_exc = (inspect.currentframe()).f_lineno + 1  # type: ignore[union-attr]
             raise ValueError("primary")
         except:
             with panic(log):
                 with panic(log):
                     raise RuntimeError("secondary")
 
-    def __assert_raised_exception_is_primary(self):
+    def __assert_raised_exception_is_primary(self) -> None:
         exc_type, exc_value, exc_traceback = sys.exc_info()
-        self.assertEqual(exc_type, ValueError)
-        self.assertEqual(str(exc_value), "primary")
+        assert exc_type == ValueError
+        assert str(exc_value) == "primary"
+        assert exc_traceback is not None
         while exc_traceback.tb_next is not None:
             exc_traceback = exc_traceback.tb_next
-        self.assertEqual(exc_traceback.tb_lineno, self.line_of_primary_exc)
+        assert exc_traceback.tb_lineno == self.line_of_primary_exc

toil/test/src/promisedRequirementTest.py

@@ -12,172 +12,162 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from collections.abc import Generator
+import argparse
 import logging
 import os
+from pathlib import Path
 import time
+from typing import Any
 
-import toil.test.batchSystems.batchSystemTest as batchSystemTest
+from toil.test.batchSystems import batchSystemTest
 from toil.batchSystems.mesos.test import MesosTestSupport
-from toil.job import Job, PromisedRequirement
+from toil.fileStores import FileID
+from toil.job import Job, PromisedRequirement, JobFunctionWrappingJob, Promise
 from toil.lib.retry import retry_flaky_test
-from toil.test import needs_mesos, slow
+from toil.test import pneeds_mesos as needs_mesos, pslow as slow
 
-log = logging.getLogger(__name__)
-
-
-class hidden:
-    """
-    Hide abstract base class from unittest's test case loader.
-
-    http://stackoverflow.com/questions/1323455/python-unit-test-with-base-and-sub-class#answer-25695512
-    """
+import pytest
 
-    class AbstractPromisedRequirementsTest(
-        batchSystemTest.hidden.AbstractBatchSystemJobTest
-    ):
-        """An abstract base class for testing Toil workflows with promised requirements."""
-
-        @slow
-        def testConcurrencyDynamic(self):
-            """
-            Asserts that promised core resources are allocated properly using a dynamic Toil workflow
-            """
-            for coresPerJob in self.allocatedCores:
-                log.debug(
-                    "Testing %d cores per job with CPU count %d",
-                    coresPerJob,
-                    self.cpuCount,
-                )
-                tempDir = self._createTempDir("testFiles")
-                counterPath = self.getCounterPath(tempDir)
-
-                root = Job.wrapJobFn(
-                    maxConcurrency,
-                    self.cpuCount,
-                    counterPath,
-                    coresPerJob,
-                    cores=1,
-                    memory="1M",
-                    disk="1M",
-                )
-                values = Job.Runner.startToil(root, self.getOptions(tempDir))
-                maxValue = max(values)
-                self.assertLessEqual(maxValue, self.cpuCount // coresPerJob)
-
-        @slow
-        @retry_flaky_test(
-            prepare=[
-                batchSystemTest.hidden.AbstractBatchSystemJobTest.tearDown,
-                batchSystemTest.hidden.AbstractBatchSystemJobTest.setUp,
-            ]
-        )
-        def testConcurrencyStatic(self):
-            """
-            Asserts that promised core resources are allocated properly using a static DAG
-            """
-            for coresPerJob in self.allocatedCores:
-                log.debug(
-                    "Testing %d cores per job with CPU count %d",
-                    coresPerJob,
-                    self.cpuCount,
-                )
-                tempDir = self._createTempDir("testFiles")
-                counterPath = self.getCounterPath(tempDir)
+log = logging.getLogger(__name__)
 
-                root = Job()
-                one = Job.wrapFn(getOne, cores=0.1, memory="32M", disk="1M")
-                thirtyTwoMb = Job.wrapFn(
-                    getThirtyTwoMb, cores=0.1, memory="32M", disk="1M"
-                )
-                root.addChild(one)
-                root.addChild(thirtyTwoMb)
-                for _ in range(self.cpuCount):
-                    root.addFollowOn(
-                        Job.wrapFn(
-                            batchSystemTest.measureConcurrency,
-                            counterPath,
-                            cores=PromisedRequirement(
-                                lambda x: x * coresPerJob, one.rv()
-                            ),
-                            memory=PromisedRequirement(thirtyTwoMb.rv()),
-                            disk="1M",
-                        )
-                    )
-                Job.Runner.startToil(root, self.getOptions(tempDir))
-                _, maxValue = batchSystemTest.getCounters(counterPath)
-                self.assertLessEqual(maxValue, self.cpuCount // coresPerJob)
-
-        def getOptions(self, tempDir, caching=True):
-            options = super().getOptions(tempDir)
-            # defaultCores defaults to 1 - this is coincidentally the core requirement relied upon by this
-            # test, so we change defaultCores to 2 to make the test more strict
-            options.defaultCores = 2
-            options.caching = caching
-            return options
-
-        def getCounterPath(self, tempDir):
-            """
-            Returns path to a counter file
-            :param str tempDir: path to test directory
-            :return: path to counter file
-            """
-            counterPath = os.path.join(tempDir, "counter")
-            batchSystemTest.resetCounters(counterPath)
-            minValue, maxValue = batchSystemTest.getCounters(counterPath)
-            assert (minValue, maxValue) == (0, 0)
-            return counterPath
-
-        def testPromisesWithJobStoreFileObjects(self, caching=True):
-            """
-            Check whether FileID objects are being pickled properly when used as return
-            values of functions.  Then ensure that lambdas of promised FileID objects can be
-            used to describe the requirements of a subsequent job.  This type of operation will be
-            used commonly in Toil scripts.
-            :return: None
-            """
-            file1 = 1024
-            file2 = 512
-            F1 = Job.wrapJobFn(_writer, file1)
-            F2 = Job.wrapJobFn(_writer, file2)
-            G = Job.wrapJobFn(
-                _follower,
-                file1 + file2,
-                disk=PromisedRequirement(
-                    lambda x, y: x.size + y.size, F1.rv(), F2.rv()
-                ),
-            )
-            F1.addChild(F2)
-            F2.addChild(G)
 
-            Job.Runner.startToil(
-                F1, self.getOptions(self._createTempDir("testFiles"), caching=caching)
+class AbstractPromisedRequirementsTest(batchSystemTest.AbstractBatchSystemJobTest):
+    """An abstract base class for testing Toil workflows with promised requirements."""
+
+    @slow
+    @pytest.mark.slow
+    def testConcurrencyDynamic(self, tmp_path: Path) -> None:
+        """
+        Asserts that promised core resources are allocated properly using a dynamic Toil workflow
+        """
+        for coresPerJob in self.allocatedCores:
+            log.debug(
+                "Testing %d cores per job with CPU count %d",
+                coresPerJob,
+                self.cpuCount,
             )
-
-        def testPromisesWithNonCachingFileStore(self):
-            self.testPromisesWithJobStoreFileObjects(caching=False)
-
-        @slow
-        def testPromiseRequirementRaceStatic(self):
-            """
-            Checks for a race condition when using promised requirements and child job functions.
-            """
-            A = Job.wrapJobFn(
-                logDiskUsage, "A", sleep=5, disk=PromisedRequirement(1024)
+            tempDir = tmp_path / f"testFiles_{coresPerJob}"
+            tempDir.mkdir()
+            counterPath = self.getCounterPath(tempDir)
+
+            root = Job.wrapJobFn(
+                maxConcurrency,
+                self.cpuCount,
+                counterPath,
+                coresPerJob,
+                cores=1,
+                memory="1M",
+                disk="1M",
             )
-            B = Job.wrapJobFn(
-                logDiskUsage, "B", disk=PromisedRequirement(lambda x: x + 1024, A.rv())
+            values = Job.Runner.startToil(root, self.getOptions(tempDir))
+            maxValue = max(values)
+            assert maxValue <= (self.cpuCount // coresPerJob)
+
+    @slow
+    @pytest.mark.slow
+    @retry_flaky_test(prepare=[])
+    def testConcurrencyStatic(self, tmp_path: Path) -> None:
+        """
+        Asserts that promised core resources are allocated properly using a static DAG
+        """
+        for coresPerJob in self.allocatedCores:
+            log.debug(
+                "Testing %d cores per job with CPU count %d",
+                coresPerJob,
+                self.cpuCount,
             )
-            A.addChild(B)
-            Job.Runner.startToil(A, self.getOptions(self._createTempDir("testFiles")))
+            tempDir = tmp_path / f"testFiles_{coresPerJob}"
+            tempDir.mkdir()
+            counterPath = self.getCounterPath(tempDir)
+
+            root = Job()
+            one = Job.wrapFn(getOne, cores=0.1, memory="32M", disk="1M")
+            thirtyTwoMb = Job.wrapFn(getThirtyTwoMb, cores=0.1, memory="32M", disk="1M")
+            root.addChild(one)
+            root.addChild(thirtyTwoMb)
+            for _ in range(self.cpuCount):
+                root.addFollowOn(
+                    Job.wrapFn(
+                        batchSystemTest.measureConcurrency,
+                        counterPath,
+                        cores=PromisedRequirement(lambda x: x * coresPerJob, one.rv()),
+                        memory=PromisedRequirement(thirtyTwoMb.rv()),
+                        disk="1M",
+                    )
+                )
+            Job.Runner.startToil(root, self.getOptions(tempDir))
+            _, maxValue = batchSystemTest.getCounters(counterPath)
+            assert maxValue <= (self.cpuCount // coresPerJob)
+
+    def getOptions(self, tempDir: Path, caching: bool = True) -> argparse.Namespace:
+        options = super().getOptions(tempDir)
+        # defaultCores defaults to 1 - this is coincidentally the core requirement relied upon by this
+        # test, so we change defaultCores to 2 to make the test more strict
+        options.defaultCores = 2
+        options.caching = caching
+        return options
+
+    def getCounterPath(self, tempDir: Path) -> Path:
+        """
+        Returns path to a counter file
+        :param tempDir: path to test directory
+        :return: path to counter file
+        """
+        counterPath = tempDir / "counter"
+        batchSystemTest.resetCounters(counterPath)
+        minValue, maxValue = batchSystemTest.getCounters(counterPath)
+        assert (minValue, maxValue) == (0, 0)
+        return counterPath
+
+    def testPromisesWithJobStoreFileObjects(
+        self, tmp_path: Path, caching: bool = True
+    ) -> None:
+        """
+        Check whether FileID objects are being pickled properly when used as return
+        values of functions.  Then ensure that lambdas of promised FileID objects can be
+        used to describe the requirements of a subsequent job.  This type of operation will be
+        used commonly in Toil scripts.
+        :return: None
+        """
+        file1 = 1024
+        file2 = 512
+        F1 = Job.wrapJobFn(_writer, file1)
+        F2 = Job.wrapJobFn(_writer, file2)
+        G = Job.wrapJobFn(
+            _follower,
+            file1 + file2,
+            disk=PromisedRequirement(lambda x, y: x.size + y.size, F1.rv(), F2.rv()),
+        )
+        F1.addChild(F2)
+        F2.addChild(G)
+
+        Job.Runner.startToil(F1, self.getOptions(tmp_path, caching=caching))
+
+    def testPromisesWithNonCachingFileStore(self, tmp_path: Path) -> None:
+        self.testPromisesWithJobStoreFileObjects(tmp_path, caching=False)
+
+    @slow
+    @pytest.mark.slow
+    def testPromiseRequirementRaceStatic(self, tmp_path: Path) -> None:
+        """
+        Checks for a race condition when using promised requirements and child job functions.
+        """
+        A = Job.wrapJobFn(logDiskUsage, "A", sleep=5, disk=PromisedRequirement(1024))
+        B = Job.wrapJobFn(
+            logDiskUsage, "B", disk=PromisedRequirement(lambda x: x + 1024, A.rv())
+        )
+        A.addChild(B)
+        Job.Runner.startToil(A, self.getOptions(tmp_path))
 
 
-def _writer(job, fileSize):
+def _writer(job: JobFunctionWrappingJob, fileSize: int) -> FileID:
     """
     Write a local file and return the FileID obtained from running writeGlobalFile on
     it.
 
-    :param job job: job
-    :param int fileSize: Size of the file in bytes
+    :param job: job
+    :param fileSize: Size of the file in bytes
     :returns: the result of writeGlobalFile on a locally created file
     :rtype: job.FileID
     """
@@ -186,26 +176,28 @@ def _writer(job, fileSize):
     return job.fileStore.writeGlobalFile(fH.name)
 
 
-def _follower(job, expectedDisk):
+def _follower(job: Job, expectedDisk: Any) -> None:
     """
     This job follows the _writer jobs and ensures the expected disk is used.
 
-    :param job job: job
+    :param job: job
     :param expectedDisk: Expect disk to be used by this job
     :return: None
     """
     assert job.disk == expectedDisk
 
 
-def maxConcurrency(job, cpuCount, filename, coresPerJob):
+def maxConcurrency(
+    job: Job, cpuCount: int, filename: Path, coresPerJob: int
+) -> list[Promise]:
     """
     Returns the max number of concurrent tasks when using a PromisedRequirement instance
     to allocate the number of cores per job.
 
-    :param int cpuCount: number of available cpus
-    :param str filename: path to counter file
-    :param int coresPerJob: number of cores assigned to each job
-    :return int max concurrency value:
+    :param cpuCount: number of available cpus
+    :param filename: path to counter file
+    :param coresPerJob: number of cores assigned to each job
+    :return: max concurrency value per CPU
     """
     one = job.addChildFn(getOne, cores=0.1, memory="32M", disk="1M")
     thirtyTwoMb = job.addChildFn(getThirtyTwoMb, cores=0.1, memory="32M", disk="1M")
@@ -223,15 +215,15 @@ def maxConcurrency(job, cpuCount, filename, coresPerJob):
     return values
 
 
-def getOne():
+def getOne() -> int:
     return 1
 
 
-def getThirtyTwoMb():
+def getThirtyTwoMb() -> str:
     return "32M"
 
 
-def logDiskUsage(job, funcName, sleep=0):
+def logDiskUsage(job: JobFunctionWrappingJob, funcName: str, sleep: int = 0) -> int:
     """
     Logs the job's disk usage to master and sleeps for specified amount of time.
 
@@ -243,34 +235,36 @@ def logDiskUsage(job, funcName, sleep=0):
     return diskUsage
 
 
-class SingleMachinePromisedRequirementsTest(hidden.AbstractPromisedRequirementsTest):
+class TestSingleMachinePromisedRequirements(AbstractPromisedRequirementsTest):
     """
     Tests against the SingleMachine batch system
     """
 
-    def getBatchSystemName(self):
+    def getBatchSystemName(self) -> str:
         return "single_machine"
 
-    def tearDown(self):
+    def tearDown(self) -> None:
         pass
 
 
 @needs_mesos
-class MesosPromisedRequirementsTest(
-    hidden.AbstractPromisedRequirementsTest, MesosTestSupport
-):
+class TestMesosPromisedRequirements(AbstractPromisedRequirementsTest, MesosTestSupport):
     """
     Tests against the Mesos batch system
     """
 
-    def getOptions(self, tempDir, caching=True):
+    @pytest.fixture(autouse=True)
+    def mesos_support(self) -> Generator[None]:
+        try:
+            self._startMesos(self.cpuCount)
+            yield
+        finally:
+            self._stopMesos()
+
+    def getOptions(self, tempDir: Path, caching: bool = True) -> argparse.Namespace:
         options = super().getOptions(tempDir, caching=caching)
         options.mesos_endpoint = "localhost:5050"
         return options
 
-    def getBatchSystemName(self):
-        self._startMesos(self.cpuCount)
+    def getBatchSystemName(self) -> str:
         return "mesos"
-
-    def tearDown(self):
-        self._stopMesos()