cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/cli/tests/test_task.py

@@ -0,0 +1,266 @@
+import contextlib
+import io
+import json
+from unittest.mock import Mock, patch
+
+import click
+import pytest
+
+from cumulusci.cli.runtime import CliRuntime
+from cumulusci.core.config import BaseProjectConfig
+from cumulusci.core.exceptions import CumulusCIUsageError
+
+from .. import task
+from .utils import DummyTask, run_click_command
+
+color_opts = {"options": {"color": {}}}
+multiple_opts = {"options": {"foo": {}, "bar": {}, "baz": {}}}
+
+test_tasks = {
+    "dummy-task": {
+        "class_path": "cumulusci.cli.tests.utils.DummyTask",
+        "description": "This is a dummy task.",
+    },
+    "dummy-derived-task": {
+        "class_path": "cumulusci.cli.tests.test_run_task.DummyDerivedTask"
+    },
+}
+
+
+@pytest.fixture
+def runtime():
+    runtime = CliRuntime(load_keychain=False)
+    runtime.project_config.config["tasks"] = {**test_tasks}
+
+    runtime.keychain = Mock()
+    runtime.keychain.get_default_org.return_value = (None, None)
+    runtime._load_keychain = Mock()
+
+    yield runtime
+
+
+def test_task_run(runtime):
+    DummyTask._run_task = Mock()
+    multi_cmd = task.RunTaskCommand()
+    with click.Context(multi_cmd, obj=runtime) as ctx:
+        cmd = multi_cmd.get_command(ctx, "dummy-task")
+        cmd.callback(runtime, "dummy-task", color="blue")
+
+    DummyTask._run_task.assert_called_once()
+
+
+def test_task_run__no_project(runtime):
+    runtime.project_config = None
+    runtime.project_config_error = Exception("Broken")
+    multi_cmd = task.RunTaskCommand()
+    with pytest.raises(Exception, match="Broken"):
+        with click.Context(multi_cmd, obj=runtime) as ctx:
+            multi_cmd.get_command(ctx, "dummy-task")
+
+
+def test_task_run__debug_before(runtime):
+    DummyTask._run_task = Mock()
+    multi_cmd = task.RunTaskCommand()
+    set_trace = Mock(side_effect=SetTrace)
+
+    with click.Context(multi_cmd, obj=runtime) as ctx:
+        with patch("pdb.set_trace", set_trace):
+            with pytest.raises(SetTrace):
+                cmd = multi_cmd.get_command(ctx, "dummy-task")
+                cmd.callback(
+                    runtime,
+                    "dummy_task",
+                    color="blue",
+                    debug_before=True,
+                    debug_after=False,
+                )
+
+
+def test_task_run__debug_after(runtime):
+    DummyTask._run_task = Mock()
+    multi_cmd = task.RunTaskCommand()
+    set_trace = Mock(side_effect=SetTrace)
+
+    with click.Context(multi_cmd, obj=runtime) as ctx:
+        with patch("pdb.set_trace", set_trace):
+            with pytest.raises(SetTrace):
+                cmd = multi_cmd.get_command(ctx, "dummy-task")
+                cmd.callback(
+                    runtime,
+                    "dummy-task",
+                    color="blue",
+                    debug_before=False,
+                    debug_after=True,
+                )
+
+
+def test_task_run__help(runtime):
+    DummyTask._run_task = Mock()
+    multi_cmd = task.RunTaskCommand()
+    with click.Context(multi_cmd, obj=runtime) as ctx:
+        cmd = multi_cmd.get_command(ctx, "dummy-task")
+
+    assert "This is a dummy task." in cmd.help  # task description
+
+
+def test_task_run__list_commands(runtime):
+    multi_cmd = task.RunTaskCommand()
+    with click.Context(multi_cmd, obj=runtime) as ctx:
+        commands = multi_cmd.list_commands(ctx)
+    assert commands == ["dummy-derived-task", "dummy-task"]
+
+
+def test_format_help(runtime):
+    runtime.universal_config = Mock()
+    multi_cmd = task.RunTaskCommand()
+    with contextlib.redirect_stdout(io.StringIO()) as stdout:
+        with click.Context(multi_cmd, obj=runtime) as ctx:
+            multi_cmd.format_help(ctx, Mock())
+
+    stdout = stdout.getvalue()
+    assert "Usage: cci task run <task_name> [TASK_OPTIONS...]" in stdout
+    assert "See above for a complete list of available tasks." in stdout
+    assert "Use cci task info <task_name>" in stdout
+    assert len(runtime.universal_config.method_calls) == 0
+
+
+def test_get_default_command_options():
+    opts = task.RunTaskCommand()._get_default_command_options(is_salesforce_task=False)
+    assert len(opts) == 4
+
+    opts = task.RunTaskCommand()._get_default_command_options(is_salesforce_task=True)
+    assert len(opts) == 5
+    assert any([o.name == "org" for o in opts])
+
+
+def test_collect_task_options():
+    new_options = {"debug-before": None}
+    old_options = (("color", "green"),)
+
+    opts = task.RunTaskCommand()._collect_task_options(
+        new_options, old_options, "dummy-task", color_opts["options"]
+    )
+    assert opts == {"color": "green"}
+
+
+def test_collect_task_options__duplicate():
+    new_options = {"color": "aqua"}
+    old_options = (("color", "green"),)
+
+    with pytest.raises(CumulusCIUsageError):
+        task.RunTaskCommand()._collect_task_options(
+            new_options, old_options, "dummy-task", color_opts["options"]
+        )
+
+
+def test_collect_task_options__not_in_task():
+    new_options = {}
+    old_options = (("color", "green"),)
+
+    with pytest.raises(CumulusCIUsageError):
+        task.RunTaskCommand()._collect_task_options(
+            new_options, old_options, "dummy-task", {"not-color": {}}
+        )
+
+
+@patch("cumulusci.cli.task.CliTable")
+def test_task_list(cli_tbl):
+    runtime = Mock()
+    runtime.universal_config.cli__plain_output = None
+    runtime.get_available_tasks.return_value = [
+        {"name": "test_task", "description": "Test Task", "group": "Test Group"}
+    ]
+
+    run_click_command(task.task_list, runtime=runtime, plain=False, print_json=False)
+
+    cli_tbl.assert_called_with(
+        [["Task", "Description"], ["test_task", "Test Task"]], "Test Group"
+    )
+
+
+def test_task_list__json(capsys):
+    expected_output = {
+        "name": "test_task",
+        "description": "This can be a really long description that might need a newline if some library is formatting it for ANSI output.",
+        "group": "Test Group",
+    }
+    runtime = Mock()
+    runtime.universal_config.cli__plain_output = None
+    runtime.get_available_tasks.return_value = [expected_output]
+
+    run_click_command(task.task_list, runtime=runtime, plain=False, print_json=True)
+
+    captured = capsys.readouterr()
+    parsed_output = json.loads(captured.out)[0]
+    assert parsed_output == expected_output
+
+
+@patch("cumulusci.cli.task.doc_task", return_value="docs")
+def test_task_doc(doc_task):
+    runtime = Mock()
+    runtime.universal_config.tasks = {"test": {}}
+    run_click_command(task.task_doc, runtime=runtime, project=False)
+    doc_task.assert_called()
+
+
+def test_task_doc__project__outside_project():
+    runtime = Mock()
+    runtime.project_config = None
+    with pytest.raises(click.UsageError):
+        run_click_command(task.task_doc, runtime=runtime, project=True)
+
+
+@patch("click.echo")
+@patch("cumulusci.cli.task.doc_task", return_value="docs")
+def test_task_doc_project(doc_task, echo):
+    runtime = Mock()
+    runtime.universal_config = {"tasks": {}}
+    runtime.project_config = BaseProjectConfig(
+        runtime.universal_config,
+        {
+            "project": {"name": "Test"},
+            "tasks": {"task1": {"a": "b"}, "task2": {}},
+        },
+    )
+    runtime.project_config.config_project = {"tasks": {"task1": {"a": "b"}}}
+    run_click_command(task.task_doc, runtime=runtime, project=True)
+    doc_task.assert_called()
+    echo.assert_called()
+
+
+@patch("cumulusci.cli.task.Path")
+@patch("click.echo")
+@patch("cumulusci.cli.task.doc_task", return_value="docs")
+def test_task_doc_project_write(doc_task, echo, Path):
+    runtime = Mock()
+    runtime.universal_config.tasks = {"test": {}}
+    runtime.project_config = BaseProjectConfig(
+        runtime.universal_config,
+        {
+            "project": {"name": "Test"},
+            "tasks": {"option": {"a": "b"}},
+        },
+    )
+    runtime.project_config.config_project = {"tasks": {"option": {"a": "b"}}}
+    run_click_command(task.task_doc, runtime=runtime, project=True, write=True)
+    doc_task.assert_called()
+    echo.assert_not_called()
+
+
+@patch("cumulusci.cli.task.rst2ansi")
+@patch("cumulusci.cli.task.doc_task")
+def test_task_info(doc_task, rst2ansi):
+    runtime = Mock()
+    runtime.project_config.tasks__test = {"options": {}}
+    run_click_command(task.task_info, runtime=runtime, task_name="test")
+    doc_task.assert_called_once()
+    rst2ansi.assert_called_once()
+
+
+class SetTrace(Exception):
+    pass
+
+
+class DummyDerivedTask(DummyTask):
+    def _run_task(self):
+        click.echo(f"<{self.__class__}>\n\tcolor: {self.options['color']}")

