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

toil/test/lib/test_conversions.py

@@ -13,9 +13,7 @@
 # limitations under the License.
 import logging
 
-from toil.lib.conversions import (convert_units,
-                                  hms_duration_to_seconds,
-                                  human2bytes)
+from toil.lib.conversions import convert_units, hms_duration_to_seconds, human2bytes
 from toil.test import ToilTest
 
 logger = logging.getLogger(__name__)
@@ -79,135 +77,135 @@ class ConversionTest(ToilTest):
             "11234234 KB": "0.0112 TB",
             "11234234 MB": "11.2342 TB",
             "11234234 GB": "11234.2340 TB",
-            "11234234 TB": "11234234.0000 TB"
+            "11234234 TB": "11234234.0000 TB",
         }
         results = {}
         for i in (0, 0.1, 0.5, 0.9, 1, 7, 7.42423, 10, 100, 1000, 11234234):
-            for src_unit in ['B', 'KB', 'MB', 'GB', 'TB']:
-                for dst_unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+            for src_unit in ["B", "KB", "MB", "GB", "TB"]:
+                for dst_unit in ["B", "KB", "MB", "GB", "TB"]:
                     converted = convert_units(i, src_unit, dst_unit)
-                    results[f'{i} {src_unit}'] = f'{converted:.4f} {dst_unit}'
+                    results[f"{i} {src_unit}"] = f"{converted:.4f} {dst_unit}"
         self.assertEqual(results, expected_conversions)
 
     def test_human2bytes(self):
         expected_results = {
-            '0 b': 0,
-            '0 Ki': 0,
-            '0 Mi': 0,
-            '0 Gi': 0,
-            '0 Ti': 0,
-            '0 K': 0,
-            '0 M': 0,
-            '0 G': 0,
-            '0 T': 0,
-            '0.1 b': 0,
-            '0.1 Ki': 102,
-            '0.1 Mi': 104857,
-            '0.1 Gi': 107374182,
-            '0.1 Ti': 109951162777,
-            '0.1 K': 100,
-            '0.1 M': 100000,
-            '0.1 G': 100000000,
-            '0.1 T': 100000000000,
-            '0.5 b': 0,
-            '0.5 Ki': 512,
-            '0.5 Mi': 524288,
-            '0.5 Gi': 536870912,
-            '0.5 Ti': 549755813888,
-            '0.5 K': 500,
-            '0.5 M': 500000,
-            '0.5 G': 500000000,
-            '0.5 T': 500000000000,
-            '0.9 b': 0,
-            '0.9 Ki': 921,
-            '0.9 Mi': 943718,
-            '0.9 Gi': 966367641,
-            '0.9 Ti': 989560464998,
-            '0.9 K': 900,
-            '0.9 M': 900000,
-            '0.9 G': 900000000,
-            '0.9 T': 900000000000,
-            '1 b': 1,
-            '1 Ki': 1024,
-            '1 Mi': 1048576,
-            '1 Gi': 1073741824,
-            '1 Ti': 1099511627776,
-            '1 K': 1000,
-            '1 M': 1000000,
-            '1 G': 1000000000,
-            '1 T': 1000000000000,
-            '7 b': 7,
-            '7 Ki': 7168,
-            '7 Mi': 7340032,
-            '7 Gi': 7516192768,
-            '7 Ti': 7696581394432,
-            '7 K': 7000,
-            '7 M': 7000000,
-            '7 G': 7000000000,
-            '7 T': 7000000000000,
-            '7.42423 b': 7,
-            '7.42423 Ki': 7602,
-            '7.42423 Mi': 7784869,
-            '7.42423 Gi': 7971706261,
-            '7.42423 Ti': 8163027212283,
-            '7.42423 K': 7424,
-            '7.42423 M': 7424230,
-            '7.42423 G': 7424230000,
-            '7.42423 T': 7424230000000,
-            '10 b': 10,
-            '10 Ki': 10240,
-            '10 Mi': 10485760,
-            '10 Gi': 10737418240,
-            '10 Ti': 10995116277760,
-            '10 K': 10000,
-            '10 M': 10000000,
-            '10 G': 10000000000,
-            '10 T': 10000000000000,
-            '100 b': 100,
-            '100 Ki': 102400,
-            '100 Mi': 104857600,
-            '100 Gi': 107374182400,
-            '100 Ti': 109951162777600,
-            '100 K': 100000,
-            '100 M': 100000000,
-            '100 G': 100000000000,
-            '100 T': 100000000000000,
-            '1000 b': 1000,
-            '1000 Ki': 1024000,
-            '1000 Mi': 1048576000,
-            '1000 Gi': 1073741824000,
-            '1000 Ti': 1099511627776000,
-            '1000 K': 1000000,
-            '1000 M': 1000000000,
-            '1000 G': 1000000000000,
-            '1000 T': 1000000000000000,
-            '11234234 b': 11234234,
-            '11234234 Ki': 11503855616,
-            '11234234 Mi': 11779948150784,
-            '11234234 Gi': 12062666906402816,
-            '11234234 Ti': 12352170912156483584,
-            '11234234 K': 11234234000,
-            '11234234 M': 11234234000000,
-            '11234234 G': 11234234000000000,
-            '11234234 T': 11234234000000000000
+            "0 b": 0,
+            "0 Ki": 0,
+            "0 Mi": 0,
+            "0 Gi": 0,
+            "0 Ti": 0,
+            "0 K": 0,
+            "0 M": 0,
+            "0 G": 0,
+            "0 T": 0,
+            "0.1 b": 0,
+            "0.1 Ki": 102,
+            "0.1 Mi": 104857,
+            "0.1 Gi": 107374182,
+            "0.1 Ti": 109951162777,
+            "0.1 K": 100,
+            "0.1 M": 100000,
+            "0.1 G": 100000000,
+            "0.1 T": 100000000000,
+            "0.5 b": 0,
+            "0.5 Ki": 512,
+            "0.5 Mi": 524288,
+            "0.5 Gi": 536870912,
+            "0.5 Ti": 549755813888,
+            "0.5 K": 500,
+            "0.5 M": 500000,
+            "0.5 G": 500000000,
+            "0.5 T": 500000000000,
+            "0.9 b": 0,
+            "0.9 Ki": 921,
+            "0.9 Mi": 943718,
+            "0.9 Gi": 966367641,
+            "0.9 Ti": 989560464998,
+            "0.9 K": 900,
+            "0.9 M": 900000,
+            "0.9 G": 900000000,
+            "0.9 T": 900000000000,
+            "1 b": 1,
+            "1 Ki": 1024,
+            "1 Mi": 1048576,
+            "1 Gi": 1073741824,
+            "1 Ti": 1099511627776,
+            "1 K": 1000,
+            "1 M": 1000000,
+            "1 G": 1000000000,
+            "1 T": 1000000000000,
+            "7 b": 7,
+            "7 Ki": 7168,
+            "7 Mi": 7340032,
+            "7 Gi": 7516192768,
+            "7 Ti": 7696581394432,
+            "7 K": 7000,
+            "7 M": 7000000,
+            "7 G": 7000000000,
+            "7 T": 7000000000000,
+            "7.42423 b": 7,
+            "7.42423 Ki": 7602,
+            "7.42423 Mi": 7784869,
+            "7.42423 Gi": 7971706261,
+            "7.42423 Ti": 8163027212283,
+            "7.42423 K": 7424,
+            "7.42423 M": 7424230,
+            "7.42423 G": 7424230000,
+            "7.42423 T": 7424230000000,
+            "10 b": 10,
+            "10 Ki": 10240,
+            "10 Mi": 10485760,
+            "10 Gi": 10737418240,
+            "10 Ti": 10995116277760,
+            "10 K": 10000,
+            "10 M": 10000000,
+            "10 G": 10000000000,
+            "10 T": 10000000000000,
+            "100 b": 100,
+            "100 Ki": 102400,
+            "100 Mi": 104857600,
+            "100 Gi": 107374182400,
+            "100 Ti": 109951162777600,
+            "100 K": 100000,
+            "100 M": 100000000,
+            "100 G": 100000000000,
+            "100 T": 100000000000000,
+            "1000 b": 1000,
+            "1000 Ki": 1024000,
+            "1000 Mi": 1048576000,
+            "1000 Gi": 1073741824000,
+            "1000 Ti": 1099511627776000,
+            "1000 K": 1000000,
+            "1000 M": 1000000000,
+            "1000 G": 1000000000000,
+            "1000 T": 1000000000000000,
+            "11234234 b": 11234234,
+            "11234234 Ki": 11503855616,
+            "11234234 Mi": 11779948150784,
+            "11234234 Gi": 12062666906402816,
+            "11234234 Ti": 12352170912156483584,
+            "11234234 K": 11234234000,
+            "11234234 M": 11234234000000,
+            "11234234 G": 11234234000000000,
+            "11234234 T": 11234234000000000000,
         }
 
         results = {}
         for i in (0, 0.1, 0.5, 0.9, 1, 7, 7.42423, 10, 100, 1000, 11234234):
