cumulusci-plus 5.0.23__py3-none-any.whl → 5.0.25__py3-none-any.whl

cumulusci/__about__.py

@@ -1 +1 @@
-__version__ = "5.0.23"
+__version__ = "5.0.25"

cumulusci/cli/task.py

@@ -2,6 +2,7 @@ import json
 from pathlib import Path
 
 import click
+from dotenv import load_dotenv
 from rich.console import Console
 from rst2ansi import rst2ansi
 
@@ -126,6 +127,10 @@ class RunTaskCommand(click.MultiCommand):
             "help": "Drops into the Python debugger at task completion.",
             "is_flag": True,
         },
+        "loadenv": {
+            "help": "Loads environment variables from the .env file.",
+            "is_flag": True,
+        },
     }
 
     def list_commands(self, ctx):
@@ -151,6 +156,17 @@ class RunTaskCommand(click.MultiCommand):
 
         def run_task(*args, **kwargs):
             """Callback function that executes when the command fires."""
+            # Load environment variables FIRST, before any task processing
+            if kwargs.get("loadenv", None):
+                # Load .env file from the project root directory
+                env_path = (
+                    Path(runtime.project_config.repo_root) / ".env"
+                    if runtime.project_config
+                    else None
+                )
+                if env_path:
+                    load_dotenv(env_path)
+
             org, org_config = runtime.get_org(
                 kwargs.pop("org", None), fail_if_missing=False
             )
@@ -168,6 +184,7 @@ class RunTaskCommand(click.MultiCommand):
             task_config.config["options"].update(options)
 
             try:
+
                 task = task_class(
                     task_config.project_config, task_config, org_config=org_config
                 )

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/cli/tests/test_task.py

@@ -1,6 +1,8 @@
 import contextlib
 import io
 import json
+import tempfile
+from pathlib import Path
 from unittest.mock import Mock, patch
 
 import click
@@ -126,10 +128,10 @@ def test_format_help(runtime):
 
 def test_get_default_command_options():
     opts = task.RunTaskCommand()._get_default_command_options(is_salesforce_task=False)
-    assert len(opts) == 4
+    assert len(opts) == 5
 
     opts = task.RunTaskCommand()._get_default_command_options(is_salesforce_task=True)
-    assert len(opts) == 5
+    assert len(opts) == 6
     assert any([o.name == "org" for o in opts])
 
 
@@ -264,3 +266,87 @@ class SetTrace(Exception):
 class DummyDerivedTask(DummyTask):
     def _run_task(self):
         click.echo(f"<{self.__class__}>\n\tcolor: {self.options['color']}")
