CodeGhost21
diff --git a/‎src/openhuman/config/schema/observability.rs‎
Lines changed: 63 additions & 0 deletions b/‎src/openhuman/config/schema/observability.rs‎
Lines changed: 63 additions & 0 deletions
diff --git a/‎src/openhuman/config/schemas.rs‎
Lines changed: 113 additions & 0 deletions b/‎src/openhuman/config/schemas.rs‎
Lines changed: 113 additions & 0 deletions
diff --git a/‎src/openhuman/cron/ops.rs‎
Lines changed: 142 additions & 0 deletions b/‎src/openhuman/cron/ops.rs‎
Lines changed: 142 additions & 0 deletions
@@ -41,3 +41,66 @@ 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_eq!(
+            back.sentry_dsn.as_deref(),
+            Some("https://token@sentry.io/1")
+        );
+        assert!(!back.analytics_enabled);
+    }
+}
@@ -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");
+    }
 }
@@ -448,4 +448,146 @@ mod tests {
         assert!(add_once(&config, "", "cmd").is_err());
         assert!(add_once(&config, "5x", "cmd").is_err());
     }
+
+    // ── add_once_at ─────────────────────────────────────────────────
+
+    #[test]
+    fn add_once_at_stores_exact_timestamp() {
+        let tmp = TempDir::new().unwrap();
+        let config = test_config(&tmp);
+        let when = chrono::Utc::now() + chrono::Duration::hours(1);
+        let job = add_once_at(&config, when, "echo hi").unwrap();
+        match job.schedule {
+            Schedule::At { at } => assert_eq!(at, when),
+            other => panic!("expected At schedule, got {other:?}"),
+        }
+    }
+
+    // ── pause_job / resume_job ──────────────────────────────────────
+
+    #[test]
+    fn pause_and_resume_toggle_enabled_flag() {
+        let tmp = TempDir::new().unwrap();
+        let config = test_config(&tmp);
+        let job = make_job(&config, "*/5 * * * *", None, "echo test");
+        assert!(job.enabled);
+
+        let paused = pause_job(&config, &job.id).unwrap();
+        assert!(!paused.enabled);
+
+        let resumed = resume_job(&config, &job.id).unwrap();
+        assert!(resumed.enabled);
+    }
+
+    // ── cron_list / cron_update / cron_remove / cron_runs ───────────
+
+    fn disabled_cron_config(tmp: &TempDir) -> Config {
+        let mut config = test_config(tmp);
+        config.cron.enabled = false;
+        config
+    }
+
+    #[tokio::test]
+    async fn cron_list_errors_when_cron_disabled() {
+        let tmp = TempDir::new().unwrap();
+        let config = disabled_cron_config(&tmp);
+        let err = cron_list(&config).await.unwrap_err();
+        assert!(err.contains("cron is disabled"));
+    }
+
+    #[tokio::test]
+    async fn cron_list_returns_jobs_when_enabled() {
+        let tmp = TempDir::new().unwrap();
+        let config = test_config(&tmp);
+        let job = make_job(&config, "*/5 * * * *", None, "echo test");
+        let out = cron_list(&config).await.unwrap();
+        assert!(out.value.iter().any(|j| j.id == job.id));
+        assert!(out.logs.iter().any(|l| l.contains("cron jobs listed")));
+    }
+
+    #[tokio::test]
+    async fn cron_update_rejects_empty_job_id() {
+        let tmp = TempDir::new().unwrap();
+        let config = test_config(&tmp);
+        let err = cron_update(&config, "   ", CronJobPatch::default())
+            .await
+            .unwrap_err();
+        assert!(err.contains("Missing 'job_id'"));
+    }
+
+    #[tokio::test]
+    async fn cron_update_errors_when_cron_disabled() {
+        let tmp = TempDir::new().unwrap();
+        let config = disabled_cron_config(&tmp);
+        let err = cron_update(&config, "some-id", CronJobPatch::default())
+            .await
+            .unwrap_err();
+        assert!(err.contains("cron is disabled"));
+    }
+
+    #[tokio::test]
+    async fn cron_update_mutates_existing_job() {
+        let tmp = TempDir::new().unwrap();
+        let config = test_config(&tmp);
+        let job = make_job(&config, "*/5 * * * *", None, "echo test");
+        let patch = CronJobPatch {
+            name: Some("renamed".to_string()),
+            ..CronJobPatch::default()
+        };
+        let out = cron_update(&config, &job.id, patch).await.unwrap();
+        assert_eq!(out.value.name.as_deref(), Some("renamed"));
+        assert!(out.logs.iter().any(|l| l.contains("cron job updated")));
+    }
+
+    #[tokio::test]
+    async fn cron_remove_rejects_empty_job_id() {
+        let tmp = TempDir::new().unwrap();
+        let config = test_config(&tmp);
+        let err = cron_remove(&config, "").await.unwrap_err();
+        assert!(err.contains("Missing 'job_id'"));
+    }
+
+    #[tokio::test]
+    async fn cron_remove_errors_when_cron_disabled() {
+        let tmp = TempDir::new().unwrap();
+        let config = disabled_cron_config(&tmp);
+        let err = cron_remove(&config, "abc").await.unwrap_err();
+        assert!(err.contains("cron is disabled"));
+    }
+
+    #[tokio::test]
+    async fn cron_remove_returns_removed_true_on_success() {
+        let tmp = TempDir::new().unwrap();
+        let config = test_config(&tmp);
+        let job = make_job(&config, "*/5 * * * *", None, "echo test");
+        let out = cron_remove(&config, &job.id).await.unwrap();
+        assert_eq!(out.value["job_id"], json!(job.id));
+        assert_eq!(out.value["removed"], json!(true));
+    }
+
+    #[tokio::test]
+    async fn cron_runs_rejects_empty_job_id() {
+        let tmp = TempDir::new().unwrap();
+        let config = test_config(&tmp);
+        let err = cron_runs(&config, "", None).await.unwrap_err();
+        assert!(err.contains("Missing 'job_id'"));
+    }
+
+    #[tokio::test]
+    async fn cron_runs_errors_when_cron_disabled() {
+        let tmp = TempDir::new().unwrap();
+        let config = disabled_cron_config(&tmp);
+        let err = cron_runs(&config, "abc", Some(5)).await.unwrap_err();
+        assert!(err.contains("cron is disabled"));
+    }
+
+    #[tokio::test]
+    async fn cron_runs_returns_empty_history_for_new_job() {
+        let tmp = TempDir::new().unwrap();
+        let config = test_config(&tmp);
+        let job = make_job(&config, "*/5 * * * *", None, "echo test");
+        let out = cron_runs(&config, &job.id, Some(10)).await.unwrap();
+        assert!(out.value.is_empty());
+        assert!(out.logs.iter().any(|l| l.contains("cron run history")));
+    }
 }