cumulusci/cli/tests/test_ui.py

@@ -0,0 +1,310 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+from pprint import pformat
+from unittest import mock
+
+import pytest
+from rich.emoji import Emoji
+from rich.table import Column
+
+from cumulusci.cli.ui import (
+    CHECKMARK,
+    CROSSMARK,
+    CliTable,
+    SimpleSalesforceUIHelpers,
+    _summarize,
+)
+
+
+@pytest.fixture
+def sample_data():
+    return {
+        "service_list": [
+            ["Name", "Description", "Configured"],
+            ["saucelabs", "Configure connection for saucelabs tasks.", False],
+            ["sentry", "Configure connection to sentry.io for error tracking", False],
+        ],
+        "org_list": [
+            [
+                "Org",
+                "Default",
+                "Days",
+                "Expired",
+                "Config",
+                Column("Domain", overflow="crop"),
+            ],
+            ["beta", None, 1, None, "beta", ""],
+            ["dev", True, "1/7", False, "dev", "test-h8znvutwnctb@example.com"],
+            ["feature", None, 1, None, "feature", ""],
+        ],
+        "task_list_util": [
+            ["Task", "Description"],
+            ["command", "Run an arbitrary command"],
+            ["log", "Log a line at the info level."],
+            ["util_sleep", "Sleeps for N seconds"],
+        ],
+    }
+
+
+def test_table_dim_rows(sample_data):
+    data = sample_data["service_list"]
+    instance = CliTable(data, dim_rows=[1])
+    assert instance.table.rows[0].style.dim
+
+
+def test_table_stringify_booleans(sample_data):
+    data = sample_data["service_list"]
+    data[1][2] = True
+    CliTable.PICTOGRAM_TRUE = CHECKMARK
+    CliTable.PICTOGRAM_FALSE = CROSSMARK
+    instance = CliTable(data)
+    table = str(instance)
+    if os.name == "posix":
+        assert Emoji.replace(":heavy_check_mark:") in table
+        assert Emoji.replace(":cross_mark:") in table
+    else:
+        assert "+" in table
+        assert "-" in table
+
+
+def test_table_stringify_misc(sample_data):
+    data = sample_data["org_list"]
+    instance = CliTable(data)
+    table = str(instance)
+    assert "7" in table
+    assert "None" not in table
+
+
+def test_columnify_headers():
+    data = [["y", Column("n", overflow="crop"), 43], [1, 2, 3]]
+    table = CliTable(data)
+    str(table)
+    formatted_table = str(table)
+    assert "  y   n   43  " in formatted_table
+
+
+def test_rich_truncation(sample_data):
+    count = 6
+    data = [["column"], ["x" * 16 * count]]
+    table = CliTable(data, title="testerino", width=20)
+    formatted_table = str(table)
+    rxp = re.compile("x{16}")
+    assert len(rxp.findall(formatted_table)) == count
+
+
+PRETEND_DESCRIBE_DATA = {
+    "name": "Blah",
+    "updateable": False,
+    "fields": [
+        {"name": "Foo", "referenceTo": ["Bar"], "picklistValues": []},
+        {
+            "name": "Bar",
+            "referenceTo": [],
+            "picklistValues": [{"value": "a"}, {"value": "b"}],
+        },
+        {"name": "Baz", "type": "string", "referenceTo": [], "picklistValues": []},
+    ],
+}
+
+SUMMARIZED_DATA = {"Foo": ["Bar"], "Bar": ["a", "b"], "Baz": "string"}
+
+
+def test_summarize():
+    fields = PRETEND_DESCRIBE_DATA["fields"]
+    assert _summarize(fields[0]) == ("Foo", ["Bar"])
+    assert _summarize(fields[1]) == ("Bar", ["a", "b"])
+    assert _summarize(fields[2]) == ("Baz", "string")
+
+
+def test_pretty_describe():
+    sf = mock.MagicMock()
+    sf.Blah.describe.return_value = PRETEND_DESCRIBE_DATA
+    rc = SimpleSalesforceUIHelpers(sf).describe("Blah", detailed=False, format="obj")
+    assert sf.Blah.describe.mock_calls
+    assert rc == SUMMARIZED_DATA, rc
+
+
+def test_pretty_describe_detailed():
+    sf = mock.MagicMock()
+    sf.Blah.describe.return_value = PRETEND_DESCRIBE_DATA
+    rc = SimpleSalesforceUIHelpers(sf).describe("Blah", detailed=True, format="obj")
+    assert sf.Blah.describe.mock_calls
+    assert rc == PRETEND_DESCRIBE_DATA, rc
+
+
+def test_pretty_describe_pprint(capsys):
+    sf = mock.MagicMock()
+    sf.Blah.describe.return_value = PRETEND_DESCRIBE_DATA
+    SimpleSalesforceUIHelpers(sf).describe("Blah", detailed=False, format="pprint")
+    out = capsys.readouterr().out
+    assert sf.Blah.describe.mock_calls
+    assert out.strip() == pformat(SUMMARIZED_DATA), (out, pformat(SUMMARIZED_DATA))
+
+
+def test_pretty_describe_format_error():
+    sf = mock.MagicMock()
+    sf.Blah.describe.return_value = PRETEND_DESCRIBE_DATA
+    with pytest.raises(TypeError):
+        SimpleSalesforceUIHelpers(sf).describe("Blah", detailed=False, format="xyzzy")
+
+
+def _pretend_soql_result(*args):
+    return {
+        "totalSize": 1,
+        "done": True,
+        "records": [{"attributes": {"type": "AggregateResult"}, "expr0": 20}],
+    }
+
+
+def _pretend_soql_results(num_records):
+    rc = {"totalSize": 1, "done": True, "records": []}
+    for i in range(0, num_records):
+        rc["records"].append(
+            {"attributes": {"type": "AggregateResult"}, "Id": "00GUSWLMA"}
+        )
+    return rc
+
+
+def test_pretty_soql_query_simple_count():
+    sf = mock.MagicMock()
+    sf.query_all.return_value = _pretend_soql_result()
+    rc = SimpleSalesforceUIHelpers(sf).query(
+        "select Count(Id) from Account",
+        include_deleted=False,
+        format="obj",
+        max_rows=100,
+    )
+    assert sf.query_all.mock_calls == [
+        mock.call("select Count(Id) from Account", include_deleted=False)
+    ], sf.query_all.mock_calls
+    assert rc == [{"expr0": 20}]
+
+    sf = mock.MagicMock()
+    sf.query_all.return_value = _pretend_soql_result()
+
+    rc = SimpleSalesforceUIHelpers(sf).query(
+        "select Count(Id) from Account",
+        include_deleted=True,
+        format="obj",
+        max_rows=100,
+    )
+    assert sf.query_all.mock_calls == [
+        mock.call("select Count(Id) from Account", include_deleted=True)
+    ], sf.query_all.mock_calls
+    assert rc == [{"expr0": 20}]
+
+
+def test_pretty_soql_query_simple_truncation():
+    sf = mock.MagicMock()
+    sf.query_all.return_value = _pretend_soql_results(150)
+    rc = SimpleSalesforceUIHelpers(sf).query(
+        "select Id from Account", include_deleted=False, format="obj", max_rows=100
+    )
+    assert sf.query_all.mock_calls == [
+        mock.call("select Id from Account", include_deleted=False)
+    ], sf.query_all.mock_calls
+    assert len(rc) == 101, len(rc)
+    assert rc[-1] == "... truncated 50 rows"
+
+
+def test_pretty_soql_query_table(capsys):
+    sf = mock.MagicMock()
+    sf.query_all.return_value = _pretend_soql_result()
+
+    SimpleSalesforceUIHelpers(sf).query(
+        "select Count(Id) from Account",
+        include_deleted=False,
+        format="table",
+        max_rows=100,
+    )
+    assert sf.query_all.mock_calls == [
+        mock.call("select Count(Id) from Account", include_deleted=False)
+    ], sf.query_all.mock_calls
+    out = capsys.readouterr().out
+
+    assert "expr0" in out
+    assert "20" in out
+    assert "help" in out
+
+
+def test_pretty_soql_query_table_truncation(capsys):
+    sf = mock.MagicMock()
+    sf.query_all.return_value = _pretend_soql_results(150)
+
+    SimpleSalesforceUIHelpers(sf).query(
+        "select Id from Account",
+        include_deleted=False,
+        format="table",
+        max_rows=100,
+    )
+    assert sf.query_all.mock_calls == [
+        mock.call("select Id from Account", include_deleted=False)
+    ], sf.query_all.mock_calls
+    out = capsys.readouterr().out
+    assert out.count("00GUSWLMA") == 100
+
+
+def test_pretty_table_empty(capsys):
+    sf = mock.MagicMock()
+    sf.query_all.return_value = _pretend_soql_results(0)
+
+    SimpleSalesforceUIHelpers(sf).query(
+        "select Id from Account", include_deleted=False, format="table", max_rows=100
+    )
+    assert sf.query_all.mock_calls == [
+        mock.call("select Id from Account", include_deleted=False)
+    ], sf.query_all.mock_calls
+    out = capsys.readouterr().out
+    assert out.count("00GUSWLMA") == 0
+    assert "No results" in out
+
+
+def test_pretty_soql_query_pprint(capsys):
+    sf = mock.MagicMock()
+    sf.query_all.return_value = _pretend_soql_results(150)
+
+    SimpleSalesforceUIHelpers(sf).query(
+        "select Id from Account", include_deleted=False, format="pprint", max_rows=100
+    )
+    assert sf.query_all.mock_calls == [
+        mock.call("select Id from Account", include_deleted=False)
+    ], sf.query_all.mock_calls
+    out = capsys.readouterr().out
+    assert out.count("00GUSWLMA") == 100
+
+
+def test_pretty_soql_query_json():
+    sf = mock.MagicMock()
+    sf.query_all.return_value = _pretend_soql_results(150)
+
+    rc = SimpleSalesforceUIHelpers(sf).query(
+        "select Id from Account", include_deleted=False, format="json", max_rows=100
+    )
+    assert sf.query_all.mock_calls == [
+        mock.call("select Id from Account", include_deleted=False)
+    ], sf.query_all.mock_calls
+
+    assert rc.count("00GUSWLMA") == 100
+
+
+def test_pretty_soql_query_errors():
+    sf = mock.MagicMock()
+    sf.query_all.return_value = _pretend_soql_results(150)
+
+    with pytest.raises(TypeError):
+        SimpleSalesforceUIHelpers(sf).query(
+            "select Id from Account",
+            include_deleted=False,
+            format="punchcard",
+            max_rows=100,
+        )
+
+
+@mock.patch("cumulusci.cli.ui.SimpleSalesforceUIHelpers.query")
+@mock.patch("cumulusci.cli.ui.SimpleSalesforceUIHelpers.describe")
+def test_repl_helpers(pretty_soql_query, pretty_describe):
+    sf = mock.MagicMock()
+    helpers = SimpleSalesforceUIHelpers(sf)
+    assert helpers.describe("Account", format="obj")
+    assert helpers.query("select Id from Account", format="obj")

