canvas 0.33.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

canvas_cli/apps/plugin/tests.py

@@ -1,85 +0,0 @@
-import shutil
-from collections.abc import Generator
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-import pytest
-import typer
-from typer.testing import CliRunner
-
-from canvas_cli.main import app
-
-from .plugin import validate_package
-
-runner = CliRunner()
-
-
-def test_validate_package_unexistant_path() -> None:
-    """Tests the validate_package callback with an invalid folder."""
-    with pytest.raises(typer.BadParameter):
-        validate_package(Path("/a_random_url_that_will_not_exist_or_so_I_hope"))
-
-
-def test_validate_package_wrong_file_type(tmp_path: Path) -> None:
-    """Tests the validate_package callback with an invalid file type."""
-    invalid_file = tmp_path / "tmp_file.zip"
-    invalid_file.write_text("definitely not a python package")
-
-    with pytest.raises(typer.BadParameter):
-        validate_package(invalid_file)
-
-
-def test_validate_package_valid_file(tmp_path: Path) -> None:
-    """Tests the validate_package callback with a valid file type."""
-    package_path = tmp_path / "test-package.whl"
-    package_path.write_text("something")
-    result = validate_package(package_path)
-    assert result == package_path
-
-
-@pytest.fixture(scope="session")
-def init_plugin_name() -> str:
-    """The plugin name to be used for the canvas cli init test."""
-    return f"testing_init-{datetime.now().timestamp()}".replace(".", "")
-
-
-@pytest.fixture(autouse=True, scope="session")
-def clean_up_plugin(init_plugin_name: str) -> Generator[Any, Any, Any]:
-    """Cleans up the plugin directory after the test."""
-    yield
-    if Path(f"./{init_plugin_name}").exists():
-        shutil.rmtree(Path(f"./{init_plugin_name}"))
-
-
-def test_canvas_init(init_plugin_name: str) -> None:
-    """Tests that the CLI successfully creates a plugin with init."""
-    result = runner.invoke(app, "init", input=init_plugin_name)
-    assert result.exit_code == 0
-
-    # plugin directory exists
-    plugin = Path(f"./{init_plugin_name}")
-    assert plugin.exists()
-    assert plugin.is_dir()
-
-    # manifest file exists
-    manifest = Path(f"./{init_plugin_name}/CANVAS_MANIFEST.json")
-    assert manifest.exists()
-    assert manifest.is_file()
-    manifest_result = runner.invoke(app, f"validate-manifest {init_plugin_name}")
-    assert manifest_result.exit_code == 0
-
-    # readme file exists
-    readme = Path(f"./{init_plugin_name}/README.md")
-    assert readme.exists()
-    assert readme.is_file()
-
-    # protocols dir exists
-    protocols = Path(f"./{init_plugin_name}/protocols")
-    assert protocols.exists()
-    assert protocols.is_dir()
-
-    # protocol file exists in protocols dir
-    protocol = Path(f"./{init_plugin_name}/protocols/my_protocol.py")
-    assert protocol.exists()
-    assert protocol.is_file()

canvas_cli/conftest.py

