test(coverage): batch 5.6 — local_ai/sentiment, migration/schemas, referral/schemas

- local_ai/sentiment.rs: 68.03% (negative-confidence clamp to zero, unknown valence fallback, all documented emotion/valence labels accepted, neutral() constructor invariants, empty-message early return)
- migration/schemas.rs: 36.73% (controller registry parity, openclaw input shape, MigrateOpenClawParams defaults + round-trip, unknown function placeholder, to_json wrapping)
- referral/schemas.rs: 37.18% (controller registry parity, claim input required/optional mapping, ReferralClaimParams camelCase alias + missing-code rejection, json_output + to_json helpers)

25 new deterministic tests. Refs tinyhumansai#530.

Author: CodeGhost21

src/openhuman/local_ai/sentiment.rs

@@ -197,4 +197,53 @@ mod tests {
         assert_eq!(r.emotion, "neutral");
         assert_eq!(r.valence, "neutral");
     }
+
+    #[test]
+    fn parse_clamps_negative_confidence_to_zero() {
+        let r = parse_sentiment_response("joy positive -0.5");
+        assert!(r.confidence >= 0.0 && r.confidence <= 1.0);
+        assert!((r.confidence - 0.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn parse_unknown_valence_falls_back_to_neutral() {
+        let r = parse_sentiment_response("joy mixed 0.8");
+        assert_eq!(r.emotion, "joy");
+        assert_eq!(r.valence, "neutral");
+    }
+
+    #[test]
+    fn parse_accepts_all_documented_emotions() {
+        for e in [
+            "joy", "sadness", "anger", "surprise", "fear", "disgust", "neutral",
+        ] {
+            let r = parse_sentiment_response(&format!("{e} positive 0.5"));
+            assert_eq!(r.emotion, e, "emotion `{e}` should be accepted verbatim");
+        }
+    }
+
+    #[test]
+    fn parse_accepts_all_documented_valences() {
+        for v in ["positive", "negative", "neutral"] {
+            let r = parse_sentiment_response(&format!("joy {v} 0.5"));
+            assert_eq!(r.valence, v, "valence `{v}` should be accepted verbatim");
+        }
+    }
+
+    #[test]
+    fn neutral_constructor_returns_documented_defaults() {
+        let r = SentimentResult::neutral();
+        assert_eq!(r.emotion, "neutral");
+        assert_eq!(r.valence, "neutral");
+        assert!((r.confidence - 1.0).abs() < 0.01);
+    }
+
+    #[tokio::test]
+    async fn local_ai_analyze_sentiment_returns_neutral_for_empty_message() {
+        let config = Config::default();
+        let outcome = local_ai_analyze_sentiment(&config, "   ").await.unwrap();
+        assert_eq!(outcome.value.emotion, "neutral");
+        assert_eq!(outcome.value.valence, "neutral");
+        assert!(outcome.logs.iter().any(|l| l.contains("empty message")));
+    }
 }

src/openhuman/migration/schemas.rs

@@ -85,3 +85,71 @@ fn handle_migrate_openclaw(params: Map<String, Value>) -> ControllerFuture {
 fn to_json<T: serde::Serialize>(outcome: RpcOutcome<T>) -> Result<Value, String> {
     outcome.into_cli_compatible_json()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn all_controller_schemas_advertises_openclaw_only() {
+        let names: Vec<_> = all_controller_schemas()
+            .into_iter()
+            .map(|s| s.function)
+            .collect();
+        assert_eq!(names, vec!["openclaw"]);
+    }
+
+    #[test]
+    fn all_registered_controllers_has_one_handler() {
+        let ctrl = all_registered_controllers();
+        assert_eq!(ctrl.len(), 1);
+        assert_eq!(ctrl[0].schema.function, "openclaw");
+    }
+
+    #[test]
+    fn openclaw_schema_describes_optional_source_and_dry_run() {
+        let s = schemas("openclaw");
+        assert_eq!(s.namespace, "migrate");
+        assert_eq!(s.function, "openclaw");
+        let names: Vec<_> = s.inputs.iter().map(|f| f.name).collect();
+        assert!(names.contains(&"source_workspace"));
+        assert!(names.contains(&"dry_run"));
+        for f in &s.inputs {
+            assert!(!f.required, "input `{}` must be optional", f.name);
+        }
+        assert_eq!(s.outputs[0].name, "report");
+    }
+
+    #[test]
+    fn unknown_function_returns_unknown_placeholder() {
+        let s = schemas("bogus");
+        assert_eq!(s.function, "unknown");
+        assert_eq!(s.namespace, "migrate");
+        assert_eq!(s.outputs[0].name, "error");
+    }
+
+    #[test]
+    fn migrate_openclaw_params_tolerates_empty_object() {
+        let params: MigrateOpenClawParams = serde_json::from_value(json!({})).unwrap();
+        assert!(params.source_workspace.is_none());
+        assert!(params.dry_run.is_none());
+    }
+
+    #[test]
+    fn migrate_openclaw_params_parses_both_fields() {
+        let params: MigrateOpenClawParams = serde_json::from_value(json!({
+            "source_workspace": "/tmp/old",
+            "dry_run": false
+        }))
+        .unwrap();
+        assert_eq!(params.source_workspace.as_deref(), Some("/tmp/old"));
+        assert_eq!(params.dry_run, Some(false));
+    }
+
+    #[test]
+    fn to_json_wraps_rpc_outcome_result_envelope() {
+        let v = to_json(RpcOutcome::single_log(json!({"done": true}), "done")).unwrap();
+        assert!(v.get("logs").is_some() || v.get("result").is_some());
+    }
+}

src/openhuman/referral/schemas.rs

@@ -123,3 +123,98 @@ fn json_output(name: &'static str, comment: &'static str) -> FieldSchema {
         required: true,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn all_referral_controller_schemas_advertises_stats_and_claim() {
+        let names: Vec<_> = all_referral_controller_schemas()
+            .into_iter()
+            .map(|s| s.function)
+            .collect();
+        assert_eq!(names, vec!["get_stats", "claim"]);
+    }
+
+    #[test]
+    fn all_referral_registered_controllers_matches_schema_count() {
+        assert_eq!(
+            all_referral_registered_controllers().len(),
+            all_referral_controller_schemas().len()
+        );
+    }
+
+    #[test]
+    fn get_stats_schema_has_no_inputs_and_required_output() {
+        let s = referral_schemas("referral_get_stats");
+        assert_eq!(s.namespace, "referral");
+        assert!(s.inputs.is_empty());
+        assert!(s.outputs.iter().all(|f| f.required));
+    }
+
+    #[test]
+    fn claim_schema_requires_code_and_has_optional_fingerprint() {
+        let s = referral_schemas("referral_claim");
+        let code = s.inputs.iter().find(|f| f.name == "code").unwrap();
+        assert!(code.required);
+        let fp = s
+            .inputs
+            .iter()
+            .find(|f| f.name == "deviceFingerprint")
+            .unwrap();
+        assert!(!fp.required);
+    }
+
+    #[test]
+    fn unknown_function_returns_unknown_placeholder() {
+        let s = referral_schemas("no_such");
+        assert_eq!(s.function, "unknown");
+        assert_eq!(s.namespace, "referral");
+    }
+
+    #[test]
+    fn claim_params_parse_camel_case_device_fingerprint() {
+        let p: ReferralClaimParams = serde_json::from_value(json!({
+            "code": "ABC123",
+            "deviceFingerprint": "fp-xyz"
+        }))
+        .unwrap();
+        assert_eq!(p.code, "ABC123");
+        assert_eq!(p.device_fingerprint.as_deref(), Some("fp-xyz"));
+    }
+
+    #[test]
+    fn claim_params_tolerate_missing_device_fingerprint() {
+        let p: ReferralClaimParams = serde_json::from_value(json!({"code": "ABC"})).unwrap();
+        assert!(p.device_fingerprint.is_none());
+    }
+
+    #[test]
+    fn claim_params_require_code() {
+        let err = serde_json::from_value::<ReferralClaimParams>(json!({})).unwrap_err();
+        assert!(err.to_string().contains("code"));
+    }
+
+    #[test]
+    fn deserialize_params_reports_invalid_params_prefix_on_bad_types() {
+        let mut m = Map::new();
+        m.insert("code".into(), json!(42));
+        let err = deserialize_params::<ReferralClaimParams>(m).unwrap_err();
+        assert!(err.starts_with("invalid params"));
+    }
+
+    #[test]
+    fn json_output_builds_required_json_field() {
+        let f = json_output("x", "c");
+        assert!(f.required);
+        assert!(matches!(f.ty, TypeSchema::Json));
+    }
+
+    #[test]
+    fn to_json_wraps_result_and_logs() {
+        let v = to_json(RpcOutcome::single_log(json!({"ok": true}), "log")).unwrap();
+        assert!(v.get("result").is_some() || v.get("logs").is_some());
+    }
+}