cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/salesforce/tests/test_update_dependencies.py

@@ -0,0 +1,509 @@
+import io
+import logging
+import zipfile
+from unittest import mock
+
+import pydantic
+import pytest
+
+from cumulusci.core.dependencies.dependencies import (
+    PackageNamespaceVersionDependency,
+    PackageVersionIdDependency,
+)
+from cumulusci.core.dependencies.github import (
+    GitHubDynamicDependency,
+    UnmanagedGitHubRefDependency,
+)
+from cumulusci.core.dependencies.resolvers import (
+    DependencyResolutionStrategy,
+    get_resolver_stack,
+)
+from cumulusci.core.exceptions import (
+    CumulusCIException,
+    DependencyParseError,
+    TaskOptionsError,
+)
+from cumulusci.core.flowrunner import StepSpec
+from cumulusci.tasks.salesforce.update_dependencies import UpdateDependencies
+from cumulusci.tests.util import create_project_config
+
+from .util import create_task
+
+
+def make_fake_zipfile(*args, **kw):
+    return zipfile.ZipFile(io.BytesIO(), "w")
+
+
+def test_init_options_base():
+    project_config = create_project_config()
+
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "namespace": "ns",
+                    "version": "1.0",
+                },
+                {"version_id": "04t000000000000"},
+                {"github": "https://github.com/Test/TestRepo"},
+            ],
+            "resolution_strategy": "production",
+        },
+        project_config=project_config,
+    )
+
+    assert task.dependencies == [
+        PackageNamespaceVersionDependency(namespace="ns", version="1.0"),
+        PackageVersionIdDependency(version_id="04t000000000000"),
+        GitHubDynamicDependency(github="https://github.com/Test/TestRepo"),
+    ]
+    assert task.resolution_strategy == get_resolver_stack(project_config, "production")
+
+
+def test_init_options_error_bad_dependencies():
+    with pytest.raises(DependencyParseError):
+        create_task(
+            UpdateDependencies,
+            {
+                "dependencies": [
+                    {
+                        "namespace": "ns",
+                        "version_id": "04t000000000000",
+                    }
+                ]
+            },
+        )
+
+
+def test_init_options_warns_deprecated_options(caplog):
+    with caplog.at_level(logging.INFO):
+        create_task(
+            UpdateDependencies,
+            {
+                "dependencies": [
+                    {
+                        "namespace": "ns",
+                        "version": "1.0",
+                    }
+                ],
+                "allow_uninstalls": False,
+                "include_beta": True,
+            },
+        )
+
+        assert "no longer supported" in caplog.text
+        assert "Use resolution strategies instead" in caplog.text
+
+
+def test_init_options_error_bad_ignore_dependencies():
+    with pytest.raises(TaskOptionsError):
+        create_task(
+            UpdateDependencies,
+            {
+                "dependencies": [
+                    {
+                        "namespace": "ns",
+                        "version": "1.0",
+                    }
+                ],
+                "ignore_dependencies": [{"foo": "bar"}],
+            },
+        )
+
+
+def test_init_options_uses_include_beta_strategy_for_include_beta_true():
+    org_config = mock.Mock()
+    org_config.scratch = True
+
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "namespace": "ns",
+                    "version": "1.0",
+                }
+            ],
+            "include_beta": True,
+            "resolution_strategy": "production",
+        },
+        org_config=org_config,
+    )
+
+    assert DependencyResolutionStrategy.BETA_RELEASE_TAG in task.resolution_strategy
+
+
+def test_init_options_removes_beta_resolver_for_include_beta_false():
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "namespace": "ns",
+                    "version": "1.0",
+                }
+            ],
+            "resolution_strategy": "include_beta",
+            "include_beta": False,
+        },
+    )
+
+    assert DependencyResolutionStrategy.BETA_RELEASE_TAG not in task.resolution_strategy
+
+
+def test_init_options_removes_2gp_resolver_for_prefer_2gp_false():
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "namespace": "ns",
+                    "version": "1.0",
+                }
+            ],
+            "resolution_strategy": "include_beta",
+            "prefer_2gp_from_release_branch": False,
+        },
+    )
+
+    assert (
+        DependencyResolutionStrategy.COMMIT_STATUS_RELEASE_BRANCH
+        not in task.resolution_strategy
+    )
+
+
+def test_init_options_removes_unsafe_resolvers_persistent_org():
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "namespace": "ns",
+                    "version": "1.0",
+                }
+            ],
+            "resolution_strategy": "include_beta",
+        },
+    )
+    task.org_config = mock.Mock()
+    task.org_config.scratch = False
+
+    assert DependencyResolutionStrategy.BETA_RELEASE_TAG not in task.resolution_strategy
+    assert (
+        DependencyResolutionStrategy.COMMIT_STATUS_RELEASE_BRANCH
+        not in task.resolution_strategy
+    )
+
+
+def test_run_task_gets_static_dependencies_and_installs():
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "namespace": "ns",
+                    "version": "1.0",
+                },
+                {"version_id": "04t000000000000"},
+            ],
+            "resolution_strategy": "production",
+            "ignore_dependencies": [{"github": "https://github.com/Test/TestRepo"}],
+            "security_type": "PUSH",
+        },
+    )
+
+    task._install_dependency = mock.Mock()
+    task()
+
+    task._install_dependency.assert_has_calls(
+        [
+            mock.call(PackageNamespaceVersionDependency(namespace="ns", version="1.0")),
+            mock.call(PackageVersionIdDependency(version_id="04t000000000000")),
+        ]
+    )
+
+
+@mock.patch("cumulusci.tasks.salesforce.update_dependencies.click.confirm")
+def test_run_task_gets_static_dependencies_and_installs__interactive(confirm):
+    confirm.return_value = True
+
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "namespace": "ns",
+                    "version": "1.0",
+                },
+                {"version_id": "04t000000000000"},
+            ],
+            "resolution_strategy": "production",
+            "ignore_dependencies": [{"github": "https://github.com/Test/TestRepo"}],
+            "security_type": "PUSH",
+            "interactive": True,
+        },
+    )
+
+    task._install_dependency = mock.Mock()
+    task()
+
+    task._install_dependency.assert_has_calls(
+        [
+            mock.call(PackageNamespaceVersionDependency(namespace="ns", version="1.0")),
+            mock.call(PackageVersionIdDependency(version_id="04t000000000000")),
+        ]
+    )
+
+    with pytest.raises(CumulusCIException) as e:
+        task._install_dependency.reset_mock()
+        confirm.return_value = False
+        task()
+
+    task._install_dependency.assert_not_called()
+    assert "canceled" in str(e)
+
+
+def test_run_task_gets_static_dependencies_and_installs__packages_only():
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "namespace": "ns",
+                    "version": "1.0",
+                },
+                {
+                    "github": "https://github.com/TestRepo/Test",
+                    "ref": "aaaa",
+                    "subfolder": "foo",
+                },
+            ],
+            "resolution_strategy": "production",
+            "security_type": "PUSH",
+            "packages_only": True,
+        },
+    )
+
+    task._install_dependency = mock.Mock()
+    task()
+
+    assert task._install_dependency.call_count == 1
+    task._install_dependency.assert_has_calls(
+        [
+            mock.call(PackageNamespaceVersionDependency(namespace="ns", version="1.0")),
+        ]
+    )
+
+
+def test_run_task_exits_no_dependencies():
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [],
+            "resolution_strategy": "production",
+            "ignore_dependencies": [{"github": "https://github.com/Test/TestRepo"}],
+            "security_type": "PUSH",
+        },
+    )
+
+    task._install_dependency = mock.Mock()
+    task()
+
+    task._install_dependency.assert_not_called()
+
+
+@mock.patch(
+    "cumulusci.core.dependencies.dependencies.install_package_by_namespace_version"
+)
+def test_install_dependency_installs_managed_package(
+    install_package_by_namespace_version,
+):
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "namespace": "ns",
+                    "version": "1.0",
+                }
+            ]
+        },
+    )
+    task.org_config = mock.Mock()
+    task.org_config.installed_packages = {}
+    task.org_config.has_minimum_package_version.return_value = False
+
+    task._install_dependency(task.dependencies[0])
+    install_package_by_namespace_version.assert_called_once_with(
+        task.project_config,
+        task.org_config,
+        "ns",
+        "1.0",
+        mock.ANY,
+        retry_options=mock.ANY,  # Ignore the options
+    )
+
+
+def test_install_dependency_installs_unmanaged():
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "zip_url": "http://example.com/foo",
+                }
+            ]
+        },
+    )
+    task.dependencies[0].__config__.extra = pydantic.Extra.allow
+    task.dependencies[0].install = mock.Mock()
+    task.org_config = mock.Mock()
+
+    task._install_dependency(task.dependencies[0])
+    task.dependencies[0].install.assert_called_once_with(
+        task.project_config, task.org_config
+    )
+
+
+@mock.patch("cumulusci.tasks.salesforce.update_dependencies.get_static_dependencies")
+def test_freeze(get_static_dependencies):
+    get_static_dependencies.return_value = [
+        PackageNamespaceVersionDependency(namespace="ns", version="1.0"),
+        UnmanagedGitHubRefDependency(
+            github="https://github.com/SFDO-Tooling/CumulusCI-Test",
+            ref="abcdef",
+            subfolder="src",
+        ),
+    ]
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "namespace": "ns",
+                    "version": "1.0",
+                },
+                {
+                    "github": "https://github.com/SFDO-Tooling/CumulusCI-Test",
+                    "ref": "abcdef",
+                    "subfolder": "src",
+                },
+            ]
+        },
+    )
+    step = StepSpec(1, "test_task", task.task_config, None, task.project_config)
+    steps = task.freeze(step)
+
+    assert [
+        {
+            "is_required": True,
+            "kind": "managed",
+            "name": "Install ns 1.0",
+            "path": "test_task.1",
+            "step_num": "1.1",
+            "source": None,
+            "task_class": None,
+            "task_config": {
+                "options": {
+                    "dependencies": [{"namespace": "ns", "version": "1.0"}],
+                    "packages_only": False,
+                    "interactive": False,
+                    "base_package_url_format": "{}",
+                },
+                "checks": [],
+            },
+        },
+        {
+            "is_required": True,
+            "kind": "metadata",
+            "name": "Deploy https://github.com/SFDO-Tooling/CumulusCI-Test",
+            "path": "test_task.2",
+            "step_num": "1.2",
+            "source": None,
+            "task_class": None,
+            "task_config": {
+                "options": {
+                    "dependencies": [
+                        {
+                            "ref": "abcdef",
+                            "github": "https://github.com/SFDO-Tooling/CumulusCI-Test",
+                            "subfolder": "src",
+                            "url": "https://github.com/SFDO-Tooling/CumulusCI-Test",
+                        },
+                    ],
+                    "packages_only": False,
+                    "interactive": False,
+                    "base_package_url_format": "{}",
+                },
+                "checks": [],
+            },
+        },
+    ] == steps
+
+
+@mock.patch("cumulusci.tasks.salesforce.update_dependencies.get_static_dependencies")
+def test_freeze__packages_only(get_static_dependencies):
+    get_static_dependencies.return_value = [
+        PackageNamespaceVersionDependency(namespace="ns", version="1.0"),
+        UnmanagedGitHubRefDependency(
+            github="https://github.com/SFDO-Tooling/CumulusCI-Test",
+            ref="abcdef",
+            subfolder="src",
+        ),
+    ]
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [
+                {
+                    "namespace": "ns",
+                    "version": "1.0",
+                },
+                {
+                    "github": "https://github.com/SFDO-Tooling/CumulusCI-Test",
+                    "ref": "abcdef",
+                    "subfolder": "src",
+                },
+            ],
+            "packages_only": True,
+        },
+    )
+    step = StepSpec(1, "test_task", task.task_config, None, task.project_config)
+    steps = task.freeze(step)
+
+    assert [
+        {
+            "is_required": True,
+            "kind": "managed",
+            "name": "Install ns 1.0",
+            "path": "test_task.1",
+            "step_num": "1.1",
+            "source": None,
+            "task_class": None,
+            "task_config": {
+                "options": {
+                    "dependencies": [{"namespace": "ns", "version": "1.0"}],
+                    "packages_only": True,
+                    "interactive": False,
+                    "base_package_url_format": "{}",
+                },
+                "checks": [],
+            },
+        }
+    ] == steps
+
+
+def test_freeze__interactive_exception():
+    task = create_task(
+        UpdateDependencies,
+        {
+            "dependencies": [],
+            "interactive": True,
+        },
+    )
+    step = StepSpec(1, "test_task", task.task_config, None, task.project_config)
+    with pytest.raises(CumulusCIException) as e:
+        task.freeze(step)
+
+    assert "cannot be frozen" in str(e)

