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

cumulusci/__about__.py

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

cumulusci/cli/task.py

@@ -140,10 +140,13 @@ class RunTaskCommand(click.MultiCommand):
 
     def get_command(self, ctx, task_name):
         runtime = ctx.obj
-        if runtime.project_config is None:
-            raise runtime.project_config_error
         runtime._load_keychain()
-        task_config = runtime.project_config.get_task(task_name)
+        if runtime.project_config is None:
+            task_config = runtime.universal_config.get_task(task_name)
+            if not task_config.is_global:
+                raise runtime.project_config_error
+        else:
+            task_config = runtime.project_config.get_task(task_name)
 
         if "options" not in task_config.config:
             task_config.config["options"] = {}
@@ -157,14 +160,10 @@ 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):
+            if kwargs.get("loadenv", None) and runtime.project_config is not 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:
+                env_path = Path(runtime.project_config.repo_root) / ".env"
+                if env_path and env_path.exists():
                     load_dotenv(env_path)
 
             org, org_config = runtime.get_org(

cumulusci/cli/tests/test_org.py

@@ -116,6 +116,7 @@ class TestOrgCommands:
                 "IsSandbox": False,
                 "InstanceName": "CS420",
                 "NamespacePrefix": None,
+                "Name": "Test Org",
             },
             status=200,
         )
@@ -173,6 +174,7 @@ class TestOrgCommands:
                 "IsSandbox": False,
                 "InstanceName": "CS420",
                 "NamespacePrefix": None,
+                "Name": "Test Org",
             },
             status=200,
         )
@@ -304,6 +306,7 @@ class TestOrgCommands:
                 "IsSandbox": True,
                 "InstanceName": "CS420",
                 "NamespacePrefix": None,
+                "Name": "Test Org",
             },
             status=200,
         )
@@ -439,6 +442,7 @@ class TestOrgCommands:
                 "IsSandbox": True,
                 "InstanceName": "CS420",
                 "NamespacePrefix": None,
+                "Name": "Test Org",
             },
             status=200,
         )
@@ -494,6 +498,7 @@ class TestOrgCommands:
                 "IsSandbox": True,
                 "InstanceName": "CS420",
                 "NamespacePrefix": None,
+                "Name": "Test Org",
             },
             status=200,
         )

cumulusci/cli/tests/test_task.py

@@ -52,6 +52,8 @@ def test_task_run(runtime):
 
 
 def test_task_run__no_project(runtime):
+    # Add task to universal_config so it can be found
+    runtime.universal_config.config["tasks"] = {**test_tasks}
     runtime.project_config = None
     runtime.project_config_error = Exception("Broken")
     multi_cmd = task.RunTaskCommand()
@@ -60,6 +62,34 @@ def test_task_run__no_project(runtime):
             multi_cmd.get_command(ctx, "dummy-task")
 
 
+def test_task_run__global_task_without_project(runtime):
+    """Test that a global task can run without a project context."""
+    # Define a global task
+    global_task = {
+        "global-dummy-task": {
+            "class_path": "cumulusci.cli.tests.utils.DummyTask",
+            "description": "This is a global dummy task.",
+            "is_global": True,
+        }
+    }
+
+    # Add global task to universal_config
+    runtime.universal_config.config["tasks"] = {**global_task}
+    runtime.project_config = None
+    runtime.project_config_error = Exception("No project config")
+
+    DummyTask._run_task = Mock()
+    multi_cmd = task.RunTaskCommand()
+
+    # Should NOT raise an exception because the task is global
+    with click.Context(multi_cmd, obj=runtime) as ctx:
+        cmd = multi_cmd.get_command(ctx, "global-dummy-task")
+        cmd.callback(runtime, "global-dummy-task", color="blue")
+
+    # Verify the task was executed
+    DummyTask._run_task.assert_called_once()
+
+
 def test_task_run__debug_before(runtime):
     DummyTask._run_task = Mock()
     multi_cmd = task.RunTaskCommand()
