cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/tests/test_salesforce.py

@@ -0,0 +1,72 @@
+from unittest.mock import MagicMock, patch
+
+from cumulusci.core.config import (
+    BaseProjectConfig,
+    OrgConfig,
+    ServiceConfig,
+    TaskConfig,
+    UniversalConfig,
+)
+from cumulusci.core.keychain import BaseProjectKeychain
+from cumulusci.tasks.salesforce import BaseSalesforceApiTask
+
+
+@patch(
+    "cumulusci.core.tasks.BaseSalesforceTask._update_credentials",
+    MagicMock(return_value=None),
+)
+class TestSalesforceToolingTask:
+    def setup_method(self):
+        self.api_version = 36.0
+        self.universal_config = UniversalConfig(
+            {"project": {"package": {"api_version": self.api_version}}}
+        )
+        self.project_config = BaseProjectConfig(
+            self.universal_config, config={"noyaml": True}
+        )
+        self.project_config.config["project"] = {
+            "package": {"api_version": self.api_version}
+        }
+        self.project_config.config["services"] = {
+            "connectedapp": {"attributes": {"client_id": {}}}
+        }
+        self.keychain = BaseProjectKeychain(self.project_config, "")
+        self.project_config.set_keychain(self.keychain)
+
+        self.task_config = TaskConfig()
+        self.org_config = OrgConfig(
+            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
+        )
+        self.base_tooling_url = "{}/services/data/v{}/tooling/".format(
+            self.org_config.instance_url, self.api_version
+        )
+
+    def test_get_tooling_object(self):
+        task = BaseSalesforceApiTask(
+            self.project_config, self.task_config, self.org_config
+        )
+        task._init_task()
+        obj = task._get_tooling_object("TestObject")
+        url = self.base_tooling_url + "sobjects/TestObject/"
+        assert obj.base_url == url
+
+    def test_default_client_name(self):
+        task = BaseSalesforceApiTask(
+            self.project_config, self.task_config, self.org_config
+        )
+        task._init_task()
+        assert "Sforce-Call-Options" in task.sf.headers
+        assert "CumulusCI/" in task.sf.headers["Sforce-Call-Options"]
+
+    def test_connected_app_client_name(self):
+        self.project_config.keychain.set_service(
+            "connectedapp", "test_alias", ServiceConfig({"client_id": "test123"})
+        )
+
+        task = BaseSalesforceApiTask(
+            self.project_config, self.task_config, self.org_config
+        )
+        task._init_task()
+        assert "Sforce-Call-Options" in task.sf.headers
+        assert "CumulusCI/" not in task.sf.headers["Sforce-Call-Options"]
+        assert "test123" in task.sf.headers["Sforce-Call-Options"]

cumulusci/tasks/tests/test_sfdx.py

