The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.
Rust agent-orchestrationai-agentsai-assistantdesktopllmlocal-firstmcppersonal-aiprivacyrustsecond-braintauri
test(security): update approval schema tests
Steven Enamakele42f013d0cb9
diff --git a/crates/openhuman-core/src/core/all_approval_controller_tests.rs b/crates/openhuman-core/src/core/all_approval_controller_tests.rsnew file mode 100644index 0000000000..3a728582d1--- /dev/null+++ b/crates/openhuman-core/src/core/all_approval_controller_tests.rs@@ -0,0 +1,148 @@+use super::*;+use crate::core::TypeSchema;+use serde_json::json;++#[test]+fn raw_approval_security_registry_matches_its_independent_contract() {+ let grouped: Vec<_> = registry()+ .iter()+ .filter(|row| row.controller.schema.namespace == "approval")+ .collect();+ let methods = [+ "approval.list_pending",+ "approval.list_recent_decisions",+ "approval.decide",+ "approval.get_gate_state",+ "approval.preauthorize_flow",+ ];+ let rpc_methods = [+ "openhuman.approval_list_pending",+ "openhuman.approval_list_recent_decisions",+ "openhuman.approval_decide",+ "openhuman.approval_get_gate_state",+ "openhuman.approval_preauthorize_flow",+ ];+ let contracts = crate::security::approval::approval_parameter_contracts();++ assert_eq!(grouped.len(), methods.len(), "complete raw approval inventory");+ assert_eq!(+ grouped+ .iter()+ .map(|row| row.controller.schema.method_name())+ .collect::<Vec<_>>(),+ methods,+ "independent approval method inventory and order"+ );+ assert!(grouped.iter().all(|row| row.group == DomainGroup::Security));+ assert!(internal_registry()+ .iter()+ .all(|row| row.controller.schema.namespace != "approval"));+ assert_eq!(+ grouped+ .iter()+ .map(|row| row.controller.rpc_method_name())+ .collect::<Vec<_>>(),+ rpc_methods+ );++ let entries: Vec<_> = grouped+ .iter()+ .map(|row| row.controller.clone())+ .collect();+ assert_eq!(+ contracts.iter().map(|row| row.method).collect::<Vec<_>>(),+ methods,+ "independent fixtures enumerate every method in registration order"+ );+ crate::core::all::verify_parameter_contracts(&entries, &contracts)+ .expect("raw approval entries use their declared schemas and runtime decoders");++ let schemas: Vec<_> = entries.iter().map(|entry| &entry.schema).collect();+ assert_input(+ schemas[0],+ "agent_id",+ false,+ |ty| matches!(ty, TypeSchema::Option(inner) if matches!(inner.as_ref(), TypeSchema::String)),+ );+ assert_eq!(schemas[1].inputs.len(), 1);+ assert_input(schemas[1], "limit", false, |ty| {+ matches!(ty, TypeSchema::Option(inner) if matches!(inner.as_ref(), TypeSchema::U64))+ });+ assert_eq!(schemas[2].inputs.len(), 3);+ assert_input(schemas[2], "request_id", true, |ty| matches!(ty, TypeSchema::String));+ assert_input(schemas[2], "decision", true, |ty| matches!(ty, TypeSchema::String));+ assert_input(schemas[2], "agent_id", false, |ty| {+ matches!(ty, TypeSchema::Option(inner) if matches!(inner.as_ref(), TypeSchema::String))+ });+ assert!(schemas[3].inputs.is_empty());+ assert_eq!(schemas[4].inputs.len(), 2);+ assert_input(schemas[4], "flow_id", true, |ty| matches!(ty, TypeSchema::String));+ assert_input(schemas[4], "tool_names", true, |ty| {+ matches!(ty, TypeSchema::Array(inner) if matches!(inner.as_ref(), TypeSchema::String))+ });++ let outputs = [+ ("pending", "PendingApproval", true),+ ("decisions", "ApprovalAuditEntry", true),+ ("decided", "PendingApproval", true),+ ("state", "ApprovalGateBootState", true),+ ("result", "FlowPreauthorizationResult", true),+ ];+ for (schema, (name, reference, required)) in schemas.iter().zip(outputs) {+ assert_eq!(schema.outputs.len(), 1, "{}.{} output count", schema.namespace, schema.function);+ let output = &schema.outputs[0];+ assert_eq!(output.name, name);+ assert_eq!(output.required, required);+ assert!(matches!(&output.ty, TypeSchema::Ref(actual) if *actual == reference));+ }++ for (entry, extra) in entries.iter().zip([+ json!({"agent_id": " raw agent ", "unknown": {"nested": [1, null]}}),+ json!({"limit": 0, "unknown": true}),+ json!({"request_id": " raw id ", "decision": "deny", "extra": [false]}),+ json!({"anything": {"ignored": true}}),+ json!({"flow_id": " raw flow ", "tool_names": [" ", "tool"], "extra": null}),+ ]) {+ entry+ .decode_params(extra.as_object().unwrap().clone())+ .expect("actual bound decoder ignores undeclared parameter keys");+ }+ entries[0]+ .decode_params(Map::from_iter([("agent_id".into(), json!(false))]))+ .expect_err("bound schema decoder rejects wrong agent_id type");+ entries[1]+ .decode_params(Map::from_iter([("limit".into(), json!(-1))]))+ .expect_err("bound schema decoder rejects negative limit");+ entries[2]+ .decode_params(Map::from_iter([+ ("request_id".into(), json!("id")),+ ("decision".into(), json!("unsupported")),+ ]))+ .expect_err("bound schema decoder enforces string wire types");+ entries[4]+ .decode_params(Map::from_iter([+ ("flow_id".into(), json!("flow")),+ ("tool_names".into(), json!([1])),+ ]))+ .expect_err("bound schema decoder enforces array item wire types");+}++fn assert_input(+ schema: &crate::core::ControllerSchema,+ name: &str,+ required: bool,+ type_matches: impl FnOnce(&TypeSchema) -> bool,+) {+ let field = schema+ .inputs+ .iter()+ .find(|field| field.name == name)+ .unwrap_or_else(|| panic!("{}.{} missing input {name}", schema.namespace, schema.function));+ assert_eq!(field.required, required, "{}.{} {name}", schema.namespace, schema.function);+ assert!(+ type_matches(&field.ty),+ "{}.{} input {name} has wrong type",+ schema.namespace,+ schema.function+ );+}diff --git a/crates/openhuman-core/src/security/approval/schemas_tests.rs b/crates/openhuman-core/src/security/approval/schemas_tests.rsindex c8942e90f0..512d0accbf 100644--- a/crates/openhuman-core/src/security/approval/schemas_tests.rs+++ b/crates/openhuman-core/src/security/approval/schemas_tests.rs@@ -1,90 +1,275 @@use super::*;+use crate::core::all::{assert_schema_controller_parity, ControllerHandler, ControllerParamContract};use serde_json::json;#[test]-fn schemas_list_pending_takes_only_an_optional_agent() {- let s = schemas("list_pending");- assert_eq!(s.namespace, "approval");- assert_eq!(s.function, "list_pending");- assert_eq!(s.inputs.len(), 1);- assert_eq!(s.inputs[0].name, "agent_id");- assert!(!s.inputs[0].required);+fn legacy_handlers_keep_their_identity_and_order() {+ let expected: [(&str, ControllerHandler); 5] = [+ ("list_pending", handle_list_pending),+ ("list_recent_decisions", handle_list_recent_decisions),+ ("decide", handle_decide),+ ("get_gate_state", handle_get_gate_state),+ ("preauthorize_flow", handle_preauthorize_flow),+ ];+ let controllers = all_registered_controllers();+ assert_eq!(controllers.len(), expected.len());+ for ((function, handler), controller) in expected.iter().zip(&controllers) {+ assert_eq!(controller.schema.namespace, "approval");+ assert_eq!(controller.schema.function, *function);+ assert!(std::ptr::fn_addr_eq(controller.handler, *handler));+ }}-#[test]-fn schemas_decide_requires_request_id_and_decision() {- let s = schemas("decide");- let names: Vec<_> = s.inputs.iter().map(|f| f.name).collect();- assert!(names.contains(&"request_id"));- assert!(names.contains(&"decision"));- assert!(s- .inputs- .iter()- .all(|f| f.required == (f.name != "agent_id")));- assert!(names.contains(&"agent_id"));+pub(super) fn parameter_contracts() -> Vec<ControllerParamContract> {+ vec![+ ControllerParamContract {+ method: "approval.list_pending",+ required: &[],+ optional: &["agent_id"],+ examples: vec![+ json!({}),+ json!({"agent_id": null}),+ json!({"agent_id": ""}),+ json!({"agent_id": " agent-1 "}),+ ],+ },+ ControllerParamContract {+ method: "approval.list_recent_decisions",+ required: &[],+ optional: &["limit"],+ examples: vec![json!({}), json!({"limit": null}), json!({"limit": 0}), json!({"limit": 500})],+ },+ ControllerParamContract {+ method: "approval.decide",+ required: &["request_id", "decision"],+ optional: &["agent_id"],+ examples: vec![+ json!({"request_id": "request-1", "decision": "approve_once"}),+ json!({"request_id": " request-2 ", "decision": " deny ", "agent_id": null}),+ ],+ },+ ControllerParamContract {+ method: "approval.get_gate_state",+ required: &[],+ optional: &[],+ examples: vec![json!({})],+ },+ ControllerParamContract {+ method: "approval.preauthorize_flow",+ required: &["flow_id", "tool_names"],+ optional: &[],+ examples: vec![+ json!({"flow_id": "flow-1", "tool_names": []}),+ json!({"flow_id": " flow-2 ", "tool_names": ["", " tool ", "tool"]}),+ ],+ },+ ]}#[test]-fn all_registered_controllers_has_handler_per_schema() {- let controllers = all_registered_controllers();- assert_eq!(controllers.len(), 5);- let names: Vec<_> = controllers.iter().map(|c| c.schema.function).collect();- assert_eq!(- names,- vec![- "list_pending",- "list_recent_decisions",- "decide",- "get_gate_state",- "preauthorize_flow",- ]+fn approval_schema_catalog_matches_legacy_handler_order() {+ assert_schema_controller_parity(+ &all_controller_schemas(),+ &all_registered_controllers(),+ "list_pending",);}#[test]-fn schemas_preauthorize_flow_requires_flow_id_and_tool_names() {- let s = schemas("preauthorize_flow");- assert_eq!(s.namespace, "approval");- let names: Vec<_> = s.inputs.iter().map(|f| f.name).collect();- assert_eq!(names, vec!["flow_id", "tool_names"]);- assert!(s.inputs.iter().all(|f| f.required));+fn list_pending_parser_trims_optional_agent_and_ignores_extras() {+ for (params, expected) in [+ (Map::new(), None),+ (Map::from_iter([("agent_id".into(), json!(null))]), None),+ (Map::from_iter([("agent_id".into(), json!(" "))]), None),+ (+ Map::from_iter([+ ("agent_id".into(), json!(" agent-a ")),+ ("extra".into(), json!({"ignored": [true]})),+ ]),+ Some("agent-a".to_owned()),+ ),+ ] {+ assert_eq!(parse_list_pending(params).unwrap(), expected);+ }+ for value in [json!(false), json!(0), json!([]), json!({})] {+ assert_eq!(+ parse_list_pending(Map::from_iter([("agent_id".into(), value.clone())]))+ .unwrap_err(),+ format!("invalid 'agent_id': expected string, got {}", value_kind(&value))+ );+ }}#[test]-fn schemas_list_recent_decisions_has_optional_limit() {- let s = schemas("list_recent_decisions");- assert_eq!(s.namespace, "approval");- assert_eq!(s.function, "list_recent_decisions");- assert_eq!(s.inputs[0].name, "limit");- assert!(!s.inputs[0].required);+fn recent_decisions_parser_keeps_optional_unsigned_limit_semantics() {+ assert_eq!(parse_list_recent_decisions(Map::new()).unwrap(), None);+ assert_eq!(+ parse_list_recent_decisions(Map::from_iter([("limit".into(), json!(null))])).unwrap(),+ None+ );+ for limit in [0, 1, u64::MAX] {+ assert_eq!(+ parse_list_recent_decisions(Map::from_iter([("limit".into(), json!(limit))]))+ .unwrap(),+ Some(limit)+ );+ }+ for value in [json!(-1), json!(1.5)] {+ assert_eq!(+ parse_list_recent_decisions(Map::from_iter([("limit".into(), value)]))+ .unwrap_err(),+ "invalid 'limit': expected unsigned integer"+ );+ }+ for (value, kind) in [+ (json!("10"), "string"),+ (json!(true), "bool"),+ (json!([]), "array"),+ (json!({}), "object"),+ ] {+ assert_eq!(+ parse_list_recent_decisions(Map::from_iter([("limit".into(), value)]))+ .unwrap_err(),+ format!("invalid 'limit': expected unsigned integer, got {kind}")+ );+ }}#[test]-fn read_required_string_returns_value_for_present_key() {- let mut params = Map::new();- params.insert("request_id".into(), json!("abc"));- let got = read_required_string(¶ms, "request_id").unwrap();- assert_eq!(got, "abc");+fn decide_parser_preserves_parse_order_raw_values_and_four_decisions() {+ for (spelling, expected) in [+ ("approve_once", ApprovalDecision::ApproveOnce),+ (+ "approve_always_for_tool",+ ApprovalDecision::ApproveAlwaysForTool,+ ),+ (+ "approve_always_for_flow",+ ApprovalDecision::ApproveAlwaysForFlow,+ ),+ ("deny", ApprovalDecision::Deny),+ ] {+ let (request_id, decision, agent_id) = parse_decide(Map::from_iter([+ ("request_id".into(), json!(" request-raw ")),+ ("decision".into(), json!(format!(" {spelling} "))),+ ("agent_id".into(), json!(" agent-raw ")),+ ("ignored".into(), json!({"nested": true})),+ ]))+ .unwrap();+ assert_eq!(request_id, " request-raw ");+ assert_eq!(decision, expected);+ assert_eq!(agent_id.as_deref(), Some("agent-raw"));+ }+ let (_, _, agent_id) = parse_decide(Map::from_iter([+ ("request_id".into(), json!("id")),+ ("decision".into(), json!("deny")),+ ("agent_id".into(), json!(" ")),+ ]))+ .unwrap();+ assert_eq!(agent_id, None);++ assert_eq!(+ parse_decide(Map::new()).unwrap_err(),+ "missing required param 'request_id'"+ );+ assert_eq!(+ parse_decide(Map::from_iter([("request_id".into(), json!("id"))])).unwrap_err(),+ "missing required param 'decision'"+ );+ assert_eq!(+ parse_decide(Map::from_iter([+ ("request_id".into(), json!("id")),+ ("decision".into(), json!(" nope ")),+ ("agent_id".into(), json!(false)),+ ]))+ .unwrap_err(),+ "invalid 'decision': expected approve_once|approve_always_for_tool|approve_always_for_flow|deny, got ' nope '"+ );+ assert_eq!(+ parse_decide(Map::from_iter([+ ("request_id".into(), json!("id")),+ ("decision".into(), json!("deny")),+ ("agent_id".into(), json!(false)),+ ]))+ .unwrap_err(),+ "invalid 'agent_id': expected string, got bool"+ );+ assert_eq!(+ parse_decide(Map::from_iter([("request_id".into(), json!(null))])).unwrap_err(),+ "invalid 'request_id': expected string, got null"+ );}#[test]-fn read_required_string_rejects_wrong_type() {- let mut params = Map::new();- params.insert("decision".into(), json!(42));- let err = read_required_string(¶ms, "decision").unwrap_err();- assert!(err.contains("expected string"));+fn gate_state_parser_ignores_the_entire_parameter_map() {+ assert_eq!(+ parse_get_gate_state(Map::from_iter([+ ("anything".into(), json!({"nested": [1, false]})),+ ("limit".into(), json!("wrong type")),+ ])),+ Ok(())+ );}#[test]-fn read_required_string_missing_key_errors() {- let err = read_required_string(&Map::new(), "request_id").unwrap_err();- assert!(err.contains("missing required"));+fn preauthorize_parser_preserves_flow_and_tool_strings_without_normalizing() {+ let (flow, tools) = parse_preauthorize_flow(Map::from_iter([+ ("flow_id".into(), json!(" flow raw ")),+ ("tool_names".into(), json!(["", " tool ", "tool", "tool"])),+ ("extra".into(), json!(true)),+ ]))+ .unwrap();+ assert_eq!(flow, " flow raw ");+ assert_eq!(tools, ["", " tool ", "tool", "tool"]);+ assert_eq!(+ parse_preauthorize_flow(Map::from_iter([("flow_id".into(), json!("flow"))]))+ .unwrap_err(),+ "missing required param 'tool_names'"+ );+ assert_eq!(+ parse_preauthorize_flow(Map::from_iter([("tool_names".into(), json!([]))]))+ .unwrap_err(),+ "missing required param 'flow_id'"+ );+ for value in [json!(null), json!(true), json!("tools"), json!({})] {+ let kind = value_kind(&value);+ assert_eq!(+ parse_preauthorize_flow(Map::from_iter([+ ("flow_id".into(), json!("flow")),+ ("tool_names".into(), value),+ ]))+ .unwrap_err(),+ format!("invalid 'tool_names': expected array of strings, got {kind}")+ );+ }+ for value in [json!(null), json!(false), json!(0), json!({})] {+ let kind = value_kind(&value);+ assert_eq!(+ parse_preauthorize_flow(Map::from_iter([+ ("flow_id".into(), json!("flow")),+ ("tool_names".into(), json!([value])),+ ]))+ .unwrap_err(),+ format!("invalid 'tool_names' entry: expected string, got {kind}")+ );+ }+ assert_eq!(+ parse_preauthorize_flow(Map::from_iter([+ ("flow_id".into(), json!(null)),+ ("tool_names".into(), json!([])),+ ]))+ .unwrap_err(),+ "invalid 'flow_id': expected string, got null"+ );}-#[test]-fn read_optional_u64_accepts_missing_and_number() {- assert_eq!(read_optional_u64(&Map::new(), "limit").unwrap(), None);- let mut params = Map::new();- params.insert("limit".into(), json!(25));- assert_eq!(read_optional_u64(¶ms, "limit").unwrap(), Some(25));+fn value_kind(value: &Value) -> &'static str {+ match value {+ Value::Null => "null",+ Value::Bool(_) => "bool",+ Value::Number(_) => "number",+ Value::String(_) => "string",+ Value::Array(_) => "array",+ Value::Object(_) => "object",+ }}