@@ -277,6 +307,10 @@ def test_task_run__loadenv_with_project_root(load_dotenv, runtime):
     with tempfile.TemporaryDirectory() as temp_dir:
         runtime.project_config._repo_info = {"root": temp_dir}
 
+        # Create the .env file so it exists
+        env_path = Path(temp_dir) / ".env"
+        env_path.write_text("TEST_VAR=test_value\n")
+
         multi_cmd = task.RunTaskCommand()
         with click.Context(multi_cmd, obj=runtime) as ctx:
             cmd = multi_cmd.get_command(ctx, "dummy-task")

cumulusci/core/config/__init__.py

@@ -68,6 +68,7 @@ class TaskConfig(BaseConfig):
     name: str
     checks: list
     project_config: "BaseProjectConfig"
+    is_global: bool
 
     # TODO: What if an intermediate repo "allows" a downstream repo?
     #       Only the top repo should be allowed to do so.

cumulusci/core/config/org_config.py

@@ -63,7 +63,7 @@ class OrgConfig(BaseConfig):
     client_secret: str
     connected_app: str
     serialization_format: str
-
+    org_name: str
     createable: Optional[bool] = None
 
     # make sure it can be mocked for tests
@@ -246,6 +246,7 @@ class OrgConfig(BaseConfig):
             "is_sandbox": self._org_sobject["IsSandbox"],
             "instance_name": self._org_sobject["InstanceName"],
             "namespace": self._org_sobject["NamespacePrefix"],
+            "org_name": self._org_sobject["Name"],
         }
         self.config.update(result)
 

cumulusci/core/config/project_config.py

@@ -452,6 +452,18 @@ class BaseProjectConfig(BaseTaskFlowConfig, ProjectConfigPropertiesMixin):
                         ):
                             return parts[0]
 
+    @property
+    def is_dependency_flow(self) -> bool:
+        return (
+            False
+            if self.executing_dependency_flow is None
+            else self.executing_dependency_flow
+        )
+
+    @is_dependency_flow.setter
+    def is_dependency_flow(self, value: bool):
+        self.executing_dependency_flow = value
+
     def get_repo(self) -> AbstractRepo:
         repo = self.repo_service.get_repository()
         if repo is None:

cumulusci/core/config/scratch_org_config.py

@@ -162,6 +162,18 @@ class ScratchOrgConfig(SfdxOrgConfig):
             args += ["-a", self.sfdx_alias]
         with open(self.config_file, "r") as org_def:
             org_def_data = json.load(org_def)
+            if (
+                "orgName" in org_def_data
+                and org_def_data["orgName"] is not None
+                and self.keychain.project_config.project__name is not None
+            ):
+                org_def_data["orgName"] = (
+                    org_def_data["orgName"]
+                    .replace(
+                        "%%%PROJECT_NAME%%%", self.keychain.project_config.project__name
+                    )
+                    .replace("%%%CONFIG_NAME%%%", self.name.upper())
+                )
             org_def_has_email = "adminEmail" in org_def_data
         if self.email_address and not org_def_has_email:
             args += [f"--admin-email={self.email_address}"]

cumulusci/core/config/tests/test_config.py

@@ -1222,6 +1222,7 @@ class TestOrgConfig:
                 "IsSandbox": False,
                 "InstanceName": "cs420",
                 "NamespacePrefix": "ns",
+                "Name": "Test Org",
             },
         )
 

cumulusci/core/dependencies/base.py

@@ -738,11 +738,15 @@ class UnmanagedVcsDependencyFlow(UnmanagedStaticDependency, ABC):
             )
         )
 
+        project_config.is_dependency_flow = True
+
         start_time = datetime.now()
         coordinator.run(org)
         duration = datetime.now() - start_time
         context.logger.info(f"Ran {self.flow_name} in {format_duration(duration)}")
 
+        project_config.is_dependency_flow = False
+
 
 class BasePackageVersionDependency(StaticDependency, ABC):
     @abstractmethod

cumulusci/cumulusci.yml

