test(coverage): batch 23 — 0% modules: socket models, encryption core, daemon, logging (tinyhumansai#530)

Add 32 new tests across 4 previously-untested modules:

- api/models/socket: ConnectionStatus serde (all 5 variants), SocketState
  default/roundtrip/skip-none, SocketMessage, McpRequest/Response/Error
- encryption/core: key derivation, encrypt/decrypt roundtrip (bytes + string),
  wrong-key rejection, salt randomness, nonce uniqueness, empty string,
  EncryptedPayload serde, KeyFile serde
- service/daemon: state_file_path with absolute and relative config paths
- core/logging: level_tag (all 5 levels), short_target, parse_log_file_constraints,
  CliLogDefault Debug/Eq

All 4345 tests pass.

Author: CodeGhost21

src/api/models/socket.rs

@@ -72,3 +72,147 @@ pub struct McpError {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub data: Option<serde_json::Value>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn connection_status_default_is_disconnected() {
+        assert_eq!(ConnectionStatus::default(), ConnectionStatus::Disconnected);
+    }
+
+    #[test]
+    fn connection_status_serde_roundtrip() {
+        for status in [
+            ConnectionStatus::Disconnected,
+            ConnectionStatus::Connecting,
+            ConnectionStatus::Connected,
+            ConnectionStatus::Reconnecting,
+            ConnectionStatus::Error,
+        ] {
+            let json = serde_json::to_string(&status).unwrap();
+            let back: ConnectionStatus = serde_json::from_str(&json).unwrap();
+            assert_eq!(back, status);
+        }
+    }
+
+    #[test]
+    fn connection_status_serializes_lowercase() {
+        assert_eq!(
+            serde_json::to_string(&ConnectionStatus::Connected).unwrap(),
+            "\"connected\""
+        );
+        assert_eq!(
+            serde_json::to_string(&ConnectionStatus::Reconnecting).unwrap(),
+            "\"reconnecting\""
+        );
+    }
+
+    #[test]
+    fn socket_state_default() {
+        let state = SocketState::default();
+        assert_eq!(state.status, ConnectionStatus::Disconnected);
+        assert!(state.socket_id.is_none());
+        assert!(state.error.is_none());
+    }
+
+    #[test]
+    fn socket_state_serde_roundtrip() {
+        let state = SocketState {
+            status: ConnectionStatus::Connected,
+            socket_id: Some("abc-123".into()),
+            error: None,
+        };
+        let json = serde_json::to_string(&state).unwrap();
+        let back: SocketState = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.status, ConnectionStatus::Connected);
+        assert_eq!(back.socket_id.as_deref(), Some("abc-123"));
+    }
+
+    #[test]
+    fn socket_state_skips_none_error_in_json() {
+        let state = SocketState::default();
+        let json = serde_json::to_string(&state).unwrap();
+        assert!(!json.contains("error"));
+    }
+
+    #[test]
+    fn socket_message_serde() {
+        let msg = SocketMessage {
+            event: "test".into(),
+            data: json!({"key": "val"}),
+        };
+        let json = serde_json::to_string(&msg).unwrap();
+        let back: SocketMessage = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.event, "test");
+        assert_eq!(back.data["key"], "val");
+    }
+
+    #[test]
+    fn mcp_request_serde() {
+        let req = McpRequest {
+            jsonrpc: "2.0".into(),
+            id: json!(1),
+            method: "test_method".into(),
+            params: Some(json!({"a": 1})),
+        };
+        let json = serde_json::to_string(&req).unwrap();
+        let back: McpRequest = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.method, "test_method");
+    }
+
+    #[test]
+    fn mcp_request_without_params() {
+        let req = McpRequest {
+            jsonrpc: "2.0".into(),
+            id: json!("req-1"),
+            method: "ping".into(),
+            params: None,
+        };
+        let json = serde_json::to_string(&req).unwrap();
+        assert!(!json.contains("params"));
+    }
+
+    #[test]
+    fn mcp_response_success() {
+        let resp = McpResponse {
+            jsonrpc: "2.0".into(),
+            id: json!(1),
+            result: Some(json!({"ok": true})),
+            error: None,
+        };
+        let json = serde_json::to_string(&resp).unwrap();
+        assert!(json.contains("result"));
+        assert!(!json.contains("error"));
+    }
+
+    #[test]
+    fn mcp_response_error() {
+        let resp = McpResponse {
+            jsonrpc: "2.0".into(),
+            id: json!(1),
+            result: None,
+            error: Some(McpError {
+                code: -32601,
+                message: "Method not found".into(),
+                data: None,
+            }),
+        };
+        let json = serde_json::to_string(&resp).unwrap();
+        assert!(json.contains("-32601"));
+        assert!(!json.contains("result"));
+    }
+
+    #[test]
+    fn mcp_error_with_data() {
+        let err = McpError {
+            code: -32600,
+            message: "Invalid Request".into(),
+            data: Some(json!({"detail": "missing method"})),
+        };
+        let json = serde_json::to_string(&err).unwrap();
+        assert!(json.contains("detail"));
+    }
+}

