cumulusci-plus 5.0.19__py3-none-any.whl → 5.0.35__py3-none-any.whl

cumulusci/__about__.py

@@ -1 +1 @@
-__version__ = "5.0.19"
+__version__ = "5.0.35"

cumulusci/cli/logger.py

@@ -32,14 +32,14 @@ def init_logger(debug=False):
             tracebacks_show_locals=debug,
         )
     )
-    logger.setLevel(logging.DEBUG)
+    logger.setLevel(logging.DEBUG if debug else logging.INFO)
     logger.propagate = False
 
     if debug:  # pragma: no cover
         # Referenced from:
         # https://github.com/urllib3/urllib3/blob/cd55f2fe98df4d499ab5c826433ee4995d3f6a60/src/urllib3/__init__.py#L48
         def add_rich_logger(
-            module: str, level: int = logging.DEBUG
+            module: str, level: int = logging.DEBUG if debug else logging.INFO
         ) -> logging.StreamHandler:
             """Retrieve the logger for the given module.
             Remove all handlers from it, and add a single RichHandler."""

cumulusci/cli/service.py

@@ -83,6 +83,25 @@ class ConnectServiceCommand(click.MultiCommand):
         services = self._get_services_config(runtime)
         return sorted(services.keys())
 
+    def invoke(self, ctx):
+        """Override to show available services instead of 'Missing command' error"""
+        try:
+            return super().invoke(ctx)
+        except click.UsageError as e:
+            if "Missing command" in str(e):
+                # No subcommand provided - list available services
+                services = self.list_commands(ctx)
+                if services:
+                    click.echo("Available services:")
+                    for service in services:
+                        click.echo(f"  {service}")
+                else:
+                    click.echo("No services available to configure.")
+                return
+            else:
+                # Re-raise other usage errors
+                raise
+
     def _build_param(self, attribute: str, details: dict) -> click.Option:
         required = details.get("required", False)
         default_factory: Optional[Callable] = self._get_callable_default(
@@ -288,6 +307,7 @@ class ConnectServiceCommand(click.MultiCommand):
     cls=ConnectServiceCommand,
     name="connect",
     help="Connect an external service to CumulusCI",
+    no_args_is_help=False,
 )
 def service_connect():
     pass

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_error.py

@@ -98,7 +98,9 @@ Environment Info: Rossian / x68_46
         )
         webbrowser_open.assert_called_once_with(expected_gist_url)
 
-    @pytest.mark.skipif(sys.version_info > (3, 11), reason="requires python3.10 or higher")
+    @pytest.mark.skipif(
+        sys.version_info > (3, 11), reason="requires python3.10 or higher"
+    )
     @mock.patch("cumulusci.cli.error.platform")
     @mock.patch("cumulusci.cli.error.sys")
     @mock.patch("cumulusci.cli.error.datetime")

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_service.py

@@ -106,9 +106,10 @@ def test_service_connect__attr_with_default_value():
     # but input of an empty line accepts the default.
     assert "attr (example) [PRESET]: " in result.output
     service_config = runtime.keychain.get_service("test", "test-alias")
-    with mock.patch(
-        "cumulusci.core.config.base_config.STRICT_GETATTR", False
-    ), pytest.warns(DeprecationWarning, match="attr"):
+    with (
+        mock.patch("cumulusci.core.config.base_config.STRICT_GETATTR", False),
+        pytest.warns(DeprecationWarning, match="attr"),
+    ):
         assert service_config.lookup("attr") == "PRESET"
         assert service_config.attr == "PRESET"
 
@@ -132,9 +133,10 @@ def test_service_connect__attr_with_default_factory():
 
     # The service should have the attribute value returned by the default factory.
     service_config = runtime.keychain.get_service("test", "test-alias")