@@ -168,6 +168,10 @@ tasks:
         description: Inserts a record of any sObject using the REST API
         class_path: cumulusci.tasks.salesforce.insert_record.InsertRecord
         group: Data Operations
+    update_record:
+        description: Updates one or more records of any sObject using the REST API
+        class_path: cumulusci.tasks.salesforce.update_record.UpdateRecord
+        group: Data Operations
     create_package:
         description: Creates a package in the target org with the default package name for the project
         class_path: cumulusci.tasks.salesforce.CreatePackage
@@ -661,6 +665,12 @@ tasks:
         class_path: cumulusci.tasks.metadata_etl.SetOrgWideDefaults
         options:
             namespace_inject: $project_config.project__package__namespace
+    add_applications_profile_action_overrides:
+        group: Metadata Transformations
+        description: Adds or updates profile action overrides to the Custom Applications.
+        class_path: cumulusci.tasks.metadata_etl.applications.AddProfileActionOverrides
+        options:
+            namespace_inject: $project_config.project__package__namespace
     strip_unwanted_components:
         description: Removes components from src folder which are not mentioned in given package.xml file
         class_path: cumulusci.tasks.metadata.package.RemoveUnwantedComponents
@@ -761,10 +771,12 @@ tasks:
         description: "Copy a file for src to dest with environment variable support, Ex: &TMPDIR&/src resolves to /tmp/src on linux or %TMPDIR%/src on windows."
         class_path: cumulusci.tasks.util.CopyFile
         group: Utilities
+        is_global: True
     load_dot_env:
         description: "Log the contents of the .env file"
         class_path: cumulusci.tasks.util.LoadDotEnv
         group: Utilities
+        is_global: True
     configure_env:
         description: Get or set environment variables.
         class_path: cumulusci.tasks.utility.env_management.EnvManagement
@@ -773,6 +785,7 @@ tasks:
         description: Get all environment variables from a target JSON file and generates a .env file that can be used to set up the environment variables for the deployment
         class_path: cumulusci.tasks.utility.secretsToEnv.SecretsToEnv
         group: Utilities
+        is_global: True
     directory_recreator:
         description: Remove and recreate a directory
         class_path: cumulusci.tasks.utility.directoryRecreator.DirectoryRecreator
@@ -874,6 +887,10 @@ tasks:
         class_path: cumulusci.tasks.salesforce.update_external_credential.UpdateExternalCredential
         description: Update external credential parameters
         group: Metadata Transformations
+    update_external_auth_identity_provider:
+        class_path: cumulusci.tasks.salesforce.update_external_auth_identity_provider.UpdateExternalAuthIdentityProvider
+        description: Update external auth identity provider parameters and credentials
+        group: Metadata Transformations
 
 flows:
     ci_beta:
@@ -1617,7 +1634,7 @@ project:
         apex_test_access:
         package_metadata_access:
         unpackaged_metadata_path:
-        api_version: "63.0"
+        api_version: "64.0"
     git:
         default_branch: master
         prefix_feature: feature/

cumulusci/schema/cumulusci.jsonschema.json

@@ -122,6 +122,11 @@
                 "name": {
                     "title": "Name",
                     "type": "string"
+                },
+                "is_global": {
+                    "title": "Is Global",
+                    "default": false,
+                    "type": "boolean"
                 }
             },
             "additionalProperties": false

cumulusci/tasks/apex/testrunner.py

@@ -246,7 +246,8 @@ class RunApexTests(BaseSalesforceApiTask):
             description="Defines a dynamic filter to apply to test classes from the org that match test_name_match. Supported values: "
             "'package_only' - only runs test classes that exist in the default package directory (force-app/ or src/),"
             "'delta_changes' - only runs test classes that are affected by the delta changes in the current branch (force-app/ or src/),"
