cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/preflight/licenses.py

@@ -0,0 +1,86 @@
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class BaseUserLicenseAwareTask(BaseSalesforceApiTask):
+    def get_available_user_licenses(self, is_assignable=False):
+        """Fetch active user licenses with availability."""
+        query = "SELECT Id, LicenseDefinitionKey, TotalLicenses, UsedLicenses FROM UserLicense WHERE Status = 'Active'"
+        return {
+            lic["Id"]: lic
+            for lic in self.sf.query(query)["records"]
+            if not is_assignable or (lic["TotalLicenses"] > lic["UsedLicenses"])
+        }
+
+    def _log_list(self, title, items):
+        self.logger.info(
+            f"{title} ({len(items)}):\n" + "\n".join(f"- {item}" for item in items)
+        )
+
+
+class GetAvailableLicenses(BaseUserLicenseAwareTask):
+    def _run_task(self):
+        self.return_values = [
+            result["LicenseDefinitionKey"]
+            for result in self.get_available_user_licenses().values()
+        ]
+        licenses = "\n".join(self.return_values)
+        self.logger.info(f"Found licenses:\n{licenses}")
+
+
+class GetAssignableLicenses(BaseUserLicenseAwareTask):
+    def _run_task(self):
+        self.return_values = [
+            result["LicenseDefinitionKey"]
+            for result in self.get_available_user_licenses(is_assignable=True).values()
+        ]
+        licenses = "\n".join(self.return_values)
+        self.logger.info(f"Found assignable licenses:\n{licenses}")
+
+
+class GetAvailablePermissionSetLicenses(BaseSalesforceApiTask):
+    def _run_task(self):
+        query = "SELECT PermissionSetLicenseKey FROM PermissionSetLicense WHERE Status = 'Active'"
+        self.return_values = [
+            result["PermissionSetLicenseKey"]
+            for result in self.sf.query(query)["records"]
+        ]
+        licenses = "\n".join(self.return_values)
+        self.logger.info(f"Found permission set licenses:\n{licenses}")
+
+
+class GetPermissionLicenseSetAssignments(BaseSalesforceApiTask):
+    def _run_task(self):
+        query = f"SELECT PermissionSetLicense.DeveloperName FROM PermissionSetLicenseAssign WHERE AssigneeId = '{self.org_config.user_id}'"
+        self.return_values = [
+            result["PermissionSetLicense"]["DeveloperName"]
+            for result in self.sf.query_all(query)["records"]
+        ]
+        permsets = "\n".join(self.return_values)
+        self.logger.info(f"Found permission licenses sets assigned:\n{permsets}")
+
+
+class GetAvailablePermissionSets(BaseSalesforceApiTask):
+    def _run_task(self):
+        self.return_values = [
+            result["Name"]
+            for result in self.sf.query_all("SELECT Name FROM PermissionSet")["records"]
+        ]
+        permsets = "\n".join(self.return_values)
+        self.logger.info(f"Found Permission Sets:\n{permsets}")
+
+
+class GetAssignablePermissionSets(BaseUserLicenseAwareTask):
+    def _run_task(self):
+        license_data = self.get_available_user_licenses(is_assignable=True)
+        permsets = self.sf.query_all("SELECT LicenseId, Name FROM PermissionSet")[
+            "records"
+        ]
+        available_permsets = [
+            ps["Name"]
+            for ps in permsets
+            if not ps["LicenseId"] or ps["LicenseId"] in license_data
+        ]
+
+        self.return_values = available_permsets
+        permsets = "\n".join(self.return_values)
+        self.logger.info(f"Found assignable permission sets:\n{permsets}")

cumulusci/tasks/preflight/packages.py

@@ -0,0 +1,14 @@
+from pprint import pformat
+
+from cumulusci.salesforce_api.metadata import ApiRetrieveInstalledPackages
+from cumulusci.tasks.salesforce import BaseSalesforceMetadataApiTask
+
+
+class GetInstalledPackages(BaseSalesforceMetadataApiTask):
+    api_class = ApiRetrieveInstalledPackages
+    name = "GetInstalledPackages"
+
+    def _run_task(self):
+        result = super()._run_task()
+
+        self.logger.info(f"{self.__class__.name} returned\n {pformat(result)}")

cumulusci/tasks/preflight/permsets.py

