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

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__)
 
 
@@ -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 TestCWLv12 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::TestCWLv12::test_run_conformance",
+                f". .{self.venvDir}/bin/activate && cd {self.cwl_test_dir}/toil && pytest --log-cli-level DEBUG -r s {test_spec}",
             ]
         )
 

toil/test/provisioners/gceProvisionerTest.py

@@ -341,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",
         ]

toil/test/server/serverTest.py

@@ -33,7 +33,7 @@ except ImportError:
     # extra wasn't installed. We'll then skip them all.
     pass
 
-from toil.test import ToilTest, needs_aws_s3, needs_celery_broker, needs_server
+from toil.test import ToilTest, needs_aws_s3, needs_celery_broker, needs_cwl, needs_server, integrative
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO)
@@ -185,6 +185,7 @@ class FileStateStoreURLTest(hidden.AbstractStateStoreTest):
 
 
 @needs_aws_s3
+@integrative
 class BucketUsingTest(ToilTest):
     """
     Base class for tests that need a bucket.
@@ -268,6 +269,35 @@ class AWSStateStoreTest(hidden.AbstractStateStoreTest, BucketUsingTest):
         self.assertEqual(obj.content_length, len("testvalue"))
 
 
+# Problem: httpx (which the Connexion test client uses the API of)
+# automatically decides whether to send posts in
+# application/x-www-form-urlencoded or multipart/form-data format
+# based on whether they are uploading any files. But the GA4GH WES
+# API run workflow endpoint only accepts multipart/form-data. It takes
+# workflow_attachment as an array of binary strings officially, but this is
+# actually how Swagger takes multiple-file upload fields. See
+# <https://swagger.io/docs/specification/v2_0/file-upload/#multiple-upload>.
+# (httpx doesn't seem to support actually sending multiple files to one field
+# either, but if we send just one file it ends up as the only value in
+# Swagger's array.)
+#
+# The apparently-official workaround for forcing multipart encoding is to
+# construct an empty dict-saped data structure that is truthy, and pass that as
+# your file list. See
+# <https://github.com/encode/httpx/discussions/2399#discussioncomment-3814186>
+class TrueDict(dict):
+    """
+    Dict that is truthy even when empty.
+
+    Used as a workaround to set httpx post request encoding as recommended in
+    <https://github.com/encode/httpx/discussions/2399#discussioncomment-3814186>.
+    """
+    def __bool__(self) -> bool:
+        """
+        Always say the object is truthy.
+        """
+        return True
+
 @needs_server
 class AbstractToilWESServerTest(ToilTest):
     """
@@ -296,11 +326,12 @@ class AbstractToilWESServerTest(ToilTest):
         )
 
         # Make the FlaskApp
-        server_app = create_app(args)
+        self.app = create_app(args)
 
-        # Fish out the actual Flask
-        self.app: Flask = server_app.app
-        self.app.testing = True
+        # Neither <https://flask.palletsprojects.com/en/stable/testing/> nor
+        # <https://connexion.readthedocs.io/en/latest/testing.html#testing>
+        # suggests setting a testing flag on the Connexion app or its internal
+        # Flask app, so we don't.
 
         self.example_cwl = textwrap.dedent(
             """
@@ -345,7 +376,6 @@ class AbstractToilWESServerTest(ToilTest):
         """
         rv = client.get(f"/ga4gh/wes/v1/runs/{run_id}")
         self.assertEqual(rv.status_code, 200)
-        self.assertTrue(rv.is_json)
         return rv
 
     def _check_successful_log(self, client: "FlaskClient", run_id: str) -> None:
@@ -354,15 +384,16 @@ class AbstractToilWESServerTest(ToilTest):
         The workflow should succeed, it should have some tasks, and they should have all succeeded.
         """
         rv = self._fetch_run_log(client, run_id)
+        rv_json = rv.json()
         logger.debug("Log info: %s", rv.json)
-        run_log = rv.json.get("run_log")
+        run_log = rv_json.get("run_log")
         self.assertEqual(type(run_log), dict)
         if "exit_code" in run_log:
             # The workflow succeeded if it has an exit code
             self.assertEqual(run_log["exit_code"], 0)
         # The workflow is complete
-        self.assertEqual(rv.json.get("state"), "COMPLETE")
-        task_logs = rv.json.get("task_logs")
+        self.assertEqual(rv_json.get("state"), "COMPLETE")
+        task_logs = rv_json.get("task_logs")
         # There are tasks reported
         self.assertEqual(type(task_logs), list)
         self.assertGreater(len(task_logs), 0)
@@ -375,7 +406,7 @@ class AbstractToilWESServerTest(ToilTest):
         """Report the log for the given workflow run."""
         rv = self._fetch_run_log(client, run_id)
         logger.debug(f"Report log response: {rv.json}")
-        run_log = rv.json.get("run_log")
+        run_log = rv.json().get("run_log")
         self.assertEqual(type(run_log), dict)
         self.assertEqual(type(run_log.get("stdout")), str)
         self.assertEqual(type(run_log.get("stderr")), str)
@@ -395,12 +426,13 @@ class AbstractToilWESServerTest(ToilTest):
         logger.info("Fetch %s", url)
         rv = client.get(url)
         self.assertEqual(rv.status_code, 200)
-        logger.info("Got %s:\n%s", url, rv.data.decode("utf-8"))
+        logger.info("Got %s:\n%s", url, rv.content.decode("utf-8"))
 
     def _start_slow_workflow(self, client: "FlaskClient") -> str:
         """
         Start a slow workflow and return its ID.
         """
+
         rv = client.post(
             "/ga4gh/wes/v1/runs",
             data={
@@ -408,15 +440,18 @@ class AbstractToilWESServerTest(ToilTest):
                 "workflow_type": "CWL",
                 "workflow_type_version": "v1.0",
                 "workflow_params": json.dumps({"delay": "5"}),
-                "workflow_attachment": [
-                    (BytesIO(self.slow_cwl.encode()), "slow.cwl"),
-                ],
+            },
+            files={
+                "workflow_attachment": (
+                    "slow.cwl",
+                    BytesIO(self.slow_cwl.encode()),
+                    "application/octet-stream",
+                ),
             },
         )
         # workflow is submitted successfully
         self.assertEqual(rv.status_code, 200)
-        self.assertTrue(rv.is_json)
-        run_id = rv.json.get("run_id")
+        run_id = rv.json().get("run_id")
         self.assertIsNotNone(run_id)
 
         return run_id
@@ -428,11 +463,11 @@ class AbstractToilWESServerTest(ToilTest):
 
         rv = client.get(f"/ga4gh/wes/v1/runs/{run_id}/status")
         self.assertEqual(rv.status_code, 200)
-        self.assertTrue(rv.is_json)
-        self.assertIn("run_id", rv.json)
-        self.assertEqual(rv.json.get("run_id"), run_id)
-        self.assertIn("state", rv.json)
-        state = rv.json.get("state")
+        rv_json = rv.json()
+        self.assertIn("run_id", rv_json)
+        self.assertEqual(rv_json.get("run_id"), run_id)
+        self.assertIn("state", rv_json)
+        state = rv_json.get("state")
         self.assertIn(
             state,
             [
@@ -492,7 +527,10 @@ class ToilWESServerBenchTest(AbstractToilWESServerTest):
         """Test the homepage endpoint."""
         with self.app.test_client() as client:
             rv = client.get("/")
-        self.assertEqual(rv.status_code, 302)
+        # The client will follow the redirect and populate the url on the response
+        self.assertEqual(rv.url.path, "/ga4gh/wes/v1/service-info")
+        # We see the final 200 OK status code
+        self.assertEqual(rv.status_code, 200)
 
     def test_health(self) -> None:
         """Test the health check endpoint."""
@@ -505,7 +543,7 @@ class ToilWESServerBenchTest(AbstractToilWESServerTest):
         with self.app.test_client() as client:
             rv = client.get("/ga4gh/wes/v1/service-info")
         self.assertEqual(rv.status_code, 200)
-        service_info = json.loads(rv.data)
+        service_info = rv.json()
 
         self.assertIn("version", service_info)
         self.assertIn("workflow_type_versions", service_info)
@@ -519,7 +557,7 @@ class ToilWESServerBenchTest(AbstractToilWESServerTest):
         self.assertIn("system_state_counts", service_info)
         self.assertIn("tags", service_info)
 
-
+@needs_cwl
 class ToilWESServerWorkflowTest(AbstractToilWESServerTest):
     """
     Tests of the WES server running workflows.
@@ -548,11 +586,10 @@ class ToilWESServerWorkflowTest(AbstractToilWESServerTest):
                 {"message": "Hello, world!"} if include_message else {}
             )
         with self.app.test_client() as client:
-            rv = client.post("/ga4gh/wes/v1/runs", data=post_data)
+            rv = client.post("/ga4gh/wes/v1/runs", data=post_data, files=TrueDict())
             # workflow is submitted successfully
             self.assertEqual(rv.status_code, 200)
-            self.assertTrue(rv.is_json)
-            run_id = rv.json.get("run_id")
+            run_id = rv.json().get("run_id")
             self.assertIsNotNone(run_id)
 
             # Check status
@@ -571,11 +608,11 @@ class ToilWESServerWorkflowTest(AbstractToilWESServerTest):
                     "workflow_type_version": "v1.0",
                     "workflow_params": "{}",
                 },
+                files=TrueDict(),
             )
             self.assertEqual(rv.status_code, 400)
-            self.assertTrue(rv.is_json)
             self.assertEqual(
-                rv.json.get("msg"),
+                rv.json().get("msg"),
                 "Relative 'workflow_url' but missing 'workflow_attachment'",
             )
 
@@ -589,20 +626,24 @@ class ToilWESServerWorkflowTest(AbstractToilWESServerTest):
                     "workflow_type": "CWL",
                     "workflow_type_version": "v1.0",
                     "workflow_params": json.dumps({"message": "Hello, world!"}),
-                    "workflow_attachment": [
-                        (BytesIO(self.example_cwl.encode()), "example.cwl"),
-                    ],
+                },
+                files={
+                    "workflow_attachment": (
+                        "example.cwl",
+                        BytesIO(self.example_cwl.encode()),
+                        "application/octet-stream",
+                    ),
                 },
             )
             # workflow is submitted successfully
             self.assertEqual(rv.status_code, 200)
-            self.assertTrue(rv.is_json)
-            run_id = rv.json.get("run_id")
+            run_id = rv.json().get("run_id")
             self.assertIsNotNone(run_id)
 
             # Check status
             self._wait_for_success(client, run_id)
 
+    @integrative
     def test_run_workflow_https_url(self) -> None:
         """Test run example CWL workflow from the Internet."""
         with self.app.test_client() as client:
@@ -614,11 +655,11 @@ class ToilWESServerWorkflowTest(AbstractToilWESServerTest):
                     "workflow_type_version": "v1.2",
                     "workflow_params": json.dumps({"message": "Hello, world!"}),
                 },
+                files=TrueDict(),
             )
             # workflow is submitted successfully
             self.assertEqual(rv.status_code, 200)
-            self.assertTrue(rv.is_json)
-            run_id = rv.json.get("run_id")
+            run_id = rv.json().get("run_id")
             self.assertIsNotNone(run_id)
 
             # Check status
@@ -730,6 +771,7 @@ class ToilWESServerWorkflowTest(AbstractToilWESServerTest):
 
 
 @needs_celery_broker
+@integrative
 class ToilWESServerCeleryWorkflowTest(ToilWESServerWorkflowTest):
     """
     End-to-end workflow-running tests against Celery.

toil/test/wdl/md5sum/md5sum-gs.json

@@ -1 +1 @@
-{"ga4ghMd5.inputFile": "gs://broad-public-datasets/NA12878/NA12878.cram.crai"}
+{"ga4ghMd5.inputFile": "gs://gcp-public-data-landsat/LT04/01/003/027/LT04_L1TP_003027_19830202_20170220_01_T1/README.GTF"}

toil/test/wdl/testfiles/read_file.wdl

@@ -0,0 +1,18 @@
+version 1.0
+
+# Workflow to read a file from a string path
+
+workflow read_file {
+
+    input {
+        String input_string
+    }
+
+    Array[String] the_lines = read_lines(input_string)
+
+    output {
+        Array[String] lines = the_lines
+        File remade_file = write_lines(the_lines)
+    }
+
+}

toil/test/wdl/testfiles/url_to_optional_file.wdl

@@ -3,9 +3,10 @@ version 1.0
 workflow url_to_optional_file {
     input {
         Int http_code = 404
+        String base_url = "https://httpstat.us/"
     }
     
-    File? the_file = "https://httpstat.us/" + http_code
+    File? the_file = base_url + http_code
 
     output {
         File? out_file = the_file

toil/test/wdl/wdltoil_test.py

@@ -13,6 +13,8 @@ from unittest.mock import patch
 from uuid import uuid4
 
 import pytest
+from pytest_httpserver import HTTPServer
+
 import WDL.Error
 import WDL.Expr
 
@@ -23,6 +25,7 @@ from toil.test import (
     needs_docker,
     needs_docker_cuda,
     needs_google_storage,
+    needs_online,
     needs_singularity_or_docker,
     needs_wdl,
     slow,
@@ -32,7 +35,6 @@ from toil.wdl.wdltoil import (
     WDLSectionJob,
     WDLWorkflowGraph,
     parse_disks,
-    remove_common_leading_whitespace,
 )
 
 logger = logging.getLogger(__name__)
@@ -113,11 +115,11 @@ class TestWDLConformance:
 
     @slow
     def test_unit_tests_v11(self, wdl_conformance_test_repo: Path) -> None:
-        # There are still some bugs with the WDL spec, use a fixed version until
-        # See comments of https://github.com/openwdl/wdl/pull/669
+        # TODO: Using a branch lets Toil commits that formerly passed start to
+        # fail CI when the branch moves.
         os.chdir(wdl_conformance_test_repo)
-        repo_url = "https://github.com/stxue1/wdl.git"
-        repo_branch = "wdl-1.1.3-fixes"
+        repo_url = "https://github.com/openwdl/wdl.git"
+        repo_branch = "wdl-1.1"
         commands1 = [
             exactPython,
             "setup_unit_tests.py",
@@ -249,6 +251,7 @@ class TestWDL:
                 assert os.path.exists(result["ga4ghMd5.value"])
                 assert os.path.basename(result["ga4ghMd5.value"]) == "md5sum.txt"
 
+    @needs_online
     def test_url_to_file(self, tmp_path: Path) -> None:
         """
         Test if web URL strings can be coerced to usable Files.
@@ -308,6 +311,59 @@ class TestWDL:
             assert isinstance(result["wait.result"], str)
             assert result["wait.result"] == "waited"
 
+    def test_restart(self, tmp_path: Path) -> None:
+        """
+        Test if a WDL workflow can be restarted and finish successfully.
+        """
+        with get_data("test/wdl/testfiles/read_file.wdl") as wdl:
+            out_dir = tmp_path / "out"
+            file_path = tmp_path / "file"
+            jobstore_path = tmp_path / "tree"
+            command = (
+                self.base_command
+                + [
+                    str(wdl),
+                    "-o",
+                    str(out_dir),
+                    "-i",
+                    json.dumps({"read_file.input_string": str(file_path)}),
+                    "--jobStore",
+                    str(jobstore_path),
+                    "--retryCount=0"
+                ]
+            )
+            with pytest.raises(subprocess.CalledProcessError):
+                # The first time we run it, it should fail because it's trying
+                # to work on a nonexistent file from a string path.
+                result_json = subprocess.check_output(
+                    command + ["--logCritical"]
+                )
+
+            # Then create the file
+            with open(file_path, "w") as f:
+                f.write("This is a line\n")
+                f.write("This is a different line")
+            
+            # Now it should work
+            result_json = subprocess.check_output(
+                    command + ["--restart"]
+                )
+            result = json.loads(result_json)
+
+            assert "read_file.lines" in result
+            assert isinstance(result["read_file.lines"], list)
+            assert result["read_file.lines"] == [
+                "This is a line",
+                "This is a different line"
+            ]
+
+            # Since we were catching
+            # <https://github.com/DataBiosphere/toil/issues/5247> at file
+            # export, make sure we actually exported a file.
+            assert "read_file.remade_file" in result
+            assert isinstance(result["read_file.remade_file"], str)
+            assert os.path.exists(result["read_file.remade_file"])
+
     @needs_singularity_or_docker
     def test_workflow_file_deletion(self, tmp_path: Path) -> None:
         """
@@ -597,7 +653,7 @@ class TestWDL:
                 != result_not_cached["random.value_written"]
             )
 
-    def test_url_to_optional_file(self, tmp_path: Path) -> None:
+    def test_url_to_optional_file(self, tmp_path: Path, httpserver: HTTPServer) -> None:
         """
         Test if missing and error-producing URLs are handled correctly for optional File? values.
         """
@@ -610,7 +666,15 @@ class TestWDL:
                 Return the parsed output.
                 """
                 logger.info("Test optional file with HTTP code %s", code)
-                json_value = '{"url_to_optional_file.http_code": %d}' % code
+                httpserver.expect_request(
+                    "/" + str(code)
+                ).respond_with_data(
+                    "Some data",
+                    status=code,
+                    content_type="text/plain"
+                )
+                base_url = httpserver.url_for("/")
+                json_value = '{"url_to_optional_file.http_code": %d, "url_to_optional_file.base_url": "%s"}' % (code, base_url)
                 result_json = subprocess.check_output(
                     self.base_command
                     + [
@@ -1055,7 +1119,7 @@ class TestWDLToilBench(unittest.TestCase):
                     assert "decl2" in result[0]
                     assert "successor" in result[1]
 
-    def make_string_expr(self, to_parse: str) -> WDL.Expr.String:
+    def make_string_expr(self, to_parse: str, expr_type: type[WDL.Expr.String] = WDL.Expr.String) -> WDL.Expr.String:
         """
         Parse pseudo-WDL for testing whitespace removal.
         """
@@ -1066,122 +1130,7 @@ class TestWDLToilBench(unittest.TestCase):
         for i in range(1, len(parts), 2):
             parts[i] = WDL.Expr.Placeholder(pos, {}, WDL.Expr.Null(pos))
 
-        return WDL.Expr.String(pos, parts)
-
-    def test_remove_common_leading_whitespace(self) -> None:
-        """
-        Make sure leading whitespace removal works properly.
-        """
-
-        # For a single line, we remove its leading whitespace
-        expr = self.make_string_expr(" a ~{b} c")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "a "
-        assert trimmed.parts[2] == " c"
-
-        # Whitespace removed isn't affected by totally blank lines
-        expr = self.make_string_expr("    \n\n    a\n    ~{stuff}\n    b\n\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\n\na\n"
-        assert trimmed.parts[2] == "\nb\n\n"
-
-        # Unless blank toleration is off
-        expr = self.make_string_expr("    \n\n    a\n    ~{stuff}\n    b\n\n")
-        trimmed = remove_common_leading_whitespace(expr, tolerate_blanks=False)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "    \n\n    a\n    "
-        assert trimmed.parts[2] == "\n    b\n\n"
-
-        # Whitespace is still removed if the first line doesn't have it before the newline
-        expr = self.make_string_expr("\n    a\n    ~{stuff}\n    b\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\na\n"
-        assert trimmed.parts[2] == "\nb\n"
-
-        # Whitespace is not removed if actual content is dedented
-        expr = self.make_string_expr("    \n\n    a\n    ~{stuff}\nuhoh\n    b\n\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "    \n\n    a\n    "
-        assert trimmed.parts[2] == "\nuhoh\n    b\n\n"
-
-        # Unless dedents are tolerated
-        expr = self.make_string_expr("    \n\n    a\n    ~{stuff}\nuhoh\n    b\n\n")
-        trimmed = remove_common_leading_whitespace(expr, tolerate_dedents=True)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\n\na\n"
-        assert trimmed.parts[2] == "\nuhoh\nb\n\n"
-
-        # Whitespace is still removed if all-whitespace lines have less of it
-        expr = self.make_string_expr("\n    a\n    ~{stuff}\n  \n    b\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\na\n"
-        assert trimmed.parts[2] == "\n\nb\n"
-
-        # Unless all-whitespace lines are not tolerated
-        expr = self.make_string_expr("\n    a\n    ~{stuff}\n  \n    b\n")
-        trimmed = remove_common_leading_whitespace(expr, tolerate_all_whitespace=False)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\n  a\n  "
-        assert trimmed.parts[2] == "\n\n  b\n"
-
-        # When mixed tabs and spaces are detected, nothing is changed.
-        expr = self.make_string_expr("\n    a\n\t~{stuff}\n    b\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\n    a\n\t"
-        assert trimmed.parts[2] == "\n    b\n"
-
-        # When mixed tabs and spaces are not in the prefix, whitespace is removed.
-        expr = self.make_string_expr("\n\ta\n\t~{stuff} \n\tb\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\na\n"
-        assert trimmed.parts[2] == " \nb\n"
-
-        # An empty string works
-        expr = self.make_string_expr("")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 1
-        assert trimmed.parts[0] == ""
-
-        # A string of only whitespace is preserved as an all-whitespece line
-        expr = self.make_string_expr("\t\t\t")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 1
-        assert trimmed.parts[0] == "\t\t\t"
-
-        # A string of only whitespace is trimmed when all-whitespace lines are not tolerated
-        expr = self.make_string_expr("\t\t\t")
-        trimmed = remove_common_leading_whitespace(expr, tolerate_all_whitespace=False)
-        assert len(trimmed.parts) == 1
-        assert trimmed.parts[0] == ""
-
-        # An empty expression works
-        expr = WDL.Expr.String(
-            WDL.Error.SourcePosition("nowhere", "nowhere", 0, 0, 0, 0), []
-        )
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 0
-
-        # An expression of only placeholders works
-        expr = self.make_string_expr("~{AAA}")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == ""
-        assert trimmed.parts[2] == ""
-
-        # The command flag is preserved
-        expr = self.make_string_expr(" a ~{b} c")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert trimmed.command == False
-        expr.command = True
-        trimmed = remove_common_leading_whitespace(expr)
-        assert trimmed.command == True
+        return expr_type(pos, parts)
 
     def test_choose_human_readable_directory(self) -> None:
         """
@@ -1195,7 +1144,7 @@ class TestWDLToilBench(unittest.TestCase):
 
         state: DirectoryNamingStateDict = {}
 
-        # The first time we should get  apath with the task name and without the ID
+        # The first time we should get a path with the task name and without the ID
         first_chosen = choose_human_readable_directory(
             "root", "taskname", "111-222-333", state
         )

toil/utils/toilSshCluster.py

@@ -14,6 +14,7 @@
 """SSH into the toil appliance container running on the leader of the cluster."""
 import argparse
 import logging
+import socket
 import sys
 
 from toil.common import parser_with_common_options
@@ -22,6 +23,22 @@ from toil.statsAndLogging import set_logging_from_options
 
 logger = logging.getLogger(__name__)
 
+def have_ipv6() -> bool:
+    """
+    Return True if the IPv6 loopback interface is useable.
+    """
+
+    # We sniff for actual IPv6 like in
+    # https://github.com/urllib3/urllib3/pull/840/files in urllib3 (which we
+    # don't depend on)
+    if socket.has_ipv6:
+        # Built with IPv6 support
+        try:
+            socket.socket(socket.AF_INET6).bind(("::1", 0))
+            return True
+        except Exception:
+            pass
+    return False
 
 def main() -> None:
     parser = parser_with_common_options(
@@ -73,6 +90,12 @@ def main() -> None:
         ["-L", f"{options.grafana_port}:localhost:3000", "-L", "9090:localhost:9090"]
     )
 
+    if not have_ipv6():
+        # If we try to do SSH port forwarding without any other options, but
+        # IPv6 is turned off on the host, we might get complaints that we
+        # "Cannot assign requested address" on ports on [::1].
+        sshOptions.append("-4")
+
     try:
         cluster.getLeader().sshAppliance(
             *command,