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

toil/test/batchSystems/test_slurm.py

@@ -6,6 +6,8 @@ import logging
 import pytest
 import sys
 
+from datetime import datetime, timedelta
+
 import toil.batchSystems.slurm
 from toil.batchSystems.abstractBatchSystem import (
     EXIT_STATUS_UNAVAILABLE_VALUE,
@@ -22,10 +24,25 @@ logger = logging.getLogger(__name__)
 # TODO: Come up with a better way to mock the commands then monkey-patching the
 # command-calling functions.
 
+# To convincingly test jobs in the past relative to the time Toil goes looking
+# for them, we give our fake jobs times relative to the module load time, which
+# we hope is not days and days away from the time the tests actually run.
+JOB_BASE_TIME = datetime.now().astimezone(None) - timedelta(days=5)
+
+def call_either(args, **_) -> str:
+    """
+    Pretend to call either sacct or scontrol as appropriate.
+    """
+    if args[0] == "sacct":
+        return call_sacct(args)
+    elif args[0] == "scontrol":
+        return call_scontrol(args)
+    else:
+        raise RuntimeError(f"Cannot fake command call: {args}")
 
 def call_sacct(args, **_) -> str:
     """
-    The arguments passed to `call_command` when executing `sacct` are:
+    The arguments passed to `call_command` when executing `sacct` are something like:
     ['sacct', '-n', '-j', '<comma-separated list of job-ids>', '--format',
     'JobIDRaw,State,ExitCode', '-P', '-S', '1970-01-01']
     The multi-line output is something like::
@@ -36,6 +53,7 @@ def call_sacct(args, **_) -> str:
         1236|FAILED|0:2
         1236.extern|COMPLETED|0:0
     """
+    logger.info("sacct call: %s", args)
     if sum(len(a) for a in args) > 1000:
         # Simulate if the argument list is too long
         raise OSError(errno.E2BIG, "Argument list is too long")
@@ -51,11 +69,58 @@ def call_sacct(args, **_) -> str:
         789868: "789868|PENDING|0:0\n",
         789869: "789869|COMPLETED|0:0\n789869.batch|COMPLETED|0:0\n789869.extern|COMPLETED|0:0\n",
     }
-    job_ids = [int(job_id) for job_id in args[3].split(",")]
+    # And time we say the job was at
+    job_time = {
+        609663: JOB_BASE_TIME + timedelta(days=1),
+        754725: JOB_BASE_TIME + timedelta(days=1),
+        765096: JOB_BASE_TIME + timedelta(days=2),
+        767925: JOB_BASE_TIME + timedelta(days=2),
+        785023: JOB_BASE_TIME + timedelta(days=3),
+        789456: JOB_BASE_TIME + timedelta(days=3),
+        789724: JOB_BASE_TIME + timedelta(days=4),
+        789868: JOB_BASE_TIME + timedelta(days=4),
+        789869: JOB_BASE_TIME + timedelta(days=4),
+    }
+
+    # See if they asked for a job list
+    try:
+        j_index = args.index('-j')
+        job_ids = [int(job_id) for job_id in args[j_index + 1].split(",")]
+    except ValueError:
+        # We're not restricting to a list of jobs.
+        job_ids = list(sacct_info.keys())
+    # See if they asked for start or end times
+    try:
+        flag_index = args.index('-S')
+        begin_time = datetime.fromisoformat(args[flag_index + 1]).astimezone(None)
+    except ValueError:
+        # By default, Slurm uses today at midnight
+        begin_time = datetime.now().astimezone(None).replace(
+            hour=0,
+            minute=0,
+            second=0,
+            microsecond=0,
+            fold=0
+        )
+    try:
+        flag_index = args.index('-E')
+        end_time = datetime.fromisoformat(args[flag_index + 1]).astimezone(None)
+    except ValueError:
+        end_time = None
+
     stdout = ""
     # Glue the fake outputs for the request job-ids together in a single string
     for job_id in job_ids:
-        stdout += sacct_info.get(job_id, "")
+        if job_id not in sacct_info:
+            # Not a job we know of.
+            continue
+        if begin_time is not None and begin_time > job_time[job_id]:
+            # Skip this job as being too early
+            continue
+        if end_time is not None and end_time < job_time[job_id]:
+            # Skip this job as being too late
+            continue
+        stdout += sacct_info[job_id]
     return stdout
 
 
@@ -64,8 +129,11 @@ def call_scontrol(args, **_) -> str:
     The arguments passed to `call_command` when executing `scontrol` are:
     ``['scontrol', 'show', 'job']`` or ``['scontrol', 'show', 'job', '<job-id>']``
     """
+    logger.info("scontrol call: %s", args)
     job_id = int(args[3]) if len(args) > 3 else None
     # Fake output per fake job-id.
+    # scontrol only shows recent jobs, so we have fewer/different jobs here
+    # than for sacct.
     scontrol_info = {
         787204: textwrap.dedent(
             """\
@@ -211,6 +279,9 @@ class FakeBatchSystem(BatchSystemSupport):
 
     def __init__(self):
         super().__init__(self.__fake_config(), float("inf"), sys.maxsize, sys.maxsize)
+        # Pretend to be a workflow that started before we pretend the jobs
+        # we pretend to have ran.
+        self.start_time = JOB_BASE_TIME - timedelta(hours=2)
 
     def getWaitDuration(self):
         return 10
@@ -358,14 +429,14 @@ class SlurmTest(ToilTest):
     ###
 
     def test_getJobExitCode_job_exists(self):
-        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_sacct)
+        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_either)
         job_id = "785023"  # FAILED
         expected_result = (127, BatchJobExitReason.FAILED)
         result = self.worker.getJobExitCode(job_id)
         assert result == expected_result, f"{result} != {expected_result}"
 
     def test_getJobExitCode_job_not_exists(self):
-        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_sacct)
+        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_either)
         job_id = "1234"  # Non-existent
         expected_result = None
         result = self.worker.getJobExitCode(job_id)
@@ -379,7 +450,7 @@ class SlurmTest(ToilTest):
         self.monkeypatch.setattr(
             self.worker, "_getJobDetailsFromSacct", call_sacct_raises
         )
-        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_scontrol)
+        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_either)
         job_id = "787204"  # COMPLETED
         expected_result = (0, BatchJobExitReason.FINISHED)
         result = self.worker.getJobExitCode(job_id)
@@ -393,7 +464,7 @@ class SlurmTest(ToilTest):
         self.monkeypatch.setattr(
             self.worker, "_getJobDetailsFromSacct", call_sacct_raises
         )
-        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_scontrol)
+        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_either)
         job_id = "1234"  # Non-existent
         try:
             _ = self.worker.getJobExitCode(job_id)
@@ -407,21 +478,21 @@ class SlurmTest(ToilTest):
     ###
 
     def test_coalesce_job_exit_codes_one_exists(self):
-        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_sacct)
+        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_either)
         job_ids = ["785023"]  # FAILED
         expected_result = [(127, BatchJobExitReason.FAILED)]
         result = self.worker.coalesce_job_exit_codes(job_ids)
         assert result == expected_result, f"{result} != {expected_result}"
 
     def test_coalesce_job_exit_codes_one_not_exists(self):
-        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_sacct)
+        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_either)
         job_ids = ["1234"]  # Non-existent
         expected_result = [None]
         result = self.worker.coalesce_job_exit_codes(job_ids)
         assert result == expected_result, f"{result} != {expected_result}"
 
     def test_coalesce_job_exit_codes_many_all_exist(self):
