cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/salesforce/users/tests/test_photos.py

@@ -0,0 +1,373 @@
+import base64
+import json
+import os
+import pathlib
+import shutil
+from unittest import mock
+
+import pytest  # noqa: F401
+from simple_salesforce.exceptions import SalesforceMalformedRequest
+
+from cumulusci.core.exceptions import CumulusCIException  # noqa: F401
+from cumulusci.tasks.salesforce.tests.util import create_task
+from cumulusci.tasks.salesforce.users.photos import UploadProfilePhoto, join_errors
+from cumulusci.utils import temporary_dir
+
+
+def test_join_errors():
+    e = SalesforceMalformedRequest(
+        "url",
+        "status",
+        "resource_name",
+        [
+            {"message": "Error message 1.", "errorCode": "ERROR_1"},
+            {"message": "Error message 2.", "errorCode": "ERROR_2"},
+            {"message": "Error message 3.", "errorCode": "ERROR_3"},
+        ],
+    )
+
+    assert join_errors(e) == "Error message 1.; Error message 2.; Error message 3."
+
+
+class TestUploadProfilePhoto:
+    def setup_method(self):
+        # Photo information
+        self.photo = "photo.mock.txt"
+        self.base_path = os.path.dirname(__file__)
+        self.photo_path = pathlib.Path(
+            os.path.join(self.base_path, self.photo)
+        ).resolve()
+        assert self.photo_path.exists(), "photo mock cannot be found"
+        assert self.photo_path.is_file(), "photo_path should point to a file"
+
+        # Resusable data
+        self.content_version_id = "0681k000001YWQ5AAO"
+        self.content_document_id = "0691k000001LtfEAAS"
+
+        self.e = SalesforceMalformedRequest(
+            "url",
+            "status",
+            "resource_name",
+            [
+                {"message": "Error message 1.", "errorCode": "ERROR_1"},
+                {"message": "Error message 2.", "errorCode": "ERROR_2"},
+                {"message": "Error message 3.", "errorCode": "ERROR_3"},
+            ],
+        )
+        self.expected_exception_message = (
+            "Error message 1.; Error message 2.; Error message 3."
+        )
+        self.user_id = "0051k000003cEL3AAM"
+
+        # Task with mocks
+        self.task = create_task(UploadProfilePhoto, {"photo": self.photo})
+        self.task.logger = mock.Mock()
+        self.task.sf = mock.Mock()
+
+    def test_raise_cumulusci_exception(self):
+        with pytest.raises(CumulusCIException) as e:
+            self.task._raise_cumulusci_exception(self.e)
+
+        assert e.value.args[0] == self.expected_exception_message
+
+    def test_get_user_id_by_query__valid_query__0_records(self):
+        # where is prefixed with "where " which will be stripped when injected into the query.
+        where = "where (FirstName = 'User' OR LastName = 'User') AND IsActive = true AND CreatedDate = TODAY"
+        expected_query = "SELECT Id FROM User WHERE (FirstName = 'User' OR LastName = 'User') AND IsActive = true AND CreatedDate = TODAY LIMIT 2"
+
+        self.task.sf.query_all.return_value = {"records": []}
+
+        self.task.logger.info._expected_calls = [
+            mock.call(f"Querying User: {expected_query}")
+        ]
+
+        # Execute the test
+        with pytest.raises(CumulusCIException) as e:
+            self.task._get_user_id_by_query(where)
+
+        assert e.value.args[0] == "No Users found."
+
+        self.task.sf.query_all.assert_called_once_with(expected_query)
+        self.task.logger.info.assert_has_calls(self.task.logger.info._expected_calls)
+
+    def test_get_user_id_by_query__valid_query__1_record(self):
+        # where is prefixed with "where " which will be stripped when injected into the query.
+        where = "where (FirstName = 'User' OR LastName = 'User') AND IsActive = true AND CreatedDate = TODAY"
+        expected_query = "SELECT Id FROM User WHERE (FirstName = 'User' OR LastName = 'User') AND IsActive = true AND CreatedDate = TODAY LIMIT 2"
+
+        expected = self.user_id
+
+        self.task.sf.query_all.return_value = {"records": [{"Id": expected}]}
+
+        self.task.logger.info._expected_calls = [
+            mock.call(f"Querying User: {expected_query}"),
+            mock.call(f"Uploading profile photo for the User with ID {expected}"),
+        ]
+
+        # Execute the test
+        actual = self.task._get_user_id_by_query(where)
+
+        assert expected == actual
+
+        self.task.sf.query_all.assert_called_once_with(expected_query)
+        self.task.logger.info.assert_has_calls(self.task.logger.info._expected_calls)
+
+    def test_get_user_id_by_query__valid_query__2_records(self):
+        # where is prefixed with "where " which will be stripped when injected into the query.
+        where = "where (FirstName = 'User' OR LastName = 'User') AND IsActive = true AND CreatedDate = TODAY"
+        expected_query = "SELECT Id FROM User WHERE (FirstName = 'User' OR LastName = 'User') AND IsActive = true AND CreatedDate = TODAY LIMIT 2"
+
+        id_0 = self.user_id
+        id_1 = "0051k000003cEL8AAM"
+
+        self.task.sf.query_all.return_value = {"records": [{"Id": id_0}, {"Id": id_1}]}
+
+        self.task.logger.info._expected_calls = [
+            mock.call(f"Querying User: {expected_query}")
+        ]
+
+        # Execute the test
+        with pytest.raises(CumulusCIException) as e:
+            self.task._get_user_id_by_query(where)
+
+        assert (
+            e.value.args[0] == f"More than one User found (at least 2): {id_0}, {id_1}"
+        )
+
+        self.task.sf.query_all.assert_called_once_with(expected_query)
+        self.task.logger.info.assert_has_calls(self.task.logger.info._expected_calls)
+
+    def test_get_user_id_by_query__invalid_query(self):
+        where = "(FirstName = 'User' OR LastName = 'User') AND IsActive = true AND CreatedDate = TODAY but the end of this query is invalid SOQL "
+        expected_query = "SELECT Id FROM User WHERE (FirstName = 'User' OR LastName = 'User') AND IsActive = true AND CreatedDate = TODAY but the end of this query is invalid SOQL  LIMIT 2"
+
+        self.task.sf.query_all.side_effect = self.e
+
+        self.task.logger.info._expected_calls = [
+            mock.call(f"Querying User: {expected_query}")
+        ]
+
+        # Execute the test
+        with pytest.raises(CumulusCIException) as e:
+            self.task._get_user_id_by_query(where)
+
+        assert e.value.args[0] == self.expected_exception_message
+
+        self.task.sf.query_all.assert_called_once_with(expected_query)
+        self.task.logger.info.assert_has_calls(self.task.logger.info._expected_calls)
+
+    def test_get_default_user_id(self):
+        expected = self.user_id
+
+        self.task.sf.restful.return_value = {
+            "identity": f"a bunch of other things{expected}"
+        }
+
+        actual = self.task._get_default_user_id()
+
+        assert expected == actual
+
+        self.task.logger.info.assert_called_once_with(
+            f"Uploading profile photo for the default User with ID {expected}"
+        )
+
+    def test_insert_content_document__no_photo_found(self):
+        with temporary_dir():
+            with pytest.raises(CumulusCIException) as e:
+                self.task._insert_content_document(self.photo)
+
+            assert e.value.args[0] == f"No photo found at {self.photo}"
+
+    def test_insert_content_document__exception_creating_content_document(self):
+        errors = "the reason why inserting the ContentVersion failed"
+        self.task.sf.ContentVersion.create.return_value = {
+            "success": False,
+            "errors": errors,
+        }
+
+        with temporary_dir() as d:
+            # Copy photo to temporary direcory.
+            shutil.copy(str(self.photo_path), d)
+            temp_photo_path = pathlib.Path(os.path.join(d, self.photo)).resolve()
+            assert (
+                temp_photo_path.exists()
+            ), "photo mock was not copied to the temporary directory"
+            assert (
+                temp_photo_path.is_file()
+            ), "Path the the photo mock in the temporary directory should point to a file"
+
+            self.task.sf.ContentVersion.create._expected_calls = [
+                mock.call(
+                    {
+                        "PathOnClient": temp_photo_path.name,
+                        "Title": temp_photo_path.stem,
+                        "VersionData": base64.b64encode(
+                            temp_photo_path.read_bytes()
+                        ).decode("utf-8"),
+                    }
+                )
+            ]
+
+            with pytest.raises(CumulusCIException) as e:
+                self.task._insert_content_document(self.photo)
+
+        assert e.value.args[0] == f"Failed to create photo ContentVersion: {errors}"
+
+        self.task.sf.ContentVersion.create.assert_has_calls(
+            self.task.sf.ContentVersion.create._expected_calls
+        )
+
+        self.task.logger.info.assert_called_once_with(
+            f"Setting user photo to {self.photo}"
+        )
+
+    def test_insert_content_document__success(self):
+        self.task.sf.ContentVersion.create.return_value = {
+            "success": True,
+            "id": self.content_version_id,
+        }
+        self.task.sf.query.return_value = {
+            "records": [
+                {
+                    "Id": self.content_version_id,
+                    "ContentDocumentId": self.content_document_id,
+                }
+            ]
+        }
+        self.task.logger.info._expected_calls = [
+            mock.call(f"Setting user photo to {self.photo}"),
+            mock.call(
+                f"Uploaded profile photo ContentDocument {self.content_document_id}"
+            ),
+        ]
+
+        expected = self.content_document_id
+
+        with temporary_dir() as d:
+            # Copy photo to temporary direcory.
+            shutil.copy(str(self.photo_path), d)
+            temp_photo_path = pathlib.Path(os.path.join(d, self.photo)).resolve()
+            assert (
+                temp_photo_path.exists()
+            ), "photo mock was not copied to the temporary directory"
+            assert (
+                temp_photo_path.is_file()
+            ), "Path the the photo mock in the temporary directory should point to a file"
+
+            self.task.sf.ContentVersion.create._expected_calls = [
+                mock.call(
+                    {
+                        "PathOnClient": temp_photo_path.name,
+                        "Title": temp_photo_path.stem,
+                        "VersionData": base64.b64encode(
+                            temp_photo_path.read_bytes()
+                        ).decode("utf-8"),
+                    }
+                )
+            ]
+
+            actual = self.task._insert_content_document(self.photo)
+
+        assert expected == actual
+
+        self.task.sf.ContentVersion.create.assert_has_calls(
+            self.task.sf.ContentVersion.create._expected_calls
+        )
+
+        self.task.sf.query.assert_called_once_with(
+            f"SELECT Id, ContentDocumentId FROM ContentVersion WHERE Id = '{self.content_version_id}'"
+        )
+
+        self.task.logger.info.assert_has_calls(self.task.logger.info._expected_calls)
+
+    def test_delete_content_document(self):
+        self.task._delete_content_document(self.content_document_id)
+
+        self.task.sf.ContentDocument.delete.assert_called_once_with(
+            self.content_document_id
+        )
+
+    def test_assign_user_profile_photo__exception(self):
+        self.task.sf.restful.side_effect = self.e
+        self.task.logger.error._expected_calls = [
+            mock.call(
+                "An error occured assigning the ContentDocument as the users's profile photo."
+            ),
+            mock.call(f"Deleting ContentDocument {self.content_document_id}"),
+        ]
+        self.task._delete_content_document = mock.Mock()
+
+        with pytest.raises(CumulusCIException) as e:
+            self.task._assign_user_profile_photo(self.user_id, self.content_document_id)
+
+        assert e.value.args[0] == self.expected_exception_message
+
+        self.task._delete_content_document.assert_called_once_with(
+            self.content_document_id
+        )
+
+        self.task.logger.error.assert_has_calls(self.task.logger.error._expected_calls)
+
+    def test_assign_user_profile_photo__success(self):
+        self.task._delete_content_document = mock.Mock()
+
+        self.task._assign_user_profile_photo(self.user_id, self.content_document_id)
+
+        self.task.sf.restful.assert_called_once_with(
+            f"connect/user-profiles/{self.user_id}/photo",
+            data=json.dumps({"fileId": self.content_document_id}),
+            method="POST",
+        )
+
+        self.task._delete_content_document.assert_not_called()
+
+        self.task.logger.error.assert_not_called()
+
+    def test_run_task__default_user(self):
+        assert bool(self.task.options.get("where")) is False
+
+        self.task._get_default_user_id = mock.Mock()
+        self.task._get_user_id_by_query = mock.Mock()
+        self.task._insert_content_document = mock.Mock()
+        self.task._assign_user_profile_photo = mock.Mock()
+
+        self.task._run_task()
+
+        self.task._get_default_user_id.assert_called_once_with()
+
+        self.task._get_user_id_by_query.assert_not_called()
+
+        self.task._insert_content_document.assert_called_once_with(
+            self.task.options["photo"]
+        )
+
+        self.task._assign_user_profile_photo.assert_called_once_with(
+            self.task._get_default_user_id.return_value,
+            self.task._insert_content_document.return_value,
+        )
+
+    def test_run_task__queries_user(self):
+        self.task.options["where"] = mock.Mock()
+        assert bool(self.task.options.get("where")) is True
+
+        self.task._get_default_user_id = mock.Mock()
+        self.task._get_user_id_by_query = mock.Mock()
+        self.task._insert_content_document = mock.Mock()
+        self.task._assign_user_profile_photo = mock.Mock()
+
+        self.task._run_task()
+
+        self.task._get_default_user_id.assert_not_called()
+
+        self.task._get_user_id_by_query.assert_called_once_with(
+            self.task.options["where"]
+        )
+
+        self.task._insert_content_document.assert_called_once_with(
+            self.task.options["photo"]
+        )
+
+        self.task._assign_user_profile_photo.assert_called_once_with(
+            self.task._get_user_id_by_query.return_value,
+            self.task._insert_content_document.return_value,
+        )

