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

toil/test/lib/test_history.py

@@ -12,44 +12,42 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
+from collections.abc import Generator
+from pathlib import Path
 import logging
-import pytest
 import time
-from toil.test import ToilTest
 
 from toil.lib.history import HistoryManager
 
+import pytest
+
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.DEBUG)
 
-class HistoryTest(ToilTest):
+
+class TestHistory:
     """
     Tests for Toil history tracking.
 
     Each test gets its own history database.
     """
 
-    def setUp(self) -> None:
-        super().setUp()
-        
-        # Apply a temp dir override to history tracking
-        temp_dir = self._createTempDir()
-        HistoryManager.database_path_override = os.path.join(temp_dir, "test-db.sqlite")
-
-        # Flag on job history tracking
-        self.original_flag = HistoryManager.JOB_HISTORY_ENABLED
-        HistoryManager.JOB_HISTORY_ENABLED = True
-        
-
-    def tearDown(self) -> None:
-        # Remove the temp dir override from history tracking
-        HistoryManager.database_path_override = None
-
-        # Restore job history tracking flag
-        HistoryManager.JOB_HISTORY_ENABLED = self.original_flag
-
-        super().tearDown()
+    @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
@@ -57,15 +55,17 @@ class HistoryTest(ToilTest):
         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)
-        
+        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( 
+        HistoryManager.record_job_attempt(
             workflow_id,
             workflow_attempt_number,
             job_name,
@@ -93,92 +93,126 @@ class HistoryTest(ToilTest):
         workflow_attempt_number = 1
 
         # Make sure we have data
-        self.assertEqual(HistoryManager.count_workflows(), 1)
-        self.assertEqual(HistoryManager.count_workflow_attempts(), 1)
-        self.assertEqual(HistoryManager.count_job_attempts(), 1)
+        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()
-        self.assertEqual(len(submittable_workflow_attempts), 1)
+        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()
-        self.assertEqual(len(with_submittable_job_attempts), 1)
+        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)
-        self.assertEqual(len(submittable_job_attempts), 1)
+        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)
+        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
-        self.assertEqual(len(HistoryManager.get_submittable_workflow_attempts()), 0)
-        self.assertEqual(len(HistoryManager.get_workflow_attempts_with_submittable_job_attempts()), 0)
-        self.assertEqual(len(HistoryManager.get_unsubmitted_job_attempts(workflow_id, workflow_attempt_number)), 0)
+        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
-        self.assertEqual(HistoryManager.count_workflows(), 1)
-        self.assertEqual(HistoryManager.count_workflow_attempts(), 1)
-        self.assertEqual(HistoryManager.count_job_attempts(), 1)
+        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
-        self.assertEqual(len(HistoryManager.get_oldest_workflow_ids()), 1)
-        self.assertEqual(len(HistoryManager.get_fully_submitted_workflow_ids()), 0)
+        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)
+        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
-        self.assertEqual(len(HistoryManager.get_fully_submitted_workflow_ids()), 1)
+        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
-        self.assertEqual(len(HistoryManager.get_oldest_workflow_ids()), 2)
-        self.assertEqual(len(HistoryManager.get_fully_submitted_workflow_ids()), 1)
+        assert len(HistoryManager.get_oldest_workflow_ids()) == 2
+        assert len(HistoryManager.get_fully_submitted_workflow_ids()) == 1
 
         # Make sure the older workflow is first.
-        self.assertEqual(HistoryManager.get_oldest_workflow_ids(), [workflow_id, other_workflow_id])
+        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
-        self.assertEqual(HistoryManager.get_oldest_workflow_ids(), [workflow_id])
-        self.assertEqual(HistoryManager.get_fully_submitted_workflow_ids(), [workflow_id])
+        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
-        self.assertEqual(HistoryManager.count_workflows(), 0)
-        self.assertEqual(HistoryManager.count_workflow_attempts(), 0)
-        self.assertEqual(HistoryManager.count_job_attempts(), 0)
-
+        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)):
+        for workflow_id in (
+            "WorkflowThatTakesUpSomeSpace,ActuallyMoreThanTheLaterOnesTake" + str(i)
+            for i in range(10)
+        ):
             self.make_fake_workflow(workflow_id)
 
         # We should see the workflows.