@@ -0,0 +1,23 @@
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class GetPermissionSetAssignments(BaseSalesforceApiTask):
+    def _run_task(self):
+        query = f"SELECT PermissionSet.Name,PermissionSetGroupId FROM PermissionSetAssignment WHERE AssigneeId = '{self.org_config.user_id}'"
+
+        self.return_values = []
+        for result in self.sf.query_all(query)["records"]:
+            if result["PermissionSet"]["Name"] not in self.return_values:
+                self.return_values.append(result["PermissionSet"]["Name"])
+            if result["PermissionSetGroupId"] is not None:
+                psg_query = f"SELECT PermissionSet.Name from PermissionSetGroupComponent where PermissionSetGroupId = '{result['PermissionSetGroupId']}'"
+                for psg_result in self.sf.query_all(psg_query)["records"]:
+                    if (
+                        psg_result["PermissionSet"]
+                        and psg_result["PermissionSet"]["Name"]
+                        not in self.return_values
+                    ):
+                        self.return_values.append(psg_result["PermissionSet"]["Name"])
+
+        permsets_str = "\n".join(self.return_values)
+        self.logger.info(f"Found permission sets assigned:\n{permsets_str}")

cumulusci/tasks/preflight/recordtypes.py

@@ -0,0 +1,16 @@
+from collections import defaultdict
+
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class CheckSObjectRecordTypes(BaseSalesforceApiTask):
+    def _run_task(self):
+        rts = defaultdict(list)
+        records = self.tooling.query_all(
+            "Select SobjectType, FullName FROM RecordType"
+        )["records"]
+        for r in records:
+            rts[r["SobjectType"]].append(r["FullName"].split(".")[1])
+
+        self.return_values = rts
+        self.logger.info(f"Found existing Record Types: {self.return_values}")

cumulusci/tasks/preflight/retrieve_tasks.py

@@ -0,0 +1,30 @@
+from typing import List
+
+from cumulusci.cli.runtime import CliRuntime
+from cumulusci.cli.utils import group_items
+from cumulusci.core.exceptions import CumulusCIException
+from cumulusci.core.tasks import BaseTask
+
+
+class RetrieveTasks(BaseTask):
+    task_options = {
+        "group_name": {
+            "description": "Name of the category or Group",
+            "required": True,
+        },
+    }
+
+    def _run_task(self):
+        runtime = CliRuntime(load_keychain=True)
+        tasks = runtime.get_available_tasks()
+        task_groups = group_items(tasks)
+        task_groups = task_groups[self.options["group_name"]]
+        self.return_values: List[str] = []
+        for task_name, description in task_groups:
+            self.return_values.append(task_name)
+        if self.return_values:
+            self.return_values.sort()
+        else:
+            raise CumulusCIException("No tasks in the specified group")
+
+        self.logger.info(self.return_values)

cumulusci/tasks/preflight/settings.py

@@ -0,0 +1,77 @@
+from simple_salesforce.exceptions import SalesforceMalformedRequest
+
+from cumulusci.core.tasks import BaseSalesforceTask
+from cumulusci.core.utils import process_bool_arg
+from cumulusci.tasks.salesforce.BaseSalesforceApiTask import BaseSalesforceApiTask
+
+
+class CheckMyDomainActive(BaseSalesforceTask):
+    def _run_task(self):
+        self.return_values = (
+            ".my." in self.org_config.instance_url
+            or ".cloudforce.com" in self.org_config.instance_url
+        )
+
+        self.logger.info(
+            f"Completed My Domain preflight check with result {self.return_values}"
+        )
+
+
+class CheckSettingsValue(BaseSalesforceApiTask):
+    task_options = {
+        "settings_type": {
+            "description": "The API name of the Settings entity to be checked, such as ChatterSettings.",
+            "required": True,
+        },
+        "settings_field": {
+            "description": "The API name of the field on the Settings entity to check.",
+            "required": True,
+        },
+        "value": {"description": "The value to check for", "required": True},
+        "treat_missing_as_failure": {
+            "description": "If True, treat a missing Settings entity as a preflight failure, instead of raising an exception. Defaults to False.",
+            "required": False,
+        },
+    }
+
+    def _run_task(self):
+        field = self.options["settings_field"]
+        entity = self.options["settings_type"]
+        try:
+            results = self.tooling.query(f"SELECT {field} FROM {entity}")["records"]
+        except SalesforceMalformedRequest as e:
+            self.logger.error(
+                f"The settings value {entity}.{field} could not be queried: {e}"
+            )
+            self.return_values = False
+
+            if not process_bool_arg(
+                self.options.get("treat_missing_as_failure", False)
+            ):
+                raise e
+
+            return
+
+        if not results:
+            self.logger.info(
+                "Located no Settings records. Returning negative preflight result."
+            )
+            self.return_values = False
+            return
+
+        value = results[0].get(self.options["settings_field"])
+        # Type-sensitive compare.
+        if type(value) is bool:
+            comparand = process_bool_arg(self.options["value"])
+        elif type(value) is float:
+            comparand = float(self.options["value"])
+        elif type(value) is int:
+            comparand = int(self.options["value"])
+        else:
+            comparand = self.options["value"]
+
+        self.return_values = value == comparand
+
+        self.logger.info(
+            f"Completed Settings preflight check with result {self.return_values}"
+        )

