cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/preflight/tests/test_licenses.py

@@ -0,0 +1,174 @@
+from unittest.mock import Mock
+
+from cumulusci.tasks.preflight.licenses import (
+    GetAssignableLicenses,
+    GetAssignablePermissionSets,
+    GetAvailableLicenses,
+    GetAvailablePermissionSetLicenses,
+    GetAvailablePermissionSets,
+    GetPermissionLicenseSetAssignments,
+)
+from cumulusci.tasks.salesforce.tests.util import create_task
+
+
+class TestLicensePreflights:
+    def test_license_preflight(self):
+        task = create_task(GetAvailableLicenses, {})
+        task._init_api = Mock()
+        task._init_api.return_value.query.return_value = {
+            "totalSize": 2,
+            "records": [
+                {
+                    "Id": "L1",
+                    "LicenseDefinitionKey": "TEST1",
+                    "TotalLicenses": 100,
+                    "UsedLicenses": 90,
+                },
+                {
+                    "Id": "L2",
+                    "LicenseDefinitionKey": "TEST2",
+                    "TotalLicenses": 100,
+                    "UsedLicenses": 100,
+                },
+            ],
+        }
+
+        task()
+        task._init_api.return_value.query.assert_called_once_with(
+            "SELECT Id, LicenseDefinitionKey, TotalLicenses, UsedLicenses FROM UserLicense WHERE Status = 'Active'"
+        )
+
+        assert task.return_values == ["TEST1", "TEST2"]
+
+    def test_assignable_license_preflight(self):
+        task = create_task(GetAssignableLicenses, {})
+        task._init_api = Mock()
+        task._init_api.return_value.query.return_value = {
+            "totalSize": 2,
+            "records": [
+                {
+                    "Id": "L1",
+                    "LicenseDefinitionKey": "TEST1",
+                    "TotalLicenses": 100,
+                    "UsedLicenses": 90,
+                },
+                {
+                    "Id": "L2",
+                    "LicenseDefinitionKey": "TEST2",
+                    "TotalLicenses": 100,
+                    "UsedLicenses": 100,
+                },
+            ],
+        }
+
+        task()
+        task._init_api.return_value.query.assert_called_once_with(
+            "SELECT Id, LicenseDefinitionKey, TotalLicenses, UsedLicenses FROM UserLicense WHERE Status = 'Active'"
+        )
+        # Only TEST1 assignable licenses
+        assert task.return_values == ["TEST1"]
+
+    def test_psl_preflight(self):
+        task = create_task(GetAvailablePermissionSetLicenses, {})
+        task._init_api = Mock()
+
+        task._init_api.return_value.query.return_value = {
+            "totalSize": 2,
+            "records": [
+                {"PermissionSetLicenseKey": "TEST1"},
+                {"PermissionSetLicenseKey": "TEST2"},
+            ],
+        }
+        task()
+
+        task._init_api.return_value.query.assert_called_once_with(
+            "SELECT PermissionSetLicenseKey FROM PermissionSetLicense WHERE Status = 'Active'"
+        )
+        assert task.return_values == ["TEST1", "TEST2"]
+
+    def test_assigned_permsetlicense_preflight(self):
+        task = create_task(GetPermissionLicenseSetAssignments, {})
+        task._init_api = Mock()
+        task._init_api.return_value.query_all.return_value = {
+            "totalSize": 2,
+            "done": True,
+            "records": [
+                {
+                    "PermissionSetLicense": {
+                        "MasterLabel": "Document Checklist",
+                        "DeveloperName": "DocumentChecklist",
+                    },
+                },
+                {
+                    "PermissionSetLicense": {
+                        "MasterLabel": "Einstein Analytics Plus Admin",
+                        "DeveloperName": "EinsteinAnalyticsPlusAdmin",
+                    },
+                },
+            ],
+        }
+        task()
+
+        task._init_api.return_value.query_all.assert_called_once_with(
+            "SELECT PermissionSetLicense.DeveloperName FROM PermissionSetLicenseAssign WHERE AssigneeId = 'USER_ID'"
+        )
+        assert task.return_values == [
+            "DocumentChecklist",
+            "EinsteinAnalyticsPlusAdmin",
+        ]
+
+    def test_permsets_preflight(self):
+        task = create_task(GetAvailablePermissionSets, {})
+        task._init_api = Mock()
+
+        task._init_api.return_value.query_all.return_value = {
+            "totalSize": 2,
+            "records": [
+                {"Name": "TEST1"},
+                {"Name": "TEST2"},
+            ],
+        }
+        task()
+
+        task._init_api.return_value.query_all.assert_called_once_with(
+            "SELECT Name FROM PermissionSet"
+        )
+        assert task.return_values == ["TEST1", "TEST2"]
+
+    def test_assignable_permsets_preflight(self):
+        task = create_task(GetAssignablePermissionSets, {})
+        task._init_api = Mock()
+        task._init_api.return_value.query.return_value = {
+            "totalSize": 2,
+            "records": [
+                {
+                    "Id": "L1",
+                    "LicenseDefinitionKey": "TEST1",
+                    "TotalLicenses": 100,
+                    "UsedLicenses": 90,
+                },
+                {
+                    "Id": "L2",
+                    "LicenseDefinitionKey": "TEST2",
+                    "TotalLicenses": 100,
+                    "UsedLicenses": 100,
+                },
+            ],
+        }
+        task._init_api.return_value.query_all.return_value = {
+            "totalSize": 3,
+            "records": [
+                {"LicenseId": "L1", "Name": "TEST1"},
+                {"LicenseId": "L2", "Name": "TEST2"},
+                {"LicenseId": None, "Name": "TEST3"},
+            ],
+        }
+        task()
+
+        task._init_api.return_value.query.assert_called_once_with(
+            "SELECT Id, LicenseDefinitionKey, TotalLicenses, UsedLicenses FROM UserLicense WHERE Status = 'Active'"
+        )
+        task._init_api.return_value.query_all.assert_called_once_with(
+            "SELECT LicenseId, Name FROM PermissionSet"
+        )
+        assert task.return_values == ["TEST1", "TEST3"]