src/core/logging.rs

@@ -217,3 +217,54 @@ pub fn init_for_cli_run(verbose: bool, default_scope: CliLogDefault) {
         let _ = tracing_log::LogTracer::init();
     });
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn level_tag_maps_all_levels() {
+        assert_eq!(level_tag(&Level::ERROR), "ERR");
+        assert_eq!(level_tag(&Level::WARN), "WRN");
+        assert_eq!(level_tag(&Level::INFO), "INF");
+        assert_eq!(level_tag(&Level::DEBUG), "DBG");
+        assert_eq!(level_tag(&Level::TRACE), "TRC");
+    }
+
+    #[test]
+    fn short_target_strips_crate_prefix() {
+        assert_eq!(short_target("openhuman_core::rpc"), "rpc");
+        assert_eq!(short_target("openhuman_core::openhuman::memory"), "memory");
+    }
+
+    #[test]
+    fn short_target_passes_through_simple_names() {
+        assert_eq!(short_target("mymodule"), "mymodule");
+        assert_eq!(short_target(""), "");
+    }
+
+    #[test]
+    fn parse_log_file_constraints_empty_when_unset() {
+        // Remove the env var if it exists
+        let prev = std::env::var("OPENHUMAN_LOG_FILE_CONSTRAINTS").ok();
+        std::env::remove_var("OPENHUMAN_LOG_FILE_CONSTRAINTS");
+        let constraints = parse_log_file_constraints();
+        assert!(constraints.is_empty());
+        if let Some(v) = prev {
+            std::env::set_var("OPENHUMAN_LOG_FILE_CONSTRAINTS", v);
+        }
+    }
+
+    #[test]
+    fn cli_log_default_debug_impl() {
+        // Just verify Debug doesn't panic
+        let _ = format!("{:?}", CliLogDefault::Global);
+        let _ = format!("{:?}", CliLogDefault::AutocompleteOnly);
+    }
+
+    #[test]
+    fn cli_log_default_eq() {
+        assert_eq!(CliLogDefault::Global, CliLogDefault::Global);
+        assert_ne!(CliLogDefault::Global, CliLogDefault::AutocompleteOnly);
+    }
+}

src/openhuman/encryption/core.rs

