cumulusci-plus 5.0.6__py3-none-any.whl → 5.0.8.dev0__py3-none-any.whl

cumulusci/__about__.py

@@ -1 +1 @@
-__version__ = "5.0.6"
+__version__ = "5.0.8.dev0"

cumulusci/cli/cci.py

@@ -1,7 +1,9 @@
 import code
 import contextlib
+import os
 import pdb
 import runpy
+import signal
 import sys
 import traceback
 
@@ -43,6 +45,78 @@ SUGGEST_ERROR_COMMAND = (
 
 USAGE_ERRORS = (CumulusCIUsageError, click.UsageError)
 
+# Global variable to track the context stack for cleanup on signal
+_exit_stack = None
+_signal_handler_active = False  # Flag to prevent recursive signal handler calls
+
+
+def _signal_handler(signum, frame):
+    """Handle termination signals.
+
+    This handler ensures the CLI exits gracefully with a failure code when
+    receiving SIGTERM or SIGINT signals, such as when an Azure DevOps pipeline
+    is cancelled. It also terminates all child processes in the process group.
+    """
+    global _signal_handler_active
+
+    # Prevent recursive signal handler calls
+    if _signal_handler_active:
+        return
+
+    _signal_handler_active = True
+
+    console = Console()
+
+    signal_names = {signal.SIGTERM: "SIGTERM", signal.SIGINT: "SIGINT"}
+
+    signal_name = signal_names.get(signum, f"signal {signum}")
+
+    console.print(
+        f"\n[yellow]Received {signal_name} - CumulusCI is being terminated[/yellow]"
+    )
+    console.print(
+        "[yellow]Exiting with failure code due to external cancellation.[/yellow]"
+    )
+
+    # Clean up managed resources
+    if _exit_stack:
+        try:
+            _exit_stack.close()
+        except Exception as e:
+            console.print(f"[red]Error during cleanup: {e}[/red]")
+
+    # Terminate child processes in the process group
+    try:
+        console.print("[yellow]Terminating child processes...[/yellow]")
+
+        # Temporarily ignore the signal to prevent recursion
+        old_handler = signal.signal(signum, signal.SIG_IGN)
+
+        try:
+            # Only use process group termination on Unix systems
+            if hasattr(os, "getpgrp") and hasattr(os, "killpg"):
+                pgrp = os.getpgrp()
+                # Send signal to all processes in the group except ourselves
+                os.killpg(pgrp, signum)
+            else:
+                # On Windows, we can't use process groups, so just log the attempt
+                console.print(
+                    "[yellow]Process group termination not supported on this platform[/yellow]"
+                )
+        finally:
+            # Restore the original signal handler
+            signal.signal(signum, old_handler)
+
+    except ProcessLookupError:
+        # Process group may not exist or may already be terminated
+        pass
+    except Exception as e:
+        console.print(f"[red]Warning: Error terminating child processes: {e}[/red]")
+
+    # Exit with appropriate failure code
+    exit_code = 143 if signum == signal.SIGTERM else 130  # Standard exit codes
+    sys.exit(exit_code)
+
 
 #
 # Root command
@@ -54,7 +128,25 @@ def main(args=None):
 
     This wraps the `click` library in order to do some initialization and centralized error handling.
     """
+    global _exit_stack
+
+    # Create a new process group so we can terminate all child processes
+    # when we receive a termination signal
+    try:
+        if hasattr(os, "setpgrp"):
+            # On Unix systems, create a new process group
+            os.setpgrp()
+    except Exception:
+        # On Windows or if setpgrp fails, continue without process group
+        pass
+
+    # Set up signal handlers for graceful termination
+    signal.signal(signal.SIGTERM, _signal_handler)
+    signal.signal(signal.SIGINT, _signal_handler)
+
     with contextlib.ExitStack() as stack:
+        _exit_stack = stack  # Store reference for signal handler cleanup
+
         args = args or sys.argv
 
         # (If enabled) set up requests to validate certs using system CA certs instead of certifi
@@ -98,15 +190,20 @@ def main(args=None):
                 sys.exit(1)
             except Exception as e:
                 if debug:
+                    console = Console()
                     show_debug_info()
+                    console.print(
+                        f"\n[red bold]Debug info for bug reports:\n{traceback.format_exc()}"
+                    )
+                    sys.exit(1)
                 else:
                     handle_exception(
-                        e,
-                        is_error_command,
-                        tempfile_path,
-                        should_show_stacktraces,
+                        e, is_error_command, tempfile_path, should_show_stacktraces
                     )
-                sys.exit(1)
+                    sys.exit(1)
+
+        # Clear the global reference when exiting normally
+        _exit_stack = None
 
 
 def handle_exception(

cumulusci/cli/tests/test_cci.py

@@ -1,9 +1,8 @@
 import contextlib
 import io
 import os
-import shutil
+import signal
 import sys
-import tempfile
 from pathlib import Path
 from unittest import mock
 
@@ -26,22 +25,11 @@ CONSOLE = mock.Mock()
 
 
 @pytest.fixture(autouse=True)
-def env_config():
-    config = {
-        "global_tempdir": tempfile.gettempdir(),
-        "tempdir": tempfile.mkdtemp(),
-        "environ_mock": mock.patch.dict(
-            os.environ, {"HOME": tempfile.mkdtemp(), "CUMULUSCI_KEY": ""}
-        ),
-    }
-    # setup
-    config["environ_mock"].start()
-    assert config["global_tempdir"] in os.environ["HOME"]
-    yield config
-    # tear down
-    assert config["global_tempdir"] in os.environ["HOME"]
-    config["environ_mock"].stop()
-    shutil.rmtree(config["tempdir"])
+def reset_signal_handler_flag():
+    """Reset signal handler flag to ensure clean state for tests"""
+    cci._signal_handler_active = False
+    yield
+    cci._signal_handler_active = False
 
 
 @mock.patch("cumulusci.cli.cci.tee_stdout_stderr")
@@ -266,7 +254,9 @@ def test_cci_org_default__no_orgname(
 DEPLOY_CLASS_PATH = f"cumulusci.tasks.salesforce.Deploy{'.Deploy' if sys.version_info >= (3, 11) else ''}"
 
 
-@mock.patch("cumulusci.cli.cci.init_logger", mock.Mock())
+@mock.patch(
+    "cumulusci.cli.cci.init_logger", mock.Mock()
+)  # side effects break other tests
 @mock.patch("cumulusci.cli.cci.tee_stdout_stderr", mock.MagicMock())
 @mock.patch(f"{DEPLOY_CLASS_PATH}.__call__", mock.Mock())
 @mock.patch("sys.exit", mock.Mock())
@@ -543,3 +533,264 @@ def test_dash_dash_version(
 
     cci.main(["cci", "--version"])
     assert len(show_version_info.mock_calls) == 2
+
+
+@mock.patch("sys.exit")
+@mock.patch("cumulusci.cli.cci.Console")
+@mock.patch("os.killpg", create=True)
+@mock.patch("os.getpgrp", create=True)
+@mock.patch("signal.signal")
+def test_signal_handler_terminates_process_group(
+    mock_signal, mock_getpgrp, mock_killpg, mock_console, mock_exit
+):
+    """Test that the signal handler terminates the process group"""
+    console_instance = mock_console.return_value
+    mock_getpgrp.return_value = 1234  # Mock process group ID
+
+    # Mock the global exit stack
+    mock_exit_stack = mock.Mock()
+    with mock.patch.object(cci, "_exit_stack", mock_exit_stack):
+        # Mock hasattr to return True for Unix functions
+        with mock.patch("builtins.hasattr", return_value=True):
+            # Call the signal handler with SIGTERM
+            cci._signal_handler(signal.SIGTERM, None)
+
+            # Verify console output
+            console_instance.print.assert_any_call(
+                "\n[yellow]Received SIGTERM - CumulusCI is being terminated[/yellow]"
+            )
+            console_instance.print.assert_any_call(
+                "[yellow]Exiting with failure code due to external cancellation.[/yellow]"
+            )
+            console_instance.print.assert_any_call(
+                "[yellow]Terminating child processes...[/yellow]"
+            )
+
+            # Verify cleanup was called
+            mock_exit_stack.close.assert_called_once()
+
+            # Verify signal was temporarily ignored and then restored
+            mock_signal.assert_called()
+
+            # Verify process group was terminated
+            mock_getpgrp.assert_called_once()
+            mock_killpg.assert_called_once_with(1234, signal.SIGTERM)
+
+            # Verify exit with correct code
+            mock_exit.assert_called_once_with(143)
+
+
+@mock.patch("sys.exit")
+@mock.patch("cumulusci.cli.cci.Console")
+@mock.patch("os.killpg", create=True)
+@mock.patch("os.getpgrp", create=True)
+@mock.patch("signal.signal")
+def test_signal_handler_sigint(
+    mock_signal, mock_getpgrp, mock_killpg, mock_console, mock_exit
+):
+    """Test that the signal handler properly handles SIGINT"""
+    console_instance = mock_console.return_value
+    mock_getpgrp.return_value = 1234
+
+    # Mock the global exit stack
+    mock_exit_stack = mock.Mock()
+    with mock.patch.object(cci, "_exit_stack", mock_exit_stack):
+        # Mock hasattr to return True for Unix functions
+        with mock.patch("builtins.hasattr", return_value=True):
+            # Call the signal handler with SIGINT
+            cci._signal_handler(signal.SIGINT, None)
+
+            # Verify console output
+            console_instance.print.assert_any_call(
+                "\n[yellow]Received SIGINT - CumulusCI is being terminated[/yellow]"
+            )
+
+            # Verify process group was terminated with SIGINT
+            mock_killpg.assert_called_once_with(1234, signal.SIGINT)
+
+            # Verify exit with correct code for SIGINT
+            mock_exit.assert_called_once_with(130)
+
+
+@mock.patch("sys.exit")
+@mock.patch("cumulusci.cli.cci.Console")
+def test_signal_handler_prevents_recursion(mock_console, mock_exit):
+    """Test that the signal handler prevents recursive calls"""
+    console_instance = mock_console.return_value
+
+    # Set the flag to simulate handler already active
+    with mock.patch.object(cci, "_signal_handler_active", True):
+        # Call the signal handler
+        cci._signal_handler(signal.SIGTERM, None)
+
+        # Verify no console output (handler should return immediately)
+        console_instance.print.assert_not_called()
+
+        # Verify no exit call
+        mock_exit.assert_not_called()
+
+
+@mock.patch("sys.exit")
+@mock.patch("cumulusci.cli.cci.Console")
+@mock.patch("os.killpg", create=True)
+@mock.patch("os.getpgrp", create=True)
+@mock.patch("signal.signal")
+def test_signal_handler_handles_killpg_error(
+    mock_signal, mock_getpgrp, mock_killpg, mock_console, mock_exit
+):
+    """Test that the signal handler handles errors from killpg gracefully"""
+    console_instance = mock_console.return_value
+    mock_getpgrp.return_value = 1234
+    mock_killpg.side_effect = OSError("Process group not found")
+
+    # Mock hasattr to return True for Unix functions
+    with mock.patch("builtins.hasattr", return_value=True):
+        # Call the signal handler with SIGTERM
+        cci._signal_handler(signal.SIGTERM, None)
+
+    # Verify error message was printed
+    console_instance.print.assert_any_call(
+        "[red]Warning: Error terminating child processes: Process group not found[/red]"
+    )
+
+    # Verify it still exits with correct code
+    mock_exit.assert_called_once_with(143)
+
+
+@mock.patch("sys.exit")
+@mock.patch("cumulusci.cli.cci.Console")
+def test_signal_handler_without_process_group_support(mock_console, mock_exit):
+    """Test that the signal handler works on Windows where process groups aren't supported"""
+    console_instance = mock_console.return_value
+
+    # Mock the global exit stack
+    mock_exit_stack = mock.Mock()
+    with mock.patch.object(cci, "_exit_stack", mock_exit_stack):
+        # Mock hasattr to return False for Unix functions (like on Windows)
+        with mock.patch("builtins.hasattr", return_value=False):
+            # Call the signal handler with SIGTERM
+            cci._signal_handler(signal.SIGTERM, None)
+
+            # Verify console output
+            console_instance.print.assert_any_call(
+                "\n[yellow]Received SIGTERM - CumulusCI is being terminated[/yellow]"
+            )
+            console_instance.print.assert_any_call(
+                "[yellow]Exiting with failure code due to external cancellation.[/yellow]"
+            )
+            console_instance.print.assert_any_call(
+                "[yellow]Terminating child processes...[/yellow]"
+            )
+            console_instance.print.assert_any_call(
+                "[yellow]Process group termination not supported on this platform[/yellow]"
+            )
+
+            # Verify cleanup was called
+            mock_exit_stack.close.assert_called_once()
+
+            # Verify exit with correct code
+            mock_exit.assert_called_once_with(143)
+
+
+@mock.patch("os.setpgrp", create=True)
+def test_main_creates_process_group(mock_setpgrp):
+    """Test that main() creates a new process group"""
+    # Mock dependencies to avoid actual CLI execution
+    with mock.patch.multiple(
+        "cumulusci.cli.cci",
+        signal=mock.Mock(),
+        init_requests_trust=mock.Mock(),
+        check_latest_version=mock.Mock(),
+        check_latest_plugins=mock.Mock(),
+        get_tempfile_logger=mock.Mock(return_value=(mock.Mock(), "tempfile.log")),
+        tee_stdout_stderr=mock.Mock(
+            return_value=mock.Mock(__enter__=mock.Mock(), __exit__=mock.Mock())
+        ),
+        set_debug_mode=mock.Mock(
+            return_value=mock.Mock(__enter__=mock.Mock(), __exit__=mock.Mock())
+        ),
+        CliRuntime=mock.Mock(),
+        init_logger=mock.Mock(),
+        cli=mock.Mock(),
+    ):
+        try:
+            cci.main(["cci", "version"])
+        except SystemExit:
+            pass  # Expected for version command
+
+        # Verify process group was created
+        mock_setpgrp.assert_called_once()
+
+
+@mock.patch("os.setpgrp", create=True)
+def test_main_handles_setpgrp_error(mock_setpgrp):
+    """Test that main() handles setpgrp errors gracefully"""
+    mock_setpgrp.side_effect = OSError("Operation not permitted")
+
+    # Mock dependencies to avoid actual CLI execution
+    with mock.patch.multiple(
+        "cumulusci.cli.cci",
+        signal=mock.Mock(),
+        init_requests_trust=mock.Mock(),
+        check_latest_version=mock.Mock(),
+        check_latest_plugins=mock.Mock(),
+        get_tempfile_logger=mock.Mock(return_value=(mock.Mock(), "tempfile.log")),
+        tee_stdout_stderr=mock.Mock(
+            return_value=mock.Mock(__enter__=mock.Mock(), __exit__=mock.Mock())
+        ),
+        set_debug_mode=mock.Mock(
+            return_value=mock.Mock(__enter__=mock.Mock(), __exit__=mock.Mock())
+        ),
+        CliRuntime=mock.Mock(),
+        init_logger=mock.Mock(),
+        cli=mock.Mock(),
+    ):
+        try:
+            # Should not raise an exception even if setpgrp fails
+            cci.main(["cci", "version"])
+        except SystemExit:
+            pass  # Expected for version command
+        except OSError:
+            pytest.fail("main() should handle setpgrp errors gracefully")
+
+        # Verify setpgrp was attempted
+        mock_setpgrp.assert_called_once()
+
+
+@mock.patch("signal.signal")
+def test_main_registers_signal_handlers(mock_signal):
+    """Test that main() registers signal handlers"""
+    # Create a proper context manager mock
+    context_manager_mock = mock.Mock()
+    context_manager_mock.__enter__ = mock.Mock(return_value=context_manager_mock)
+    context_manager_mock.__exit__ = mock.Mock(return_value=None)
+
+    # Create another context manager mock for set_debug_mode
+    debug_context_mock = mock.Mock()
+    debug_context_mock.__enter__ = mock.Mock(return_value=debug_context_mock)
+    debug_context_mock.__exit__ = mock.Mock(return_value=None)
+
+    # Mock dependencies to avoid actual CLI execution
+    with mock.patch.multiple(
+        "cumulusci.cli.cci",
+        init_requests_trust=mock.Mock(),
+        check_latest_version=mock.Mock(),
+        check_latest_plugins=mock.Mock(),
+        get_tempfile_logger=mock.Mock(return_value=(mock.Mock(), "tempfile.log")),
+        tee_stdout_stderr=mock.Mock(return_value=context_manager_mock),
+        set_debug_mode=mock.Mock(return_value=debug_context_mock),
+        CliRuntime=mock.Mock(),
+        init_logger=mock.Mock(),
+        cli=mock.Mock(),
+    ):
+        try:
+            cci.main(["cci", "version"])
+        except SystemExit:
+            pass  # Expected for version command
+
+        # Verify signal handlers were registered
+        expected_calls = [
+            mock.call(signal.SIGTERM, cci._signal_handler),
+            mock.call(signal.SIGINT, cci._signal_handler),
+        ]
+        mock_signal.assert_has_calls(expected_calls, any_order=True)

cumulusci/core/dependencies/base.py

@@ -1,5 +1,6 @@
 import contextlib
 from abc import ABC, abstractmethod
+from datetime import datetime
 from typing import List, Optional, Type
 from zipfile import ZipFile
 
@@ -9,11 +10,13 @@ from cumulusci.core.config import OrgConfig
 from cumulusci.core.config.project_config import BaseProjectConfig
 from cumulusci.core.dependencies.utils import TaskContext
 from cumulusci.core.exceptions import DependencyResolutionError, VcsNotFoundError
+from cumulusci.core.flowrunner import FlowCallback, FlowCoordinator
 from cumulusci.core.sfdx import (
     SourceFormat,
     convert_sfdx_source,
     get_source_format_for_zipfile,
 )
+from cumulusci.core.utils import format_duration
 from cumulusci.salesforce_api.metadata import ApiDeploy
 from cumulusci.salesforce_api.package_zip import MetadataPackageZipBuilder
 from cumulusci.utils import download_extract_vcs_from_repo, temporary_dir
@@ -153,11 +156,8 @@ class DynamicDependency(Dependency, ABC):
         resolve_dependency(self, context, strategies)
 
 
-class UnmanagedDependency(StaticDependency, ABC):
-    """Abstract base class for static, unmanaged dependencies."""
-
+class UnmanagedStaticDependency(StaticDependency, ABC):
     unmanaged: Optional[bool] = None
-    subfolder: Optional[str] = None
     namespace_inject: Optional[str] = None
     namespace_strip: Optional[str] = None
     collision_check: Optional[bool] = None
@@ -171,6 +171,12 @@ class UnmanagedDependency(StaticDependency, ABC):
 
         return self.unmanaged
 
+
+class UnmanagedDependency(UnmanagedStaticDependency, ABC):
+    """Abstract base class for static, unmanaged dependencies."""
+
+    subfolder: Optional[str] = None
+
     @abstractmethod
     def _get_zip_src(self, context: BaseProjectConfig) -> ZipFile:
         pass
@@ -378,6 +384,28 @@ class VcsDynamicDependency(BaseVcsDynamicDependency, ABC):
 
         return values
 
+    def _flatten_dependency_flow(
+        self,
+        remote_config: BaseProjectConfig,
+        flow_type: str,
+        managed: bool,
+        namespace: Optional[str],
+    ) -> List[StaticDependency]:
+
+        if remote_config.project.get(flow_type):
+            return [
+                UnmanagedVcsDependencyFlow(
+                    url=self.url,
+                    vcs=self.vcs,
+                    commit=self.ref,
+                    flow_name=remote_config.project.get(flow_type),
+                    unmanaged=not managed,
+                    namespace_inject=namespace if namespace and managed else None,
+                    namespace_strip=namespace if namespace and not managed else None,
+                )
+            ]
+        return []
+
     def _flatten_unpackaged(
         self,
         repo: AbstractRepo,
@@ -454,6 +482,17 @@ class VcsDynamicDependency(BaseVcsDynamicDependency, ABC):
         # Check for unmanaged flag on a namespaced package
         managed = bool(namespace and not self.unmanaged)
 
+        # Look for any flow to executed in project config
+        # Pre flows will run to dynamically generate metadata and deploy.
+        deps.extend(
+            self._flatten_dependency_flow(
+                package_config,
+                "dependency_flow_pre",
+                managed=managed,
+                namespace=namespace,
+            )
+        )
+
         # Look for subfolders under unpackaged/pre
         # unpackaged/pre is always deployed unmanaged, no namespace manipulation.
         deps.extend(
@@ -482,6 +521,17 @@ class VcsDynamicDependency(BaseVcsDynamicDependency, ABC):
         else:
             deps.append(self.package_dependency)
 
+        # Look for any flow to executed in project config
+        # Pre flows will run to dynamically generate metadata and deploy.
+        deps.extend(
+            self._flatten_dependency_flow(
+                package_config,
+                "dependency_flow_post",
+                managed=managed,
+                namespace=namespace,
+            )
+        )
+
         # We always inject the project's namespace into unpackaged/post metadata if managed
         deps.extend(
             self._flatten_unpackaged(
@@ -559,3 +609,73 @@ class UnmanagedVcsDependency(UnmanagedDependency, ABC):
         )
 
         return f"{self.url}{subfolder} @{self.ref}"
+
+
+class UnmanagedVcsDependencyFlow(UnmanagedStaticDependency, ABC):
+    vcs: str
+    url: AnyUrl
+    commit: str
+    flow_name: str
+    callback_class = FlowCallback
+
+    # Add these fields to support namespace manipulation
+    namespace_inject: Optional[str] = None
+    namespace_strip: Optional[str] = None
+    password_env_name: Optional[str] = None
+
+    @property
+    def name(self):
+        return f"Deploy {self.url} Flow: {self.flow_name}"
+
+    @property
+    def description(self):
+        return f"{self.url} Flow: {self.flow_name} @{self.commit}"
+
+    def install(self, context: BaseProjectConfig, org: OrgConfig):
+        context.logger.info(f"Deploying dependency Flow from {self.description}")
+
+        from cumulusci.utils.yaml.cumulusci_yml import VCSSourceModel
+        from cumulusci.vcs.vcs_source import VCSSource
+
+        # Get the VCS Source class from the vcs field.
+        source_model = VCSSourceModel(
+            vcs=self.vcs,
+            url=self.url,
+            commit=self.commit,
+            allow_remote_code=context.allow_remote_code,
+        )
+        vcs_source = VCSSource.create(context, source_model)
+
+        # Fetch the data and get remote project config.
+        context.logger.info(f"Fetching from {vcs_source}")
+        project_config = vcs_source.fetch()
+
+        project_config.set_keychain(context.keychain)
+        project_config.source = vcs_source
+
+        # If I can't load remote code, make sure that my
+        # included repos can't either.
+        if vcs_source.allow_remote_code:
+            project_config._add_tasks_directory_to_python_path()
+
+        # Run the flow.
+        flow_config = project_config.get_flow(self.flow_name)
+        flow_config.name = self.flow_name
+
+        coordinator = FlowCoordinator(
+            project_config,
+            flow_config,
+            name=flow_config.name,
+            options={
+                "unmanaged": self._get_unmanaged(org),
+                "namespace_inject": self.namespace_inject,
+                "namespace_strip": self.namespace_strip,
+            },
+            skip=None,
+            callbacks=self.callback_class(),
+        )
+
+        start_time = datetime.now()
+        coordinator.run(org)
+        duration = datetime.now() - start_time
+        context.logger.info(f"Ran {self.flow_name} in {format_duration(duration)}")

cumulusci/core/dependencies/tests/test_dependencies.py

@@ -9,7 +9,11 @@ from pydantic import ValidationError, root_validator
 
 from cumulusci.core.config.org_config import OrgConfig, VersionInfo
 from cumulusci.core.config.project_config import BaseProjectConfig
-from cumulusci.core.dependencies.base import DynamicDependency, StaticDependency
+from cumulusci.core.dependencies.base import (
+    DynamicDependency,
+    StaticDependency,
+    UnmanagedVcsDependencyFlow,
+)
 from cumulusci.core.dependencies.dependencies import (
     PackageNamespaceVersionDependency,
     PackageVersionIdDependency,
@@ -903,6 +907,203 @@ class TestUnmanagedZipURLDependency:
         zf.close()
 
 
+# Concrete implementation of UnmanagedVcsDependencyFlow for testing
+class ConcreteUnmanagedVcsDependencyFlow(UnmanagedVcsDependencyFlow):
+    """Concrete implementation of UnmanagedVcsDependencyFlow for testing"""
+
+    def __init__(self, **kwargs):
+        # Set default values for testing
+        defaults = {
+            "vcs": "github",
+            "url": "https://github.com/test/repo",
+            "commit": "abc123",
+            "flow_name": "test_flow",
+        }
+        defaults.update(kwargs)
+        super().__init__(**defaults)
+
+    @root_validator(pre=True)
+    def sync_vcs_and_url(cls, values):
+        """Implement required abstract method from base class"""
+        return _sync_vcs_and_url(values)
+
+
+class TestUnmanagedVcsDependencyFlow:
+    def test_name(self):
+        """Test the name property"""
+        flow_dep = ConcreteUnmanagedVcsDependencyFlow(
+            url="https://github.com/test/repo", flow_name="install_deps"
+        )
+        expected_name = "Deploy https://github.com/test/repo Flow: install_deps"
+        assert flow_dep.name == expected_name
+
+    def test_description(self):
+        """Test the description property"""
+        flow_dep = ConcreteUnmanagedVcsDependencyFlow(
+            url="https://github.com/test/repo",
+            flow_name="install_deps",
+            commit="abc123",
+        )
+        expected_description = "https://github.com/test/repo Flow: install_deps @abc123"
+        assert flow_dep.description == expected_description
+
+    def test_get_unmanaged(self):
+        """Test the _get_unmanaged method inherited from UnmanagedStaticDependency"""
+        # Test with unmanaged = None and no namespace_inject
+        flow_dep = ConcreteUnmanagedVcsDependencyFlow(
+            unmanaged=None, namespace_inject=None
+        )
+        org_config = mock.Mock()
+        org_config.installed_packages = {}
+        assert flow_dep._get_unmanaged(org_config) is True
+
+        # Test with unmanaged = None and namespace_inject present but not in installed packages
+        flow_dep = ConcreteUnmanagedVcsDependencyFlow(
+            unmanaged=None, namespace_inject="test_ns"
+        )
+        org_config = mock.Mock()
+        org_config.installed_packages = {}
+        assert flow_dep._get_unmanaged(org_config) is True
+
+        # Test with unmanaged = None and namespace_inject present and in installed packages
+        flow_dep = ConcreteUnmanagedVcsDependencyFlow(
+            unmanaged=None, namespace_inject="test_ns"
+        )
+        org_config = mock.Mock()
+        org_config.installed_packages = {"test_ns": mock.Mock()}
+        assert flow_dep._get_unmanaged(org_config) is False
+
+        # Test with explicit unmanaged = True
+        flow_dep = ConcreteUnmanagedVcsDependencyFlow(unmanaged=True)
+        org_config = mock.Mock()
+        assert flow_dep._get_unmanaged(org_config) is True
+
+        # Test with explicit unmanaged = False
+        flow_dep = ConcreteUnmanagedVcsDependencyFlow(unmanaged=False)
+        org_config = mock.Mock()
+        assert flow_dep._get_unmanaged(org_config) is False
+
+    @mock.patch("cumulusci.core.dependencies.base.datetime")
+    @mock.patch("cumulusci.core.dependencies.base.format_duration")
+    @mock.patch("cumulusci.core.dependencies.base.FlowCoordinator")
+    @mock.patch("cumulusci.vcs.vcs_source.VCSSource")
+    @mock.patch("cumulusci.utils.yaml.cumulusci_yml.VCSSourceModel")
+    def test_install(
+        self,
+        vcs_source_model_mock,
+        vcs_source_mock,
+        flow_coordinator_mock,
+        format_duration_mock,
+        datetime_mock,
+    ):
+        """Test the install method"""
+        # Setup mocks
+        mock_context = mock.Mock()
+        mock_context.logger = mock.Mock()
+        mock_context.allow_remote_code = False
+        mock_context.keychain = mock.Mock()
+
+        mock_org = mock.Mock()
+        mock_org.installed_packages = {}
+
+        # Setup VCS source mock
+        mock_vcs_source_instance = mock.Mock()
+        mock_vcs_source_instance.allow_remote_code = False
+        vcs_source_mock.create.return_value = mock_vcs_source_instance
+
+        # Setup project config mock
+        mock_project_config = mock.Mock()
+        mock_vcs_source_instance.fetch.return_value = mock_project_config
+
+        # Setup flow config mock
+        mock_flow_config = mock.Mock()
+        mock_project_config.get_flow.return_value = mock_flow_config
+
+        # Setup coordinator mock
+        mock_coordinator_instance = mock.Mock()
+        flow_coordinator_mock.return_value = mock_coordinator_instance
+
+        # Setup datetime mock
+        from datetime import datetime as real_datetime
+
+        mock_start_time = real_datetime(2023, 1, 1, 10, 0, 0)
+        mock_end_time = real_datetime(2023, 1, 1, 10, 0, 5)
+        datetime_mock.now.side_effect = [mock_start_time, mock_end_time]
+
+        # Setup format duration mock
+        format_duration_mock.return_value = "5.2s"
+
+        # Create flow dependency
+        flow_dep = ConcreteUnmanagedVcsDependencyFlow(
+            vcs="github",
+            url="https://github.com/test/repo",
+            commit="abc123",
+            flow_name="install_deps",
+            namespace_inject="test_ns",
+            namespace_strip="old_ns",
+        )
+
+        # Call install
+        flow_dep.install(mock_context, mock_org)
+
+        # Verify VCSSourceModel was created correctly
+        vcs_source_model_mock.assert_called_once_with(
+            vcs="github",
+            url="https://github.com/test/repo",
+            commit="abc123",
+            allow_remote_code=False,
+        )
+
+        # Verify VCSSource.create was called
+        vcs_source_mock.create.assert_called_once_with(
+            mock_context, vcs_source_model_mock.return_value
+        )
+
+        # Verify fetch was called
+        mock_vcs_source_instance.fetch.assert_called_once()
+
+        # Verify project config setup
+        mock_project_config.set_keychain.assert_called_once_with(mock_context.keychain)
+        assert mock_project_config.source == mock_vcs_source_instance
+
+        # Verify flow config setup
+        mock_project_config.get_flow.assert_called_once_with("install_deps")
+        assert mock_flow_config.name == "install_deps"
+
+        # Verify FlowCoordinator was created correctly
+        flow_coordinator_mock.assert_called_once()
+        args, kwargs = flow_coordinator_mock.call_args
+        assert args[0] == mock_project_config
+        assert args[1] == mock_flow_config
+        assert kwargs["name"] == "install_deps"
+        assert kwargs["options"] == {
+            "unmanaged": True,  # _get_unmanaged should return True for empty installed_packages
+            "namespace_inject": "test_ns",
+            "namespace_strip": "old_ns",
+        }
+        assert kwargs["skip"] is None
+        assert isinstance(kwargs["callbacks"], type(flow_dep.callback_class()))
+
+        # Verify coordinator.run was called
+        mock_coordinator_instance.run.assert_called_once_with(mock_org)
+
+        # Verify logging
+        assert (
+            mock_context.logger.info.call_count == 3
+        )  # Initial log, fetching log, final log
+        mock_context.logger.info.assert_any_call(
+            "Deploying dependency Flow from https://github.com/test/repo Flow: install_deps @abc123"
+        )
+        mock_context.logger.info.assert_any_call(
+            f"Fetching from {mock_vcs_source_instance}"
+        )
+        mock_context.logger.info.assert_any_call("Ran install_deps in 5.2s")
+
+        # Verify datetime and format_duration calls
+        assert datetime_mock.now.call_count == 2
+        format_duration_mock.assert_called_once_with(mock_end_time - mock_start_time)
+
+
 class TestParseDependency:
     def test_parse_managed_package_dep(self):
         m = parse_dependency({"version": "1.0", "namespace": "foo"})

cumulusci/core/tests/test_utils.py

@@ -139,3 +139,154 @@ class TestProcessListOfPairsDictArg:
         error_message = re.escape("Var specified twice: foo")
         with pytest.raises(TaskOptionsError, match=error_message):
             utils.process_list_of_pairs_dict_arg(duplicate)
+
+
+class TestDeepMergePlugins:
+    """Test the deep_merge_plugins function"""
+
+    def test_deep_merge_plugins_remote_takes_precedence(self):
+        """Test that remote plugins take precedence over project plugins"""
+        remote_plugins = {"plugin1": {"setting": "remote_value"}}
+        project_plugins = {"plugin1": {"setting": "project_value"}}
+
+        result = utils.deep_merge_plugins(remote_plugins, project_plugins)
+
+        assert result == {"plugin1": {"setting": "remote_value"}}
+
+    def test_deep_merge_plugins_project_provides_defaults(self):
+        """Test that project plugins provide defaults for missing keys"""
+        remote_plugins = {"plugin1": {"setting1": "remote_value"}}
+        project_plugins = {"plugin1": {"setting2": "project_value"}}
+
+        result = utils.deep_merge_plugins(remote_plugins, project_plugins)
+
+        assert result == {
+            "plugin1": {"setting1": "remote_value", "setting2": "project_value"}
+        }
+
+    def test_deep_merge_plugins_missing_keys_from_project(self):
+        """Test that missing top-level keys are added from project plugins"""
+        remote_plugins = {"plugin1": {"setting": "remote_value"}}
+        project_plugins = {"plugin2": {"setting": "project_value"}}
+
+        result = utils.deep_merge_plugins(remote_plugins, project_plugins)
+
+        assert result == {
+            "plugin1": {"setting": "remote_value"},
+            "plugin2": {"setting": "project_value"},
+        }
+
+    def test_deep_merge_plugins_recursive_merge(self):
+        """Test recursive merging of nested dictionaries"""
+        remote_plugins = {
+            "plugin1": {
+                "nested": {"setting1": "remote_value", "setting2": "remote_value2"}
+            }
+        }
+        project_plugins = {
+            "plugin1": {
+                "nested": {
+                    "setting2": "project_value2",  # Should be overridden
+                    "setting3": "project_value3",  # Should be added
+                }
+            }
+        }
+
+        result = utils.deep_merge_plugins(remote_plugins, project_plugins)
+
+        assert result == {
+            "plugin1": {
+                "nested": {
+                    "setting1": "remote_value",
+                    "setting2": "remote_value2",
+                    "setting3": "project_value3",
+                }
+            }
+        }
+
+    def test_deep_merge_plugins_non_dict_inputs(self):
+        """Test that non-dict inputs return the remote plugins unchanged"""
+        remote_plugins = {"plugin1": {"setting": "value"}}
+
+        # Test with non-dict project_plugins
+        result = utils.deep_merge_plugins(remote_plugins, "not_a_dict")
+        assert result == remote_plugins
+
+        # Test with non-dict remote_plugins
+        result = utils.deep_merge_plugins(
+            "not_a_dict", {"plugin1": {"setting": "value"}}
+        )
+        assert result == "not_a_dict"
+
+        # Test with both non-dict
+        result = utils.deep_merge_plugins("remote", "project")
+        assert result == "remote"
+
+    def test_deep_merge_plugins_type_mismatch(self):
+        """Test that type mismatches preserve remote values"""
+        remote_plugins = {"plugin1": {"setting": "string_value"}}
+        project_plugins = {"plugin1": {"setting": {"nested": "dict_value"}}}
+
+        result = utils.deep_merge_plugins(remote_plugins, project_plugins)
+
+        # Remote takes precedence when types don't match
+        assert result == {"plugin1": {"setting": "string_value"}}
+
+    def test_deep_merge_plugins_deep_copy(self):
+        """Test that deep copy is used to avoid modifying original data"""
+        remote_plugins = {"plugin1": {"setting": "remote_value"}}
+        project_plugins = {"plugin2": {"nested": {"setting": "project_value"}}}
+
+        result = utils.deep_merge_plugins(remote_plugins, project_plugins)
+
+        # Modify the result to check if originals are affected
+        result["plugin2"]["nested"]["setting"] = "modified_value"
+
+        # Original should remain unchanged
+        assert project_plugins["plugin2"]["nested"]["setting"] == "project_value"
+
+    def test_deep_merge_plugins_empty_inputs(self):
+        """Test with empty dictionaries"""
+        # Empty remote, non-empty project
+        result = utils.deep_merge_plugins({}, {"plugin1": {"setting": "value"}})
+        assert result == {"plugin1": {"setting": "value"}}
+
+        # Non-empty remote, empty project
+        result = utils.deep_merge_plugins({"plugin1": {"setting": "value"}}, {})
+        assert result == {"plugin1": {"setting": "value"}}
+
+        # Both empty
+        result = utils.deep_merge_plugins({}, {})
+        assert result == {}
+
+    def test_deep_merge_plugins_complex_nested_structure(self):
+        """Test with complex nested structure"""
+        remote_plugins = {
+            "plugin1": {"level1": {"level2": {"remote_setting": "remote_value"}}}
+        }
+        project_plugins = {
+            "plugin1": {
+                "level1": {
+                    "level2": {"project_setting": "project_value"},
+                    "project_level2": "project_value2",
+                },
+                "project_level1": "project_value3",
+            }
+        }
+
+        result = utils.deep_merge_plugins(remote_plugins, project_plugins)
+
+        expected = {
+            "plugin1": {
+                "level1": {
+                    "level2": {
+                        "remote_setting": "remote_value",
+                        "project_setting": "project_value",
+                    },
+                    "project_level2": "project_value2",
+                },
+                "project_level1": "project_value3",
+            }
+        }
+
+        assert result == expected

cumulusci/core/utils.py

@@ -400,3 +400,26 @@ def determine_managed_mode(options, project_config, org_config):
     else:
         # Fall back to checking namespace in installed packages
         return bool(namespace) and namespace in installed_packages
+
+
+def deep_merge_plugins(remote_plugins, project_plugins):
+    """
+    Deep merge project_plugins into remote_plugins, adding only missing keys.
+    Remote plugins take precedence, project plugins provide defaults for missing keys.
+    """
+    if not isinstance(remote_plugins, dict) or not isinstance(project_plugins, dict):
+        return remote_plugins
+
+    result = remote_plugins.copy()
+
+    for key, value in project_plugins.items():
+        if key not in result:
+            # Key doesn't exist in remote, add it from project
+            result[key] = copy.deepcopy(value)
+        elif isinstance(result[key], dict) and isinstance(value, dict):
+            # Both are dictionaries, recursively merge
+            result[key] = deep_merge_plugins(result[key], value)
+        # If key exists in remote but types don't match or remote value is not dict,
+        # keep the remote value (remote takes precedence)
+
+    return result

cumulusci/schema/cumulusci.jsonschema.json

@@ -426,6 +426,14 @@
                 "custom": {
                     "title": "Custom",
                     "type": "object"
+                },
+                "dependency_flow_pre": {
+                    "title": "Dependency Flow Pre",
+                    "type": "string"
+                },
+                "dependency_flow_post": {
+                    "title": "Dependency Flow Post",
+                    "type": "string"
                 }
             },
             "additionalProperties": false

cumulusci/tasks/vcs/tests/github/test_download_extract.py

@@ -373,20 +373,24 @@ class TestDownloadExtract:
 
     def test_set_target_directory__absolute_path(self):
         """Test _set_target_directory with absolute path"""
-        absolute_path = "/tmp/test_dir"
-        task_config = TaskConfig(
-            {
-                "options": {
-                    "repo_url": self.repo_url,
-                    "target_directory": absolute_path,
+        absolute_path = tempfile.mkdtemp(prefix="test_")
+        try:
+            task_config = TaskConfig(
+                {
+                    "options": {
+                        "repo_url": self.repo_url,
+                        "target_directory": absolute_path,
+                    }
                 }
-            }
-        )
-        task = DownloadExtract(self.project_config, task_config)
+            )
+            task = DownloadExtract(self.project_config, task_config)
 
-        task._set_target_directory()
+            task._set_target_directory()
 
-        assert task.options["target_directory"] == absolute_path
+            assert task.options["target_directory"] == absolute_path
+        finally:
+            # Clean up the temporary directory
+            os.rmdir(absolute_path)
 
     def test_rename_files(self):
         """Test _rename_files method"""

cumulusci/utils/yaml/cumulusci_yml.py

@@ -144,6 +144,8 @@ class Project(CCIDictModel):
     dependency_pins: Optional[List[Dict[str, str]]]
     source_format: Literal["sfdx", "mdapi"] = "mdapi"
     custom: Optional[Dict] = None
+    dependency_flow_pre: str = None
+    dependency_flow_post: str = None
 
 
 class ScratchOrg(CCIDictModel):

cumulusci/vcs/vcs_source.py

@@ -255,6 +255,7 @@ class VCSSource(ABC):
                 "name": self.repo.repo_name,
                 "url": self.url,
                 "commit": self.commit,
+                "vcs_service": self.vcs_service,
                 # Note: we currently only pass the branch if it was explicitly
                 # included in the source spec. If the commit was found another way,
                 # we aren't looking up what branches have that commit as their head.

{cumulusci_plus-5.0.6.dist-info → cumulusci_plus-5.0.8.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cumulusci-plus
-Version: 5.0.6
+Version: 5.0.8.dev0
 Summary: Build and release tools for Salesforce developers
 Project-URL: Homepage, https://github.com/jorgesolebur/CumulusCI
 Project-URL: Changelog, https://cumulusci.readthedocs.io/en/stable/history.html

{cumulusci_plus-5.0.6.dist-info → cumulusci_plus-5.0.8.dev0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-cumulusci/__about__.py,sha256=g6rB4S_8iDhKN5JGqjcBZgs-fUDE2THmw5wKLngtRVQ,22
+cumulusci/__about__.py,sha256=nnWzpE6c_AzsihHEu6Ul-b8Oj0n88PpGCNkmHuwzmis,27
 cumulusci/__init__.py,sha256=jdanFQ_i8vbdO7Eltsf4pOfvV4mwa_Osyc4gxWKJ8ng,764
 cumulusci/__main__.py,sha256=kgRH-n5AJrH_daCK_EJwH7azAUxdXEmpi-r-dPGMR6Y,43
 cumulusci/conftest.py,sha256=AIL98BDwNAQtdo8YFmLKwav0tmrQ5dpbw1cX2FyGouQ,5108
 cumulusci/cumulusci.yml,sha256=FE1Dm7EhcMXY-XtLljbcbRyo_E0tvspaxqh8Nsiup3w,72365
 cumulusci/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cumulusci/cli/cci.py,sha256=GQKxxkz1furfcaDlm7qc2P4cww0GvhlNr2dpc_Hp9Lw,8523
+cumulusci/cli/cci.py,sha256=NcFm0Nng5o47fAMcjpSHjWRvQKDbD2lwPSkuoCVW9eA,11901
 cumulusci/cli/error.py,sha256=znj0YN8D2Grozm1u7mZAsJlmmdGebbuy0c1ofQluL4Q,4410
 cumulusci/cli/flow.py,sha256=rN_9WL2Z6dcx-oRngChIgei3E5Qmg3XVzk5ND1o0i3s,6171
 cumulusci/cli/logger.py,sha256=bpzSD0Bm0BAwdNbVR6yZXMREh2vm7jOytZevEaNoVR4,2267
@@ -18,7 +18,7 @@ cumulusci/cli/task.py,sha256=xm8lo0_LMMpcsUDv1Gj_HpW1phllyEW9IRm2lQSh5wg,10077
 cumulusci/cli/ui.py,sha256=Ld-2S6Kr204SBput-1pNAVlYglzcvbV5nVA_rGXlAo8,7346
 cumulusci/cli/utils.py,sha256=Bl-l8eOXxzi6E_DsWGGGeefwZxrVg7Zo52BIwoNhKH8,5522
 cumulusci/cli/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cumulusci/cli/tests/test_cci.py,sha256=wtzuXggLGrbMWjMQMVkdqXnYT_rqAr68xWCjTjbhH4w,18142
+cumulusci/cli/tests/test_cci.py,sha256=p9PYNij3dB3dNwOg9ivPSzVw179WORFVMfRpkWW68pg,27891
 cumulusci/cli/tests/test_error.py,sha256=zU2ccfGOivcVMpCManam18uyhlzT-HFb9xuMljU4few,6629
 cumulusci/cli/tests/test_flow.py,sha256=CIkZWvai5H4EOs35epMKWmxzDfauIEqL6BUwC8q3LPU,8535
 cumulusci/cli/tests/test_logger.py,sha256=-XBwSmtuelpx5sax0_E2xi4F9m_UsRkt2gn1o9ub6h8,834
@@ -43,7 +43,7 @@ cumulusci/core/runtime.py,sha256=H2e3YN2i_nPiB2oVB_0V0rLsmTqBs8CdajdGOA4gsB0,377
 cumulusci/core/sfdx.py,sha256=ZGW71iMdcMa8RlgZFXcrzZJg5ADCRtzZ-_P8DVUvYJg,4788
 cumulusci/core/tasks.py,sha256=FF96ywx9VF1nSWQXyPrfFXcPIdsTkA9dvgxaKlKmkg8,14142
 cumulusci/core/template_utils.py,sha256=to1kv-4gaKELNYIpeAUSHcJOvwgRx1sbI5wdz_I0Cnc,1409
-cumulusci/core/utils.py,sha256=S7shYnPaUd54WpmArVR2jyGcjJiRh6y6y_csr-lqJJI,14593
+cumulusci/core/utils.py,sha256=7E2HI-FEy7K-PsHHejISI6VDKuhW9QkfJ97RTg-me4I,15527
 cumulusci/core/versions.py,sha256=TooqfsKAdEomLsjQaYvarPDu34kNTPeIvEzXLhuUev4,4675
 cumulusci/core/config/BaseConfig.py,sha256=WFz6jq2xnUHyi-Plm3ARpqAZtDlI4zLact3e5gqO-Yc,130
 cumulusci/core/config/BaseTaskFlowConfig.py,sha256=vdUijsUtURFl9e3M8qv-KSLkLBSsMFh-zuDgbPcyDKA,158
@@ -65,7 +65,7 @@ cumulusci/core/config/tests/test_config.py,sha256=ZtIQSIzQWebw7mYXgehnp3CvoatC_t
 cumulusci/core/config/tests/test_config_expensive.py,sha256=__3JEuoAQ8s5njTcbyZlpXHr0jR0Qtne96xyF7fzqjQ,30137
 cumulusci/core/config/tests/test_config_util.py,sha256=X1SY9PIhLoQuC8duBKgs804aghN3n12DhqiC_f6jSmM,3177
 cumulusci/core/dependencies/__init__.py,sha256=Txf4VCrRW-aREKHqzK3ZyauQMsgtCXjiLkQzpMQT0kI,1533
-cumulusci/core/dependencies/base.py,sha256=Lf5yKZaEUYabFMyrmU-4L04N1RU1-2sakbwhHRFxlv8,18770
+cumulusci/core/dependencies/base.py,sha256=i5F7D2CwoWwUHqjI0LRCwwJGqhGKFRDkerg0N8uJdQs,22804
 cumulusci/core/dependencies/dependencies.py,sha256=74KjrCRn7AjKPBSGOm4pU34eJd8GSp1wNs7EFIC0wBE,8689
 cumulusci/core/dependencies/github.py,sha256=ozpRc5ADJsRDD5C_T-TLFygnBDE5Y9_03ZLCtZ-qr98,5897
 cumulusci/core/dependencies/github_resolvers.py,sha256=Em8p41Q-npoKv1ZAYNxXVrluQmYitzVfLLXlmln-MGw,9196
@@ -73,7 +73,7 @@ cumulusci/core/dependencies/resolvers.py,sha256=xWVijK6Eu-WFyGnQPFANLkZFTjq4NQYh
 cumulusci/core/dependencies/utils.py,sha256=y54fWqLZ8IUIV9i1b6WcDXIJsK0ygny5DTsZCXbgeoM,369
 cumulusci/core/dependencies/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cumulusci/core/dependencies/tests/conftest.py,sha256=rd0ZqpV6GTk7IRtPYJ7jyLWHM1g_xtZ4PABuvkN-TZY,11004
-cumulusci/core/dependencies/tests/test_dependencies.py,sha256=V7clNtNN8n2jCw45BzO7clZE4YyCB-qN-KI_GdlucGE,33024
+cumulusci/core/dependencies/tests/test_dependencies.py,sha256=MiKet_2xCMhzyo3oz_DzBnwVBjfCetmbmpBVQVKMEpg,40705
 cumulusci/core/dependencies/tests/test_github.py,sha256=_JiUh-xgGmnsA2X_57i3gOwcDv_xBj66mdhitcZ-APU,2765
 cumulusci/core/dependencies/tests/test_resolvers.py,sha256=kLnvs0QTDKQwkxZ_lAAcetWZUNwBoP-TJYp9fdgRbHU,36271
 cumulusci/core/keychain/__init__.py,sha256=UbuaIrKZSczVVqbG_7BHFTkQukbqinGJlJlQGIpIsOI,595
@@ -103,7 +103,7 @@ cumulusci/core/tests/test_github.py,sha256=cXsCAMzub2EUAI0_x2CYBR-bn4FE_OYe72zZO
 cumulusci/core/tests/test_sfdx.py,sha256=-pC6oGVF5H_OQfZxUG_YbPCYddxWhBS6gPImKO-XqN4,4540
 cumulusci/core/tests/test_source.py,sha256=m66vXcgMwc92R1OotTdMzd6Mg6gAHj5QrYJMDnL_i5s,24468
 cumulusci/core/tests/test_tasks.py,sha256=hJbVmecbJekOJQdB67aMmPSirPCCf-MGGAnfkLFdTfs,9543
-cumulusci/core/tests/test_utils.py,sha256=TpNzuX_WrRKuKyDn9gJd3FFzP_-kxavFAd9mBgsu8EI,5116
+cumulusci/core/tests/test_utils.py,sha256=rDvBePhwyrrMOlSXArzmSwO7S2jyny1y23vIi7w2AX0,10810
 cumulusci/core/tests/test_utils_merge_config.py,sha256=FfezjbsW7-45T9Apf6DqUXdxMyu7CtlG3_8CsUghqJ0,9676
 cumulusci/core/tests/test_versions.py,sha256=s7JsmBAHN8FA2KWRFzVxGj-EgyA05hiFGnfRvkGgLtM,2427
 cumulusci/core/tests/utils.py,sha256=odciQ496J-LxTrKOXGyNx-yaprbUL713eZlh6h9W49g,3182
@@ -224,7 +224,7 @@ cumulusci/salesforce_api/tests/test_package_zip.py,sha256=C8YzRFvRRpgT1ysqUMGhGV
 cumulusci/salesforce_api/tests/test_rest_deploy.py,sha256=VRADL5vHlCJcswLk1IA6Chs6UD6YJUzPiM3KzPJ63L8,10045
 cumulusci/salesforce_api/tests/test_retrieve_profile_api.py,sha256=oDE0fM992y0N7fI94oJtRXJzIQ5sew285-ywDk4c-S4,11778
 cumulusci/salesforce_api/tests/test_utils.py,sha256=h3dGnr-au7H9QUzUv-3uDFEjP6eq29MXFQeYi3Cxfwk,3965
-cumulusci/schema/cumulusci.jsonschema.json,sha256=16BHBrlplqvuL3Fy-M2MCDLxD07Oc-OfUudAzm5umOA,24682
+cumulusci/schema/cumulusci.jsonschema.json,sha256=V3VGXNslrrqGbceSmjvmnkG99b2GrwhXhYugz2FGPWw,24982
 cumulusci/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cumulusci/tasks/base_source_control_task.py,sha256=YVLngLcXsjnsbQwTS33tioLic3EU5D-P0GtY8op00Uw,637
 cumulusci/tasks/command.py,sha256=ntVmi98kUvoQm90sd34pbILLt73tdG9VUT1-eTdHQ6g,5710
@@ -622,7 +622,7 @@ cumulusci/tasks/vcs/release.py,sha256=xXim12XVij34LRK6kAQ_5qeQLlYHNtx4e386doQCxh
 cumulusci/tasks/vcs/release_report.py,sha256=B8ehl6PK7kaEI_jS-rapQfNm0bhJRR7LBL4WFq1meNE,4226
 cumulusci/tasks/vcs/tag.py,sha256=x9Xw5t6g13ztl0TjtclQ1_JRBWtez73e9Az8oYJeqvU,1098
 cumulusci/tasks/vcs/tests/github/test_commit_status.py,sha256=1IAGz8_wFVUvk0wY5V_Aetb6M5Ri0nkOHaRSUdqQkZI,7206
-cumulusci/tasks/vcs/tests/github/test_download_extract.py,sha256=mpDYmuai0cF_p-PjPlY3MPMoDhk2r8QAcm4qZq2fOHQ,32420
+cumulusci/tasks/vcs/tests/github/test_download_extract.py,sha256=_8j2xkypbF6xECkYgWby6vfHAss16FHhuy9flu-m5Fo,32594
 cumulusci/tasks/vcs/tests/github/test_merge.py,sha256=OS25YJHNVqfb2lPzpXOpzR8BEiDEh_C94BwDTvTDQ-U,39306
 cumulusci/tasks/vcs/tests/github/test_publish.py,sha256=kl3IvWmDL8M225R7Ygyr-vUjXQ0_GoUDH85kOncDlMk,30739
 cumulusci/tasks/vcs/tests/github/test_pull_request.py,sha256=dh-XihMjCH69wML6vg3KKqjB2NsfhBoMr0Ii1xfM8gw,974
@@ -711,7 +711,7 @@ cumulusci/utils/xml/robot_xml.py,sha256=V9daywDdxBMDUYvMchWaPx-rj9kCXYskua1hvG_t
 cumulusci/utils/xml/salesforce_encoding.py,sha256=ahPJWYfq3NMW8oSjsrzzQnAqghL-nQBWn-lSXuGjhIc,3071
 cumulusci/utils/xml/test/test_metadata_tree.py,sha256=4jzKqYUEVzK6H8iCWMTD2v2hRssz2OeLspQO9osqm2E,8517
 cumulusci/utils/xml/test/test_salesforce_encoding.py,sha256=DN0z5sM6Lk1U2hD7nYt7eYK1BjJy3-d5OdHk4HsPo6Y,6309
-cumulusci/utils/yaml/cumulusci_yml.py,sha256=cWk2o7UzyX4JsDQIAEprglKqNl-iC78_QEQA4yjjJgY,11279
+cumulusci/utils/yaml/cumulusci_yml.py,sha256=OmoxbE9jczQ1w9UfwJefROdNlChHwXsCJm9e6Zw3NJM,11352
 cumulusci/utils/yaml/model_parser.py,sha256=aTnlWwfMpDOGnlVKLvPAl5oLH0FReVeqDM-EUA4s7k8,5057
 cumulusci/utils/yaml/safer_loader.py,sha256=O7hhI2DqVA0GV4oY4rlB084QCc_eXFg2HTNHlfGVOcQ,2388
 cumulusci/utils/yaml/tests/bad_cci.yml,sha256=Idj6subt7pNZk8A1Vt3bs_lM99Ash5ZVgOho1drMTXQ,17
@@ -722,7 +722,7 @@ cumulusci/utils/yaml/tests/cassettes/TestCumulusciYml.test_validate_url__with_er
 cumulusci/vcs/base.py,sha256=HxkCaVf0-Oj7L9y9x0k3fb9RCQb9GVHpvedTPnYXpOM,6460
 cumulusci/vcs/bootstrap.py,sha256=vhvYFep6wu74CSbR_M9HMHMPBLbhih6rqgZnN_z-zHI,9266
 cumulusci/vcs/models.py,sha256=dSxQFZj_620tXO7JPoGgxgSNLYUup3lnqnrHxP0rNqA,22976
-cumulusci/vcs/vcs_source.py,sha256=zDciXg4aqVZ3vrFgHyiElNUabeb_T9f2baq75j2jrHM,10445
+cumulusci/vcs/vcs_source.py,sha256=0_kWOSxNUhVxBOgmY7WiEKSbwwZhx_jcfVs5lTobE4E,10494
 cumulusci/vcs/github/__init__.py,sha256=LUnwWubhqDLXiej9AZvC9WryXiMhsnbYD8CiJgbJ0Ek,512
 cumulusci/vcs/github/adapter.py,sha256=DN2std4UgNW_eeuvI4fuWxYhzj4pAUYAiTYJvVh9v4A,23769
 cumulusci/vcs/github/service.py,sha256=Mbb6y6ngHLBR2J24Awn02I_rC1ufjdiYn3gGv0si5cQ,21265
@@ -736,9 +736,9 @@ cumulusci/vcs/tests/dummy_service.py,sha256=RltOUpMIhSDNrfxk0LhLqlH4ppC0sK6NC2cO
 cumulusci/vcs/tests/test_vcs_base.py,sha256=9mp6uZ3lTxY4onjUNCucp9N9aB3UylKS7_2Zu_hdAZw,24331
 cumulusci/vcs/tests/test_vcs_bootstrap.py,sha256=N0NA48-rGNIIjY3Z7PtVnNwHObSlEGDk2K55TQGI8g4,27954
 cumulusci/vcs/utils/__init__.py,sha256=py4fEcHM7Vd0M0XWznOlywxaeCtG3nEVGmELmEKVGU8,869
-cumulusci_plus-5.0.6.dist-info/METADATA,sha256=oRRHu-EE-Kv7C4P-bjlInR9uzUoHMYbWNm8LwyfzhuM,6134
-cumulusci_plus-5.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cumulusci_plus-5.0.6.dist-info/entry_points.txt,sha256=nTtu04b9iLXhzADcTrb5PwmdXE6e2MTUAMh9OK6Z2pg,80
-cumulusci_plus-5.0.6.dist-info/licenses/AUTHORS.rst,sha256=PvewjKImdKPhhJ6xR2EEZ4T7GbpY2ZeAeyWm2aLtiMQ,676
-cumulusci_plus-5.0.6.dist-info/licenses/LICENSE,sha256=NFsF_s7RVXk2dU6tmRAN8wF45pnD98VZ5IwqOsyBcaU,1499
-cumulusci_plus-5.0.6.dist-info/RECORD,,
+cumulusci_plus-5.0.8.dev0.dist-info/METADATA,sha256=No5M7E99WFdnfIqbyhyCUrW2WpLlo8W09i7yx6wgr7w,6139
+cumulusci_plus-5.0.8.dev0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cumulusci_plus-5.0.8.dev0.dist-info/entry_points.txt,sha256=nTtu04b9iLXhzADcTrb5PwmdXE6e2MTUAMh9OK6Z2pg,80
+cumulusci_plus-5.0.8.dev0.dist-info/licenses/AUTHORS.rst,sha256=PvewjKImdKPhhJ6xR2EEZ4T7GbpY2ZeAeyWm2aLtiMQ,676
+cumulusci_plus-5.0.8.dev0.dist-info/licenses/LICENSE,sha256=NFsF_s7RVXk2dU6tmRAN8wF45pnD98VZ5IwqOsyBcaU,1499
+cumulusci_plus-5.0.8.dev0.dist-info/RECORD,,