cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/core/metadeploy/api.py

@@ -0,0 +1,88 @@
+"""Calls to the MetaDeploy REST API."""
+
+import functools
+from typing import Optional, Union
+
+from requests.models import Response
+from requests.sessions import Session
+
+from cumulusci.core.config import ServiceConfig
+from cumulusci.core.exceptions import CumulusCIException
+from cumulusci.utils.http.requests_utils import safe_json_from_response
+
+
+def make_api_session(metadeploy_service: ServiceConfig) -> Session:
+    """
+    Given a MetaDeploy ServiceConfig, returns a requests.Session with
+    authorization headers and service.base_url set.
+    """
+    base_url: str = metadeploy_service.url
+
+    patched_session = Session()
+    patched_session.headers["Authorization"] = f"token {metadeploy_service.token}"
+
+    def patched_request(base, func, method, url, *args, **kwargs):
+        """Call requests.request with base_url prepended."""
+        base_url = base + url.replace(base, "", 1)
+        return func(method, base_url, *args, **kwargs)
+
+    patched_session.request = functools.partial(
+        patched_request, base_url, patched_session.request
+    )
+
+    return patched_session
+
+
+class MetaDeployAPI:
+    def __init__(self, metadeploy_service: ServiceConfig) -> None:
+        self.session: Session = make_api_session(metadeploy_service=metadeploy_service)
+
+    def _create(self, obj: str, json: dict) -> dict:
+        response: Response = self.session.post(obj, json=json)
+        return safe_json_from_response(response)
+
+    def _find(self, obj: str, query: Union[dict, str]) -> Optional[dict]:
+        response: Response = self.session.get(obj, params=query)
+        result: dict = safe_json_from_response(response)
+
+        try:
+            return result["data"][0]
+        except IndexError:
+            return None
+        except KeyError:
+            raise CumulusCIException(
+                "CumulusCI received an unexpected response from MetaDeploy. "
+                "Ensure that your MetaDeploy service is configured with the Admin API URL, which "
+                "ends in /rest, and that your authentication token is valid."
+            ) from None
+
+    def create_plan(self, plan: dict) -> dict:
+        return self._create("/plans", plan)
+
+    def create_plan_template(self, template: dict) -> dict:
+        return self._create("/plantemplates", json=template)
+
+    def create_plan_slug(self, slug: dict) -> dict:
+        return self._create("/planslug", json=slug)
+
+    def create_version(self, version: dict) -> dict:
+        return self._create("/versions", json=version)
+
+    def find_product(self, repo_url: str) -> Optional[dict]:
+        return self._find("/products", {"repo_url": repo_url})
+
+    def find_plan_template(self, query: dict) -> Optional[dict]:
+        return self._find("/plantemplates", query)
+
+    def find_version(self, query: dict) -> Optional[dict]:
+        return self._find("/versions", query)
+
+    def update_version(self, pk: Union[int, str]) -> dict:
+        response: Response = self.session.patch(
+            f"/versions/{pk}", json={"is_listed": True}
+        )
+        return safe_json_from_response(response)
+
+    def update_lang_translation(self, lang: str, labels: dict) -> dict:
+        response: Response = self.session.patch(f"/translations/{lang}", json=labels)
+        return safe_json_from_response(response)

cumulusci/core/metadeploy/plans.py

@@ -0,0 +1,25 @@
+"""Utilities for working with MetaDeploy plans"""
+
+from cumulusci.core.config import FlowConfig, TaskConfig
+from cumulusci.core.flowrunner import FlowCoordinator
+from cumulusci.utils import cd
+
+
+def get_frozen_steps(project_config, plan_config):
+    """Return a list of frozen steps for a MetaDeploy plan config"""
+    flow_config = FlowConfig(plan_config)
+    flow_config.project_config = project_config
+    flow = FlowCoordinator(project_config, flow_config)
+    steps = []
+    for step in flow.steps:
+        if step.skip:
+            continue
+        with cd(step.project_config.repo_root):
+            assert step.task_class
+            task = step.task_class(
+                step.project_config,
+                TaskConfig(step.task_config),
+                name=step.task_name,
+            )
+            steps.extend(task.freeze(step))
+    return steps

cumulusci/core/metadeploy/tests/test_api.py