+
+
+@patch("cumulusci.cli.task.load_dotenv")
+def test_task_run__loadenv_with_project_root(load_dotenv, runtime):
+    """Test that loadenv loads .env file from project root when project exists."""
+    DummyTask._run_task = Mock()
+
+    # Create a temporary directory for the test
+    with tempfile.TemporaryDirectory() as temp_dir:
+        runtime.project_config._repo_info = {"root": temp_dir}
+
+        multi_cmd = task.RunTaskCommand()
+        with click.Context(multi_cmd, obj=runtime) as ctx:
+            cmd = multi_cmd.get_command(ctx, "dummy-task")
+            cmd.callback(runtime, "dummy-task", color="blue", loadenv=True)
+
+        # Verify load_dotenv was called with the correct path
+        expected_path = Path(temp_dir) / ".env"
+        load_dotenv.assert_called_once_with(expected_path)
+        DummyTask._run_task.assert_called_once()
+
+
+@patch("cumulusci.cli.task.load_dotenv")
+def test_task_run__loadenv_false(load_dotenv, runtime):
+    """Test that loadenv does not call load_dotenv when loadenv=False."""
+    DummyTask._run_task = Mock()
+
+    multi_cmd = task.RunTaskCommand()
+    with click.Context(multi_cmd, obj=runtime) as ctx:
+        cmd = multi_cmd.get_command(ctx, "dummy-task")
+        cmd.callback(runtime, "dummy-task", color="blue", loadenv=False)
+
+    # Verify load_dotenv was not called
+    load_dotenv.assert_not_called()
+    DummyTask._run_task.assert_called_once()
+
+
+@patch("cumulusci.cli.task.load_dotenv")
+def test_task_run__loadenv_not_provided(load_dotenv, runtime):
+    """Test that loadenv does not call load_dotenv when loadenv is not provided."""
+    DummyTask._run_task = Mock()
+
+    multi_cmd = task.RunTaskCommand()
+    with click.Context(multi_cmd, obj=runtime) as ctx:
+        cmd = multi_cmd.get_command(ctx, "dummy-task")
+        cmd.callback(runtime, "dummy-task", color="blue")
+
+    # Verify load_dotenv was not called
+    load_dotenv.assert_not_called()
+    DummyTask._run_task.assert_called_once()
+
+
+@patch("cumulusci.cli.task.load_dotenv")
+def test_task_run__loadenv_none_value(load_dotenv, runtime):
+    """Test that loadenv does not call load_dotenv when loadenv=None."""
+    DummyTask._run_task = Mock()
+
+    multi_cmd = task.RunTaskCommand()
+    with click.Context(multi_cmd, obj=runtime) as ctx:
+        cmd = multi_cmd.get_command(ctx, "dummy-task")
+        cmd.callback(runtime, "dummy-task", color="blue", loadenv=None)
+
+    # Verify load_dotenv was not called
+    load_dotenv.assert_not_called()
+    DummyTask._run_task.assert_called_once()
+
+
+def test_get_default_command_options_includes_loadenv():
+    """Test that the loadenv option is included in default command options."""
+    opts = task.RunTaskCommand()._get_default_command_options(is_salesforce_task=False)
+
+    # Should have 5 global options including loadenv
+    assert len(opts) == 5
+
+    # Find the loadenv option
+    loadenv_opt = None
+    for opt in opts:
+        if hasattr(opt, "name") and opt.name == "loadenv":
+            loadenv_opt = opt
+            break
+
+    assert loadenv_opt is not None
+    assert loadenv_opt.is_flag is True
+    assert "Loads environment variables from the .env file" in loadenv_opt.help

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})"
@@ -685,6 +751,20 @@ class FlowCoordinator:
             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

@@ -795,6 +795,10 @@ tasks:
         description: Load Custom Settings specified in a YAML file to the target org
         class_path: cumulusci.tasks.salesforce.LoadCustomSettings
         group: "Data Operations"
+    sfdmu:
+        description: Execute SFDmu data migration with namespace injection support
+        class_path: cumulusci.tasks.sfdmu.sfdmu.SfdmuTask
+        group: "Data Operations"
     remove_metadata_xml_elements:
         description: Remove specified XML elements from one or more metadata files
         class_path: cumulusci.tasks.metadata.modify.RemoveElementsXPath
@@ -831,6 +835,26 @@ 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
+    update_named_credential:
+        class_path: cumulusci.tasks.salesforce.update_named_credential.UpdateNamedCredential
+        description: Update named credential parameters
+        group: Metadata Transformations
+    update_external_credential:
+        class_path: cumulusci.tasks.salesforce.update_external_credential.UpdateExternalCredential
+        description: Update external credential parameters
+        group: Metadata Transformations
+
 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,
@@ -163,10 +163,9 @@ class CreatePackageVersion(BaseSalesforceApiTask):
             "Defaults to False."
         },
         "dependencies": {
-            "description": "The dependencies to use when creating the package version. Defaults to None."
-            "Ensure that the dependencies are in the correct format for Package2VersionCreateRequest."
+            "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 list of dictionaries with the key: 'subscriberPackageVersionId' and the value: '04t...'"
+            "The format should be a pcakge version Ids i.e '04t...,04t...'"
         },
     }
 
@@ -219,6 +218,14 @@ class CreatePackageVersion(BaseSalesforceApiTask):
             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(
@@ -465,8 +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")
+                dependencies = (
+                    self.options.get("dependencies") or self._get_dependencies()
+                )
             if dependencies:
                 package_descriptor["dependencies"] = dependencies