cumulusci 3.61.0.dev0__tar.gz → 3.61.0.dev2__tar.gz

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev2}/AUTHORS.rst

@@ -35,3 +35,4 @@ For example:
 (add your name here, when you contribute through a Pull Request!)
 
 * Ed Rivas (jerivas)
+* Gustavo Tandeciarz (dcinzona)

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev2}/HISTORY.rst

@@ -2047,8 +2047,7 @@ New features:
 * Python 3.8 is now officially supported.
 
 * Flows can now include tasks or flows from a different project.
-  See `Using Tasks and Flows from a Different Project
-  <https://cumulusci.readthedocs.io/en/latest/features.html>`_ for details.
+  See [](tasks-and-flows-from-a-different-project) for details.
 
 * In the ``metadeploy_publish`` task it is now possible to specify a
   commit hash with ``-o commit [sha]``, instead of a tag. This is useful

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cumulusci
-Version: 3.61.0.dev0
+Version: 3.61.0.dev2
 Summary: Build and release tools for Salesforce developers
 Home-page: https://github.com/SFDO-Tooling/CumulusCI
 Author: Salesforce.org
@@ -2111,8 +2111,7 @@ Description: =========
         * Python 3.8 is now officially supported.
         
         * Flows can now include tasks or flows from a different project.
-          See `Using Tasks and Flows from a Different Project
-          <https://cumulusci.readthedocs.io/en/latest/features.html>`_ for details.
+          See [](tasks-and-flows-from-a-different-project) for details.
         
         * In the ``metadeploy_publish`` task it is now possible to specify a
           commit hash with ``-o commit [sha]``, instead of a tag. This is useful

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev2}/cumulusci/cli/tests/test_flow.py

@@ -124,7 +124,7 @@ def test_flow_doc__with_flows_rst_file(load_yaml_data, echo):
         "Flow Reference\n==========================================\n\nopening blurb for flow reference doc\n\n",
         "Group1\n------",
         "This is a description of group1.",
-        "Flow1\n^^^^^\n\n**Description:** Description of Flow1\n\nSome ``extra`` **pizzaz**!\n**Flow Steps**\n\n.. code-block:: console\n",
+        ".. _Flow1:\n\nFlow1\n^^^^^\n\n**Description:** Description of Flow1\n\nSome ``extra`` **pizzaz**!\n**Flow Steps**\n\n.. code-block:: console\n",
         "",
     ]
     expected_call_args = [mock.call(s) for s in expected_call_args]

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev2}/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.dev2}/cumulusci/cumulusci.yml

@@ -1262,6 +1262,8 @@ flows:
                     resolution_strategy: unlocked
                     org_dependent: True
                     force_upload: True
+                    post_install_script: null
+                    uninstall_script: null
             3:
                 task: promote_package_version
                 options:

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev2}/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.dev0 → cumulusci-3.61.0.dev2}/cumulusci/tasks/create_package_version.py

@@ -137,16 +137,27 @@ class CreatePackageVersion(BaseSalesforceApiTask):
     def _init_options(self, kwargs):
         super()._init_options(kwargs)
 
+        # Allow these fields to be explicitly set to blanks
+        # so that unlocked builds can override an otherwise-configured
+        # postinstall script
+        if "post_install_script" in self.options:
+            post_install_script = self.options["post_install_script"]
+        else:
+            post_install_script = self.project_config.project__package__install_class
+
+        if "uninstall_script" in self.options:
+            uninstall_script = self.options["uninstall_script"]
+        else:
+            uninstall_script = self.project_config.project__package__uninstall_class
+
         self.package_config = PackageConfig(
             package_name=self.options.get("package_name")
             or self.project_config.project__package__name,
             package_type=self.options.get("package_type")
             or self.project_config.project__package__type,
             org_dependent=self.options.get("org_dependent", False),
-            post_install_script=self.options.get("post_install_script")
-            or self.project_config.project__package__install_class,
-            uninstall_script=self.options.get("uninstall_script")
-            or self.project_config.project__package__uninstall_class,
+            post_install_script=post_install_script,
+            uninstall_script=uninstall_script,
             namespace=self.options.get("namespace")
             or self.project_config.project__package__namespace,
             version_name=self.options.get("version_name") or "Release",

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

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

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev2}/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.dev2/cumulusci/tasks/robotframework/template.html

