Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

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.rs
new file mode 100644
index 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.rs
index 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(&params, "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(&params, "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(&params, "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",
+ }
}