@@ -0,0 +1,276 @@
+import pytest
+import responses
+from requests.models import Response
+from requests.sessions import Session
+from responses import matchers
+
+from cumulusci.core.config import ServiceConfig
+from cumulusci.core.exceptions import CumulusCIException
+from cumulusci.core.metadeploy.api import MetaDeployAPI, make_api_session
+
+pytestmark = pytest.mark.metadeploy
+DEFAULT_REST_URL: str = "https://metadeploy.example.com/api/rest"
+DEFAULT_TOKEN: str = "37b003aee9bdd744a6618e9fe12"
+
+
+@pytest.fixture
+def default_api_client():
+    return MetaDeployAPI(
+        metadeploy_service=ServiceConfig(
+            {"url": DEFAULT_REST_URL, "token": DEFAULT_TOKEN}
+        )
+    )
+
+
+@pytest.fixture
+def auth_header_matcher():
+    return matchers.header_matcher({"Authorization": f"token {DEFAULT_TOKEN}"})
+
+
+@responses.activate
+def test_make_api(auth_header_matcher):
+    expected_result: dict = {"data": [1]}
+    responses.add(
+        "GET",
+        f"{DEFAULT_REST_URL}/resource",
+        json=expected_result,
+        match=[auth_header_matcher],
+    )
+    responses.add(
+        "POST",
+        f"{DEFAULT_REST_URL}/resource",
+        json=expected_result,
+        match=[auth_header_matcher],
+    )
+    service: ServiceConfig = ServiceConfig(
+        {"url": f"{DEFAULT_REST_URL}", "token": DEFAULT_TOKEN}
+    )
+    api_session: Session = make_api_session(service)
+    resp: Response = api_session.get("/resource")
+    result: dict = resp.json()
+    assert result == expected_result
+    _ = api_session.get(f"{DEFAULT_REST_URL}/resource")
+
+    assert responses.assert_call_count(f"{DEFAULT_REST_URL}/resource", 2) is True
+
+
+def test_find_product(default_api_client, auth_header_matcher):
+    params = {"repo_url": "https://api.github.com/repos/TestOwner/TestRepo"}
+    payload = {
+        "data": [
+            {
+                "id": "abcdef",
+                "url": "https://EXISTING_PRODUCT",
+                "slug": "existing",
+            }
+        ]
+    }
+
+    with responses.RequestsMock() as rsps:
+        rsps.add(
+            method=responses.GET,
+            url=f"{DEFAULT_REST_URL}/products",
+            match=(auth_header_matcher, matchers.query_param_matcher(params)),
+            json=payload,
+        )
+
+        product: dict = default_api_client.find_product(params["repo_url"])
+    assert product == payload["data"][0]
+
+
+def test_find_product__api_err(default_api_client, auth_header_matcher):
+    params = {"repo_url": "https://api.github.com/repos/TestOwner/MISSING"}
+    payload = {"result": []}
+
+    with pytest.raises(CumulusCIException, match="unexpected response"):
+        with responses.RequestsMock() as rsps:
+            rsps.add(
+                method=responses.GET,
+                url=f"{DEFAULT_REST_URL}/products",
+                match=(auth_header_matcher, matchers.query_param_matcher(params)),
+                json=payload,
+            )
+
+            default_api_client.find_product(params["repo_url"])
+
+
+def test_create_plan(default_api_client, auth_header_matcher):
+    payload = {"url": f"{DEFAULT_REST_URL}/plans/1"}
+    plan = {
+        "is_listed": True,
+        "plan_template": "https://foo.example.com/1",
+        "post_install_message_additional": "",
+        "preflight_message_additional": "",
+        "steps": [],
+        "supported_orgs": "persistent",
+        "tier": "primary",
+        "title": "Install Tubulator 1.0",
+        "version": f"{DEFAULT_REST_URL}/version/1",
+        "visible_to": None,
+    }
+
+    with responses.RequestsMock() as rsps:
+        rsps.add(
+            method=responses.POST,
+            url=f"{DEFAULT_REST_URL}/plans",
+            match=(auth_header_matcher, matchers.json_params_matcher(plan)),
+            status=201,
+            json=payload,
+        )
+        result = default_api_client.create_plan(plan)
+    assert result == payload
+
+
+def test_find_version(default_api_client, auth_header_matcher):
+    query = {"product": "bDcaVz", "label": "1.0"}
+    payload = {"data": [{"url": "http://EXISTING_VERSION"}]}
+
+    with responses.RequestsMock() as rsps:
+        rsps.add(
+            method=responses.GET,
+            url=f"{DEFAULT_REST_URL}/versions",
+            match=(auth_header_matcher, matchers.query_param_matcher(query)),
+            json=payload,
+        )
+
+        result = default_api_client.find_version(query)
+
+    assert result == payload["data"][0]
+
+
+def test_find_version_missing_none(default_api_client, auth_header_matcher):
+    query = {"product": "bDcaVz", "label": "1.0"}
+    payload = {"data": []}
+
+    with responses.RequestsMock() as rsps:
+        rsps.add(
+            method=responses.GET,
+            url=f"{DEFAULT_REST_URL}/versions",
+            match=(auth_header_matcher, matchers.query_param_matcher(query)),
+            json=payload,
+        )
+
+        result = default_api_client.find_version(query)
+
+    assert result is None
+
+
+def test_create_version(default_api_client, auth_header_matcher):
+    version = {
+        "product": f"{DEFAULT_REST_URL}/product/foo",
+        "label": "1.0",
+        "description": "",
+        "is_production": True,
+        "commit_ish": "tag_or_sha",
+        "is_listed": False,
+    }
+    payload = {"url": f"http://{DEFAULT_REST_URL}/versions/1", "id": 1}
+
+    with responses.RequestsMock() as rsps:
+        rsps.add(
+            method=responses.POST,
+            url=f"{DEFAULT_REST_URL}/versions",
+            match=(auth_header_matcher, matchers.json_params_matcher(version)),
+            status=201,
+            json=payload,
+        )
+
+        version = default_api_client.create_version(version)
+
+    assert version == payload
+
+
+def test_publish_version(default_api_client, auth_header_matcher):
+    vers = {"is_listed": True}
+    pk = "XG4pVvD"
+    payload = {"url": f"http://{DEFAULT_REST_URL}/versions/{pk}", "id": pk}
+
+    with responses.RequestsMock() as rsps:
+        rsps.add(
+            method=responses.PATCH,
+            url=f"{DEFAULT_REST_URL}/versions/{pk}",
+            match=(auth_header_matcher, matchers.json_params_matcher(vers)),
+            json=payload,
+        )
+
+        updated_version = default_api_client.update_version(pk)
+    assert payload == updated_version
+
+
+def test_find_plan_template(default_api_client, auth_header_matcher):
+    query = {"product": "bDcaVz", "name": "Shinra"}
+    payload = {"data": [{"url": "http://existing_template"}]}
+
+    with responses.RequestsMock() as rsps:
+        rsps.add(
+            method=responses.GET,
+            url=f"{DEFAULT_REST_URL}/plantemplates",
+            match=(auth_header_matcher, matchers.query_param_matcher(query)),
+            json=payload,
+        )
+
+        template = default_api_client.find_plan_template(query)
+
+    assert template == payload["data"][0]
+
+
+def test_create_plan_template(default_api_client, auth_header_matcher):
+    template = {
+        "name": "plan_name",
+        "product": "product",
+        "preflight_message": "",
+        "post_install_message": "",
+        "error_message": "oops",
+    }
+    payload = {"url": "http://EXISTING_VERSION"}
+
+    with responses.RequestsMock() as rsps:
+        rsps.add(
+            method=responses.POST,
+            url=f"{DEFAULT_REST_URL}/plantemplates",
+            match=(auth_header_matcher, matchers.json_params_matcher(template)),
+            status=201,
+            json=payload,
+        )
+
+        created_template = default_api_client.create_plan_template(template)
+
+    assert created_template == payload
+
+
+def test_create_plan_slug(default_api_client, auth_header_matcher):
+    slug = {"slug": "plan_name", "parent": "product"}
+    payload = {"url": "http://EXISTING_VERSION"}
+
+    with responses.RequestsMock() as rsps:
+        rsps.add(
+            method=responses.POST,
+            url=f"{DEFAULT_REST_URL}/planslug",
+            match=(auth_header_matcher, matchers.json_params_matcher(slug)),
+            status=201,
+            json=payload,
+        )
+
+        created_slug = default_api_client.create_plan_slug(slug)
+
+    assert created_slug == payload
+
+
+def test_publish_labels(default_api_client, auth_header_matcher):
+    lang = "en_us"
+    labels = {
+        "title": "name of product",
+        "error_message": "shown after failed installation (markdown)",
+    }
+    payload = {}
+
+    with responses.RequestsMock() as rsps:
+        rsps.add(
+            method=responses.PATCH,
+            url=f"{DEFAULT_REST_URL}/translations/{lang}",
+            match=(auth_header_matcher, matchers.json_params_matcher(labels)),
+            json=payload,
+        )
+
+        updated_txn = default_api_client.update_lang_translation(lang, labels)
+    assert payload == updated_txn