-        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_sacct)
+        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_either)
         job_ids = [
             "754725",  # TIMEOUT,
             "789456",  # FAILED,
@@ -440,8 +511,26 @@ class SlurmTest(ToilTest):
         result = self.worker.coalesce_job_exit_codes(job_ids)
         assert result == expected_result, f"{result} != {expected_result}"
 
+    def test_coalesce_job_exit_codes_mix_sacct_scontrol(self):
+        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_either)
+        job_ids = [
+            "609663",  # FAILED, in sacct only
+            "789869",  # COMPLETED, in sacct only
+            "787204",  # COMPLETED, in scontrol only
+            "789724",  # RUNNING, in scontrol only
+        ]
+        # RUNNING and PENDING jobs should return None
+        expected_result = [
+            (130, BatchJobExitReason.FAILED),
+            (0, BatchJobExitReason.FINISHED),
+            (0, BatchJobExitReason.FINISHED),
+            None
+        ]
+        result = self.worker.coalesce_job_exit_codes(job_ids)
+        assert result == expected_result, f"{result} != {expected_result}"
+
     def test_coalesce_job_exit_codes_some_exists(self):
-        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_sacct)
+        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_either)
         job_ids = [
             "609663",  # FAILED (SIGINT)
             "767925",  # FAILED,
@@ -468,7 +557,7 @@ class SlurmTest(ToilTest):
         self.monkeypatch.setattr(
             self.worker, "_getJobDetailsFromSacct", call_sacct_raises
         )
-        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_scontrol)
+        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_either)
         job_ids = ["787204"]  # COMPLETED
         expected_result = [(0, BatchJobExitReason.FINISHED)]
         result = self.worker.coalesce_job_exit_codes(job_ids)
@@ -482,7 +571,7 @@ class SlurmTest(ToilTest):
         self.monkeypatch.setattr(
             self.worker, "_getJobDetailsFromSacct", call_sacct_raises
         )
-        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_scontrol)
+        self.monkeypatch.setattr(toil.batchSystems.slurm, "call_command", call_either)
         job_ids = ["1234"]  # Non-existent
         try:
             _ = self.worker.coalesce_job_exit_codes(job_ids)
@@ -644,5 +733,5 @@ class SlurmTest(ToilTest):
         self.assertTrue(detector("-B"))
         self.assertFalse(detector("--no-bazz"))
         self.assertFalse(detector("--foo-bar=--bazz-only"))
-       
+
 

toil/test/cwl/staging_cat.cwl

@@ -0,0 +1,27 @@
+#!/usr/bin/env cwl-runner
+
+cwlVersion: v1.0
+class: CommandLineTool
+baseCommand: [ "bash", "run.sh" ]
+
+requirements:
+  DockerRequirement: # <- this is the part that causes the error
+    dockerPull: ubuntu:latest
+  InitialWorkDirRequirement:
+    listing:
+      - entryname: some_dir # <- put all the input files into a dir
+        writable: true
+        entry: "$({class: 'Directory', listing: inputs.input_files})"
+      - entryname: run.sh
+        entry: |-
+          for i in \$(find some_dir -type f); do cat \$i ; done
+
+stdout: output.txt
+
+inputs:
+  input_files:
+    type: File[]
+
+outputs:
+  output_file:
+    type: stdout

toil/test/cwl/staging_make_file.cwl

@@ -0,0 +1,25 @@
+#!/usr/bin/env cwl-runner
+
+cwlVersion: v1.0
+class: CommandLineTool
+baseCommand: [ "bash", "run.sh" ]
+
+stdout: output.txt
+
+requirements:
+  InitialWorkDirRequirement:
+    listing:
+      - entryname: run.sh
+        entry: |-
+          echo "$1"
+
+inputs:
+  sampleId:
+    type: string
+    inputBinding:
+      position: 1
+
+outputs:
+  output_file:
+    type: stdout
+

toil/test/cwl/staging_workflow.cwl

@@ -0,0 +1,43 @@
+#!/usr/bin/env cwl-runner
+
+cwlVersion: v1.0
+class: Workflow
+requirements:
+  MultipleInputFeatureRequirement: {}
+  ScatterFeatureRequirement: {}
+  StepInputExpressionRequirement: {}
+  InlineJavascriptRequirement: {}
+  SubworkflowFeatureRequirement: {}
+
+inputs:
+  samples:
+    type:
+      type: array
+      items:
+        type: record
+        fields:
+          sampleId: string
+
+steps:
+  make_file:
+    run: staging_make_file.cwl
+    scatter: sample
+    in:
+      sample: samples
+      sampleId:
+        valueFrom: ${ return inputs.sample['sampleId']; }
+    out:
+      [ output_file ]
+
+  gather_files:
+    run: staging_cat.cwl
+    in:
+      input_files: make_file/output_file
+    out:
+      [ output_file ]
+
+outputs:
+  output_file:
+    type: File
+    outputSource: gather_files/output_file
+