cumulusci/tasks/sample_data/capture_sample_data.py

@@ -0,0 +1,77 @@
+from pathlib import Path
+
+from cumulusci.core.config.org_config import OrgConfig
+from cumulusci.core.datasets import Dataset
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.salesforce_api.filterable_objects import OPT_IN_ONLY
+from cumulusci.salesforce_api.org_schema import Filters, get_org_schema
+from cumulusci.tasks.salesforce.BaseSalesforceApiTask import BaseSalesforceApiTask
+
+
+class CaptureSampleData(BaseSalesforceApiTask):
+    """Capture contextual sample data based on repo."""
+
+    task_options = {
+        "dataset": {
+            "description": (
+                "The name of the dataset. If none is provided, it will use 'default'. "
+                "Names that match scratch org config names (such as 'dev', 'qa') will be loaded "
+                "into those orgs by the CumulusCI default org setup flows."
+            )
+        },
+        "extraction_definition": {
+            "description": "A file describing what to be extracted. "
+            "Defaults to `datasets/{datasetname}/{datasetname}.extract.yml` if it exists."
+        },
+        "loading_rules": {
+            "description": (
+                "Path to .load.yml file containing rules to use when loading the mapping. "
+                "Defaults to`datasets/{datasetname}/{datasetname}.load.yml` if it exists. "
+                "Multiple files can be comma separated."
+            )
+        },
+    }
+
+    org_config: OrgConfig
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+        self.options.setdefault("dataset", "default")
+
+    def _run_task(self):
+        name = self.options["dataset"]
+        if extraction_definition := self.options.get("extraction_definition"):
+            extraction_definition = Path(extraction_definition)
+            if not extraction_definition.exists():
+                raise TaskOptionsError(f"Cannot find {extraction_definition}")
+
+        if loading_rules := self.options.get("loading_rules"):
+            loading_rules = Path(loading_rules)
+            if not loading_rules.exists():
+                raise TaskOptionsError(f"Cannot find {loading_rules}")
+
+        with get_org_schema(
+            self.sf,
+            self.org_config,
+            include_counts=True,
+            filters=[Filters.extractable, Filters.createable],
+        ) as schema, Dataset(
+            name,
+            self.project_config,
+            self.sf,
+            self.org_config,
+            schema,
+        ) as dataset:
+            if not dataset.path.exists():
+                dataset.create()
+                verb = "Created"
+            else:
+                verb = "Updated"
+            opt_in_only = [f["name"] for f in self.tooling.describe()["sobjects"]]  # type: ignore
+            opt_in_only += OPT_IN_ONLY
+
+            self.return_values = dataset.extract(
+                {}, self.logger, extraction_definition, opt_in_only, loading_rules
+            )
+            self.logger.info(f"{verb} dataset '{name}' in 'datasets/{name}'")
+            return self.return_values