-        self.assertEqual(HistoryManager.count_workflows(), 10)
+        assert HistoryManager.count_workflows() == 10
         # And they take up space.
         small_size = HistoryManager.get_database_byte_size()
-        self.assertGreater(small_size, 0)
+        assert small_size > 0
 
         # Add a bunch more
         for workflow_id in ("WorkflowThatTakesUpSpace" + str(i) for i in range(50)):
@@ -187,26 +221,16 @@ class HistoryTest(ToilTest):
         # 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)
-        self.assertGreater(large_size, small_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
-        self.assertLessEqual(reduced_size, small_size)
+        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)
-        self.assertGreater(remaining_workflows, 0)
-        
-
-
-
-
-       
-
-
-
-        
+        assert remaining_workflows > 0

toil/test/lib/test_url.py

@@ -0,0 +1,69 @@
+# Copyright (C) 2015-2022 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 getpass
+import logging
+
+from pytest_httpserver import HTTPServer
+
+from toil.lib.misc import get_user_name
+from toil.lib.url import URLAccess
+from toil.test import needs_aws_s3, needs_online
+
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.DEBUG)
+
+class TestURLAccess():
+    """
+    Test URLAccess class handling read, list,
+    and checking the size/existence of resources at given URL
+    """
+
+    def test_get_url_access(self, httpserver: HTTPServer) -> None:
+        httpserver.expect_request("/some_url").respond_with_data("Yep that's a URL")
+        file_url = httpserver.url_for("/some_url")
+        assert URLAccess.url_exists(file_url)
+
+    @needs_aws_s3
+    def test_get_size(self) -> None:
+        size = URLAccess.get_size("s3://toil-datasets/hello.txt")
+        assert isinstance(size, int)
+        assert size > 0
+
+    @needs_aws_s3
+    def test_get_is_directory(self) -> None:
+        assert not URLAccess.get_is_directory("s3://toil-datasets/hello.txt")
+
+    @needs_aws_s3
+    def test_list_url(self) -> None:
+        test_dir = URLAccess.list_url("s3://1000genomes/")
+        assert isinstance(test_dir, list)
+        assert len(test_dir) > 0
+
+    @needs_aws_s3
+    def test_read_from_url(self) -> None:
+        import io
+        output = io.BytesIO()
+        size, executable = URLAccess.read_from_url("s3://toil-datasets/hello.txt", output)
+        assert isinstance(size, int)
+        assert size > 0
+        assert not executable
+        assert len(output.getvalue()) > 0
+
+    @needs_aws_s3
+    def test_open_url(self) -> None:
+        with URLAccess.open_url("s3://toil-datasets/hello.txt") as readable:
+            content = readable.read()
+            assert isinstance(content, bytes)
+            assert len(content) > 0

toil/test/lib/url_plugin_test.py