@@ -0,0 +1,109 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="utf-8" />
+        <script
+            src="https://code.jquery.com/jquery-3.3.1.slim.min.js"
+            integrity="sha256-3edrmyuQ0w65f8gfBsqowzjJe2iM6n0nKciPUp8y+7E="
+            crossorigin="anonymous"
+        ></script>
+        <script>
+            function filter() {
+                var filter_string = $("#filter").val().toLowerCase();
+                $(".kwtable .kwname").each(function () {
+                    if ($(this).text().toLowerCase().indexOf(filter_string) !== -1) {
+                        $(this).parent().show();
+                    } else {
+                        $(this).parent().hide();
+                    }
+                });
+            }
+            $(document).ready(function () {
+                $("#filter").on("input", function () {
+                    filter();
+                });
+                $("#filter").keyup(function () {
+                    filter();
+                });
+            });
+        </script>
+        <style>
+            {{stylesheet}}
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <!-- this is the header for the documentation as a whole -->
+            <div class="header">
+                <h1 class="title">{{title}}</h1>
+                <div class="filter right">
+                    filter: <input id="filter" type="filter" />
+                </div>
+            </div>
+
+            {% for kwfile in libraries %}
+            <div class="file" id="file-{{kwfile.path}}">
+                <div class="file-header">
+                    <h2 title="{{kwfile.path}}">{{kwfile.title}}</h2>
+                    <div class="file-path">{{kwfile.path}}</div>
+                </div>
+
+                {% if kwfile.doc %}
+                <div class="pageobject-file-description">{{kwfile.doc|robot_html}}</div>
+                {% endif %} {% for pageobject, library in kwfile.keywords.items() %}
+                <div class="section" pageobject="{{pageobject|join('-')}}">
+                    {% if pageobject %}
+                    <div class="pageobject-header">
+                        <table class="pageobject-header">
+                            <tbody>
+                                <tr class="data">
+                                    <td title="Page Type">{{pageobject[0]}}</td>
+                                    {% if pageobject[1] %}
+                                    <td title="Object Name">{{pageobject[1]}}</td>
+                                    {% endif %}
+                                </tr>
+                                <tr class="labels">
+                                    <td>Page Type</td>
+                                    {% if pageobject[1] %}
+                                    <td>Object Name</td>
+                                    {% endif %}
+                                </tr>
+                            </tbody>
+                        </table>
+                    </div>
+                    {% endif %}
+
+                    <div class="description" title="Description">
+                        {{library.doc|robot_html}}
+                    </div>
+                    <table class="kwtable" title="Table of keywords">
+                        <tbody>
+                            <tr>
+                                <th>Keyword</th>
+                                <th>Arguments</th>
+                                <th>Documentation</th>
+                            </tr>
+                            {% for keyword in library.keywords %}
+                            <tr
+                                class="kwrow"
+                                id="{{kwfile.filename}}.{{keyword.name.replace(' ', '-')}}"
+                            >
+                                <td class="kwname">{{keyword.name}}</td>
+                                <td class="kwargs">
+                                    {% for arg in keyword.args %}
+                                    <i>{{arg}}</i>{% if not loop.last %}, {% endif %} {%
+                                    endfor %}
+                                </td>
+                                <td class="kwdoc">{{keyword.doc|robot_html}}</td>
+                            </tr>
+                            {% endfor %}
+                        </tbody>
+                    </table>
+                </div>
+                {# class="library-whatever" #} {% endfor %}
+            </div>
+            {% endfor %}
+        </div>
+        <div class="footer">Generated on {{date}} - cumulusci v{{cci_version}}</div>
+    </body>
+</html>

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev2}/cumulusci/tasks/robotframework/tests/test_robotframework.py

@@ -672,7 +672,7 @@ class TestRobotLibDocOutput:
     def test_formatted_documentation(self):
         """Verify that markup in the documentation is rendered as html"""
         doc_element = self.html_body.find(
-            ".//tr[@id='TestLibrary.py.Library Keyword One']//td[@class='kwdoc']"
+            ".//tr[@id='TestLibrary.py.Library-Keyword-One']//td[@class='kwdoc']"
         )
         doc_html = str(ET.tostring(doc_element, method="html").strip())
         # we could just do an assert on the full markup of the
