cumulusci-plus 5.0.15__tar.gz → 5.0.16__tar.gz

{cumulusci_plus-5.0.15 → cumulusci_plus-5.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cumulusci-plus
-Version: 5.0.15
+Version: 5.0.16
 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
@@ -127,7 +127,7 @@ license](https://github.com/SFDO-Tooling/CumulusCI/blob/main/LICENSE)
 and is not covered by the Salesforce Master Subscription Agreement.
 
 <!-- Changelog -->
-## v5.0.15 (2025-08-03)
+## v5.0.16 (2025-08-20)
 
 <!-- Release notes generated using configuration in .github/release.yml at main -->
 
@@ -135,6 +135,6 @@ and is not covered by the Salesforce Master Subscription Agreement.
 
 ### Changes
 
-- Add flow options to all supported flows by [@rupeshjSFDC](https://github.com/rupeshjSFDC) in [#55](https://github.com/jorgesolebur/CumulusCI/pull/55)
+- Add configure_env task and fix failing test classes. by [@rupeshjSFDC](https://github.com/rupeshjSFDC) in [#57](https://github.com/jorgesolebur/CumulusCI/pull/57)
 
-**Full Changelog**: https://github.com/jorgesolebur/CumulusCI/compare/v5.0.14...v5.0.15
+**Full Changelog**: https://github.com/jorgesolebur/CumulusCI/compare/v5.0.15...v5.0.16

cumulusci_plus-5.0.16/cumulusci/__about__.py

@@ -0,0 +1 @@
+__version__ = "5.0.16"

{cumulusci_plus-5.0.15 → cumulusci_plus-5.0.16}/cumulusci/cli/cci.py

@@ -1,5 +1,6 @@
 import code
 import contextlib
+import os
 import pdb
 import runpy
 import signal
@@ -79,8 +80,33 @@ def _cleanup_on_signal(signum):
         except Exception as e:
             console.print(f"[red]Error during cleanup: {e}[/red]")
 
-    # The parent process's trap is now responsible for killing the process group.
-    # This process will exit gracefully after receiving the signal from the parent.
+    # 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
@@ -104,8 +130,15 @@ def main(args=None):
     """
     global _exit_stack
 
-    # By not creating a new process group, cci remains in the parent's group.
-    # This allows the parent's trap command to correctly terminate cci and its children.
+    # 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)
@@ -152,7 +185,10 @@ def main(args=None):
             try:
                 cli(args[1:], standalone_mode=False, obj=runtime)
             except click.Abort:  # Keyboard interrupt
-                _cleanup_on_signal(signal.SIGINT)
+                if _exit_stack:
+                    _exit_stack.close()
+                Console(stderr=True).print("[yellow]Aborted![/yellow]")
+                sys.exit(1)
             except Exception as e:
                 if debug:
                     console = Console()

{cumulusci_plus-5.0.15 → cumulusci_plus-5.0.16}/cumulusci/core/dependencies/tests/test_dependencies.py

@@ -1018,6 +1018,7 @@ class TestUnmanagedVcsDependencyFlow:
         # Setup flow config mock
         mock_flow_config = mock.Mock()
         mock_project_config.get_flow.return_value = mock_flow_config
+        mock_project_config.list_tasks.return_value = []
 
         # Setup coordinator mock
         mock_coordinator_instance = mock.Mock()
@@ -1076,11 +1077,7 @@ class TestUnmanagedVcsDependencyFlow:
         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["options"] == {}
         assert kwargs["skip"] is None
         assert isinstance(kwargs["callbacks"], type(flow_dep.callback_class()))
 

{cumulusci_plus-5.0.15 → cumulusci_plus-5.0.16}/cumulusci/cumulusci.yml

@@ -749,6 +749,10 @@ tasks:
         options:
             level: info
         group: Utilities
+    configure_env:
+        description: Get or set environment variables.
+        class_path: cumulusci.tasks.utility.env_management.EnvManagement
+        group: Utilities
     download_extract:
         description: Downloads files and folders from a VCS repository.
         class_path: cumulusci.tasks.vcs.download_extract.DownloadExtract

cumulusci_plus-5.0.16/cumulusci/tasks/utility/env_management.py

@@ -0,0 +1,157 @@
+import json
+import os
+from datetime import date
+from pathlib import Path
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, validator
+
+from cumulusci.core.config import BaseProjectConfig, OrgConfig, TaskConfig
+from cumulusci.core.tasks import BaseTask
+from cumulusci.utils.options import CCIOptions, Field
+from cumulusci.vcs.bootstrap import get_repo_from_url
+
+
+class EnvManagementOption(CCIOptions):
+    name: str = Field(
+        ...,
+        description="The name of the environment variable to get the value from the environment",
+    )
+    default: Any = Field(
+        default=None,
+        description="The default value of the environment variable. Defaults to None",
+    )
+    datatype: str = Field(
+        default="string",
+        description="The datatype of the environment variable. Defaults to string. Valid values are string, bool, int, float, date, list, dict, path, directory, filename, vcs_branch",
+    )
+    set: bool = Field(
+        default=False,
+        description="If True, sets the value of the environment variable if it is not already set. Defaults to False",
+    )
+    url: str = Field(
+        default="",
+        description="The url of the repository to get the branch value from, Applicable only for vcs_branch datatype. Defaults to empty string",
+    )
+
+    @validator("datatype")
+    def validate_datatype(cls, v):
+        if v not in [
+            "string",
+            "bool",
+            "int",
+            "float",
+            "date",
+            "list",
+            "dict",
+            "path",
+            "directory",
+            "filename",
+            "vcs_branch",
+        ]:
+            raise ValueError(f"Invalid datatype: {v}")
+        return v
+
+    def formated_value(
+        self,
+        project_config: Optional[BaseProjectConfig],
+        org_config: Optional[OrgConfig],
+    ) -> tuple[Any, str]:
+        value = os.getenv(self.name, self.default)
+        datatype = self.datatype or "string"
+
+        try:
+            match datatype:
+                case "string":
+                    return str(value), str(value)
+                case "bool":
+                    v = DummyValidatorModel(b=value).b
+                    return v, str(v)
+                case "int":
+                    v = DummyValidatorModel(i=value).i
+                    return v, str(v)
+                case "float":
+                    v = DummyValidatorModel(f=value).f
+                    return v, str(v)
+                case "date":
+                    v = DummyValidatorModel(d=date.fromisoformat(str(value))).d
+                    return v, str(v)
+                case "list":
+                    v = value if isinstance(value, list) else value.split(",")
+                    return v, str(v)
+                case "dict":
+                    v = value if isinstance(value, dict) else json.loads(str(value))
+                    return v, str(v)
+                case "path":
+                    v = Path(str(value))
+                    return v.absolute(), str(v.absolute())
+                case "directory":
+                    v = Path(str(value)).parent.absolute()
+                    return v, str(v.absolute())
+                case "filename":
+                    v = Path(str(value)).name
+                    return v, str(v)
+                case "vcs_branch":
+                    task_config = TaskConfig({"options": {"url": self.url}})
+                    task = VcsRemoteBranch(project_config, task_config, org_config)
+                    result = task()
+                    return result["remote_branch"], str(result["remote_branch"])
+                case _:
+                    raise ValueError(f"Invalid datatype: {datatype}")
+        except Exception as e:
+            raise ValueError(
+                f"Formatting Error: {value} for datatype: {datatype} - {e}"
+            )
+
+
+class DummyValidatorModel(BaseModel):
+    b: Optional[bool]
+    i: Optional[int]
+    f: Optional[float]
+    d: Optional[date]
+
+
+class EnvManagement(BaseTask):
+    class Options(CCIOptions):
+        envs: List[EnvManagementOption] = Field(
+            default=[],
+            description="A list of environment variables definitions.",
+        )
+
+    parsed_options: Options
+
+    def _run_task(self):
+        self.return_values = {}
+
+        for env_option in self.parsed_options.envs:
+            self.return_values[env_option.name], str_value = env_option.formated_value(
+                self.project_config, self.org_config
+            )
+            if env_option.set and env_option.name not in os.environ:
+                os.environ[env_option.name] = str_value
+
+        return self.return_values
+
+
+class VcsRemoteBranch(BaseTask):
+    class Options(CCIOptions):
+        url: str = Field(
+            ...,
+            description="Gets if the remote branch name exist with the same name in the remote repository.",
+        )
+
+    parsed_options: Options
+
+    def _run_task(self):
+        self.return_values = {}
+        # Get current branch name.
+        local_branch = self.project_config.repo_branch
+        repo = get_repo_from_url(self.project_config, self.parsed_options.url)
+
+        try:
+            branch = repo.branch(local_branch)
+            self.return_values["remote_branch"] = branch.name
+        except Exception:
+            self.return_values["remote_branch"] = repo.default_branch
+
+        return self.return_values

cumulusci_plus-5.0.16/cumulusci/tasks/utility/tests/test_env_management.py

@@ -0,0 +1,220 @@
+import os
+import unittest
+from datetime import date
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+from cumulusci.core.config import TaskConfig
+from cumulusci.tasks.utility.env_management import (
+    EnvManagement,
+    EnvManagementOption,
+    VcsRemoteBranch,
+)
+from cumulusci.tests.util import create_project_config
+
+
+class TestVcsRemoteBranch(unittest.TestCase):
+    def test_run_task_branch_exists(self):
+        project_config = create_project_config()
+        project_config.repo_info["branch"] = "feature/branch-1"
+        task_config = TaskConfig(
+            {"options": {"url": "https://github.com/TestOwner/TestRepo"}}
+        )
+
+        with patch(
+            "cumulusci.tasks.utility.env_management.get_repo_from_url"
+        ) as get_repo_mock:
+            repo_mock = Mock()
+            branch_mock = Mock()
+            branch_mock.name = "feature/branch-1"
+            repo_mock.branch.return_value = branch_mock
+            get_repo_mock.return_value = repo_mock
+
+            task = VcsRemoteBranch(project_config, task_config)
+            task()
+            self.assertEqual(task.return_values["remote_branch"], "feature/branch-1")
+            repo_mock.branch.assert_called_once_with("feature/branch-1")
+
+    def test_run_task_branch_not_exist(self):
+        project_config = create_project_config()
+        project_config.repo_info["branch"] = "feature/branch-1"
+        task_config = TaskConfig(
+            {"options": {"url": "https://github.com/TestOwner/TestRepo"}}
+        )
+
+        with patch(
+            "cumulusci.tasks.utility.env_management.get_repo_from_url"
+        ) as get_repo_mock:
+            repo_mock = Mock()
+            repo_mock.branch.side_effect = Exception("Branch not found")
+            repo_mock.default_branch = "main"
+            get_repo_mock.return_value = repo_mock
+
+            task = VcsRemoteBranch(project_config, task_config)
+            task()
+            self.assertEqual(task.return_values["remote_branch"], "main")
+            repo_mock.branch.assert_called_once_with("feature/branch-1")
+
+
+class TestEnvManagement(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.project_config = create_project_config()
+        cls.org_config = Mock()
+
+    def test_init_options(self):
+        task_config = TaskConfig(
+            {
+                "options": {
+                    "envs": [
+                        {"name": "MY_VAR", "default": "default_val"},
+                        {"name": "MY_BOOL", "datatype": "bool", "default": "true"},
+                    ]
+                }
+            }
+        )
+        task = EnvManagement(self.project_config, task_config)
+        self.assertEqual(len(task.parsed_options.envs), 2)
+        self.assertIsInstance(task.parsed_options.envs[0], EnvManagementOption)
+
+    @patch.dict(os.environ, {}, clear=True)
+    def test_run_task_get_values(self):
+        os.environ["MY_VAR"] = "env_val"
+        os.environ["MY_INT"] = "123"
+        os.environ["MY_DATE"] = "2023-10-26"
+        os.environ["MY_LIST"] = "a,b,c"
+
+        task_config = TaskConfig(
+            {
+                "options": {
+                    "envs": [
+                        {"name": "MY_VAR"},
+                        {"name": "MY_INT", "datatype": "int"},
+                        {"name": "MY_DATE", "datatype": "date"},
+                        {"name": "MY_LIST", "datatype": "list"},
+                        {"name": "NOT_SET", "default": "default_val"},
+                    ]
+                }
+            }
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        result = task()
+
+        self.assertEqual(
+            result,
+            {
+                "MY_VAR": "env_val",
+                "MY_INT": 123,
+                "MY_DATE": date(2023, 10, 26),
+                "MY_LIST": ["a", "b", "c"],
+                "NOT_SET": "default_val",
+            },
+        )
+        self.assertNotIn("NOT_SET", os.environ)
+
+    @patch.dict(os.environ, {}, clear=True)
+    def test_run_task_set_values(self):
+        os.environ["EXISTING_VAR"] = "original_value"
+        task_config = TaskConfig(
+            {
+                "options": {
+                    "envs": [
+                        {"name": "NEW_VAR", "default": "new_value", "set": True},
+                        {
+                            "name": "EXISTING_VAR",
+                            "default": "new_default",
+                            "set": True,
+                        },
+                    ]
+                }
+            }
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        task()
+
+        self.assertEqual(os.environ.get("NEW_VAR"), "new_value")
+        self.assertEqual(os.environ.get("EXISTING_VAR"), "original_value")
+
+    def test_datatype_validation(self):
+        with self.assertRaises(ValueError):
+            EnvManagementOption(name="test", datatype="invalid")
+
+    @patch.dict(os.environ, {}, clear=True)
+    def _test_datatype_conversion(self, datatype, env_value, expected_value):
+        os.environ["TEST_VAR"] = str(env_value)
+        task_config = TaskConfig(
+            {"options": {"envs": [{"name": "TEST_VAR", "datatype": datatype}]}}
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        result = task()
+        self.assertEqual(result["TEST_VAR"], expected_value)
+
+    def test_datatypes(self):
+        test_cases = [
+            ("string", "hello", "hello"),
+            ("bool", "true", True),
+            ("bool", "0", False),
+            ("int", "42", 42),
+            ("float", "3.14", 3.14),
+            ("date", "2024-01-01", date(2024, 1, 1)),
+            ("list", "one,two", ["one", "two"]),
+            ("dict", '{"key": "value"}', {"key": "value"}),
+            ("path", "/tmp/test", Path("/tmp/test").absolute()),
+            ("directory", "/tmp/test/file.txt", Path("/tmp/test").absolute()),
+            ("filename", "/tmp/test/file.txt", "file.txt"),
+        ]
+        for datatype, env_value, expected_value in test_cases:
+            with self.subTest(datatype=datatype):
+                self._test_datatype_conversion(datatype, env_value, expected_value)
+
+    def test_formatting_error(self):
+        os.environ["TEST_VAR"] = "not-an-int"
+        task_config = TaskConfig(
+            {"options": {"envs": [{"name": "TEST_VAR", "datatype": "int"}]}}
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        with self.assertRaises(ValueError):
+            task()
+
+    @patch("cumulusci.tasks.utility.env_management.VcsRemoteBranch")
+    def test_vcs_branch_datatype(self, vcs_mock):
+        os.environ["TEST_VAR"] = ""  # vcs_branch doesn't use env var
+
+        vcs_instance_mock = vcs_mock.return_value
+        vcs_instance_mock.return_value = {"remote_branch": "my-feature-branch"}
+
+        task_config = TaskConfig(
+            {
+                "options": {
+                    "envs": [
+                        {
+                            "name": "VCS_BRANCH",
+                            "datatype": "vcs_branch",
+                            "url": "https://github.com/TestOwner/TestRepo",
+                        }
+                    ]
+                }
+            }
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        result = task()
+
+        self.assertEqual(result["VCS_BRANCH"], "my-feature-branch")
+        vcs_mock.assert_called_once()
+
+    @patch.dict(os.environ, {}, clear=True)
+    def test_run_task_with_default_types(self):
+        task_config = TaskConfig(
+            {
+                "options": {
+                    "envs": [
+                        {"name": "MY_LIST", "datatype": "list", "default": ["a", "b"]},
+                        {"name": "MY_DICT", "datatype": "dict", "default": {"x": 1}},
+                    ]
+                }
+            }
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        result = task()
+        self.assertEqual(result["MY_LIST"], ["a", "b"])
+        self.assertEqual(result["MY_DICT"], {"x": 1})