cumulusci-plus 5.0.26__tar.gz → 5.0.53__tar.gz

{cumulusci_plus-5.0.26 → cumulusci_plus-5.0.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cumulusci-plus
-Version: 5.0.26
+Version: 5.0.53
 Summary: Build and release tools for Salesforce developers
 Project-URL: Homepage, https://github.com/jorgesolebur/CumulusCI
 Project-URL: Changelog, https://cumulusci.readthedocs.io/en/stable/history.html
@@ -19,10 +19,11 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.11
+Requires-Dist: boto3
 Requires-Dist: click>=8.1
 Requires-Dist: cryptography
 Requires-Dist: defusedxml
-Requires-Dist: docutils==0.21.2
+Requires-Dist: docutils<=0.21.2
 Requires-Dist: faker
 Requires-Dist: fs
 Requires-Dist: github3-py
@@ -32,7 +33,7 @@ Requires-Dist: lxml
 Requires-Dist: markupsafe
 Requires-Dist: packaging>=23.0
 Requires-Dist: psutil
-Requires-Dist: pydantic<2
+Requires-Dist: pydantic<3,>=2.0
 Requires-Dist: pyjwt
 Requires-Dist: python-dateutil
 Requires-Dist: python-dotenv
@@ -50,18 +51,17 @@ Requires-Dist: salesforce-bulk
 Requires-Dist: sarge
 Requires-Dist: selenium<4
 Requires-Dist: simple-salesforce==1.11.4
-Requires-Dist: snowfakery>=4.0.0
+Requires-Dist: snowfakery>=4.1.0
 Requires-Dist: sqlalchemy<2
 Requires-Dist: xmltodict
 Provides-Extra: select
 Requires-Dist: annoy; extra == 'select'
-Requires-Dist: boto3; extra == 'select'
 Requires-Dist: numpy; extra == 'select'
 Requires-Dist: pandas; extra == 'select'
 Requires-Dist: scikit-learn; extra == 'select'
 Description-Content-Type: text/markdown
 
-# CumulusCI
+# CumulusCI Plus
 
 [![Code Coverage](https://coveralls.io/repos/github/SFDO-Tooling/CumulusCI/badge.svg?branch=main)](https://coveralls.io/github/SFDO-Tooling/CumulusCI?branch=main)
 [![PyPI](https://img.shields.io/pypi/v/cumulusci)](https://pypi.org/project/cumulusci-plus/)
@@ -129,14 +129,12 @@ license](https://github.com/SFDO-Tooling/CumulusCI/blob/main/LICENSE)
 and is not covered by the Salesforce Master Subscription Agreement.
 
 <!-- Changelog -->
-## v5.0.26 (2025-10-14)
+## v5.0.53 (2026-01-19)
 <!-- Release notes generated using configuration in .github/release.yml at main -->
 
 ## What's Changed
 ### Changes
-* Fix lint issues. by [@rupeshjSFDC](https://github.com/rupeshjSFDC) in [#95](https://github.com/jorgesolebur/CumulusCI/pull/95)
-* Fix failing test on Mac with Python 3.11 and 3.13 by [@rupeshjSFDC](https://github.com/rupeshjSFDC) in [#97](https://github.com/jorgesolebur/CumulusCI/pull/97)
-* Feature/secret manager by [@rupeshjSFDC](https://github.com/rupeshjSFDC) in [#99](https://github.com/jorgesolebur/CumulusCI/pull/99)
+* Get instance url from the config. by [@rupeshjSFDC](https://github.com/rupeshjSFDC) in [#184](https://github.com/jorgesolebur/CumulusCI/pull/184)
 
 
-**Full Changelog**: https://github.com/jorgesolebur/CumulusCI/compare/v5.0.25...v5.0.26
+**Full Changelog**: https://github.com/jorgesolebur/CumulusCI/compare/v5.0.52...v5.0.53

{cumulusci_plus-5.0.26 → cumulusci_plus-5.0.53}/README.md

@@ -1,4 +1,4 @@
-# CumulusCI
+# CumulusCI Plus
 
 [![Code Coverage](https://coveralls.io/repos/github/SFDO-Tooling/CumulusCI/badge.svg?branch=main)](https://coveralls.io/github/SFDO-Tooling/CumulusCI?branch=main)
 [![PyPI](https://img.shields.io/pypi/v/cumulusci)](https://pypi.org/project/cumulusci-plus/)

cumulusci_plus-5.0.53/cumulusci/__about__.py

@@ -0,0 +1 @@
+__version__ = "5.0.53"

{cumulusci_plus-5.0.26 → cumulusci_plus-5.0.53}/cumulusci/cli/cci.py

@@ -23,7 +23,7 @@ from cumulusci.utils.logging import tee_stdout_stderr
 
 from .error import error
 from .flow import flow
-from .logger import get_tempfile_logger, init_logger
+from .logger import _set_windows_console_encoding, get_tempfile_logger, init_logger
 from .org import org
 from .plan import plan
 from .project import project
@@ -152,6 +152,9 @@ def main(args=None):
         # (If enabled) set up requests to validate certs using system CA certs instead of certifi
         init_requests_trust()
 
+        # Set Windows console encoding early (before wrapping stdout/stderr)
+        _set_windows_console_encoding()
+
         # Check for updates _unless_ we've been asked to output JSON,
         # or if we're going to check anyway as part of the `version` command.
         is_version_command = len(args) > 1 and args[1] == "version"
@@ -173,11 +176,11 @@ def main(args=None):
         with set_debug_mode(debug):
             try:
                 runtime = CliRuntime(load_keychain=False)
+                runtime.check_cumulusci_version()
             except Exception as e:
                 handle_exception(e, is_error_command, tempfile_path, debug)
                 sys.exit(1)
 
-            runtime.check_cumulusci_version()
             should_show_stacktraces = runtime.universal_config.cli__show_stacktraces
 
             init_logger(debug=debug)
@@ -233,7 +236,8 @@ def handle_exception(
         with open(logfile_path, "a") as log_file:
             traceback.print_exc(file=log_file)  # log stacktrace silently
 
-    if should_show_stacktraces and not isinstance(error, USAGE_ERRORS):
+    # Show stacktraces when explicitly requested (e.g., --debug flag)
+    if should_show_stacktraces:
         error_console.print_exception()
 
 

{cumulusci_plus-5.0.26 → cumulusci_plus-5.0.53}/cumulusci/cli/flow.py

@@ -127,6 +127,11 @@ def flow_info(runtime, flow_name):
     is_flag=True,
     help="If set, deletes the scratch org after the flow completes",
 )
+@click.option(
+    "--no-org",
+    is_flag=True,
+    help="If set, does not need an org for the flow to run against, no-org and org options are mutually exclusive",
+)
 @click.option(
     "--debug", is_flag=True, help="Drops into pdb, the Python debugger, on an exception"
 )
@@ -142,12 +147,21 @@ def flow_info(runtime, flow_name):
     help="Disables all prompts.  Set for non-interactive mode use such as calling from scripts or CI systems",
 )
 @pass_runtime(require_keychain=True)
-def flow_run(runtime, flow_name, org, delete_org, debug, o, no_prompt):
+def flow_run(runtime, flow_name, org, delete_org, no_org, debug, o, no_prompt):
+
+    # Set click.no_prompt to disable all prompts in non-interactive mode
+    if no_prompt:
+        click.no_prompt = True
 
     # Get necessary configs
-    org, org_config = runtime.get_org(org)
-    if delete_org and not org_config.scratch:
-        raise click.UsageError("--delete-org can only be used with a scratch org")
+    org_config = None
+    if no_org:
+        if org:
+            raise click.UsageError("--no-org and --org are mutually exclusive")
+    else:
+        org, org_config = runtime.get_org(org, fail_if_missing=True)
+        if delete_org and not org_config.scratch:
+            raise click.UsageError("--delete-org can only be used with a scratch org")
 
     # Parse command line options
     options = defaultdict(dict)

{cumulusci_plus-5.0.26 → cumulusci_plus-5.0.53}/cumulusci/cli/logger.py

@@ -14,6 +14,54 @@ except ImportError:
     pass
 
 
+def _set_windows_console_encoding():
+    """Set Windows console encoding to UTF-8 to support Unicode characters.
+
+    This function attempts multiple methods to set UTF-8 encoding on Windows:
+    1. Sets PYTHONIOENCODING environment variable
+    2. Sets sys.stdout and sys.stderr encoding
+    3. Uses Windows console API if available
+    """
+    if os.name != "nt":  # Only on Windows
+        return
+
+    try:
+        # Method 1: Set environment variable (affects subprocesses too)
+        os.environ.setdefault("PYTHONIOENCODING", "utf-8")
+
+        # Method 2: Reconfigure stdout/stderr with UTF-8 encoding
+        # This works if the streams support reconfiguration
+        if hasattr(sys.stdout, "reconfigure"):
+            try:
+                sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+            except (AttributeError, ValueError):
+                pass
+
+        if hasattr(sys.stderr, "reconfigure"):
+            try:
+                sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+            except (AttributeError, ValueError):
+                pass
+
+        # Method 3: Use Windows console API to set code page to UTF-8 (65001)
+        try:
+            import ctypes
+
+            kernel32 = ctypes.windll.kernel32
+            # Set console output code page to UTF-8
+            kernel32.SetConsoleOutputCP(65001)
+            # Set console input code page to UTF-8 (optional, for input)
+            kernel32.SetConsoleCP(65001)
+        except (AttributeError, OSError):
+            # Windows API not available or failed, continue with other methods
+            pass
+
+    except Exception:
+        # If any method fails, continue - encoding setup is best-effort
+        # The console should handle UTF-8 if Windows API calls succeed
+        pass
+
+
 def init_logger(debug=False):
     """Initialize the logger"""
 
@@ -21,6 +69,9 @@ def init_logger(debug=False):
     for handler in logger.handlers:  # pragma: no cover
         logger.removeHandler(handler)
 
+    # Set Windows console encoding to UTF-8 before initializing colorama
+    _set_windows_console_encoding()
+
     if os.name == "nt" and "colorama" in sys.modules:  # pragma: no cover
         colorama.init()
 
@@ -32,14 +83,14 @@ def init_logger(debug=False):
             tracebacks_show_locals=debug,
         )
     )
-    logger.setLevel(logging.DEBUG)
+    logger.setLevel(logging.DEBUG if debug else logging.INFO)
     logger.propagate = False
 
     if debug:  # pragma: no cover
         # Referenced from:
         # https://github.com/urllib3/urllib3/blob/cd55f2fe98df4d499ab5c826433ee4995d3f6a60/src/urllib3/__init__.py#L48
         def add_rich_logger(
-            module: str, level: int = logging.DEBUG
+            module: str, level: int = logging.DEBUG if debug else logging.INFO
         ) -> logging.StreamHandler:
             """Retrieve the logger for the given module.
             Remove all handlers from it, and add a single RichHandler."""

{cumulusci_plus-5.0.26 → cumulusci_plus-5.0.53}/cumulusci/cli/service.py

@@ -83,6 +83,25 @@ class ConnectServiceCommand(click.MultiCommand):
         services = self._get_services_config(runtime)
         return sorted(services.keys())
 
+    def invoke(self, ctx):
+        """Override to show available services instead of 'Missing command' error"""
+        try:
+            return super().invoke(ctx)
+        except click.UsageError as e:
+            if "Missing command" in str(e):
+                # No subcommand provided - list available services
+                services = self.list_commands(ctx)
+                if services:
+                    click.echo("Available services:")
+                    for service in services:
+                        click.echo(f"  {service}")
+                else:
+                    click.echo("No services available to configure.")
+                return
+            else:
+                # Re-raise other usage errors
+                raise
+
     def _build_param(self, attribute: str, details: dict) -> click.Option:
         required = details.get("required", False)
         default_factory: Optional[Callable] = self._get_callable_default(
@@ -288,6 +307,7 @@ class ConnectServiceCommand(click.MultiCommand):
     cls=ConnectServiceCommand,
     name="connect",
     help="Connect an external service to CumulusCI",
+    no_args_is_help=False,
 )
 def service_connect():
     pass

{cumulusci_plus-5.0.26 → cumulusci_plus-5.0.53}/cumulusci/cli/task.py

@@ -140,10 +140,13 @@ class RunTaskCommand(click.MultiCommand):
 
     def get_command(self, ctx, task_name):
         runtime = ctx.obj
-        if runtime.project_config is None:
-            raise runtime.project_config_error
         runtime._load_keychain()
-        task_config = runtime.project_config.get_task(task_name)
+        if runtime.project_config is None:
+            task_config = runtime.universal_config.get_task(task_name)
+            if not task_config.is_global:
+                raise runtime.project_config_error
+        else:
+            task_config = runtime.project_config.get_task(task_name)
 
         if "options" not in task_config.config:
             task_config.config["options"] = {}
@@ -156,15 +159,15 @@ class RunTaskCommand(click.MultiCommand):
 
         def run_task(*args, **kwargs):
             """Callback function that executes when the command fires."""
+            # Set click.no_prompt to disable all prompts in non-interactive mode
+            if kwargs.get("no_prompt", False):
+                click.no_prompt = True
+
             # Load environment variables FIRST, before any task processing
-            if kwargs.get("loadenv", None):
+            if kwargs.get("loadenv", None) and runtime.project_config is not None:
                 # Load .env file from the project root directory
-                env_path = (
-                    Path(runtime.project_config.repo_root) / ".env"
-                    if runtime.project_config
-                    else None
-                )
-                if env_path:
+                env_path = Path(runtime.project_config.repo_root) / ".env"
+                if env_path and env_path.exists():
                     load_dotenv(env_path)
 
             org, org_config = runtime.get_org(

{cumulusci_plus-5.0.26 → cumulusci_plus-5.0.53}/cumulusci/cli/tests/test_cci.py

@@ -36,11 +36,13 @@ def reset_signal_handler_flag():
 @mock.patch("cumulusci.cli.cci.get_tempfile_logger")
 @mock.patch("cumulusci.cli.cci.init_logger")
 @mock.patch("cumulusci.cli.cci.check_latest_version")
+@mock.patch("cumulusci.cli.cci._set_windows_console_encoding")
 @mock.patch("cumulusci.cli.cci.CliRuntime")
 @mock.patch("cumulusci.cli.cci.cli")
 def test_main(
     cli,
     CliRuntime,
+    set_windows_encoding,
     check_latest_version,
     init_logger,
     get_tempfile_logger,
@@ -49,6 +51,8 @@ def test_main(
     get_tempfile_logger.return_value = mock.Mock(), "tempfile.log"
     cci.main()
 
+    # Verify _set_windows_console_encoding is called
+    set_windows_encoding.assert_called_once()
     check_latest_version.assert_called_once()
     init_logger.assert_called_once()
     CliRuntime.assert_called_once()
@@ -60,6 +64,7 @@ def test_main(
 @mock.patch("cumulusci.cli.cci.get_tempfile_logger")
 @mock.patch("cumulusci.cli.cci.init_logger")
 @mock.patch("cumulusci.cli.cci.check_latest_version")
+@mock.patch("cumulusci.cli.cci._set_windows_console_encoding")
 @mock.patch("cumulusci.cli.cci.CliRuntime")
 @mock.patch("cumulusci.cli.cci.cli")
 @mock.patch("pdb.post_mortem")
@@ -69,6 +74,7 @@ def test_main__debug(
     post_mortem,
     cli,
     CliRuntime,
+    set_windows_encoding,
     check_latest_version,
     init_logger,
     get_tempfile_logger,
@@ -79,6 +85,7 @@ def test_main__debug(
 
     cci.main(["cci", "--debug"])
 
+    set_windows_encoding.assert_called_once()
     check_latest_version.assert_called_once()
     init_logger.assert_called_once_with(debug=True)
     CliRuntime.assert_called_once()

{cumulusci_plus-5.0.26 → cumulusci_plus-5.0.53}/cumulusci/cli/tests/test_flow.py

@@ -154,6 +154,7 @@ def test_flow_run():
         runtime=runtime,
         flow_name="test",
         org="test",
+        no_org=False,
         delete_org=True,
         debug=False,
         o=[("test_task__color", "blue")],
@@ -191,6 +192,7 @@ def test_flow_run__delete_org_when_error_occurs_in_flow():
             runtime=runtime,
             flow_name="test",
             org="test",
+            no_org=False,
             delete_org=True,
             debug=False,
             o=[("test_task__color", "blue")],
@@ -214,6 +216,7 @@ def test_flow_run__option_error():
             runtime=runtime,
             flow_name="test",
             org="test",
+            no_org=False,
             delete_org=True,
             debug=False,
             o=[("test_task", "blue")],
@@ -232,6 +235,7 @@ def test_flow_run__delete_non_scratch():
             runtime=runtime,
             flow_name="test",
             org="test",
+            no_org=False,
             delete_org=True,
             debug=False,
             o=None,
@@ -264,6 +268,7 @@ def test_flow_run__org_delete_error(echo):
         "runtime": runtime,
         "flow_name": "test",
         "org": "test",
+        "no_org": False,
         "delete_org": True,
         "debug": False,
         "no_prompt": True,

cumulusci_plus-5.0.53/cumulusci/cli/tests/test_logger.py

@@ -0,0 +1,187 @@
+import builtins
+import logging
+import os
+from unittest.mock import Mock, patch
+
+from ..logger import _set_windows_console_encoding, get_tempfile_logger, init_logger
+
+
+class TestLogger:
+    @patch("cumulusci.cli.logger.requests")
+    @patch("cumulusci.cli.logger.logging")
+    def test_init_logger(self, logging, requests):
+        logger = Mock(handlers=["leftover"])
+        logging.getLogger.return_value = logger
+        init_logger()
+        logger.removeHandler.assert_called_once_with("leftover")
+        logger.addHandler.assert_called_once()
+
+    def test_get_tempfile_logger(self):
+        logger, tempfile = get_tempfile_logger()
+        assert os.path.isfile(tempfile)
+        assert len(logger.handlers) == 1
+        assert isinstance(logger.handlers[0], logging.FileHandler)
+        # delete temp logfile
+        logger.handlers[0].close()
+        os.remove(tempfile)
+
+    @patch("cumulusci.cli.logger.os.name", "nt")
+    @patch("cumulusci.cli.logger.os.environ")
+    @patch("cumulusci.cli.logger.sys.stdout")
+    @patch("cumulusci.cli.logger.sys.stderr")
+    @patch("builtins.__import__", wraps=builtins.__import__)
+    def test_set_windows_console_encoding_on_windows(
+        self, mock_import, mock_stderr, mock_stdout, mock_environ
+    ):
+        """Test that _set_windows_console_encoding() sets encoding on Windows"""
+        # Mock stdout/stderr to have reconfigure method
+        mock_stdout.reconfigure = Mock()
+        mock_stderr.reconfigure = Mock()
+
+        # Mock Windows API - intercept ctypes import
+        mock_kernel32 = Mock()
+        mock_ctypes = Mock()
+        mock_ctypes.windll.kernel32 = mock_kernel32
+
+        def import_side_effect(name, *args, **kwargs):
+            if name == "ctypes":
+                return mock_ctypes
+            # For other imports, use the wrapped original import
+            return mock_import.__wrapped__(name, *args, **kwargs)
+
+        mock_import.side_effect = import_side_effect
+
+        _set_windows_console_encoding()
+
+        # Verify environment variable was set
+        mock_environ.setdefault.assert_called_once_with("PYTHONIOENCODING", "utf-8")
+
+        # Verify reconfigure was attempted
+        mock_stdout.reconfigure.assert_called_once_with(
+            encoding="utf-8", errors="replace"
+        )
+        mock_stderr.reconfigure.assert_called_once_with(
+            encoding="utf-8", errors="replace"
+        )
+
+        # Verify Windows API was called
+        assert mock_kernel32.SetConsoleOutputCP.called
+        assert mock_kernel32.SetConsoleOutputCP.call_args[0] == (65001,)
+        assert mock_kernel32.SetConsoleCP.called
+        assert mock_kernel32.SetConsoleCP.call_args[0] == (65001,)
+
+    @patch("cumulusci.cli.logger.os.name", "posix")
+    @patch("cumulusci.cli.logger.os.environ")
+    @patch("cumulusci.cli.logger.sys.stdout")
+    @patch("cumulusci.cli.logger.sys.stderr")
+    def test_set_windows_console_encoding_skips_on_non_windows(
+        self, mock_stderr, mock_stdout, mock_environ
+    ):
+        """Test that _set_windows_console_encoding() does nothing on non-Windows"""
+        _set_windows_console_encoding()
+
+        # Verify nothing was called
+        mock_environ.setdefault.assert_not_called()
+        assert (
+            not hasattr(mock_stdout, "reconfigure")
+            or not mock_stdout.reconfigure.called
+        )
+        assert (
+            not hasattr(mock_stderr, "reconfigure")
+            or not mock_stderr.reconfigure.called
+        )
+
+    @patch("cumulusci.cli.logger.os.name", "nt")
+    @patch("cumulusci.cli.logger.os.environ")
+    @patch("cumulusci.cli.logger.sys.stdout", new_callable=lambda: Mock(spec=[]))
+    @patch("cumulusci.cli.logger.sys.stderr", new_callable=lambda: Mock(spec=[]))
+    def test_set_windows_console_encoding_handles_no_reconfigure(
+        self, mock_stderr, mock_stdout, mock_environ
+    ):
+        """Test that _set_windows_console_encoding() handles streams without reconfigure"""
+        # Mock stdout/stderr created with spec=[] means hasattr() will return False for reconfigure
+        # Should not raise an error
+        _set_windows_console_encoding()
+
+        # Verify environment variable was still set
+        mock_environ.setdefault.assert_called_once_with("PYTHONIOENCODING", "utf-8")
+
+    @patch("cumulusci.cli.logger.os.name", "nt")
+    @patch("cumulusci.cli.logger.os.environ")
+    @patch("cumulusci.cli.logger.sys.stdout")
+    @patch("cumulusci.cli.logger.sys.stderr")
+    @patch("builtins.__import__", wraps=builtins.__import__)
+    def test_set_windows_console_encoding_handles_reconfigure_error(
+        self, mock_import, mock_stderr, mock_stdout, mock_environ
+    ):
+        """Test that _set_windows_console_encoding() handles reconfigure errors gracefully"""
+        # Mock stdout/stderr to raise errors on reconfigure
+        mock_stdout.reconfigure = Mock(side_effect=ValueError("Cannot reconfigure"))
+        mock_stderr.reconfigure = Mock(side_effect=ValueError("Cannot reconfigure"))
+
+        # Mock ctypes import to avoid errors
+        mock_ctypes = Mock()
+        mock_kernel32 = Mock()
+        mock_ctypes.windll.kernel32 = mock_kernel32
+
+        def import_side_effect(name, *args, **kwargs):
+            if name == "ctypes":
+                return mock_ctypes
+            return mock_import.__wrapped__(name, *args, **kwargs)
+
+        mock_import.side_effect = import_side_effect
+
+        # Should not raise an error
+        _set_windows_console_encoding()
+
+        # Verify environment variable was still set
+        mock_environ.setdefault.assert_called_once_with("PYTHONIOENCODING", "utf-8")
+
+    @patch("cumulusci.cli.logger.os.name", "nt")
+    @patch("cumulusci.cli.logger.os.environ")
+    @patch("cumulusci.cli.logger.sys.stdout")
+    @patch("cumulusci.cli.logger.sys.stderr")
+    @patch("builtins.__import__", wraps=builtins.__import__)
+    def test_set_windows_console_encoding_handles_ctypes_error(
+        self, mock_import, mock_stderr, mock_stdout, mock_environ
+    ):
+        """Test that _set_windows_console_encoding() handles ctypes import/API errors gracefully"""
+        # Mock stdout/stderr
+        mock_stdout.reconfigure = Mock()
+        mock_stderr.reconfigure = Mock()
+
+        # Mock ctypes.windll.kernel32 to raise OSError (simulating Windows API failure)
+        mock_kernel32 = Mock()
+        mock_kernel32.SetConsoleOutputCP.side_effect = OSError("API call failed")
+        mock_ctypes = Mock()
+        mock_ctypes.windll.kernel32 = mock_kernel32
+
+        def import_side_effect(name, *args, **kwargs):
+            if name == "ctypes":
+                return mock_ctypes
+            return mock_import.__wrapped__(name, *args, **kwargs)
+
+        mock_import.side_effect = import_side_effect
+
+        # Should not raise an error
+        _set_windows_console_encoding()
+
+        # Verify environment variable was still set
+        mock_environ.setdefault.assert_called_once_with("PYTHONIOENCODING", "utf-8")
+
+    @patch("cumulusci.cli.logger.os.name", "nt")
+    @patch("cumulusci.cli.logger.os.environ")
+    @patch("cumulusci.cli.logger._set_windows_console_encoding")
+    @patch("cumulusci.cli.logger.requests")
+    @patch("cumulusci.cli.logger.logging")
+    def test_init_logger_calls_set_windows_console_encoding(
+        self, logging, requests, mock_set_encoding, mock_environ
+    ):
+        """Test that init_logger() calls _set_windows_console_encoding()"""
+        logger = Mock(handlers=[])
+        logging.getLogger.return_value = logger
+
+        init_logger()
+
+        # Verify _set_windows_console_encoding was called
+        mock_set_encoding.assert_called_once()

{cumulusci_plus-5.0.26 → cumulusci_plus-5.0.53}/cumulusci/cli/tests/test_org.py

@@ -116,6 +116,7 @@ class TestOrgCommands:
                 "IsSandbox": False,
                 "InstanceName": "CS420",
                 "NamespacePrefix": None,
+                "Name": "Test Org",
             },
             status=200,
         )
@@ -173,6 +174,7 @@ class TestOrgCommands:
                 "IsSandbox": False,
                 "InstanceName": "CS420",
                 "NamespacePrefix": None,
+                "Name": "Test Org",
             },
             status=200,
         )
@@ -304,6 +306,7 @@ class TestOrgCommands:
                 "IsSandbox": True,
                 "InstanceName": "CS420",
                 "NamespacePrefix": None,
+                "Name": "Test Org",
             },
             status=200,
         )
@@ -439,6 +442,7 @@ class TestOrgCommands:
                 "IsSandbox": True,
                 "InstanceName": "CS420",
                 "NamespacePrefix": None,
+                "Name": "Test Org",
             },
             status=200,
         )
@@ -494,6 +498,7 @@ class TestOrgCommands:
                 "IsSandbox": True,
                 "InstanceName": "CS420",
                 "NamespacePrefix": None,
+                "Name": "Test Org",
             },
             status=200,
         )