@@ -180,3 +180,135 @@ pub async fn ai_decrypt(password: String, encrypted: String) -> Result<String, S
     let key = EncryptionKey::derive(&password, &key_file.salt)?;
     key.decrypt_string(&encrypted)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn generate_salt_has_correct_length() {
+        let salt = EncryptionKey::generate_salt();
+        assert_eq!(salt.len(), SALT_LENGTH);
+    }
+
+    #[test]
+    fn generate_salt_is_random() {
+        let s1 = EncryptionKey::generate_salt();
+        let s2 = EncryptionKey::generate_salt();
+        assert_ne!(s1, s2);
+    }
+
+    #[test]
+    fn derive_key_succeeds_with_valid_password() {
+        let salt = EncryptionKey::generate_salt();
+        let key = EncryptionKey::derive("test-password", &salt);
+        assert!(key.is_ok());
+    }
+
+    #[test]
+    fn encrypt_decrypt_roundtrip_bytes() {
+        let salt = EncryptionKey::generate_salt();
+        let key = EncryptionKey::derive("my-secret-password", &salt).unwrap();
+
+        let plaintext = b"Hello, World! This is a secret message.";
+        let payload = key.encrypt(plaintext).unwrap();
+
+        assert!(!payload.ciphertext.is_empty());
+        assert_eq!(payload.nonce.len(), NONCE_LENGTH);
+
+        let decrypted = key.decrypt(&payload).unwrap();
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn encrypt_decrypt_roundtrip_string() {
+        let salt = EncryptionKey::generate_salt();
+        let key = EncryptionKey::derive("password123", &salt).unwrap();
+
+        let original = "sensitive API key: sk-1234567890";
+        let encrypted = key.encrypt_string(original).unwrap();
+
+        assert!(!encrypted.is_empty());
+        assert_ne!(encrypted, original);
+
+        let decrypted = key.decrypt_string(&encrypted).unwrap();
+        assert_eq!(decrypted, original);
+    }
+
+    #[test]
+    fn decrypt_with_wrong_key_fails() {
+        let salt = EncryptionKey::generate_salt();
+        let key1 = EncryptionKey::derive("correct-password", &salt).unwrap();
+        let key2 = EncryptionKey::derive("wrong-password", &salt).unwrap();
+
+        let payload = key1.encrypt(b"secret data").unwrap();
+        let result = key2.decrypt(&payload);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn different_salts_produce_different_keys() {
+        let salt1 = EncryptionKey::generate_salt();
+        let salt2 = EncryptionKey::generate_salt();
+        let key1 = EncryptionKey::derive("same-password", &salt1).unwrap();
+        let key2 = EncryptionKey::derive("same-password", &salt2).unwrap();
+
+        let payload = key1.encrypt(b"test").unwrap();
+        // key2 has different salt, so it can't decrypt key1's payload
+        assert!(key2.decrypt(&payload).is_err());
+    }
+
+    #[test]
+    fn each_encryption_produces_different_ciphertext() {
+        let salt = EncryptionKey::generate_salt();
+        let key = EncryptionKey::derive("password", &salt).unwrap();
+
+        let payload1 = key.encrypt(b"same plaintext").unwrap();
+        let payload2 = key.encrypt(b"same plaintext").unwrap();
+
+        // Different nonces → different ciphertext
+        assert_ne!(payload1.ciphertext, payload2.ciphertext);
+        assert_ne!(payload1.nonce, payload2.nonce);
+    }
+
+    #[test]
+    fn encrypted_payload_serde_roundtrip() {
+        let salt = EncryptionKey::generate_salt();
+        let key = EncryptionKey::derive("pw", &salt).unwrap();
+        let payload = key.encrypt(b"data").unwrap();
+
+        let json = serde_json::to_string(&payload).unwrap();
+        let back: EncryptedPayload = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.ciphertext, payload.ciphertext);
+        assert_eq!(back.nonce, payload.nonce);
+    }
+
+    #[test]
+    fn decrypt_string_rejects_invalid_json() {
+        let salt = EncryptionKey::generate_salt();
+        let key = EncryptionKey::derive("pw", &salt).unwrap();
+        let result = key.decrypt_string("not-json");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn encrypt_empty_string() {
+        let salt = EncryptionKey::generate_salt();
+        let key = EncryptionKey::derive("pw", &salt).unwrap();
+        let encrypted = key.encrypt_string("").unwrap();
+        let decrypted = key.decrypt_string(&encrypted).unwrap();
+        assert_eq!(decrypted, "");
+    }
+
+    #[test]
+    fn key_file_serde_roundtrip() {
+        let kf = KeyFile {
+            salt: vec![1, 2, 3, 4],
+            version: 1,
+        };
+        let json = serde_json::to_string(&kf).unwrap();
+        let back: KeyFile = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.salt, vec![1, 2, 3, 4]);
+        assert_eq!(back.version, 1);
+    }
+}

src/openhuman/service/daemon.rs

@@ -9,3 +9,32 @@ pub fn state_file_path(config: &Config) -> PathBuf {
         .map_or_else(|| PathBuf::from("."), PathBuf::from)
         .join("daemon_state.json")
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn state_file_path_uses_config_parent() {
+        let config = Config {
+            config_path: PathBuf::from("/home/user/.openhuman/config.toml"),
+            ..Config::default()
+        };
+        let path = state_file_path(&config);
+        assert_eq!(
+            path,
+            PathBuf::from("/home/user/.openhuman/daemon_state.json")
+        );
+    }
+
+    #[test]
+    fn state_file_path_relative_config() {
+        let config = Config {
+            config_path: PathBuf::from("config.toml"),
+            ..Config::default()
+        };
+        let path = state_file_path(&config);
+        // "config.toml".parent() = "" which joins to "daemon_state.json"
+        assert!(path.to_str().unwrap().contains("daemon_state.json"));
+    }
+}