-    with mock.patch(
-        "cumulusci.core.config.base_config.STRICT_GETATTR", False
-    ), pytest.warns(DeprecationWarning, match="attr"):
+    with (
+        mock.patch("cumulusci.core.config.base_config.STRICT_GETATTR", False),
+        pytest.warns(DeprecationWarning, match="attr"),
+    ):
         assert service_config.lookup("attr") == "CALCULATED"
         assert service_config.attr == "CALCULATED"
 
@@ -155,13 +157,14 @@ def test_service_connect__alias_already_exists():
         "test-type",
         "already-exists",
         runtime=runtime,
-        input="new\ny\n",
+        input="new\ny\nn\n",
     )
 
     service_config = runtime.keychain.get_service("test-type", "already-exists")
-    with mock.patch(
-        "cumulusci.core.config.base_config.STRICT_GETATTR", False
-    ), pytest.warns(DeprecationWarning, match="attr"):
+    with (
+        mock.patch("cumulusci.core.config.base_config.STRICT_GETATTR", False),
+        pytest.warns(DeprecationWarning, match="attr"),
+    ):
         assert service_config.lookup("attr") == "new"
         assert service_config.attr == "new"
 
@@ -536,7 +539,7 @@ def test_service_connect__connected_app():
         "connect",
         "connected_app",
         "new",
-        input="\n\nID\nSECRET\n",
+        input="\n\nID\nSECRET\nn\n",
         runtime=runtime,
     )
 
@@ -559,7 +562,7 @@ def test_service_connect__connected_app__with_cli_options():
         "new",
         "--login_url",
         "https://custom",
-        input="\nID\nSECRET\n",  # not prompted for login_url
+        input="\nID\nSECRET\nn\n",  # not prompted for login_url
         runtime=runtime,
     )
 

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

@@ -17,10 +17,7 @@ def run_click_command(cmd, *args, **kw):
 
 def run_cli_command(*args, runtime=None, input=None, **kw):
     """Run a click command with arg parsing and injected CCI runtime object."""
-    if tuple(map(int, click.__version__.split("."))) >= (8, 1, 0):
-        runner = CliRunner()
-    else:
-        runner = CliRunner(mix_stderr=False)
+    runner = CliRunner()
     result = runner.invoke(
         cli,
         args,

cumulusci/core/config/base_task_flow_config.py

@@ -1,5 +1,5 @@
 from difflib import get_close_matches
-from typing import Any, Dict, List
+from typing import Any, Dict, List, cast
 
 from cumulusci.core.config import BaseConfig, FlowConfig, TaskConfig
 from cumulusci.core.exceptions import (
@@ -7,6 +7,8 @@ from cumulusci.core.exceptions import (
     FlowNotFoundError,
     TaskNotFoundError,
 )
+from cumulusci.core.utils import merge_config
+from cumulusci.plugins.plugin_loader import load_plugins
 
 
 def list_infos(infos: dict) -> List[Dict[str, str]]:
@@ -30,6 +32,7 @@ class BaseTaskFlowConfig(BaseConfig):
 
     tasks: dict
     flows: dict
+    config_plugins: dict = {}
 
     def list_tasks(self) -> List[Dict[str, str]]:
         """Returns a list of task info dictionaries with keys 'name' and 'description'"""
@@ -80,3 +83,25 @@ class BaseTaskFlowConfig(BaseConfig):
             return f'. Did you mean "{match_list[0]}"?'
         else:
             return ""
+
+    def _load_plugins_config(self):
+        """Loads the plugin configurations"""
+        plugins = load_plugins()
+        self.config_plugins = {}
+        for plugin in plugins:
+            if plugin.plugin_project_config:
+                self.config_plugins.update(plugin.plugin_project_config)
+            plugin.teardown()  # clean up the plugin
+
+    def merge_base_config(self, base_config: dict) -> dict:
+        """Merges the base config with the plugin configurations"""
+        self._load_plugins_config()
+        return cast(
+            dict,
+            merge_config(
+                {
+                    **base_config,
+                    "plugins_config": self.config_plugins,
+                }
+            ),
+        )