-            for src_unit in ['b', 'Ki', 'Mi', 'Gi', 'Ti', 'K', 'M', 'G', 'T']:
-                results[f'{i} {src_unit}'] = human2bytes(f'{i} {src_unit}')
+            for src_unit in ["b", "Ki", "Mi", "Gi", "Ti", "K", "M", "G", "T"]:
+                results[f"{i} {src_unit}"] = human2bytes(f"{i} {src_unit}")
         self.assertEqual(results, expected_results)
 
     def test_hms_duration_to_seconds(self):
         expected_results = {
-            '0:0:0' : 0.0,
-            '00:00:00' : 0.0,
-            '1:1:1' : 3661.0,
-            '20:14:33' : 72873.0,
-            '72:80:112' : 264112.0,
+            "0:0:0": 0.0,
+            "00:00:00": 0.0,
+            "1:1:1": 3661.0,
+            "20:14:33": 72873.0,
+            "72:80:112": 264112.0,
         }
         results = {}
         for key in expected_results.keys():
-            results[key] = hms_duration_to_seconds(f'{key}')
-            
+            results[key] = hms_duration_to_seconds(f"{key}")
+
         self.assertEqual(results, expected_results)

toil/test/lib/test_ec2.py

@@ -14,17 +14,21 @@
 import logging
 import os
 
