style: cargo fmt cleanup in coverage test modules

Auto-fixes from `cargo fmt` on test code added in batches 4.1–4.3.
No behavioral changes.

Author: CodeGhost21

src/openhuman/migration/ops.rs

@@ -42,7 +42,10 @@ mod tests {
         match result {
             Ok(outcome) => {
                 assert!(
-                    outcome.logs.iter().any(|l| l.contains("migration completed")),
+                    outcome
+                        .logs
+                        .iter()
+                        .any(|l| l.contains("migration completed")),
                     "expected 'migration completed' log, got logs: {:?}",
                     outcome.logs
                 );

src/openhuman/referral/ops.rs

@@ -199,9 +199,7 @@ mod tests {
     async fn claim_referral_posts_trimmed_code_and_drops_whitespace_fingerprint() {
         let app = Router::new().route(
             "/referral/claim",
-            post(|Json(body): Json<Value>| async move {
-                Json(json!({ "echoed": body }))
-            }),
+            post(|Json(body): Json<Value>| async move { Json(json!({ "echoed": body })) }),
         );
         let base = spawn_mock(app).await;
         let tmp = TempDir::new().unwrap();
@@ -226,9 +224,7 @@ mod tests {
     async fn claim_referral_forwards_non_empty_device_fingerprint_trimmed() {
         let app = Router::new().route(
             "/referral/claim",
-            post(|Json(body): Json<Value>| async move {
-                Json(json!({ "echoed": body }))
-            }),
+            post(|Json(body): Json<Value>| async move { Json(json!({ "echoed": body })) }),
         );
         let base = spawn_mock(app).await;
         let tmp = TempDir::new().unwrap();

src/openhuman/service/ops.rs

@@ -102,7 +102,10 @@ mod tests {
         // No assertion on `show_tray` value — defaults vary by build.
         // The contract under test is that the function returns Ok with
         // the canonical log line and a deterministic struct shape.
-        assert!(out.logs.iter().any(|l| l.contains("daemon host config loaded")));
+        assert!(out
+            .logs
+            .iter()
+            .any(|l| l.contains("daemon host config loaded")));
         let _ = out.value.show_tray;
     }
 
@@ -121,7 +124,10 @@ mod tests {
             .any(|l| l.contains("daemon host config saved")));
 
         let loaded = daemon_host_get(&config).await.unwrap();
-        assert!(!loaded.value.show_tray, "set→get round-trip must observe the persisted value");
+        assert!(
+            !loaded.value.show_tray,
+            "set→get round-trip must observe the persisted value"
+        );
 
         // Flip it back and confirm the toggle round-trips too.
         let saved = daemon_host_set(&config, true).await.unwrap();

src/openhuman/text_input/types.rs

@@ -172,7 +172,8 @@ mod tests {
         // key keep working) and preserve the None round-trip.
         let parsed: ReadFieldParams = serde_json::from_value(json!({})).unwrap();
         assert!(parsed.include_bounds.is_none());
-        let parsed: ReadFieldParams = serde_json::from_value(json!({"include_bounds": true})).unwrap();
+        let parsed: ReadFieldParams =
+            serde_json::from_value(json!({"include_bounds": true})).unwrap();
         assert_eq!(parsed.include_bounds, Some(true));
     }
 

src/openhuman/update/ops.rs

@@ -142,8 +142,8 @@ mod tests {
 
     #[test]
     fn validate_download_url_rejects_non_https_schemes() {
-        let err =
-            validate_download_url("http://github.com/owner/repo/releases/download/v1/x").unwrap_err();
+        let err = validate_download_url("http://github.com/owner/repo/releases/download/v1/x")
+            .unwrap_err();
         assert!(err.contains("must use HTTPS"), "got: {err}");
     }
 

src/openhuman/voice/postprocess.rs

@@ -309,9 +309,7 @@ mod tests {
             .unwrap_or_else(|p| p.into_inner());
         let app = Router::new().route(
             "/api/generate",
-            post(|| async {
-                Json(json!({"model":"test","response":"   ","done": true}))
-            }),
+            post(|| async { Json(json!({"model":"test","response":"   ","done": true})) }),
         );
         let base = spawn_mock(app).await;
         let config = Config::default();
@@ -372,8 +370,7 @@ mod tests {
         let config = Config::default();
         let raw = "raw text";
         let result = with_ready_llm(base, &config, || async {
-            cleanup_transcription(&config, raw, Some("previous turn: check the oven"))
-                .await
+            cleanup_transcription(&config, raw, Some("previous turn: check the oven")).await
         })
         .await;
         if result.contains("Conversation context:") {

src/openhuman/voice/text_input.rs

@@ -224,10 +224,7 @@ mod tests {
         assert_eq!(escape_applescript_string(r"a\b"), r"a\\b");
         // Backslash must be escaped BEFORE quotes so the order of
         // substitutions doesn't double-escape already-escaped quotes.
-        assert_eq!(
-            escape_applescript_string(r#"\"mix"#),
-            r#"\\\"mix"#
-        );
+        assert_eq!(escape_applescript_string(r#"\"mix"#), r#"\\\"mix"#);
     }
 
     #[cfg(target_os = "macos")]

src/openhuman/webhooks/ops.rs

@@ -344,7 +344,10 @@ mod tests {
             .await
             .unwrap();
         assert!(out.value.registrations.is_empty());
-        assert!(out.logs.iter().any(|l| l.contains("registered tunnel uuid-1")));
+        assert!(out
+            .logs
+            .iter()
+            .any(|l| l.contains("registered tunnel uuid-1")));
     }
 
     #[tokio::test]
@@ -382,7 +385,9 @@ mod tests {
             Some("application/json")
         );
         assert_eq!(
-            resp.headers.get("x-openhuman-webhook-target").map(String::as_str),
+            resp.headers
+                .get("x-openhuman-webhook-target")
+                .map(String::as_str),
             Some("echo")
         );
         // Decode the body and check the echoed fields survived the round-trip.
@@ -417,8 +422,14 @@ mod tests {
         let tmp = TempDir::new().unwrap();
         let config = test_config(&tmp);
         for id in ["", "   "] {
-            assert!(get_tunnel(&config, id).await.unwrap_err().contains("id is required"));
-            assert!(delete_tunnel(&config, id).await.unwrap_err().contains("id is required"));
+            assert!(get_tunnel(&config, id)
+                .await
+                .unwrap_err()
+                .contains("id is required"));
+            assert!(delete_tunnel(&config, id)
+                .await
+                .unwrap_err()
+                .contains("id is required"));
             assert!(update_tunnel(&config, id, json!({}))
                 .await
                 .unwrap_err()
@@ -439,7 +450,10 @@ mod tests {
         let config = config_with_backend(&tmp, base);
         let out = list_tunnels(&config).await.unwrap();
         assert_eq!(out.value["tunnels"][0]["id"], json!("t-1"));
-        assert!(out.logs.iter().any(|l| l.contains("webhook tunnels fetched")));
+        assert!(out
+            .logs
+            .iter()
+            .any(|l| l.contains("webhook tunnels fetched")));
     }
 
     #[tokio::test]

src/openhuman/webhooks/schemas.rs

@@ -437,7 +437,11 @@ mod tests {
     #[test]
     fn all_controller_schemas_entries_are_all_under_webhooks_namespace() {
         for s in all_controller_schemas() {
-            assert_eq!(s.namespace, "webhooks", "schema `{}` has wrong namespace", s.function);
+            assert_eq!(
+                s.namespace, "webhooks",
+                "schema `{}` has wrong namespace",
+                s.function
+            );
             assert!(
                 !s.description.trim().is_empty(),
                 "schema `{}` must have a description",
@@ -472,13 +476,21 @@ mod tests {
             clone.dedup();
             clone.len()
         };
-        assert_eq!(unique_count, names.len(), "duplicate function names: {names:?}");
+        assert_eq!(
+            unique_count,
+            names.len(),
+            "duplicate function names: {names:?}"
+        );
     }
 
     // ── schemas(function) per-arm coverage ───────────────────────
 
     fn required_input_names(s: &ControllerSchema) -> Vec<&'static str> {
-        s.inputs.iter().filter(|f| f.required).map(|f| f.name).collect()
+        s.inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect()
     }
 
     #[test]
@@ -519,7 +531,9 @@ mod tests {
                 .find(|f| f.name == optional)
                 .unwrap_or_else(|| panic!("missing optional `{optional}`"));
             assert!(!f.required);
-            assert!(matches!(&f.ty, TypeSchema::Option(inner) if matches!(**inner, TypeSchema::String)));
+            assert!(
+                matches!(&f.ty, TypeSchema::Option(inner) if matches!(**inner, TypeSchema::String))
+            );
         }
     }
 
@@ -538,7 +552,10 @@ mod tests {
     fn create_tunnel_requires_name_and_allows_optional_description() {
         let s = schemas("create_tunnel");
         assert_eq!(required_input_names(&s), vec!["name"]);
-        assert!(s.inputs.iter().any(|f| f.name == "description" && !f.required));
+        assert!(s
+            .inputs
+            .iter()
+            .any(|f| f.name == "description" && !f.required));
     }
 
     #[test]

src/openhuman/webhooks/types.rs

@@ -240,7 +240,10 @@ mod tests {
         let s = serde_json::to_string(&resp).unwrap();
         let back: WebhookResponseData = serde_json::from_str(&s).unwrap();
         assert_eq!(back.status_code, 200);
-        assert_eq!(back.headers.get("Content-Type").map(String::as_str), Some("text/plain"));
+        assert_eq!(
+            back.headers.get("Content-Type").map(String::as_str),
+            Some("text/plain")
+        );
         assert_eq!(back.body, "Zm9v");
     }