test(coverage): batches 13–18 — Rust unit tests for 40+ modules (#530) (#618)

* test(coverage): batch 13–14 — core/all registry, proxy_config tool (#530)

Add 36 new tests:
- core/all: registry integrity (no duplicates, schema-controller parity),
  rpc_method_name, namespace_description, validate_params, schema lookup
- proxy_config: parse_scope, parse_string_list (CSV, array, errors),
  parse_optional_string_update, env_snapshot, proxy_json, security gates

All 4096 tests pass.

* test(coverage): batch 15 — memory/store/unified/helpers pure functions (#530)

Add 31 new tests for helpers module:
- vec_to_bytes/bytes_to_vec roundtrip, cosine_similarity (identical,
  orthogonal, mismatched, zero), collapse_whitespace, normalize_search_text,
  tokenize_search_terms, normalize_graph_entity/predicate, json_string_array,
  merge_unique_string_arrays, json_i64 (int/float/missing/string),
  recency_score (current/old/future), chunk_document_content

All 4127 tests pass.

* test(coverage): batch 16 — terminal, supervision, security detect, trigger history (#530)

Add 27 new tests across 4 modules:
- accessibility/terminal: is_text_role, is_terminal_app, looks_like_terminal_buffer,
  extract_terminal_input_context, noise line detection
- channels/runtime/supervision: compute_max_in_flight_messages clamping
- security/detect: all sandbox backend fallback paths (landlock, firejail,
  bubblewrap, docker on non-linux), disabled-via-enabled-false
- composio/trigger_history: list_recent with limit, empty store, field validation

All 4154 tests pass.

* test(coverage): batch 17 — learning, update, encryption, doctor, service schemas + skills/types (#530)

Add 49 new tests across 6 modules:
- learning/schemas: catalog, schema validation, unknown fallback
- update/schemas: check/apply schemas, optional staging_dir, controller parity
- encryption/schemas: encrypt/decrypt schemas, read_required helper
- doctor/schemas: report/models schemas, read_optional helper (none/null/value/error)
- service/schemas: 8 lifecycle functions, restart optional params, daemon_host
- skills/types: ToolResult success/error/json/mixed, serde roundtrip, ToolContent

All 4203 tests pass.

* test(coverage): batch 18 — accessibility/keys key-state probes (#530)

Add tests for is_tab_key_down/is_escape_key_down (platform-safe),
macOS-specific constant validation.

All 4216 tests pass.

* test(coverage): batch 19 — service/restart, memory/store/factories (#530)

Add 7 new tests:
- service/restart: default source/reason, whitespace trimming, empty-string
  defaults, RestartStatus serde, startup delay noop
- memory/store/factories: effective_memory_backend_name, migration-disabled error

All 4223 tests pass.

* test(coverage): batch 20 — tree_summarizer schemas, subconscious schemas (#530)

Add 38 new tests across 2 modules:
- tree_summarizer/schemas: catalog parity, all 5 functions, param helpers
  (read_required, read_optional, read_optional_timestamp), type_name,
  namespace_input
- subconscious/schemas: catalog parity, all 10 functions, required input
  validation, field/field_req/field_opt helpers

All 4261 tests pass.

---------

Co-authored-by: Steven Enamakel <31011319+senamakel@users.noreply.github.com>

src/core/all.rs

@@ -474,4 +474,157 @@ mod tests {
         let err = validate_registry(&registered, &declared).expect_err("expected duplicate input");
         assert!(err.contains("duplicate required input `use_cache` in `doctor.models`"));
     }
+
+    #[test]
+    fn validate_registry_accepts_valid_registry() {
+        let declared = vec![
+            schema("ns1", "fn1", vec![]),
+            schema("ns1", "fn2", vec![]),
+            schema("ns2", "fn1", vec![]),
+        ];
+        let registered = declared
+            .iter()
+            .map(|s| RegisteredController {
+                schema: s.clone(),
+                handler: noop_handler,
+            })
+            .collect::<Vec<_>>();
+        assert!(validate_registry(&registered, &declared).is_ok());
+    }
+
+    #[test]
+    fn rpc_method_name_formats_correctly() {
+        let s = schema("memory", "doc_put", vec![]);
+        assert_eq!(rpc_method_name(&s), "openhuman.memory_doc_put");
+    }
+
+    #[test]
+    fn registered_controller_rpc_method_name() {
+        let s = schema("billing", "get_balance", vec![]);
+        let rc = RegisteredController {
+            schema: s,
+            handler: noop_handler,
+        };
+        assert_eq!(rc.rpc_method_name(), "openhuman.billing_get_balance");
+    }
+
+    #[test]
+    fn namespace_description_known_namespaces() {
+        assert!(namespace_description("memory").is_some());
+        assert!(namespace_description("billing").is_some());
+        assert!(namespace_description("config").is_some());
+        assert!(namespace_description("health").is_some());
+        assert!(namespace_description("voice").is_some());
+        assert!(namespace_description("webhooks").is_some());
+    }
+
+    #[test]
+    fn namespace_description_unknown_returns_none() {
+        assert!(namespace_description("nonexistent_xyz").is_none());
+    }
+
+    #[test]
+    fn validate_params_accepts_valid_params() {
+        let s = schema(
+            "test",
+            "fn",
+            vec![FieldSchema {
+                name: "key",
+                ty: TypeSchema::String,
+                comment: "a key",
+                required: true,
+            }],
+        );
+        let mut params = Map::new();
+        params.insert("key".into(), Value::String("value".into()));
+        assert!(validate_params(&s, &params).is_ok());
+    }
+
+    #[test]
+    fn validate_params_rejects_missing_required() {
+        let s = schema(
+            "test",
+            "fn",
+            vec![FieldSchema {
+                name: "key",
+                ty: TypeSchema::String,
+                comment: "a key",
+                required: true,
+            }],
+        );
+        let params = Map::new();
+        let err = validate_params(&s, &params).unwrap_err();
+        assert!(err.contains("missing required param 'key'"));
+    }
+
+    #[test]
+    fn validate_params_rejects_unknown_param() {
+        let s = schema("test", "fn", vec![]);
+        let mut params = Map::new();
+        params.insert("unknown".into(), Value::Null);
+        let err = validate_params(&s, &params).unwrap_err();
+        assert!(err.contains("unknown param 'unknown'"));
+    }
+
+    #[test]
+    fn validate_params_accepts_empty_for_no_required() {
+        let s = schema("test", "fn", vec![]);
+        assert!(validate_params(&s, &Map::new()).is_ok());
+    }
+
+    #[test]
+    fn all_registered_controllers_is_nonempty() {
+        let controllers = all_registered_controllers();
+        assert!(
+            controllers.len() > 50,
+            "expected many controllers, got {}",
+            controllers.len()
+        );
+    }
+
+    #[test]
+    fn all_controller_schemas_matches_registered_count() {
+        let schemas = all_controller_schemas();
+        let controllers = all_registered_controllers();
+        assert_eq!(schemas.len(), controllers.len());
+    }
+
+    #[test]
+    fn schema_for_rpc_method_finds_known_method() {
+        let schema = schema_for_rpc_method("openhuman.health_snapshot");
+        assert!(schema.is_some(), "health.snapshot should be findable");
+        let s = schema.unwrap();
+        assert_eq!(s.namespace, "health");
+        assert_eq!(s.function, "snapshot");
+    }
+
+    #[test]
+    fn schema_for_rpc_method_returns_none_for_unknown() {
+        assert!(schema_for_rpc_method("openhuman.nonexistent_method_xyz").is_none());
+    }
+
+    #[test]
+    fn rpc_method_from_parts_finds_known() {
+        let method = rpc_method_from_parts("health", "snapshot");
+        assert_eq!(method.as_deref(), Some("openhuman.health_snapshot"));
+    }
+
+    #[test]
+    fn rpc_method_from_parts_returns_none_for_unknown() {
+        assert!(rpc_method_from_parts("fake", "method").is_none());
+    }
+
+    #[test]
+    fn no_duplicate_rpc_methods_in_registry() {
+        let controllers = all_registered_controllers();
+        let mut methods: Vec<String> = controllers.iter().map(|c| c.rpc_method_name()).collect();
+        let original_len = methods.len();
+        methods.sort();
+        methods.dedup();
+        assert_eq!(
+            methods.len(),
+            original_len,
+            "duplicate RPC methods found in registry"
+        );
+    }
 }