@@ -1,28 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-import canvas_cli.main
-from canvas_cli.utils.context import context
-
-
-@pytest.fixture(autouse=True)
-def monkeypatch_app_dir(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    """Monkeypatch `get_app_dir` in order to return a temp dir when testing, so we don't overwrite our config file."""
-
-    def app_dir() -> str:
-        return str(tmp_path)
-
-    monkeypatch.setattr(canvas_cli.main, "get_app_dir", app_dir)
-
-
-@pytest.fixture(autouse=True)
-def reset_context_variables() -> None:
-    """Reset the context properties to their default value.
-
-    This is needed because we cannot build a `reset` method in the CLIContext class,
-    because `load_from_file` loads properties dynamically.
-    Also since this is a CLI, it's not expected to keep the global context in memory for more than a run,
-    which definitely happens with tests run
-    """
-    context._default_host = None

canvas_cli/tests.py

@@ -1,217 +0,0 @@
-import os
-import shutil
-from collections.abc import Callable, Generator
-from datetime import datetime
-from pathlib import Path
-from typing import Any, cast
-from unittest.mock import MagicMock, patch
-from urllib.parse import urlparse
-
-import pytest
-from django.core.exceptions import ImproperlyConfigured
-from typer.testing import CliRunner
-
-import settings
-from canvas_cli.apps.auth.utils import CONFIG_PATH
-
-from .main import app
-
-runner = CliRunner()
-
-
-@pytest.fixture(scope="session")
-def plugin_name() -> str:
-    """The plugin name to be used for the canvas cli test."""
-    return f"cli-{datetime.now().timestamp()}".replace(".", "")
-
-
-@pytest.fixture(scope="session")
-def create_or_update_config_auth_file_for_testing(plugin_name: str) -> Generator[None, None, None]:
-    """Creates the necessary config file for auth before performing cli tests."""
-    if not settings.INTEGRATION_TEST_URL:
-        raise ImproperlyConfigured("INTEGRATION_TEST_URL is not set")
-
-    host = cast(str, urlparse(settings.INTEGRATION_TEST_URL).hostname).replace(
-        ".canvasmedical.com", ""
-    )
-    client_id = settings.INTEGRATION_TEST_CLIENT_ID
-    client_secret = settings.INTEGRATION_TEST_CLIENT_SECRET
-
-    path = CONFIG_PATH
-    if not path.exists():
-        if not path.parent.exists():
-            path.parent.mkdir()
-        path.touch()
-
-    temp_path = path.parent / "temp_credentials.ini"
-
-    # Read the original content
-    with open(path) as original_file:
-        original_content = original_file.read()
-
-    # Write new content to the original file
-    with open(path, "w") as original_file:
-        original_file.writelines(
-            [
-                f"[{host}]\n",
-                f"client_id={client_id}\n",
-                f"client_secret={client_secret}\n",
-            ]
-        )
-
-    # Append original content to the temp file
-    with open(temp_path, "a") as temp_file:
-        temp_file.write(original_content)
-
-    yield
-
-    with open(temp_path) as temp:
-        original_content = temp.read()
-        with open(path, "w") as f:
-            f.write(original_content)
-    os.remove(temp_path)
-
-
-@pytest.fixture(autouse=True, scope="session")
-def write_plugin(plugin_name: str) -> Generator[Any, Any, Any]:
-    """Writes a plugin to the file system."""
-    runner.invoke(app, "init", input=plugin_name)
-
-    protocol_code = """
-from canvas_sdk.events import EventType
-from canvas_sdk.protocols import BaseProtocol
-from logger import log
-
-class Protocol(BaseProtocol):
-    RESPONDS_TO = EventType.Name(EventType.ASSESS_COMMAND__CONDITION_SELECTED)
-    NARRATIVE_STRING = "I was inserted from my plugin's protocol."
-
-    def compute(self):
-        log.info(self.NARRATIVE_STRING)
-        return []
-"""
-
-    with open(f"./{plugin_name}/protocols/my_protocol.py", "w") as protocol:
-        protocol.write(protocol_code)
-
-    yield
-
-    if Path(f"./{plugin_name}").exists():
-        shutil.rmtree(Path(f"./{plugin_name}"))
-
-
-def list_empty_plugins(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 1 - list all plugins."""
-    return ("list", 0, [], [f"{plugin_name}"])
-
-
-def install_new_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 2 - install a new plugin."""
-    return (
-        f"install {plugin_name}",
-        0,
-        [
-            f"Plugin {plugin_name} has a valid CANVAS_MANIFEST.json file",
-            "Installing plugin:",
-            "Posting",
-            f"Plugin {plugin_name} successfully installed!",
-        ],
-        [],
-    )
-
-
-def list_newly_installed_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 3 - list all plugins, including newly installed one."""
-    return ("list", 0, [f"{plugin_name}@0.0.1	enabled"], [])
-
-
-def disable_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 4 - disable plugin."""
-    return (
-        f"disable {plugin_name}",
-        0,
-        [f"Disabling {plugin_name} using ", f"Plugin {plugin_name} successfully disabled!"],
-        [],
-    )
-
-
-def list_disabled_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 5 - list disabled plugin."""
-    return ("list", 0, [f"{plugin_name}@0.0.1	disabled"], [])
-
-
-def enable_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 6 - enable the disabled plugin."""
-    return (
-        f"enable {plugin_name}",
-        0,
-        [f"Enabling {plugin_name} using ", f"Plugin {plugin_name} successfully enabled!"],
-        [],
-    )
-
-
-def uninstall_enabled_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 7 - try to uninstall the enabled plugin."""
-    return (
-        f"uninstall {plugin_name}",
-        1,
-        [
-            f"Uninstalling {plugin_name} using",
-            'Status code 403: {"detail":"Cannot delete an enabled plugin."}',
-        ],
-        [],
-    )
-
-
-def uninstall_disabled_plugin(plugin_name: str) -> tuple[str, int, list[str], list[str]]:
-    """Step 8 - disable and then uninstall the plugin."""
-    runner.invoke(app, f"disable {plugin_name}")
-
-    return (
-        f"uninstall {plugin_name}",
-        0,
-        [
-            f"Uninstalling {plugin_name} using",
-            f"Plugin {plugin_name} successfully uninstalled!",
-        ],
-        [],
-    )
-
-
-@pytest.mark.integtest
-@patch("keyring.get_password")
-@patch("keyring.set_password")
-@pytest.mark.parametrize(
-    "step",
-    [
-        (list_empty_plugins),
-        (install_new_plugin),
-        (list_newly_installed_plugin),
-        (disable_plugin),
-        (list_disabled_plugin),
-        (enable_plugin),
-        (uninstall_enabled_plugin),
-        (uninstall_disabled_plugin),
-        (list_empty_plugins),
-    ],
-)
-def test_canvas_list_install_disable_enable_uninstall(
-    mock_get_password: MagicMock,
-    mock_set_password: MagicMock,
-    plugin_name: str,
-    create_or_update_config_auth_file_for_testing: None,
-    step: Callable,
-) -> None:
-    """Tests that the Canvas CLI can list, install, disable, enable, and uninstall a plugin."""
-    mock_get_password.return_value = None
-    mock_set_password.return_value = None
-
-    (command, expected_exit_code, expected_outputs, expected_no_outputs) = step(plugin_name)
-
-    result = runner.invoke(app, command)
-
-    assert result.exit_code == expected_exit_code
-    for expected_output in expected_outputs:
-        assert expected_output in result.stdout
-    for expected_no_output in expected_no_outputs:
-        assert expected_no_output not in result.stdout

canvas_cli/utils/context/tests.py

@@ -1,131 +0,0 @@
-import json
-import os
-from collections.abc import Generator
-from pathlib import Path
-
-import pytest
-import typer
-
-from canvas_cli.utils.context import CLIContext
-
-
-class CLIContextTestHelper(CLIContext):
-    """CLIContext subclass that defines some properties we can test."""
-
-    _persistent_mock_property: str | None = None
-    _transient_mock_property: bool = False
-
-    @property
-    def persistent_mock_property(self) -> str | None:
-        """Mock persistent property."""
-        return self._persistent_mock_property
-
-    @persistent_mock_property.setter
-    @CLIContext.persistent
-    def persistent_mock_property(self, new_persistent_mock_property: str | None) -> None:
-        self._persistent_mock_property = new_persistent_mock_property
-
-    @property
-    def transient_mock_property(self) -> bool:
-        """Mock transient property."""
-        return self._transient_mock_property
-
-    @transient_mock_property.setter
-    def transient_mock_property(self, new_transient_mock_property: bool) -> None:
-        self._transient_mock_property = new_transient_mock_property
-
-
-@pytest.fixture
-def config_file(tmp_path: Path) -> Generator[Path, None, None]:
-    """Fixture that yields an empty config file and cleans up after itself."""
-    config_file = tmp_path / "mock_config.json"
-    yield config_file
-    os.remove(config_file)
-
-
-@pytest.fixture
-def valid_mock_config_file(config_file: Path) -> Path:
-    """Fixture that yields a valid mock config file."""
-    mock_config = {
-        "persistent_mock_property": "mock-value",
-    }
-    with open(config_file, "w") as f:
-        json.dump(mock_config, f)
-
-    return config_file
-
-
-@pytest.fixture
-def invalid_json_mock_config_file(config_file: Path) -> Path:
-    """Fixture that yields an invalid config file."""
-    config_file.write_text("Absolutely invalid JSON")
-
-    return config_file
-
-
-@pytest.fixture
-def invalid_properties_mock_config_file(config_file: Path) -> Path:
-    """Fixture that yields a valid mock config file."""
-    mock_config = {
-        "unknown-property": "mock-value",
-    }
-    with open(config_file, "w") as f:
-        json.dump(mock_config, f)
-
-    return config_file
-
-
-def test_valid_load_from_file(valid_mock_config_file: Path) -> None:
-    """Test loading a valid config file."""
-    context = CLIContextTestHelper()
-    context.load_from_file(valid_mock_config_file)
-
-    assert context.persistent_mock_property == "mock-value"
-
-
-def test_invalid_load_from_file(invalid_json_mock_config_file: Path) -> None:
-    """Test loading an invalid config file aborts the execution."""
-    context = CLIContextTestHelper()
-
-    with pytest.raises(typer.Abort):
-        context.load_from_file(invalid_json_mock_config_file)
-
-
-def test_load_invalid_property(invalid_properties_mock_config_file: Path) -> None:
-    """Since we dynamically load the properties, this test ensures that unknown properties don't throw exceptions."""
-    context = CLIContextTestHelper()
-
-    context.load_from_file(invalid_properties_mock_config_file)
-
-
-def test_config_persistence(valid_mock_config_file: Path) -> None:
-    """Test marking a property with @persistent stores the value in the config file."""
-    context = CLIContextTestHelper()
-    context.load_from_file(valid_mock_config_file)
-
-    assert context.persistent_mock_property == "mock-value"
-
-    context.persistent_mock_property = "new-value"
-
-    # This won't ever happen but since the values are in memory, we need to create a new context instance,
-    # as if mimicking a new program launch
-    context_b = CLIContextTestHelper()
-    context_b.load_from_file(valid_mock_config_file)
-
-    assert context_b.persistent_mock_property == "new-value"
-
-
-def test_config_transience(valid_mock_config_file: Path) -> None:
-    """Test the properties transient default."""
-    context = CLIContextTestHelper()
-    context.load_from_file(valid_mock_config_file)
-
-    assert context.transient_mock_property is False
-    context.transient_mock_property = True
-
-    # This won't ever happen but since the values are in memory, we need to create a new context instance,
-    # as if mimicking a new program launch
-    context_b = CLIContextTestHelper()
-    context_b.load_from_file(valid_mock_config_file)
-
-    assert context_b.transient_mock_property is False

canvas_cli/utils/print/tests.py

@@ -1,69 +0,0 @@
-import json
-from typing import Any
-from unittest.mock import Mock
-
-import pytest
-from requests import Response
-
-from canvas_cli.utils.print import print
-
-
-@pytest.mark.parametrize(
-    "message", ["a simple message", ["an array", "of messages"], {"one": "test"}]
-)
-def test_print_json_outputs_valid_json(message: Any, capfd: pytest.CaptureFixture[str]) -> None:
-    """Test the output of print is always valid json."""
-    print.json(message)
-    output, _ = capfd.readouterr()
-    try:
-        json.loads(output)
-    except ValueError as exc:
-        assert AssertionError(f"{output} is not valid json: {exc}")
-
-
-def test_print_json_outputs_kwargs(capfd: pytest.CaptureFixture[str]) -> None:
-    """Test the output of print contains all given kwargs."""
-    print.json("A message", status_code=200, a_string="a_value", an_array=[1, 2], a_dict={"one": 2})
-    output, _ = capfd.readouterr()
-    try:
-        json_dict = json.loads(output)
-
-        assert json_dict.get("a_string") == "a_value"
-        assert json_dict.get("an_array") == [1, 2]
-        assert json_dict.get("a_dict") == {"one": 2}
-
-    except ValueError as exc:
-        assert AssertionError(f"{output} is not valid json: {exc}")
-
-
-def test_print_overrides_default(capfd: pytest.CaptureFixture[str]) -> None:
-    """Test using `print` defaults to Rich."""
-    message = "Testing print"
-    print(message)
-    output, _ = capfd.readouterr()
-    assert message + "\n" == output
-
-
-def test_print_response_non_json_text(capfd: pytest.CaptureFixture[str]) -> None:
-    """Test print.response with a non-json response."""
-    response = Mock(spec=Response)
-    response.status_code = 200
-    response.text = "testing text"
-    response.json.side_effect = json.JSONDecodeError("", "", 0)
-    print.response(response)
-    output, _ = capfd.readouterr()
-    assert json.loads(output) == json.loads(
-        '{"status_code": 200, "success": true, "message": "testing text"}'
-    )
-
-
-def test_print_response_json_text(capfd: pytest.CaptureFixture[str]) -> None:
-    """Test print.response with a json response."""
-    response = Mock(spec=Response)
-    response.status_code = 201
-    response.json.return_value = {"something": True}
-    print.response(response)
-    output, _ = capfd.readouterr()
-    assert json.loads(output) == json.loads(
-        '{"status_code": 201, "success": true, "message": {"something": true} }'
-    )

canvas_cli/utils/urls/tests.py

@@ -1,12 +0,0 @@
-import pytest
-
-from canvas_cli.utils.urls import CoreEndpoint
-
-
-@pytest.mark.parametrize("path", ["a-path", "/a-path", "/a-path/", "a-path/"])
-def test_endpoint_builder(path: str) -> None:
-    """Test that the endpoint is always generated with a trailing `/`."""
-    assert (
-        CoreEndpoint.LOG.build("https://test-host.com", path)
-        == "https://test-host.com/core/api/v1/logging/a-path/"
-    )

canvas_cli/utils/validators/tests.py

@@ -1,37 +0,0 @@
-import pytest
-
-from canvas_cli.utils.validators import validate_manifest_file
-
-
-@pytest.fixture
-def protocol_manifest_example() -> dict:
-    """Return a valid protocol manifest example."""
-    return {
-        "sdk_version": "0.3.1",
-        "plugin_version": "1.0.1",
-        "name": "Prompt to prescribe when assessing condition",
-        "description": "To assist in ....",
-        "components": {
-            "protocols": [
-                {
-                    "class": "prompt_to_prescribe.protocols.prompt_when_assessing.PromptWhenAssessing",
-                    "description": "probably the same as the plugin's description",
-                    "data_access": {
-                        "event": "",
-                        "read": ["conditions"],
-                        "write": ["commands"],
-                    },
-                }
-            ]
-        },
-        "tags": {"patient_sourcing_and_intake": ["symptom_triage"]},
-        "references": [],
-        "license": "",
-        "diagram": False,
-        "readme": "README.MD",
-    }
-
-
-def test_manifest_file_schema(protocol_manifest_example: dict) -> None:
-    """Test that no exception raised when a valid manifest file is validated."""
-    validate_manifest_file(protocol_manifest_example)

canvas_sdk/commands/tests/protocol/tests.py

@@ -1,83 +0,0 @@
-from collections.abc import Generator
-from datetime import datetime
-from typing import cast
-
-import pytest
-
-import settings
-from canvas_sdk.commands.tests.test_utils import (
-    COMMANDS,
-    MaskedValue,
-    clean_up_files_and_plugins,
-    create_new_note,
-    get_original_note_body_commands,
-    get_token,
-    install_plugin,
-    trigger_plugin_event,
-    wait_for_log,
-    write_protocol_code,
-)
-
-
-@pytest.fixture(scope="session")
-def token() -> MaskedValue:
-    """Get a valid token."""
-    return get_token()
-
-
-@pytest.fixture(scope="session")
-def new_note(token: MaskedValue) -> dict:
-    """Create a new note."""
-    return create_new_note(token)
-
-
-@pytest.fixture(scope="session")
-def plugin_name() -> str:
-    """The plugin name to be used."""
-    return f"commands{datetime.now().timestamp()}".replace(".", "")
-
-
-@pytest.fixture(scope="session")
-def write_and_install_protocol_and_clean_up(
-    plugin_name: str, token: MaskedValue, new_note: dict
-) -> Generator[None, None, None]:
-    """Write the protocol code, install the plugin, and clean up after the test."""
-    write_protocol_code(new_note["externallyExposableId"], plugin_name, COMMANDS)
-    message_received_event, thread, ws = wait_for_log(
-        cast(str, settings.INTEGRATION_TEST_URL),
-        token.value,
-        f"Loading plugin '{plugin_name}",
-    )
-    install_plugin(plugin_name, token)
-    message_received_event.wait(timeout=15.0)
-
-    # unfortunately sometimes the log websocket just doesn't return any
-    # messages, so asserting on the state of the timeout here causes failures
-    # even though the delay itself will cause the waiting test to pass (because
-    # the plugin has been loaded).
-    # timeout_not_hit = message_received_event.wait(timeout=15.0)
-    # if not timeout_not_hit:
-    #     ws.close()
-    # assert timeout_not_hit, f"plugin loading message timeout hit: Loading plugin '{plugin_name}"
-
-    yield
-
-    ws.close()
-    thread.join()
-    clean_up_files_and_plugins(plugin_name, token)
-
-
-@pytest.mark.integtest
-def test_protocol_that_inserts_every_command(
-    write_and_install_protocol_and_clean_up: None, token: MaskedValue, new_note: dict
-) -> None:
-    """Test that the protocol inserts every command."""
-    trigger_plugin_event(token)
-
-    commands_in_body = get_original_note_body_commands(new_note["id"], token)
-
-    # TODO: Temporary workaround to ignore the updateGoal command until the integration test instance is fixed.
-    command_keys = [c.Meta.key for c in COMMANDS]
-    assert len(command_keys) == len(commands_in_body)
-    for i, command_key in enumerate(command_keys):
-        assert commands_in_body[i] == command_key