test(coverage): batch 11–12 — channels schemas, conversation store (tinyhumansai#530)

Add 33 new tests:
- channels/controllers/schemas: per-function input validation, param
  deserialization, helper coverage
- memory/conversations/store: thread lifecycle (create, delete, idempotent),
  multi-thread, empty/nonexistent thread, purge empty store

All 4060 tests pass.

Author: CodeGhost21

src/openhuman/channels/controllers/schemas.rs

@@ -676,6 +676,7 @@ fn to_json<T: serde::Serialize>(outcome: RpcOutcome<T>) -> Result<Value, String>
 #[cfg(test)]
 mod tests {
     use super::*;
+    use serde_json::json;
 
     #[test]
     fn schema_handler_parity() {
@@ -781,4 +782,229 @@ mod tests {
         // schema must still exist with outputs.
         assert!(!s.outputs.is_empty());
     }
+
+    #[test]
+    fn connect_schema_requires_channel_auth_mode() {
+        let s = schemas("connect");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"channel"));
+        assert!(required.contains(&"authMode"));
+    }
+
+    #[test]
+    fn disconnect_schema_requires_channel_auth_mode() {
+        let s = schemas("disconnect");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"channel"));
+        assert!(required.contains(&"authMode"));
+    }
+
+    #[test]
+    fn status_schema_has_optional_channel() {
+        let s = schemas("status");
+        let chan = s.inputs.iter().find(|f| f.name == "channel");
+        assert!(chan.is_some_and(|f| !f.required));
+    }
+
+    #[test]
+    fn test_schema_requires_channel_auth_mode_credentials() {
+        let s = schemas("test");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"channel"));
+        assert!(required.contains(&"authMode"));
+        assert!(required.contains(&"credentials"));
+    }
+
+    #[test]
+    fn list_schema_has_no_inputs() {
+        let s = schemas("list");
+        assert!(s.inputs.is_empty());
+    }
+
+    #[test]
+    fn discord_link_start_schema() {
+        let s = schemas("discord_link_start");
+        assert_eq!(s.namespace, "channels");
+        assert_eq!(s.function, "discord_link_start");
+    }
+
+    #[test]
+    fn discord_link_check_requires_link_token() {
+        let s = schemas("discord_link_check");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"linkToken"));
+    }
+
+    #[test]
+    fn discord_list_channels_requires_guild_id() {
+        let s = schemas("discord_list_channels");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"guildId"));
+    }
+
+    #[test]
+    fn discord_check_permissions_requires_guild_and_channel() {
+        let s = schemas("discord_check_permissions");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"guildId"));
+        assert!(required.contains(&"channelId"));
+    }
+
+    #[test]
+    fn send_reaction_requires_channel_and_reaction() {
+        let s = schemas("send_reaction");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"channel"));
+        assert!(required.contains(&"reaction"));
+    }
+
+    #[test]
+    fn create_thread_requires_channel_and_title() {
+        let s = schemas("create_thread");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"channel"));
+        assert!(required.contains(&"title"));
+    }
+
+    #[test]
+    fn update_thread_requires_channel_thread_id_action() {
+        let s = schemas("update_thread");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"channel"));
+        assert!(required.contains(&"threadId"));
+        assert!(required.contains(&"action"));
+    }
+
+    #[test]
+    fn list_threads_requires_channel() {
+        let s = schemas("list_threads");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"channel"));
+    }
+
+    #[test]
+    fn telegram_login_start_schema_has_no_inputs() {
+        let s = schemas("telegram_login_start");
+        assert!(s.inputs.is_empty());
+    }
+
+    #[test]
+    fn deserialize_connect_params() {
+        let params: ConnectParams = serde_json::from_value(json!({
+            "channel": "telegram",
+            "authMode": "bot_token"
+        }))
+        .unwrap();
+        assert_eq!(params.channel, "telegram");
+        assert_eq!(params.auth_mode, "bot_token");
+        assert!(params.credentials.is_none());
+    }
+
+    #[test]
+    fn deserialize_disconnect_params() {
+        let params: DisconnectParams = serde_json::from_value(json!({
+            "channel": "discord",
+            "authMode": "bot_token"
+        }))
+        .unwrap();
+        assert_eq!(params.channel, "discord");
+    }
+
+    #[test]
+    fn deserialize_status_params_empty() {
+        let params: StatusParams = serde_json::from_value(json!({})).unwrap();
+        assert!(params.channel.is_none());
+    }
+
+    #[test]
+    fn deserialize_status_params_with_channel() {
+        let params: StatusParams = serde_json::from_value(json!({"channel": "telegram"})).unwrap();
+        assert_eq!(params.channel.as_deref(), Some("telegram"));
+    }
+
+    #[test]
+    fn deserialize_send_message_params() {
+        let params: SendMessageParams = serde_json::from_value(json!({
+            "channel": "telegram",
+            "message": {"text": "hello"}
+        }))
+        .unwrap();
+        assert_eq!(params.channel, "telegram");
+    }
+
+    #[test]
+    fn to_json_helper() {
+        let outcome = RpcOutcome::single_log(json!({"ok": true}), "log");
+        assert!(to_json(outcome).is_ok());
+    }
+
+    #[test]
+    fn required_string_helper() {
+        let f = required_string("channel", "channel name");
+        assert!(f.required);
+        assert!(matches!(f.ty, TypeSchema::String));
+    }
+
+    #[test]
+    fn optional_string_helper() {
+        let f = optional_string("auth_mode", "auth");
+        assert!(!f.required);
+    }
+
+    #[test]
+    fn json_output_helper() {
+        let f = json_output("result", "the result");
+        assert!(f.required);
+        assert!(matches!(f.ty, TypeSchema::Json));
+    }
 }

