cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/core/config/scratch_org_config.py

@@ -0,0 +1,251 @@
+import datetime
+import json
+import os
+from typing import List, NoReturn, Optional
+
+import sarge
+
+from cumulusci.core.config import FAILED_TO_CREATE_SCRATCH_ORG
+from cumulusci.core.config.sfdx_org_config import SfdxOrgConfig
+from cumulusci.core.exceptions import (
+    CumulusCIException,
+    ScratchOrgException,
+    ServiceNotConfigured,
+)
+from cumulusci.core.sfdx import sfdx
+
+
+class ScratchOrgConfig(SfdxOrgConfig):
+    """Salesforce DX Scratch org configuration"""
+
+    noancestors: bool
+    # default = None  # what is this?
+    instance: str
+    password_failed: bool
+    devhub: str
+    release: str
+
+    createable: bool = True
+
+    @property
+    def scratch_info(self):
+        """Deprecated alias for sfdx_info.
+
+        Will create the scratch org if necessary.
+        """
+        return self.sfdx_info
+
+    @property
+    def days(self) -> int:
+        return self.config.setdefault("days", 1)
+
+    @property
+    def active(self) -> bool:
+        """Check if an org is alive"""
+        return self.date_created and not self.expired
+
+    @property
+    def expired(self) -> bool:
+        """Check if an org has already expired"""
+        now = datetime.datetime.now(datetime.timezone.utc)
+        if self.expires and self.expires.tzinfo is None:
+            # Convert naive expires to UTC for comparison
+            now = now.replace(tzinfo=None)
+        return bool(self.expires) and self.expires < now
+
+    @property
+    def expires(self) -> Optional[datetime.datetime]:
+        if self.date_created:
+            return self.date_created + datetime.timedelta(days=int(self.days))
+
+    @property
+    def days_alive(self) -> Optional[int]:
+        if self.date_created and not self.expired:
+            if self.date_created.tzinfo is None:
+                # For naive date_created, use naive local time for consistent comparison
+                now = datetime.datetime.now()
+            else:
+                # For timezone-aware date_created, use timezone-aware UTC time
+                now = datetime.datetime.now(datetime.timezone.utc)
+            delta = now - self.date_created
+            return delta.days + 1
+
+    def create_org(self) -> None:
+        """Uses sf org create scratch  to create the org"""
+        if not self.config_file:
+            raise ScratchOrgException(
+                f"Scratch org config {self.name} is missing a config_file"
+            )
+        if not self.scratch_org_type:
+            self.config["scratch_org_type"] = "workspace"
+
+        args: List[str] = self._build_org_create_args()
+        extra_args = os.environ.get("SFDX_ORG_CREATE_ARGS", "")
+        p: sarge.Command = sfdx(
+            f"org create scratch --json {extra_args}",
+            args=args,
+            username=None,
+            log_note="Creating scratch org",
+        )
+        stdout = p.stdout_text.read()
+        stderr = p.stderr_text.read()
+
+        def raise_error() -> NoReturn:
+            message = f"{FAILED_TO_CREATE_SCRATCH_ORG}: \n{stdout}\n{stderr}"
+            try:
+                output = json.loads(stdout)
+                if (
+                    output.get("message") == "The requested resource does not exist"
+                    and output.get("name") == "NOT_FOUND"
+                ):
+                    raise ScratchOrgException(
+                        "The Salesforce CLI was unable to create a scratch org. Ensure you are connected using a valid API version on an active Dev Hub."
+                    )
+            except json.decoder.JSONDecodeError:
+                raise ScratchOrgException(message)
+
+            raise ScratchOrgException(message)
+
+        result = {}  # for type checker.
+        if p.returncode:
+            raise_error()
+        try:
+            result = json.loads(stdout)
+
+        except json.decoder.JSONDecodeError:
+            raise_error()
+
+        if (
+            not (res := result.get("result"))
+            or ("username" not in res)
+            or ("orgId" not in res)
+        ):
+            raise_error()
+
+        if res["username"] is None:
+            raise ScratchOrgException(
+                "SFDX claimed to be successful but there was no username "
+                "in the output...maybe there was a gack?"
+            )
+
+        self.config["org_id"] = res["orgId"]
+        self.config["username"] = res["username"]
+
+        self.config["date_created"] = datetime.datetime.now(datetime.timezone.utc)
+
+        self.logger.error(stderr)
+
+        self.logger.info(
+            f"Created: OrgId: {self.config['org_id']}, Username:{self.config['username']}"
+        )
+
+        if self.config.get("set_password"):
+            self.generate_password()
+
+        # Flag that this org has been created
+        self.config["created"] = True
+
+    def _build_org_create_args(self) -> List[str]:
+        args = ["-f", self.config_file, "-w", "120"]
+        devhub_username: Optional[str] = self._choose_devhub_username()
+        if devhub_username:
+            args += ["--target-dev-hub", devhub_username]
+        if not self.namespaced:
+            args += ["--no-namespace"]
+        if self.noancestors:
+            args += ["--no-ancestors"]
+        if self.days:
+            args += ["--duration-days", str(self.days)]
+        if self.release:
+            args += [f"--release={self.release}"]
+        if self.sfdx_alias:
+            args += ["-a", self.sfdx_alias]
+        with open(self.config_file, "r") as org_def:
+            org_def_data = json.load(org_def)
+            org_def_has_email = "adminEmail" in org_def_data
+        if self.email_address and not org_def_has_email:
+            args += [f"--admin-email={self.email_address}"]
+        if self.default:
+            args += ["--set-default"]
+
+        return args
+
+    def _choose_devhub_username(self) -> Optional[str]:
+        """Determine which devhub username to specify when calling sfdx, if any."""
+        # If a devhub was specified via `cci org scratch`, use it.
+        # (This will return None if "devhub" isn't set in the org config,
+        # in which case sf will use its target-dev-hub.)
+        devhub_username = self.devhub
+        if not devhub_username and self.keychain is not None:
+            # Otherwise see if one is configured via the "devhub" service
+            try:
+                devhub_service = self.keychain.get_service("devhub")
+            except (ServiceNotConfigured, CumulusCIException):
+                pass
+            else:
+                devhub_username = devhub_service.username
+        return devhub_username
+
+    def generate_password(self) -> None:
+        """Generates an org password with: sf org generate password.
+        On a non-zero return code, set the password_failed in our config
+        and log the output (stdout/stderr) from sfdx."""
+
+        if self.password_failed:
+            self.logger.warning("Skipping resetting password since last attempt failed")
+            return
+
+        p: sarge.Command = sfdx(
+            "org generate password",
+            self.username,
+            log_note="Generating scratch org user password",
+        )
+
+        if p.returncode:
+            self.config["password_failed"] = True
+            stderr = p.stderr_text.readlines()
+            stdout = p.stdout_text.readlines()
+            # Don't throw an exception because of failure creating the
+            # password, just notify in a log message
+            nl = "\n"  # fstrings can't contain backslashes
+            self.logger.warning(
+                f"Failed to set password: \n{nl.join(stdout)}\n{nl.join(stderr)}"
+            )
+
+    def format_org_days(self) -> str:
+        if self.days_alive:
+            org_days = f"{self.days_alive}/{self.days}"
+        else:
+            org_days = str(self.days)
+        return org_days
+
+    def can_delete(self) -> bool:
+        return bool(self.date_created)
+
+    def delete_org(self) -> None:
+        """Uses sf org delete scratch to delete the org"""
+        if not self.created:
+            self.logger.info("Skipping org deletion: the scratch org does not exist.")
+            return
+
+        p: sarge.Command = sfdx(
+            "org delete scratch -p", self.username, "Deleting scratch org"
+        )
+        sfdx_output: List[str] = list(p.stdout_text) + list(p.stderr_text)
+
+        for line in sfdx_output:
+            if "error" in line.lower():
+                self.logger.error(line)
+            else:
+                self.logger.info(line)
+
+        if p.returncode:
+            message = "Failed to delete scratch org"
+            raise ScratchOrgException(message)
+
+        # Flag that this org has been deleted
+        self.config["created"] = False
+        self.config["username"] = None
+        self.config["date_created"] = None
+        self.config["instance_url"] = None
+        self.save()

