cumulusci-plus 5.0.22__py3-none-any.whl → 5.0.24__py3-none-any.whl

cumulusci/__about__.py

@@ -1 +1 @@
-__version__ = "5.0.22"
+__version__ = "5.0.24"

cumulusci/cli/tests/test_flow.py

@@ -4,9 +4,10 @@ import click
 import pytest
 
 from cumulusci.cli.runtime import CliRuntime
-from cumulusci.core.config import FlowConfig
+from cumulusci.core.config import FlowConfig, OrgConfig
 from cumulusci.core.exceptions import CumulusCIException, FlowNotFoundError
-from cumulusci.core.flowrunner import FlowCoordinator
+from cumulusci.core.flowrunner import FlowCoordinator, FlowStepSpec, StepSpec
+from cumulusci.tests.util import create_project_config
 
 from .. import flow
 from .utils import DummyTask, run_click_command
@@ -274,3 +275,279 @@ def test_flow_run__org_delete_error(echo):
     echo.assert_any_call(
         "Scratch org deletion failed.  Ignoring the error below to complete the flow:"
     )
+
+
+# Tests for new FlowStepSpec and flow skipping functionality
+
+
+class TestFlowStepSpec:
+    """Test the FlowStepSpec class functionality."""
+
+    def test_flowstep_spec_creation(self):
+        """Test that FlowStepSpec can be created with proper inheritance."""
+        project_config = create_project_config("TestOwner", "TestRepo")
+
+        flow_step = FlowStepSpec(
+            task_config={"test": "value"},
+            step_num="1.0",
+            task_name="test_flow",
+            task_class=None,
+            project_config=project_config,
+            allow_failure=False,
+            when="org_config.username == 'test@example.com'",
+        )
+
+        assert isinstance(flow_step, StepSpec)
+        assert isinstance(flow_step, FlowStepSpec)
+        assert flow_step.task_name == "test_flow"
+        assert flow_step.when == "org_config.username == 'test@example.com'"
+        assert flow_step.task_config == {"test": "value"}
+
+
+class TestEvaluationMethods:
+    """Test the evaluation methods for flow and task skipping."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.project_config = create_project_config("TestOwner", "TestRepo")
+        self.org_config = OrgConfig(
+            {"username": "test@example.com"}, "test", mock.Mock()
+        )
+        self.org_config.refresh_oauth_token = mock.Mock()
+
+    def test_evaluate_flow_step_with_true_condition(self):
+        """Test _evaluate_flow_step with a condition that evaluates to True."""
+        flow_config = FlowConfig({"description": "Test Flow", "steps": {}})
+        flow_config.project_config = self.project_config
+        coordinator = FlowCoordinator(self.project_config, flow_config)
+        coordinator.org_config = self.org_config
+
+        step = FlowStepSpec(
+            task_config={},
+            step_num="1.0",
+            task_name="test_flow",
+            task_class=None,
+            project_config=self.project_config,
+            allow_failure=False,
+            when="org_config.username == 'test@example.com'",
+        )
+
+        result = coordinator._evaluate_flow_step(step)
+        assert result is True
+
+    def test_evaluate_flow_step_with_false_condition(self):
+        """Test _evaluate_flow_step with a condition that evaluates to False."""
+        flow_config = FlowConfig({"description": "Test Flow", "steps": {}})
+        flow_config.project_config = self.project_config
+        coordinator = FlowCoordinator(self.project_config, flow_config)
+        coordinator.org_config = self.org_config
+
+        step = FlowStepSpec(
+            task_config={},
+            step_num="1.0",
+            task_name="test_flow",
+            task_class=None,
+            project_config=self.project_config,
+            allow_failure=False,
+            when="org_config.username == 'wrong@example.com'",
+        )
+
+        result = coordinator._evaluate_flow_step(step)
+        assert result is False
+
+    def test_evaluate_flow_step_without_when_condition(self):
+        """Test _evaluate_flow_step without a when condition."""
+        flow_config = FlowConfig({"description": "Test Flow", "steps": {}})
+        flow_config.project_config = self.project_config
+        coordinator = FlowCoordinator(self.project_config, flow_config)
+        coordinator.org_config = self.org_config
+
+        step = FlowStepSpec(
+            task_config={},
+            step_num="1.0",
+            task_name="test_flow",
+            task_class=None,
+            project_config=self.project_config,
+            allow_failure=False,
+            when=None,
+        )
+
+        result = coordinator._evaluate_flow_step(step)
+        assert result is True
+
+    def test_is_task_in_skipped_flow_true(self):
+        """Test _is_task_in_skipped_flow returns True when task is in skipped flow."""
+        flow_config = FlowConfig({"description": "Test Flow", "steps": {}})
+        flow_config.project_config = self.project_config
+        coordinator = FlowCoordinator(self.project_config, flow_config)
+        coordinator.org_config = self.org_config
+
+        skipped_flows_set = {"skipped_flow", "another_flow"}
+        task_path = "skipped_flow.sub_task"
+
+        result = coordinator._is_task_in_skipped_flow(task_path, skipped_flows_set)
+        assert result is True
+
+    def test_is_task_in_skipped_flow_false(self):
+        """Test _is_task_in_skipped_flow returns False when task is not in skipped flow."""
+        flow_config = FlowConfig({"description": "Test Flow", "steps": {}})
+        flow_config.project_config = self.project_config
+        coordinator = FlowCoordinator(self.project_config, flow_config)
+        coordinator.org_config = self.org_config
+
+        skipped_flows_set = {"skipped_flow", "another_flow"}
+        task_path = "normal_flow.sub_task"
+
+        result = coordinator._is_task_in_skipped_flow(task_path, skipped_flows_set)
+        assert result is False
+
+    def test_is_task_in_skipped_flow_empty_set(self):
+        """Test _is_task_in_skipped_flow with empty skipped flows set."""
+        flow_config = FlowConfig({"description": "Test Flow", "steps": {}})
+        flow_config.project_config = self.project_config
+        coordinator = FlowCoordinator(self.project_config, flow_config)
+        coordinator.org_config = self.org_config
+
+        skipped_flows_set = set()
+        task_path = "any_flow.sub_task"
+
+        result = coordinator._is_task_in_skipped_flow(task_path, skipped_flows_set)
+        assert result is False
+
+
+class TestExpressionCaching:
+    """Test Jinja2 expression caching functionality."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.project_config = create_project_config("TestOwner", "TestRepo")
+        self.org_config = OrgConfig(
+            {"username": "test@example.com"}, "test", mock.Mock()
+        )
+        self.org_config.refresh_oauth_token = mock.Mock()
+
+    def test_expression_caching_reuse(self):
+        """Test that compiled expressions are cached and reused."""
+        flow_config = FlowConfig({"description": "Test Flow", "steps": {}})
+        flow_config.project_config = self.project_config
+        coordinator = FlowCoordinator(self.project_config, flow_config)
+        coordinator.org_config = self.org_config
+
+        # Clear any existing cache
+        coordinator._expression_cache = {}
+
+        step1 = FlowStepSpec(
+            task_config={},
+            step_num="1.0",
+            task_name="test_flow1",
+            task_class=None,
+            project_config=self.project_config,
+            allow_failure=False,
+            when="org_config.username == 'test@example.com'",
+        )
+
+        step2 = FlowStepSpec(
+            task_config={},
+            step_num="2.0",
+            task_name="test_flow2",
+            task_class=None,
+            project_config=self.project_config,
+            allow_failure=False,
+            when="org_config.username == 'test@example.com'",
+        )
+
+        # First evaluation should compile and cache the expression
+        result1 = coordinator._evaluate_flow_step(step1)
+        assert result1 is True
+        assert len(coordinator._expression_cache) == 1
+
+        # Second evaluation should use cached expression
+        result2 = coordinator._evaluate_flow_step(step2)
+        assert result2 is True
+        assert (
+            len(coordinator._expression_cache) == 1
+        )  # Still only one cached expression
+
+    def test_expression_caching_different_expressions(self):
+        """Test that different expressions are cached separately."""
+        flow_config = FlowConfig({"description": "Test Flow", "steps": {}})
+        flow_config.project_config = self.project_config
+        coordinator = FlowCoordinator(self.project_config, flow_config)
+        coordinator.org_config = self.org_config
+
+        # Clear any existing cache
+        coordinator._expression_cache = {}
+
+        step1 = FlowStepSpec(
+            task_config={},
+            step_num="1.0",
+            task_name="test_flow1",
+            task_class=None,
+            project_config=self.project_config,
+            allow_failure=False,
+            when="org_config.username == 'test@example.com'",
+        )
+
+        step2 = FlowStepSpec(
+            task_config={},
+            step_num="2.0",
+            task_name="test_flow2",
+            task_class=None,
+            project_config=self.project_config,
+            allow_failure=False,
+            when="org_config.username == 'wrong@example.com'",
+        )
+
+        # Evaluate both steps
+        coordinator._evaluate_flow_step(step1)
+        coordinator._evaluate_flow_step(step2)
+
+        # Should have two different cached expressions
+        assert len(coordinator._expression_cache) == 2
+
+
+class TestPerformanceImprovements:
+    """Test that performance improvements work correctly."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.project_config = create_project_config("TestOwner", "TestRepo")
+        self.org_config = OrgConfig(
+            {"username": "test@example.com"}, "test", mock.Mock()
+        )
+        self.org_config.refresh_oauth_token = mock.Mock()
+
+    def test_context_reuse(self):
+        """Test that Jinja2 context is reused when possible."""
+        flow_config = FlowConfig({"description": "Test Flow", "steps": {}})
+        flow_config.project_config = self.project_config
+        coordinator = FlowCoordinator(self.project_config, flow_config)
+        coordinator.org_config = self.org_config
+
+        # Clear any existing context
+        coordinator._jinja2_context = None
+        coordinator._context_project_config = None
+        coordinator._context_org_config = None
+
+        step = FlowStepSpec(
+            task_config={},
+            step_num="1.0",
+            task_name="test_flow",
+            task_class=None,
+            project_config=self.project_config,
+            allow_failure=False,
+            when="org_config.username == 'test@example.com'",
+        )
+
+        # First evaluation should create context
+        result1 = coordinator._evaluate_flow_step(step)
+        assert result1 is True
+        assert coordinator._jinja2_context is not None
+        assert coordinator._context_project_config == self.project_config
+        assert coordinator._context_org_config == self.org_config
+
+        # Second evaluation should reuse context
+        original_context = coordinator._jinja2_context
+        result2 = coordinator._evaluate_flow_step(step)
+        assert result2 is True
+        assert coordinator._jinja2_context is original_context  # Same object reused

cumulusci/core/flowrunner.py

@@ -164,6 +164,11 @@ class StepSpec:
         )
 
 
+class FlowStepSpec(StepSpec):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+
 class StepResult(NamedTuple):
     step_num: StepVersion
     task_name: str
@@ -356,6 +361,10 @@ class FlowCoordinator:
 
         self.logger = self._init_logger()
         self.steps = self._init_steps()
+        self._expression_cache = {}
+        self._jinja2_context = None
+        self._context_project_config = None
+        self._context_org_config = None
 
     @classmethod
     def from_steps(
@@ -403,6 +412,9 @@ class FlowCoordinator:
         previous_parts = []
         previous_source = None
         for step in self.steps:
+            if isinstance(step, FlowStepSpec):
+                continue
+
             parts = step.path.split(".")
             steps = str(step.step_num).split("/")
             if len(parts) > len(steps):
@@ -491,7 +503,27 @@ class FlowCoordinator:
         self._rule(new_line=True)
 
         try:
+            # Pre-evaluate all flow conditions
+            skipped_flows_set = set()
             for step in self.steps:
+                if isinstance(step, FlowStepSpec):
+                    if not self._evaluate_flow_step(step):
+                        skipped_flows_set.add(step.path)
+
+            # Main execution loop with optimized path checking
+            for step in self.steps:
+                if isinstance(step, FlowStepSpec):
+                    self.logger.info(
+                        f"Skipping Flow {step.task_name} (skipped unless {step.when})"
+                    )
+                    continue
+
+                if self._is_task_in_skipped_flow(step.path, skipped_flows_set):
+                    self.logger.info(
+                        f"Skipping Task {step.task_name} in flow {step.path} (parent flow is skipped)"
+                    )
+                    continue
+
                 self._run_step(step)
             flow_name = f"'{self.name}' " if self.name else ""
             self.logger.info(
@@ -500,6 +532,45 @@ class FlowCoordinator:
         finally:
             self.callbacks.post_flow(self)
 
+    def _get_jinja2_context(self, project_config, org_config):
+        """Get or create jinja2 context, reusing when possible."""
+        if (
+            self._jinja2_context is None
+            or self._context_project_config != project_config
+            or self._context_org_config != org_config
+        ):
+
+            self._jinja2_context = {
+                "project_config": project_config,
+                "org_config": org_config,
+            }
+            self._context_project_config = project_config
+            self._context_org_config = org_config
+
+        return self._jinja2_context
+
+    def _evaluate_flow_step(self, step: StepSpec) -> bool:
+        if not step.when:
+            return True
+
+        # Check cache first
+        if step.when in self._expression_cache:
+            expr = self._expression_cache[step.when]
+        else:
+            expr = jinja2_env.compile_expression(step.when)
+            self._expression_cache[step.when] = expr
+
+        jinja2_context = self._get_jinja2_context(step.project_config, self.org_config)
+
+        return expr(**jinja2_context)
+
+    def _is_task_in_skipped_flow(self, task_path: str, skipped_flows_set: set) -> bool:
+        """Check if task belongs to any skipped flow using O(1) set lookup."""
+        for skipped_path in skipped_flows_set:
+            if task_path.startswith(skipped_path + "."):
+                return True
+        return False
+
     def _run_step(self, step: StepSpec):
         if step.skip:
             self._rule(fill="*")
@@ -508,12 +579,7 @@ class FlowCoordinator:
             return
 
         if step.when:
-            jinja2_context = {
-                "project_config": step.project_config,
-                "org_config": self.org_config,
-            }
-            expr = jinja2_env.compile_expression(step.when)
-            value = expr(**jinja2_context)
+            value = self._evaluate_flow_step(step)
             if not value:
                 self.logger.info(
                     f"Skipping task {step.task_name} (skipped unless {step.when})"
@@ -681,8 +747,24 @@ class FlowCoordinator:
             else:
                 path = name
             step_options = step_config.get("options", {})
+            parent_task_options = parent_options.get(name, {})
+            step_options.update(parent_task_options)
             step_ui_options = step_config.get("ui_options", {})
             flow_config = project_config.get_flow(name)
+
+            if step_config.get("when"):
+                visited_steps.append(
+                    FlowStepSpec(
+                        task_config={},
+                        step_num=step_number,
+                        task_name=path,
+                        task_class=None,
+                        project_config=flow_config.project_config,
+                        allow_failure=step_config.get("ignore_failure", False),
+                        when=step_config.get("when"),
+                    )
+                )
+
             for sub_number, sub_stepconf in flow_config.steps.items():
                 # append the flow number to the child number, since its a LooseVersion.
                 # e.g. if we're in step 2.3 which references a flow with steps 1-5, it

cumulusci/cumulusci.yml

@@ -831,6 +831,18 @@ tasks:
         class_path: cumulusci.tasks.salesforce.SfDataCommands.DataCreateRecordTask
         description: "Executes the `sf data create` command against an org"
         group: SalesforceDX Data Commands
+    update_package_version:
+        class_path: cumulusci.tasks.salesforce.SfPackageCommands.PackageVersionUpdateTask
+        description: "Executes the `sf package version update` command against an org"
+        group: Salesforce Packages
+    get_package_version:
+        description: Get package version id from package name and version
+        class_path: cumulusci.tasks.salesforce.getPackageVersion.GetPackageVersion
+        group: Salesforce Packages
+        options:
+            package_name: $project_config.project__package__name
+            fail_on_error: False
+
 flows:
     ci_beta:
         group: Continuous Integration

cumulusci/tasks/create_package_version.py

@@ -29,7 +29,7 @@ from cumulusci.core.exceptions import (
     VcsException,
 )
 from cumulusci.core.sfdx import convert_sfdx_source
-from cumulusci.core.utils import process_bool_arg
+from cumulusci.core.utils import process_bool_arg, process_list_arg
 from cumulusci.core.versions import PackageType, PackageVersionNumber, VersionTypeEnum
 from cumulusci.salesforce_api.package_zip import (
     BasePackageZipBuilder,
@@ -114,15 +114,21 @@ class CreatePackageVersion(BaseSalesforceApiTask):
         "version_base": {
             "description": "The version number to use as a base before incrementing. "
             "Optional; defaults to the highest existing version number of this package. "
-            "Can be set to ``latest_vcs_release`` to use the version of the most recent release published to GitHub."
+            "Can be set to ``latest_vcs_release`` to use the version of the most recent release published to VCS."
+            "If version_number is set, version_base and version_type will be ignored"
         },
         "version_type": {
             "description": "The part of the version number to increment. "
             "Options are major, minor, patch, build.  Defaults to build"
+            "If version_number is set, version_base and version_type will be ignored"
+        },
+        "version_number": {
+            "description": "Set a fixed version number, if not using version_base and version_type"
         },
         "skip_validation": {
             "description": "If true, skip validation of the package version. Default: false. "
             "Skipping validation creates packages more quickly, but they cannot be promoted for release."
+            "And package version is created without reference to dependencies."
         },
         "org_dependent": {
             "description": "If true, create an org-dependent unlocked package. Default: false."
@@ -156,6 +162,11 @@ class CreatePackageVersion(BaseSalesforceApiTask):
             "description": "If True, create unlocked packages for unpackaged metadata in this project and dependencies. "
             "Defaults to False."
         },
+        "dependencies": {
+            "description": "The list of dependencies to use when creating the package version. Defaults to None."
+            "If not provided, the dependencies will be resolved using the resolution_strategy."
+            "The format should be a pcakge version Ids i.e '04t...,04t...'"
+        },
     }
 
     def _init_options(self, kwargs):
@@ -200,6 +211,21 @@ class CreatePackageVersion(BaseSalesforceApiTask):
         self.options["create_unlocked_dependency_packages"] = process_bool_arg(
             self.options.get("create_unlocked_dependency_packages") or False
         )
+        self.options["version_number"] = (
+            PackageVersionNumber.parse(
+                self.options.get("version_number"), package_type=PackageType.SECOND_GEN
+            )
+            if self.options.get("version_number")
+            else None
+        )
+        self.options["dependencies"] = (
+            [
+                {"subscriberPackageVersionId": x}
+                for x in process_list_arg(self.options.get("dependencies"))
+            ]
+            if self.options.get("dependencies")
+            else None
+        )
 
     def _init_task(self):
         self.tooling = get_simple_salesforce_connection(
@@ -384,9 +410,13 @@ class CreatePackageVersion(BaseSalesforceApiTask):
                     return res["records"][0]["Id"]
 
             # Create the package descriptor
-            version_number = self._get_base_version_number(
+            version_number = self.options.get(
+                "version_number"
+            ) or self._get_base_version_number(
                 package_config.version_base, package_id
-            ).increment(package_config.version_type)
+            ).increment(
+                package_config.version_type
+            )
 
             package_descriptor = {
                 "id": package_id,
@@ -442,7 +472,9 @@ class CreatePackageVersion(BaseSalesforceApiTask):
                 and not is_dependency
             ):
                 self.logger.info("Determining dependencies for package")
-                dependencies = self._get_dependencies()
+                dependencies = (
+                    self.options.get("dependencies") or self._get_dependencies()
+                )
             if dependencies:
                 package_descriptor["dependencies"] = dependencies