canvas 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

plugin_runner/tests/test_application.py

@@ -6,7 +6,7 @@ from canvas_sdk.events import Event, EventRequest, EventType
 from canvas_sdk.handlers.application import Application
 
 
-class TestApplication(Application):
+class ExampleApplication(Application):
     """A concrete implementation of the Application class for testing."""
 
     def on_open(self) -> Effect:
@@ -15,9 +15,9 @@ class TestApplication(Application):
 
 
 @pytest.fixture
-def app_instance(event: Event) -> TestApplication:
+def app_instance(event: Event) -> ExampleApplication:
     """Provide an instance of the TestApplication with a mocked event."""
-    app = TestApplication(event)
+    app = ExampleApplication(event)
     return app
 
 
@@ -25,7 +25,7 @@ def test_compute_event_not_targeted() -> None:
     """Test that compute filters out events not targeted for the app."""
     request = EventRequest(type=EventType.APPLICATION__ON_OPEN, target="some_identifier")
     event = Event(request)
-    app = TestApplication(event)
+    app = ExampleApplication(event)
 
     result = app.compute()
 
@@ -36,10 +36,10 @@ def test_compute_event_targeted() -> None:
     """Test that compute processes events targeted for the app."""
     request = EventRequest(
         type=EventType.APPLICATION__ON_OPEN,
-        target=f"{TestApplication.__module__}:{TestApplication.__qualname__}",
+        target=f"{ExampleApplication.__module__}:{ExampleApplication.__qualname__}",
     )
     event = Event(request)
-    app = TestApplication(event)
+    app = ExampleApplication(event)
     result = app.compute()
 
     assert len(result) == 1, "Expected a single effect if the event target is the app identifier"
@@ -48,13 +48,13 @@ def test_compute_event_targeted() -> None:
 
 def test_identifier_property() -> None:
     """Test the identifier property of the Application class."""
-    expected_identifier = f"{TestApplication.__module__}:{TestApplication.__qualname__}"
+    expected_identifier = f"{ExampleApplication.__module__}:{ExampleApplication.__qualname__}"
     request = EventRequest(
         type=EventType.APPLICATION__ON_OPEN,
-        target=f"{TestApplication.__module__}:{TestApplication.__qualname__}",
+        target=f"{ExampleApplication.__module__}:{ExampleApplication.__qualname__}",
     )
     event = Event(request)
-    app = TestApplication(event)
+    app = ExampleApplication(event)
 
     assert app.identifier == expected_identifier, "The identifier property is incorrect"
 

plugin_runner/tests/test_plugin_installer.py

@@ -83,8 +83,19 @@ def test_plugin_installation_from_tarball(mocker: MockerFixture) -> None:
     tarball_2 = _create_tarball("plugin2")
 
     mocker.patch("plugin_runner.plugin_installer.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.plugin_installer.download_plugin", side_effect=[tarball_1, tarball_2]
+        "plugin_runner.plugin_installer.download_plugin",
+        side_effect=mock_download_plugin,
     )
 
     install_plugins()

plugin_runner/tests/test_plugin_runner.py

@@ -1,3 +1,4 @@
+import logging
 import shutil
 from collections.abc import Generator
 from pathlib import Path
@@ -7,18 +8,18 @@ import pytest
 
 from canvas_generated.messages.effects_pb2 import EffectType
 from canvas_generated.messages.plugins_pb2 import ReloadPluginsRequest
-from canvas_sdk.events import EventRequest, EventType
+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,
-    sandbox_from_package,
 )
 
 
 @pytest.fixture
-def setup_test_plugin(request: pytest.FixtureRequest) -> Generator[Path, None, None]:
+def install_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.
 
