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

plugin_runner/tests/test_plugin_installer.py

@@ -1,127 +0,0 @@
-import json
-import tarfile
-import tempfile
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-from pytest_mock import MockerFixture
-
-from plugin_runner.installation import (
-    PluginAttributes,
-    _extract_rows_to_dict,
-    download_plugin,
-    install_plugins,
-    uninstall_plugin,
-)
-
-
-def _create_tarball(name: str) -> Path:
-    # Create a temporary tarball file
-    temp_dir = tempfile.mkdtemp()
-    tarball_path = Path(temp_dir) / f"{name}.tar.gz"
-
-    # Add some files to the tarball
-    with tarfile.open(tarball_path, "w:gz") as tar:
-        for i in range(3):
-            file_path = Path(temp_dir) / f"file{i}.txt"
-            file_path.write_text(f"Content of file {i}")
-            tar.add(file_path, arcname=f"file{i}.txt")
-
-    # Return a Path handle to the tarball
-    return tarball_path
-
-
-def test_extract_rows_to_dict() -> None:
-    """Test that database rows can be extracted to a dictionary with secrets appropriately attributed to plugin."""
-    rows = [
-        {
-            "name": "plugin1",
-            "version": "1.0",
-            "package": "package1",
-            "key": "key1",
-            "value": "value1",
-        },
-        {
-            "name": "plugin1",
-            "version": "1.0",
-            "package": "package1",
-            "key": "key2",
-            "value": "value2",
-        },
-        {"name": "plugin2", "version": "2.0", "package": "package2", "key": None, "value": None},
-    ]
-
-    expected_output = {
-        "plugin1": {
-            "version": "1.0",
-            "package": "package1",
-            "secrets": {"key1": "value1", "key2": "value2"},
-        },
-        "plugin2": {
-            "version": "2.0",
-            "package": "package2",
-            "secrets": {},
-        },
-    }
-
-    result = _extract_rows_to_dict(rows)
-    assert result == expected_output
-
-
-def test_plugin_installation_from_tarball(mocker: MockerFixture) -> None:
-    """Test that plugins can be installed from tarballs."""
-    mock_plugins = {
-        "plugin1": PluginAttributes(
-            version="1.0", package="plugins/plugin1.tar.gz", secrets={"key1": "value1"}
-        ),
-        "plugin2": PluginAttributes(
-            version="1.0", package="plugins/plugin2.tar", secrets={"key2": "value2"}
-        ),
-    }
-
-    tarball_1 = _create_tarball("plugin1")
-    tarball_2 = _create_tarball("plugin2")
-
-    mocker.patch("plugin_runner.installation.enabled_plugins", return_value=mock_plugins)
-
-    def mock_download_plugin(package: str) -> MagicMock:
-        mock_context = mocker.Mock()
-        if package == "plugins/plugin1.tar.gz":
-            mock_context.__enter__ = mocker.Mock(return_value=tarball_1)
-        elif package == "plugins/plugin2.tar":
-            mock_context.__enter__ = mocker.Mock(return_value=tarball_2)
-        mock_context.__exit__ = mocker.Mock(return_value=None)
-        return mock_context
-
-    mocker.patch(
-        "plugin_runner.installation.download_plugin",
-        side_effect=mock_download_plugin,
-    )
-
-    install_plugins()
-    assert Path("plugin_runner/tests/data/plugins/plugin1").exists()
-    assert Path("plugin_runner/tests/data/plugins/plugin1/SECRETS.json").exists()
-    with open("plugin_runner/tests/data/plugins/plugin1/SECRETS.json") as f:
-        assert json.load(f) == mock_plugins["plugin1"]["secrets"]
-    assert Path("plugin_runner/tests/data/plugins/plugin2").exists()
-    assert Path("plugin_runner/tests/data/plugins/plugin2/SECRETS.json").exists()
-    with open("plugin_runner/tests/data/plugins/plugin2/SECRETS.json") as f:
-        assert json.load(f) == mock_plugins["plugin2"]["secrets"]
-
-    uninstall_plugin("plugin1")
-    uninstall_plugin("plugin2")
-    assert not Path("plugin_runner/tests/data/plugins/plugin1").exists()
-    assert not Path("plugin_runner/tests/data/plugins/plugin2").exists()
-
-
-def test_download(mocker: MockerFixture) -> None:
-    """Test that the plugin package can be written to disk, mocking out S3."""
-    mock_response = MagicMock()
-    mock_response.status_code = 200
-    mock_response.content = b"some content in a file"
-    with patch("requests.request", return_value=mock_response) as mock_request:
-        plugin_package = "plugins/plugin1.tar.gz"
-        with download_plugin(plugin_package) as plugin_path:
-            assert plugin_path.exists()
-            assert plugin_path.read_bytes() == b"some content in a file"
-        mock_request.assert_called_once()