cumulusci/tasks/preflight/tests/test_packages.py

@@ -0,0 +1,14 @@
+from unittest import mock
+
+from cumulusci.tasks.preflight.packages import GetInstalledPackages
+from cumulusci.tasks.salesforce.tests.util import create_task
+
+
+class TestGetInstalledPackages:
+    @mock.patch(
+        "cumulusci.salesforce_api.metadata.ApiRetrieveInstalledPackages.__call__"
+    )
+    def test_run_task(self, api):
+        task = create_task(GetInstalledPackages)
+        task()
+        api.assert_called_once()

cumulusci/tasks/preflight/tests/test_permset_preflights.py

@@ -0,0 +1,51 @@
+from unittest.mock import Mock
+
+from cumulusci.tasks.preflight.permsets import GetPermissionSetAssignments
+from cumulusci.tasks.salesforce.tests.util import create_task
+
+
+class TestPermsetPreflights:
+    def test_assigned_permset_preflight(self):
+        task = create_task(GetPermissionSetAssignments, {})
+        task._init_api = Mock()
+        task._init_api.return_value.query_all.side_effect = [
+            {
+                "totalSize": 2,
+                "done": True,
+                "records": [
+                    {
+                        "PermissionSet": {
+                            "Label": "Document Checklist",
+                            "Name": "DocumentChecklist",
+                        },
+                        "PermissionSetGroupId": None,
+                    },
+                    {
+                        "PermissionSet": {
+                            "Label": "Einstein Analytics Plus Admin",
+                            "Name": "EinsteinAnalyticsPlusAdmin",
+                        },
+                        "PermissionSetGroupId": "0PG000000000001",
+                    },
+                ],
+            },
+            {
+                "totalSize": 1,
+                "done": True,
+                "records": [
+                    {
+                        "PermissionSet": {
+                            "Label": "Customer Experience Analytics Admin",
+                            "Name": "CustomerExperienceAnalyticsAdmin",
+                        },
+                    },
+                ],
+            },
+        ]
+        task()
+        task._init_api.return_value.query_all.assert_called()
+        assert task.return_values == [
+            "DocumentChecklist",
+            "EinsteinAnalyticsPlusAdmin",
+            "CustomerExperienceAnalyticsAdmin",
+        ]

cumulusci/tasks/preflight/tests/test_recordtypes.py

