cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/cli/tests/test_plan.py

@@ -0,0 +1,245 @@
+import json
+from unittest import mock
+
+import click
+import pytest
+
+from cumulusci.cli.runtime import CliRuntime
+
+from .. import plan
+from .utils import run_click_command
+
+pytestmark = pytest.mark.metadeploy
+
+
+@pytest.fixture
+def runtime():
+    runtime = CliRuntime()
+    runtime.project_config.config["plans"] = {
+        "plan 1": {
+            "title": "Test Plan #1",
+            "slug": "plan1_slug",
+            "tier": "primary",
+            "preflight_message": "This is a preflight message",
+            "error_message": "This is an error message",
+            "steps": {
+                1: {
+                    "task": "run_tests",
+                    "ui_options": {
+                        "name": "Run Tests",
+                        "is_recommended": False,
+                        "is_required": False,
+                    },
+                    "checks": [
+                        {
+                            "when": "soon",
+                            "action": "error",
+                            "message": "Danger Will Robinson!",
+                        }
+                    ],
+                }
+            },
+            "checks": [
+                {
+                    "when": "'test package' not in tasks.get_installed_packages()",
+                    "action": "error",
+                    "message": "Test Package must be installed in your org.",
+                }
+            ],
+        },
+        "plan 2": {
+            "title": "Test Plan #2",
+            "slug": "plan2_slug",
+            "tier": "secondary",
+        },
+        "plan 3": {
+            "title": "Test Plan #3",
+            "slug": "plan3_slug",
+            "tier": "additional",
+            "group": "optional",
+        },
+    }
+
+    yield runtime
+
+
+class TestPlanList:
+    @mock.patch("cumulusci.cli.plan.CliTable")
+    def test_plan_list(self, cli_table, runtime):
+        """Happy-path smoke test"""
+
+        run_click_command(plan.plan_list, runtime=runtime, print_json=False)
+
+        cli_table.assert_called_once_with(
+            data=[
+                ["Name", "Title", "Slug", "Tier"],
+                ["plan 1", "Test Plan #1", "plan1_slug", "primary"],
+                ["plan 2", "Test Plan #2", "plan2_slug", "secondary"],
+                ["plan 3", "Test Plan #3", "plan3_slug", "additional"],
+            ]
+        )
+
+    @mock.patch("cumulusci.cli.plan.CliTable")
+    def test_plan_list__no_plans(self, cli_table, runtime):
+        """Make sure we gracefully handle projects with no plans"""
+        runtime.project_config.config["plans"] = []
+
+        run_click_command(plan.plan_list, runtime=runtime, print_json=False)
+
+        assert cli_table.call_count == 1
+        cli_table.assert_called_once_with(data=[["Name", "Title", "Slug", "Tier"]])
+
+    def test_plan_list__json(self, runtime):
+        """Verify we get valid json output with --json"""
+        stdout = []
+        with mock.patch("click.echo", stdout.append):
+            run_click_command(plan.plan_list, runtime=runtime, print_json=True)
+            assert len(stdout) == 1
+            data = json.loads(stdout[0])
+            assert data == [
+                {
+                    "name": "plan 1",
+                    "title": "Test Plan #1",
+                    "slug": "plan1_slug",
+                    "tier": "primary",
+                },
+                {
+                    "name": "plan 2",
+                    "title": "Test Plan #2",
+                    "slug": "plan2_slug",
+                    "tier": "secondary",
+                },
+                {
+                    "name": "plan 3",
+                    "title": "Test Plan #3",
+                    "slug": "plan3_slug",
+                    "tier": "additional",
+                },
+            ]
+
+    @mock.patch("cumulusci.cli.plan.CliTable")
+    def test_plan_list__sorting(self, cli_table):
+        runtime = CliRuntime()
+        # define some plans in reverse order from how they
+        # should appear...
+        runtime.project_config.config["plans"] = {
+            "Plan 4": dict(tier="additional"),
+            "Plan 3": dict(tier="additional"),
+            "Plan 2": dict(tier="secondary"),
+            "Plan 1": dict(tier="primary"),
+        }
+
+        run_click_command(plan.plan_list, runtime=runtime, print_json=False)
+        cli_table.assert_called_once_with(
+            data=[
+                ["Name", "Title", "Slug", "Tier"],
+                ["Plan 1", "", "", "primary"],
+                ["Plan 2", "", "", "secondary"],
+                ["Plan 3", "", "", "additional"],
+                ["Plan 4", "", "", "additional"],
+            ],
+        )
+
+
+class TestPlanInfo:
+    @mock.patch("cumulusci.cli.plan.CliTable")
+    def test_plan_info__config(self, cli_table, runtime):
+        """Verify we are creating a CliTable for the config"""
+        run_click_command(
+            plan.plan_info, "plan 1", runtime=runtime, messages_only=False
+        )
+        cli_table.assert_any_call(
+            title="Config",
+            data=[
+                ["Key", "Value"],
+                ["YAML Key", "plan 1"],
+                ["Slug", "plan1_slug"],
+                ["Tier", "primary"],
+                ["Hidden?", False],
+            ],
+        ),
+
+    @mock.patch("cumulusci.cli.plan.CliTable")
+    def test_plan_info__messages(self, cli_table, runtime):
+        """Verify we are creating a CliTable for messages"""
+        run_click_command(
+            plan.plan_info, "plan 1", runtime=runtime, messages_only=False
+        )
+        cli_table.assert_any_call(
+            title="Messages",
+            data=[
+                ["Type", "Message"],
+                ["Title", "Test Plan #1"],
+                ["Preflight", "This is a preflight message"],
+                ["Post-install", ""],
+                ["Error", "This is an error message"],
+            ],
+        )
+
+    @mock.patch("cumulusci.cli.plan.CliTable")
+    def test_plan_info__preflight_checks(self, cli_table, runtime):
+        """Verify we are creating a CliTable for the preflight checks"""
+        run_click_command(
+            plan.plan_info, "plan 1", runtime=runtime, messages_only=False
+        )
+        cli_table.assert_any_call(
+            title="Plan Preflights",
+            data=[
+                ["Action", "Message", "When"],
+                [
+                    "error",
+                    "Test Package must be installed in your org.",
+                    "'test package' not in tasks.get_installed_packages()",
+                ],
+            ],
+        ),
+
+    @mock.patch("cumulusci.cli.plan.CliTable")
+    def test_plan_info__step_preflight_checks(self, cli_table, runtime):
+        """Verify we are creating a CliTable for the step preflight checks"""
+        run_click_command(
+            plan.plan_info, "plan 1", runtime=runtime, messages_only=False
+        )
+        cli_table.assert_any_call(
+            title="Step Preflights",
+            data=[
+                ["Step", "Action", "Message", "When"],
+                [1, "error", "Danger Will Robinson!", "soon"],
+            ],
+        ),
+
+    @mock.patch("cumulusci.cli.plan.CliTable")
+    def test_plan_info__steps(self, cli_table, runtime):
+        """Verify we are creating a CliTable for the preflight checks"""
+        run_click_command(
+            plan.plan_info, "plan 1", runtime=runtime, messages_only=False
+        )
+        cli_table.assert_any_call(
+            title="Steps",
+            data=[
+                ["Step", "Name", "Required", "Recommended"],
+                [1, "Run Tests", False, False],
+            ],
+        )
+
+    @mock.patch("cumulusci.cli.plan.CliTable")
+    def test_plan_info__messages_only(self, cli_table, runtime):
+        """Verify that --messages results in only messages being output"""
+        run_click_command(plan.plan_info, "plan 1", runtime=runtime, messages_only=True)
+        cli_table.assert_called_once_with(
+            title="Messages",
+            data=[
+                ["Type", "Message"],
+                ["Title", "Test Plan #1"],
+                ["Preflight", "This is a preflight message"],
+                ["Post-install", ""],
+                ["Error", "This is an error message"],
+            ],
+        )
+
+    def test_plan_info__bogus_plan(self, runtime):
+        """Verify a missing play causes a useful message"""
+        with pytest.raises(click.UsageError, match=r"Unknown plan 'invalid_plan'."):
+            run_click_command(
+                plan.plan_info, "invalid_plan", runtime=runtime, messages_only=False
+            )