@@ -51,6 +52,17 @@ def setup_test_plugin(request: pytest.FixtureRequest) -> Generator[Path, None, N
             shutil.rmtree(dest_plugin_path)
 
 
+@pytest.fixture
+def load_test_plugins() -> Generator[None, None, None]:
+    """Manages the lifecycle of test plugins by loading and unloading them."""
+    try:
+        load_plugins()
+        yield
+    finally:
+        LOADED_PLUGINS.clear()
+        EVENT_HANDLER_MAP.clear()
+
+
 @pytest.fixture
 def plugin_runner() -> PluginRunner:
     """Fixture to initialize PluginRunner with mocks."""
@@ -59,11 +71,9 @@ def plugin_runner() -> PluginRunner:
     return runner
 
 
-@pytest.mark.parametrize("setup_test_plugin", ["example_plugin"], indirect=True)
-def test_load_plugins_with_valid_plugin(setup_test_plugin: Path) -> None:
+@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."""
-    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"]
@@ -72,12 +82,11 @@ def test_load_plugins_with_valid_plugin(setup_test_plugin: Path) -> None:
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("setup_test_plugin", ["test_module_imports_plugin"], indirect=True)
+@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(
-    setup_test_plugin: Path, plugin_runner: PluginRunner
+    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."""
-    load_plugins()
     assert (
         "test_module_imports_plugin:test_module_imports_plugin.protocols.my_protocol:Protocol"
         in LOADED_PLUGINS
@@ -102,7 +111,7 @@ async def test_load_plugins_with_plugin_that_imports_other_modules_within_plugin
 
 
 @pytest.mark.parametrize(
-    "setup_test_plugin",
+    "install_test_plugin",
     [
         "test_module_imports_outside_plugin_v1",
         "test_module_imports_outside_plugin_v2",
@@ -111,18 +120,108 @@ async def test_load_plugins_with_plugin_that_imports_other_modules_within_plugin
     indirect=True,
 )
 def test_load_plugins_with_plugin_that_imports_other_modules_outside_plugin_package(
-    setup_test_plugin: Path,
+    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 pytest.raises(ImportError, match="is not an allowed import"):
-        sandbox_from_package(setup_test_plugin)
+    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("setup_test_plugin", ["example_plugin"], indirect=True)
-def test_reload_plugin(setup_test_plugin: Path) -> None:
+@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()
-    load_plugins()
 
     assert "example_plugin:example_plugin.protocols.my_protocol:Protocol" in LOADED_PLUGINS
     assert (
@@ -131,18 +230,22 @@ def test_reload_plugin(setup_test_plugin: Path) -> None:
     )
 
 
-@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:
+@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."""
-    load_plugins()
     assert "example_plugin:example_plugin.protocols.my_protocol:Protocol" in LOADED_PLUGINS
-    shutil.rmtree(setup_test_plugin)
+    shutil.rmtree(install_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:
+@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()
@@ -153,13 +256,11 @@ def test_load_plugins_should_refresh_event_protocol_map(setup_test_plugin: Path)
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("setup_test_plugin", ["example_plugin"], indirect=True)
+@pytest.mark.parametrize("install_test_plugin", ["example_plugin"], indirect=True)
 async def test_handle_plugin_event_returns_expected_result(
-    setup_test_plugin: Path, plugin_runner: PluginRunner
+    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."""
-    load_plugins()
-
     event = EventRequest(type=EventType.UNKNOWN)
 
     result = []
@@ -174,11 +275,11 @@ async def test_handle_plugin_event_returns_expected_result(
 
 
 @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
+@pytest.mark.parametrize("install_test_plugin", ["example_plugin"], indirect=True)
+async def test_reload_plugins_event_handler_successfully_publishes_message(
+    install_test_plugin: Path, plugin_runner: PluginRunner
 ) -> None:
-    """Test ReloadPlugins Event handler successfully loads plugins."""
+    """Test ReloadPlugins Event handler successfully publishes a message with restart action."""
     with patch("plugin_runner.plugin_runner.publish_message", MagicMock()) as mock_publish_message:
         request = ReloadPluginsRequest()
 
@@ -190,4 +291,42 @@ async def test_reload_plugins_event_handler_successfully_loads_plugins(
 
     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
+@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!"

plugin_runner/tests/test_sandbox.py

@@ -28,9 +28,9 @@ CODE_WITH_FORBIDDEN_FUNC_NAME = """
 builtins = {}
 """
 
-SOURCE_CODE_MODULE_OS = """
-import os
-result = os.listdir('.')
+SOURCE_CODE_MODULE = """
+import module.b
+result = module.b
 """
 
 
@@ -110,16 +110,8 @@ print("Hello, Sandbox!")
     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, namespace="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, namespace="module.a")
-    with pytest.raises(ImportError, match="os' is not an allowed import."):
+    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()

settings.py

@@ -19,7 +19,9 @@ INTEGRATION_TEST_CLIENT_SECRET = os.getenv("INTEGRATION_TEST_CLIENT_SECRET")
 
 GRAPHQL_ENDPOINT = os.getenv("GRAPHQL_ENDPOINT", "http://localhost:8000/plugins-graphql")
 
-INSTALLED_APPS = ["canvas_sdk"]
+INSTALLED_APPS = [
+    "canvas_sdk.v1",
+]
 
 SECRET_KEY = os.getenv(
     "SECRET_KEY",

canvas_sdk/models/__init__.py

@@ -1,8 +0,0 @@
-# ruff: noqa
-# register all models in the app so they can be used with apps.get_model()
-from canvas_sdk.v1.data.command import Command
-from canvas_sdk.v1.data.condition import Condition
-from canvas_sdk.v1.data.note import Note
-from canvas_sdk.v1.data.patient import Patient
-from canvas_sdk.v1.data.user import CanvasUser
-from canvas_sdk.v1.data.questionnaire import Interview