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

cumulusci-3.61.0.dev0/CONTRIBUTING.rst

@@ -0,0 +1 @@
+See docs/contributing.rst

{cumulusci-3.60.0.dev1 → cumulusci-3.61.0.dev0}/HISTORY.rst

@@ -1,6 +1,21 @@
 =======
 History
 =======
+3.60.0 (2022-06-09)
+-------------------
+Changes:
+
+* We added a new dependency resolution strategy, ``unlocked``. Like our existing dependency strategies using parallel 2GP package builds, this strategy installs parallel unlocked package builds. (#3223)
+* We added the flows ``build_unlocked_test_package``, ``install_unlocked_commit``, and ``qa_org_unlocked`` to support use of parallel unlocked packages. (#3223)
+* We added a property, ``is_survey_advanced_features_enabled``, to the org_config entity available in when clauses. (#3149)
+* Robot framework API and performance keywords have been moved into separate libraries. They are still automatically imported when using Salesforce.robot so it is not necessary to modify any existing test files. (#3216)
+* There are new robot framework keyword libraries with limited support for `Playwright <https://playwright.dev/>`_ via the `robotframework-browser library <https://robotframework-browser.org/>`_. To use, import the resource file ``cumulusci/robotframework/SalesforcePlaywright.robot`` instead of ``cumulusci/robotframework/Salesforce.robot``. Note: Playwright is not yet supported by MetaCI. (#3216)
+* ``cumulusci.robotframework.BaseLibrary`` can be used when creating new libraries in order to get some useful properties (``self.salesforce``, ``self.salesforce_api``, ``self.cumulusci``, etc) (#3216)
+* Snowfakery 3.2 is included, with the following changes:
+* Snowfakery can now do random_reference to nicknames.
+* We removed some limitations on what Snowfakery can do with objects referenced through random_reference, especially using a.b.c.d syntax.
+* We added a unique option for random_reference to allow for 1-1 relationships across random references and no-duplicates many-to-many join relationships like Account->CampaignMember->Campaign
+
 3.59.1 (2022-05-31)
 -------------------
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cumulusci
-Version: 3.60.0.dev1
+Version: 3.61.0.dev0
 Summary: Build and release tools for Salesforce developers
 Home-page: https://github.com/SFDO-Tooling/CumulusCI
 Author: Salesforce.org
@@ -65,6 +65,21 @@ Description: =========
         =======
         History
         =======
+        3.60.0 (2022-06-09)
+        -------------------
+        Changes:
+        
+        * We added a new dependency resolution strategy, ``unlocked``. Like our existing dependency strategies using parallel 2GP package builds, this strategy installs parallel unlocked package builds. (#3223)
+        * We added the flows ``build_unlocked_test_package``, ``install_unlocked_commit``, and ``qa_org_unlocked`` to support use of parallel unlocked packages. (#3223)
+        * We added a property, ``is_survey_advanced_features_enabled``, to the org_config entity available in when clauses. (#3149)
+        * Robot framework API and performance keywords have been moved into separate libraries. They are still automatically imported when using Salesforce.robot so it is not necessary to modify any existing test files. (#3216)
+        * There are new robot framework keyword libraries with limited support for `Playwright <https://playwright.dev/>`_ via the `robotframework-browser library <https://robotframework-browser.org/>`_. To use, import the resource file ``cumulusci/robotframework/SalesforcePlaywright.robot`` instead of ``cumulusci/robotframework/Salesforce.robot``. Note: Playwright is not yet supported by MetaCI. (#3216)
+        * ``cumulusci.robotframework.BaseLibrary`` can be used when creating new libraries in order to get some useful properties (``self.salesforce``, ``self.salesforce_api``, ``self.cumulusci``, etc) (#3216)
+        * Snowfakery 3.2 is included, with the following changes:
+        * Snowfakery can now do random_reference to nicknames.
+        * We removed some limitations on what Snowfakery can do with objects referenced through random_reference, especially using a.b.c.d syntax.
+        * We added a unique option for random_reference to allow for 1-1 relationships across random references and no-duplicates many-to-many join relationships like Account->CampaignMember->Campaign
+        
         3.59.1 (2022-05-31)
         -------------------
         

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

@@ -82,7 +82,7 @@ class OrgConfig(BaseConfig):
 
         super().__init__(config)
 
-    def refresh_oauth_token(self, keychain, connected_app=None):
+    def refresh_oauth_token(self, keychain, connected_app=None, is_sandbox=False):
         """Get a fresh access token and store it in the org config.
 
         If the SFDX_CLIENT_ID and SFDX_HUB_KEY environment variables are set,
@@ -104,6 +104,7 @@ class OrgConfig(BaseConfig):
                     self.username,
                     self.instance_url,
                     auth_url=auth_url,
+                    is_sandbox=is_sandbox,
                 )
             else:
                 info = self._refresh_token(keychain, connected_app)
@@ -529,6 +530,13 @@ class OrgConfig(BaseConfig):
             # DatedConversionRate Sobject is not exposed meaning Multiple Currencies is not enabled.
             return False
 
+    @property
+    def is_survey_advanced_features_enabled(self) -> bool:
+        return any(
+            f["name"] == "PermissionsAllowSurveyAdvancedFeatures"
+            for f in self.salesforce_client.PermissionSet.describe()["fields"]
+        )
+
     def resolve_04t_dependencies(self, dependencies):
         """Look up 04t SubscriberPackageVersion ids for 1GP project dependencies"""
         from cumulusci.core.dependencies.dependencies import (

{cumulusci-3.60.0.dev1 → cumulusci-3.61.0.dev0}/cumulusci/core/config/tests/test_config.py

@@ -1661,6 +1661,56 @@ class TestOrgConfig:
         # We should have made 2 calls: 1 token call + 1 describe call
         assert len(responses.calls) == 1 + 1
 
+    @responses.activate
+    def test_is_survey_advanced_features_enabled(self):
+        config = OrgConfig(
+            {
+                "instance_url": "https://example.com",
+                "access_token": "TOKEN",
+                "id": "OODxxxxxxxxxxxx/user",
+            },
+            "test",
+        )
+
+        # Token call.
+        responses.add(
+            "GET", "https://example.com/services/data", json=[{"version": 48.0}]
+        )
+
+        # describe()
+        responses.add(
+            "GET",
+            "https://example.com/services/data/v48.0/sobjects/PermissionSet/describe",
+            json={"fields": [{"name": "PermissionsAllowSurveyAdvancedFeatures"}]},
+        )
+
+        assert config.is_survey_advanced_features_enabled
+
+    @responses.activate
+    def test_is_survey_advanced_features_enabled__not_enabled(self):
+        config = OrgConfig(
+            {
+                "instance_url": "https://example.com",
+                "access_token": "TOKEN",
+                "id": "OODxxxxxxxxxxxx/user",
+            },
+            "test",
+        )
+
+        # Token call.
+        responses.add(
+            "GET", "https://example.com/services/data", json=[{"version": 48.0}]
+        )
+
+        # describe()
+        responses.add(
+            "GET",
+            "https://example.com/services/data/v48.0/sobjects/PermissionSet/describe",
+            json={"fields": [{"name": "foo"}]},
+        )
+
+        assert not config.is_survey_advanced_features_enabled
+
     def test_resolve_04t_dependencies(self):
         config = OrgConfig({}, "test")
         config._installed_packages = {

{cumulusci-3.60.0.dev1 → cumulusci-3.61.0.dev0}/cumulusci/core/keychain/encrypted_file_project_keychain.py

@@ -25,6 +25,7 @@ from cumulusci.core.exceptions import (
 from cumulusci.core.keychain import BaseProjectKeychain
 from cumulusci.core.keychain.base_project_keychain import DEFAULT_CONNECTED_APP_NAME
 from cumulusci.core.utils import import_class, import_global
+from cumulusci.utils.yaml.cumulusci_yml import ScratchOrg
 
 DEFAULT_SERVICES_FILENAME = "DEFAULT_SERVICES.json"
 
@@ -308,18 +309,18 @@ class EncryptedFileProjectKeychain(BaseProjectKeychain):
         with open(fd, "wb") as f:
             f.write(org_bytes)
 
-    def _get_org(self, name):
+    def _get_org(self, org_name: str) -> ScratchOrgConfig:
         try:
-            config = self.orgs[name].data
-            global_org = self.orgs[name].global_org
+            config = self.orgs[org_name].data
+            global_org = self.orgs[org_name].global_org
         except KeyError:
-            raise OrgNotFound(f"Org with name '{name}' does not exist.")
+            raise OrgNotFound(f"Org with name '{org_name}' does not exist.")
 
         try:
-            org = self._config_from_bytes(config, name)
+            org = self._config_from_bytes(config, org_name)
         except Exception as e:
             try:
-                filename = self.orgs[name].filename
+                filename = self.orgs[org_name].filename
             except Exception:  # pragma: no cover
                 filename = None
             if not filename:
@@ -333,8 +334,26 @@ class EncryptedFileProjectKeychain(BaseProjectKeychain):
                 "The org can be connected or imported again to replace the corrupted config."
             )
         org.global_org = global_org
+
+        if isinstance(org, ScratchOrgConfig):
+            self._merge_config_from_yml(org)
+
         return org
 
+    def _merge_config_from_yml(self, scratch_config: ScratchOrgConfig):
+        """Merges any values configurable via cumulusci.yml
+        into the scratch org config that is loaded from file."""
+
+        configurable_attributes = list(ScratchOrg.schema()["properties"].keys())
+        for attr in configurable_attributes:
+            try:
+                value_from_yml = self.project_config.config["orgs"]["scratch"][
+                    scratch_config.name
+                ][attr]
+                scratch_config.config[attr] = value_from_yml
+            except KeyError:
+                pass
+
     def _config_from_bytes(self, config, name):
         if self.key:
             org = self._decrypt_config(

{cumulusci-3.60.0.dev1 → cumulusci-3.61.0.dev0}/cumulusci/core/keychain/tests/conftest.py

@@ -6,6 +6,7 @@ from cumulusci.core.config import (
     ServiceConfig,
     UniversalConfig,
 )
+from cumulusci.core.config.scratch_org_config import ScratchOrgConfig
 
 
 @pytest.fixture()
@@ -31,6 +32,11 @@ def org_config():
     return OrgConfig({"foo": "bar"}, "test")
 
 
+@pytest.fixture
+def scratch_org_config():
+    return ScratchOrgConfig({"foo": "bar"}, "test")
+
+
 @pytest.fixture
 def key():
     return "0123456789123456"

{cumulusci-3.60.0.dev1 → cumulusci-3.61.0.dev0}/cumulusci/core/keychain/tests/test_encrypted_file_project_keychain.py

@@ -79,6 +79,24 @@ class TestEncryptedFileProjectKeychain:
         assert list(keychain.orgs.keys()) == ["test"]
         assert keychain.get_org("test").config == org_config.config
 
+    def test_get_org__with_config_properly_overridden(
+        self, keychain, scratch_org_config
+    ):
+        days = 16
+        config_file = "./foo/bar/baz"
+        scratch_org_config.global_org = True
+        # the orgs encrypted file has the default value for days and config_file
+        keychain.set_org(scratch_org_config, True)
+        # but this particular scratch org has days and config_file specified via cumulusci.yml
+        keychain.project_config.config = {
+            "orgs": {"scratch": {"test": {"days": days, "config_file": config_file}}}
+        }
+        org = keychain.get_org("test")
+
+        # ensure what is configured in cumulusci.yml is what is loaded into the config
+        assert org.config["days"] == days
+        assert org.config["config_file"] == config_file
+
     def test_get_org__not_found(self, keychain):
         org_name = "mythical"
         error_message = f"Org with name '{org_name}' does not exist."

{cumulusci-3.60.0.dev1 → cumulusci-3.61.0.dev0}/cumulusci/cumulusci.yml

@@ -1369,7 +1369,7 @@ project:
         namespace:
         install_class:
         uninstall_class:
-        api_version: "54.0"
+        api_version: "55.0"
     git:
         default_branch: master
         prefix_feature: feature/

{cumulusci-3.60.0.dev1 → cumulusci-3.61.0.dev0}/cumulusci/oauth/salesforce.py

@@ -21,7 +21,9 @@ SANDBOX_LOGIN_URL = (
 PROD_LOGIN_URL = os.environ.get("SF_PROD_LOGIN_URL") or "https://login.salesforce.com"
 
 
-def jwt_session(client_id, private_key, username, url=None, auth_url=None):
+def jwt_session(
+    client_id, private_key, username, url=None, auth_url=None, is_sandbox=False
+):
     """Complete the JWT Token Oauth flow to obtain an access token for an org.
 
     :param client_id: Client Id for the connected app
@@ -53,6 +55,9 @@ def jwt_session(client_id, private_key, username, url=None, auth_url=None):
                 instance = m.group(2)
                 url = f"https://{instance}.salesforce.com"
 
+    if is_sandbox:  # pragma: no cover
+        aud = SANDBOX_LOGIN_URL
+
     payload = {
         "alg": "RS256",
         "iss": client_id,

cumulusci-3.61.0.dev0/cumulusci/robotframework/Performance.py

@@ -0,0 +1,165 @@
+from datetime import datetime
+
+from dateutil.parser import ParserError
+from dateutil.parser import parse as parse_date
+from robot.libraries.BuiltIn import BuiltIn
+from robot.utils import timestr_to_secs
+
+from cumulusci.robotframework.base_library import BaseLibrary
+
+
+class Performance(BaseLibrary):
+    """
+    Keywords for performance testing.
+
+    For more information on how to use these keywords, see
+    the "Performance Testing" section of the CumulusCI documentation.
+    """
+
+    def elapsed_time_for_last_record(
+        self, obj_name, start_field, end_field, order_by, **kwargs
+    ):
+        """For records representing jobs or processes, compare the record's start-time to its end-time to see how long a process took.
+
+        Arguments:
+            obj_name:   SObject to look for last record
+            start_field: Name of the datetime field that represents the process start
+            end_field: Name of the datetime field that represents the process end
+            order_by: Field name to order by. Should be a datetime field, and usually is just the same as end_field.
+            where:  Optional Where-clause to use for filtering
+            Other keywords are used for filtering as in the Salesforce Query keywordf
+
+        The last matching record queried and summarized.
+
+        Example:
+
+            | ${time_in_seconds} =    Elapsed Time For Last Record
+            | ...             obj_name=AsyncApexJob
+            | ...             where=ApexClass.Name='BlahBlah'
+            | ...             start_field=CreatedDate
+            | ...             end_field=CompletedDate
+            | ...             order_by=CompletedDate
+        """
+        if len(order_by.split()) != 1:
+            raise Exception("order_by should be a simple field name")
+        query = self.salesforce_api._soql_query_builder(
+            obj_name,
+            select=f"{start_field}, {end_field}",
+            order_by=order_by + " DESC NULLS LAST",
+            limit=1,
+            **kwargs,
+        )
+        response = self.salesforce_api.soql_query(query)
+        results = response["records"]
+
+        if results:
+            record = results[0]
+            return _duration(record[start_field], record[end_field], record)
+        else:
+            raise Exception(f"Matching record not found: {query}")
+
+    def start_performance_timer(self):
+        """Start an elapsed time stopwatch for performance tests.
+
+        See the docummentation for **Stop Performance Timer** for more
+        information.
+
+        Example:
+
+        | Start Performance Timer
+        | Do Something
+        | Stop Performance Timer
+        """
+        BuiltIn().set_test_variable("${__start_time}", datetime.now())
+
+    def stop_performance_timer(self):
+        """Record the results of a stopwatch. For perf testing.
+
+        This keyword uses Set Test Elapsed Time internally and therefore
+        outputs in all of the ways described there.
+
+        Example:
+
+        | Start Performance Timer
+        | Do Something
+        | Stop Performance Timer
+
+        """
+        start_time = self.builtin.get_variable_value("${__start_time}")
+        if start_time:
+            seconds = (datetime.now() - start_time).seconds
+            assert seconds is not None
+            self.set_test_elapsed_time(seconds)
+        else:
+            raise Exception(
+                "Elapsed time clock was not started. "
+                "Use the Start Elapsed Time keyword to do so."
+            )
+
+    def set_test_elapsed_time(self, elapsedtime):
+        """This keyword captures a computed rather than measured elapsed time for performance tests.
+
+        For example, if you were performance testing a Salesforce batch process, you might want to
+        store the Salesforce-measured elapsed time of the batch process instead of the time measured
+        in the CCI client process.
+
+        The keyword takes a single argument which is either a number of seconds or a Robot time string
+        (https://robotframework.org/robotframework/latest/libraries/DateTime.html#Time%20formats).
+
+        Using this keyword will automatically add the tag cci_metric_elapsed_time to the test case
+        and ${cci_metric_elapsed_time} to the test's variables. cci_metric_elapsed_time is not
+        included in Robot's html statistical roll-ups.
+
+        Example:
+
+        | Set Test Elapsed Time       11655.9
+
+        Performance test times are output in the CCI logs and are captured in MetaCI instead of the
+        "total elapsed time" measured by Robot Framework. The Robot "test message" is also updated."""
+
+        try:
+            seconds = float(elapsedtime)
+        except ValueError:
+            seconds = timestr_to_secs(elapsedtime)
+        assert seconds is not None
+
+        self.builtin.set_test_message(f"Elapsed time set by test : {seconds}")
+        self.builtin.set_tags("cci_metric_elapsed_time")
+        self.builtin.set_test_variable("${cci_metric_elapsed_time}", seconds)
+
+    def set_test_metric(self, metric: str, value=None):
+        """This keyword captures any metric for performance monitoring.
+
+        For example: number of queries, rows processed, CPU usage, etc.
+
+        The keyword takes a metric name, which can be any string, and a value, which
+        can be any number.
+
+        Using this keyword will automatically add the tag cci_metric to the test case
+        and ${cci_metric_<metric_name>} to the test's variables. These permit downstream
+        processing in tools like CCI and MetaCI.
+
+        cci_metric is not included in Robot's html statistical roll-ups.
+
+        Example:
+
+        | Set Test Metric    Max_CPU_Percent    30
+
+        Performance test metrics are output in the CCI logs, log.html and output.xml.
+        MetaCI captures them but does not currently have a user interface for displaying
+        them."""
+
+        value = float(value)
+
+        self.builtin.set_tags("cci_metric")
+        self.builtin.set_test_variable("${cci_metric_%s}" % metric, value)
+
+
+def _duration(start_date: str, end_date: str, record: dict):
+    try:
+        start_date = parse_date(start_date)
+        end_date = parse_date(end_date)
+    except (ParserError, TypeError) as e:
+        raise Exception(f"Date parse error: {e} in record {record}")
+    duration = end_date - start_date
+    return duration.total_seconds()