toil/test/cwl/zero_default.cwl

@@ -0,0 +1,61 @@
+#!/usr/bin/env cwl-runner
+cwlVersion: v1.2
+class: Workflow
+requirements:
+  MultipleInputFeatureRequirement: {}
+  InlineJavascriptRequirement: {}
+inputs:
+  valueA:
+    type: int?
+    default: 0
+  valueB:
+    type: int?
+  someFile:
+    type: File?
+steps:
+  prev_step:
+    run:
+      class: ExpressionTool
+      requirements:
+        InlineJavascriptRequirement: {}
+      inputs:
+        someFile:
+          type: File
+      outputs:
+        valueA:
+          type: int
+      expression: |
+        ${
+          return {valueA: 1};
+        }
+    in:
+      someFile: someFile
+    out: [valueA]
+    when: $(inputs.someFile != null)
+    
+  main_step:
+    run:
+      class: ExpressionTool
+      requirements:
+        InlineJavascriptRequirement: {}
+      inputs:
+        valueA:
+          type: int
+      outputs:
+        valueA:
+          type: int
+      expression: |
+        ${
+          return {valueA: inputs.valueA};
+        }
+    in:
+      valueA:
+        source: [prev_step/valueA, valueA]
+        pickValue: first_non_null
+    out: [valueA]
+outputs:
+  valueA:
+    type: int
+    outputSource: main_step/valueA
+
+

toil/test/docs/scripts/tutorial_staging.py

@@ -4,7 +4,6 @@ from toil.common import Toil
 from toil.job import Job
 from toil.lib.io import mkdtemp
 
-
 class HelloWorld(Job):
     def __init__(self, id):
         Job.__init__(self)
@@ -22,6 +21,7 @@ class HelloWorld(Job):
 
 if __name__ == "__main__":
     jobstore: str = mkdtemp("tutorial_staging")
+    tmp: str = mkdtemp("tutorial_staging_tmp")
     os.rmdir(jobstore)
     options = Job.Runner.getDefaultOptions(jobstore)
     options.logLevel = "INFO"
@@ -29,17 +29,26 @@ if __name__ == "__main__":
 
     with Toil(options) as toil:
         if not toil.options.restart:
-            ioFileDirectory = os.path.join(
-                os.path.dirname(os.path.abspath(__file__)), "stagingExampleFiles"
-            )
-            inputFileID = toil.importFile(
-                "file://" + os.path.abspath(os.path.join(ioFileDirectory, "in.txt"))
-            )
+            # Prepare an input file
+            path = os.path.join(tmp, "in.txt")
+            with open(path, "w") as f:
+                f.write("Hello,\n")
+            # In a real workflow, you would obtain an input file path from the
+            # user.
+
+            # Stage it into the Toil job store.
+            #
+            # Note: this may create a symlink depending on the value of the
+            # --linkImports command line option, in which case the original
+            # input file needs to still exist if the workflow is restarted.
+            inputFileID = toil.importFile(f"file://{path}")
+
+            # Run the workflow
             outputFileID = toil.start(HelloWorld(inputFileID))
         else:
             outputFileID = toil.restart()
 
         toil.exportFile(
             outputFileID,
-            "file://" + os.path.abspath(os.path.join(ioFileDirectory, "out.txt")),
+            "file://" + os.path.join(tmp, "out.txt"),
         )

toil/test/jobStores/jobStoreTest.py

@@ -420,27 +420,31 @@ class AbstractJobStoreTest:
 
         def testReadWriteFileStreamTextMode(self):
             """Checks if text mode is compatible for file streams."""
-            jobstore = self.jobstore_initialized
+            jobstore1 = self.jobstore_initialized
+            jobstore2 = self.jobstore_resumed_noconfig
             job = self.arbitraryJob()