@@ -0,0 +1,105 @@
+""" Tests for the SFDX Command Wrapper"""
+
+
+from unittest import mock
+from unittest.mock import MagicMock, patch
+
+from cumulusci.core.config import (
+    BaseProjectConfig,
+    OrgConfig,
+    ScratchOrgConfig,
+    TaskConfig,
+    UniversalConfig,
+)
+from cumulusci.core.keychain import BaseProjectKeychain
+from cumulusci.core.tests.utils import MockLoggerMixin
+from cumulusci.tasks.command import CommandException
+from cumulusci.tasks.salesforce.tests.util import create_task
+from cumulusci.tasks.sfdx import SFDXBaseTask, SFDXJsonTask, SFDXOrgTask
+
+
+class TestSFDXBaseTask(MockLoggerMixin):
+    """Tests for the Base Task type"""
+
+    def setup_method(self):
+        self.universal_config = UniversalConfig()
+        self.project_config = BaseProjectConfig(
+            self.universal_config, config={"noyaml": True}
+        )
+        self.task_config = TaskConfig()
+
+        keychain = BaseProjectKeychain(self.project_config, "")
+        self.project_config.set_keychain(keychain)
+
+        self._task_log_handler.reset()
+        self.task_log = self._task_log_handler.messages
+
+    def test_base_task(self):
+        """The command is prefixed w/ sfdx"""
+
+        self.task_config.config["options"] = {"command": "org", "extra": "--help"}
+        task = SFDXBaseTask(self.project_config, self.task_config)
+
+        try:
+            task()
+        except CommandException:
+            pass
+
+        assert task.options["command"] == "org"
+        assert task._get_command() == "sf org --help"
+
+    @patch("cumulusci.tasks.command.Command._run_task", MagicMock(return_value=None))
+    def test_keychain_org_creds(self):
+        """Keychain org creds are passed by env var"""
+
+        self.task_config.config["options"] = {"command": "org --help"}
+        access_token = "00d123"
+        org_config = OrgConfig(
+            {
+                "instance_url": "https://test.salesforce.com",
+            },
+            "test",
+        )
+
+        def refresh_oauth_token(keychain):
+            org_config.config["access_token"] = access_token
+
+        org_config.refresh_oauth_token = mock.Mock(side_effect=refresh_oauth_token)
+        org_config.save = mock.Mock()
+
+        task = SFDXOrgTask(self.project_config, self.task_config, org_config)
+        task()
+
+        org_config.refresh_oauth_token.assert_called_once()
+        print(task._get_env())
+        assert "SF_ORG_INSTANCE_URL" in task._get_env()
+        assert "SF_TARGET_ORG" in task._get_env()
+        assert access_token in task._get_env()["SF_TARGET_ORG"]
+
+    def test_scratch_org_username(self):
+        """Scratch Org credentials are passed by -u flag"""
+        self.task_config.config["options"] = {"command": "org --help"}
+        org_config = ScratchOrgConfig({"username": "test@example.com"}, "test")
+
+        task = SFDXOrgTask(self.project_config, self.task_config, org_config)
+        assert "-o test@example.com" in task._get_command()
+
+
+class TestSFDXJsonTask:
+    def test_get_command(self):
+        task = create_task(SFDXJsonTask)
+        command = task._get_command()
+        print(command)
+        assert command == "sf project deploy start --json"
+
+    def test_process_output(self):
+        task = create_task(SFDXJsonTask)
+        task.logger = mock.Mock()
+        task._process_output("{}")
+        task.logger.info.assert_called_once_with("JSON = {}")
+
+    def test_process_output__json_parse_error(self):
+        task = create_task(SFDXJsonTask)
+        task.logger = mock.Mock()
+        task._process_output("{")
+        task.logger.error.assert_called_once()

cumulusci/tasks/tests/test_util.py

