canvas 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

plugin_runner/tests/test_plugin_runner.py

@@ -0,0 +1,208 @@
+import shutil
+from pathlib import Path
+from typing import Generator
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from canvas_generated.messages.effects_pb2 import EffectType
+from canvas_generated.messages.plugins_pb2 import ReloadPluginsRequest
+from canvas_sdk.events import Event, EventType
+from plugin_runner.plugin_runner import (
+    EVENT_PROTOCOL_MAP,
+    LOADED_PLUGINS,
+    PluginRunner,
+    load_plugins,
+    sandbox_from_package,
+)
+
+
+@pytest.fixture
+def setup_test_plugin(request: pytest.FixtureRequest) -> Generator[Path, None, None]:
+    """Copies a specified plugin from the fixtures directory to the data directory
+    and removes it after the test.
+
+    Parameters:
+    - request.param: The name of the plugin package to copy.
+
+    Yields:
+    - Path to the copied plugin directory.
+    """
+    # Define base directories
+    base_dir = Path("./plugin_runner/tests")
+    fixture_plugin_dir = base_dir / "fixtures" / "plugins"
+    data_plugin_dir = base_dir / "data" / "plugins"
+
+    # The plugin name should be passed as a parameter to the fixture
+    plugin_name = request.param  # Expected to be a str
+    src_plugin_path = fixture_plugin_dir / plugin_name
+    dest_plugin_path = data_plugin_dir / plugin_name
+
+    # Ensure the data plugin directory exists
+    data_plugin_dir.mkdir(parents=True, exist_ok=True)
+
+    # Copy the specific plugin from fixtures to data
+    try:
+        shutil.copytree(src_plugin_path, dest_plugin_path)
+        yield dest_plugin_path  # Provide the path to the test
+    finally:
+        # Cleanup: remove data/plugins directory after the test
+        if dest_plugin_path.exists():
+            shutil.rmtree(dest_plugin_path)
+
+
+@pytest.fixture
+def plugin_runner() -> PluginRunner:
+    """Fixture to initialize PluginRunner with mocks."""
+    runner = PluginRunner()
+    runner.statsd_client = MagicMock()
+    return runner
+
+
+@pytest.mark.parametrize("setup_test_plugin", ["example_plugin"], indirect=True)
+def test_load_plugins_with_valid_plugin(setup_test_plugin: Path) -> None:
+    """Test loading plugins with a valid 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.asyncio
+@pytest.mark.parametrize("setup_test_plugin", ["test_module_imports_plugin"], indirect=True)
+async def test_load_plugins_with_plugin_that_imports_other_modules_within_plugin_package(
+    setup_test_plugin: Path, plugin_runner: PluginRunner
+) -> None:
+    """Test loading plugins with a valid plugin that imports other modules within the current plugin package."""
+    load_plugins()
+    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(Event(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(
+    "setup_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(
+    setup_test_plugin: Path,
+) -> None:
+    """Test loading plugins with an invalid plugin that imports other modules outside the current plugin package."""
+    with pytest.raises(ImportError, match="is not an allowed import"):
+        sandbox_from_package(setup_test_plugin)
+
+
+@pytest.mark.parametrize("setup_test_plugin", ["example_plugin"], indirect=True)
+def test_reload_plugin(setup_test_plugin: Path) -> None:
+    """Test reloading a plugin."""
+    load_plugins()
+    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("setup_test_plugin", ["example_plugin"], indirect=True)
+def test_remove_plugin_should_be_removed_from_loaded_plugins(setup_test_plugin: Path) -> None:
+    """Test removing a plugin."""
+    load_plugins()
+    assert "example_plugin:example_plugin.protocols.my_protocol:Protocol" in LOADED_PLUGINS
+    shutil.rmtree(setup_test_plugin)
+    load_plugins()
+    assert "example_plugin:example_plugin.protocols.my_protocol:Protocol" not in LOADED_PLUGINS
+
+
+@pytest.mark.parametrize("setup_test_plugin", ["example_plugin"], indirect=True)
+def test_load_plugins_should_refresh_event_protocol_map(setup_test_plugin: Path) -> None:
+    """Test that the event protocol map is refreshed when loading plugins."""
+    assert EVENT_PROTOCOL_MAP == {}
+    load_plugins()
+    assert EventType.Name(EventType.UNKNOWN) in EVENT_PROTOCOL_MAP
+    assert EVENT_PROTOCOL_MAP[EventType.Name(EventType.UNKNOWN)] == [
+        "example_plugin:example_plugin.protocols.my_protocol:Protocol"
+    ]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("setup_test_plugin", ["example_plugin"], indirect=True)
+async def test_handle_plugin_event_returns_expected_result(
+    setup_test_plugin: Path, plugin_runner: PluginRunner
+) -> None:
+    """Test that HandleEvent successfully calls the relevant plugins and returns the expected result."""
+    load_plugins()
+
+    event = Event(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
+@pytest.mark.parametrize("setup_test_plugin", ["example_plugin"], indirect=True)
+async def test_reload_plugins_event_handler_successfully_loads_plugins(
+    setup_test_plugin: Path, plugin_runner: PluginRunner
+) -> None:
+    """Test ReloadPlugins Event handler successfully loads plugins."""
+
+    with patch("plugin_runner.plugin_runner.publish_message", MagicMock()) 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({"action": "restart"})
+
+    assert len(result) == 1
+    assert result[0].success is True
+    assert "example_plugin:example_plugin.protocols.my_protocol:Protocol" in LOADED_PLUGINS
+
+
+@pytest.mark.asyncio
+async def test_reload_plugins_import_error(plugin_runner: PluginRunner) -> None:
+    """Test ReloadPlugins response when an ImportError occurs."""
+    request = ReloadPluginsRequest()
+
+    with patch("plugin_runner.plugin_runner.load_plugins", side_effect=ImportError):
+        responses = []
+        async for response in plugin_runner.ReloadPlugins(request, None):
+            responses.append(response)
+
+        assert len(responses) == 1
+        assert responses[0].success is False

plugin_runner/tests/test_sandbox.py

@@ -0,0 +1,113 @@
+import pytest
+
+from plugin_runner.sandbox import 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_ALLOWED_IMPORT = """
+import json
+result = json.dumps({"key": "value"})
+"""
+
+CODE_WITH_FORBIDDEN_FUNC_NAME = """
+builtins = {}
+"""
+
+SOURCE_CODE_MODULE_OS = """
+import os
+result = os.listdir('.')
+"""
+
+
+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_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()
+
+
+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_module_name_imports_within_package() -> None:
+    """Test that modules within the same package can be imported."""
+    sandbox_module_a = Sandbox(source_code=SOURCE_CODE_MODULE_OS, module_name="os.a")
+    result = sandbox_module_a.execute()
+
+    assert "os" in result
+
+
+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_OS, module_name="module.a")
+    with pytest.raises(ImportError, match="os' is not an allowed import."):
+        sandbox_module_a.execute()

settings.py

@@ -1,11 +1,18 @@
 import os
+import sys
 
 from dotenv import load_dotenv
+from env_tools import env_to_bool
 
 from canvas_sdk.utils.db import get_database_dict_from_url
 
 load_dotenv()
 
+ENV = os.getenv("ENV", "development")
+IS_PRODUCTION = ENV == "production"
+IS_TESTING = env_to_bool("IS_TESTING", "pytest" in sys.argv[0] or sys.argv[0] == "-c")
+
+
 INTEGRATION_TEST_URL = os.getenv("INTEGRATION_TEST_URL")
 INTEGRATION_TEST_CLIENT_ID = os.getenv("INTEGRATION_TEST_CLIENT_ID")
 INTEGRATION_TEST_CLIENT_SECRET = os.getenv("INTEGRATION_TEST_CLIENT_SECRET")
@@ -41,3 +48,19 @@ else:
     }
 
 DATABASES = {"default": database_dict}
+
+
+PLUGIN_RUNNER_SIGNING_KEY = os.getenv("PLUGIN_RUNNER_SIGNING_KEY", "")
+
+PLUGIN_DIRECTORY = os.getenv(
+    "PLUGIN_DIRECTORY",
+    (
+        "/plugin-runner/custom-plugins"
+        if IS_PRODUCTION
+        else "./plugin_runner/tests/data/plugins" if IS_TESTING else "./custom-plugins"
+    ),
+)
+
+MANIFEST_FILE_NAME = "CANVAS_MANIFEST.json"
+
+SECRETS_FILE_NAME = "SECRETS.json"