test(coverage): batch 5.4 — config/{schemas, schema/observability}

- config/schemas.rs: 52.37% (adds required_string / optional_string / optional_bool field builder coverage, exercises deserialize_params across ModelSettings / MemorySettings / WorkspaceOnboarding / SetBrowserAllowAll / OnboardingCompleted params, pins DEFAULT_ONBOARDING_FLAG_NAME constant)
- config/schema/observability.rs: 66.67% (default-values invariant, serde defaults for optional fields, explicit analytics flag, round-trip)

16 new deterministic tests. Refs tinyhumansai#530.

Author: CodeGhost21

src/openhuman/config/schema/observability.rs

@@ -41,3 +41,63 @@ impl Default for ObservabilityConfig {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn default_disables_backend_and_enables_analytics() {
+        let cfg = ObservabilityConfig::default();
+        assert_eq!(cfg.backend, "none");
+        assert!(cfg.otel_endpoint.is_none());
+        assert!(cfg.otel_service_name.is_none());
+        assert!(cfg.sentry_dsn.is_none());
+        assert!(cfg.analytics_enabled);
+    }
+
+    #[test]
+    fn default_analytics_enabled_helper_returns_true() {
+        assert!(default_analytics_enabled());
+    }
+
+    #[test]
+    fn deserialize_missing_optional_fields_uses_defaults() {
+        let cfg: ObservabilityConfig = serde_json::from_value(json!({
+            "backend": "log"
+        }))
+        .unwrap();
+        assert_eq!(cfg.backend, "log");
+        assert!(cfg.otel_endpoint.is_none());
+        assert!(cfg.analytics_enabled, "analytics default must be true");
+    }
+
+    #[test]
+    fn deserialize_respects_explicit_analytics_flag() {
+        let cfg: ObservabilityConfig = serde_json::from_value(json!({
+            "backend": "otel",
+            "analytics_enabled": false
+        }))
+        .unwrap();
+        assert!(!cfg.analytics_enabled);
+    }
+
+    #[test]
+    fn round_trip_preserves_all_fields() {
+        let original = ObservabilityConfig {
+            backend: "otel".into(),
+            otel_endpoint: Some("http://localhost:4318".into()),
+            otel_service_name: Some("openhuman-test".into()),
+            sentry_dsn: Some("https://token@sentry.io/1".into()),
+            analytics_enabled: false,
+        };
+        let s = serde_json::to_string(&original).unwrap();
+        let back: ObservabilityConfig = serde_json::from_str(&s).unwrap();
+        assert_eq!(back.backend, "otel");
+        assert_eq!(back.otel_endpoint.as_deref(), Some("http://localhost:4318"));
+        assert_eq!(back.otel_service_name.as_deref(), Some("openhuman-test"));
+        assert!(back.sentry_dsn.is_some());
+        assert!(!back.analytics_enabled);
+    }
+}

src/openhuman/config/schemas.rs

@@ -870,4 +870,117 @@ mod tests {
             .expect("serialize");
         assert!(v.get("logs").is_some() || v.get("result").is_some());
     }
+
+    // ── Field builder helpers ────────────────────────────────────
+
+    #[test]
+    fn required_string_builds_required_string_field() {
+        let f = required_string("api_key", "Auth key");
+        assert_eq!(f.name, "api_key");
+        assert_eq!(f.comment, "Auth key");
+        assert!(f.required);
+        assert!(matches!(f.ty, TypeSchema::String));
+    }
+
+    #[test]
+    fn optional_string_builds_option_string_field() {
+        let f = optional_string("model", "model name");
+        assert!(!f.required);
+        match &f.ty {
+            TypeSchema::Option(inner) => assert!(matches!(**inner, TypeSchema::String)),
+            other => panic!("expected Option<String>, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn optional_bool_builds_option_bool_field() {
+        let f = optional_bool("enabled", "Whether enabled");
+        assert!(!f.required);
+        match &f.ty {
+            TypeSchema::Option(inner) => assert!(matches!(**inner, TypeSchema::Bool)),
+            other => panic!("expected Option<Bool>, got {other:?}"),
+        }
+    }
+
+    // ── deserialize_params helper ────────────────────────────────
+
+    #[test]
+    fn deserialize_params_parses_model_settings_update() {
+        let mut m = Map::new();
+        m.insert("api_key".into(), Value::String("sk-123".into()));
+        m.insert(
+            "default_temperature".into(),
+            Value::Number(serde_json::Number::from_f64(0.7).unwrap()),
+        );
+        let out: ModelSettingsUpdate = deserialize_params(m).unwrap();
+        assert_eq!(out.api_key.as_deref(), Some("sk-123"));
+        assert_eq!(out.default_temperature, Some(0.7));
+        assert!(out.api_url.is_none());
+        assert!(out.default_model.is_none());
+    }
+
+    #[test]
+    fn deserialize_params_parses_memory_settings_update() {
+        let mut m = Map::new();
+        m.insert("backend".into(), Value::String("sqlite".into()));
+        m.insert("auto_save".into(), Value::Bool(true));
+        m.insert(
+            "embedding_dimensions".into(),
+            Value::Number(serde_json::Number::from(1536)),
+        );
+        let out: MemorySettingsUpdate = deserialize_params(m).unwrap();
+        assert_eq!(out.backend.as_deref(), Some("sqlite"));
+        assert_eq!(out.auto_save, Some(true));
+        assert_eq!(out.embedding_dimensions, Some(1536));
+    }
+
+    #[test]
+    fn deserialize_params_parses_workspace_onboarding_flag_params() {
+        let out: WorkspaceOnboardingFlagParams = deserialize_params(Map::new()).unwrap();
+        assert!(out.flag_name.is_none());
+
+        let mut m = Map::new();
+        m.insert("flag_name".into(), Value::String(".custom_marker".into()));
+        let out: WorkspaceOnboardingFlagParams = deserialize_params(m).unwrap();
+        assert_eq!(out.flag_name.as_deref(), Some(".custom_marker"));
+    }
+
+    #[test]
+    fn deserialize_params_parses_workspace_onboarding_flag_set_params() {
+        let mut m = Map::new();
+        m.insert("value".into(), Value::Bool(true));
+        let out: WorkspaceOnboardingFlagSetParams = deserialize_params(m).unwrap();
+        assert_eq!(out.value, true);
+        assert!(out.flag_name.is_none());
+    }
+
+    #[test]
+    fn deserialize_params_rejects_wrong_types_with_invalid_params_prefix() {
+        let mut m = Map::new();
+        m.insert(
+            "default_temperature".into(),
+            Value::String("not-a-number".into()),
+        );
+        let err = deserialize_params::<ModelSettingsUpdate>(m).unwrap_err();
+        assert!(err.starts_with("invalid params"));
+    }
+
+    #[test]
+    fn deserialize_params_requires_value_on_set_onboarding() {
+        let err = deserialize_params::<OnboardingCompletedSetParams>(Map::new()).unwrap_err();
+        assert!(err.contains("invalid params"));
+    }
+
+    #[test]
+    fn deserialize_params_rejects_missing_required_for_set_browser_allow_all() {
+        let err = deserialize_params::<SetBrowserAllowAllParams>(Map::new()).unwrap_err();
+        assert!(err.contains("invalid params"));
+    }
+
+    #[test]
+    fn default_onboarding_flag_constant_points_to_hidden_marker() {
+        // Keeps the constant's observable value pinned so tool behavior
+        // stays stable across refactors.
+        assert_eq!(DEFAULT_ONBOARDING_FLAG_NAME, ".skip_onboarding");
+    }
 }