@@ -0,0 +1,207 @@
+import os
+import shutil
+from tempfile import mkdtemp
+from unittest import mock
+
+import pytest
+
+from cumulusci.core.config import (
+    BaseProjectConfig,
+    OrgConfig,
+    TaskConfig,
+    UniversalConfig,
+)
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.tasks import util
+from cumulusci.tests.util import DummyLogger
+
+
+class TestUtilTasks:
+    def setup_method(self, method):
+        self.old_dir = os.getcwd()
+        self.tempdir = mkdtemp()
+        os.chdir(self.tempdir)
+        os.mkdir(os.path.join(self.tempdir, ".git"))
+        self.universal_config = UniversalConfig()
+        self.project_config = BaseProjectConfig(
+            self.universal_config, config={"noyaml": True}
+        )
+        self.org_config = OrgConfig({}, "test")
+        self.task_config = TaskConfig({})
+
+    def teardown_method(self):
+        os.chdir(self.old_dir)
+        shutil.rmtree(self.tempdir)
+
+    @mock.patch("cumulusci.tasks.util.download_extract_zip")
+    def test_DownloadZip(self, download_extract_zip):
+        target = os.path.join(self.tempdir, "extracted")
+        task_config = TaskConfig({"options": {"url": "http://test", "dir": target}})
+        task = util.DownloadZip(self.project_config, task_config, self.org_config)
+        task()
+        download_extract_zip.assert_called_once_with("http://test", target, None)
+
+    def test_ListMetadataTypes(self):
+        os.mkdir(os.path.join(self.tempdir, "src"))
+        package_xml_path = os.path.join(self.tempdir, "src", "package.xml")
+        with open(package_xml_path, "w") as f:
+            f.write(
+                """<?xml version="1.0" encoding="UTF-8"?>
+<Package xmlns="http://soap.sforce.com/2006/04/metadata">
+    <types>
+        <members>Test__c</members>
+        <name>CustomObject</name>
+    </types>
+</Package>"""
+            )
+
+        task = util.ListMetadataTypes(
+            self.project_config, self.task_config, self.org_config
+        )
+        task.logger = DummyLogger()
+        task()
+
+        output = task.logger.get_output()
+        assert "Metadata types found" in output
+        assert "CustomObject" in output
+
+    @mock.patch("cumulusci.tasks.util.time")
+    def test_Sleep(self, time):
+        task_config = TaskConfig({"options": {"seconds": "1"}})
+        task = util.Sleep(self.project_config, task_config, self.org_config)
+        task()
+        time.sleep.assert_called_once_with(1)
+
+    def test_Delete__single_file(self):
+        file_path = os.path.join(self.tempdir, "file")
+        with open(file_path, "w"):
+            pass
+
+        task_config = TaskConfig({"options": {"path": "file"}})
+        task = util.Delete(self.project_config, task_config, self.org_config)
+        task()
+
+        assert not os.path.exists(file_path)
+
+    def test_Delete__glob(self):
+        target = os.path.join(self.tempdir, "dir1")
+        os.mkdir(target)
+        file_path = os.path.join(target, "file")
+        with open(file_path, "w"):
+            pass
+
+        task_config = TaskConfig({"options": {"path": ["*"], "chdir": target}})
+        task = util.Delete(self.project_config, task_config, self.org_config)
+        task()
+
+        assert not os.path.exists(file_path)
+
+    def test_Delete__subdir(self):
+        target = os.path.join(self.tempdir, "dir1")
+        os.mkdir(target)
+
+        task_config = TaskConfig({"options": {"path": "dir1"}})
+        task = util.Delete(self.project_config, task_config, self.org_config)
+        task()
+
+        assert not os.path.exists(target)
+
+    def test_Delete__no_match(self):
+        task_config = TaskConfig({"options": {"path": "bogus"}})
+        task = util.Delete(self.project_config, task_config, self.org_config)
+        task()
+
+    @mock.patch("cumulusci.tasks.util.find_replace")
+    def test_FindReplace(self, find_replace):
+        task_config = TaskConfig({"options": {"find": "foo", "path": ".", "max": 1}})
+        task = util.FindReplace(self.project_config, task_config, self.org_config)
+        task()
+        find_replace.assert_called_once()
+
+    @mock.patch("cumulusci.tasks.util.find_replace")
+    def test_FindReplace_env_replace_error(self, find_replace):
+        with pytest.raises(TaskOptionsError):
+            task_config = TaskConfig(
+                {
+                    "options": {
+                        "find": "foo",
+                        "replace": "bar",
+                        "env_replace": True,
+                        "path": ".",
+                        "max": 1,
+                    }
+                }
+            )
+            task = util.FindReplace(self.project_config, task_config, self.org_config)
+            task()
+            find_replace.assert_called_once()
+
+    @mock.patch("cumulusci.tasks.util.find_replace")
+    def test_FindReplace_env_replace(self, find_replace):
+        with mock.patch.dict(os.environ, {"bar": "bars"}):
+            task_config = TaskConfig(
+                {
+                    "options": {
+                        "find": "foo",
+                        "replace": "bar",
+                        "env_replace": True,
+                        "path": ".",
+                        "max": 1,
+                    }
+                }
+            )
+            task = util.FindReplace(self.project_config, task_config, self.org_config)
+            task()
+            assert task.parsed_options["replace"] == "bars"
+            find_replace.assert_called_once()
+            assert find_replace.mock_calls[0] == mock.call(
+                find="foo",
+                replace="bars",
+                directory=mock.ANY,
+                filePattern="*",
+                logger=mock.ANY,
+                max=1,
+            )
+
+    @mock.patch("cumulusci.tasks.util.find_replace_regex")
+    def test_FindReplaceRegex(self, find_replace_regex):
+        task_config = TaskConfig({"options": {"find": "foo", "path": "."}})
+        task = util.FindReplaceRegex(self.project_config, task_config, self.org_config)
+        task()
+        find_replace_regex.assert_called_once()
+
+    def test_CopyFile(self):
+        src = os.path.join(self.tempdir, "src")
+        with open(src, "w"):
+            pass
+        dest = os.path.join(self.tempdir, "dest")
+
+        task_config = TaskConfig({"options": {"src": src, "dest": dest}})
+        task = util.CopyFile(self.project_config, task_config, self.org_config)
+        task()
+
+        assert os.path.exists(dest)
+
+    def test_LogLine(self):
+        task_config = TaskConfig({"options": {"level": "debug", "line": "test"}})
+        task = util.LogLine(self.project_config, task_config, self.org_config)
+        task.logger = DummyLogger()
+        task()
+        output = task.logger.get_output()
+        assert output == "Beginning task: LogLine\n\ntest"
+
+    def test_PassOptionAsResult(self):
+        task_config = TaskConfig({"options": {"result": "test"}})
+        task = util.PassOptionAsResult(
+            self.project_config, task_config, self.org_config
+        )
+        task()
+        assert task.result == "test"
+
+    def test_PassOptionAsReturnValue(self):
+        task_config = TaskConfig({"options": {"key": "foo", "value": "bar"}})
+        task = util.PassOptionAsReturnValue(
+            self.project_config, task_config, self.org_config
+        )
+        result = task()
+        assert result["foo"] == "bar"