cumulusci/core/config/sfdx_org_config.py

@@ -0,0 +1,220 @@
+import datetime
+import json
+from json.decoder import JSONDecodeError
+
+from cumulusci.core.config import OrgConfig
+from cumulusci.core.exceptions import SfdxOrgException
+from cumulusci.core.sfdx import sfdx
+from cumulusci.utils import get_git_config
+
+nl = "\n"  # fstrings can't contain backslashes
+
+
+class SfdxOrgConfig(OrgConfig):
+    """Org config which loads from sfdx keychain"""
+
+    @property
+    def sfdx_info(self):
+        if hasattr(self, "_sfdx_info"):
+            return self._sfdx_info
+
+        # On-demand creation of scratch orgs
+        if self.createable and not self.created:
+            self.create_org()
+
+        username = self.config.get("username")
+        assert username is not None, "SfdxOrgConfig must have a username"
+        if not self.print_json:
+            self.logger.info(f"Getting org info from Salesforce CLI for {username}")
+
+        # Call org display and parse output to get instance_url and
+        # access_token
+        p = sfdx("org display --json", self.username)
+
+        org_info = None
+        stderr_list = [line.strip() for line in p.stderr_text]
+        stdout_list = [line.strip() for line in p.stdout_text]
+
+        if p.returncode:
+            self.logger.error(f"Return code: {p.returncode}")
+            for line in stderr_list:
+                self.logger.error(line)
+            for line in stdout_list:
+                self.logger.error(line)
+            message = f"\nstderr:\n{nl.join(stderr_list)}"
+            message += f"\nstdout:\n{nl.join(stdout_list)}"
+            raise SfdxOrgException(message)
+
+        else:
+            try:
+                org_info = json.loads("".join(stdout_list))
+            except Exception as e:
+                raise SfdxOrgException(
+                    "Failed to parse json from output.\n  "
+                    f"Exception: {e.__class__.__name__}\n  Output: {''.join(stdout_list)}"
+                )
+            org_id = org_info["result"]["accessToken"].split("!")[0]
+
+        sfdx_info = {
+            "instance_url": org_info["result"]["instanceUrl"],
+            "access_token": org_info["result"]["accessToken"],
+            "org_id": org_id,
+            "username": org_info["result"]["username"],
+        }
+        if org_info["result"].get("password"):
+            sfdx_info["password"] = org_info["result"]["password"]
+        self._sfdx_info = sfdx_info
+        self._sfdx_info_date = datetime.datetime.now(datetime.timezone.utc)
+        self.config.update(sfdx_info)
+
+        sfdx_info.update(
+            {
+                "created_date": org_info["result"].get("createdDate"),
+                "expiration_date": org_info["result"].get("expirationDate"),
+            }
+        )
+        return sfdx_info
+
+    @property
+    def access_token(self):
+        return self.sfdx_info["access_token"]
+
+    @property
+    def instance_url(self):
+        return self.config.get("instance_url") or self.sfdx_info["instance_url"]
+
+    @property
+    def org_id(self):
+        org_id = self.config.get("org_id")
+        if not org_id:
+            org_id = self.sfdx_info["org_id"]
+        return org_id
+
+    @property
+    def user_id(self):
+        if not self.config.get("user_id"):
+            result = self.salesforce_client.query_all(
+                f"SELECT Id FROM User WHERE UserName='{self.username}'"
+            )
+            self.config["user_id"] = result["records"][0]["Id"]
+        return self.config["user_id"]
+
+    @property
+    def username(self):
+        username = self.config.get("username")
+        if not username:
+            username = self.sfdx_info["username"]
+        return username
+
+    @property
+    def password(self):
+        password = self.config.get("password")
+        if not password:
+            password = self.sfdx_info["password"]
+        return password
+
+    @property
+    def email_address(self):
+        email_address = self.config.get("email_address")
+        if not email_address:
+            email_address = get_git_config("user.email")
+            self.config["email_address"] = email_address
+
+        return email_address
+
+    def get_access_token(self, **userfields):
+        """Get the access token for a specific user
+
+        If no keyword arguments are passed in, this will return the
+        access token for the default user. If userfields has the key
+        "username", the access token for that user will be returned.
+        Otherwise, a SOQL query will be made based off of the
+        passed-in fields to find the username, and the token for that
+        username will be returned.
+
+        Examples:
+
+        | # default user access token:
+        | token = org.get_access_token()
+
+        | # access token for 'test@example.com'
+        | token = org.get_access_token(username='test@example.com')
+
+        | # access token for user based on lookup fields
+        | token = org.get_access_token(alias='dadvisor')
+
+        """
+        if not userfields:
+            # No lookup fields specified? Return the token for the default user
+            return self.access_token
+
+        # if we have a username, use it. Otherwise we need to do a
+        # lookup using the passed-in fields.
+        username = userfields.get("username", None)
+        if username is None:
+            where = [f"{key} = '{value}'" for key, value in userfields.items()]
+            query = f"SELECT Username FROM User WHERE {' AND '.join(where)}"
+            result = self.salesforce_client.query_all(query).get("records", [])
+            if len(result) == 0:
+                raise SfdxOrgException(
+                    "Couldn't find a username for the specified user."
+                )
+            elif len(result) > 1:
+                raise SfdxOrgException(
+                    "More than one user matched the search critiera."
+                )
+            else:
+                username = result[0]["Username"]
+
+        p = sfdx(f"org display --target-org={username} --json")
+        if p.returncode:
+            output = p.stdout_text.read()
+            try:
+                info = json.loads(output)
+                explanation = info["message"]
+            except (JSONDecodeError, KeyError):
+                explanation = output
+
+            raise SfdxOrgException(
+                f"Unable to find access token for {username}\n{explanation}"
+            )
+        else:
+            info = json.loads(p.stdout_text.read())
+            return info["result"]["accessToken"]
+
+    def force_refresh_oauth_token(self):
+        # Call org display and parse output to get instance_url and
+        # access_token
+        p = sfdx("org open -r", self.username, log_note="Refreshing OAuth token")
+
+        stdout_list = [line.strip() for line in p.stdout_text]
+
+        if p.returncode:
+            self.logger.error(f"Return code: {p.returncode}")
+            for line in stdout_list:
+                self.logger.error(line)
+            message = f"Message: {nl.join(stdout_list)}"
+            raise SfdxOrgException(message)
+
+    # Added a print json argument to check whether it is there or not
+    def refresh_oauth_token(self, keychain, print_json=False):
+        """Use sfdx org display to refresh token instead of built in OAuth handling"""
+        if hasattr(self, "_sfdx_info"):
+            # Cache the sfdx_info for 1 hour to avoid unnecessary calls out to sfdx CLI
+            if self._sfdx_info_date.tzinfo is None:
+                # For naive _sfdx_info_date, use naive local time for consistent comparison
+                now = datetime.datetime.now()
+            else:
+                # For timezone-aware _sfdx_info_date, use timezone-aware UTC time
+                now = datetime.datetime.now(datetime.timezone.utc)
+            delta = now - self._sfdx_info_date
+            if delta.total_seconds() > 3600:
+                del self._sfdx_info
+
+                # Force a token refresh
+                self.force_refresh_oauth_token()
+        self.print_json = print_json
+        # Get org info via sf org display
+        self.sfdx_info
+        # Get additional org info by querying API
+        self._load_orginfo()

cumulusci/core/config/tests/_test_config_backwards_compatibility.py

@@ -0,0 +1,33 @@
+# run this in a separate process to not confuse
+# the module table
+import os
+from unittest.mock import patch
+
+import pytest
+
+from cumulusci.utils.deprecation import ClassMovedWarning
+
+
+class TestConfigBackwardsCompatibility:
+    @patch.dict(os.environ)
+    def test_temporary_backwards_compatibility_hacks(self):
+        with pytest.warns(ClassMovedWarning):
+
+            from cumulusci.core.config.OrgConfig import OrgConfig
+
+            assert isinstance(OrgConfig, type)
+
+        with pytest.warns(ClassMovedWarning):
+            from cumulusci.core.config.ScratchOrgConfig import ScratchOrgConfig  # noqa
+
+            assert isinstance(ScratchOrgConfig, type)
+
+        with pytest.warns(ClassMovedWarning):
+            from cumulusci.core.config.BaseConfig import BaseConfig
+
+            assert isinstance(BaseConfig, type)
+
+        with pytest.warns(ClassMovedWarning):
+            from cumulusci.core.config.BaseTaskFlowConfig import BaseTaskFlowConfig
+
+            assert isinstance(BaseTaskFlowConfig, type)