-import pytest
+from unittest import mock
 
-from toil.lib.aws.ami import (aws_marketplace_flatcar_ami_search,
-                              feed_flatcar_ami_release,
-                              flatcar_release_feed_amis,
-                              get_flatcar_ami)
+from toil.lib.aws.ami import (
+    aws_marketplace_flatcar_ami_search,
+    feed_flatcar_ami_release,
+    flatcar_release_feed_ami,
+    get_flatcar_ami,
+    ReleaseFeedUnavailableError
+)
 from toil.test import ToilTest, needs_aws_ec2, needs_online
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.DEBUG)
 
+
 @needs_online
 class FlatcarFeedTest(ToilTest):
     """Test accessing the Flatcar AMI release feed, independent of the AWS API"""
@@ -35,62 +39,66 @@ class FlatcarFeedTest(ToilTest):
 
     def test_parse_archive_feed(self):
         """Make sure we can get a Flatcar release from the Internet Archive."""
-        amis = list(flatcar_release_feed_amis('us-west-2', 'amd64', 'archive'))
-        for ami in amis:
-            self.assertEqual(len(ami), len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami.startswith('ami-'))
-            
+        ami = flatcar_release_feed_ami("us-west-2", "amd64", "archive")
+        self.assertEqual(len(ami), len("ami-02b46c73fed689d1c"))
+        self.assertTrue(ami.startswith("ami-"))
+
     def test_parse_beta_feed(self):
         """Make sure we can get a Flatcar release from the beta channel."""
-        amis = list(flatcar_release_feed_amis('us-west-2', 'amd64', 'beta'))
-        for ami in amis:
-            self.assertEqual(len(ami), len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami.startswith('ami-'))
-    
+        ami = flatcar_release_feed_ami("us-west-2", "amd64", "beta")
+        self.assertEqual(len(ami), len("ami-02b46c73fed689d1c"))
+        self.assertTrue(ami.startswith("ami-"))
+
     def test_parse_stable_feed(self):
         """Make sure we can get a Flatcar release from the stable channel."""
-        amis = list(flatcar_release_feed_amis('us-west-2', 'amd64', 'stable'))
-        for ami in amis:
-            self.assertEqual(len(ami), len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami.startswith('ami-'))
-            
+        ami = flatcar_release_feed_ami("us-west-2", "amd64", "stable")
+        self.assertEqual(len(ami), len("ami-02b46c73fed689d1c"))
+        self.assertTrue(ami.startswith("ami-"))
+
+
 @needs_aws_ec2
 class AMITest(ToilTest):
     @classmethod
     def setUpClass(cls):
         from toil.lib.aws.session import establish_boto3_session
-        session = establish_boto3_session(region_name='us-west-2')
-        cls.ec2_client = session.client('ec2')
+
+        session = establish_boto3_session(region_name="us-west-2")
+        cls.ec2_client = session.client("ec2")
 
     def test_fetch_flatcar(self):