cumulusci/tasks/util.py

@@ -0,0 +1,261 @@
+import glob
+import os
+import shutil
+import time
+
+from defusedxml.minidom import parse
+
+from cumulusci.core.exceptions import TaskOptionsError
+from cumulusci.core.tasks import BaseTask
+from cumulusci.utils import download_extract_zip, find_replace, find_replace_regex
+from cumulusci.utils.options import (
+    CCIOptions,
+    DirectoryPath,
+    Field,
+    ListOfStringsOption,
+)
+
+
+class DownloadZip(BaseTask):
+    name = "Download"
+
+    class Options(CCIOptions):
+        url: str = Field(..., description="The url of the zip file to download")
+        dir: str = Field(
+            ..., description="The directory where the zip should be extracted"
+        )
+        subfolder: str = Field(
+            None,
+            description=(
+                "The subfolder of the target zip to extract. Defaults to"
+                + " extracting the root of the zip file to the destination."
+            ),
+        )
+
+    parsed_options: Options
+
+    def _run_task(self):
+        if not os.path.exists(self.parsed_options.dir):
+            os.makedirs(self.parsed_options.dir)
+
+        download_extract_zip(
+            self.parsed_options.url,
+            self.parsed_options.dir,
+            self.parsed_options.subfolder,
+        )
+
+
+class ListMetadataTypes(BaseTask):
+    name = "ListMetadataTypes"
+
+    class Options(CCIOptions):
+        package_xml: str = Field(
+            None,
+            description=(
+                "The project package.xml file."
+                + " Defaults to <project_root>/src/package.xml"
+            ),
+        )
+
+    def _init_options(self, kwargs):
+        super(ListMetadataTypes, self)._init_options(kwargs)
+        if not self.parsed_options.get("package_xml"):
+            self.parsed_options["package_xml"] = os.path.join(
+                self.project_config.repo_root, "src", "package.xml"
+            )
+
+    def _run_task(self):
+        dom = parse(self.parsed_options["package_xml"])
+        package = dom.getElementsByTagName("Package")[0]
+        types = package.getElementsByTagName("types")
+        type_list = []
+        for t in types:
+            name = t.getElementsByTagName("name")[0]
+            metadata_type = name.firstChild.nodeValue
+            type_list.append(metadata_type)
+        self.logger.info(
+            "Metadata types found in %s:\r\n%s",
+            self.parsed_options["package_xml"],
+            "\r\n".join(type_list),
+        )
+
+
+class Sleep(BaseTask):
+    name = "Sleep"
+
+    class Options(CCIOptions):
+        seconds: int = Field(..., description="The number of seconds to sleep")
+
+    parsed_options: Options
+
+    def _run_task(self):
+        self.logger.info("Sleeping for {} seconds".format(self.parsed_options.seconds))
+        time.sleep(float(self.parsed_options.seconds))
+        self.logger.info("Done")
+
+
+class Delete(BaseTask):
+    name = "Delete"
+
+    class Options(CCIOptions):
+        path: ListOfStringsOption = Field(
+            default=...,
+            description=(
+                "The path to delete. "
+                "If path is a directory, recursively deletes the directory: BE CAREFUL!!! "
+                "If path is a list, all paths will be deleted"
+            ),
+        )
+        chdir: DirectoryPath = Field(
+            default=None,
+            description=(
+                "Change directories before deleting path(s). "
+                "This is useful if you have a common list of relative paths to "
+                "delete that you want to call against different directories."
+            ),
+        )
+
+    def _run_task(self):
+        chdir = self.parsed_options.chdir
+        cwd = os.getcwd()
+        if chdir:
+            self.logger.info("Changing directory to {}".format(chdir))
+            os.chdir(chdir)
+
+        path = self.parsed_options.path
+        if not isinstance(path, list):
+            path = [path]
+        for path_item in path:
+            matches = glob.glob(path_item)
+            if matches:
+                for match in matches:
+                    self._delete(match)
+            else:
+                self.logger.info("{} does not exist, skipping delete".format(path))
+
+        if chdir:
+            os.chdir(cwd)
+
+    def _delete(self, path):
+        if os.path.isdir(path):
+            self.logger.info("Recursively deleting directory {}".format(path))
+            shutil.rmtree(path)
+        else:
+            self.logger.info("Deleting file {}".format(path))
+            os.remove(path)
+
+
+class FindReplaceOptions(CCIOptions):
+    find: str = Field(..., description="The string to search for")
+    replace: str = Field(
+        "",
+        description="The string to replace matches with. Defaults to an empty string",
+    )
+    path: DirectoryPath = Field(..., description="The path to recursively search")
+    file_pattern: ListOfStringsOption = Field(
+        "*",
+        description="A UNIX like filename pattern used for matching filenames, or a list of them. See python fnmatch docs for syntax. If passed via command line, use a comma separated string. Defaults to *",
+    )
+    env_replace: bool = Field(
+        False,
+        description="If True, treat the value of the replace option as the name of an environment variable, and use the value of that variable as the replacement string. Defaults to False",
+    )
+
+
+class FindReplace(BaseTask):
+    class Options(FindReplaceOptions):
+        max: int = Field(
+            None,
+            description="The max number of matches to replace.  Defaults to replacing all matches.",
+        )
+
+    parsed_options: Options
+
+    def _run_task(self):
+        kwargs = {}
+        if self.parsed_options.max:
+            kwargs["max"] = self.parsed_options.max
+
+        if self.parsed_options["env_replace"]:
+            if self.parsed_options["replace"] in os.environ.keys():
+                self.parsed_options["replace"] = os.environ[
+                    self.parsed_options["replace"]
+                ]
+            else:
+                raise TaskOptionsError(
+                    f"The environment variable {self.parsed_options['replace']} was not found. Ensure that this value is populated or set env_replace to False."
+                )
+
+        for file_pattern in self.parsed_options["file_pattern"]:
+            find_replace(
+                find=self.parsed_options.find,
+                replace=self.parsed_options.replace,
+                directory=self.parsed_options.path,
+                filePattern=file_pattern,
+                logger=self.logger,
+                **kwargs,
+            )
+
+
+class FindReplaceRegex(FindReplace):
+    class Options(FindReplaceOptions):
+        pass
+
+    def _run_task(self):
+        find_replace_regex(
+            find=self.parsed_options.find,
+            replace=self.parsed_options.replace,
+            directory=self.parsed_options.path,
+            filePattern=self.parsed_options.file_pattern,
+            logger=self.logger,
+        )
+
+
+class CopyFile(BaseTask):
+    task_options = {
+        "src": {"description": "The path to the source file to copy", "required": True},
+        "dest": {
+            "description": "The destination path where the src file should be copied",
+            "required": True,
+        },
+    }
+
+    def _run_task(self):
+        self.logger.info("Copying file {src} to {dest}".format(**self.options))
+        shutil.copyfile(src=self.options["src"], dst=self.options["dest"])
+
+
+class LogLine(BaseTask):
+    task_options = {
+        "level": {"description": "The logger level to use", "required": True},
+        "line": {"description": "A formatstring like line to log", "required": True},
+        "format_vars": {"description": "A Dict of format vars", "required": False},
+    }
+
+    def _init_options(self, kwargs):
+        super(LogLine, self)._init_options(kwargs)
+        if "format_vars" not in self.options:
+            self.options["format_vars"] = {}
+
+    def _run_task(self):
+        log = getattr(self.logger, self.options["level"])
+        log(self.options["line"].format(**self.options["format_vars"]))
+
+
+class PassOptionAsResult(BaseTask):
+    task_options = {
+        "result": {"description": "The result for the task", "required": True}
+    }
+
+    def _run_task(self):
+        return self.options["result"]
+
+
+class PassOptionAsReturnValue(BaseTask):
+    task_options = {
+        "key": {"required": True, "description": "The return value key to use."},
+        "value": {"required": True, "description": "The value to set."},
+    }
+
+    def _run_task(self):
+        self.return_values[self.options["key"]] = self.options["value"]

cumulusci/tasks/vcs/__init__.py

@@ -0,0 +1,19 @@
+from cumulusci.tasks.vcs.merge import MergeBranch
+from cumulusci.tasks.vcs.commit_status import GetPackageDataFromCommitStatus
+from cumulusci.tasks.vcs.publish import PublishSubtree
+from cumulusci.tasks.vcs.pull_request import PullRequests
+from cumulusci.tasks.vcs.release import CreateRelease
+from cumulusci.tasks.vcs.release_report import ReleaseReport
+from cumulusci.tasks.vcs.tag import CloneTag
+from cumulusci.tasks.vcs.create_commit_status import CreatePackageDataFromCommitStatus
+
+__all__ = (
+    "MergeBranch",
+    "CloneTag",
+    "GetPackageDataFromCommitStatus",
+    "PublishSubtree",
+    "PullRequests",
+    "CreateRelease",
+    "ReleaseReport",
+    "CreatePackageDataFromCommitStatus",
+)