canvas 0.11.1__py3-none-any.whl → 0.13.0__py3-none-any.whl

plugin_runner/sandbox.py

@@ -93,7 +93,6 @@ class Sandbox:
 
     source_code: str
     namespace: str
-    module_name: str | None
 
     class Transformer(RestrictingNodeTransformer):
         """A node transformer for customizing the sandbox compiler."""
@@ -200,19 +199,16 @@ class Sandbox:
                 # Impossible Case only ctx Load, Store and Del are defined in ast.
                 raise NotImplementedError(f"Unknown ctx type: {type(node.ctx)}")
 
-    def __init__(
-        self, source_code: str, namespace: str | None = None, module_name: str | None = None
-    ) -> None:
+    def __init__(self, source_code: str, namespace: str | None = None) -> None:
         if source_code is None:
             raise TypeError("source_code may not be None")
-        self.module_name = module_name
         self.namespace = namespace or "protocols"
         self.source_code = source_code
 
     @cached_property
     def package_name(self) -> str | None:
         """Return the root package name."""
-        return self.module_name.split(".")[0] if self.module_name else None
+        return self.namespace.split(".")[0] if self.namespace else None
 
     @cached_property
     def scope(self) -> dict[str, Any]:

plugin_runner/tests/test_application.py

@@ -0,0 +1,65 @@
+import pytest
+
+from canvas_sdk.effects import Effect
+from canvas_sdk.effects.launch_modal import LaunchModalEffect
+from canvas_sdk.events import Event, EventRequest, EventType
+from canvas_sdk.handlers.application import Application
+
+
+class TestApplication(Application):
+    """A concrete implementation of the Application class for testing."""
+
+    def on_open(self) -> Effect:
+        """Handle the application open event by returning a mock effect."""
+        return LaunchModalEffect(url="https://example.com").apply()
+
+
+@pytest.fixture
+def app_instance(event: Event) -> TestApplication:
+    """Provide an instance of the TestApplication with a mocked event."""
+    app = TestApplication(event)
+    return app
+
+
+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)
+
+    result = app.compute()
+
+    assert result == [], "Expected no effects if the event target is not the app identifier"
+
+
+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__}",
+    )
+    event = Event(request)
+    app = TestApplication(event)
+    result = app.compute()
+
+    assert len(result) == 1, "Expected a single effect if the event target is the app identifier"
+    assert isinstance(result[0], Effect), "Effect should be an instance of Effect"
+
+
+def test_identifier_property() -> None:
+    """Test the identifier property of the Application class."""
+    expected_identifier = f"{TestApplication.__module__}:{TestApplication.__qualname__}"
+    request = EventRequest(
+        type=EventType.APPLICATION__ON_OPEN,
+        target=f"{TestApplication.__module__}:{TestApplication.__qualname__}",
+    )
+    event = Event(request)
+    app = TestApplication(event)
+
+    assert app.identifier == expected_identifier, "The identifier property is incorrect"
+
+
+def test_abstract_method_on_open() -> None:
+    """Test that the abstract method on_open must be implemented."""
+    with pytest.raises(TypeError):
+        Application(Event(EventRequest(type=EventType.UNKNOWN)))  # type: ignore[abstract]

plugin_runner/tests/test_plugin_runner.py

@@ -9,7 +9,7 @@ from canvas_generated.messages.effects_pb2 import EffectType
 from canvas_generated.messages.plugins_pb2 import ReloadPluginsRequest
 from canvas_sdk.events import EventRequest, EventType
 from plugin_runner.plugin_runner import (
-    EVENT_PROTOCOL_MAP,
+    EVENT_HANDLER_MAP,
     LOADED_PLUGINS,
     PluginRunner,
     load_plugins,
@@ -144,10 +144,10 @@ def test_remove_plugin_should_be_removed_from_loaded_plugins(setup_test_plugin:
 @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 == {}
+    assert EVENT_HANDLER_MAP == {}
     load_plugins()
-    assert EventType.Name(EventType.UNKNOWN) in EVENT_PROTOCOL_MAP
-    assert EVENT_PROTOCOL_MAP[EventType.Name(EventType.UNKNOWN)] == [
+    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"
     ]
 

plugin_runner/tests/test_sandbox.py

@@ -100,7 +100,7 @@ print("Hello, Sandbox!")
 
 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")
+    sandbox_module_a = Sandbox(source_code=SOURCE_CODE_MODULE_OS, namespace="os.a")
     result = sandbox_module_a.execute()
 
     assert "os" in result
@@ -108,6 +108,6 @@ def test_sandbox_module_name_imports_within_package() -> None:
 
 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")
+    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.execute()