cumulusci/cli/tests/test_project.py

@@ -0,0 +1,235 @@
+import os
+from pathlib import Path
+from unittest import mock
+
+import click
+import pytest
+
+from cumulusci.cli.tests.utils import recursive_list_files, run_click_command
+from cumulusci.core.dependencies.dependencies import PackageNamespaceVersionDependency
+from cumulusci.core.exceptions import NotInProject
+from cumulusci.utils import temporary_dir
+
+from .. import project
+from ..runtime import CliRuntime
+
+
+class TestProjectCommands:
+    def test_validate_project_name(self):
+        with pytest.raises(click.UsageError):
+            project.validate_project_name("with spaces")
+
+    def test_validate_project_name__valid(self):
+        assert project.validate_project_name("valid") == "valid"
+
+    @mock.patch("cumulusci.cli.project.click")
+    def test_project_init(self, click):
+        with temporary_dir():
+            os.mkdir(".git")
+            Path(".git", "HEAD").write_text("ref: refs/heads/main")
+
+            click.prompt.side_effect = (
+                "testproj",  # project_name
+                "testpkg",  # package_name
+                "testns",  # package_namespace
+                "43.0",  # api_version
+                "mdapi",  # source_format
+                "3",  # extend other URL
+                "https://github.com/SalesforceFoundation/NPSP",  # github_url
+                "main",  # git_default_branch
+                "work/",  # git_prefix_feature
+                "uat/",  # git_prefix_beta
+                "rel/",  # git_prefix_release
+                "%_TEST%",  # test_name_match
+                "90",  # code_coverage
+            )
+            click.confirm.side_effect = (
+                True,
+                True,
+                True,
+            )  # is managed? extending? enforce Apex coverage?
+
+            runtime = CliRuntime(
+                config={"project": {"test": {"name_match": "%_TEST%"}}},
+                load_keychain=False,
+            )
+            run_click_command(project.project_init, runtime=runtime)
+
+            # Make sure expected files/dirs were created
+            assert [
+                ".git/",
+                ".git/HEAD",
+                ".github/",
+                ".github/PULL_REQUEST_TEMPLATE.md",
+                ".gitignore",
+                "README.md",
+                "cumulusci.yml",
+                "datasets/",
+                "datasets/mapping.yml",
+                "orgs/",
+                "orgs/beta.json",
+                "orgs/dev.json",
+                "orgs/feature.json",
+                "orgs/release.json",
+                "robot/",
+                "robot/testproj/",
+                "robot/testproj/doc/",
+                "robot/testproj/resources/",
+                "robot/testproj/tests/",
+                "robot/testproj/tests/create_contact.robot",
+                "sfdx-project.json",
+                "src/",
+            ] == recursive_list_files()
+
+    @mock.patch("cumulusci.cli.project.click")
+    def test_project_init_tasks(self, click):
+        """Verify that the generated cumulusci.yml file is readable and has the proper robot task"""
+        with temporary_dir():
+            os.mkdir(".git")
+            Path(".git", "HEAD").write_text("ref: refs/heads/main")
+
+            click.prompt.side_effect = (
+                "testproj",  # project_name
+                "testpkg",  # package_name
+                "testns",  # package_namespace
+                "43.0",  # api_version
+                "mdapi",  # source_format
+                "3",  # extend other URL
+                "https://github.com/SalesforceFoundation/NPSP",  # github_url
+                "main",  # git_default_branch
+                "work/",  # git_prefix_feature
+                "uat/",  # git_prefix_beta
+                "rel/",  # git_prefix_release
+                "%_TEST%",  # test_name_match
+                "90",  # code_coverage
+            )
+            click.confirm.side_effect = (
+                True,
+                True,
+                True,
+            )  # is managed? extending? enforce code coverage?
+
+            run_click_command(project.project_init)
+
+            # verify we can load the generated yml
+            cli_runtime = CliRuntime(load_keychain=False)
+
+            # ...and verify it has the expected tasks
+            config = cli_runtime.project_config.config_project
+            expected_tasks = {
+                "robot": {
+                    "options": {
+                        "suites": "robot/testproj/tests",
+                        "options": {"outputdir": "robot/testproj/results"},
+                    }
+                },
+                "robot_testdoc": {
+                    "options": {
+                        "path": "robot/testproj/tests",
+                        "output": "robot/testproj/doc/testproj_tests.html",
+                    }
+                },
+                "run_tests": {"options": {"required_org_code_coverage_percent": 90}},
+            }
+            assert config["tasks"] == expected_tasks
+
+    def test_project_init_no_git(self):
+        with temporary_dir():
+            with pytest.raises(click.ClickException):
+                run_click_command(project.project_init)
+
+    def test_project_init_already_initted(self):
+        with temporary_dir():
+            os.mkdir(".git")
+            Path(".git", "HEAD").write_text("ref: refs/heads/main")
+            with open("cumulusci.yml", "w"):
+                pass  # create empty file
+
+            with pytest.raises(click.ClickException):
+                run_click_command(project.project_init)
+
+    def test_project_init_dont_overwrite(self):
+        with temporary_dir():
+            # Gotta have a Repo
+            os.mkdir(".git")
+            Path(".git", "HEAD").write_text("ref: refs/heads/main")
+
+            os.mkdir("orgs")
+            orgs = "orgs/"
+            text = "Can't touch this"
+
+            path_list = [
+                Path("README.md"),
+                Path(".gitignore"),
+                Path(orgs + "dev.json"),
+                Path(orgs + "release.json"),
+            ]
+            for path in path_list:
+                path.write_text(text)
+
+            runtime = mock.Mock()
+            runtime.project_config.project = {"test": "test"}
+
+            run_click_command(project.project_info, runtime=runtime)
+
+            # Project init must not overwrite project files or org defs
+            for path in path_list:
+                assert text == path.read_text()
+
+    @mock.patch("click.echo")
+    def test_project_info(self, echo):
+        runtime = mock.Mock()
+        runtime.project_config.project = {"test": "test"}
+
+        run_click_command(project.project_info, runtime=runtime)
+
+        echo.assert_called_once_with("\x1b[1mtest:\x1b[0m test")
+
+    def test_project_info__outside_project(self):
+        runtime = mock.Mock()
+        runtime.project_config = None
+        runtime.project_config_error = NotInProject()
+        with temporary_dir():
+            with pytest.raises(NotInProject):
+                run_click_command(project.project_info, runtime=runtime)
+
+    @mock.patch("cumulusci.cli.project.get_static_dependencies")
+    def test_project_dependencies(self, get_static_dependencies):
+        out = []
+        runtime = mock.Mock()
+        runtime.project_config.project__dependencies = [
+            {"namespace": "npe01", "version": "3.16"},
+            {"namespace": "npsp", "version": "3.193"},
+        ]
+        get_static_dependencies.return_value = [
+            PackageNamespaceVersionDependency(namespace="npe01", version="3.16"),
+            PackageNamespaceVersionDependency(namespace="npsp", version="3.193"),
+        ]
+
+        with mock.patch("click.echo", out.append):
+            run_click_command(
+                project.project_dependencies,
+                runtime=runtime,
+                resolution_strategy="production",
+            )
+
+        assert out == [
+            str(PackageNamespaceVersionDependency(namespace="npe01", version="3.16")),
+            str(PackageNamespaceVersionDependency(namespace="npsp", version="3.193")),
+        ]
+
+    def test_render_recursive(self):
+        out = []
+        with mock.patch("click.echo", out.append):
+            project.render_recursive(
+                {"test": [{"list": ["list"], "dict": {"key": "value"}, "str": "str"}]}
+            )
+        assert """\x1b[1mtest:\x1b[0m
+    -
+        \x1b[1mlist:\x1b[0m
+            - list
+        \x1b[1mdict:\x1b[0m
+            \x1b[1mkey:\x1b[0m value
+        \x1b[1mstr:\x1b[0m str""" == "\n".join(
+            out
+        )