@@ -0,0 +1,30 @@
+from unittest.mock import Mock
+
+from cumulusci.tasks.preflight.recordtypes import CheckSObjectRecordTypes
+from cumulusci.tasks.salesforce.tests.util import create_task
+
+
+class TestRecordTypePreflights:
+    def test_record_type_preflight(self):
+        task = create_task(CheckSObjectRecordTypes, {})
+        task.tooling = Mock()
+        task.tooling.query_all.return_value = {
+            "totalSize": 3,
+            "records": [
+                {"SobjectType": "Account", "FullName": "Account.Business_Account"},
+                {"SobjectType": "Account", "FullName": "PersonAccount.PersonAccount"},
+                {
+                    "SobjectType": "ActionPlanTemplate",
+                    "FullName": "ActionPlanTemplate.Default",
+                },
+            ],
+        }
+        task._run_task()
+
+        task.tooling.query_all.assert_called_once_with(
+            "Select SobjectType, FullName FROM RecordType"
+        )
+        assert task.return_values == {
+            "Account": ["Business_Account", "PersonAccount"],
+            "ActionPlanTemplate": ["Default"],
+        }

cumulusci/tasks/preflight/tests/test_retrieve_tasks.py

@@ -0,0 +1,62 @@
+from unittest import mock
+
+import pytest
+
+from cumulusci.cli.runtime import CliRuntime
+from cumulusci.core.exceptions import CumulusCIException
+from cumulusci.tasks.preflight.retrieve_tasks import RetrieveTasks
+from cumulusci.tasks.salesforce.tests.util import create_task
+
+
+class TestRetrieveTasks:
+    @pytest.mark.parametrize(
+        "available_tasks, group_name, expected_output",
+        [
+            (
+                [
+                    {
+                        "name": "test_task1",
+                        "description": "Test Task",
+                        "group": "Group",
+                    },
+                    {
+                        "name": "test_task2",
+                        "description": "Test Task",
+                        "group": "Group",
+                    },
+                    {
+                        "name": "test_task3",
+                        "description": "Test Task",
+                        "group": "Test Group",
+                    },
+                ],
+                "Group",
+                ["test_task1", "test_task2"],
+            ),
+            (
+                [
+                    {
+                        "name": "test_task1",
+                        "description": "Test Task",
+                        "group": "Group",
+                    },
+                ],
+                "Tests",
+                None,
+            ),
+        ],
+    )
+    def test_run_task(self, available_tasks, group_name, expected_output):
+        task = create_task(RetrieveTasks, options={"group_name": group_name})
+
+        with mock.patch.object(
+            CliRuntime, "get_available_tasks", return_value=available_tasks
+        ):
+            if expected_output is not None:
+                output = task()
+                assert output == expected_output
+            else:
+                with pytest.raises(
+                    CumulusCIException, match="No tasks in the specified group"
+                ):
+                    task()

cumulusci/tasks/preflight/tests/test_settings.py