cumulusci/tasks/preflight/sobjects.py

@@ -0,0 +1,202 @@
+from simple_salesforce.exceptions import SalesforceMalformedRequest
+
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.core.utils import process_bool_arg
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+class CheckSObjectsAvailable(BaseSalesforceApiTask):
+    task_docs = """As a MetaDeploy preflight check, validates that an sObject is present in the schema.
+
+    The task can be used as a preflight check thus::
+
+        3:
+            task: insert_sobject_records
+            checks:
+                - when: "'ContentNote' not in tasks.check_sobjects_available()"
+                  action: error
+                  message: "Enhanced Notes are not turned on."
+    """
+
+    def _run_task(self):
+
+        self.return_values = {entry["name"] for entry in self.sf.describe()["sobjects"]}
+
+        self.logger.info(
+            "Completed sObjects preflight check with result {}".format(
+                self.return_values
+            )
+        )
+
+
+class CheckSObjectPerms(BaseSalesforceApiTask):
+    task_docs = """As a MetaDeploy preflight check, validates that an sObject's permissions are in the expected state.
+
+    For example, specify::
+
+        check_sobject_permissions:
+            options:
+                Account:
+                    createable: True
+                    updateable: False
+                Contact:
+                    createable: False
+
+    to validate that the Account object is createable but not updateable, and the Contact object is not createable.
+    The output is True if all sObjects and permissions are present and matching the specification.
+
+    Given the above configuration, the task can be used as a preflight check in a MetaDeploy plan::
+
+        3:
+            task: insert_sobject_records
+            checks:
+                - when: "not tasks.check_sobject_permissions()"
+                  action: error
+                  message: "sObject permissions are not configured correctly."
+    """
+
+    task_options = {
+        "permissions": {
+            "description": "The object permissions to check. Each key should be an sObject API name, whose value is a map of describe keys, "
+            "such as `queryable` and `createable`, to their desired values (True or False). The output is True if all sObjects and permissions "
+            "are present and matching the specification. See the task documentation for examples.",
+            "required": True,
+        }
+    }
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+
+        if type(self.options.get("permissions")) is not dict:
+            raise TaskOptionsError(
+                "Each sObject should contain a map of permissions to desired values"
+            )
+
+        self.permissions = {}
+        for sobject, perms in self.options["permissions"].items():
+            self.permissions[sobject] = {
+                perm: process_bool_arg(value) for perm, value in perms.items()
+            }
+
+    def _run_task(self):
+        describe = {s["name"]: s for s in self.sf.describe()["sobjects"]}
+
+        success = True
+
+        for sobject, perms in self.permissions.items():
+            if sobject not in describe:
+                success = False
+                self.logger.info(f"sObject {sobject} is not present in the describe.")
+            else:
+                for perm in perms:
+                    if perm not in describe[sobject]:
+                        success = False
+                        self.logger.info(
+                            f"Permission {perm} is not present for sObject {sobject}."
+                        )
+                    else:
+                        if describe[sobject][perm] is not perms[perm]:
+                            success = False
+                            self.logger.info(
+                                f"Permission {perm} for sObject {sobject} is {describe[sobject][perm]}, not {perms[perm]}."
+                            )
+
+        self.return_values = success
+        self.logger.info(f"Completing preflight check with result {self.return_values}")
+
+
+class CheckSObjectOWDs(BaseSalesforceApiTask):
+    task_docs = """As a MetaDeploy preflight check, validates that an sObject's Org-Wide Defaults are in the expected state.
+
+    For example, specify::
+
+        check_org_wide_defaults:
+            options:
+                org_wide_defaults:
+                    - api_name: Account
+                      internal_sharing_model: Private
+                      external_sharing_model: Private
+                    - api_name: Contact
+                      internal_sharing_model: Private
+
+    to validate that the Account object has Private internal and external OWDs, and Contact a Private internal model.
+    The output is True if all sObjects and permissions are present and matching the specification.
+
+    Given the above configuration, the task can be used as a preflight check in a MetaDeploy plan::
+
+        3:
+            task: insert_sobject_records
+            checks:
+                - when: "not tasks.check_org_wide_defaults()"
+                  action: error
+                  message: "Org-Wide Defaults are not configured correctly."
+    """
+    task_options = {
+        "org_wide_defaults": {
+            "description": "The Organization-Wide Defaults to check, "
+            "organized as a list with each element containing the keys api_name, "
+            "internal_sharing_model, and external_sharing_model. NOTE: you must have "
+            "External Sharing Model turned on in Sharing Settings to use the latter feature. "
+            "Checking External Sharing Model when it is turned off will fail the preflight.",
+            "required": True,
+        }
+    }
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+
+        if "org_wide_defaults" not in self.options:
+            raise TaskOptionsError("org_wide_defaults is a required option")
+
+        if not all("api_name" in entry for entry in self.options["org_wide_defaults"]):
+            raise TaskOptionsError("api_name must be included in each entry")
+
+        if not all(
+            "internal_sharing_model" in entry or "external_sharing_model" in entry
+            for entry in self.options["org_wide_defaults"]
+        ):
+            raise TaskOptionsError("Each entry must include a sharing model to check.")
+
+        self.owds = {
+            entry["api_name"]: (
+                entry.get("internal_sharing_model"),
+                entry.get("external_sharing_model"),
+            )
+            for entry in self.options["org_wide_defaults"]
+        }
+
+    def _check_owds(self, sobject, result):
+        internal = (
+            result["InternalSharingModel"] == self.owds[sobject][0]
+            if self.owds[sobject][0]
+            else True
+        )
+        external = (
+            result["ExternalSharingModel"] == self.owds[sobject][1]
+            if self.owds[sobject][1]
+            else True
+        )
+        return internal and external
+
+    def _run_task(self):
+        try:
+            ext = (
+                ", ExternalSharingModel"
+                if any(owd[1] is not None for owd in self.owds.values())
+                else ""
+            )
+            object_list = ", ".join(f"'{obj}'" for obj in self.owds.keys())
+            results = self.sf.query(
+                f"SELECT QualifiedApiName, InternalSharingModel{ext} "
+                "FROM EntityDefinition "
+                f"WHERE QualifiedApiName IN ({object_list})"
+            )["records"]
+            self.return_values = all(
+                self._check_owds(rec["QualifiedApiName"], rec) for rec in results
+            )
+        except (IndexError, KeyError, SalesforceMalformedRequest):
+            self.return_values = False
+
+        self.logger.info(
+            f"Completed Organization-Wide Default preflight with result: {self.return_values}"
+        )