src/openhuman/memory/conversations/store.rs

@@ -554,4 +554,148 @@ mod tests {
         assert_eq!(stats.message_count, 1);
         assert!(store.list_threads().expect("list threads").is_empty());
     }
+
+    #[test]
+    fn ensure_thread_is_idempotent() {
+        let (_temp, store) = make_store();
+        let req = CreateConversationThread {
+            id: "t1".to_string(),
+            title: "Thread".to_string(),
+            created_at: "2026-04-10T12:00:00Z".to_string(),
+        };
+        store.ensure_thread(req.clone()).unwrap();
+        store.ensure_thread(req).unwrap();
+        let threads = store.list_threads().unwrap();
+        assert_eq!(threads.len(), 1);
+    }
+
+    #[test]
+    fn delete_thread_removes_thread_and_messages() {
+        let (_temp, store) = make_store();
+        store
+            .ensure_thread(CreateConversationThread {
+                id: "t1".to_string(),
+                title: "Thread".to_string(),
+                created_at: "2026-04-10T12:00:00Z".to_string(),
+            })
+            .unwrap();
+        store
+            .append_message(
+                "t1",
+                ConversationMessage {
+                    id: "m1".to_string(),
+                    content: "msg".to_string(),
+                    message_type: "text".to_string(),
+                    extra_metadata: json!({}),
+                    sender: "user".to_string(),
+                    created_at: "2026-04-10T12:01:00Z".to_string(),
+                },
+            )
+            .unwrap();
+        store.delete_thread("t1", "2026-04-10T12:02:00Z").unwrap();
+        let threads = store.list_threads().unwrap();
+        assert!(threads.is_empty());
+    }
+
+    #[test]
+    fn delete_nonexistent_thread_is_ok() {
+        let (_temp, store) = make_store();
+        // Should not error
+        store
+            .delete_thread("nonexistent", "2026-04-10T12:00:00Z")
+            .unwrap();
+    }
+
+    #[test]
+    fn get_messages_empty_thread() {
+        let (_temp, store) = make_store();
+        store
+            .ensure_thread(CreateConversationThread {
+                id: "t1".to_string(),
+                title: "Empty".to_string(),
+                created_at: "2026-04-10T12:00:00Z".to_string(),
+            })
+            .unwrap();
+        let messages = store.get_messages("t1").unwrap();
+        assert!(messages.is_empty());
+    }
+
+    #[test]
+    fn get_messages_nonexistent_thread() {
+        let (_temp, store) = make_store();
+        let messages = store.get_messages("nonexistent").unwrap();
+        assert!(messages.is_empty());
+    }
+
+    #[test]
+    fn multiple_threads_and_messages() {
+        let (_temp, store) = make_store();
+        for i in 0..3 {
+            store
+                .ensure_thread(CreateConversationThread {
+                    id: format!("t{i}"),
+                    title: format!("Thread {i}"),
+                    created_at: format!("2026-04-10T12:0{i}:00Z"),
+                })
+                .unwrap();
+            store
+                .append_message(
+                    &format!("t{i}"),
+                    ConversationMessage {
+                        id: format!("m{i}"),
+                        content: format!("msg {i}"),
+                        message_type: "text".to_string(),
+                        extra_metadata: json!({}),
+                        sender: "user".to_string(),
+                        created_at: format!("2026-04-10T12:0{i}:30Z"),
+                    },
+                )
+                .unwrap();
+        }
+        let threads = store.list_threads().unwrap();
+        assert_eq!(threads.len(), 3);
+    }
+
+    #[test]
+    fn purge_on_empty_store() {
+        let (_temp, store) = make_store();
+        let stats = store.purge_threads().unwrap();
+        assert_eq!(stats.thread_count, 0);
+        assert_eq!(stats.message_count, 0);
+    }
+
+    #[test]
+    fn update_message_nonexistent_returns_error() {
+        let (_temp, store) = make_store();
+        store
+            .ensure_thread(CreateConversationThread {
+                id: "t1".to_string(),
+                title: "Thread".to_string(),
+                created_at: "2026-04-10T12:00:00Z".to_string(),
+            })
+            .unwrap();
+        let result = store.update_message(
+            "t1",
+            "nonexistent",
+            ConversationMessagePatch {
+                extra_metadata: Some(json!({})),
+            },
+        );
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn conversation_store_new() {
+        let tmp = TempDir::new().unwrap();
+        let store = ConversationStore::new(tmp.path().to_path_buf());
+        let threads = store.list_threads().unwrap();
+        assert!(threads.is_empty());
+    }
+
+    #[test]
+    fn conversation_purge_stats_default() {
+        let stats = ConversationPurgeStats::default();
+        assert_eq!(stats.thread_count, 0);
+        assert_eq!(stats.message_count, 0);
+    }
 }