-            "Default is None, which means no dynamic filter is applied and all test classes from the org that match test_name_match are run.",
+            "Default is None, which means no dynamic filter is applied and all test classes from the org that match test_name_match are run."
+            "Setting this option, the org code coverage will not be calculated.",
         )
         base_ref: Optional[str] = Field(
             None,
@@ -897,12 +898,14 @@ class RunApexTests(BaseSalesforceApiTask):
             )
 
         if self.code_coverage_level or self.required_per_class_code_coverage_percent:
-            if self.parsed_options.namespace not in self.org_config.installed_packages:
-                self._check_code_coverage()
-            else:
+            if self.parsed_options.managed:
                 self.logger.info(
                     "This org contains a managed installation; not checking code coverage."
                 )
+            elif self.parsed_options.dynamic_filter is not None:
+                self.logger.info("Dynamic filter is set; not checking code coverage.")
+            else:
+                self._check_code_coverage()
         else:
             self.logger.info(
                 "No code coverage level specified; not checking code coverage."

cumulusci/tasks/bulkdata/tests/test_select_utils.py

@@ -624,6 +624,10 @@ def test_vectorize_records_mixed_numerical_boolean_categorical():
     sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
     reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
 )
+@pytest.mark.skipif(
+    sys.platform == "linux" and sys.version_info[:2] == (3, 12),
+    reason="Annoy library has known compatibility issues on Linux with Python 3.12",
+)
 def test_annoy_post_process():
     # Test data
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]
@@ -658,6 +662,10 @@ def test_annoy_post_process():
     sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
     reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
 )
+@pytest.mark.skipif(
+    sys.platform == "linux" and sys.version_info[:2] == (3, 12),
+    reason="Annoy library has known compatibility issues on Linux with Python 3.12",
+)
 def test_annoy_post_process__insert_records():
     # Test data
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]
@@ -707,6 +715,10 @@ def test_annoy_post_process__insert_records():
     sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
     reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
 )
+@pytest.mark.skipif(
+    sys.platform == "linux" and sys.version_info[:2] == (3, 12),
+    reason="Annoy library has known compatibility issues on Linux with Python 3.12",
+)
 def test_annoy_post_process__no_query_records():
     # Test data
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]
@@ -743,6 +755,10 @@ def test_annoy_post_process__no_query_records():
     sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
     reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
 )
+@pytest.mark.skipif(
+    sys.platform == "linux" and sys.version_info[:2] == (3, 12),
+    reason="Annoy library has known compatibility issues on Linux with Python 3.12",
+)
 def test_annoy_post_process__insert_records_with_polymorphic_fields():
     # Test data
     load_records = [
@@ -804,6 +820,10 @@ def test_annoy_post_process__insert_records_with_polymorphic_fields():
     sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
     reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
 )
+@pytest.mark.skipif(
+    sys.platform == "linux" and sys.version_info[:2] == (3, 12),
+    reason="Annoy library has known compatibility issues on Linux with Python 3.12",
+)
 def test_single_record_match_annoy_post_process():
     # Mock data where only the first query record matches the first load record
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]

cumulusci/tasks/metadata_etl/__init__.py

@@ -6,6 +6,7 @@ from cumulusci.tasks.metadata_etl.base import (
     MetadataOperation,
     UpdateMetadataFirstChildTextTask,
 )
+from cumulusci.tasks.metadata_etl.applications import AddProfileActionOverrides
 from cumulusci.tasks.metadata_etl.duplicate_rules import SetDuplicateRuleStatus
 from cumulusci.tasks.metadata_etl.layouts import AddRelatedLists
 from cumulusci.tasks.metadata_etl.objects import SetObjectSettings