cumulusci/tasks/salesforce/tests/util.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from unittest import mock
+
+from cumulusci.core.config import TaskConfig
+from cumulusci.core.config.org_config import OrgConfig
+from cumulusci.tests.util import DummyKeychain, create_project_config
+
+
+def create_task(task_class, options=None, project_config=None, org_config=None):
+    "Older create_task helper which does not support orginfo cache."
+    if project_config is None:
+        project_config = create_project_config("TestRepo", "TestOwner")
+    if org_config is None:
+        org_config = OrgConfig(
+            {
+                "instance_url": "https://test.salesforce.com",
+                "id": "https://test.salesforce.com/ORG_ID/USER_ID",
+                "access_token": "TOKEN",
+                "org_id": "ORG_ID",
+                "username": "test-cci@example.com",
+            },
+            "test",
+            keychain=DummyKeychain(),
+        )
+        org_config.refresh_oauth_token = mock.Mock()
+    if options is None:
+        options = {}
+    task_config = TaskConfig({"options": options})
+    with mock.patch(
+        "cumulusci.core.tasks.BaseSalesforceTask._get_client_name",
+        return_value="ccitests",
+    ):
+        with mock.patch(
+            "cumulusci.core.config.org_config.OrgConfig.installed_packages",
+            return_value=[],
+        ):
+            return task_class(project_config, task_config, org_config)
+
+
+def patch_dir(patch_path, file_path):
+    def return_file_path(*args, **kwargs):
+        """
+        Python 3.11 removed pathlib._Accessor. This replaced a call to
+        os.getcwd() with Path.cwd() in Path.absolute(). This means we can have 0
+        or 1 arguments.
+        """
+        return file_path
+
+    directory = Path(file_path)
+    directory.mkdir(parents=True, exist_ok=True)
+    patch = mock.patch(patch_path, return_file_path)
+    patch.start()
+    return patch
+
+
+def create_task_fixture(request):
+    "create_task fixture which does support orginfo cache."
+    temp_dirs = TemporaryDirectory()
+    temp_root = Path(temp_dirs.name)
+
+    to_patch = {
+        "pathlib.Path.home": temp_root / "fixture_user_home",
+        "pathlib.Path.cwd": temp_root / "fixture_user_home/project",
+    }
+
+    pretend_git = temp_root / "fixture_user_home/project/.git"
+    pretend_git.mkdir(parents=True)
+    patches = [patch_dir(p, d) for p, d in to_patch.items()]
+
+    def fin():
+        for patch in patches:
+            patch.stop()
+
+        temp_dirs.cleanup()
+
+    request.addfinalizer(fin)
+
+    return create_task