cumulusci/tasks/preflight/tests/test_dataset_load.py

@@ -0,0 +1,85 @@
+from unittest import mock
+
+import pytest
+
+from cumulusci.core.exceptions import BulkDataException
+from cumulusci.tasks.bulkdata.mapping_parser import MappingStep
+from cumulusci.tasks.bulkdata.step import DataApi, DataOperationType
+from cumulusci.tasks.preflight.dataset_load import LoadDataSetCheck
+from cumulusci.tasks.salesforce.tests.util import create_task
+
+
+class TestLoadDataSetCheck:
+    @mock.patch(
+        "cumulusci.tasks.preflight.dataset_load.validate_and_inject_mapping",
+        return_value=True,
+    )
+    def test_run_task(self, validate_and_inject_mapping):
+        task = create_task(LoadDataSetCheck, {})
+        assert task()
+        assert task.options["dataset"] == "default"
+        assert task.mapping == {
+            "Account": MappingStep(
+                sf_object="Account",
+                table="Account",
+                fields={
+                    "Name": "Name",
+                    "Description": "Description",
+                    "ShippingStreet": "ShippingStreet",
+                    "ShippingCity": "ShippingCity",
+                    "ShippingState": "ShippingState",
+                    "ShippingPostalCode": "ShippingPostalCode",
+                    "ShippingCountry": "ShippingCountry",
+                    "Phone": "Phone",
+                    "AccountNumber": "AccountNumber",
+                },
+                lookups={},
+                static={},
+                filters=[],
+                action=DataOperationType.INSERT,
+                api=DataApi.BULK,
+                batch_size=1,
+                oid_as_pk=False,
+                record_type=None,
+                bulk_mode=None,
+                anchor_date=None,
+                soql_filter=None,
+                update_key=(),
+            ),
+            "Contact": MappingStep(
+                sf_object="Contact",
+                table="Contact",
+                fields={"FirstName": "FirstName"},
+                lookups={},
+                static={},
+                filters=[],
+                action=DataOperationType.INSERT,
+                api=DataApi.BULK,
+                batch_size=1,
+                oid_as_pk=False,
+                record_type=None,
+                bulk_mode=None,
+                anchor_date=None,
+                soql_filter=None,
+                update_key=(),
+            ),
+        }
+
+    def test_mapping_file_not_found(self):
+        task = create_task(LoadDataSetCheck, {"dataset": "alpha"})
+        with pytest.raises(Exception) as e:
+            task()
+        assert "No such file or directory" in str(e.value)
+        assert task.options["dataset"] == "alpha"
+
+    @mock.patch(
+        "cumulusci.tasks.preflight.dataset_load.validate_and_inject_mapping",
+        side_effect=BulkDataException("An error occurred during validation"),
+    )
+    def test_run_fail(self, validate_and_inject_mapping):
+        task = create_task(LoadDataSetCheck, {})
+        task.logger = mock.Mock()
+        assert not task()
+        assert task.logger.error.asset_called_once_with(
+            "An error occurred during validation"
+        )