-        with self.subTest('Test flatcar AMI from user is prioritized.'):
-            os.environ['TOIL_AWS_AMI'] = 'overridden'
-            ami = get_flatcar_ami(self.ec2_client)
-            self.assertEqual(ami, 'overridden')
-            del os.environ['TOIL_AWS_AMI']
-
-        with self.subTest('Test flatcar AMI returns an AMI-looking AMI.'):
-            ami = get_flatcar_ami(self.ec2_client)
-            self.assertEqual(len(ami), len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami.startswith('ami-'))
-
-        with self.subTest('Test feed_flatcar_ami_release() returns an AMI-looking AMI.'):
-            ami = feed_flatcar_ami_release(self.ec2_client, source='archive')
-            self.assertTrue(ami is None or len(ami) == len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami is None or ami.startswith('ami-'))
-
-        with self.subTest('Test aws_marketplace_flatcar_ami_search() returns an AMI-looking AMI.'):
+        with self.subTest("Test flatcar AMI from user is prioritized."):
+            with mock.patch.dict(os.environ, {"TOIL_AWS_AMI": "overridden"}):
+                ami = get_flatcar_ami(self.ec2_client)
+                self.assertEqual(ami, "overridden")
+
+        with self.subTest("Test flatcar AMI returns an AMI-looking AMI."):
+            try:
+                ami = get_flatcar_ami(self.ec2_client)
+                self.assertEqual(len(ami), len("ami-02b46c73fed689d1c"))
+                self.assertTrue(ami.startswith("ami-"))
+            except ReleaseFeedUnavailableError:
+                # Ignore any remote systems being down.
+                pass
+
+        with self.subTest(
+            "Test feed_flatcar_ami_release() returns an AMI-looking AMI."
+        ):
+            ami = feed_flatcar_ami_release(self.ec2_client, source="archive")
+            self.assertTrue(ami is None or len(ami) == len("ami-02b46c73fed689d1c"))
+            self.assertTrue(ami is None or ami.startswith("ami-"))
+
+        with self.subTest(
+            "Test aws_marketplace_flatcar_ami_search() returns an AMI-looking AMI."
+        ):
             ami = aws_marketplace_flatcar_ami_search(self.ec2_client)
-            self.assertEqual(len(ami), len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami.startswith('ami-'))
+            self.assertTrue(ami is None or len(ami), len("ami-02b46c73fed689d1c"))
+            self.assertTrue(ami is None or ami.startswith("ami-"))
 
-    # TODO: This will fail until https://github.com/flatcar/Flatcar/issues/962 is fixed
-    @pytest.mark.xfail
     def test_fetch_arm_flatcar(self):
         """Test flatcar AMI finder architecture parameter."""
-        amis = set()
-        for arch in ['amd64', 'arm64']:
-            ami = get_flatcar_ami(self.ec2_client, architecture=arch)
-            self.assertTrue(ami.startswith('ami-'))
-            amis.add(ami)
-        self.assertTrue(len(amis) == 2)
+        try:
+            ami = get_flatcar_ami(self.ec2_client, architecture="arm64")
+            self.assertTrue(ami.startswith("ami-"))
+        except ReleaseFeedUnavailableError:
+            # Ignore any remote systems being down.
+            pass

toil/test/lib/test_history.py

@@ -0,0 +1,212 @@
+# 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 os
+import logging
+import pytest
+import time
+from toil.test import ToilTest
+
+from toil.lib.history import HistoryManager
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.DEBUG)
+
+class HistoryTest(ToilTest):
+    """
+    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()
+
+    def make_fake_workflow(self, workflow_id: str) -> None:
+        # Make a fake workflow
+        workflow_jobstore_spec = "file:/tmp/tree"
+        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)
+        
+        # Give it a job
+        workflow_attempt_number = 1
+        job_name = "DoThing"
+        succeeded = True
+        start_time = time.time()
+        runtime = 0.1
+        HistoryManager.record_job_attempt( 
+            workflow_id,
+            workflow_attempt_number,
+            job_name,
+            succeeded,
+            start_time,
+            runtime,
+        )
+
+        # Give it a workflow attempt with the same details.
+        HistoryManager.record_workflow_attempt(
+            workflow_id,
+            workflow_attempt_number,
+            succeeded,
+            start_time,
+            runtime,
+        )
+
+    def test_history_submittable_detection(self) -> None:
+        """
+        Make sure that a submittable workflow shows up as such before
+        submission and doesn't afterward.
+        """
+        workflow_id = "123"
+        self.make_fake_workflow(workflow_id)
+        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)
+
+        # Make sure we see it as submittable
+        submittable_workflow_attempts = HistoryManager.get_submittable_workflow_attempts()
+        self.assertEqual(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)
+
+        # 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)
+
+        # 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)
+
+        # 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)
+
+        # 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)
+
+    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)
+
+        # 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)
+
+        # Make sure we can see the workflow for deletion by done-ness
+        self.assertEqual(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)
+
+        # Make sure the older workflow is first.
+        self.assertEqual(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])
+
+        # 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)
+
+
+    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)):
+            self.make_fake_workflow(workflow_id)
+
+        # We should see the workflows.
+        self.assertEqual(HistoryManager.count_workflows(), 10)
+        # And they take up space.
+        small_size = HistoryManager.get_database_byte_size()
+        self.assertGreater(small_size, 0)
+
+        # Add a bunch more
+        for workflow_id in ("WorkflowThatTakesUpSpace" + str(i) for i in range(50)):
+            self.make_fake_workflow(workflow_id)
+
+        # 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)
+        
+        # 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)
+        # 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)
+        
+
+
+
+
+       
+
+
+
+