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

plugin_runner/tests/fixtures/plugins/test_implicit_imports_plugin/protocols/my_protocol.py

@@ -0,0 +1,33 @@
+from canvas_sdk.effects import Effect
+from canvas_sdk.events import EventType
+from canvas_sdk.protocols import BaseProtocol
+from logger import log
+
+
+class Forbidden(BaseProtocol):
+    """You should put a helpful description of this protocol's behavior here."""
+
+    # Name the event type you wish to run in response to
+    RESPONDS_TO = EventType.Name(EventType.UNKNOWN)
+
+    def compute(self) -> list[Effect]:
+        """This method gets called when an event of the type RESPONDS_TO is fired."""
+        from test_implicit_imports_plugin.utils.base import OtherClass
+
+        OtherClass()
+
+        return []
+
+
+class Allowed(BaseProtocol):
+    """You should put a helpful description of this protocol's behavior here."""
+
+    RESPONDS_TO = EventType.Name(EventType.UNKNOWN)
+
+    def compute(self) -> list[Effect]:
+        """This method gets called when an event of the type RESPONDS_TO is fired."""
+        from test_implicit_imports_plugin.templates import Template
+
+        log.info(Template().render())
+
+        return []

plugin_runner/tests/fixtures/plugins/test_implicit_imports_plugin/templates/__init__.py

@@ -0,0 +1,3 @@
+from test_implicit_imports_plugin.templates.base import Template
+
+__all__ = ("Template",)

plugin_runner/tests/fixtures/plugins/test_implicit_imports_plugin/templates/base.py

@@ -0,0 +1,6 @@
+class Template:
+    """A template class for testing implicit imports."""
+
+    def render(self) -> str:
+        """Renders the template."""
+        return "Hello, World!"

plugin_runner/tests/fixtures/plugins/test_implicit_imports_plugin/utils/__init__.py

@@ -0,0 +1,5 @@
+import os
+
+from logger import log
+
+log.info(f"os list dir: {os.listdir('.')}")

plugin_runner/tests/fixtures/plugins/test_implicit_imports_plugin/utils/base.py

@@ -0,0 +1,4 @@
+class OtherClass:
+    """This class is used to test implicit imports."""
+
+    pass

plugin_runner/tests/fixtures/plugins/test_module_forbidden_imports_plugin/CANVAS_MANIFEST.json

@@ -0,0 +1,29 @@
+{
+    "sdk_version": "0.1.4",
+    "plugin_version": "0.0.1",
+    "name": "test_module_forbidden_imports_plugin",
+    "description": "Edit the description in CANVAS_MANIFEST.json",
+    "components": {
+        "protocols": [
+            {
+                "class": "test_module_forbidden_imports_plugin.protocols.my_protocol:Protocol",
+                "description": "A protocol that does xyz...",
+                "data_access": {
+                    "event": "",
+                    "read": [],
+                    "write": []
+                }
+            }
+        ],
+        "commands": [],
+        "content": [],
+        "effects": [],
+        "views": []
+    },
+    "secrets": [],
+    "tags": {},
+    "references": [],
+    "license": "",
+    "diagram": false,
+    "readme": "./README.md"
+}

plugin_runner/tests/fixtures/plugins/test_module_forbidden_imports_plugin/README.md

@@ -0,0 +1,12 @@
+==========================
+test_module_forbidden_imports_plugin
+==========================
+
+## Description
+
+A description of this plugin
+
+### Important Note!
+
+The CANVAS_MANIFEST.json is used when installing your plugin. Please ensure it
+gets updated if you add, remove, or rename protocols.

plugin_runner/tests/fixtures/plugins/test_module_forbidden_imports_plugin/other_module/base.py

@@ -0,0 +1,10 @@
+import os
+
+from logger import log
+
+log.info(f"This is a forbidden import. {os}")
+
+
+def import_me() -> str:
+    """Test method."""
+    return "Successfully imported!"

plugin_runner/tests/fixtures/plugins/test_module_forbidden_imports_plugin/protocols/my_protocol.py