cumulusci/cli/tests/test_robot.py

@@ -0,0 +1,177 @@
+import sys
+from unittest import mock
+
+import click.exceptions
+import pytest
+
+from cumulusci.cli.robot import _is_package_installed
+
+from .utils import run_cli_command
+
+
+class MockDistribution:
+    """Mocks an importlib.metadata.Distribution object"""
+
+    def __init__(self, name):
+        self.name = name
+
+
+def mock_Command(returncodes={}):
+    """Create a mock for sarge.Command
+
+    returncodes is a dictionary of commands as keys
+    and returncodes as values, so we can control which
+    command line tools act like they pass or fail.
+
+    By default, every command will return zero unless
+    explicitly told to exit with something else.
+    """
+
+    def the_real_mock(cmd, **kwargs):
+        the_mock = mock.Mock()
+        the_mock.args = cmd
+
+        def run():
+            returncode = returncodes.get(str(cmd), 0)
+            the_mock.returncode = returncode
+
+        the_mock.run.side_effect = run
+        return the_mock
+
+    return the_real_mock
+
+
+@mock.patch("cumulusci.cli.robot.importlib.metadata.distribution")
+def test_is_package_installed(mock_distribution):
+    """Verify that the helper _is_package_installed returns the correct result"""
+    # Test when package is installed
+    mock_distribution.return_value = MockDistribution("robotframework-browser")
+    result = _is_package_installed("robotframework-browser")
+    assert result is True
+
+    # Test when package is not installed
+    from importlib.metadata import PackageNotFoundError
+
+    mock_distribution.side_effect = PackageNotFoundError("Package not found")
+    result = _is_package_installed("robotframework-browser")
+    assert result is False
+
+
+@mock.patch("cumulusci.cli.robot.sarge")
+def test_happy_path(sarge):
+    """Verify the happy path is indeed happy"""
+    sarge.Command.side_effect = mock_Command()
+    with mock.patch("cumulusci.cli.robot._is_package_installed", return_value=False):
+        run_cli_command("robot", "install_playwright")
+        actual_calls = [call.args[0] for call in sarge.Command.mock_calls]
+        expected_calls = [
+            "npm --version",
+            [
+                sys.executable,
+                "-m",
+                "pip",
+                "install",
+                "robotframework-browser",
+            ],
+            [sys.executable, "-m", "Browser.entry", "init"],
+        ]
+        msg = f"\n-- expected --\n{expected_calls}\n\n-- actual --\n{actual_calls}"
+
+        assert actual_calls == expected_calls, msg
+
+
+@mock.patch("sys.exit")
+def test_bogus_subcommand(sys_exit):
+    """Verify a bogus subcommand returns a UsageError"""
+    with pytest.raises(click.exceptions.UsageError, match="No such command 'bogus'"):
+        run_cli_command("robot", "bogus")
+
+
+@mock.patch("cumulusci.cli.robot.sarge")
+def test_no_npm(sarge):
+    """Verify the error message we emit when npm --version throws an error"""
+
+    sarge.Command.side_effect = mock_Command(returncodes={"npm --version": 1})
+    with pytest.raises(
+        click.exceptions.ClickException, match="Unable to find a usable npm.*"
+    ):
+        run_cli_command("robot", "install_playwright", "--dry_run")
+    sarge.Command.assert_called_once()
+    assert sarge.Command.mock_calls[0].args[0] == "npm --version"
+
+
+@mock.patch("cumulusci.cli.robot.sarge")
+def test_playwright_dry_run(sarge):
+    """Verify the output of a dry run"""
+    sarge.Command.side_effect = mock_Command(returncodes={"npm --version": 0})
+    with mock.patch("cumulusci.cli.robot._is_package_installed", return_value=False):
+        result = run_cli_command("robot", "install_playwright", "--dry_run")
+        expected_output = "\n".join(
+            [
+                "installing robotframework-browser ...",
+                f"would run {sys.executable} -m pip install robotframework-browser",
+                f"would run {sys.executable} -m Browser.entry init\n",
+            ]
+        )
+        msg = f"\n-- expected --\n{expected_output}\n\n-- actual --\n{result.output}"
+        assert result.output == expected_output, msg
+
+
+@mock.patch("cumulusci.cli.robot.sarge")
+def test_playwright_failure_to_initialize_browser_library(sarge):
+    """Verify we raise an exception if we can't initialize the browser library"""
+    cmd = str([sys.executable, "-m", "Browser.entry", "init"])
+    sarge.Command.side_effect = mock_Command(returncodes={cmd: 1})
+    with mock.patch("cumulusci.cli.robot._is_package_installed", return_value=False):
+        with pytest.raises(
+            click.exceptions.ClickException,
+            match="unable to initialize browser library",
+        ):
+            run_cli_command("robot", "install_playwright")
+
+
+@mock.patch("cumulusci.cli.robot.sarge")
+def test_playwright_failure_to_install_browser_library(sarge):
+    """Verify we raise an exception if we can't install playwright"""
+    cmd = str([sys.executable, "-m", "pip", "install", "robotframework-browser"])
+    sarge.Command.side_effect = mock_Command(returncodes={cmd: 1})
+    with mock.patch("cumulusci.cli.robot._is_package_installed", return_value=False):
+        with pytest.raises(
+            click.exceptions.ClickException,
+            match="robotframework-browser was not installed",
+        ):
+            run_cli_command("robot", "install_playwright")
+
+
+@mock.patch("cumulusci.cli.robot.sarge")
+def test_playwright_already_installed(sarge):
+    """Verify we exit early if the package is already installed"""
+    sarge.Command.side_effect = mock_Command()
+    with mock.patch("cumulusci.cli.robot._is_package_installed", return_value=True):
+        result = run_cli_command("robot", "install_playwright", "--dry_run")
+        assert (
+            result.output == "Playwright support seems to already have been installed\n"
+        )
+
+
+@mock.patch("cumulusci.cli.robot.sarge")
+def test_uninstall_playwright(sarge):
+    """Verify calling 'robot uninstall_playwright' calls the right utilities"""
+    sarge.Command.side_effect = mock_Command()
+    with mock.patch("cumulusci.cli.robot._is_package_installed", return_value=False):
+        run_cli_command("robot", "uninstall_playwright")
+        sarge.Command.assert_has_calls(
+            [
+                mock.call([sys.executable, "-m", "Browser.entry", "clean-node"]),
+                mock.call(
+                    [
+                        sys.executable,
+                        "-m",
+                        "pip",
+                        "uninstall",
+                        "robotframework-browser",
+                        "--yes",
+                    ],
+                ),
+            ]
+        )