@@ -0,0 +1,130 @@
+from unittest.mock import MagicMock
+
+import pytest
+import responses
+from simple_salesforce.exceptions import SalesforceMalformedRequest
+
+from cumulusci.tasks.preflight.settings import CheckMyDomainActive, CheckSettingsValue
+from cumulusci.tasks.salesforce.tests.util import create_task
+from cumulusci.tests.util import CURRENT_SF_API_VERSION
+
+JSON_RESPONSE = {
+    "records": [{"IntVal": 3, "FloatVal": 3.0, "BoolVal": True, "StringVal": "foo"}],
+    "done": True,
+    "totalSize": 1,
+}
+
+
+@responses.activate
+@pytest.mark.parametrize(
+    "settings_field,value,outcome",
+    [
+        ("IntVal", 3, True),
+        ("FloatVal", 3.0, True),
+        ("BoolVal", "true", True),
+        ("StringVal", "foo", True),
+        ("StringVal", "bad", False),
+    ],
+)
+def test_check_settings(settings_field, value, outcome):
+    responses.add(
+        "GET",
+        f"https://test.salesforce.com/services/data/v{CURRENT_SF_API_VERSION}/tooling/query/?q=SELECT+{settings_field}+FROM+ChatterSettings",
+        json=JSON_RESPONSE,
+    )
+    task = create_task(
+        CheckSettingsValue,
+        {
+            "settings_type": "ChatterSettings",
+            "settings_field": settings_field,
+            "value": value,
+        },
+    )
+
+    task()
+
+    assert task.return_values is outcome
+
+
+@responses.activate
+def test_check_settings__no_settings():
+    responses.add(
+        "GET",
+        f"https://test.salesforce.com/services/data/v{CURRENT_SF_API_VERSION}/tooling/query/?q=SELECT+Foo+FROM+ChatterSettings",
+        json={"records": []},
+    )
+    task = create_task(
+        CheckSettingsValue,
+        {
+            "settings_type": "ChatterSettings",
+            "settings_field": "Foo",
+            "value": True,
+        },
+    )
+
+    task()
+
+    assert task.return_values is False
+
+
+@responses.activate
+def test_check_settings__failure():
+    responses.add(
+        "GET",
+        status=400,
+        url=f"https://test.salesforce.com/services/data/v{CURRENT_SF_API_VERSION}/tooling/query/?q=SELECT+Test+FROM+NoSettings",
+        json={},
+    )
+    task = create_task(
+        CheckSettingsValue,
+        {
+            "settings_type": "NoSettings",
+            "settings_field": "Test",
+            "value": True,
+            "treat_missing_as_failure": True,
+        },
+    )
+
+    task()
+
+    assert task.return_values is False
+
+
+@responses.activate
+def test_check_settings__exception():
+    responses.add(
+        "GET",
+        status=400,
+        url=f"https://test.salesforce.com/services/data/v{CURRENT_SF_API_VERSION}/tooling/query/?q=SELECT+Test+FROM+NoSettings",
+        json={},
+    )
+    task = create_task(
+        CheckSettingsValue,
+        {
+            "settings_type": "NoSettings",
+            "settings_field": "Test",
+            "value": True,
+        },
+    )
+
+    with pytest.raises(SalesforceMalformedRequest):
+        task()
+
+    assert task.return_values is False
+
+
+@pytest.mark.parametrize(
+    "my_domain,outcome",
+    [
+        ("https://cumulusci.my.salesforce.com", True),
+        ("https://cumulusci.cloudforce.com", True),
+        ("https://na44.salesforce.com", False),
+    ],
+)
+def test_my_domain_check(my_domain, outcome):
+    org_config = MagicMock()
+    org_config.instance_url = my_domain
+    task = create_task(CheckMyDomainActive, {}, org_config=org_config)
+    task()
+
+    assert task.return_values is outcome

cumulusci/tasks/preflight/tests/test_sobjects.py