cumulusci/core/runtime.py

@@ -0,0 +1,115 @@
+import sys
+from abc import abstractmethod
+from typing import Optional, Type
+
+from cumulusci.core.config import BaseProjectConfig, UniversalConfig
+from cumulusci.core.debug import DebugMode, get_debug_mode
+from cumulusci.core.exceptions import NotInProject, ProjectConfigNotFound
+from cumulusci.core.flowrunner import FlowCallback, FlowCoordinator
+from cumulusci.core.keychain import BaseProjectKeychain
+
+
+# pylint: disable=assignment-from-none
+class BaseCumulusCI:
+    universal_config_class = UniversalConfig
+    project_config_class = BaseProjectConfig
+    keychain_class = BaseProjectKeychain
+    callback_class = FlowCallback
+
+    universal_config: UniversalConfig
+    project_config: Optional[BaseProjectConfig]
+    keychain: Optional[BaseProjectKeychain]
+    debug_mode: DebugMode
+    project_config_error: Exception
+
+    def __init__(self, *args, load_keychain=True, **kwargs):
+        self.keychain = None
+        self.debug_mode = get_debug_mode()
+
+        self._load_universal_config()
+
+        try:
+            self._load_project_config(*args, **kwargs)
+            self._add_repo_to_path()
+        except (NotInProject, ProjectConfigNotFound) as e:
+            self.project_config = None
+            self.project_config_error = e
+        if load_keychain:
+            self._load_keychain()
+
+    @property
+    def universal_config_cls(self) -> Type:
+        klass = self.get_universal_config_class()
+        return klass or self.universal_config_class
+
+    @abstractmethod
+    def get_universal_config_class(self) -> Optional[Type]:
+        return None
+
+    @property
+    def project_config_cls(self) -> Type:
+        klass = self.get_project_config_class()
+        return klass or self.project_config_class
+
+    @abstractmethod
+    def get_project_config_class(self) -> Optional[Type]:
+        return None
+
+    @property
+    def keychain_cls(self) -> Type:
+        klass = self.get_keychain_class()
+        return klass or self.keychain_class
+
+    @abstractmethod
+    def get_keychain_class(self) -> Optional[Type]:
+        return None
+
+    @property
+    def keychain_key(self):
+        return self.get_keychain_key()
+
+    @abstractmethod
+    def get_keychain_key(self):
+        return None
+
+    def _add_repo_to_path(self):
+        if self.project_config and self.project_config.repo_root:
+            sys.path.append(self.project_config.repo_root)
+
+    def _load_universal_config(self):
+        self.universal_config = self.universal_config_cls()
+
+    def _load_project_config(self, *args, **kwargs):
+        self.project_config = self.project_config_cls(
+            self.universal_config, *args, **kwargs
+        )
+        if self.project_config is not None:
+            self.project_config._add_tasks_directory_to_python_path()
+
+    def _load_keychain(self):
+        if self.keychain is not None:
+            return
+
+        keychain_key = self.keychain_key if self.keychain_cls.encrypted else None
+
+        if self.project_config is None:
+            self.keychain = self.keychain_cls(self.universal_config, keychain_key)
+        else:
+            self.keychain = self.keychain_cls(self.project_config, keychain_key)
+            self.project_config.keychain = self.keychain
+
+    def get_flow(self, name: str, options: Optional[dict] = None) -> FlowCoordinator:
+        """Get a primed and ready-to-go flow coordinator."""
+        if not self.project_config:
+            raise ProjectConfigNotFound
+        flow_config = self.project_config.get_flow(name)
+        callbacks = self.callback_class()
+        coordinator = FlowCoordinator(
+            flow_config.project_config,
+            flow_config,
+            name=flow_config.name,
+            options=options,
+            skip=None,
+            callbacks=callbacks,
+        )
+        return coordinator