cumulusci/cli/tests/test_utils.py

@@ -0,0 +1,122 @@
+import json
+import sys
+import time
+from unittest import mock
+
+import pytest
+import requests
+import responses
+from packaging import version
+
+import cumulusci
+
+from .. import utils
+
+
+def test_get_installed_version():
+    result = utils.get_installed_version()
+    assert cumulusci.__version__ == str(result)
+
+
+@responses.activate
+def test_get_latest_final_version():
+    responses.add(
+        method="GET",
+        url="https://pypi.org/pypi/cumulusci/json",
+        body=json.dumps(
+            {
+                "releases": {
+                    "1.0b1": {},
+                    "1.0": {},
+                    "1.0.1.dev0": {},
+                    "1.0.1": {},
+                    "1.0.post1": {},
+                }
+            }
+        ),
+        status=200,
+    )
+    result = utils.get_latest_final_version()
+    assert result.base_version == "1.0.1"
+
+
+@mock.patch("cumulusci.cli.utils.get_installed_version")
+@mock.patch("cumulusci.cli.utils.get_latest_final_version")
+@mock.patch("cumulusci.cli.utils.click")
+def test_check_latest_version(click, get_latest_final_version, get_installed_version):
+    with utils.timestamp_file() as f:
+        f.write(str(time.time() - 4000))
+    get_latest_final_version.return_value = version.parse("2")
+    get_installed_version.return_value = version.parse("1")
+
+    utils.check_latest_version()
+    if sys.version_info > utils.LOWEST_SUPPORTED_VERSION:
+        click.echo.assert_called_once()
+    else:
+        click.echo.assert_called()
+
+
+@mock.patch("cumulusci.cli.utils.get_latest_final_version")
+@mock.patch("cumulusci.cli.utils.click")
+def test_check_latest_version_request_error(click, get_latest_final_version):
+    with utils.timestamp_file() as f:
+        f.write(str(time.time() - 4000))
+    get_latest_final_version.side_effect = requests.exceptions.RequestException()
+
+    utils.check_latest_version()
+
+    click.echo.assert_any_call("Error checking cci version:", err=True)
+
+
+@pytest.mark.skipif(
+    not sys.platform.startswith("win"), reason="Requires Windows Registry"
+)
+@mock.patch("winreg.QueryValueEx")
+def test_win32_warning(query_value):
+    query_value.return_value = (1, 1)
+
+    is_enabled = utils.win32_long_paths_enabled()
+
+    query_value.assert_called_once()
+    assert "LongPathsEnabled" in query_value.call_args.args
+    assert is_enabled
+
+
+@pytest.mark.skipif(
+    sys.platform.startswith("win"), reason="Should not print on non-win32"
+)
+@mock.patch("cumulusci.cli.utils.win32_long_paths_enabled")
+@mock.patch("rich.console.Console.print")
+def test_no_longpath_warn_on_posix(console_print, is_enabled):
+    utils.warn_if_no_long_paths()
+
+    is_enabled.assert_not_called()
+    console_print.assert_not_called()
+
+
+@pytest.mark.skipif(
+    not sys.platform.startswith("win"), reason="Requires Windows Registry"
+)
+@mock.patch("cumulusci.cli.utils.win32_long_paths_enabled")
+@mock.patch("rich.console.Console.print")
+def test_no_longpath_warn_on_win(console_print, is_enabled):
+    is_enabled.return_value = True
+
+    utils.warn_if_no_long_paths()
+
+    is_enabled.assert_called_once()
+    console_print.assert_not_called()
+
+
+@pytest.mark.skipif(
+    not sys.platform.startswith("win"), reason="Requires Windows Registry"
+)
+@mock.patch("cumulusci.cli.utils.win32_long_paths_enabled")
+@mock.patch("rich.console.Console.print")
+def test_longpath_warn_on_win(console_print, is_enabled):
+    is_enabled.return_value = False
+
+    utils.warn_if_no_long_paths()
+
+    is_enabled.assert_called_once()
+    console_print.assert_called_once_with(utils.WIN_LONG_PATH_WARNING)