cumulusci 3.61.0.dev0__tar.gz → 3.61.0.dev1__tar.gz

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cumulusci
-Version: 3.61.0.dev0
+Version: 3.61.0.dev1
 Summary: Build and release tools for Salesforce developers
 Home-page: https://github.com/SFDO-Tooling/CumulusCI
 Author: Salesforce.org

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev1}/cumulusci/core/config/marketing_cloud_service_config.py

@@ -6,7 +6,6 @@ import requests
 from cumulusci.core.config.oauth2_service_config import OAuth2ServiceConfig
 from cumulusci.core.keychain import BaseProjectKeychain
 from cumulusci.oauth.client import OAuth2Client
-from cumulusci.tasks.marketing_cloud.mc_constants import AUTH_URI
 from cumulusci.utils.http.requests_utils import safe_json_from_response
 
 
@@ -73,13 +72,12 @@ class MarketingCloudServiceConfig(OAuth2ServiceConfig):
         """Make a call to the Marketing Cloud REST API UserInfo endpoint.
         Raises HTTPError for bad response status, otherwise returns the payload
         in full."""
+        auth_uri = self.rest_instance_url.replace(".rest", ".auth")
         headers = {
             "Authorization": f"Bearer {self.access_token}",
             "Content-Type": "application/json",
         }
-        response = requests.get(
-            f"{AUTH_URI.format(self.tssd)}/v2/userinfo", headers=headers
-        )
+        response = requests.get(f"{auth_uri}v2/userinfo", headers=headers)
         response.raise_for_status()
 
         return safe_json_from_response(response)

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev1}/cumulusci/schema/cumulusci.jsonschema.json

@@ -547,6 +547,15 @@
                 "preflight_message": {
                     "title": "Preflight Message",
                     "type": "string"
+                },
+                "allowed_org_providers": {
+                    "title": "Allowed Org Providers",
+                    "default": ["user"],
+                    "type": "array",
+                    "items": {
+                        "enum": ["devhub", "user"],
+                        "type": "string"
+                    }
                 }
             },
             "additionalProperties": false

cumulusci-3.61.0.dev1/cumulusci/tasks/marketing_cloud/mc_constants.py

@@ -0,0 +1 @@
+MC_API_VERSION = "v2"

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev1}/cumulusci/tasks/metadeploy.py

@@ -2,6 +2,7 @@ import json
 import os
 import re
 from pathlib import Path
+from typing import List, Union
 
 import requests
 
@@ -13,6 +14,7 @@ from cumulusci.core.tasks import BaseTask
 from cumulusci.core.utils import process_bool_arg
 from cumulusci.utils import cd, download_extract_github, temporary_dir
 from cumulusci.utils.http.requests_utils import safe_json_from_response
+from cumulusci.utils.yaml.cumulusci_yml import Plan
 
 INSTALL_VERSION_RE = re.compile(r"^Install .*\d$")
 
@@ -24,7 +26,7 @@ class BaseMetaDeployTask(BaseTask):
         metadeploy_service = self.project_config.keychain.get_service("metadeploy")
         self.base_url = metadeploy_service.url
         self.api = requests.Session()
-        self.api.headers["Authorization"] = "token {}".format(metadeploy_service.token)
+        self.api.headers["Authorization"] = f"token {metadeploy_service.token}"
 
     def _call_api(self, method, path, collect_pages=False, **kwargs):
         next_url = self.base_url + path
@@ -85,9 +87,7 @@ class Publish(BaseMetaDeployTask):
         plan_name = self.options.get("plan")
         if plan_name:
             plan_configs = {}
-            plan_configs[plan_name] = self.project_config.lookup(
-                "plans__{}".format(plan_name)
-            )
+            plan_configs[plan_name] = self.project_config.lookup(f"plans__{plan_name}")
 
             self.plan_configs = plan_configs
         else:
@@ -184,10 +184,10 @@ class Publish(BaseMetaDeployTask):
             if self.publish:
                 self._call_api(
                     "PATCH",
-                    "/versions/{}".format(version["id"]),
+                    f"/versions/{version['id']}",
                     json={"is_listed": True},
                 )
-                self.logger.info("Published Version {}".format(version["url"]))
+                self.logger.info(f"Published Version {version['url']}")
 
         # Save labels
         self._save_labels()
@@ -197,6 +197,11 @@ class Publish(BaseMetaDeployTask):
             product, plan_name, plan_config
         )
 
+        allowed_org_providers = self._get_allowed_org_providers(plan_name)
+        supported_orgs = self._convert_org_providers_to_plan_equivalent(
+            allowed_org_providers
+        )
+
         plan_json = {
             "is_listed": plan_config.get("is_listed", True),
             "plan_template": plan_template["url"],
@@ -207,6 +212,7 @@ class Publish(BaseMetaDeployTask):
                 "preflight_message_additional", ""
             ),
             "steps": steps,
+            "supported_orgs": supported_orgs,
             "tier": plan_config["tier"],
             "title": plan_config["title"],
             "version": version["url"],
@@ -218,7 +224,27 @@ class Publish(BaseMetaDeployTask):
 
         # Create Plan
         plan = self._call_api("POST", "/plans", json=plan_json)
