total-perspective-vortex 3.2.1__tar.gz → 3.3.1__tar.gz

{total_perspective_vortex-3.2.1 → total_perspective_vortex-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: total-perspective-vortex
-Version: 3.2.1
+Version: 3.3.1
 Summary: A library for routing entities (jobs, users or groups) to destinations in Galaxy
 Author: Galaxy Contributors
 Maintainer-email: Galaxy Committers <galaxy-committers@lists.galaxyproject.org>
@@ -22,10 +22,14 @@ Requires-Dist: types-requests
 Provides-Extra: cli
 Requires-Dist: total-perspective-vortex; extra == "cli"
 Requires-Dist: galaxy; extra == "cli"
+Provides-Extra: resource-pools
+Requires-Dist: redis>=5.3.0; extra == "resource-pools"
 Provides-Extra: test
 Requires-Dist: total-perspective-vortex[cli]; extra == "test"
+Requires-Dist: total-perspective-vortex[resource-pools]; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: responses; extra == "test"
+Requires-Dist: fakeredis[lua]; extra == "test"
 Requires-Dist: tox>=2.9.1; extra == "test"
 Requires-Dist: coverage>=4.4.1; extra == "test"
 Provides-Extra: dev
@@ -59,12 +63,12 @@ GTN](https://training.galaxyproject.org/training-material/topics/admin/tutorials
 ### Installing latest released version
 
 Once configured in the Galaxy application, TPV will be automatically installed
-in the Galaxy environment. If you would like to manually install it instead, you
-can do so from [PyPI](https://pypi.org/project/total-perspective-vortex/) with
+in the Galaxy environment. If you would like to manually install it for independent
+CLI use instead, you can do so from [PyPI](https://pypi.org/project/total-perspective-vortex/) with
 the following command:
 
 ```python
-pip install total-perspective-vortex
+pip install "total-perspective-vortex[cli]"
 ```
 
 

{total_perspective_vortex-3.2.1 → total_perspective_vortex-3.3.1}/README.md

@@ -23,12 +23,12 @@ GTN](https://training.galaxyproject.org/training-material/topics/admin/tutorials
 ### Installing latest released version
 
 Once configured in the Galaxy application, TPV will be automatically installed
-in the Galaxy environment. If you would like to manually install it instead, you
-can do so from [PyPI](https://pypi.org/project/total-perspective-vortex/) with
+in the Galaxy environment. If you would like to manually install it for independent
+CLI use instead, you can do so from [PyPI](https://pypi.org/project/total-perspective-vortex/) with
 the following command:
 
 ```python
-pip install total-perspective-vortex
+pip install "total-perspective-vortex[cli]"
 ```
 
 

{total_perspective_vortex-3.2.1 → total_perspective_vortex-3.3.1}/pyproject.toml

@@ -14,7 +14,7 @@ authors = [
 maintainers = [
     {name = "Galaxy Committers", email = "galaxy-committers@lists.galaxyproject.org"}
 ]
-version = "3.2.1"
+version = "3.3.1"
 dependencies = [
     "pydantic>=2",
     "cachetools>=3.1.0",
@@ -33,10 +33,19 @@ cli = [
   "total-perspective-vortex",
   "galaxy"
 ]
+# Required by the Valkey-backed per-user resource pools (see docs: Per-user resource pools).
+# redis-py speaks the Valkey wire protocol.
+resource-pools = [
+  "redis>=5.3.0",
+]
 test = [
   "total-perspective-vortex[cli]",
+  "total-perspective-vortex[resource-pools]",
   "pytest",
   "responses",
+  # Lets the resource-pool store contract test run the real Valkey adapter (Lua script)
+  # without a live server. This is required: the production Lua path must be tested.
+  "fakeredis[lua]",
   "tox>=2.9.1",
   "coverage>=4.4.1",
 ]
@@ -56,6 +65,9 @@ Documentation = "https://total-perspective-vortex.readthedocs.io"
 [tool.setuptools]
 include-package-data = true
 
+[tool.setuptools.packages.find]
+include = ["tpv*"]
+
 [tool.setuptools.package-data]
 "tpv" = ["**/*.j2"]
 

total_perspective_vortex-3.3.1/tests/test_dryrunner_resource_pool.py

@@ -0,0 +1,60 @@
+import os
+import unittest
+
+from tpv.commands.dryrunner import TPVDryRunner
+from tpv.commands.test import mock_galaxy
+from tpv.core.resource_pool import InMemoryAllocationStore
+from tpv.rules import gateway
+
+FIXTURES = os.path.join(os.path.dirname(__file__), "fixtures")
+POOL_CONFIG = os.path.join(FIXTURES, "mapping-resource-pool.yml")
+DEAD_STORE_OVERLAY = os.path.join(FIXTURES, "mapping-resource-pool-dead-store.yml")
+JOB_CONF = os.path.join(FIXTURES, "job_conf_dry_run.yml")
+
+
+class TestMockJob(unittest.TestCase):
+    def test_jobs_get_distinct_default_ids(self):
+        # Pool admission keys the ledger by job id, so a mock job must always have one.
+        a, b = mock_galaxy.Job(), mock_galaxy.Job()
+        self.assertIsInstance(a.id, int)
+        self.assertNotEqual(a.id, b.id)
+
+
+class TestDryRunResourcePools(unittest.TestCase):
+    def _run(self, tool, user, confs, explain=False):
+        runner = TPVDryRunner.from_params(job_conf=JOB_CONF, tool_id=tool, user_email=user, tpv_confs=confs)
+        return runner.run(explain=explain)
+
+    def test_dry_run_maps_a_pooled_config(self):
+        destination, _ = self._run("bigtool", "arthur@vortex.org", [POOL_CONFIG])
+        self.assertEqual(destination.id, "local")
+
+    def test_dry_run_never_touches_the_configured_store(self):
+        # The configured store is a Valkey nothing listens on. If the dry run consulted it, the
+        # job would be deferred fail-closed (or the run would error); an admin's dry run must
+        # neither depend on nor write to production accounting.
+        destination, _ = self._run("bigtool", "arthur@vortex.org", [POOL_CONFIG, DEAD_STORE_OVERLAY])
+        self.assertEqual(destination.id, "local")
+        store = gateway.ACTIVE_DESTINATION_MAPPERS["tpv_dispatcher"].resource_pools.store
+        self.assertIsInstance(store, InMemoryAllocationStore)
+
+    def test_dry_run_still_reports_pools_without_a_store(self):
+        # Swapping in an in-memory store must not hide the misconfiguration the mapper rejects.
+        no_store = os.path.join(FIXTURES, "mapping-resource-pool-no-store.yml")
+        with self.assertRaisesRegex(ValueError, "resource_pool_store"):
+            self._run("bigtool", "arthur@vortex.org", [no_store])
+
+    def test_explain_reports_which_pools_govern_the_job_and_why(self):
+        _, collector = self._run("bigtool", "arthur@vortex.org", [POOL_CONFIG], explain=True)
+        trace = collector.render()
+        self.assertIn("Resource Pools", trace)
+        # bigtool is 64 cores against a 32-core budget: governed by 'default', classified oversize.
+        self.assertIn("default", trace)
+        self.assertIn("oversize", trace.lower())
+        self.assertIn("32", trace)
+
+    def test_explain_reports_a_permanently_rejected_request(self):
+        # hugetool (200 cores) exceeds the oversize ceiling and can never be scheduled.
+        destination, collector = self._run("hugetool", "arthur@vortex.org", [POOL_CONFIG], explain=True)
+        self.assertIsNone(destination)
+        self.assertIn("can never be scheduled", collector.render())

{total_perspective_vortex-3.2.1 → total_perspective_vortex-3.3.1}/tests/test_entity.py

@@ -11,6 +11,53 @@ from tpv.rules import gateway
 
 class TestEntity(unittest.TestCase):
 
+    def test_rule_context_uses_local_copy_and_keeps_self_alias(self):
+        loader = TPVConfigLoader(
+            {
+                "tools": {
+                    "test": {
+                        "cores": 1,
+                        "params": {},
+                        "rules": [
+                            {
+                                "if": "self is entity and entity.cores == 1",
+                                "execute": "entity.params['local_change'] = 'preserved'",
+                            },
+                            {"if": True, "cores": 4},
+                            {
+                                "if": "self is entity and entity.cores == 4",
+                                "execute": "entity.mem = 8",
+                            },
+                        ],
+                    }
+                }
+            }
+        )
+        original = loader.config.tools["test"]
+        context = {"entity": original, "self": original}
+        evaluated = original.evaluate_rules(context)
+        self.assertEqual(evaluated.cores, 4)
+        self.assertEqual(evaluated.mem, 8)
+        self.assertEqual(evaluated.params, {"local_change": "preserved"})
+        self.assertEqual(original.cores, 1)
+        self.assertIsNone(original.mem)
+        self.assertEqual(original.params, {})
+        self.assertIs(context["entity"], evaluated)
+        self.assertIs(context["self"], evaluated)
+        self.assertIsNot(evaluated, original)
+
+    def test_rule_context_initialized_when_no_rules_match(self):
+        for rules in ([], [{"if": False, "cores": 4}]):
+            with self.subTest(rules=rules):
+                loader = TPVConfigLoader({"tools": {"test": {"cores": 1, "rules": rules}}})
+                original = loader.config.tools["test"]
+                context = {}
+                evaluated = original.evaluate_rules(context)
+                self.assertIs(context["entity"], evaluated)
+                self.assertIs(context["self"], evaluated)
+                self.assertIsNot(evaluated, original)
+                self.assertEqual(evaluated.cores, 1)
+
     @staticmethod
     def _map_to_destination(app, job, tool, user, referrer=None):
         tpv_config = os.path.join(os.path.dirname(__file__), "fixtures/mapping-rule-argument-based.yml")

{total_perspective_vortex-3.2.1 → total_perspective_vortex-3.3.1}/tests/test_explain.py

@@ -3,11 +3,14 @@ import unittest
 from unittest.mock import MagicMock
 
 import yaml
+from galaxy.jobs import JobDestination
 from galaxy.jobs.mapper import JobMappingException
 
 from tpv.commands.dryrunner import TPVDryRunner
+from tpv.commands.test import mock_galaxy
 from tpv.core.entities import SchedulingTags
 from tpv.core.explain import ExplainCollector, ExplainPhase
+from tpv.rules import gateway
 
 
 class TestExplainCollectorUnit(unittest.TestCase):
@@ -239,6 +242,20 @@ class TestDryRunExplain(unittest.TestCase):
         self.assertIn("Destination Ranking", trace)
         self.assertIn("Final Result", trace)
 
+    def test_dry_run_explain_unconfigured_tool_without_a_default(self):
+        """A tool with no entity in a config that sets no default_inherits still maps, via the
+        entity TPV builds from the Galaxy tool itself -- and the trace names that entity, which is
+        how an admin learns the tool got injected defaults rather than configured ones."""
+        dry_runner = TPVDryRunner.from_params(
+            job_conf=self._fixture_path("job_conf_dry_run.yml"),
+            tool_id="a_tool_nobody_configured",
+            user_email="fairycake@vortex.org",
+            tpv_confs=[self._fixture_path("mapping-inheritance-no-default.yml")],
+        )
+        destination, collector = dry_runner.run(explain=True)
+        self.assertIsNotNone(destination)
+        self.assertIn("matched entity 'tool_provided_resources_a_tool_nobody_configured'", collector.render())
+
     def test_dry_run_explain_shows_matched_entities(self):
         """The trace should show which tool and user entities matched."""
         dry_runner = TPVDryRunner.from_params(
@@ -496,3 +513,61 @@ class TestDryRunExplain(unittest.TestCase):
             tpv_confs=[self._fixture_path("mapping-basic.yml")],
         )
         self.assertIsNone(runner.tool)
+
+
+class TestGatewayExplainOnFailure(unittest.TestCase):
+    """Tests for the tpv_explain_on_failure gateway config option."""
+
+    @staticmethod
+    def _fixture_path(name):
+        return os.path.join(os.path.dirname(__file__), f"fixtures/{name}")
+
+    def _call_gateway(self, tool_id, referrer=None, explain_collector=None):
+        gateway.ACTIVE_DESTINATION_MAPPERS = {}
+        app = mock_galaxy.App(job_conf=self._fixture_path("job_conf.yml"))
+        tool = mock_galaxy.Tool(tool_id)
+        job = mock_galaxy.Job()
+        user = mock_galaxy.User("gargravarr", "fairycake@vortex.org")
+        return gateway.map_tool_to_destination(
+            app,
+            job,
+            tool,
+            user,
+            referrer=referrer,
+            tpv_config_files=[self._fixture_path("mapping-basic.yml")],
+            explain_collector=explain_collector,
+        )
+
+    def test_no_log_when_param_not_set(self):
+        """No warning is logged on failure when tpv_explain_on_failure is not configured."""
+        with self.assertNoLogs("tpv.rules.gateway", level="WARNING"):
+            with self.assertRaises(JobMappingException):
+                self._call_gateway("unschedulable_tool")
+
+    def test_logs_trace_on_mapping_failure(self):
+        """A WARNING containing the scheduling trace is logged when tpv_explain_on_failure=true and mapping fails."""
+        referrer = JobDestination(id="tpv_dispatcher", params={"tpv_explain_on_failure": True})
+        with self.assertLogs("tpv.rules.gateway", level="WARNING") as cm:
+            with self.assertRaises(JobMappingException):
+                self._call_gateway("unschedulable_tool", referrer=referrer)
+        self.assertEqual(len(cm.records), 1)
+        trace = cm.records[0].getMessage()
+        self.assertIn("TPV SCHEDULING DECISION TRACE", trace)
+        self.assertIn("REJECTED", trace)
+        self.assertIn("tag mismatch", trace)
+        self.assertIn("No destinations", trace)
+
+    def test_no_log_on_successful_mapping(self):
+        """No warning is logged when tpv_explain_on_failure=true but mapping succeeds."""
+        referrer = JobDestination(id="tpv_dispatcher", params={"tpv_explain_on_failure": True})
+        with self.assertNoLogs("tpv.rules.gateway", level="WARNING"):
+            destination = self._call_gateway("bwa", referrer=referrer)
+        self.assertIsNotNone(destination)
+
+    def test_explicit_collector_not_logged_by_gateway(self):
+        """When an explicit explain_collector is passed (dry-run path), the gateway does not log on failure."""
+        collector = ExplainCollector()
+        with self.assertNoLogs("tpv.rules.gateway", level="WARNING"):
+            with self.assertRaises(JobMappingException):
+                self._call_gateway("unschedulable_tool", explain_collector=collector)
+        self.assertTrue(len(collector.steps) > 0)

total_perspective_vortex-3.3.1/tests/test_helpers.py

@@ -0,0 +1,350 @@
+"""Unit tests module for the helper functions"""
+
+import unittest
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from tpv.commands.test import mock_galaxy
+from tpv.core.helpers import (
+    concurrent_job_count_for_tool,
+    get_dataset_attributes,
+    get_input_dataset,
+    get_input_datasets,
+    get_input_size,
+    input_size,
+    job_args_match,
+    tool_version_eq,
+    tool_version_gte,
+    weighted_choice,
+    weighted_random_sampling,
+)
+
+
+class TestHelpers(unittest.TestCase):
+    """Tests for helper functions"""
+
+    def test_get_dataset_attributes(self):
+        """Test that the function returns a dictionary with the correct attributes"""
+        job = mock_galaxy.Job()
+        dataset = mock_galaxy.Dataset("test.txt", file_size=7 * 1024**3, object_store_id="files1")
+        job.add_input_dataset(mock_galaxy.DatasetAssociation("test", dataset))
+        dataset_attributes = get_dataset_attributes(job.input_datasets)
+        expected_result = {dataset.id: {"object_store_id": "files1", "size": 7 * 1024**3}}
+        self.assertEqual(dataset_attributes, expected_result)
+
+    @staticmethod
+    def _job_with_multiple_data_param():
+        """A job with a `multiple="true"` data param `inputs` holding two datasets.
+
+        Galaxy records the first dataset twice: once as `inputs` (the copy-metadata alias for
+        the first element) and once as `inputs1`.
+        """
+        job = mock_galaxy.Job()
+        first = mock_galaxy.DatasetAssociation(
+            "first", mock_galaxy.Dataset("first.txt", file_size=3 * 1024**3), extension="txt"
+        )
+        second = mock_galaxy.DatasetAssociation(
+            "second", mock_galaxy.Dataset("second.txt", file_size=5 * 1024**3), extension="txt"
+        )
+        job.add_input_dataset(first, name="inputs")
+        job.add_input_dataset(first, name="inputs1")
+        job.add_input_dataset(second, name="inputs2")
+        return job
+
+    def test_get_input_datasets_deduplicates_multiple_data_param_alias(self):
+        """The `name`/`name1` alias of a multiple data param must not yield the dataset twice"""
+        job = self._job_with_multiple_data_param()
+        datasets = get_input_datasets(job, "inputs")
+        self.assertEqual([dataset.name for dataset in datasets], ["first", "second"])
+
+    def test_get_input_datasets_matches_collection_element_names(self):
+        """A collection param is recorded as `name1`..`nameN`, with no unsuffixed entry"""
+        job = mock_galaxy.Job()
+        for index in range(1, 4):
+            job.add_input_dataset(
+                mock_galaxy.DatasetAssociation(
+                    f"element{index}", mock_galaxy.Dataset(f"element{index}.txt", file_size=1 * 1024**3)
+                ),
+                name=f"inputs{index}",
+            )
+        datasets = get_input_datasets(job, "inputs")
+        self.assertEqual([dataset.name for dataset in datasets], ["element1", "element2", "element3"])
+
+    def test_get_input_datasets_ignores_other_params(self):
+        """Only datasets recorded for the requested param are returned"""
+        job = self._job_with_multiple_data_param()
+        job.add_input_dataset(
+            mock_galaxy.DatasetAssociation("ref", mock_galaxy.Dataset("ref.txt", file_size=9 * 1024**3)),
+            name="reference",
+        )
+        self.assertEqual([dataset.name for dataset in get_input_datasets(job, "reference")], ["ref"])
+        self.assertEqual([dataset.name for dataset in get_input_datasets(job, "inputs")], ["first", "second"])
+        self.assertEqual([dataset.name for dataset in get_input_datasets(job)], ["first", "second", "ref"])
+
+    def test_get_input_datasets_skips_unset_optional_params(self):
+        """An unset optional data param is recorded with no dataset at all"""
+        job = mock_galaxy.Job()
+        job.input_datasets.append(mock_galaxy.JobToInputDatasetAssociation("inputs", None))
+        self.assertEqual(get_input_datasets(job, "inputs"), [])
+        self.assertIsNone(get_input_dataset(job, "inputs"))
+        self.assertEqual(get_input_size(job, "inputs"), 0)
+
+    def test_get_input_dataset_returns_first_match(self):
+        job = self._job_with_multiple_data_param()
+        dataset = get_input_dataset(job, "inputs")
+        self.assertEqual(dataset.name, "first")
+        self.assertIsNone(get_input_dataset(job, "nonexistent"))
+
+    def test_get_input_size_totals_all_inputs_by_default(self):
+        job = self._job_with_multiple_data_param()
+        self.assertEqual(get_input_size(job), 8)
+        # the existing input_size helper deduplicates the same way
+        self.assertEqual(input_size(job), 8)
+
+    def test_get_input_size_skips_inputs_whose_dataset_is_gone(self):
+        # An input association can outlive its dataset (deleted or purged). It must contribute
+        # nothing rather than raise mid-scheduling.
+        job = self._job_with_multiple_data_param()
+        job.add_input_dataset(mock_galaxy.DatasetAssociation("gone", None))
+        self.assertEqual(get_input_size(job), 8)
+
+    def test_get_input_size_by_param_name(self):
+        job = self._job_with_multiple_data_param()
+        job.add_input_dataset(
+            mock_galaxy.DatasetAssociation("ref", mock_galaxy.Dataset("ref.txt", file_size=9 * 1024**3)),
+            name="reference",
+        )
+        self.assertEqual(get_input_size(job, "inputs"), 8)
+        self.assertEqual(get_input_size(job, "reference"), 9)
+        self.assertEqual(get_input_size(job), 17)
+
+    def test_get_input_size_adjusts_compressed_inputs(self):
+        job = mock_galaxy.Job()
+        job.add_input_dataset(
+            mock_galaxy.DatasetAssociation(
+                "compressed",
+                mock_galaxy.Dataset("compressed.fastq.gz", file_size=2 * 1024**3),
+                extension="fastqsanger.gz",
+            ),
+            name="inputs1",
+        )
+        job.add_input_dataset(
+            mock_galaxy.DatasetAssociation(
+                "uncompressed",
+                mock_galaxy.Dataset("uncompressed.fastq", file_size=4 * 1024**3),
+                extension="fastqsanger",
+            ),
+            name="inputs2",
+        )
+        self.assertAlmostEqual(get_input_size(job, "inputs"), 2 * 3.4 + 4)
+        self.assertAlmostEqual(get_input_size(job, "inputs", compression_factor=2), 2 * 2 + 4)
+        self.assertEqual(get_input_size(job, "inputs", estimate_uncompressed_size=False), 6)
+
+    def test_weighted_random_sampling_without_weights_uses_unweighted_sampling(self):
+        """When no destination defines params.weight, use unweighted random sampling."""
+        destinations = [
+            SimpleNamespace(id="dest_a", params={}),
+            SimpleNamespace(id="dest_b", params=None),
+            SimpleNamespace(id="dest_c", params={"foo": "bar"}),
+        ]
+        sampled_destinations = [destinations[2], destinations[0], destinations[1]]
+
+        with patch("tpv.core.helpers.random.sample", return_value=sampled_destinations) as sample_mock:
+            with patch("tpv.core.helpers.random.choices") as choices_mock:
+                result = weighted_random_sampling(destinations)
+
+        self.assertEqual(result, sampled_destinations)
+        sample_mock.assert_called_once_with(destinations, k=3)
+        choices_mock.assert_not_called()
+
+    def test_weighted_random_sampling_with_weights_uses_weighted_choices(self):
+        """When any destination defines params.weight, use weighted random choices."""
+        destinations = [
+            SimpleNamespace(id="dest_a", params={"weight": 5}),
+            SimpleNamespace(id="dest_b", params={}),
+            SimpleNamespace(id="dest_c", params=None),
+        ]
+        sampled_destinations = [destinations[0], destinations[0], destinations[2]]
+
+        with patch("tpv.core.helpers.random.choices", return_value=sampled_destinations) as choices_mock:
+            with patch("tpv.core.helpers.random.sample") as sample_mock:
+                result = weighted_random_sampling(destinations)
+
+        self.assertEqual(result, sampled_destinations)
+        choices_mock.assert_called_once_with(destinations, weights=[5, 1, 1], k=3)
+        sample_mock.assert_not_called()
+
+    def test_weighted_choice_without_weights_uses_unweighted_choice(self):
+        """When no item defines weight, use unweighted random choice."""
+        items = [
+            {"value": "/fast/jobs"},
+            {"value": "/slow/jobs"},
+            {"value": "/backup/jobs", "foo": "bar"},
+        ]
+
+        with patch("tpv.core.helpers.random.sample", return_value=[items[1]]) as sample_mock:
+            with patch("tpv.core.helpers.random.choices") as choices_mock:
+                result = weighted_choice(items)
+
+        self.assertEqual(result, items[1])
+        sample_mock.assert_called_once_with(items, k=1)
+        choices_mock.assert_not_called()
+
+    def test_weighted_choice_with_weights_uses_weighted_choices(self):
+        """When any item defines weight, use weighted random choices."""
+        items = [
+            {"value": "/fast/jobs", "weight": 3},
+            {"value": "/slow/jobs"},
+            {"value": "/backup/jobs"},
+        ]
+        with patch("tpv.core.helpers.random.choices", return_value=[items[0]]) as choices_mock:
+            with patch("tpv.core.helpers.random.sample") as sample_mock:
+                result = weighted_choice(items)
+
+        self.assertEqual(result, items[0])
+        choices_mock.assert_called_once_with(items, weights=[3, 1, 1], k=1)
+        sample_mock.assert_not_called()
+
+    def test_weighted_choice_missing_weight_defaults_to_one(self):
+        """Items without a weight key should default to weight 1."""
+        items = [
+            {"value": "/a", "weight": 5},
+            {"value": "/b"},
+            {"value": "/c"},
+        ]
+        with patch("tpv.core.helpers.random.choices", return_value=[items[1]]) as choices_mock:
+            result = weighted_choice(items)
+
+        self.assertEqual(result, items[1])
+        choices_mock.assert_called_once_with(items, weights=[5, 1, 1], k=1)
+
+    def test_weighted_choice_zero_weights_falls_back_to_unweighted(self):
+        """If all weights are zero or negative, fall back to unweighted selection."""
+        items = [
+            {"value": "/drained/jobs", "weight": 0},
+            {"value": "/also-drained/jobs", "weight": -1},
+        ]
+        with patch("tpv.core.helpers.random.sample", return_value=[items[0]]) as sample_mock:
+            with patch("tpv.core.helpers.random.choices") as choices_mock:
+                result = weighted_choice(items)
+
+        self.assertEqual(result, items[0])
+        sample_mock.assert_called_once_with(items, k=1)
+        choices_mock.assert_not_called()
+
+    def test_weighted_choice_negative_weight_is_clamped_to_zero(self):
+        """A negative weight is clamped to 0 while positive weights are preserved."""
+        items = [
+            {"value": "/a", "weight": 5},
+            {"value": "/b", "weight": -3},
+        ]
+        with patch("tpv.core.helpers.random.choices", return_value=[items[0]]) as choices_mock:
+            with patch("tpv.core.helpers.random.sample") as sample_mock:
+                weighted_choice(items)
+
+        choices_mock.assert_called_once_with(items, weights=[5, 0], k=1)
+        sample_mock.assert_not_called()
+
+    def test_weighted_choice_default_weight_keys_use_unweighted(self):
+        """If every item has weight: 1 (the default), use unweighted choice."""
+        items = [
+            {"value": "/a", "weight": 1},
+            {"value": "/b", "weight": 1},
+        ]
+        with patch("tpv.core.helpers.random.sample", return_value=[items[0]]) as sample_mock:
+            with patch("tpv.core.helpers.random.choices") as choices_mock:
+                weighted_choice(items)
+
+        sample_mock.assert_called_once_with(items, k=1)
+        choices_mock.assert_not_called()
+
+    def test_weighted_choice_empty_list_raises_value_error(self):
+        """An empty list should raise ValueError."""
+        with self.assertRaises(ValueError):
+            weighted_choice([])
+
+    def test_weighted_choice_returns_selected_item(self):
+        """The helper should return the selected item, not a derived string value."""
+        items = [
+            {"value": "/primary/jobs", "weight": 10},
+            {"value": "/secondary/jobs", "weight": 1},
+        ]
+        with patch("tpv.core.helpers.random.choices", return_value=[items[1]]):
+            result = weighted_choice(items)
+
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result, items[1])
+
+
+class TestJobArgsMatch(unittest.TestCase):
+    """job_args_match decides whether a rule fires on a job's parameters. Its only test so far is
+    the positive case, which a helper that always returned True would pass."""
+
+    def setUp(self):
+        self.app = mock_galaxy.App(create_model=True)
+        self.job = mock_galaxy.Job()
+        self.job.param_values = {
+            "input_opts": {"db_selector": "db", "tabs_to_spaces": False},
+            "files": [{"name": "reads.fq"}],
+        }
+
+    def test_matches_only_when_every_given_value_matches(self):
+        self.assertTrue(job_args_match(self.job, self.app, {"input_opts": {"db_selector": "db"}}))
+        self.assertFalse(job_args_match(self.job, self.app, {"input_opts": {"db_selector": "other"}}))
+        # one matching and one differing value is not a match
+        self.assertFalse(
+            job_args_match(self.job, self.app, {"input_opts": {"db_selector": "db", "tabs_to_spaces": True}})
+        )
+
+    def test_a_parameter_the_job_does_not_have_does_not_match(self):
+        self.assertFalse(job_args_match(self.job, self.app, {"input_opts": {"no_such_option": 1}}))
+        self.assertFalse(job_args_match(self.job, self.app, {"no_such_section": {"x": 1}}))
+        # a nested dict in args where the job's parameter is a scalar is a mismatch, not an error
+        self.assertFalse(job_args_match(self.job, self.app, {"files": {"name": "reads.fq"}}))
+
+    def test_nothing_to_match_against_never_matches(self):
+        for args in (None, {}, "input_opts", ["input_opts"]):
+            with self.subTest(args=args):
+                self.assertFalse(job_args_match(self.job, self.app, args))
+
+    def test_a_list_valued_parameter_is_compared_as_a_whole(self):
+        # Repeats and multi-selects are lists. The list is the value; keys inside its items are
+        # not a path into it.
+        self.assertTrue(job_args_match(self.job, self.app, {"files": [{"name": "reads.fq"}]}))
+        self.assertFalse(job_args_match(self.job, self.app, {"files": [{"name": "other.fq"}]}))
+
+
+class TestConcurrentJobCount(unittest.TestCase):
+    def test_plain_tool_ids_match_exactly_and_do_not_count_prefix_collisions(self):
+        # Tool Shed ids are matched by prefix so every installed version is counted together.
+        # A plain id must not get that treatment: "bwa" must not count "bwa_mem" jobs.
+        app = mock_galaxy.App(create_model=True)
+        session = app.model.context
+        user = app.model.User(username="arthur", email="arthur@vortex.org", password="x")
+        session.add(user)
+        session.flush()
+        for tool_id in ("bwa", "bwa", "bwa_mem"):
+            job = app.model.Job()
+            job.user = user
+            job.tool_id = tool_id
+            job.state = "running"
+            session.add(job)
+        session.flush()
+
+        self.assertEqual(concurrent_job_count_for_tool(app, mock_galaxy.Tool("bwa")), 2)
+        self.assertEqual(concurrent_job_count_for_tool(app, mock_galaxy.Tool("bwa_mem")), 1)
+
+
+class TestToolVersionComparison(unittest.TestCase):
+    def test_versions_are_compared_as_versions_not_strings(self):
+        tool = mock_galaxy.Tool("t", version="1.2.0")
+        self.assertTrue(tool_version_eq(tool, "1.2"))  # PEP 440: 1.2.0 == 1.2
+        self.assertTrue(tool_version_eq(tool, "1.2.0"))
+        self.assertFalse(tool_version_eq(tool, "1.3"))
+        self.assertTrue(tool_version_gte(tool, "1.10") is False)  # not a string compare: "1.2" < "1.10"
+
+    def test_comparison_is_unknown_not_false_when_a_version_is_missing(self):
+        # A rule can tell "no version to compare" (None) from "compared and did not match" (False).
+        unversioned = mock_galaxy.Tool("t")
+        self.assertIsNone(tool_version_eq(unversioned, "1.0"))
+        self.assertIsNone(tool_version_gte(mock_galaxy.Tool("t", version="1.0"), None))

{total_perspective_vortex-3.2.1 → total_perspective_vortex-3.3.1}/tests/test_mapper_context.py

@@ -44,7 +44,7 @@ class TestMapperContext(unittest.TestCase):
         self.assertEqual(destination.params["native_spec"], "--mem 15 --cores 5 --gpus 4")
 
     def test_context_variable_overridden_in_rule(self):
-        # test that job will not fail with 40GB input size because large_input_size has been set to 60
+        # test that job will not fail with 40GiB input size because large_input_size has been set to 60
         tool = mock_galaxy.Tool("bwa")
         user = mock_galaxy.User("gargravarr", "fairycake@vortex.org")
         datasets = [mock_galaxy.DatasetAssociation("test", mock_galaxy.Dataset("test.txt", file_size=40 * 1024**3))]