Merge branch 'main' into feature/fake-data-docs

Author: Paul Prescod

docs/salesforce.md

@@ -219,11 +219,11 @@ In general, you can test Snowfakery files outside of CumulusCI to see if they wo
 $ snowfakery recipe.yml
 ```
 
-If you have a recipe which depends on data from an org, specify the CumulusCI orgname
-like this:
+If you have a recipe which depends on data from an org,
+specify the CumulusCI org name like this:
 
 ```s
-$ snowfakery recipe.yml --plugin-options orgname qa
+$ snowfakery recipe.yml --plugin-options org_name qa
 ```
 
 When you run the recipe in this way, it will connect to the org to pull data but

snowfakery/data_generator.py

@@ -192,7 +192,7 @@ def process_plugins_options(
 ) -> Mapping[str, object]:
     """Replace option short names with fully qualified names
        and convert types of options.
-    e.g. the option name that the user specifies on the CLI or API is just "orgname"
+    e.g. the option name that the user specifies on the CLI or API is just "org_name"
          but we use the long name internally to avoid clashing with the
          user's variable names."""
 

snowfakery/standard_plugins/Salesforce.py

@@ -29,26 +29,35 @@
 
 MAX_SALESFORCE_OFFSET = 2000  # Any way around this?
 
-# the option name that the user specifies on the CLI or API is just "orgname"
+# the option name that the user specifies on the CLI or API is just "org_name"
 # but using this long name internally prevents us from clashing with the
 # user's variable names.
-plugin_option_name = "snowfakery.standard_plugins.Salesforce.SalesforceQuery.orgname"
+plugin_option_org_name = (
+    "snowfakery.standard_plugins.Salesforce.SalesforceQuery.org_name"
+)
+plugin_option_org_config = (
+    "snowfakery.standard_plugins.Salesforce.SalesforceQuery.org_config"
+)
+plugin_option_project_config = (
+    "snowfakery.standard_plugins.Salesforce.SalesforceQuery.project_config"
+)
 
 
 class SalesforceConnection:
     """Helper layer above simple_salesforce and salesforce_bulk"""
 
     _sf = None
 
-    def __init__(self, get_orgname):
-        self.get_orgname = get_orgname
+    def __init__(self, get_project_config_and_org_config):
+        self.get_project_config_and_org_config = get_project_config_and_org_config
         self.logger = getLogger(__name__)
 
     @property
     def sf(self):
         """simple_salesforce client"""
         if not self._sf:
-            self._sf, self._bulk = self._get_sf_clients(self.orgname)
+            project_config, org_config = self.get_project_config_and_org_config()
+            self._sf, self._bulk = self._get_sf_clients(project_config, org_config)
         return self._sf
 
     @property
@@ -57,11 +66,6 @@ def bulk(self):
         self.sf  # initializes self._bulk as a side-effect
         return self._bulk
 
-    @property
-    def orgname(self):
-        """Look up the orgname in the scope"""
-        return self.get_orgname()
-
     def query(self, *args, **kwargs):
         """Query Salesforce through simple_salesforce"""
         return self.sf.query(*args, **kwargs)
@@ -108,50 +112,85 @@ def compose_query(self, context_name, **kwargs):
         return query
 
     @staticmethod
-    def _get_sf_clients(orgname):
+    def _get_sf_clients(project_config, org_config):
+        from cumulusci.salesforce_api.utils import get_simple_salesforce_connection
 
-        try:
-            from cumulusci.cli.runtime import CliRuntime
-            from cumulusci.salesforce_api.utils import get_simple_salesforce_connection
+        sf = get_simple_salesforce_connection(project_config, org_config)
+        return sf, _init_bulk(sf, org_config)
 
-            runtime = CliRuntime(load_keychain=True)
-        except Exception as e:  # pragma: no cover
-            raise DataGenError("CumulusCI Runtime cannot be loaded", *e.args)
 
-        name, org_config = runtime.get_org(orgname)
-        sf = get_simple_salesforce_connection(runtime.project_config, org_config)
-        return sf, SalesforceConnection._init_bulk(sf, org_config)
+def _init_bulk(sf, org_config):
+    from salesforce_bulk import SalesforceBulk
 
-    @staticmethod
-    def _init_bulk(sf, org_config):
-        from salesforce_bulk import SalesforceBulk
+    return SalesforceBulk(
+        host=org_config.instance_url.replace("https://", "").rstrip("/"),
+        sessionId=org_config.access_token,
+        API_version=sf.sf_version,
+    )
 
-        return SalesforceBulk(
-            host=org_config.instance_url.replace("https://", "").rstrip("/"),
-            sessionId=org_config.access_token,
-            API_version=sf.sf_version,
-        )
+
+def check_orgconfig(config):
+    from cumulusci.core.config import BaseConfig
+
+    if isinstance(config, BaseConfig):
+        return config
+    raise TypeError(f"Should be a CCI Config, not {type(config)}")
 
 
 class SalesforceConnectionMixin:
     _sf_connection = None
-    allowed_options = [PluginOption(plugin_option_name, str)]
+    _runtime = None
+    allowed_options = [
+        PluginOption(plugin_option_org_name, str),
+        PluginOption(plugin_option_org_config, check_orgconfig),
+        PluginOption(plugin_option_project_config, check_orgconfig),
+    ]
 
     @property
     def sf_connection(self):
         assert self.context
         if not self._sf_connection:
-            self._sf_connection = SalesforceConnection(self.get_orgname)
+            self._sf_connection = SalesforceConnection(
+                self.get_project_config_and_org_config
+            )
         return self._sf_connection
 
-    def get_orgname(self):
-        """Look up the orgname in the scope"""
+    def get_project_config_and_org_config(self):
+        fieldvars = self.context.field_vars()
+        project_config = fieldvars.get(plugin_option_project_config)
+        org_config = fieldvars.get(plugin_option_org_config)
+
+        if not project_config or not org_config:
+            project_config, org_config = self._get_org_info_from_cli_keychain()
+
+        return project_config, org_config
+
+    def _get_org_info_from_cli_keychain(self):
+        org_name = self.get_org_name()  # from command line argument
+        runtime = self._get_CliRuntime()  # from CCI CliRuntime
+        name, org_config = runtime.get_org(org_name)
+        return runtime.project_config, org_config
+
+    def _get_CliRuntime(self):
+        if self._runtime:
+            return self._runtime  # pragma: no cover
+
+        try:
+            from cumulusci.cli.runtime import CliRuntime
+
+            self._runtime = CliRuntime(load_keychain=True)
+            return self._runtime
+        except Exception as e:  # pragma: no cover
+            raise DataGenError("CumulusCI Runtime cannot be loaded", *e.args)
+
+    def get_org_name(self):
+        """Look up the org_name in the scope"""
         fieldvars = self.context.field_vars()
         try:
-            return fieldvars[plugin_option_name]
+            return fieldvars[plugin_option_org_name]
         except KeyError:
             raise DataGenNameError(
-                "Orgname is not specified. Use --plugin-option orgname <yourorgname>",
+                "Orgname is not specified. Use --plugin-option org_name <yourorgname>",
                 None,
                 None,
             )

snowfakery/version.txt

@@ -1 +1 @@
-2.0.dev0
+2.0.dev1

tests/salesforce/test_where.recipe.yml

@@ -1,6 +1,6 @@
 # execute this recipe like this:
 
-# snowfakery tests/salesforce/test_where.recipe.yml --plugin-option orgname qa
+# snowfakery tests/salesforce/test_where.recipe.yml --plugin-option org_name qa
 
 - plugin: snowfakery.standard_plugins.Salesforce.SalesforceQuery