@@ -0,0 +1,18 @@
+from test_module_forbidden_imports_plugin.other_module.base import import_me
+
+from canvas_sdk.effects import Effect, EffectType
+from canvas_sdk.events import EventType
+from canvas_sdk.protocols import BaseProtocol
+
+
+class Protocol(BaseProtocol):
+    """
+    You should put a helpful description of this protocol's behavior here.
+    """
+
+    # Name the event type you wish to run in response to
+    RESPONDS_TO = EventType.Name(EventType.UNKNOWN)
+
+    def compute(self) -> list[Effect]:
+        """This method gets called when an event of the type RESPONDS_TO is fired."""
+        return [Effect(type=EffectType.LOG, payload=import_me())]

plugin_runner/tests/fixtures/plugins/test_module_forbidden_imports_runtime_plugin/CANVAS_MANIFEST.json

@@ -0,0 +1,29 @@
+{
+    "sdk_version": "0.1.4",
+    "plugin_version": "0.0.1",
+    "name": "test_module_forbidden_imports_runtime_plugin",
+    "description": "Edit the description in CANVAS_MANIFEST.json",
+    "components": {
+        "protocols": [
+            {
+                "class": "test_module_forbidden_imports_runtime_plugin.protocols.my_protocol:Protocol",
+                "description": "A protocol that does xyz...",
+                "data_access": {
+                    "event": "",
+                    "read": [],
+                    "write": []
+                }
+            }
+        ],
+        "commands": [],
+        "content": [],
+        "effects": [],
+        "views": []
+    },
+    "secrets": [],
+    "tags": {},
+    "references": [],
+    "license": "",
+    "diagram": false,
+    "readme": "./README.md"
+}

plugin_runner/tests/fixtures/plugins/test_module_forbidden_imports_runtime_plugin/README.md

@@ -0,0 +1,12 @@
+==========================
+test_module_forbidden_imports_runtime_plugin
+==========================
+
+## Description
+
+A description of this plugin
+
+### Important Note!
+
+The CANVAS_MANIFEST.json is used when installing your plugin. Please ensure it
+gets updated if you add, remove, or rename protocols.

plugin_runner/tests/fixtures/plugins/test_module_forbidden_imports_runtime_plugin/other_module/base.py

@@ -0,0 +1,10 @@
+import os
+
+from logger import log
+
+log.info(f"This is a forbidden import. {os}")
+
+
+def import_me() -> str:
+    """Test method."""
+    return "Successfully imported!"

plugin_runner/tests/fixtures/plugins/test_module_forbidden_imports_runtime_plugin/protocols/my_protocol.py

@@ -0,0 +1,18 @@
+from canvas_sdk.effects import Effect, EffectType
+from canvas_sdk.events import EventType
+from canvas_sdk.protocols import BaseProtocol
+
+
+class Protocol(BaseProtocol):
+    """
+    You should put a helpful description of this protocol's behavior here.
+    """
+
+    # Name the event type you wish to run in response to
+    RESPONDS_TO = EventType.Name(EventType.UNKNOWN)
+
+    def compute(self) -> list[Effect]:
+        """This method gets called when an event of the type RESPONDS_TO is fired."""
+        from test_module_forbidden_imports_runtime_plugin.other_module.base import import_me
+
+        return [Effect(type=EffectType.LOG, payload=import_me())]

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

@@ -2,11 +2,10 @@ import json
 import tarfile
 import tempfile
 from pathlib import Path
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
 from pytest_mock import MockerFixture
 
-import settings
 from plugin_runner.plugin_installer import (
     PluginAttributes,
     _extract_rows_to_dict,
@@ -84,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()
@@ -106,13 +116,12 @@ def test_plugin_installation_from_tarball(mocker: MockerFixture) -> None:
 
 def test_download(mocker: MockerFixture) -> None:
     """Test that the plugin package can be written to disk, mocking out S3."""
-    mock_s3_client = MagicMock()
-    mocker.patch("boto3.client", return_value=mock_s3_client)
-
-    plugin_package = "plugins/plugin1.tar.gz"
-    with download_plugin(plugin_package) as plugin_path:
-        assert plugin_path.exists()
-
-    mock_s3_client.download_fileobj.assert_called_once_with(
-        "canvas-client-media", f"{settings.CUSTOMER_IDENTIFIER}/{plugin_package}", mocker.ANY
-    )
+    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,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!"