add frontend

src/infrastructure/services/plugins/runtime_test.rs

@@ -9,6 +9,7 @@ use std::time::{Duration, Instant};
 use super::ExtismPluginManager;
 use super::manifest;
 use super::runtime::{InvokeOutcome, PluginRuntime};
+use crate::application::ports::plugin_ports::event_export_name;
 use crate::common::config::PluginConfig;
 
 fn cfg() -> PluginConfig {
@@ -27,7 +28,7 @@ fn fixture(name: &str) -> Vec<u8> {
     })
 }
 
-fn sample_input() -> String {
+fn file_uploaded_input() -> String {
     serde_json::json!({
         "abi": 0,
         "event": "file.uploaded",
@@ -41,21 +42,38 @@ fn sample_input() -> String {
     .to_string()
 }
 
-// ---- The M0 exit criterion: the full loop -----------------------------------
+fn user_login_input() -> String {
+    serde_json::json!({
+        "abi": 0,
+        "event": "user.login",
+        "context": {
+            "plugin_id": "com.example.hello",
+            "user_id": "u_test",
+            "invocation_id": "inv_login_0001"
+        },
+        "payload": {
+            "user_id": "u_test",
+            "username": "alice",
+            "email": "alice@example.com",
+            "first_login": true,
+            "is_external": false
+        }
+    })
+    .to_string()
+}
+
+// ---- The M0 exit criterion: the full loop, per event ------------------------
 
 #[test]
-fn acceptance_hello_returns_ok_and_calls_host_log() {
+fn acceptance_file_uploaded_returns_ok_and_calls_host_log() {
     let rt = PluginRuntime::new("com.example.hello", fixture("hello.wasm"));
-    let result = rt.invoke(&cfg(), "inv_test_0001", &sample_input());
+    let result = rt.invoke(&cfg(), "on_file_uploaded", "inv", &file_uploaded_input());
 
-    // 1. handle returned a well-formed PluginOutput with ok = true.
     assert!(
         result.outcome.is_ok(),
         "plugin did not complete: {:?}",
         result.outcome
     );
-
-    // 2. The plugin called the host `log` function (plugin -> host).
     assert!(
         result.logs.iter().any(|(level, msg)| level == "info"
             && msg.contains("hello plugin saw upload: /photos/2026/cat.jpg")),
@@ -64,6 +82,24 @@ fn acceptance_hello_returns_ok_and_calls_host_log() {
     );
 }
 
+#[test]
+fn acceptance_user_login_returns_ok_and_calls_host_log() {
+    let rt = PluginRuntime::new("com.example.hello", fixture("hello.wasm"));
+    let result = rt.invoke(&cfg(), "on_user_login", "inv", &user_login_input());
+
+    assert!(
+        result.outcome.is_ok(),
+        "plugin did not complete: {:?}",
+        result.outcome
+    );
+    assert!(
+        result.logs.iter().any(|(level, msg)| level == "info"
+            && msg.contains("hello plugin saw login: user u_test (first_login=true)")),
+        "expected the plugin's user.login log line, got: {:?}",
+        result.logs
+    );
+}
+
 // ---- The guarantees, not just the happy path --------------------------------
 
 #[test]
@@ -71,17 +107,45 @@ fn rejects_wrong_abi() {
     let rt = PluginRuntime::new("com.example.wrong-abi", fixture("wrong_abi.wasm"));
     assert!(
         matches!(
-            rt.check_loadable(&cfg()),
+            rt.check_loadable(&cfg(), &[]),
             InvokeOutcome::AbiMismatch { got: 1 }
         ),
         "wrong-abi plugin should be rejected at load"
     );
 }
 
+#[test]
+fn load_requires_subscribed_event_exports() {
+    let cfg = cfg();
+    let login_export = vec![event_export_name("user.login")];
+
+    // hello.wasm exports both handlers -> loadable for user.login.
+    let hello = PluginRuntime::new("com.example.hello", fixture("hello.wasm"));
+    assert!(matches!(
+        hello.check_loadable(&cfg, &login_export),
+        InvokeOutcome::Ok
+    ));
+
+    // omit_login.wasm lacks on_user_login -> rejected when it claims user.login.
+    let omit = PluginRuntime::new("com.example.omit", fixture("omit_login.wasm"));
+    assert!(
+        matches!(
+            omit.check_loadable(&cfg, &login_export),
+            InvokeOutcome::MissingExport(ref e) if e == "on_user_login"
+        ),
+        "omit_login must be rejected for a user.login subscription"
+    );
+    // …but it is fine for file.uploaded, which it does export.
+    assert!(matches!(
+        omit.check_loadable(&cfg, &[event_export_name("file.uploaded")]),
+        InvokeOutcome::Ok
+    ));
+}
+
 #[test]
 fn contains_a_panicking_plugin() {
     let rt = PluginRuntime::new("com.example.panic", fixture("panic.wasm"));
-    let result = rt.invoke(&cfg(), "inv", &sample_input());
+    let result = rt.invoke(&cfg(), "on_file_uploaded", "inv", &file_uploaded_input());
     assert!(
         matches!(result.outcome, InvokeOutcome::Trap(_)),
         "expected a contained trap, got {:?}",
@@ -94,7 +158,7 @@ fn contains_a_panicking_plugin() {
 fn enforces_timeout() {
     let rt = PluginRuntime::new("com.example.sleep", fixture("sleep.wasm"));
     let start = Instant::now();
-    let result = rt.invoke(&cfg(), "inv", &sample_input());
+    let result = rt.invoke(&cfg(), "on_file_uploaded", "inv", &file_uploaded_input());
     let elapsed = start.elapsed();
 
     assert!(
@@ -111,9 +175,7 @@ fn enforces_timeout() {
 #[test]
 fn no_network() {
     let rt = PluginRuntime::new("com.example.net", fixture("net.wasm"));
-    let result = rt.invoke(&cfg(), "inv", &sample_input());
-    // No allowed_hosts are granted, so the outbound call is denied and the
-    // plugin cannot complete successfully.
+    let result = rt.invoke(&cfg(), "on_file_uploaded", "inv", &file_uploaded_input());
     assert!(
         !result.outcome.is_ok(),
         "network access should be denied, got {:?}",
@@ -121,47 +183,75 @@ fn no_network() {
     );
 }
 
-#[tokio::test]
-async fn manager_loads_and_dispatches() {
-    use crate::application::ports::plugin_ports::{FileUploadedEvent, PluginDispatchPort};
+// ---- Manager discovery + dispatch ------------------------------------------
 
+/// Write a one-plugin directory (plugin.toml + the given wasm) under a tempdir
+/// and load a manager from it.
+fn manager_with(wasm_name: &str, subscribe_toml: &str) -> (tempfile::TempDir, ExtismPluginManager) {
     let tmp = tempfile::tempdir().unwrap();
-    let plugin_dir = tmp.path().join("hello");
-    std::fs::create_dir_all(&plugin_dir).unwrap();
-    std::fs::write(plugin_dir.join("hello.wasm"), fixture("hello.wasm")).unwrap();
+    let dir = tmp.path().join("plugin");
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(dir.join("plugin.wasm"), fixture(wasm_name)).unwrap();
     std::fs::write(
-        plugin_dir.join("plugin.toml"),
-        r#"
+        dir.join("plugin.toml"),
+        format!(
+            r#"
 [plugin]
-id = "com.example.hello"
-name = "Hello"
+id = "com.example.test"
+name = "Test"
 version = "0.1.0"
 abi = 0
-entrypoint = "hello.wasm"
+entrypoint = "plugin.wasm"
 
 [events]
-subscribe = ["file.uploaded"]
-"#,
+subscribe = {subscribe_toml}
+"#
+        ),
     )
     .unwrap();
-
     let manager = ExtismPluginManager::load_from_dir(cfg(), tmp.path());
+    (tmp, manager)
+}
+
+#[tokio::test]
+async fn manager_loads_and_dispatches_both_events() {
+    use crate::application::ports::plugin_ports::{
+        EVENT_FILE_UPLOADED, EVENT_USER_LOGIN, PluginDispatchPort, PluginEvent,
+    };
+
+    let (_tmp, manager) = manager_with("hello.wasm", r#"["file.uploaded", "user.login"]"#);
     assert_eq!(manager.loaded_count(), 1, "the valid plugin should load");
     assert!(manager.has_subscribers("file.uploaded"));
+    assert!(manager.has_subscribers("user.login"));
     assert!(!manager.has_subscribers("file.deleted"));
 
-    // Dispatch runs the plugin on the blocking pool; it must not panic or block.
-    manager.dispatch_file_uploaded(FileUploadedEvent {
-        path: "/a.txt".into(),
-        size: 3,
-        mime: "text/plain".into(),
+    // Both dispatches run the plugin on the blocking pool; neither may panic.
+    manager.dispatch(PluginEvent {
+        name: EVENT_FILE_UPLOADED,
         user_id: Some("u_test".into()),
-        invocation_id: "inv_dispatch".into(),
+        invocation_id: "inv_upload".into(),
+        payload: serde_json::json!({ "path": "/a.txt", "size": 3, "mime": "text/plain" }),
+    });
+    manager.dispatch(PluginEvent {
+        name: EVENT_USER_LOGIN,
+        user_id: Some("u_test".into()),
+        invocation_id: "inv_login".into(),
+        payload: serde_json::json!({ "user_id": "u_test", "first_login": false }),
     });
-    // Give the spawned task time to complete before the test runtime shuts down.
     tokio::time::sleep(Duration::from_millis(300)).await;
 }
 
+#[test]
+fn manager_rejects_plugin_missing_a_subscribed_export() {
+    // omit_login.wasm subscribes to user.login but doesn't export on_user_login.
+    let (_tmp, rejected) = manager_with("omit_login.wasm", r#"["user.login"]"#);
+    assert_eq!(rejected.loaded_count(), 0, "missing export -> not loaded");
+
+    // The same wasm is fine when it only claims an event it actually exports.
+    let (_tmp2, loaded) = manager_with("omit_login.wasm", r#"["file.uploaded"]"#);
+    assert_eq!(loaded.loaded_count(), 1);
+}
+
 // ---- Manifest validation (no wasm needed) -----------------------------------
 
 const VALID_MANIFEST: &str = r#"
@@ -182,6 +272,15 @@ fn manifest_accepts_valid() {
     assert_eq!(m.plugin.id, "com.example.hello");
 }
 
+#[test]
+fn manifest_accepts_user_login_and_combined() {
+    let login = VALID_MANIFEST.replace(r#"["file.uploaded"]"#, r#"["user.login"]"#);
+    assert!(manifest::parse_and_validate(&login).is_ok());
+
+    let both = VALID_MANIFEST.replace(r#"["file.uploaded"]"#, r#"["file.uploaded", "user.login"]"#);
+    assert!(manifest::parse_and_validate(&both).is_ok());
+}
+
 #[test]
 fn manifest_rejects_unknown_field() {
     let toml = format!("{VALID_MANIFEST}\nbogus_top_level = true\n");