cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/tasks/vcs/publish.py

@@ -0,0 +1,207 @@
+import copy
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from cumulusci.core.exceptions import TaskOptionsError, VcsException, VcsNotFoundError
+from cumulusci.core.utils import process_bool_arg, process_list_arg
+from cumulusci.tasks.base_source_control_task import BaseSourceControlTask
+from cumulusci.utils import download_extract_vcs_from_repo, filter_namelist
+from cumulusci.vcs.base import VCSService
+from cumulusci.vcs.bootstrap import get_service_for_repo_url, get_tag_by_name
+from cumulusci.vcs.models import AbstractGitTag, AbstractRelease, AbstractRepo
+
+if TYPE_CHECKING:
+    from cumulusci.vcs.utils import AbstractCommitDir
+
+
+class PublishSubtree(BaseSourceControlTask):
+    task_options = {  # TODO: should use `class Options instead`
+        "repo_url": {"description": "The url to the public repo", "required": True},
+        "branch": {
+            "description": "The branch to update in the target repo",
+            "required": True,
+        },
+        "version": {
+            "description": "(Deprecated >= 3.42.0) Only the values of 'latest' and 'latest_beta' are acceptable. "
+            "Required if 'ref' or 'tag_name' is not set. This will override tag_name if it is provided."
+        },
+        "tag_name": {
+            "description": "The name of the tag that should be associated with this release. "
+            "Values of 'latest' and 'latest_beta' are also allowed. "
+            "Required if 'ref' or 'version' is not set."
+        },
+        "ref": {
+            "description": "The git reference to publish.  Takes precedence over 'version' and 'tag_name'. "
+            "Required if 'tag_name' is not set."
+        },
+        "include": {
+            "description": "A list of paths from repo root to include. Directories must end with a trailing slash."
+        },
+        "renames": {
+            "description": "A list of paths to rename in the target repo, given as `local:` `target:` pairs."
+        },
+        "create_release": {
+            "description": "If True, create a release in the public repo.  Defaults to False"
+        },
+        "release_body": {
+            "description": "If True, the entire release body will be published to the public repo.  Defaults to False"
+        },
+        "dry_run": {
+            "description": "If True, skip creating Github data.  Defaults to False"
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+        self.options["include"] = process_list_arg(
+            self.options.get(
+                "include", ["datasets/", "documentation/", "tasks/", "unpackaged/"]
+            )
+        )
+
+        self.options["renames"] = self._process_renames(self.options.get("renames", []))
+
+        if "version" in self.options:  # pragma: no cover
+            self.logger.warning(
+                "The `version` option is deprecated. Please use the `tag_name` option instead."
+            )
+            if self.options["version"] not in ("latest", "latest_beta"):
+                raise TaskOptionsError(
+                    f"Only `latest` and `latest_beta` are valid values for the `version` option. Found: {self.options['version']}"
+                )
+
+        if (
+            "ref" not in self.options
+            and "tag_name" not in self.options
+            and "version" not in self.options
+        ):
+            raise TaskOptionsError("Either `ref` or `tag_name` option is required.")
+
+        self.options["create_release"] = process_bool_arg(
+            self.options.get("create_release", False)
+        )
+        self.options["release_body"] = process_bool_arg(
+            self.options.get("release_body", False)
+        )
+        self.options["dry_run"] = process_bool_arg(self.options.get("dry_run", False))
+
+    def _process_renames(self, renamed_paths):
+        """
+        For each entry in renames, any renames and store them
+        in self.local_to_target_paths.
+        """
+        if not renamed_paths:
+            return {}
+
+        is_list_of_dicts = all(isinstance(pair, dict) for pair in renamed_paths)
+        dicts_have_correct_keys = is_list_of_dicts and all(
+            {"local", "target"} == pair.keys() for pair in renamed_paths
+        )
+
+        ERROR_MSG = (
+            "Renamed paths must be a list of dicts with `local:` and `target:` keys."
+        )
+        if not dicts_have_correct_keys:
+            raise TaskOptionsError(ERROR_MSG)
+
+        local_to_target_paths = {}
+
+        for rename in renamed_paths:
+            local_path = rename.get("local")
+            target_path = rename.get("target")
+
+            if local_path and target_path:
+                local_to_target_paths[local_path] = target_path
+            else:
+                raise TaskOptionsError(ERROR_MSG)
+
+        return local_to_target_paths
+
+    def _get_target_repo_api(self) -> AbstractRepo:
+        target_vcs_service: VCSService = get_service_for_repo_url(
+            self.project_config, self.options["repo_url"]
+        )
+        target_vcs_service.logger = self.logger
+        repo_options = copy.deepcopy(self.options)
+        repo_options.update({"repository_url": self.options["repo_url"]})
+        return target_vcs_service.get_repository(options=repo_options)
+
+    def _run_task(self):
+        self.target_repo = self._get_target_repo_api()
+        self._set_ref()
+
+        with tempfile.TemporaryDirectory() as target:
+            self._download_repo_and_extract(target)
+            self._rename_files(target)
+            commit = self._create_commit(target)
+            if commit and self.options["create_release"]:
+                self._create_release(target, commit.sha)
+
+    def _set_ref(self):
+        from cumulusci.vcs.utils import get_ref_from_options
+
+        self.ref = get_ref_from_options(self.project_config, self.options)
+        self.tag_name = self.ref[5:] if self.ref.startswith("tags/") else None
+
+    def _download_repo_and_extract(self, path):
+        zf = download_extract_vcs_from_repo(self.get_repo(), ref=self.ref)
+        included_members = filter_namelist(
+            includes=self.options["include"], namelist=zf.namelist()
+        )
+        zf.extractall(path=path, members=included_members)
+
+    def _rename_files(self, zip_dir):
+        for local_name, target_name in self.options["renames"].items():
+            local_path = Path(zip_dir, local_name)
+            if local_path.exists():
+                target_path = Path(zip_dir, target_name)
+                target_path.parent.mkdir(parents=True, exist_ok=True)
+                local_path.replace(target_path)
+
+    def _create_commit(self, path):
+        committer: AbstractCommitDir = self.vcs_service.get_committer(self.target_repo)
+        message = f"Published content from ref {self.ref}"
+        if "tag_name" in self.options:
+            message += f"\n\nTag {self.tag_name}"
+        return committer(
+            path,
+            self.options["branch"],
+            repo_dir="",
+            commit_message=message,
+            dry_run=self.options["dry_run"],
+        )
+
+    def _create_release(self, path, commit):
+        repo: AbstractRepo = self.get_repo()
+        tag: AbstractGitTag = get_tag_by_name(repo, self.tag_name)
+
+        # Get the release
+        release: AbstractRelease = repo.release_from_tag(self.tag_name)
+        release_body: str = release.body if self.options["release_body"] else ""
+
+        # Check for tag in target repo
+        try:
+            self.target_repo.get_ref_for_tag(self.tag_name)
+        except VcsNotFoundError:
+            pass
+        else:
+            message = f"Ref for tag {self.tag_name} already exists in target repo"
+            raise VcsException(message)
+
+        # Create the tag
+        self.target_repo.create_tag(
+            tag_name=self.tag_name,
+            message=tag.message,
+            sha=commit,
+            obj_type="commit",
+            lightweight=False,
+        )
+
+        # Create the release
+        self.target_repo.create_release(
+            tag_name=self.tag_name,
+            name=self.project_config.get_version_for_tag(self.tag_name),
+            prerelease=release.prerelease,
+            body=release_body,
+        )

cumulusci/tasks/vcs/pull_request.py

@@ -0,0 +1,9 @@
+from cumulusci.tasks.base_source_control_task import BaseSourceControlTask
+from cumulusci.vcs.models import AbstractRepo
+
+
+class PullRequests(BaseSourceControlTask):
+    def _run_task(self):
+        repo: AbstractRepo = self.get_repo()
+        for pr in repo.pull_requests(state="open"):
+            self.logger.info("#{}: {}".format(pr.number, pr.title))

cumulusci/tasks/vcs/release.py

@@ -0,0 +1,134 @@
+import json
+import time
+
+from cumulusci.core.dependencies import parse_dependencies
+from cumulusci.core.dependencies.resolvers import get_static_dependencies
+from cumulusci.core.exceptions import TaskOptionsError, VcsException, VcsNotFoundError
+from cumulusci.tasks.base_source_control_task import BaseSourceControlTask
+from cumulusci.vcs.models import AbstractRelease, AbstractRepo
+
+
+class CreateRelease(BaseSourceControlTask):
+
+    task_options = {
+        "version": {
+            "description": "The managed package version number.  Ex: 1.2",
+            "required": True,
+        },
+        "version_id": {
+            "description": "The SubscriberPackageVersionId (04t) associated with this release.",
+            "required": False,
+        },
+        "message": {"description": "The message to attach to the created git tag"},
+        "release_content": {
+            "description": "The content to include as the release body. Note: vcs_release_notes will overwrite this content, if used."
+        },
+        "dependencies": {
+            "description": "List of dependencies to record in the tag message."
+        },
+        "commit": {
+            "description": (
+                "Override the commit used to create the release. "
+                "Defaults to the current local HEAD commit"
+            )
+        },
+        "resolution_strategy": {
+            "description": "The name of a sequence of resolution_strategy (from project__dependency_resolutions) to apply to dynamic dependencies. Defaults to 'production'."
+        },
+        "package_type": {
+            "description": "The package type of the project (either 1GP or 2GP)",
+            "required": True,
+        },
+        "tag_prefix": {
+            "description": "The prefix to use for the release tag created in VCS.",
+            "required": True,
+        },
+    }
+
+    def _init_options(self, kwargs):
+        super()._init_options(kwargs)
+
+        self.commit = self.options.get("commit", self.project_config.repo_commit)
+        if not self.commit:
+            message = "Could not detect the current commit from the local repo"
+            self.logger.error(message)
+            raise VcsException(message)
+        if len(self.commit) != 40:
+            raise TaskOptionsError("The commit option must be exactly 40 characters.")
+
+    def _run_task(self):
+        repo: AbstractRepo = self.get_repo()
+        version = self.options["version"]
+        tag_prefix = self.options.get("tag_prefix", "")
+        tag_name = self.project_config.get_tag_for_version(tag_prefix, version)
+
+        self._verify_release(repo, tag_name)
+        self._verify_commit(repo)
+
+        # Build tag message
+        message = self.options.get("message", "Release of version {}".format(version))
+        if self.options.get("version_id"):
+            message += f"\n\nversion_id: {self.options['version_id']}"
+        if self.options.get("package_type"):
+            message += f"\n\npackage_type: {self.options['package_type']}"
+        dependencies = get_static_dependencies(
+            self.project_config,
+            dependencies=parse_dependencies(
+                self.options.get("dependencies")
+                or self.project_config.project__dependencies,
+            ),
+            resolution_strategy=self.options.get("resolution_strategy") or "production",
+        )
+        if dependencies:
+            dependencies = [d.dict(exclude_none=True) for d in dependencies]
+            message += "\n\ndependencies: {}".format(json.dumps(dependencies, indent=4))
+
+        try:
+            repo.get_ref_for_tag(tag_name)
+        except VcsNotFoundError:
+            # Create the annotated tag
+            repo.create_tag(
+                tag_name=tag_name,
+                message=message,
+                sha=self.commit,
+                obj_type="commit",
+                lightweight=False,
+            )
+
+            # Sleep for Github to catch up with the fact that the tag actually exists!
+            time.sleep(3)
+
+        prerelease = tag_name.startswith(self.project_config.project__git__prefix_beta)
+
+        # Create the Github Release
+        release_parameters = {
+            "tag_name": tag_name,
+            "name": version,
+            "prerelease": prerelease,
+        }
+        if "release_content" in self.options:
+            release_parameters["body"] = self.options["release_content"]
+        release = repo.create_release(**release_parameters, options=self.options)
+        self.return_values = {
+            "tag_name": tag_name,
+            "name": version,
+            "dependencies": dependencies,
+        }
+        self.logger.info(f"Created release {release.name} at {release.html_url}")
+
+    def _verify_release(self, repo: AbstractRepo, tag_name: str) -> None:
+        """Make sure release doesn't already exist"""
+        try:
+            release: AbstractRelease = repo.release_from_tag(tag_name)
+            if release is None or release.updateable:
+                raise VcsNotFoundError
+        except VcsNotFoundError:
+            pass
+        else:
+            message = f"Release {release.name} already exists at {release.html_url}"
+            self.logger.error(message)
+            raise VcsException(message)
+
+    def _verify_commit(self, repo: AbstractRepo) -> None:
+        """Verify that the commit exists on the remote."""
+        repo.get_commit(self.commit)

cumulusci/tasks/vcs/release_report.py

@@ -0,0 +1,105 @@
+import json
+import re
+
+from cumulusci.core.utils import parse_datetime, process_bool_arg
+from cumulusci.tasks.base_source_control_task import BaseSourceControlTask
+from cumulusci.vcs.models import AbstractRepo
+
+
+class ReleaseReport(BaseSourceControlTask):
+    task_options = {  # TODO: should use `class Options instead`
+        "date_start": {
+            "description": "Filter out releases created before this date (YYYY-MM-DD)"
+        },
+        "date_end": {
+            "description": "Filter out releases created after this date (YYYY-MM-DD)"
+        },
+        "include_beta": {
+            "description": "Include beta releases in report [default=False]"
+        },
+        "print": {"description": "Print info to screen as JSON [default=False]"},
+    }
+    DATE_FORMAT = "%Y-%m-%d"
+
+    def _init_options(self, kwargs):
+        super(ReleaseReport, self)._init_options(kwargs)
+        self.options["date_start"] = (
+            parse_datetime(self.options["date_start"], self.DATE_FORMAT)
+            if "date_start" in self.options
+            else None
+        )
+        self.options["date_end"] = (
+            parse_datetime(self.options["date_end"], self.DATE_FORMAT)
+            if "date_end" in self.options
+            else None
+        )
+        self.options["include_beta"] = process_bool_arg(
+            self.options.get("include_beta", False)
+        )
+        self.options["print"] = process_bool_arg(self.options.get("print", False))
+
+    def _run_task(self):
+        releases = []
+        repo: AbstractRepo = self.get_repo()
+        regex_compiled_prefix = re.compile(
+            r"^((?P<sandbox>{})|(?P<production>{}))(?P<remaining>.*)$".format(
+                self.project_config.project__git__push_prefix_sandbox,
+                self.project_config.project__git__push_prefix_production,
+            )
+        )
+        regex_compiled_date = re.compile(r"\s*(?P<date>\d\d\d\d-\d\d-\d\d)")
+        for release in repo.releases():
+            if release.prerelease and not self.options["include_beta"]:
+                continue
+            if (
+                self.options["date_start"]
+                and release.created_at < self.options["date_start"]
+            ):
+                continue
+            if (
+                self.options["date_end"]
+                and release.created_at > self.options["date_end"]
+            ):
+                continue
+            release_info = {
+                "url": release.html_url,
+                "name": release.name,
+                "tag": release.tag_name,
+                "beta": release.prerelease,
+                "time_created": release.created_at,
+                "time_push_sandbox": None,
+                "time_push_production": None,
+            }
+            release_body = release.body or ""
+            for line in release_body.splitlines():
+                m = regex_compiled_prefix.match(line)
+                if m:
+                    if not m.group("remaining"):
+                        self.logger.warning(
+                            "[%s] Nothing found after push date prefix: %s",
+                            release_info["url"],
+                            line,
+                        )
+                        continue
+                    m2 = regex_compiled_date.match(m.group("remaining"))
+                    if not m2:
+                        self.logger.warning(
+                            (
+                                "[%s] Could not find date in line: %s\n"
+                                "Use the format YYYY-MM-DD"
+                            ),
+                            release_info["url"],
+                            line,
+                        )
+                        continue
+                    if m.group("sandbox"):
+                        key = "time_push_sandbox"
+                    else:
+                        key = "time_push_production"
+                    release_info[key] = parse_datetime(
+                        m2.group("date"), self.DATE_FORMAT
+                    )
+            releases.append(release_info)
+        self.return_values = {"releases": releases}
+        if self.options["print"]:
+            print(json.dumps(releases, indent=4, sort_keys=True, default=str))

cumulusci/tasks/vcs/tag.py

@@ -0,0 +1,31 @@
+from cumulusci.tasks.base_source_control_task import BaseSourceControlTask
+from cumulusci.vcs.bootstrap import get_tag_by_name
+from cumulusci.vcs.models import AbstractGitTag, AbstractRepo
+
+
+class CloneTag(BaseSourceControlTask):
+    task_options = {  # TODO: should use `class Options instead`
+        "src_tag": {
+            "description": "The source tag to clone.  Ex: beta/1.0-Beta_2",
+            "required": True,
+        },
+        "tag": {
+            "description": "The new tag to create by cloning the src tag.  Ex: release/1.0",
+            "required": True,
+        },
+    }
+
+    def _run_task(self):
+        src_tag_name = self.options["src_tag"]
+        repo: AbstractRepo = self.get_repo()
+        src_tag: AbstractGitTag = get_tag_by_name(repo, src_tag_name)
+
+        tag: AbstractGitTag = repo.create_tag(
+            tag_name=self.options["tag"],
+            message=f"Cloned from {src_tag_name}",
+            sha=src_tag.sha,
+            obj_type="commit",
+        )
+        self.logger.info(f"Tag {self.options['tag']} created by cloning {src_tag_name}")
+
+        return tag

cumulusci/tasks/vcs/tests/github/test_commit_status.py

@@ -0,0 +1,196 @@
+from datetime import datetime
+
+import pytest
+import responses
+
+from cumulusci.core.config import OrgConfig, ServiceConfig, TaskConfig
+from cumulusci.core.exceptions import DependencyLookupError
+from cumulusci.tasks.github.tests.util_github_api import GithubApiTestMixin
+from cumulusci.tasks.vcs.commit_status import GetPackageDataFromCommitStatus
+from cumulusci.tests.util import CURRENT_SF_API_VERSION, create_project_config
+
+
+class TestGetPackageDataFromCommitStatus(GithubApiTestMixin):
+    @responses.activate
+    def test_run_task(self):
+        self.init_github()
+        repo_response = self._get_expected_repo("TestOwner", "TestRepo")
+        now = datetime.now().isoformat()
+        responses.add(method=responses.GET, url=self.repo_api_url, json=repo_response)
+        responses.add(
+            method=responses.GET,
+            url=f"{self.repo_api_url}/commits/abcdef",
+            json=self._get_expected_commit("abcdef"),
+        )
+        responses.add(
+            method=responses.GET,
+            url=f"{self.repo_api_url}/commits/abcdef/status",
+            json={
+                "url": f"{self.repo_api_url}/abcdef/status",
+                "commit_url": f"{self.repo_api_url}/abcdef",
+                "repository": repo_response,
+                "sha": "abcdef",
+                "state": "success",
+                "statuses": [
+                    {
+                        "context": "2gp",
+                        "created_at": now,
+                        "updated_at": now,
+                        "description": "version_id: 04t_1",
+                        "id": 1,
+                        "state": "success",
+                        "target_url": None,
+                        "url": f"{self.repo_api_url}/statuses/abcdef",
+                    }
+                ],
+                "total_count": 1,
+            },
+        )
+        responses.add(
+            "GET",
+            f"https://salesforce/services/data/v{CURRENT_SF_API_VERSION}/tooling/query/",
+            json={
+                "records": [
+                    {"Dependencies": {"ids": [{"subscriberPackageVersionId": "04t_2"}]}}
+                ]
+            },
+        )
+
+        project_config = create_project_config(repo_commit="abcdef")
+        project_config.keychain.set_service(
+            "github",
+            "test_alias",
+            ServiceConfig(
+                {
+                    "username": "TestUser",
+                    "token": "TestPass",
+                    "email": "testuser@testdomain.com",
+                }
+            ),
+        )
+        task_config = TaskConfig({"options": {"context": "2gp"}})
+        org_config = OrgConfig(
+            {"instance_url": "https://salesforce", "access_token": "TOKEN"}, "test"
+        )
+        task = GetPackageDataFromCommitStatus(project_config, task_config, org_config)
+        task._init_task()
+        task._run_task()
+        assert task.return_values == {
+            "version_id": "04t_1",
+            "dependencies": [{"version_id": "04t_2"}],
+        }
+
+    @responses.activate
+    def test_run_task__commit_not_found(self):
+        self.init_github()
+        responses.add(
+            method=responses.GET,
+            url=self.repo_api_url,
+            json=self._get_expected_repo("TestOwner", "TestRepo"),
+        )
+        responses.add(
+            method=responses.GET, url=f"{self.repo_api_url}/commits/abcdef", status=422
+        )
+
+        project_config = create_project_config(repo_commit="abcdef")
+        project_config.keychain.set_service(
+            "github",
+            "test_alias",
+            ServiceConfig(
+                {
+                    "username": "TestUser",
+                    "token": "TestPass",
+                    "email": "testuser@testdomain.com",
+                }
+            ),
+        )
+        task_config = TaskConfig({"options": {"context": "2gp"}})
+        org_config = OrgConfig(
+            {"instance_url": "https://salesforce", "access_token": "TOKEN"}, "test"
+        )
+        task = GetPackageDataFromCommitStatus(project_config, task_config, org_config)
+        task._init_task()
+        with pytest.raises(
+            DependencyLookupError,
+            match="Could not find package version id in '2gp' commit status for commit abcdef.",
+        ):
+            task._run_task()
+
+    @responses.activate
+    def test_run_task__status_not_found(self):
+        self.init_github()
+        repo_response = self._get_expected_repo("TestOwner", "TestRepo")
+        responses.add(method=responses.GET, url=self.repo_api_url, json=repo_response)
+        responses.add(
+            method=responses.GET,
+            url=f"{self.repo_api_url}/commits/abcdef",
+            json=self._get_expected_commit("abcdef"),
+        )
+        responses.add(
+            method=responses.GET,
+            url=f"{self.repo_api_url}/commits/abcdef/status",
+            json={
+                "url": f"{self.repo_api_url}/abcdef/status",
+                "commit_url": f"{self.repo_api_url}/abcdef",
+                "repository": repo_response,
+                "sha": "abcdef",
+                "state": "success",
+                "statuses": [],
+                "total_count": 0,
+            },
+        )
+
+        project_config = create_project_config(repo_commit="abcdef")
+        project_config.keychain.set_service(
+            "github",
+            "test_alias",
+            ServiceConfig(
+                {
+                    "username": "TestUser",
+                    "token": "TestPass",
+                    "email": "testuser@testdomain.com",
+                }
+            ),
+        )
+        task_config = TaskConfig({"options": {"context": "2gp"}})
+        org_config = OrgConfig(
+            {"instance_url": "https://salesforce", "access_token": "TOKEN"}, "test"
+        )
+        task = GetPackageDataFromCommitStatus(project_config, task_config, org_config)
+        task._init_task()
+        with pytest.raises(
+            DependencyLookupError,
+            match="Could not find package version id in '2gp' commit status",
+        ):
+            task._run_task()
+
+    @responses.activate
+    def test_get_dependencies__version_not_found(self):
+        responses.add(
+            "GET",
+            f"https://salesforce/services/data/v{CURRENT_SF_API_VERSION}/tooling/query/",
+            json={"records": []},
+        )
+
+        project_config = create_project_config(repo_commit="abcdef")
+        project_config.keychain.set_service(
+            "github",
+            "test_alias",
+            ServiceConfig(
+                {
+                    "username": "TestUser",
+                    "token": "TestPass",
+                    "email": "testuser@testdomain.com",
+                }
+            ),
+        )
+        task_config = TaskConfig({"options": {"context": "2gp"}})
+        org_config = OrgConfig(
+            {"instance_url": "https://salesforce", "access_token": "TOKEN"}, "test"
+        )
+        task = GetPackageDataFromCommitStatus(project_config, task_config, org_config)
+        task._init_task()
+        with pytest.raises(
+            DependencyLookupError, match="Could not look up dependencies of 04t"
+        ):
+            task._get_dependencies("04t")