-            jobstore.assign_job_id(job)
-            jobstore.create_job(job)
+            jobstore1.assign_job_id(job)
+            jobstore1.create_job(job)
 
             foo = "foo"
             bar = "bar"
 
-            with jobstore.write_file_stream(job.jobStoreID, encoding="utf-8") as (
+            with jobstore1.write_file_stream(job.jobStoreID, encoding="utf-8") as (
                 f,
                 fileID,
             ):
                 f.write(foo)
 
-            with jobstore.read_file_stream(fileID, encoding="utf-8") as f:
+            with jobstore1.read_file_stream(fileID, encoding="utf-8") as f:
                 self.assertEqual(foo, f.read())
 
-            with jobstore.update_file_stream(fileID, encoding="utf-8") as f:
+            with jobstore1.update_file_stream(fileID, encoding="utf-8") as f:
                 f.write(bar)
 
-            with jobstore.read_file_stream(fileID, encoding="utf-8") as f:
+            with jobstore1.read_file_stream(fileID, encoding="utf-8") as f:
+                self.assertEqual(bar, f.read())
+
+            with jobstore2.read_file_stream(fileID, encoding="utf-8") as f:
                 self.assertEqual(bar, f.read())
 
         def testPerJobFiles(self):
@@ -1173,6 +1177,9 @@ class AbstractEncryptedJobStoreTest:
             Create an encrypted file. Read it in encrypted mode then try with encryption off
             to ensure that it fails.
             """
+
+            from toil.lib.aws.s3 import AWSBadEncryptionKeyError
+
             phrase = b"This file is encrypted."
             fileName = "foo"
             with self.jobstore_initialized.write_shared_file_stream(
@@ -1186,13 +1193,14 @@ class AbstractEncryptedJobStoreTest:
             self.jobstore_initialized.config.sseKey = None
             try:
                 with self.jobstore_initialized.read_shared_file_stream(fileName) as f:
-                    self.assertEqual(phrase, f.read())
-            except AssertionError as e:
-                self.assertEqual(
-                    "Content is encrypted but no key was provided.", e.args[0]
-                )
-            else:
-                self.fail("Read encryption content with encryption off.")
+                    # If the read goes through, we should fail the assert because
+                    # we read the cyphertext
+                    assert f.read() != phrase, (
+                        "Managed to read plaintext content with encryption off."
+                    )
+            except AWSBadEncryptionKeyError as e:
+                # If the read doesn't go through, we get this.
+                assert "Your AWS encryption key is most likely configured incorrectly" in str(e)
 
 
 class FileJobStoreTest(AbstractJobStoreTest.Test):
@@ -1435,113 +1443,6 @@ class AWSJobStoreTest(AbstractJobStoreTest.Test):
         assert isinstance(self.jobstore_initialized, AWSJobStore)  # type hinting
         self.jobstore_initialized.destroy()
 
-    def testSDBDomainsDeletedOnFailedJobstoreBucketCreation(self):
-        """
-        This test ensures that SDB domains bound to a jobstore are deleted if the jobstore bucket
-        failed to be created.  We simulate a failed jobstore bucket creation by using a bucket in a
-        different region with the same name.
-        """
-        from botocore.exceptions import ClientError
-
-        from toil.jobStores.aws.jobStore import BucketLocationConflictException
-        from toil.lib.aws.session import establish_boto3_session
-        from toil.lib.aws.utils import retry_s3
-
-        externalAWSLocation = "us-west-1"
-        for testRegion in "us-east-1", "us-west-2":
-            # We run this test twice, once with the default s3 server us-east-1 as the test region
-            # and once with another server (us-west-2).  The external server is always us-west-1.
-            # This incidentally tests that the BucketLocationConflictException is thrown when using
-            # both the default, and a non-default server.
-            testJobStoreUUID = str(uuid.uuid4())
-            # Create the bucket at the external region
-            bucketName = "domain-test-" + testJobStoreUUID + "--files"
-            client = establish_boto3_session().client(
-                "s3", region_name=externalAWSLocation
-            )
-            resource = establish_boto3_session().resource(
-                "s3", region_name=externalAWSLocation
-            )
-
-            for attempt in retry_s3(delays=(2, 5, 10, 30, 60), timeout=600):
-                with attempt:
-                    # Create the bucket at the home region
-                    client.create_bucket(
-                        Bucket=bucketName,
-                        CreateBucketConfiguration={
-                            "LocationConstraint": externalAWSLocation
-                        },
-                    )
-
-            owner_tag = os.environ.get("TOIL_OWNER_TAG")
-            if owner_tag:
-                for attempt in retry_s3(delays=(1, 1, 2, 4, 8, 16), timeout=33):
-                    with attempt:
-                        bucket_tagging = resource.BucketTagging(bucketName)
-                        bucket_tagging.put(
-                            Tagging={"TagSet": [{"Key": "Owner", "Value": owner_tag}]}
-                        )
-
-            options = Job.Runner.getDefaultOptions(
-                "aws:" + testRegion + ":domain-test-" + testJobStoreUUID
-            )
-            options.logLevel = "DEBUG"
-            try:
-                with Toil(options) as toil:
-                    pass
-            except BucketLocationConflictException:
-                # Catch the expected BucketLocationConflictException and ensure that the bound
-                # domains don't exist in SDB.
-                sdb = establish_boto3_session().client(
-                    region_name=self.awsRegion(), service_name="sdb"
-                )
-                next_token = None
-                allDomainNames = []
-                while True:
-                    if next_token is None:
-                        domains = sdb.list_domains(MaxNumberOfDomains=100)
-                    else:
-                        domains = sdb.list_domains(
-                            MaxNumberOfDomains=100, NextToken=next_token
-                        )
-                    allDomainNames.extend(domains["DomainNames"])
-                    next_token = domains.get("NextToken")
-                    if next_token is None:
-                        break
-                self.assertFalse([d for d in allDomainNames if testJobStoreUUID in d])
-            else:
-                self.fail()
-            finally:
-                try:
-                    for attempt in retry_s3():
-                        with attempt:
-                            client.delete_bucket(Bucket=bucketName)
-                except ClientError as e:
-                    # The actual HTTP code of the error is in status.
-                    if (
-                        e.response.get("ResponseMetadata", {}).get("HTTPStatusCode")
-                        == 404
-                    ):
-                        # The bucket doesn't exist; maybe a failed delete actually succeeded.
-                        pass
-                    else:
-                        raise
-
-    @slow
-    def testInlinedFiles(self):
-        from toil.jobStores.aws.jobStore import AWSJobStore
-
-        jobstore = self.jobstore_initialized
-        for encrypted in (True, False):
-            n = AWSJobStore.FileInfo.maxInlinedSize()
-            sizes = (1, n // 2, n - 1, n, n + 1, 2 * n)
-            for size in chain(sizes, islice(reversed(sizes), 1)):
-                s = os.urandom(size)
-                with jobstore.write_shared_file_stream("foo") as f:
-                    f.write(s)
-                with jobstore.read_shared_file_stream("foo") as f:
-                    self.assertEqual(s, f.read())
-
     def testOverlargeJob(self):
         jobstore = self.jobstore_initialized
         jobRequirements = dict(memory=12, cores=34, disk=35, preemptible=True)
@@ -1661,19 +1562,8 @@ class AWSJobStoreTest(AbstractJobStoreTest.Test):
         )
         delete_s3_bucket(resource, bucket.name)
 
-    def _largeLogEntrySize(self):
-        from toil.jobStores.aws.jobStore import AWSJobStore
-
-        # So we get into the else branch of reader() in uploadStream(multiPart=False):
-        return AWSJobStore.FileInfo.maxBinarySize() * 2
-
-    def _batchDeletionSize(self):
-        from toil.jobStores.aws.jobStore import AWSJobStore
-
-        return AWSJobStore.itemsPerBatchDelete
-
 
-@needs_aws_s3
+# @needs_aws_s3
 class InvalidAWSJobStoreTest(ToilTest):
     def testInvalidJobStoreName(self):
         from toil.jobStores.aws.jobStore import AWSJobStore