@@ -0,0 +1,231 @@
+from unittest.mock import Mock
+
+import pytest
+from simple_salesforce.exceptions import SalesforceMalformedRequest
+
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.tasks.preflight.sobjects import (
+    CheckSObjectOWDs,
+    CheckSObjectPerms,
+    CheckSObjectsAvailable,
+)
+from cumulusci.tasks.salesforce.tests.util import create_task
+
+
+class TestCheckSObjectsAvailable:
+    def test_sobject_preflight(self):
+        task = create_task(CheckSObjectsAvailable, {})
+
+        task._init_task = Mock()
+        task.sf = Mock()
+        task.sf.describe.return_value = {
+            "sobjects": [{"name": "Network"}, {"name": "Account"}]
+        }
+
+        task()
+
+        assert task.return_values == {"Network", "Account"}
+
+
+class TestCheckSObjectPerms:
+    def test_sobject_perms_preflight(self):
+        task = create_task(
+            CheckSObjectPerms,
+            {
+                "permissions": {
+                    "Network": {"createable": "false"},
+                    "Account": {"createable": True},
+                }
+            },
+        )
+
+        task._init_task = Mock()
+        task.sf = Mock()
+        task.sf.describe.return_value = {
+            "sobjects": [
+                {"name": "Network", "createable": False},
+                {"name": "Account", "createable": True},
+            ]
+        }
+
+        task()
+
+        assert task.return_values is True
+
+    def test_sobject_perms_preflight__negative(self):
+        task = create_task(
+            CheckSObjectPerms,
+            {
+                "permissions": {
+                    "Network": {"createable": "false"},
+                    "Account": {"createable": True},
+                }
+            },
+        )
+
+        task._init_task = Mock()
+        task.sf = Mock()
+        task.sf.describe.return_value = {
+            "sobjects": [
+                {"name": "Network", "createable": False},
+                {"name": "Account", "createable": False},
+            ]
+        }
+
+        task()
+
+        assert task.return_values is False
+
+    def test_sobject_perms_preflight__missing(self):
+        task = create_task(
+            CheckSObjectPerms,
+            {
+                "permissions": {
+                    "Network": {"createable": "false"},
+                    "Account": {"createable": True},
+                }
+            },
+        )
+
+        task._init_task = Mock()
+        task.sf = Mock()
+        task.sf.describe.return_value = {"sobjects": [{"name": "Network"}]}
+
+        task()
+
+        assert task.return_values is False
+
+    def test_sobject_perms_preflight__bad_options(self):
+        with pytest.raises(TaskOptionsError):
+            create_task(CheckSObjectPerms, {"permissions": True})
+
+
+class TestCheckSObjectOWDs:
+    def test_sobject_preflight__positive(self):
+        task = create_task(
+            CheckSObjectOWDs,
+            {
+                "org_wide_defaults": [
+                    {"api_name": "Account", "internal_sharing_model": "Private"},
+                    {"api_name": "Contact", "internal_sharing_model": "ReadWrite"},
+                ]
+            },
+        )
+        task._init_task = Mock()
+        task.sf = Mock()
+        task.sf.query.return_value = {
+            "totalSize": 2,
+            "records": [
+                {"QualifiedApiName": "Account", "InternalSharingModel": "Private"},
+                {"QualifiedApiName": "Contact", "InternalSharingModel": "ReadWrite"},
+            ],
+        }
+        task()
+
+        assert task.return_values is True
+
+    def test_sobject_preflight__negative(self):
+        task = create_task(
+            CheckSObjectOWDs,
+            {
+                "org_wide_defaults": [
+                    {"api_name": "Account", "internal_sharing_model": "Private"}
+                ]
+            },
+        )
+        task._init_task = Mock()
+        task.sf = Mock()
+        task.sf.query.return_value = {
+            "totalSize": 1,
+            "records": [
+                {"QualifiedApiName": "Account", "InternalSharingModel": "ReadWrite"}
+            ],
+        }
+        task()
+
+        assert task.return_values is False
+
+    def test_sobject_preflight__external(self):
+        task = create_task(
+            CheckSObjectOWDs,
+            {
+                "org_wide_defaults": [
+                    {"api_name": "Account", "external_sharing_model": "Private"}
+                ]
+            },
+        )
+        task._init_task = Mock()
+        task.sf = Mock()
+        task.sf.query.return_value = {
+            "totalSize": 1,
+            "records": [
+                {
+                    "QualifiedApiName": "Account",
+                    "InternalSharingModel": "Private",
+                    "ExternalSharingModel": "Private",
+                }
+            ],
+        }
+        task()
+
+        assert task.return_values is True
+
+    def test_sobject_preflight__both(self):
+        task = create_task(
+            CheckSObjectOWDs,
+            {
+                "org_wide_defaults": [
+                    {
+                        "api_name": "Account",
+                        "internal_sharing_model": "ReadWrite",
+                        "external_sharing_model": "Private",
+                    }
+                ]
+            },
+        )
+        task._init_task = Mock()
+        task.sf = Mock()
+        task.sf.query.return_value = {
+            "totalSize": 1,
+            "records": [
+                {
+                    "QualifiedApiName": "Account",
+                    "InternalSharingModel": "ReadWrite",
+                    "ExternalSharingModel": "Private",
+                }
+            ],
+        }
+        task()
+
+        assert task.return_values is True
+
+    def test_sobject_preflight__external_not_enabled(self):
+        task = create_task(
+            CheckSObjectOWDs,
+            {
+                "org_wide_defaults": [
+                    {"api_name": "Account", "external_sharing_model": "Private"}
+                ]
+            },
+        )
+        task._init_task = Mock()
+        task.sf = Mock()
+        task.sf.query.side_effect = SalesforceMalformedRequest(
+            "url", 400, "resource_name", "content"
+        )
+        task()
+
+        assert task.return_values is False
+
+    def test_sobject_preflight__task_options(self):
+        with pytest.raises(TaskOptionsError):
+            create_task(CheckSObjectOWDs, {})
+        with pytest.raises(TaskOptionsError):
+            create_task(
+                CheckSObjectOWDs,
+                {"org_wide_defaults": [{"internal_sharing_model": "Private"}]},
+            )
+        with pytest.raises(TaskOptionsError):
+            create_task(
+                CheckSObjectOWDs, {"org_wide_defaults": [{"api_name": "Account"}]}
+            )