@@ -756,13 +756,13 @@ class TestLibdocPageObjects:
         description = section.find("div[@class='description']")
         expected = '<div class="description" title="Description"><p>Description of SomethingDetailPage</p></div>'
         actual = ET.tostring(description).decode("utf-8").strip()
-        assert actual == expected
+        assert shrinkws(actual) == shrinkws(expected)
 
         section = self.html_body.find(".//div[@pageobject='Listing-Something__c']")
         description = section.find("div[@class='description']")
         expected = '<div class="description" title="Description"><p>Description of SomethingListingPage</p></div>'
         actual = ET.tostring(description).decode("utf-8").strip()
-        assert actual == expected
+        assert shrinkws(actual) == shrinkws(expected)
 
 
 class TestRobotPerformanceKeywords:
@@ -858,3 +858,7 @@ class TestRobotPerformanceKeywords:
             assert list(filter(None, elapsed_times)) == [
                 {"Elapsed Time": 11655.9, "Donuts": 42.3}
             ]
+
+
+def shrinkws(s):
+    return re.sub(r"\s+", " ", s).replace("> <", "><")

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev2}/cumulusci/tasks/salesforce/tests/test_ProfileGrantAllAccess.py

@@ -269,6 +269,66 @@ def test_throws_exception_record_type_not_found():
         task._transform_entity(metadata_tree.fromstring(ADMIN_PROFILE_BEFORE), "Admin")
 
 
+def test_transforms_profile_with_layouts():
+    task = create_task(
+        ProfileGrantAllAccess,
+        {
+            "record_types": [
+                {
+                    "record_type": "Account.HH_Account",
+                    "page_layout": "Account-Account Layout",
+                },
+                {
+                    "record_type": "Account.Business_Account",
+                    "page_layout": "Account-Account Layout",
+                    "default": True,
+                },
+            ],
+        },
+    )
+
+    # To support coverage for when pulling metadata with layout definitions
+    profile_before = ADMIN_PROFILE_BEFORE.replace(
+        b"</Profile>",
+        b"""\n      <layoutAssignments>
+            <recordType>Account.Business_Account</recordType>
+            <layout>Account-Business Account Layout</layout>
+        </layoutAssignments>
+    </Profile>""",
+    )
+
+    inbound = metadata_tree.fromstring(profile_before)
+    assert len(inbound.findall("layoutAssignments")) == 1
+
+    # Verify the expected input includes the layoutAssignment element and
+    # the original layout
+    assert (
+        inbound.find("layoutAssignments", recordType="Account.Business_Account")
+        .find("layout")
+        .text
+        == "Account-Business Account Layout"
+    )
+
+    # Run the transformation and assert that there are two layoutAssignments
+    outbound = task._transform_entity(inbound, "Admin")
+    assert len(outbound.findall("layoutAssignments")) == 2
+
+    # Verify that the original layout assignment was updated
+    assignments = outbound.find(
+        "layoutAssignments", recordType="Account.Business_Account"
+    )
+    assert assignments is not None
+    assert assignments.find("layout").text == "Account-Account Layout"
+
+    assignments = outbound.find("layoutAssignments", recordType="Account.HH_Account")
+    assert assignments is not None
+    assert assignments.find("layout").text == "Account-Account Layout"
+
+    # assert that the nodes are included in the xml output as expected
+    xml_output = outbound.tostring(xml_declaration=True)
+    assert xml_output.count("<layoutAssignments>") == 2
+
+
 def test_expand_package_xml():
     task = create_task(ProfileGrantAllAccess, {"api_names": ["Admin"]})
     task.tooling = mock.Mock()
@@ -287,6 +347,30 @@ def test_expand_package_xml():
     assert "fb__Foo_Bar__c" in {elem.text for elem in types.findall("members")}
 
 