plugin_runner/tests/test_plugin_runner.py

@@ -1,388 +0,0 @@
-import asyncio
-import json
-import logging
-import pickle
-import shutil
-from base64 import b64encode
-from http import HTTPStatus
-from pathlib import Path
-from typing import Any
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from canvas_generated.messages.effects_pb2 import EffectType
-from canvas_generated.messages.plugins_pb2 import ReloadPluginsRequest
-from canvas_sdk.effects.simple_api import Response
-from canvas_sdk.events import Event, EventRequest, EventType
-from plugin_runner.plugin_runner import (
-    EVENT_HANDLER_MAP,
-    LOADED_PLUGINS,
-    PluginRunner,
-    load_or_reload_plugin,
-    load_plugins,
-    synchronize_plugins,
-)
-
-
-@pytest.fixture
-def plugin_runner() -> PluginRunner:
-    """Fixture to initialize PluginRunner with mocks."""
-    runner = PluginRunner()
-    runner.statsd_client = MagicMock()  # type: ignore[attr-defined]
-    return runner
-
-
-@pytest.mark.parametrize("install_test_plugin", ["example_plugin"], indirect=True)
-def test_load_plugins_with_valid_plugin(install_test_plugin: Path, load_test_plugins: None) -> None:
-    """Test loading plugins with a valid plugin."""
-    assert "example_plugin:example_plugin.protocols.my_protocol:Protocol" in LOADED_PLUGINS
-    assert (
-        LOADED_PLUGINS["example_plugin:example_plugin.protocols.my_protocol:Protocol"]["active"]
-        is True
-    )
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("install_test_plugin", ["test_module_imports_plugin"], indirect=True)
-async def test_load_plugins_with_plugin_that_imports_other_modules_within_plugin_package(
-    install_test_plugin: Path, plugin_runner: PluginRunner, load_test_plugins: None
-) -> None:
-    """Test loading plugins with a valid plugin that imports other modules within the current plugin package."""
-    assert (
-        "test_module_imports_plugin:test_module_imports_plugin.protocols.my_protocol:Protocol"
-        in LOADED_PLUGINS
-    )
-    assert (
-        LOADED_PLUGINS[
-            "test_module_imports_plugin:test_module_imports_plugin.protocols.my_protocol:Protocol"
-        ]["active"]
-        is True
-    )
-
-    result = [
-        response
-        async for response in plugin_runner.HandleEvent(EventRequest(type=EventType.UNKNOWN), None)
-    ]
-
-    assert len(result) == 1
-    assert result[0].success is True
-    assert len(result[0].effects) == 1
-    assert result[0].effects[0].type == EffectType.LOG
-    assert result[0].effects[0].payload == "Successfully imported!"
-
-
-@pytest.mark.parametrize(
-    "install_test_plugin",
-    [
-        "test_module_imports_outside_plugin_v1",
-        "test_module_imports_outside_plugin_v2",
-        "test_module_imports_outside_plugin_v3",
-    ],
-    indirect=True,
-)
-def test_load_plugins_with_plugin_that_imports_other_modules_outside_plugin_package(
-    install_test_plugin: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """Test loading plugins with an invalid plugin that imports other modules outside the current plugin package."""
-    with caplog.at_level(logging.ERROR):
-        load_or_reload_plugin(install_test_plugin)
-
-    assert any("Error importing module" in record.message for record in caplog.records), (
-        "log.error() was not called with the expected message."
-    )
-
-
-@pytest.mark.parametrize(
-    "install_test_plugin",
-    [
-        "test_module_forbidden_imports_plugin",
-    ],
-    indirect=True,
-)
-def test_load_plugins_with_plugin_that_imports_forbidden_modules(
-    install_test_plugin: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """Test loading plugins with an invalid plugin that imports forbidden modules."""
-    with caplog.at_level(logging.ERROR):
-        load_or_reload_plugin(install_test_plugin)
-
-    assert any("Error importing module" in record.message for record in caplog.records), (
-        "log.error() was not called with the expected message."
-    )
-
-
-@pytest.mark.parametrize(
-    "install_test_plugin",
-    [
-        "test_module_forbidden_imports_runtime_plugin",
-    ],
-    indirect=True,
-)
-def test_load_plugins_with_plugin_that_imports_forbidden_modules_at_runtime(
-    install_test_plugin: Path,
-) -> None:
-    """Test loading plugins with an invalid plugin that imports forbidden modules at runtime."""
-    with pytest.raises(ImportError, match="is not an allowed import."):
-        load_or_reload_plugin(install_test_plugin)
-        class_handler = LOADED_PLUGINS[
-            "test_module_forbidden_imports_runtime_plugin:test_module_forbidden_imports_runtime_plugin.protocols.my_protocol:Protocol"
-        ]["class"]
-        class_handler(Event(EventRequest(type=EventType.UNKNOWN))).compute()
-
-
-@pytest.mark.parametrize(
-    "install_test_plugin",
-    [
-        "test_implicit_imports_plugin",
-    ],
-    indirect=True,
-)
-def test_plugin_that_implicitly_imports_allowed_modules(
-    install_test_plugin: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """Test loading plugins with a plugin that implicitly imports allowed modules."""
-    with caplog.at_level(logging.INFO):
-        load_or_reload_plugin(install_test_plugin)
-        class_handler = LOADED_PLUGINS[
-            "test_implicit_imports_plugin:test_implicit_imports_plugin.protocols.my_protocol:Allowed"
-        ]["class"]
-        class_handler(Event(EventRequest(type=EventType.UNKNOWN))).compute()
-
-    assert any("Hello, World!" in record.message for record in caplog.records), (
-        "log.info() with Template.render() was not called."
-    )
-
-
-@pytest.mark.parametrize(
-    "install_test_plugin",
-    [
-        "test_implicit_imports_plugin",
-    ],
-    indirect=True,
-)
-def test_plugin_that_implicitly_imports_forbidden_modules(
-    install_test_plugin: Path, caplog: pytest.LogCaptureFixture
-) -> None:
-    """Test loading plugins with an invalid plugin that implicitly imports forbidden modules."""
-    with (
-        caplog.at_level(logging.INFO),
-        pytest.raises(ImportError, match="'os' is not an allowed import."),
-    ):
-        load_or_reload_plugin(install_test_plugin)
-        class_handler = LOADED_PLUGINS[
-            "test_implicit_imports_plugin:test_implicit_imports_plugin.protocols.my_protocol:Forbidden"
-        ]["class"]
-        class_handler(Event(EventRequest(type=EventType.UNKNOWN))).compute()
-
-    assert any("os list dir" in record.message for record in caplog.records) is False, (
-        "log.info() with os.listdir() was called."
-    )
-
-
-@pytest.mark.parametrize("install_test_plugin", ["example_plugin"], indirect=True)
-def test_reload_plugin(install_test_plugin: Path, load_test_plugins: None) -> None:
-    """Test reloading a plugin."""
-    load_plugins()
-
-    assert "example_plugin:example_plugin.protocols.my_protocol:Protocol" in LOADED_PLUGINS
-    assert (
-        LOADED_PLUGINS["example_plugin:example_plugin.protocols.my_protocol:Protocol"]["active"]
-        is True
-    )
-
-
-@pytest.mark.parametrize("install_test_plugin", ["example_plugin"], indirect=True)
-def test_remove_plugin_should_be_removed_from_loaded_plugins(
-    install_test_plugin: Path, load_test_plugins: None
-) -> None:
-    """Test removing a plugin."""
-    assert "example_plugin:example_plugin.protocols.my_protocol:Protocol" in LOADED_PLUGINS
-    shutil.rmtree(install_test_plugin)
-    load_plugins()
-    assert "example_plugin:example_plugin.protocols.my_protocol:Protocol" not in LOADED_PLUGINS
-
-
-@pytest.mark.parametrize("install_test_plugin", ["example_plugin"], indirect=True)
-@pytest.mark.parametrize("load_test_plugins", [None], indirect=True)
-def test_load_plugins_should_refresh_event_protocol_map(
-    load_test_plugins: None, install_test_plugin: Path
-) -> None:
-    """Test that the event protocol map is refreshed when loading plugins."""
-    assert EVENT_HANDLER_MAP == {}
-    load_plugins()
-    assert EventType.Name(EventType.UNKNOWN) in EVENT_HANDLER_MAP
-    assert EVENT_HANDLER_MAP[EventType.Name(EventType.UNKNOWN)] == [
-        "example_plugin:example_plugin.protocols.my_protocol:Protocol"
-    ]
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("install_test_plugin", ["example_plugin"], indirect=True)
-async def test_handle_plugin_event_returns_expected_result(
-    install_test_plugin: Path, plugin_runner: PluginRunner, load_test_plugins: None
-) -> None:
-    """Test that HandleEvent successfully calls the relevant plugins and returns the expected result."""
-    event = EventRequest(type=EventType.UNKNOWN)
-
-    result = []
-    async for response in plugin_runner.HandleEvent(event, None):
-        result.append(response)
-
-    assert len(result) == 1
-    assert result[0].success is True
-    assert len(result[0].effects) == 1
-    assert result[0].effects[0].type == EffectType.LOG
-    assert result[0].effects[0].payload == "Hello, world!"
-
-
-@pytest.mark.asyncio
-async def test_reload_plugins_event_handler_successfully_publishes_message(
-    plugin_runner: PluginRunner,
-) -> None:
-    """Test ReloadPlugins Event handler successfully publishes a message with restart action."""
-    with patch(
-        "plugin_runner.plugin_runner.publish_message", new_callable=AsyncMock
-    ) as mock_publish_message:
-        request = ReloadPluginsRequest()
-
-        result = []
-        async for response in plugin_runner.ReloadPlugins(request, None):
-            result.append(response)
-
-        mock_publish_message.assert_called_once_with(message={"action": "reload"})
-
-    assert len(result) == 1
-    assert result[0].success is True
-
-
-@pytest.mark.asyncio
-async def test_synchronize_plugins_calls_install_and_load_plugins() -> None:
-    """Test that synchronize_plugins calls install_plugins and load_plugins."""
-    with (
-        patch("plugin_runner.plugin_runner.get_client", new_callable=MagicMock) as mock_get_client,
-        patch(
-            "plugin_runner.plugin_runner.install_plugins", new_callable=AsyncMock
-        ) as mock_install_plugins,
-        patch(
-            "plugin_runner.plugin_runner.load_plugins", new_callable=AsyncMock
-        ) as mock_load_plugins,
-    ):
-        mock_client = AsyncMock()
-        mock_pubsub = AsyncMock()
-        mock_get_client.return_value = (mock_client, mock_pubsub)
-        mock_pubsub.get_message.return_value = {
-            "type": "pmessage",
-            "data": pickle.dumps({"action": "reload"}),
-        }
-
-        task = asyncio.create_task(synchronize_plugins(run_once=True))
-        await asyncio.sleep(0.1)  # Give some time for the coroutine to run
-        task.cancel()
-
-        mock_install_plugins.assert_called_once()
-        mock_load_plugins.assert_called_once()
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("install_test_plugin", ["test_module_imports_plugin"], indirect=True)
-async def test_changes_to_plugin_modules_should_be_reflected_after_reload(
-    install_test_plugin: Path, load_test_plugins: None, plugin_runner: PluginRunner
-) -> None:
-    """Test that changes to plugin modules are reflected after reloading the plugin."""
-    event = EventRequest(type=EventType.UNKNOWN)
-
-    result = []
-    async for response in plugin_runner.HandleEvent(event, None):
-        result.append(response)
-
-    assert len(result) == 1
-    assert result[0].success is True
-    assert len(result[0].effects) == 1
-    assert result[0].effects[0].type == EffectType.LOG
-    assert result[0].effects[0].payload == "Successfully imported!"
-
-    NEW_CODE = """
-def import_me() -> str:
-    return "Successfully changed!"
-"""
-    file_path = install_test_plugin / "other_module" / "base.py"
-    file_path.write_text(NEW_CODE, encoding="utf-8")
-
-    # Reload the plugin
-    load_plugins()
-
-    result = []
-    async for response in plugin_runner.HandleEvent(event, None):
-        result.append(response)
-
-    assert len(result) == 1
-    assert result[0].success is True
-    assert len(result[0].effects) == 1
-    assert result[0].effects[0].type == EffectType.LOG
-    assert result[0].effects[0].payload == "Successfully changed!"
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    argnames="context,status_code",
-    argvalues=[
-        (
-            {
-                "plugin_name": "test_simple_api",
-                "method": "GET",
-                "path": "/route",
-                "query_string": "",
-                "body": b64encode(b"").decode(),
-                "headers": {},
-            },
-            HTTPStatus.OK,
-        ),
-        (
-            {
-                "plugin_name": "test_simple_api",
-                "method": "GET",
-                "path": "/notfound",
-                "query_string": "",
-                "body": b64encode(b"").decode(),
-                "headers": {},
-            },
-            HTTPStatus.NOT_FOUND,
-        ),
-        (
-            {
-                "plugin_name": "test_simple_api",
-                "method": "GET",
-                "path": "/error",
-                "query_string": "",
-                "body": b64encode(b"").decode(),
-                "headers": {},
-            },
-            HTTPStatus.INTERNAL_SERVER_ERROR,
-        ),
-    ],
-    ids=["success", "not found error", "multiple handlers error"],
-)
-@pytest.mark.parametrize("install_test_plugin", ["test_simple_api"], indirect=True)
-async def test_simple_api(
-    install_test_plugin: Path,
-    load_test_plugins: None,
-    plugin_runner: PluginRunner,
-    context: dict[str, Any],
-    status_code: HTTPStatus,
-) -> None:
-    """Test that the PluginRunner returns responses to SimpleAPI request events."""
-    event = EventRequest(
-        type=EventType.SIMPLE_API_REQUEST,
-        context=json.dumps(context),
-    )
-
-    result = []
-    async for response in plugin_runner.HandleEvent(event, None):
-        result.append(response)
-
-    expected_response = Response(status_code=status_code).apply()
-    if status_code == HTTPStatus.OK:
-        expected_response.plugin_name = "test_simple_api"
-
-    assert result[0].effects == [expected_response]

plugin_runner/tests/test_sandbox.py

@@ -1,137 +0,0 @@
-import pytest
-
-from plugin_runner.sandbox import FORBIDDEN_ASSIGNMENTS, Sandbox
-
-# Sample code strings for testing various scenarios
-VALID_CODE = """
-x = 10
-y = 20
-result = x + y
-"""
-
-CODE_WITH_RESTRICTED_IMPORT = """
-import os
-result = os.listdir('.')
-"""
-
-CODE_WITH_PLUGIN_RUNNER_SETTING_IMPORT = """
-import settings
-result = settings.AWS_SECRET_ACCESS_KEY
-"""
-
-CODE_WITH_ALLOWED_IMPORT = """
-import json
-result = json.dumps({"key": "value"})
-"""
-
-CODE_WITH_FORBIDDEN_FUNC_NAME = """
-builtins = {}
-"""
-
-SOURCE_CODE_MODULE = """
-import module.b
-result = module.b
-"""
-
-CODE_WITH_FORBIDDEN_ASSIGNMENTS = [
-    code
-    for var in FORBIDDEN_ASSIGNMENTS
-    for code in [
-        f"{var} = 'test'",
-        f"test = {var} = 'test'",
-        f"test = {var} = test2 = 'test'",
-        f"(a, (b, c), (d, ({var}, f))) = (1, (2, 3), (4, (5, 6)))",
-        f"(a, (b, c), (d, [{var}, f])) = (1, (2, 3), (4, [5, 6]))",
-    ]
-]
-
-
-def test_valid_code_execution() -> None:
-    """Test execution of valid code in the sandbox."""
-    sandbox = Sandbox(VALID_CODE)
-    scope = sandbox.execute()
-    assert scope["result"] == 30, "The code should compute result as 30."
-
-
-def test_disallowed_import() -> None:
-    """Test that restricted imports are not allowed."""
-    sandbox = Sandbox(CODE_WITH_RESTRICTED_IMPORT)
-    with pytest.raises(ImportError, match="'os' is not an allowed import."):
-        sandbox.execute()
-
-
-def test_plugin_runner_settings_import() -> None:
-    """Test that imports of plugin runner settings are not allowed."""
-    sandbox = Sandbox(CODE_WITH_PLUGIN_RUNNER_SETTING_IMPORT)
-    with pytest.raises(ImportError, match="'settings' is not an allowed import."):
-        sandbox.execute()
-
-
-def test_allowed_import() -> None:
-    """Test that allowed imports (from ALLOWED_MODULES) work correctly."""
-    sandbox = Sandbox(CODE_WITH_ALLOWED_IMPORT)
-    scope = sandbox.execute()
-    assert scope["result"] == '{"key": "value"}', "JSON encoding should work with allowed imports."
-
-
-def test_forbidden_name() -> None:
-    """Test that forbidden function names are blocked by Transformer."""
-    sandbox = Sandbox(CODE_WITH_FORBIDDEN_FUNC_NAME)
-    with pytest.raises(RuntimeError, match="Code is invalid"):
-        sandbox.execute()
-
-
-@pytest.mark.parametrize("code", CODE_WITH_FORBIDDEN_ASSIGNMENTS)
-def test_forbidden_assignment(code: str) -> None:
-    """Test that forbidden assignments are blocked by Transformer."""
-    sandbox = Sandbox(code)
-    with pytest.raises(RuntimeError, match="Code is invalid"):
-        sandbox.execute()
-
-
-def test_code_with_warnings() -> None:
-    """Test that the sandbox captures warnings for restricted names or usage."""
-    code_with_warning = """
-_x = 5
-result = _x
-"""
-    sandbox = Sandbox(code_with_warning)
-    assert sandbox.warnings, "There should be warnings for using restricted names."
-    scope = sandbox.execute()
-    assert scope["result"] == 5, "Code should execute despite warnings."
-
-
-def test_compile_errors() -> None:
-    """Test that compile errors are detected for invalid syntax."""
-    invalid_code = """
-def missing_colon()
-    return 42
-"""
-    sandbox = Sandbox(invalid_code)
-    with pytest.raises(RuntimeError, match="Code is invalid"):
-        sandbox.execute()
-
-
-def test_sandbox_scope() -> None:
-    """Verify the sandbox scope includes expected built-ins and utility functions."""
-    sandbox = Sandbox(VALID_CODE)
-    scope = sandbox.execute()
-    assert "any" in scope["__builtins__"]
-    assert scope["__builtins__"]["any"] == any, "'any' function should be accessible in sandbox."
-
-
-def test_print_collector() -> None:
-    """Ensure that PrintCollector is used for capturing prints."""
-    code_with_print = """
-print("Hello, Sandbox!")
-"""
-    sandbox = Sandbox(code_with_print)
-    scope = sandbox.execute()
-    assert "Hello, Sandbox!" in scope["_print"].txt, "Print output should be captured."
-
-
-def test_sandbox_denies_module_name_import_outside_package() -> None:
-    """Test that modules outside the root package cannot be imported."""
-    sandbox_module_a = Sandbox(source_code=SOURCE_CODE_MODULE, namespace="other_module.a")
-    with pytest.raises(ImportError, match="module.b' is not an allowed import."):
-        sandbox_module_a.execute()