cumulusci/tasks/sample_data/load_sample_data.py

@@ -0,0 +1,85 @@
+from typing import Optional
+
+from cumulusci.core.config import OrgConfig
+from cumulusci.core.datasets import Dataset
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.salesforce_api.org_schema import Filters, get_org_schema
+from cumulusci.tasks.salesforce.BaseSalesforceApiTask import BaseSalesforceApiTask
+
+
+class LoadSampleData(BaseSalesforceApiTask):
+    """Loads contextual sample data based on repo."""
+
+    task_options = {
+        "dataset": {
+            "description": "The name of the dataset. If none is provided, it will use the scratch org config name (e.g. 'dev', 'qa') or fall back to 'default'."
+        },
+        "ignore_row_errors": {
+            "description": "If True, allow the load to continue even if individual rows fail to load."
+        },
+        "drop_missing_schema": {
+            "description": "Set to True to skip any missing objects or fields instead of stopping with an error."
+        },
+        "set_recently_viewed": {
+            "description": "By default, the first 1000 records inserted via the Bulk API will be set as recently viewed. If fewer than 1000 records are inserted, existing objects of the same type being inserted will also be set as recently viewed.",
+        },
+    }
+    org_config: OrgConfig
+
+    def _run_task(self):
+        name = self._find_dataset()
+        if not name:
+            return
+        with get_org_schema(
+            self.sf,
+            self.org_config,
+            include_counts=True,
+            filters=[Filters.extractable, Filters.createable],
+        ) as schema, Dataset(
+            name,
+            self.project_config,
+            self.sf,
+            self.org_config,
+            schema,
+        ) as dataset:
+            self.return_values = dataset.load(self.options, self.logger) or {}
+        return self.return_values
+
+    def _find_dataset(self) -> Optional[str]:
+        def dataset_for_name(name: str):
+            return Dataset(name, self.project_config, self.sf, self.org_config)
+
+        checked_folders = []
+        dataset_name = self.options.get("dataset")
+        if dataset_name:
+            dsf = dataset_for_name(dataset_name)
+            if dsf.exists():
+                return dataset_name
+            else:
+                raise TaskOptionsError(f"Could not find dataset directory {dsf.path}")
+
+        config_name = self.org_config.lookup("config_name")
+        if config_name:
+            config_dsf = dataset_for_name(config_name)
+            if config_dsf.exists() and (
+                config_dsf.data_file.exists() or config_dsf.snowfakery_recipe.exists()
+            ):
+                return config_name
+            else:
+                checked_folders.append(config_dsf.path)
+
+        default_dsf = dataset_for_name("default")
+        if default_dsf.exists():
+            return "default"
+        else:
+            checked_folders.append(default_dsf.path)
+
+        checked_folders = " and ".join(
+            str(f.relative_to(self.project_config.repo_root)) for f in checked_folders
+        )
+        # Don't throw exception in this case
+        self.logger.info(
+            f"No contextual sample data found. (looked in '{checked_folders}') Skipping step."
+        )
+
+        return None