-        self.logger.info("Created Plan {}".format(plan["url"]))
+        self.logger.info(f"Created Plan {plan['url']}")
+
+    def _get_allowed_org_providers(self, plan_name: str) -> List[str]:
+        "Validates and returns the org providers for a given plan"
+        plan = Plan.parse_obj(self.project_config.config["plans"][plan_name])
+        return plan.allowed_org_providers
+
+    def _convert_org_providers_to_plan_equivalent(
+        self, providers: Union[None, List[str]]
+    ) -> str:
+        """Given a list of plan.allowed_org_providers return the value that
+        corresponds `supported_orgs` field on the Plan model in MetaDeploy
+        """
+        if not providers or providers == ["user"]:
+            org_providers = "persistent"
+        elif "user" in providers and "devhub" in providers:
+            org_providers = "both"
+        elif providers == ["devhub"]:
+            org_providers = "scratch"
+
+        return org_providers
 
     def _freeze_steps(self, project_config, plan_config):
         steps = plan_config["steps"]
@@ -243,7 +269,7 @@ class Publish(BaseMetaDeployTask):
             result = self._call_api("GET", "/products", params={"repo_url": repo_url})
             if len(result["data"]) != 1:
                 raise CumulusCIException(
-                    "No product found in MetaDeploy with repo URL {}".format(repo_url)
+                    f"No product found in MetaDeploy with repo URL {repo_url}"
                 )
         except KeyError:
             raise CumulusCIException(
@@ -287,10 +313,10 @@ class Publish(BaseMetaDeployTask):
                     "is_listed": False,
                 },
             )
-            self.logger.info("Created {}".format(version["url"]))
+            self.logger.info(f"Created {version['url']}")
         else:
             version = result["data"][0]
-            self.logger.info("Found {}".format(version["url"]))
+            self.logger.info(f"Found {version['url']}")
         return version
 
     def _find_or_create_plan_template(self, product, plan_name, plan_config):
@@ -311,16 +337,16 @@ class Publish(BaseMetaDeployTask):
                     "error_message": plan_config.get("error_message", ""),
                 },
             )
-            self.logger.info("Created {}".format(plantemplate["url"]))
+            self.logger.info(f"Created {plantemplate['url']}")
             planslug = self._call_api(
                 "POST",
                 "/planslug",
                 json={"slug": plan_config["slug"], "parent": plantemplate["url"]},
             )
-            self.logger.info("Created {}".format(planslug["url"]))
+            self.logger.info(f"Created {planslug['url']}")
         else:
             plantemplate = result["data"][0]
-            self.logger.info("Found {}".format(plantemplate["url"]))
+            self.logger.info(f"Found {plantemplate['url']}")
         return plantemplate
 
     def _load_labels(self):

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev1}/cumulusci/tasks/tests/test_metadeploy.py

@@ -126,6 +126,7 @@ class TestPublish(GithubApiTestMixin):
                     },
                 },
                 "checks": [{"when": "False", "action": "error"}],
+                "allowed_org_providers": ["user", "devhub"],
             }
         }
         project_config.keychain.set_service(
@@ -269,7 +270,10 @@ class TestPublish(GithubApiTestMixin):
         task = Publish(project_config, task_config)
         task()
 
-        steps = json.loads(responses.calls[-2].request.body)["steps"]
+        body = json.loads(responses.calls[-2].request.body)
+        assert body["supported_orgs"] == "both"
+
+        steps = body["steps"]
         self.maxDiff = None
         assert [
             {
@@ -524,3 +528,38 @@ class TestPublish(GithubApiTestMixin):
         task._init_task()
         steps = task._freeze_steps(project_config, plan_config)
         assert steps == []
+
+    providers = [
+        (["user"], "persistent"),
+        (["devhub"], "scratch"),
+        (["user", "devhub"], "both"),
+    ]
+
+    @pytest.mark.parametrize("org_providers,metadeploy_equivalent", providers)
+    def test_convert_org_providers_to_plan_equivalent(
+        self, org_providers, metadeploy_equivalent
+    ):
+        project_config = create_project_config()
+        project_config.keychain.set_service(
+            "metadeploy",
+            "test_alias",
+            ServiceConfig({"url": "https://metadeploy", "token": "TOKEN"}),
+        )
+
+        plan_config = {
+            "title": "Test Install",
+            "slug": "install",
+            "tier": "primary",
+            "steps": {1: {"task": "None"}},
+            "allowed_org_providers": org_providers,
+        }
+        plan_name = "test_install"
+        project_config.config["plans"] = {
+            plan_name: plan_config,
+        }
+        task_config = TaskConfig({"options": {"tag": "release/1.0"}})
+
+        task = Publish(project_config, task_config)
+        actual = task._convert_org_providers_to_plan_equivalent(org_providers)
+
+        assert actual == metadeploy_equivalent

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev1}/cumulusci/utils/yaml/cumulusci_yml.py

@@ -123,6 +123,7 @@ class Plan(CCIDictModel):  # MetaDeploy plans
     error_message: str = None
     post_install_message: str = None
     preflight_message: str = None
+    allowed_org_providers: List[Literal["devhub", "user"]] = ["user"]
 
 
 class DependencyResolutions(CCIDictModel):

cumulusci-3.61.0.dev1/cumulusci/version.txt

@@ -0,0 +1 @@
+3.61.0.dev1

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev1}/cumulusci.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cumulusci
-Version: 3.61.0.dev0
+Version: 3.61.0.dev1
 Summary: Build and release tools for Salesforce developers
 Home-page: https://github.com/SFDO-Tooling/CumulusCI
 Author: Salesforce.org

cumulusci-3.61.0.dev0/cumulusci/tasks/marketing_cloud/mc_constants.py

@@ -1,5 +0,0 @@
-MC_API_VERSION = "v2"
-
-# We *do not* want to derive this URL from `rest_instance_url` because
-# it could potentially change in the future.
-AUTH_URI = "https://{}.auth.marketingcloudapis.com"

cumulusci-3.61.0.dev0/cumulusci/version.txt

@@ -1 +0,0 @@
-3.61.0.dev0