@@ -18,6 +19,7 @@ flake8 = (
     BaseMetadataSynthesisTask,
     BaseMetadataTransformTask,
     MetadataSingleEntityTransformTask,
+    AddProfileActionOverrides,
     AddRelatedLists,
     AddPermissionSetPermissions,
     AddValueSetEntries,

cumulusci/tasks/metadata_etl/applications.py

@@ -0,0 +1,256 @@
+from typing import List, Optional, Set
+from urllib.parse import quote
+
+from pydantic.v1 import BaseModel
+
+from cumulusci.tasks.metadata_etl import MetadataSingleEntityTransformTask
+from cumulusci.utils import inject_namespace
+from cumulusci.utils.xml.metadata_tree import MetadataElement
+
+
+def _inject_namespace(text: str, options: dict) -> str:
+    return inject_namespace(
+        "",
+        text,
+        namespace=options["namespace_inject"]
+        if not options.get("namespaced_org")
+        else "",
+        managed=options.get("managed") or False,
+        namespaced_org=options.get("namespaced_org"),
+    )[1]
+
+
+class ProfileActionOverrideOptions(BaseModel):
+    """Options for a single profileActionOverride"""
+
+    action_name: str
+    content: str
+    form_factor: str
+    page_or_sobject_type: str
+    record_type: Optional[str]
+    type: str
+    profile: str
+    options: dict = {}
+
+    def namespace_inject(self, field_name: str) -> None:
+        setattr(
+            self, field_name, _inject_namespace(getattr(self, field_name), self.options)
+        )
+
+
+class AddProfileActionOverridesOptions(BaseModel):
+    """Options container for profile action overrides"""
+
+    name: str
+    overrides: List[ProfileActionOverrideOptions]
+
+
+class AddProfileActionOverrides(MetadataSingleEntityTransformTask):
+    """
+    Inserts or updates profileActionOverrides in CustomApplication metadata.
+    If a profileActionOverride with the same actionName, pageOrSobjectType,
+    recordType, and profile already exists, it will be updated with a warning.
+    Otherwise, a new override will be added.
+    Task option details:
+    - applications: List of CustomApplications to modify
+        - name: API name of the CustomApplication to modify
+        - overrides: List of profile action overrides to add/update
+            - action_name: Action name (e.g., "View", "Edit", "New")
+            - content: Content reference (page/component API name)
+            - form_factor: Form factor (e.g., "Large", "Small")
+            - page_or_sobject_type: Page or SObject type
+            - record_type: Record type API name (optional)
+            - type: Override type (e.g., "Flexipage", "Visualforce", "LightningComponent")
+            - profile: Profile name or API name
+    Example Usage
+    -----------------------
+    .. code-block::  yaml
+        task: add_profile_action_overrides
+        options:
+            applications:
+                - name: "%%%NAMESPACE%%%CustomApplicationConsole"
+                  overrides:
+                    - action_name: View
+                      content: "%%%NAMESPACED_ORG%%%AccountUserRecordPage"
+                      form_factor: Large
+                      page_or_sobject_type: Account
+                      record_type: PersonAccount.User
+                      type: Flexipage
+                      profile: Admin
+    """
+
+    entity = "CustomApplication"
+    task_options = {
+        "applications": {
+            "description": "List of CustomApplications to modify. See task info for structure.",
+            "required": True,
+        },
+        **MetadataSingleEntityTransformTask.task_options,
+    }
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+
+        # Validate options using Pydantic
+        self._validated_options: List[AddProfileActionOverridesOptions] = []
+        for application in self.options.get("applications"):
+            validated_options = AddProfileActionOverridesOptions(
+                name=quote(_inject_namespace(application.get("name"), self.options)),
+                overrides=application.get("overrides"),
+            )
+
+            self._validated_options.append(validated_options)
+
+        self.api_names: Set[str] = set(
+            application.name for application in self._validated_options
+        )
+
+    def _transform_entity(
+        self, metadata: MetadataElement, api_name: str
+    ) -> Optional[MetadataElement]:
+
+        if not self._validated_options:
+            self.logger.warning("No applications to add profile action overrides for")
+            return None
+
+        for application in self._validated_options:
+            if application.name != api_name:
+                continue
+
+            for override_config in application.overrides:
+                self._add_or_update_override(
+                    metadata, application.name, override_config
+                )
+
+        return metadata
+
+    def _add_or_update_override(self, metadata, api_name, override_config):
+        """Add or update a single profileActionOverride"""
+        override_config.options = self.options
+
+        # Inject namespace where needed
+        override_config.namespace_inject("content")
+        override_config.namespace_inject("page_or_sobject_type")
+        override_config.namespace_inject(
+            "record_type"
+        ) if override_config.record_type else None
+
+        # Find existing override with same key fields
+        existing_override = self._find_existing_override(metadata, override_config)
+
+        if existing_override:
+            self.logger.warning(
+                f"Updating existing profileActionOverride for {override_config.profile}/{override_config.page_or_sobject_type}/{override_config.action_name} in {api_name}"
+            )
+            # Update the existing override
+            self._update_override_element(
+                existing_override,
+                override_config,
+            )
+        else:
+            self.logger.info(
+                f"Adding profileActionOverride for {override_config.profile}/{override_config.page_or_sobject_type}/{override_config.action_name} to {api_name}"
+            )
+            # Create new override
+            self._create_new_override(metadata, override_config)
+
+    def _find_existing_override(self, metadata, override_config):
+        """
+        Find an existing profileActionOverride that matches the key fields:
+        actionName, pageOrSobjectType, recordType, and profile
+        """
+        for override_elem in metadata.findall("profileActionOverrides"):
+            elem_action = override_elem.find("actionName")
+            elem_page = override_elem.find("pageOrSobjectType")
+            elem_record_type = override_elem.find("recordType")
+            elem_profile = override_elem.find("profile")
+
+            # Match on all key fields
+            if (
+                elem_action
+                and elem_action.text == override_config.action_name
+                and elem_page
+                and elem_page.text == override_config.page_or_sobject_type
+                and elem_profile
+                and elem_profile.text == override_config.profile
+            ):
+                # Handle recordType - both must be None or both must match
+                if override_config.record_type is None and elem_record_type is None:
+                    return override_elem
+                elif (
+                    override_config.record_type is not None
+                    and elem_record_type is not None
+                    and elem_record_type.text == override_config.record_type
+                ):
+                    return override_elem
+
+        return None
+
+    def _update_override_element(
+        self,
+        override_elem,
+        override_config,
+    ):
+        """Update an existing profileActionOverride element"""
+        # Update each child element
+        # actionName
+        elem = override_elem.find("actionName")
+        if elem is not None:
+            elem.text = override_config.action_name
+
+        # content
+        elem = override_elem.find("content")
+        if elem is not None:
+            elem.text = override_config.content
+
+        # formFactor
+        elem = override_elem.find("formFactor")
+        if elem is not None:
+            elem.text = override_config.form_factor
+
+        # pageOrSobjectType
+        elem = override_elem.find("pageOrSobjectType")
+        if elem is not None:
+            elem.text = override_config.page_or_sobject_type
+
+        # recordType (optional)
+        elem = override_elem.find("recordType")
+        if override_config.record_type:
+            if elem is not None:
+                elem.text = override_config.record_type
+        elif elem is not None:
+            # Remove recordType if it exists but shouldn't
+            override_elem.remove(elem)
+
+        # type
+        elem = override_elem.find("type")
+        if elem is not None:
+            elem.text = override_config.type
+
+        # profile
+        elem = override_elem.find("profile")
+        if elem is not None:
+            elem.text = override_config.profile
+
+    def _create_new_override(
+        self,
+        metadata,
+        override_config,
+    ):
+        """Create a new profileActionOverride element with proper ordering"""
+        override_elem = metadata.append("profileActionOverrides")
+
+        # Add elements in the correct order per Salesforce metadata API
+        override_elem.append("actionName", text=override_config.action_name)
+        override_elem.append("content", text=override_config.content)
+        override_elem.append("formFactor", text=override_config.form_factor)
+        override_elem.append(
+            "pageOrSobjectType", text=override_config.page_or_sobject_type
+        )
+
+        # recordType is optional
+        if override_config.record_type:
+            override_elem.append("recordType", text=override_config.record_type)
+
+        override_elem.append("type", text=override_config.type)
+        override_elem.append("profile", text=override_config.profile)