cumulusci/tasks/sample_data/test_capture_sample_data.py

@@ -0,0 +1,117 @@
+from contextlib import contextmanager
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from unittest import mock
+
+import pytest
+import responses
+
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.tasks.bulkdata.extract_dataset_utils.tests.test_synthesize_extract_declarations import (
+    _fake_get_org_schema,
+    describe_for,
+)
+from cumulusci.tasks.sample_data.capture_sample_data import CaptureSampleData
+from cumulusci.tests.util import CURRENT_SF_API_VERSION
+
+
+@contextmanager
+def setup_test(org_config):
+    object_counts = {"Account": 6, "Contact": 1, "Opportunity": 5}
+    obj_describes = (
+        describe_for("Account"),
+        describe_for("Contact"),
+        describe_for("Opportunity"),
+    )
+    with mock.patch.object(
+        type(org_config), "is_person_accounts_enabled", False
+    ), mock.patch(
+        "cumulusci.tasks.sample_data.capture_sample_data.get_org_schema",
+        lambda _sf, org_config, **kwargs: _fake_get_org_schema(
+            org_config,
+            obj_describes,
+            object_counts,
+            included_objects=["Account", "Contact", "Opportunity"],
+            **kwargs,
+        ),
+    ), responses.RequestsMock() as rsps:
+        rsps.add(
+            responses.GET,
+            f"{org_config.instance_url}/services/data/v{CURRENT_SF_API_VERSION}/tooling/sobjects",
+            json={"sobjects": [{"name": "WebLink"}]},
+            status=200,
+        )
+        yield
+
+
+class TestCaptureDatasets:
+    @mock.patch("cumulusci.tasks.sample_data.capture_sample_data.Dataset")
+    def test_simple_extract(
+        self,
+        Dataset,
+        create_task,
+        org_config,
+    ):
+        with setup_test(org_config):
+            task = create_task(CaptureSampleData, {})
+            task()
+            print("Dataset.mock_calls", Dataset.mock_calls)
+            # default dataset should created
+            Dataset.assert_any_call("default", mock.ANY, mock.ANY, org_config, mock.ANY)
+            # and extracted
+            Dataset().__enter__().extract.assert_called_with(
+                {}, task.logger, None, mock.ANY, None
+            )
+
+    @mock.patch("cumulusci.tasks.sample_data.capture_sample_data.Dataset")
+    def test_named_extract(
+        self,
+        Dataset,
+        create_task,
+        org_config,
+    ):
+        with setup_test(org_config), TemporaryDirectory() as t:
+            extraction_definition = Path(t) / "test_extract_definition"
+            with open(extraction_definition, "w") as f:
+                f.write("")  # Doesn't matter. We won't parse it
+
+            loading_rules = Path(t) / "test_load_definition"
+            with open(loading_rules, "w") as f:
+                f.write("[]")  # Doesn't matter. We won't parse it
+
+            Dataset().__enter__().path.exists.return_value = False
+            task = create_task(
+                CaptureSampleData,
+                {
+                    "dataset": "mydataset",
+                    "extraction_definition": extraction_definition,
+                    "loading_rules": loading_rules,
+                },
+            )
+            task()
+            # named dataset should create
+            Dataset.assert_any_call(
+                "mydataset", mock.ANY, mock.ANY, org_config, mock.ANY
+            )
+            Dataset().__enter__().create.assert_called_with()
+            # and extracted
+            Dataset().__enter__().extract.assert_called_with(
+                {}, task.logger, extraction_definition, mock.ANY, loading_rules
+            )
+
+    @mock.patch("cumulusci.tasks.sample_data.capture_sample_data.Dataset")
+    def test_option_error(
+        self,
+        Dataset,
+        create_task,
+        org_config,
+    ):
+        task = create_task(
+            CaptureSampleData,
+            {
+                "dataset": "mydataset",
+                "extraction_definition": Path("xyzzy.bbb.yml"),
+            },
+        )
+        with pytest.raises(TaskOptionsError, match="xyzzy.bbb.yml"):
+            task()