+def test_expand_package_xml_objects():
+    task = create_task(
+        ProfileGrantAllAccess,
+        {"api_names": ["Admin"], "record_types": [{"record_type": "Case.Case"}]},
+    )
+    task.tooling = mock.Mock()
+    package_xml = metadata_tree.fromstring(PACKAGE_XML_BEFORE)
+    task._expand_package_xml_objects(package_xml)
+    types = package_xml.find("types", name="CustomObject")
+    assert "Case" in {elem.text for elem in types.findall("members")}
+
+
+def test_expand_package_xml_objects_no_record_types():
+    task = create_task(
+        ProfileGrantAllAccess,
+        {"api_names": ["Admin"]},
+    )
+    task.tooling = mock.Mock()
+    package_xml = metadata_tree.fromstring(PACKAGE_XML_BEFORE)
+    task._expand_package_xml_objects(package_xml)
+    types = package_xml.find("types", name="CustomObject")
+    assert "Case" not in {elem.text for elem in types.findall("members")}
+
+
 def test_expand_package_xml__broken_package():
     task = create_task(ProfileGrantAllAccess, {"api_names": ["Admin"]})
     task.tooling = mock.Mock()

{cumulusci-3.61.0.dev0 → cumulusci-3.61.0.dev2}/cumulusci/tasks/salesforce/update_profile.py

@@ -28,7 +28,10 @@ class ProfileGrantAllAccess(MetadataSingleEntityTransformTask, BaseSalesforceApi
             "the record type in format <object>.<developer_name>.  Record type names can use the token strings {managed} "
             "and {namespaced_org} for namespace prefix injection as needed.  By default, all listed record types will be set "
             "to visible and not default.  Use the additional keys `visible`, `default`, and `person_account_default` set to "
-            "true/false to override.  NOTE: Setting record_types is only supported in cumulusci.yml, command line override is not supported."
+            "true/false to override.  "
+            "Page Layout Support: If you are using the Page Layouts feature, you can specify the `page_layout` key with the "
+            "layout name to use for the record type.  If not specified, the default page layout will be used.  "
+            "NOTE: Setting record_types is only supported in cumulusci.yml, command line override is not supported."
         },
         "managed": {
             "description": "If True, uses the namespace prefix where appropriate.  Use if running against an org with the managed package "
@@ -178,6 +181,27 @@ class ProfileGrantAllAccess(MetadataSingleEntityTransformTask, BaseSalesforceApi
                 text=f"{record['NamespacePrefix']}__{record['DeveloperName']}__c",
             )
 
+        self._expand_package_xml_objects(package_xml)
+
+    def _expand_package_xml_objects(self, package_xml):
+        # Check for any record types specified in the options, but missing from the package.xml
+        # Add these entities to the package.xml
+
+        custom_objects = package_xml.find("types", name="CustomObject")
+
+        # Append custom objects if record types are present but missing from package.xml
+        record_types = self.options.get("record_types") or []
+        rt_objects = {rt["record_type"].split(".")[0] for rt in record_types}
+        listed_custom_objects = {c.text for c in custom_objects.findall("members")}
+
+        for rt in rt_objects:
+            if rt not in listed_custom_objects:
+                self.logger.info('Adding "{}" to package.xml'.format(rt))
+                custom_objects.append(
+                    "members",
+                    text=rt,
+                )
+
     def _transform_entity(self, tree, api_name):
         # Custom applications
         self._set_elements_visible(tree, "applicationVisibilities", "visible")
@@ -254,5 +278,26 @@ class ProfileGrantAllAccess(MetadataSingleEntityTransformTask, BaseSalesforceApi
             if pa_default is not None:
                 pa_default.text = str(rt.get("person_account_default", "false")).lower()
 
+        # Set page layout defaults for record types
+        for rt in record_types:
+            # We need it to look like this:
+            # <layoutAssignments>
+            #   <layout>{page_layout}</layout>
+            #   <recordType>{record_type}</recordType>
+            # </layoutAssignments>
+            layout_option = rt.get("page_layout", None)
+            if layout_option:
+                # Look for page layout definitions in the record type
+                found_layout = False
+                for elem in tree.findall("layoutAssignments"):
+                    if elem.find("recordType").text == rt["record_type"]:
+                        elem.layout.text = layout_option
+                        found_layout = True
+
+                if not found_layout:
+                    assignment = tree.append(tag="layoutAssignments")
+                    assignment.append(tag="recordType", text=rt["record_type"])
+                    assignment.append(tag="layout", text=layout_option)
+
 
 UpdateAdminProfile = UpdateProfile = ProfileGrantAllAccess