cumulusci/core/sfdx.py

@@ -0,0 +1,162 @@
+import contextlib
+import io
+import json
+import logging
+import os
+import pathlib
+import platform
+import sys
+import typing as T
+from os import PathLike
+from zipfile import ZipFile
+
+import sarge
+
+# Fix for TextIOWrapper flush issue with sarge.Capture objects
+# Add flush method to sarge.Capture to prevent AttributeError during garbage collection
+if not hasattr(sarge.Capture, 'flush'):
+    def _capture_flush(self):
+        """No-op flush method for sarge.Capture compatibility with TextIOWrapper"""
+        pass
+    sarge.Capture.flush = _capture_flush
+
+from cumulusci.core.enums import StrEnum
+from cumulusci.core.exceptions import SfdxOrgException
+from cumulusci.utils import temporary_dir
+
+logger = logging.getLogger(__name__)
+
+
+def sfdx(
+    command,
+    username=None,
+    log_note=None,
+    access_token=None,
+    args: T.Optional[T.List[str]] = None,
+    env=None,
+    capture_output=True,
+    check_return=False,
+):
+    """Call an sfdx command and capture its output.
+
+    Be sure to quote user input that is part of the command using `shell_quote`.
+
+    Returns a `sarge` Command instance with returncode, stdout, stderr
+    """
+    command = f"sf {command}"
+    if args is not None:
+        for arg in args:
+            command += " " + shell_quote(arg)
+    if username:
+        command += f" -o {shell_quote(username)}"
+    if log_note:
+        logger.info(f"{log_note} with command: {command}")
+    # Avoid logging access token
+    if access_token:
+        command += f" -o {shell_quote(access_token)}"
+    env = env or {}
+    p = sarge.Command(
+        command,
+        stdout=sarge.Capture(buffer_size=-1) if capture_output else None,
+        stderr=sarge.Capture(buffer_size=-1) if capture_output else None,
+        shell=True,
+        env={**env, "SFDX_TOOL": "CCI"},
+    )
+    p.run()
+    if capture_output:
+        p.stdout_text = io.TextIOWrapper(p.stdout, encoding=sys.stdout.encoding)
+        p.stderr_text = io.TextIOWrapper(p.stderr, encoding=sys.stdout.encoding)
+    if check_return and p.returncode:
+        message = f"Command exited with return code {p.returncode}"
+        if capture_output:
+            message += f":\n{p.stderr_text.read()}"
+        raise Exception(message)
+    return p
+
+
+def shell_quote(s: str):
+    if platform.system() == "Windows":
+        assert isinstance(s, str)
+        if not s:
+            result = '""'
+        elif '"' not in s:
+            result = s
+            if " " in result:
+                result = f'"{result}"'
+        else:
+            escaped = s.replace('"', r"\"")
+            result = f'"{escaped}"'
+
+        return result
+    else:
+        return sarge.shell_quote(s)
+
+
+def get_default_devhub_username():
+    p = sfdx(
+        "config get target-dev-hub --json",
+        log_note="Getting default Dev Hub username from sfdx",
+        check_return=True,
+    )
+    result = json.load(p.stdout_text)
+    if "result" not in result or "value" not in result["result"][0]:
+        raise SfdxOrgException(
+            "No sf config found for target-dev-hub. "
+            "Please use the sf config set to set the target-dev-hub and run again."
+        )
+    username = result["result"][0]["value"]
+    return username
+
+
+class SourceFormat(StrEnum):
+    SFDX = "SFDX"
+    MDAPI = "MDAPI"
+
+
+def get_source_format_for_path(path: T.Optional[PathLike]) -> SourceFormat:
+    if pathlib.Path(path or pathlib.Path.cwd(), "package.xml").exists():
+        return SourceFormat.MDAPI
+
+    return SourceFormat.SFDX
+
+
+def get_source_format_for_zipfile(
+    zf: ZipFile, subfolder: T.Optional[str]
+) -> SourceFormat:
+    namelist = zf.namelist()
+
+    target_name = str(pathlib.PurePosixPath(subfolder or "", "package.xml"))
+
+    if target_name in namelist:
+        return SourceFormat.MDAPI
+
+    return SourceFormat.SFDX
+
+
+@contextlib.contextmanager
+def convert_sfdx_source(
+    path: T.Optional[PathLike], name: T.Optional[str], logger: logging.Logger
+):
+    mdapi_path = None
+    with contextlib.ExitStack() as stack:
+        # Convert SFDX -> MDAPI format if path exists but does not have package.xml
+        if (
+            len(os.listdir(path))  # path is None -> CWD
+            and get_source_format_for_path(path) is SourceFormat.SFDX
+        ):
+            logger.info("Converting from SFDX to MDAPI format.")
+            mdapi_path = stack.enter_context(temporary_dir(chdir=False))
+            args = ["-d", mdapi_path]
+            if path:
+                # No path means convert default package directory in the CWD
+                args += ["-r", str(path)]
+            if name:
+                args += ["-n", name]
+            sfdx(
+                "project convert source",
+                args=args,
+                capture_output=True,
+                check_return=True,
+            )
+
+        yield mdapi_path or path

cumulusci/core/source/__init__.py

@@ -0,0 +1,16 @@
+from .github import GitHubSource, GitHubEnterpriseSource
+from .local_folder import LocalFolderSource
+
+
+class NullSource:
+    """Source for the root project."""
+
+    frozenspec = None
+    allow_remote_code = True
+    location = None
+
+    def __str__(self):
+        return "current folder"
+
+
+__all__ = ("GitHubSource", "GitHubEnterpriseSource", "LocalFolderSource", "NullSource")