commit e043094862b8315f21f07013e1ec3c380b486463
parent c78524ff860eaef623a3b494ba33bffd0dbb9487
Author: triesap <tyson@radroots.org>
Date: Thu, 9 Apr 2026 01:12:35 +0000
tests: back fixture contract coverage with helpers
- add a shared fixture assertion helper for mirrored hyf scenarios
- drive status capabilities assisted and deferred tests from fixture json
- derive invalid-envelope stdio coverage from the mirrored status request
- compact fixture request bodies before stdio execution to respect line framing
Diffstat:
3 files changed, 311 insertions(+), 201 deletions(-)
diff --git a/tests/fixture_assertions.mojo b/tests/fixture_assertions.mojo
@@ -0,0 +1,258 @@
+from std.testing import assert_equal, assert_true
+
+from mojson import Value, dumps
+
+from fixture_loader import load_fixture_scenario
+
+
+def load_scenario_request(relative_path: String) raises -> Value:
+ return load_fixture_scenario(relative_path)["request"].clone()
+
+
+def load_scenario_request_json(relative_path: String) raises -> String:
+ return _compact_json(load_scenario_request(relative_path))
+
+
+def status_request_with_invalid_version_json() raises -> String:
+ var request = load_scenario_request("scenarios/status_ok.json")
+ request.set("version", Value(2))
+ return _compact_json(request)
+
+
+def assert_matches_scenario_response(
+ actual: Value, relative_path: String
+) raises:
+ var expected = load_fixture_scenario(relative_path)["expected"]
+
+ if _has_key(expected, "ok"):
+ _assert_json_equal(actual["ok"], expected["ok"])
+
+ if _has_key(expected, "equals"):
+ var equals = expected["equals"]
+ for path in equals.object_keys():
+ _assert_json_equal(_lookup_path(actual, path), equals[path])
+
+ if _has_key(expected, "contains_all"):
+ var contains_all = expected["contains_all"]
+ for path in contains_all.object_keys():
+ _assert_contains_all(
+ _lookup_path(actual, path), contains_all[path]
+ )
+
+ if _has_key(expected, "present_paths"):
+ for path in expected["present_paths"].array_items():
+ assert_true(
+ _path_exists(actual, path.string_value()),
+ "expected present path '" + path.string_value() + "'",
+ )
+
+ if _has_key(expected, "absent_paths"):
+ for path in expected["absent_paths"].array_items():
+ assert_true(
+ not _path_exists(actual, path.string_value()),
+ "expected absent path '" + path.string_value() + "'",
+ )
+
+ if _has_key(expected, "error_code"):
+ _assert_json_equal(actual["error"]["code"], expected["error_code"])
+
+ if _has_key(expected, "message_contains"):
+ assert_true(
+ actual["error"]["message"].string_value().find(
+ expected["message_contains"].string_value()
+ )
+ >= 0
+ )
+
+
+def _lookup_path(value: Value, dotted_path: String) raises -> Value:
+ return value.at(_to_json_pointer(dotted_path))
+
+
+def _path_exists(value: Value, dotted_path: String) -> Bool:
+ try:
+ _ = _lookup_path(value, dotted_path)
+ return True
+ except:
+ return False
+
+
+def _to_json_pointer(dotted_path: String) -> String:
+ var pointer = String("")
+ for token in dotted_path.split("."):
+ pointer += "/" + token
+ return pointer^
+
+
+def _compact_json(value: Value) raises -> String:
+ if value.is_null() or value.is_bool() or value.is_int() or value.is_float():
+ return dumps(value)
+
+ if value.is_string():
+ return dumps(Value(value.string_value()))
+
+ if value.is_array():
+ var items = value.array_items()
+ var json = String("[")
+ for i in range(len(items)):
+ if i > 0:
+ json += ","
+ json += _compact_json(items[i])
+ json += "]"
+ return json^
+
+ if value.is_object():
+ var json = String("{")
+ var keys = value.object_keys()
+ for i in range(len(keys)):
+ if i > 0:
+ json += ","
+ json += dumps(Value(keys[i]))
+ json += ":"
+ json += _compact_json(value[keys[i]])
+ json += "}"
+ return json^
+
+ return dumps(value)
+
+
+def _assert_contains_all(actual: Value, expected_subset: Value) raises:
+ if expected_subset.is_array():
+ assert_true(actual.is_array())
+ var actual_items = actual.array_items()
+ for expected_item in expected_subset.array_items():
+ var found = False
+ for actual_item in actual_items:
+ if _json_values_equal(actual_item, expected_item):
+ found = True
+ break
+ assert_true(
+ found,
+ "expected array item missing: " + dumps(expected_item),
+ )
+ return
+
+ if expected_subset.is_object():
+ assert_true(actual.is_object())
+ for key in expected_subset.object_keys():
+ assert_true(
+ _has_key(actual, key),
+ "expected object key '" + key + "'",
+ )
+ _assert_contains_all(actual[key], expected_subset[key])
+ return
+
+ _assert_json_equal(actual, expected_subset)
+
+
+def _json_values_equal(lhs: Value, rhs: Value) raises -> Bool:
+ if lhs.is_null() or rhs.is_null():
+ return lhs.is_null() and rhs.is_null()
+
+ if lhs.is_bool() or rhs.is_bool():
+ return (
+ lhs.is_bool()
+ and rhs.is_bool()
+ and lhs.bool_value() == rhs.bool_value()
+ )
+
+ if lhs.is_int() or rhs.is_int():
+ return (
+ lhs.is_int()
+ and rhs.is_int()
+ and lhs.int_value() == rhs.int_value()
+ )
+
+ if lhs.is_float() or rhs.is_float():
+ return (
+ lhs.is_float()
+ and rhs.is_float()
+ and lhs.float_value() == rhs.float_value()
+ )
+
+ if lhs.is_string() or rhs.is_string():
+ return (
+ lhs.is_string()
+ and rhs.is_string()
+ and lhs.string_value() == rhs.string_value()
+ )
+
+ if lhs.is_array() or rhs.is_array():
+ if not lhs.is_array() or not rhs.is_array():
+ return False
+ var lhs_items = lhs.array_items()
+ var rhs_items = rhs.array_items()
+ if len(lhs_items) != len(rhs_items):
+ return False
+ for i in range(len(lhs_items)):
+ if not _json_values_equal(lhs_items[i], rhs_items[i]):
+ return False
+ return True
+
+ if lhs.is_object() or rhs.is_object():
+ if not lhs.is_object() or not rhs.is_object():
+ return False
+ var rhs_keys = rhs.object_keys()
+ if len(lhs.object_keys()) != len(rhs_keys):
+ return False
+ for key in rhs_keys:
+ if not _has_key(lhs, key):
+ return False
+ if not _json_values_equal(lhs[key], rhs[key]):
+ return False
+ return True
+
+ return dumps(lhs) == dumps(rhs)
+
+
+def _assert_json_equal(actual: Value, expected: Value) raises:
+ if expected.is_null():
+ assert_true(actual.is_null())
+ return
+
+ if expected.is_bool():
+ assert_true(actual.is_bool())
+ assert_equal(actual.bool_value(), expected.bool_value())
+ return
+
+ if expected.is_int():
+ assert_true(actual.is_int())
+ assert_equal(Int(actual.int_value()), Int(expected.int_value()))
+ return
+
+ if expected.is_float():
+ assert_true(actual.is_float())
+ assert_equal(actual.float_value(), expected.float_value())
+ return
+
+ if expected.is_string():
+ assert_true(actual.is_string())
+ assert_equal(actual.string_value(), expected.string_value())
+ return
+
+ if expected.is_array():
+ assert_true(actual.is_array())
+ var actual_items = actual.array_items()
+ var expected_items = expected.array_items()
+ assert_equal(len(actual_items), len(expected_items))
+ for i in range(len(expected_items)):
+ _assert_json_equal(actual_items[i], expected_items[i])
+ return
+
+ if expected.is_object():
+ assert_true(actual.is_object())
+ var expected_keys = expected.object_keys()
+ assert_equal(len(actual.object_keys()), len(expected_keys))
+ for key in expected_keys:
+ assert_true(_has_key(actual, key))
+ _assert_json_equal(actual[key], expected[key])
+ return
+
+ assert_equal(dumps(actual), dumps(expected))
+
+
+def _has_key(value: Value, key: String) -> Bool:
+ for candidate in value.object_keys():
+ if candidate == key:
+ return True
+ return False
diff --git a/tests/test_hyf.mojo b/tests/test_hyf.mojo
@@ -11,6 +11,12 @@ from std.tempfile import TemporaryDirectory
from mojson import Value, loads
+from fixture_assertions import (
+ assert_matches_scenario_response,
+ load_scenario_request_json,
+ status_request_with_invalid_version_json,
+)
+
from fixture_loader import (
fixture_manifest_path,
load_fixture_manifest,
@@ -120,13 +126,6 @@ def _has_key(value: Value, key: String) -> Bool:
return False
-def _business_capability(result: Value, capability_id: String) raises -> Value:
- for capability in result["output"]["business_capabilities"].array_items():
- if capability["id"].string_value() == capability_id:
- return capability.clone()
- raise Error("missing capability '" + capability_id + "' in response")
-
-
def _array_string_values(value: Value) raises -> List[String]:
var items = List[String]()
for item in value.array_items():
@@ -303,163 +302,24 @@ def test_repo_local_fixture_loader_reads_all_mirrored_scenarios() raises:
def test_status_reports_registered_deterministic_ready() raises:
- var result = _dispatch(
- '{"version":1,"request_id":"status-1","trace_id":"trace-status-1","capability":"sys.status","input":{}}'
- )
-
- assert_equal(Int(result["version"].int_value()), 1)
- assert_equal(result["trace_id"].string_value(), "trace-status-1")
- assert_equal(result["ok"].bool_value(), True)
- assert_equal(
- result["output"]["build_identity"]["service_name"].string_value(),
- "hyf",
- )
- assert_equal(
- result["output"]["build_identity"]["package_name"].string_value(),
- "hyf",
- )
- assert_equal(
- result["output"]["build_identity"]["package_version"].string_value(),
- "0.1.0",
- )
- assert_equal(
- result["output"]["build_identity"]["protocol_version"].int_value(),
- 1,
- )
- assert_equal(
- result["output"]["build_identity"]["default_execution_mode"].string_value(),
- "deterministic",
- )
- assert_equal(
- result["output"]["build_identity"]["deterministic_execution_available"].bool_value(),
- True,
- )
- assert_equal(
- result["output"]["build_identity"]["assisted_execution_available"].bool_value(),
- False,
- )
- assert_equal(
- result["output"]["implementation_status"].string_value(),
- "bootstrap_registered_deterministic_ready",
- )
- assert_equal(
- result["output"]["backend_reachability"]["deterministic_backend"].string_value(),
- "available",
- )
- assert_equal(
- result["output"]["execution_mode_request_behavior"]["deterministic"].string_value(),
- "execute",
- )
- assert_equal(
- result["output"]["execution_mode_request_behavior"]["assisted"].string_value(),
- "backend_unavailable",
- )
- assert_equal(
- Int(
- result["output"]["counts"]["deterministic_registered_business_capabilities"].int_value()
- ),
- 3,
- )
- assert_equal(
- Int(
- result["output"]["counts"]["deterministic_implemented_business_capabilities"].int_value()
- ),
- 3,
- )
- assert_true(
- not _has_key(result["output"]["limits"], "request_context_features")
- )
- var status_request_context_contract = result["output"][
- "request_context_contract"
- ]
- var status_accepted = _array_string_values(
- status_request_context_contract["accepted_features"]
- )
- assert_equal(len(status_accepted), 4)
- assert_equal(status_accepted[0], "consumer")
- assert_equal(status_accepted[1], "execution_mode_preference")
- assert_equal(status_accepted[2], "scope.listing_ids")
- assert_equal(status_accepted[3], "return_provenance")
- var status_effective = _array_string_values(
- status_request_context_contract["effective_features"]
- )
- assert_equal(len(status_effective), 3)
- assert_equal(status_effective[0], "execution_mode_preference")
- assert_equal(status_effective[1], "scope.listing_ids")
- assert_equal(status_effective[2], "return_provenance")
- assert_equal(
- status_request_context_contract["unsupported_field_behavior"].string_value(),
- "reject",
- )
+ var result = _dispatch(load_scenario_request_json("scenarios/status_ok.json"))
+ assert_matches_scenario_response(result, "scenarios/status_ok.json")
def test_capabilities_report_implemented_and_disabled_states() raises:
var result = _dispatch(
- '{"version":1,"request_id":"caps-1","capability":"sys.capabilities","input":{}}'
- )
-
- assert_equal(Int(result["version"].int_value()), 1)
- var query_rewrite = _business_capability(result, "query_rewrite")
- var semantic_rank = _business_capability(result, "semantic_rank")
- var explain_result = _business_capability(result, "explain_result")
- var filter_extraction = _business_capability(result, "filter_extraction")
-
- assert_equal(query_rewrite["implemented"].bool_value(), True)
- assert_equal(query_rewrite["callable"].bool_value(), True)
- assert_equal(
- semantic_rank["implementation_status"].string_value(), "implemented"
- )
- assert_equal(
- explain_result["implementation_status"].string_value(), "implemented"
- )
- assert_equal(
- filter_extraction["deterministic_execution"].string_value(),
- "disabled",
- )
- assert_equal(
- filter_extraction["disabled_reason"].string_value(),
- "deferred_bootstrap_capability",
- )
- assert_true(
- not _has_key(result["output"], "request_context_features")
- )
- var capabilities_request_context_contract = result["output"][
- "request_context_contract"
- ]
- var capabilities_accepted = _array_string_values(
- capabilities_request_context_contract["accepted_features"]
- )
- assert_equal(len(capabilities_accepted), 4)
- assert_equal(capabilities_accepted[0], "consumer")
- assert_equal(
- capabilities_accepted[1], "execution_mode_preference"
- )
- assert_equal(capabilities_accepted[2], "scope.listing_ids")
- assert_equal(capabilities_accepted[3], "return_provenance")
- var capabilities_effective = _array_string_values(
- capabilities_request_context_contract["effective_features"]
- )
- assert_equal(len(capabilities_effective), 3)
- assert_equal(
- capabilities_effective[0], "execution_mode_preference"
- )
- assert_equal(capabilities_effective[1], "scope.listing_ids")
- assert_equal(capabilities_effective[2], "return_provenance")
- assert_equal(
- capabilities_request_context_contract["unsupported_field_behavior"].string_value(),
- "reject",
+ load_scenario_request_json("scenarios/capabilities_ok.json")
)
+ assert_matches_scenario_response(result, "scenarios/capabilities_ok.json")
def test_disabled_capability_returns_capability_disabled() raises:
var result = _dispatch(
- '{"version":1,"request_id":"disabled-1","capability":"filter_extraction","input":{}}'
+ load_scenario_request_json("scenarios/deferred_capability_disabled.json")
+ )
+ assert_matches_scenario_response(
+ result, "scenarios/deferred_capability_disabled.json"
)
-
- assert_equal(Int(result["version"].int_value()), 1)
- assert_equal(result["ok"].bool_value(), False)
- assert_equal(result["request_id"].string_value(), "disabled-1")
- assert_equal(result["error"]["code"].string_value(), "capability_disabled")
def test_backend_selector_routes_deterministic_wave() raises:
@@ -744,32 +604,23 @@ def test_semantic_rank_invalid_input_returns_invalid_request() raises:
def test_assisted_request_returns_backend_unavailable() raises:
var result = _dispatch(
- '{"version":1,"request_id":"rewrite-assisted-1","trace_id":"trace-rewrite-assisted-1","capability":"query_rewrite","context":{"execution_mode_preference":"assisted"},"input":{"text":"eggs near me"}}'
- )
-
- assert_equal(Int(result["version"].int_value()), 1)
- assert_equal(result["request_id"].string_value(), "rewrite-assisted-1")
- assert_equal(
- result["trace_id"].string_value(), "trace-rewrite-assisted-1"
- )
- assert_equal(result["ok"].bool_value(), False)
- assert_equal(
- result["error"]["code"].string_value(), "backend_unavailable"
+ load_scenario_request_json("scenarios/assisted_backend_unavailable.json")
)
- assert_true(
- result["error"]["message"].string_value().find("assisted_execution")
- >= 0
+ assert_matches_scenario_response(
+ result, "scenarios/assisted_backend_unavailable.json"
)
def test_invalid_request_preserves_request_and_trace_correlation() raises:
- var result = _dispatch(
- '{"version":2,"request_id":"bad-version-1","trace_id":"trace-bad-version-1","capability":"sys.status","input":{}}'
- )
+ var result = _dispatch(status_request_with_invalid_version_json())
assert_equal(Int(result["version"].int_value()), 1)
- assert_equal(result["request_id"].string_value(), "bad-version-1")
- assert_equal(result["trace_id"].string_value(), "trace-bad-version-1")
+ assert_equal(
+ result["request_id"].string_value(), "status-fixture-1"
+ )
+ assert_equal(
+ result["trace_id"].string_value(), "trace-status-fixture-1"
+ )
assert_equal(result["ok"].bool_value(), False)
assert_equal(result["error"]["code"].string_value(), "invalid_request")
assert_true(
diff --git a/tests/test_stdio_contract.mojo b/tests/test_stdio_contract.mojo
@@ -5,6 +5,11 @@ from std.testing import assert_equal, assert_true, TestSuite
from std.tempfile import TemporaryDirectory
from mojson import Value
+from fixture_assertions import (
+ assert_matches_scenario_response,
+ load_scenario_request_json,
+ status_request_with_invalid_version_json,
+)
from stdio_process_helper import (
HYF_DIAGNOSTICS_DIR_ENV,
ScopedEnvVar,
@@ -25,40 +30,27 @@ def _has_key(value: Value, key: String) -> Bool:
def test_status_success() raises:
var response = run_hyf_stdio(
- '{"version":1,"request_id":"status-proc-1","trace_id":"trace-status-proc-1","capability":"sys.status","input":{}}'
+ load_scenario_request_json("scenarios/status_ok.json")
)
+ assert_matches_scenario_response(response, "scenarios/status_ok.json")
- assert_equal(Int(response["version"].int_value()), 1)
- assert_equal(response["request_id"].string_value(), "status-proc-1")
- assert_equal(response["trace_id"].string_value(), "trace-status-proc-1")
- assert_true(response["ok"].bool_value())
- assert_equal(
- response["output"]["build_identity"]["service_name"].string_value(),
- "hyf",
- )
- assert_equal(
- response["output"]["execution_mode_request_behavior"]["assisted"].string_value(),
- "backend_unavailable",
- )
- assert_equal(
- response["output"]["request_context_contract"]["accepted_features"][2].string_value(),
- "scope.listing_ids",
- )
- assert_equal(
- response["output"]["request_context_contract"]["effective_features"][0].string_value(),
- "execution_mode_preference",
+
+def test_capabilities_success() raises:
+ var response = run_hyf_stdio(
+ load_scenario_request_json("scenarios/capabilities_ok.json")
)
+ assert_matches_scenario_response(response, "scenarios/capabilities_ok.json")
def test_invalid_envelope_preserves_correlation() raises:
- var response = run_hyf_stdio(
- '{"version":2,"request_id":"bad-envelope-proc-1","trace_id":"trace-bad-envelope-proc-1","capability":"sys.status","input":{}}'
- )
+ var response = run_hyf_stdio(status_request_with_invalid_version_json())
assert_equal(Int(response["version"].int_value()), 1)
- assert_equal(response["request_id"].string_value(), "bad-envelope-proc-1")
assert_equal(
- response["trace_id"].string_value(), "trace-bad-envelope-proc-1"
+ response["request_id"].string_value(), "status-fixture-1"
+ )
+ assert_equal(
+ response["trace_id"].string_value(), "trace-status-fixture-1"
)
assert_true(not response["ok"].bool_value())
assert_equal(response["error"]["code"].string_value(), "invalid_request")
@@ -66,11 +58,20 @@ def test_invalid_envelope_preserves_correlation() raises:
def test_assisted_request_fails_explicitly() raises:
var response = run_hyf_stdio(
- '{"version":1,"request_id":"assisted-proc-1","capability":"query_rewrite","context":{"execution_mode_preference":"assisted"},"input":{"text":"eggs near me"}}'
+ load_scenario_request_json("scenarios/assisted_backend_unavailable.json")
+ )
+ assert_matches_scenario_response(
+ response, "scenarios/assisted_backend_unavailable.json"
)
- assert_true(not response["ok"].bool_value())
- assert_equal(response["error"]["code"].string_value(), "backend_unavailable")
+
+def test_deferred_capability_returns_disabled_error() raises:
+ var response = run_hyf_stdio(
+ load_scenario_request_json("scenarios/deferred_capability_disabled.json")
+ )
+ assert_matches_scenario_response(
+ response, "scenarios/deferred_capability_disabled.json"
+ )
def test_semantic_rank_exports_heuristic_score_without_latency() raises:
