toil 6.1.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

toil/test/provisioners/clusterTest.py

@@ -11,36 +11,40 @@
 # 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
 import os
 import subprocess
 import time
+
 from uuid import uuid4
 from typing import Optional, List
 
-from toil.lib.aws import zone_to_region
 from toil.lib.retry import retry
+from toil.test import ToilTest, needs_aws_ec2, needs_fetchable_appliance, slow, needs_env_var
+from toil.lib.aws import zone_to_region
+from toil.lib.aws.session import AWSConnectionManager
+from toil.provisioners import cluster_factory
 from toil.provisioners.aws import get_best_aws_zone
-from toil.test import ToilTest, needs_aws_ec2, needs_fetchable_appliance
 
 log = logging.getLogger(__name__)
 
+
 @needs_aws_ec2
 @needs_fetchable_appliance
 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.clusterName = 'aws-provisioner-test-' + str(uuid4())
+        self.clusterName = f'aws-provisioner-test-{uuid4()}'
         self.leaderNodeType = 't2.medium'
         self.clusterType = 'mesos'
         self.zone = get_best_aws_zone()
         assert self.zone is not None, "Could not determine AWS availability zone to test in; is TOIL_AWS_ZONE set?"
-        # We need a boto2 connection to EC2 to check on the cluster.
-        # Since we are protected by needs_aws_ec2 we can import from boto.
-        import boto.ec2
-        self.boto2_ec2 = boto.ec2.connect_to_region(zone_to_region(self.zone))
+        self.region = zone_to_region(self.zone)
+
+        # Get connection to AWS
+        self.aws = AWSConnectionManager()
+
         # Where should we put our virtualenv?
         self.venvDir = '/tmp/venv'
 
@@ -170,3 +174,81 @@ class AbstractClusterTest(ToilTest):
 
     def launchCluster(self) -> None:
         self.createClusterUtil()
+
+
+@needs_aws_ec2
+@needs_fetchable_appliance
+@slow
+class CWLOnARMTest(AbstractClusterTest):
+    """Run the CWL 1.2 conformance tests on ARM specifically."""
+    def __init__(self, methodName: str) -> None:
+        super().__init__(methodName=methodName)
+        self.clusterName = f'cwl-test-{uuid4()}'
+        self.leaderNodeType = "t4g.2xlarge"
+        self.clusterType = "kubernetes"
+        # We need to be running in a directory which Flatcar and the Toil Appliance both have
+        self.cwl_test_dir = "/tmp/toil/cwlTests"
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.jobStore = f"aws:{self.awsRegion()}:cluster-{uuid4()}"
+
+    @needs_env_var("CI_COMMIT_SHA", "a git commit sha")
+    def test_cwl_on_arm(self) -> None:
+        # Make a cluster
+        self.launchCluster()
+        # get the leader so we know the IP address - we don't need to wait since create cluster
+        # already ensures the leader is running
+        self.cluster = cluster_factory(
+            provisioner="aws", zone=self.zone, clusterName=self.clusterName
+        )
+        self.leader = self.cluster.getLeader()
+
+        commit = os.environ["CI_COMMIT_SHA"]
+        self.sshUtil(
+            [
+                "bash",
+                "-c",
+                f"mkdir -p {self.cwl_test_dir} && cd {self.cwl_test_dir} && git clone https://github.com/DataBiosphere/toil.git",
+            ]
+        )
+
+        # We use CI_COMMIT_SHA to retrieve the Toil version needed to run the CWL tests
+        self.sshUtil(
+            ["bash", "-c", f"cd {self.cwl_test_dir}/toil && git checkout {commit}"]
+        )
+
+        # --never-download prevents silent upgrades to pip, wheel and setuptools
+        self.sshUtil(
+            [
+                "bash",
+                "-c",
+                f"virtualenv --system-site-packages --never-download {self.venvDir}",
+            ]
+        )
+        self.sshUtil(
+            [
+                "bash",
+                "-c",
+                f". .{self.venvDir}/bin/activate && cd {self.cwl_test_dir}/toil && make prepare && make develop extras=[all]",
+            ]
+        )
+
+        # Runs the CWLv12Test 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",
+            ]
+        )
+
+        # We know if it succeeds it should save a junit XML for us to read.
+        # 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"
+            )
+        )

toil/test/server/serverTest.py

@@ -575,9 +575,9 @@ class ToilWESServerWorkflowTest(AbstractToilWESServerTest):
         with self.app.test_client() as client:
             rv = client.post("/ga4gh/wes/v1/runs", data={
                 "workflow_url": "https://raw.githubusercontent.com/DataBiosphere/toil/releases/5.4.x/src/toil"
-                                "/test/docs/scripts/cwlExampleFiles/hello.cwl",
+                                "/test/cwl/echo.cwl",
                 "workflow_type": "CWL",
-                "workflow_type_version": "v1.0",
+                "workflow_type_version": "v1.2",
                 "workflow_params": json.dumps({"message": "Hello, world!"}),
             })
             # workflow is submitted successfully

toil/test/src/autoDeploymentTest.py

@@ -243,7 +243,7 @@ class AutoDeploymentTest(ApplianceTestSupport):
 
         3) it is an instance of Job (and so does not introduce the user script to sys.path itself),
 
-        … it might cause problems with deserializing a defered function defined in the user script.
+        … it might cause problems with deserializing a deferred function defined in the user script.
 
         `Encapsulated` has two children to ensure that `Follow-on` is run in a separate worker.
         """

toil/test/src/dockerCheckTest.py

@@ -14,7 +14,7 @@
 import unittest
 
 from docker.errors import ImageNotFound
-from toil import checkDockerImageExists, parseDockerAppliance
+from toil import checkDockerImageExists, parseDockerAppliance, retry
 from toil.test import ToilTest, needs_docker
 
 
@@ -76,6 +76,7 @@ class DockerCheckTest(ToilTest):
         google_repo = 'gcr.io/google-containers/busybox:latest'
         assert checkDockerImageExists(google_repo)
 
+    @retry(errors=[TimeoutError])  # see: https://github.com/DataBiosphere/toil/issues/4902
     def testBadGoogleRepo(self):
         """Bad repo and tag.  This should raise."""
         nonexistent_google_repo = 'gcr.io/google-containers/--------:---'

toil/test/src/environmentTest.py

@@ -0,0 +1,125 @@
+# 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 logging
+import os
+import sys
+import time
+
+from argparse import Namespace
+from threading import Thread
+from typing import Optional
+
+from toil.common import Toil
+from toil.job import Job
+from toil.test import ToilTest, slow
+from toil.jobStores.abstractJobStore import NoSuchFileException
+
+logger = logging.getLogger(__name__)
+
+class EnvironmentTest(ToilTest):
+    """
+    Test to make sure that Toil's environment variable save and restore system
+    (environment.pickle) works.
+
+    The environment should be captured once at the start of the workflow and
+    should be sent through based on that, not base don the leader's current
+    environment when the job is launched.
+    """
+    
+    def test_environment(self):
+        options = Job.Runner.getDefaultOptions(self._getTestJobStorePath())
+        options.logLevel = "DEBUG"
+        options.retryCount = 0
+
+        main(options)
+        
+def signal_leader(job):
+    """
+    Make a file in the file store that the leader can see.
+    """
+    with job.fileStore.jobStore.write_shared_file_stream("jobstarted.txt", encoding="utf-8") as stream:
+        stream.write("Job has run")
+        
+def check_environment(job, try_name: str):
+    """
+    Fail if the test environment is wrong.
+    """
+    
+    job.fileStore.log_to_leader(f"Try {try_name} checking environment")
+    value = os.environ["MAGIC_ENV_VAR_123"]
+    job.fileStore.log_to_leader(f"Try {try_name} got: {value}")
+    if value != "Value1":
+        raise RuntimeError("Environment variable is wrong!")
+
+def wait_a_bit(job):
+    """
+    Toil job that waits.
+    """
+    time.sleep(10)
+
+def check_environment_repeatedly(job):
+    """
+    Toil job that checks the environment, waits, and checks it again, as
+    separate invocations.
+    """
+    
+    signal = job.addChildJobFn(signal_leader)
+    check1 = signal.addFollowOnJobFn(check_environment, "try1")
+    waiter = check1.addFollowOnJobFn(wait_a_bit)
+    check2 = waiter.addFollowOnJobFn(check_environment, "try2")
+    # Add another one to make sure we don't chain
+    check3 = waiter.addFollowOnJobFn(check_environment, "try3")
+
+def main(options: Optional[Namespace] = None):
+    """
+    Run the actual workflow with the given options.
+    """
+    if not options:
+        # deal with command line arguments
+        parser = Job.Runner.getDefaultArgumentParser()
+        options = parser.parse_args()
+        logging.basicConfig()
+
+    # Set something that should be seen by Toil jobs
+    os.environ["MAGIC_ENV_VAR_123"] = "Value1"
+
+    with Toil(options) as toil:
+
+        # Get a tthe job store so we can use shared files.
+        jobStore = toil._jobStore
+
+        # Once the workflow has started, change the environment
+        def change_environment_later():
+            """
+            After waiting, modify the environment.
+            """
+            while True:
+                # Wait for the workflow to say it ran something
+                time.sleep(5)
+                try:
+                    with jobStore.read_shared_file_stream("jobstarted.txt", encoding="utf-8") as stream:
+                        logger.info("Got signal from job: %s", stream.read().strip())
+                        break
+                except NoSuchFileException:
+                    pass
+            # Change the environment variable
+            logger.info("Changing environment variable")
+            os.environ["MAGIC_ENV_VAR_123"] = "Value2"
+        changer_thread = Thread(target=change_environment_later)
+        changer_thread.start()
+
+        toil.start(Job.wrapJobFn(check_environment_repeatedly))
+
+if __name__ == "__main__":
+    main()

toil/test/src/fileStoreTest.py

@@ -641,7 +641,7 @@ class hidden:
             file into cache then rewrites it to the job store triggering an async write since the
             two unique jobstore IDs point to the same local file.  Also, the second write is not
             cached since the first was written to cache, and there "isn't enough space" to cache the
-            second.  Imediately assert that the second write isn't cached, and is being
+            second.  Immediately assert that the second write isn't cached, and is being
             asynchronously written to the job store.
 
             Attempting to get the file from the jobstore should not fail.

toil/test/src/jobDescriptionTest.py

@@ -18,6 +18,7 @@ from configargparse import ArgumentParser
 
 from toil.common import Toil
 from toil.job import Job, JobDescription, TemporaryID
+from toil.resource import ModuleDescriptor
 from toil.test import ToilTest
 
 
@@ -43,17 +44,24 @@ class JobDescriptionTest(ToilTest):
         Tests the public interface of a JobDescription.
         """
 
-        command = "by your command"
         memory = 2^32
         disk = 2^32
         cores = "1"
         preemptible = 1
 
-        j = JobDescription(command=command, requirements={"memory": memory, "cores": cores, "disk": disk, "preemptible": preemptible},
+        j = JobDescription(requirements={"memory": memory, "cores": cores, "disk": disk, "preemptible": preemptible},
                            jobName='testJobGraph', unitName='noName')
+        
+
+        # Without a body, and with nothing to run, nextSuccessors will be None
+        self.assertEqual(j.has_body(), False)
+        self.assertEqual(j.nextSuccessors(), None)
+
+        # Attach a body so the job has something to do itself.
+        j.attach_body("fake", ModuleDescriptor.forModule("toil"))
+        self.assertEqual(j.has_body(), True)
 
         #Check attributes
-        self.assertEqual(j.command, command)
         self.assertEqual(j.memory, memory)
         self.assertEqual(j.disk, disk)
         self.assertEqual(j.cores, int(cores))
@@ -68,22 +76,24 @@ class JobDescriptionTest(ToilTest):
         self.assertEqual(j.logJobStoreFileID, None)
 
         #Check equals function (should be based on object identity and not contents)
-        j2 = JobDescription(command=command, requirements={"memory": memory, "cores": cores, "disk": disk, "preemptible": preemptible},
+        j2 = JobDescription(requirements={"memory": memory, "cores": cores, "disk": disk, "preemptible": preemptible},
                             jobName='testJobGraph', unitName='noName')
+        j2.attach_body("fake", ModuleDescriptor.forModule("toil"))
         self.assertNotEqual(j, j2)
         ###TODO test other functionality
 
     def testJobDescriptionSequencing(self):
-        j = JobDescription(command='command', requirements={},  jobName='unimportant')
+        j = JobDescription(requirements={},  jobName='unimportant')
 
         j.addChild('child')
         j.addFollowOn('followOn')
 
-        # With a command, nothing should be ready to run
+        # With a body, nothing should be ready to run
+        j.attach_body("fake", ModuleDescriptor.forModule("toil"))
         self.assertEqual(list(j.nextSuccessors()), [])
 
-        # With command cleared, child should be ready to run
-        j.command = None
+        # With body cleared, child should be ready to run
+        j.detach_body()
         self.assertEqual(list(j.nextSuccessors()), ['child'])
 
         # Without the child, the follow-on should be ready to run

toil/test/src/jobTest.py

@@ -268,7 +268,7 @@ class JobTest(ToilTest):
         Test for issue #1465: Detection of checkpoint jobs that are not leaf vertices
         identifies leaf vertices incorrectly
 
-        Test verification of new checkpoint jobs being leaf verticies,
+        Test verification of new checkpoint jobs being leaf vertices,
         starting with the following baseline workflow::
 
             Parent

toil/test/src/realtimeLoggerTest.py

@@ -30,6 +30,9 @@ class RealtimeLoggerTest(ToilTest):
         # Set up a log message detector to the root logger
         logging.getLogger().addHandler(detector)
 
+        # I believe coloredlogs replaces handlers with its own when doing handler formatting, preserving only filters
+        # https://github.com/xolox/python-coloredlogs/blob/65bdfe976ac0bf81e8c0bd9a98242b9d666b2859/coloredlogs/__init__.py#L453-L459
+        options.colored_logs = False
         Job.Runner.startToil(LogTest(), options)
 
         # We need the message we're supposed to see
@@ -46,6 +49,7 @@ class MessageDetector(logging.StreamHandler):
     def __init__(self):
         self.detected = False  # Have we seen the message we want?
         self.overLogged = False  # Have we seen the message we don't want?
+
         super().__init__()
 
     def emit(self, record):

toil/test/src/workerTest.py

@@ -18,6 +18,8 @@ from toil.jobStores.fileJobStore import FileJobStore
 from toil.test import ToilTest
 from toil.worker import nextChainable
 
+from typing import Optional
+
 
 class WorkerTests(ToilTest):
     """Test miscellaneous units of the worker."""
@@ -32,7 +34,7 @@ class WorkerTests(ToilTest):
 
     def testNextChainable(self):
         """Make sure chainable/non-chainable jobs are identified correctly."""
-        def createTestJobDesc(memory, cores, disk, preemptible, checkpoint):
+        def createTestJobDesc(memory, cores, disk, preemptible: bool = True, checkpoint: bool = False, local: Optional[bool] = None):
             """
             Create a JobDescription with no command (representing a Job that
             has already run) and return the JobDescription.
@@ -41,7 +43,16 @@ class WorkerTests(ToilTest):
             self.jobNumber += 1
 
             descClass = CheckpointJobDescription if checkpoint else JobDescription
-            jobDesc = descClass(requirements={'memory': memory, 'cores': cores, 'disk': disk, 'preemptible': preemptible}, jobName=name)
+            jobDesc = descClass(
+                requirements={
+                    'memory': memory,
+                    'cores': cores,
+                    'disk': disk,
+                    'preemptible': preemptible
+                }, 
+                jobName=name, 
+                local=local
+            )
 
             # Assign an ID
             self.jobStore.assign_job_id(jobDesc)
@@ -53,42 +64,64 @@ class WorkerTests(ToilTest):
             # Try with the branch point at both child and follow-on stages
 
             # Identical non-checkpoint jobs should be chainable.
-            jobDesc1 = createTestJobDesc(1, 2, 3, True, False)
-            jobDesc2 = createTestJobDesc(1, 2, 3, True, False)
+            jobDesc1 = createTestJobDesc(1, 2, 3)
+            jobDesc2 = createTestJobDesc(1, 2, 3)
             getattr(jobDesc1, successorType)(jobDesc2.jobStoreID)
             chainable = nextChainable(jobDesc1, self.jobStore, self.config)
             self.assertNotEqual(chainable, None)
-            self.assertEqual(jobDesc2.jobStoreID, chainable.jobStoreID)
+            self.assertEqual(chainable.jobStoreID, jobDesc2.jobStoreID)
 
             # Identical checkpoint jobs should not be chainable.
-            jobDesc1 = createTestJobDesc(1, 2, 3, True, False)
-            jobDesc2 = createTestJobDesc(1, 2, 3, True, True)
+            jobDesc1 = createTestJobDesc(1, 2, 3, checkpoint=True)
+            jobDesc2 = createTestJobDesc(1, 2, 3, checkpoint=True)
+            getattr(jobDesc1, successorType)(jobDesc2.jobStoreID)
+            self.assertEqual(nextChainable(jobDesc1, self.jobStore, self.config), None)
+
+            # Changing checkpoint from false to true should make it not chainable.
+            jobDesc1 = createTestJobDesc(1, 2, 3, checkpoint=False)
+            jobDesc2 = createTestJobDesc(1, 2, 3, checkpoint=True)
             getattr(jobDesc1, successorType)(jobDesc2.jobStoreID)
-            self.assertEqual(None, nextChainable(jobDesc1, self.jobStore, self.config))
+            self.assertEqual(nextChainable(jobDesc1, self.jobStore, self.config), None)
 
             # If there is no child we should get nothing to chain.
-            jobDesc1 = createTestJobDesc(1, 2, 3, True, False)
-            self.assertEqual(None, nextChainable(jobDesc1, self.jobStore, self.config))
+            jobDesc1 = createTestJobDesc(1, 2, 3)
+            self.assertEqual(nextChainable(jobDesc1, self.jobStore, self.config), None)
 
             # If there are 2 or more children we should get nothing to chain.
-            jobDesc1 = createTestJobDesc(1, 2, 3, True, False)
-            jobDesc2 = createTestJobDesc(1, 2, 3, True, False)
-            jobDesc3 = createTestJobDesc(1, 2, 3, True, False)
+            jobDesc1 = createTestJobDesc(1, 2, 3)
+            jobDesc2 = createTestJobDesc(1, 2, 3)
+            jobDesc3 = createTestJobDesc(1, 2, 3)
             getattr(jobDesc1, successorType)(jobDesc2.jobStoreID)
             getattr(jobDesc1, successorType)(jobDesc3.jobStoreID)
-            self.assertEqual(None, nextChainable(jobDesc1, self.jobStore, self.config))
+            self.assertEqual(nextChainable(jobDesc1, self.jobStore, self.config), None)
 
             # If there is an increase in resource requirements we should get nothing to chain.
-            reqs = {'memory': 1, 'cores': 2, 'disk': 3, 'preemptible': True, 'checkpoint': False}
+            base_reqs = {'memory': 1, 'cores': 2, 'disk': 3, 'preemptible': True, 'checkpoint': False}
             for increased_attribute in ('memory', 'cores', 'disk'):
+                reqs = dict(base_reqs)
                 jobDesc1 = createTestJobDesc(**reqs)
                 reqs[increased_attribute] += 1
                 jobDesc2 = createTestJobDesc(**reqs)
                 getattr(jobDesc1, successorType)(jobDesc2.jobStoreID)
-                self.assertEqual(None, nextChainable(jobDesc1, self.jobStore, self.config))
+                self.assertEqual(nextChainable(jobDesc1, self.jobStore, self.config), None)
 
             # A change in preemptability from True to False should be disallowed.
-            jobDesc1 = createTestJobDesc(1, 2, 3, True, False)
-            jobDesc2 = createTestJobDesc(1, 2, 3, False, True)
+            jobDesc1 = createTestJobDesc(1, 2, 3, preemptible=True)
+            jobDesc2 = createTestJobDesc(1, 2, 3, preemptible=False)
+            getattr(jobDesc1, successorType)(jobDesc2.jobStoreID)
+            self.assertEqual(nextChainable(jobDesc1, self.jobStore, self.config), None)
+
+            # A change in local-ness from True to False should be disallowed.
+            jobDesc1 = createTestJobDesc(1, 2, 3, local=True)
+            jobDesc2 = createTestJobDesc(1, 2, 3, local=False)
             getattr(jobDesc1, successorType)(jobDesc2.jobStoreID)
-            self.assertEqual(None, nextChainable(jobDesc1, self.jobStore, self.config))
+            self.assertEqual(nextChainable(jobDesc1, self.jobStore, self.config), None)
+
+            # A change in local-ness from False to True should be allowed,
+            # since running locally is an optional optimization.
+            jobDesc1 = createTestJobDesc(1, 2, 3, local=False)
+            jobDesc2 = createTestJobDesc(1, 2, 3, local=True)
+            getattr(jobDesc1, successorType)(jobDesc2.jobStoreID)
+            chainable = nextChainable(jobDesc1, self.jobStore, self.config)
+            self.assertNotEqual(chainable, None)
+            self.assertEqual(chainable.jobStoreID, jobDesc2.jobStoreID)

toil/test/utils/toilDebugTest.py

@@ -21,7 +21,7 @@ import pytest
 from toil.test import ToilTest
 
 from toil.lib.resources import glob
-from toil.test import slow
+from toil.test import slow, needs_wdl
 from toil.version import python
 
 logger = logging.getLogger(__name__)
@@ -136,7 +136,7 @@ class DebugJobTest(ToilTest):
 
         logger.info("Running workflow that always fails")
         try:
-            # Run an always-failign workflow
+            # Run an always-failing workflow
             subprocess.check_call([
                 python,
                 os.path.abspath("src/toil/test/docs/scripts/example_alwaysfail.py"),
@@ -150,13 +150,44 @@ class DebugJobTest(ToilTest):
             # Should fail to run
             logger.info("Task failed successfully")
             pass
-
+        
         # Get the job ID.
         # TODO: This assumes a lot about the FileJobStore. Use the MessageBus instead?
         job_id = "kind-explode/" + os.listdir(os.path.join(job_store, "jobs/kind-explode"))[0]
 
         return job_store, job_id
 
+    def _get_wdl_job_store_and_job_name(self):
+        """
+        Get a job store and the name of a failed job in it that actually wanted to use some files.
+        """
+        
+        # First make a job store.
+        job_store = os.path.join(self._createTempDir(), "tree")
+
+        logger.info("Running workflow that always fails")
+        try:
+            # Run an always-failing workflow
+            subprocess.check_call([
+                "toil-wdl-runner",
+                os.path.abspath("src/toil/test/docs/scripts/example_alwaysfail_with_files.wdl"),
+                "--retryCount=0",
+                "--logCritical",
+                "--disableProgress",
+                "--jobStore",
+                job_store
+            ], stderr=subprocess.DEVNULL)
+            raise RuntimeError("Failing workflow succeeded!")
+        except subprocess.CalledProcessError:
+            # Should fail to run
+            logger.info("Task failed successfully")
+            pass
+
+        # Get a job name for a job that fails
+        job_name = "WDLTaskJob"
+
+        return job_store, job_name
+
     def test_run_job(self):
         """
         Make sure that we can use toil debug-job to try and run a job in-process.
@@ -198,4 +229,31 @@ class DebugJobTest(ToilTest):
             job_id
         ])
 
+    @needs_wdl
+    def test_retrieve_task_directory(self):
+        """
+        Make sure that we can use --retrieveTaskDirectory to get the input files for a job.
+        """
+
+        job_store, job_name = self._get_wdl_job_store_and_job_name()
+
+        logger.info("Trying to retrieve task dorectory for job %s", job_name)
+
+        dest_dir = os.path.join(self._createTempDir(), "dump")
+
+        # Print the job info and make sure that doesn't crash.
+        subprocess.check_call([
+            "toil",
+            "debug-job",
+            "--logDebug",
+            job_store,
+            job_name,
+            "--retrieveTaskDirectory",
+            dest_dir
+        ])
+        
+        first_file = os.path.join(dest_dir, "inside/mnt/miniwdl_task_container/work/_miniwdl_inputs/0/test.txt")
+        assert os.path.exists(first_file), "Input file not found in fake container environment"
+        self.assertEqual(open(first_file).read(), "These are the contents\n")
+