@@ -0,0 +1,105 @@
+# 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.
+import logging
+from typing import IO, Optional, Union
+
+from configargparse import ArgParser, ArgumentParser
+
+from toil.batchSystems.abstractBatchSystem import (
+    AbstractBatchSystem,
+    UpdatedBatchJobInfo,
+)
+from toil.batchSystems.cleanup_support import BatchSystemCleanupSupport
+from toil.batchSystems.options import OptionSetter
+from toil.batchSystems.registry import add_batch_system_factory
+from toil.common import Toil, addOptions
+from toil.job import JobDescription
+
+import io
+from urllib.parse import ParseResult
+from toil.test import ToilTest
+from toil.lib.url import URLAccess
+from toil.lib.plugins import register_plugin, remove_plugin
+
+logger = logging.getLogger(__name__)
+
+class FakeURLPlugin(URLAccess):
+    @classmethod
+    def _supports_url(cls, url: ParseResult, export: bool = False) -> bool:
+        return url.scheme == "fake"
+
+    @classmethod
+    def _url_exists(cls, url: ParseResult) -> bool:
+        return url.netloc == "exists"
+
+    @classmethod
+    def _get_size(cls, url: ParseResult) -> int:
+        return 1234
+
+    @classmethod
+    def _get_is_directory(cls, url: ParseResult) -> bool:
+        return url.path.endswith("/")
+
+    @classmethod
+    def _list_url(cls, url: ParseResult) -> list[str]:
+        return ["file1.txt", "subdir/"]
+
+    @classmethod
+    def _read_from_url(cls, url: ParseResult, writable: IO[bytes]) -> tuple[int, bool]:
+        content = b"hello world"
+        writable.write(content)
+        return len(content), False
+
+    @classmethod
+    def _open_url(cls, url: ParseResult) -> IO[bytes]:
+        return io.BytesIO(b"hello world")
+
+    @classmethod
+    def _write_to_url(cls, readable: Union[IO[bytes], IO[str]], url: ParseResult, executable: bool = False) -> None:
+        pass
+
+
+class TestURLAccess(ToilTest):
+    def setUp(self) -> None:
+        super().setUp()
+        register_plugin("url_access", "fake", lambda: FakeURLPlugin)
+
+    def tearDown(self) -> None:
+        remove_plugin("url_access", "fake")
+        super().tearDown()
+
+    def test_url_exists(self) -> None:
+        assert URLAccess.url_exists("fake://exists/resource") == True
+        assert URLAccess.url_exists("fake://missing/resource") == False
+
+    def test_get_size(self) -> None:
+        assert URLAccess.get_size("fake://any/resource") == 1234
+
+    def test_get_is_directory(self) -> None:
+        assert URLAccess.get_is_directory("fake://any/folder/") == True
+        assert URLAccess.get_is_directory("fake://any/file.txt") == False
+
+    def test_list_url(self) -> None:
+        assert URLAccess.list_url("fake://any/folder/") == ["file1.txt", "subdir/"]
+
+    def test_read_from_url(self) -> None:
+        output = io.BytesIO()
+        size, _ = URLAccess.read_from_url("fake://any/resource", output)
+        assert output.getvalue() == b"hello world"
+        assert size == len("hello world")
+
+    def test_open_url(self) -> None:
+        with URLAccess.open_url("fake://any/resource") as stream:
+            content = stream.read()
+            assert content == b"hello world"

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)
 
@@ -523,7 +526,7 @@ class AWSAutoscaleTestMultipleNodeTypes(AbstractAWSAutoscaleTest):
         runCommand = [
             self.python(),
             self.script(),
-            "--fileToSort=/home/s3am/bin/asadmin",
+            "--fileToSort=/etc/passwd",
             "--sortMemory=0.6G",
             "--mergeMemory=3.0G",
         ]

toil/test/provisioners/clusterTest.py

@@ -31,6 +31,8 @@ from toil.test import (
     slow,
 )
 
+from toil.test.cwl.cwlTest import TestCWLv12Conformance
+
 log = logging.getLogger(__name__)
 
 
@@ -39,7 +41,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"
@@ -237,6 +239,17 @@ class CWLOnARMTest(AbstractClusterTest):
 
     @needs_env_var("CI_COMMIT_SHA", "a git commit sha")
     def test_cwl_on_arm(self) -> None:
+        # Import the test we want to run remotely, so we know right away if it exists.
+        test_class = TestCWLv12Conformance
+        test_method = test_class.test_run_conformance
+
+        # Work out how to describe it as a pytest test spec.
+        # __qualname__ gives classname.methodname
+        test_name = test_method.__qualname__.replace(".", "::")
+        # The module path is the file path under src, with dots.
+        test_path = test_class.__module__.replace(".", "/")
+        test_spec = f"src/{test_path}.py::{test_name}"
+
         # Make a cluster
         self.launchCluster()
         # get the leader so we know the IP address - we don't need to wait since create cluster
@@ -276,12 +289,12 @@ class CWLOnARMTest(AbstractClusterTest):
             ]
         )
 
-        # Runs the CWLv12Test on an ARM instance
+        # Runs the test 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 {test_spec}",
             ]
         )
 
@@ -289,5 +302,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)
 
@@ -338,7 +341,7 @@ class GCEAutoscaleTestMultipleNodeTypes(AbstractGCEAutoscaleTest):
         runCommand = [
             "/home/venv/bin/python",
             "/home/sort.py",
-            "--fileToSort=/home/s3am/bin/asadmin",
+            "--fileToSort=/etc/passwd",
             "--sortMemory=0.6G",
             "--mergeMemory=3.0G",
         ]
@@ -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