cumulusci/tasks/salesforce/trigger_handlers.py

@@ -0,0 +1,119 @@
+from collections import defaultdict
+from contextlib import contextmanager
+
+import yaml
+
+from cumulusci.core.exceptions import CumulusCIException, TaskOptionsError
+from cumulusci.core.utils import process_bool_arg, process_list_arg
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+from cumulusci.utils.fileutils import FSResource, open_fs_resource
+
+
+class SetTDTMHandlerStatus(BaseSalesforceApiTask):
+    """Alter the active status of specific NPSP or EDA TDTM trigger handlers.
+    Save a state file to allow the handlers to be restored to their previous status.
+    """
+
+    task_options = {
+        "handlers": {
+            "description": "List of Trigger Handlers (by Class, Object, or 'Class:Object') to affect (defaults to all handlers)."
+        },
+        "namespace": {
+            "description": "The namespace of the Trigger Handler object ('eda' or 'npsp'). The task will apply the namespace if needed."
+        },
+        "active": {
+            "description": "True or False to activate or deactivate trigger handlers."
+        },
+        "restore_file": {
+            "description": "Path to the state file to store or restore the current trigger handler state. Set to False to discard trigger state information. By default the state is cached in an org-specific directory for later restore."
+        },
+        "restore": {
+            "description": "If True, restore the state of Trigger Handlers to that stored in the (specified or default) restore file."
+        },
+    }
+    should_restore = False
+    should_save = False
+
+    def _init_options(self, kwargs):
+        super(SetTDTMHandlerStatus, self)._init_options(kwargs)
+        self.options["handlers"] = process_list_arg(self.options.get("handlers", []))
+        self.options["active"] = process_bool_arg(self.options.get("active") or False)
+        has_restore_file = (
+            self.options.get("restore_file") is not False
+            and self.options.get("restore_file") != "False"
+        )
+        should_restore = process_bool_arg(self.options.get("restore", False))
+        if should_restore:
+            if not has_restore_file:
+                raise TaskOptionsError("Restoring requires a restore file name")
+            self.should_restore = True
+        else:
+            self.should_save = has_restore_file
+
+    @contextmanager
+    def _default_restore_resource(self):
+        with self.org_config.get_orginfo_cache_dir(self.__module__) as cache:
+            yield cache / "trigger_status.yml"
+
+    def _run_task(self):
+        restore_path = self.options.get("restore_file")
+        if restore_path:
+            restore_file = open_fs_resource(restore_path)
+        else:
+            restore_file = self._default_restore_resource()
+
+        with restore_file as f:
+            self._do_trigger_handlers(f)
+
+    def _do_trigger_handlers(self, restore_file: FSResource):
+        global_describe = self.sf.describe()
+        sobject_names = [x["name"] for x in global_describe["sobjects"]]
+
+        if self.should_restore:
+            with restore_file.open("r") as f:
+                target_status = yaml.safe_load(f)
+                self.options["handlers"] = list(target_status.keys())
+        else:
+            target_status = defaultdict(lambda: self.options["active"])
+
+        namespace = self.options.get("namespace", "") + "__"
+        if f"{namespace}Trigger_Handler__c" in sobject_names:
+            pass
+        elif "Trigger_Handler__c" in sobject_names:
+            namespace = ""
+        else:
+            raise CumulusCIException(
+                "Unable to locate the Trigger Handler sObject. "
+                "Ensure the namespace option is set correctly."
+            )
+
+        proxy_obj = getattr(self.sf, f"{namespace}Trigger_Handler__c")
+        trigger_handlers = self.sf.query(
+            f"SELECT Id, {namespace}Class__c, {namespace}Object__c, {namespace}Active__c FROM {namespace}Trigger_Handler__c"
+        )
+
+        current_status = {}
+
+        for handler in trigger_handlers.get("records", []):
+            class_name = handler[f"{namespace}Class__c"]
+            object_name = handler[f"{namespace}Object__c"]
+            compound_name = f"{object_name}:{class_name}"
+
+            if not self.options["handlers"] or any(
+                [
+                    class_name in self.options["handlers"],
+                    object_name in self.options["handlers"],
+                    compound_name in self.options["handlers"],
+                ]
+            ):
+                current_status[compound_name] = handler[f"{namespace}Active__c"]
+                proxy_obj.update(
+                    handler["Id"],
+                    {f"{namespace}Active__c": target_status[compound_name]},
+                )
+
+        if self.should_save:
+            with restore_file.open("w") as f:
+                yaml.safe_dump(current_status, f)
+        elif self.should_restore:
+            restore_file.unlink()