test_hyf.mojo (34925B)
1 import std.os 2 from std.os.path import exists 3 from std.pathlib import Path, _dir_of_current_file 4 from std.testing import ( 5 TestSuite, 6 assert_equal, 7 assert_raises, 8 assert_true, 9 ) 10 from std.tempfile import TemporaryDirectory 11 12 from json import Value, loads 13 14 from fixture_assertions import ( 15 assert_matches_scenario_response, 16 load_scenario_request_json, 17 status_request_with_invalid_version_json, 18 ) 19 20 from fixture_loader import ( 21 fixture_manifest_path, 22 load_fixture_json_file, 23 load_fixture_manifest, 24 load_fixture_scenario, 25 load_fixture_scenario_expected, 26 load_fixture_scenario_request, 27 load_fixture_top_level_field_from_path, 28 ) 29 from hyf_core.backends.selector import ( 30 execute_capability as execute_core_capability, 31 resolve_backend, 32 ) 33 from hyf_core.capabilities.registry import canonical_business_capabilities 34 from hyf_core.metadata import current_build_identity, current_package_surface 35 from hyf_core.request_context import ( 36 default_request_context, 37 ) 38 from hyf_stdio.control.capabilities import build_capabilities_output 39 from hyf_stdio.codec import decode_request, encode_error, encode_success 40 from hyf_stdio.envelope import WireErrorResponse, WireSuccessResponse 41 from hyf_stdio.errors import WireError 42 from hyf_runtime.startup import RuntimeStartupInput, resolve_startup_context 43 from hyf_stdio.server import ( 44 handle_request_line_with_runtime_context, 45 ) 46 from stdio_process_helper import run_stdio_entrypoint 47 48 49 comptime _EXPECTED_INTERNAL_ERROR_MESSAGE = ( 50 "internal hyf daemon error; inspect local diagnostics" 51 ) 52 comptime _HYF_DIAGNOSTICS_DIR_ENV = "HYF_DIAGNOSTICS_DIR" 53 54 55 struct ScopedEnvVar: 56 var name: String 57 var value: String 58 var previous: String 59 var had_previous: Bool 60 61 def __init__(out self, name: String, value: String): 62 self.name = String(name) 63 self.value = String(value) 64 self.previous = std.os.getenv(name) 65 self.had_previous = self.previous != "" 66 67 def __enter__(mut self) raises: 68 _ = std.os.setenv(self.name, self.value, overwrite=True) 69 70 def __exit__(mut self): 71 if self.had_previous: 72 _ = std.os.setenv(self.name, self.previous, overwrite=True) 73 else: 74 _ = std.os.unsetenv(self.name) 75 76 77 def _dispatch(line: String) raises -> Value: 78 var result = Value(None) 79 with TemporaryDirectory() as temp_dir: 80 var runtime_context = resolve_startup_context( 81 RuntimeStartupInput( 82 env_paths_profile="repo_local", 83 env_repo_local_base_root=temp_dir, 84 user_home="/home/unused", 85 argv=List[String](), 86 ) 87 ) 88 result = loads( 89 handle_request_line_with_runtime_context(line, runtime_context) 90 ) 91 return result^ 92 93 94 def _capability_output_entry_by_id( 95 output: Value, capability_id: String 96 ) raises -> Value: 97 for entry in output["business_capabilities"].array_items(): 98 if entry["id"].string_value() == capability_id: 99 return entry.clone() 100 raise Error("missing business capability entry '" + capability_id + "'") 101 102 103 def _sample_request_json_for_callable_capability( 104 capability_id: String, 105 ) raises -> String: 106 if capability_id == "query_rewrite": 107 return load_scenario_request_json( 108 "scenarios/query_rewrite_local_pickup_weekend.json" 109 ) 110 if capability_id == "semantic_rank": 111 return load_scenario_request_json( 112 "scenarios/semantic_rank_local_pickup_weekend.json" 113 ) 114 if capability_id == "explain_result": 115 return load_scenario_request_json( 116 "scenarios/explain_result_local_pickup_weekend.json" 117 ) 118 raise Error( 119 "missing sample request for callable capability '" + capability_id + "'" 120 ) 121 122 123 def _test_manifest_path() raises -> Path: 124 return _dir_of_current_file() / ".." / "pixi.toml" 125 126 127 def _parse_manifest_quoted_value(value: String) raises -> String: 128 var trimmed = value.strip() 129 if ( 130 trimmed.byte_length() < 2 131 or not trimmed.startswith('"') 132 or not trimmed.endswith('"') 133 ): 134 raise Error("manifest assignment value must be quoted") 135 return String(trimmed[byte = 1 : trimmed.byte_length() - 1]) 136 137 138 def _manifest_workspace_value(target_key: String) raises -> String: 139 var in_workspace = False 140 141 for raw_line in _test_manifest_path().read_text().splitlines(): 142 var line = String(raw_line).strip() 143 if line == "" or line.startswith("#"): 144 continue 145 146 if line.startswith("["): 147 in_workspace = line == "[workspace]" 148 continue 149 150 if not in_workspace: 151 continue 152 153 var equals_index = line.find("=") 154 if equals_index < 0: 155 continue 156 157 var key = String(line[byte=0:equals_index]).strip() 158 if key != target_key: 159 continue 160 161 return _parse_manifest_quoted_value( 162 String(line[byte = equals_index + 1 :]) 163 ) 164 165 raise Error("missing workspace manifest key '" + target_key + "'") 166 167 168 def _has_key(value: Value, key: String) -> Bool: 169 for candidate in value.object_keys(): 170 if candidate == key: 171 return True 172 return False 173 174 175 def _array_string_values(value: Value) raises -> List[String]: 176 var items = List[String]() 177 for item in value.array_items(): 178 items.append(item.string_value()) 179 return items^ 180 181 182 def test_decode_request_parses_context_and_input() raises: 183 var request = decode_request( 184 '{"version":1,"request_id":"req-1","trace_id":"trace-1","capability":"query_rewrite","context":{"consumer":"radroots-cli","execution_mode_preference":"deterministic","deadline_ms":2500,"time_range":{"start":"2026-04-12","end":"2026-04-13"},"evidence_limit":5,"consistency":"default","return_provenance":true,"explain_plan":true},"input":{"query":"eggs' 185 ' near me"}}' 186 ) 187 188 assert_equal(request.version, 1) 189 assert_equal(request.request_id, "req-1") 190 assert_equal(request.trace_id.value(), "trace-1") 191 assert_equal(request.capability, "query_rewrite") 192 assert_equal(request.context.consumer, "radroots-cli") 193 assert_equal(request.context.execution_mode_preference, "deterministic") 194 assert_equal(request.context.deadline_ms, 2500) 195 assert_equal(request.context.time_range.value().start, "2026-04-12") 196 assert_equal(request.context.time_range.value().end, "2026-04-13") 197 assert_equal(request.context.evidence_limit, 5) 198 assert_equal(request.context.consistency, "default") 199 assert_equal(request.context.return_provenance, True) 200 assert_equal(request.context.explain_plan, True) 201 assert_equal(request.input["query"].string_value(), "eggs near me") 202 203 204 def test_decode_request_rejects_unexpected_field() raises: 205 with assert_raises(): 206 _ = decode_request( 207 '{"version":1,"request_id":"req-1","capability":"query_rewrite","input":{"query":"eggs"},"unexpected":true}' 208 ) 209 210 211 def test_decode_request_requires_input_object() raises: 212 with assert_raises(): 213 _ = decode_request( 214 '{"version":1,"request_id":"req-no-input-1","capability":"query_rewrite"}' 215 ) 216 217 with assert_raises(): 218 _ = decode_request( 219 '{"version":1,"request_id":"req-bad-input-1","capability":"query_rewrite","input":"eggs"}' 220 ) 221 222 223 def test_decode_request_rejects_unknown_context_field() raises: 224 with assert_raises(): 225 _ = decode_request( 226 '{"version":1,"request_id":"req-ctx-1","capability":"query_rewrite","context":{"planner":"strict"},"input":{"query":"eggs"}}' 227 ) 228 229 230 def test_decode_request_rejects_invalid_activated_context_field() raises: 231 with assert_raises(): 232 _ = decode_request( 233 '{"version":1,"request_id":"req-ctx-2","capability":"query_rewrite","context":{"deadline_ms":0},"input":{"query":"eggs"}}' 234 ) 235 236 237 def test_decode_request_rejects_unsupported_scope_field() raises: 238 with assert_raises(): 239 _ = decode_request( 240 '{"version":1,"request_id":"req-scope-1","capability":"semantic_rank","context":{"scope":{"farm_ids":["farm-1"]}},"input":{"query":"eggs","candidates":[{"id":"lst_1","title":"Eggs","farm":"One' 241 ' Farm","delivery":"pickup","distance_km":1.0,"freshness_minutes":5}]}}' 242 ) 243 244 245 def test_encode_success_and_error_shapes() raises: 246 var output = loads("{}") 247 output.set("kind", Value("ok")) 248 249 var meta = loads("{}") 250 meta.set("execution_mode", Value("deterministic")) 251 252 var success = loads( 253 encode_success( 254 WireSuccessResponse( 255 version=1, 256 request_id="req-success", 257 trace_id=String("trace-success"), 258 output=output.copy(), 259 meta=meta.copy(), 260 ) 261 ) 262 ) 263 assert_equal(Int(success["version"].int_value()), 1) 264 assert_equal(success["request_id"].string_value(), "req-success") 265 assert_equal(success["trace_id"].string_value(), "trace-success") 266 assert_equal(success["ok"].bool_value(), True) 267 assert_equal(success["output"]["kind"].string_value(), "ok") 268 assert_equal( 269 success["meta"]["execution_mode"].string_value(), 270 "deterministic", 271 ) 272 assert_true(not _has_key(success["meta"], "latency_ms")) 273 274 var failure = loads( 275 encode_error( 276 WireErrorResponse( 277 version=1, 278 request_id="req-error", 279 trace_id=String("trace-error"), 280 error=WireError(code="invalid_request", message="bad request"), 281 ) 282 ) 283 ) 284 assert_equal(Int(failure["version"].int_value()), 1) 285 assert_equal(failure["request_id"].string_value(), "req-error") 286 assert_equal(failure["trace_id"].string_value(), "trace-error") 287 assert_equal(failure["ok"].bool_value(), False) 288 assert_equal(failure["error"]["code"].string_value(), "invalid_request") 289 assert_equal(failure["error"]["message"].string_value(), "bad request") 290 291 292 def test_handle_request_line_returns_invalid_request_for_bad_line() raises: 293 var result = _dispatch("") 294 assert_equal(Int(result["version"].int_value()), 1) 295 assert_equal(result["request_id"].string_value(), "") 296 assert_equal(_has_key(result, "trace_id"), False) 297 assert_equal(result["ok"].bool_value(), False) 298 assert_equal(result["error"]["code"].string_value(), "invalid_request") 299 300 301 def test_current_build_identity_matches_manifest_package_surface() raises: 302 var package_surface = current_package_surface() 303 var build_identity = current_build_identity() 304 var manifest_package_name = _manifest_workspace_value("name") 305 var manifest_package_version = _manifest_workspace_value("version") 306 307 assert_equal(package_surface.package_name, manifest_package_name) 308 assert_equal(package_surface.package_version, manifest_package_version) 309 assert_equal(build_identity.package_name, manifest_package_name) 310 assert_equal(build_identity.package_version, manifest_package_version) 311 312 313 def test_repo_local_fixture_manifest_declares_expected_scenarios() raises: 314 assert_true(exists(fixture_manifest_path())) 315 316 var manifest = load_fixture_manifest() 317 assert_equal( 318 manifest["fixture_namespace"].string_value(), 319 "radroots-canonical-hyf-v1", 320 ) 321 assert_equal(Int(manifest["schema_version"].int_value()), 1) 322 assert_equal(manifest["family_kind"].string_value(), "wire_compatibility") 323 assert_equal(manifest["transport"].string_value(), "stdio") 324 assert_equal( 325 manifest["request_framing"].string_value(), 326 "newline_delimited_json", 327 ) 328 assert_equal( 329 manifest["family_role"].string_value(), 330 "dependency_surface", 331 ) 332 assert_equal( 333 manifest["canonical_authority_path"].string_value(), 334 "testing/fixtures/canonical/hyf/v1", 335 ) 336 assert_equal( 337 manifest["shared_scenario_sync_policy"].string_value(), 338 "same_logical_workstream", 339 ) 340 341 var scenario_files = _array_string_values(manifest["scenario_files"]) 342 assert_equal(len(scenario_files), 8) 343 assert_equal(scenario_files[0], "scenarios/status_ok.json") 344 assert_equal( 345 scenario_files[7], "scenarios/query_rewrite_unexpected_field.json" 346 ) 347 348 349 def test_repo_local_fixture_loader_reads_all_mirrored_scenarios() raises: 350 var manifest = load_fixture_manifest() 351 assert_equal( 352 manifest["fixture_namespace"].string_value(), 353 "radroots-canonical-hyf-v1", 354 ) 355 356 var status_scenario = load_fixture_scenario("scenarios/status_ok.json") 357 assert_equal(status_scenario["fixture_id"].string_value(), "status_ok") 358 assert_equal( 359 status_scenario["request"]["capability"].string_value(), 360 "sys.status", 361 ) 362 assert_true(_has_key(status_scenario, "expected")) 363 364 var rewrite_scenario = load_fixture_scenario( 365 "scenarios/query_rewrite_local_pickup_weekend.json" 366 ) 367 assert_equal( 368 rewrite_scenario["fixture_id"].string_value(), 369 "query_rewrite_local_pickup_weekend", 370 ) 371 assert_equal( 372 rewrite_scenario["request"]["capability"].string_value(), 373 "query_rewrite", 374 ) 375 assert_equal( 376 rewrite_scenario["request"]["input"]["query"].string_value(), 377 "apples near me with weekend pickup", 378 ) 379 380 381 def test_fixture_loader_reads_top_level_request_and_expected_structurally() raises: 382 with TemporaryDirectory() as temp_dir: 383 var scenario_path = Path(temp_dir) / "scenario.json" 384 scenario_path.write_text( 385 "{" 386 + '"fixture_id":"shadowed-top-level-fields",' 387 + '"description":"this description mentions request and expected' 388 ' before the real fields",' 389 + '"request":{"version":1,"request_id":"shadow-1","capability":"sys.status","input":{}},' 390 + '"expected":{"ok":true,"equals":{"output.kind":"status"}}' 391 + "}" 392 ) 393 394 var scenario = load_fixture_json_file(scenario_path) 395 var request = load_fixture_scenario_request("scenarios/status_ok.json") 396 var expected = load_fixture_scenario_expected( 397 "scenarios/status_ok.json" 398 ) 399 var temp_request = load_fixture_top_level_field_from_path( 400 scenario_path, "request" 401 ) 402 var temp_expected = load_fixture_top_level_field_from_path( 403 scenario_path, "expected" 404 ) 405 406 assert_equal( 407 scenario["fixture_id"].string_value(), 408 "shadowed-top-level-fields", 409 ) 410 assert_equal( 411 temp_request["request_id"].string_value(), 412 "shadow-1", 413 ) 414 assert_equal( 415 temp_request["capability"].string_value(), 416 "sys.status", 417 ) 418 assert_true(temp_expected["ok"].bool_value()) 419 assert_equal( 420 temp_expected["equals"]["output.kind"].string_value(), 421 "status", 422 ) 423 assert_equal(request["capability"].string_value(), "sys.status") 424 assert_true(expected["ok"].bool_value()) 425 426 427 def test_status_reports_registered_deterministic_ready() raises: 428 var result = _dispatch( 429 load_scenario_request_json("scenarios/status_ok.json") 430 ) 431 assert_matches_scenario_response(result, "scenarios/status_ok.json") 432 433 434 def test_capabilities_report_implemented_and_disabled_states() raises: 435 var result = _dispatch( 436 load_scenario_request_json("scenarios/capabilities_ok.json") 437 ) 438 assert_matches_scenario_response(result, "scenarios/capabilities_ok.json") 439 440 441 def test_capabilities_output_reflects_registry_truth_for_all_business_capabilities() raises: 442 var output = build_capabilities_output() 443 for capability in canonical_business_capabilities(): 444 var entry = _capability_output_entry_by_id(output, capability.id) 445 assert_equal(entry["id"].string_value(), capability.id) 446 assert_equal(entry["implemented"].bool_value(), capability.implemented) 447 assert_equal(entry["callable"].bool_value(), capability.callable) 448 assert_equal(entry["assisted_backend_available"].bool_value(), False) 449 assert_equal( 450 entry["deterministic_execution"].string_value(), 451 "enabled" if capability.deterministic_enabled else "disabled", 452 ) 453 assert_equal( 454 entry["implementation_status"].string_value(), 455 "implemented" if capability.implemented else ( 456 "not_implemented" if capability.deterministic_enabled else "disabled" 457 ), 458 ) 459 if capability.disabled_reason != "": 460 assert_equal( 461 entry["disabled_reason"].string_value(), 462 capability.disabled_reason, 463 ) 464 else: 465 assert_true(not _has_key(entry, "disabled_reason")) 466 467 assert_equal( 468 output["provider_runtime_capabilities"][0]["id"].string_value(), 469 "hyf_provider_runtime", 470 ) 471 assert_equal( 472 output["provider_runtime_capabilities"][0]["kind"].string_value(), 473 "provider_runtime", 474 ) 475 assert_equal( 476 output["provider_runtime_capabilities"][0]["transport"] 477 .string_value(), 478 "deferred", 479 ) 480 assert_equal( 481 output["provider_runtime_capabilities"][0]["state"].string_value(), 482 "disabled_by_runtime_config", 483 ) 484 assert_equal( 485 output["provider_runtime_capabilities"][0]["backend_kind"] 486 .string_value(), 487 "deferred", 488 ) 489 490 491 def test_disabled_capability_returns_capability_disabled() raises: 492 var result = _dispatch( 493 load_scenario_request_json( 494 "scenarios/deferred_capability_disabled.json" 495 ) 496 ) 497 assert_matches_scenario_response( 498 result, "scenarios/deferred_capability_disabled.json" 499 ) 500 501 502 def test_all_callable_registry_business_capabilities_are_dispatchable() raises: 503 for capability in canonical_business_capabilities(): 504 if not capability.callable: 505 continue 506 var result = _dispatch( 507 _sample_request_json_for_callable_capability(capability.id) 508 ) 509 assert_equal(Int(result["version"].int_value()), 1) 510 assert_equal(result["ok"].bool_value(), True) 511 512 513 def test_non_callable_registry_business_capabilities_do_not_route_as_success() raises: 514 for capability in canonical_business_capabilities(): 515 if capability.callable: 516 continue 517 var result = _dispatch( 518 '{"version":1,"request_id":"' 519 + capability.id 520 + '-routing-1","capability":"' 521 + capability.id 522 + '","input":{}}' 523 ) 524 assert_equal(Int(result["version"].int_value()), 1) 525 assert_equal( 526 result["request_id"].string_value(), capability.id + "-routing-1" 527 ) 528 assert_equal(result["ok"].bool_value(), False) 529 assert_equal( 530 result["error"]["code"].string_value(), 531 "capability_disabled" if not capability.deterministic_enabled else "capability_unavailable", 532 ) 533 534 535 def test_backend_selector_routes_deterministic_wave() raises: 536 var context = default_request_context() 537 var selection = resolve_backend(context) 538 539 assert_equal(selection.backend_name, "heuristic") 540 assert_equal(selection.available, True) 541 542 var result = execute_core_capability( 543 "query_rewrite", 544 loads('{"text":"eggs near me with weekend pickup"}'), 545 context, 546 ) 547 548 assert_true(result.success) 549 assert_equal( 550 result.success.value().meta.value().backend, 551 "heuristic", 552 ) 553 assert_equal( 554 result.success.value().meta.value().execution_mode, 555 "deterministic", 556 ) 557 558 559 def test_backend_selector_routes_assisted_preference_to_deterministic_fallback() raises: 560 var context = default_request_context() 561 context.execution_mode_preference = "assisted" 562 563 var selection = resolve_backend(context) 564 assert_equal(selection.backend_name, "heuristic") 565 assert_equal(selection.available, True) 566 567 var result = execute_core_capability( 568 "query_rewrite", 569 loads('{"text":"eggs near me"}'), 570 context, 571 ) 572 573 assert_true(result.success) 574 assert_equal( 575 result.success.value().meta.value().execution_mode, 576 "deterministic", 577 ) 578 assert_equal(result.success.value().meta.value().backend, "heuristic") 579 580 581 def test_query_rewrite_returns_deterministic_output() raises: 582 var result = _dispatch( 583 load_scenario_request_json( 584 "scenarios/query_rewrite_local_pickup_weekend.json" 585 ) 586 ) 587 assert_matches_scenario_response( 588 result, "scenarios/query_rewrite_local_pickup_weekend.json" 589 ) 590 591 592 def test_query_rewrite_accepts_query_alias_with_same_behavior() raises: 593 var result = _dispatch( 594 '{"version":1,"request_id":"rewrite-query-1","capability":"query_rewrite","input":{"query":"eggs' 595 ' near me with weekend pickup"}}' 596 ) 597 598 assert_equal(Int(result["version"].int_value()), 1) 599 assert_equal(result["ok"].bool_value(), True) 600 assert_equal( 601 result["output"]["rewritten_text"].string_value(), 602 "eggs", 603 ) 604 assert_equal( 605 result["output"]["extracted_filters"]["fulfillment"].string_value(), 606 "pickup", 607 ) 608 609 610 def test_query_rewrite_rejects_unknown_input_field() raises: 611 var result = _dispatch( 612 load_scenario_request_json( 613 "scenarios/query_rewrite_unexpected_field.json" 614 ) 615 ) 616 assert_matches_scenario_response( 617 result, "scenarios/query_rewrite_unexpected_field.json" 618 ) 619 620 621 def test_query_rewrite_rejects_text_and_query_together() raises: 622 var result = _dispatch( 623 '{"version":1,"request_id":"rewrite-bad-dual-1","capability":"query_rewrite","input":{"text":"eggs' 624 ' near me","query":"eggs"}}' 625 ) 626 627 assert_equal(Int(result["version"].int_value()), 1) 628 assert_equal(result["ok"].bool_value(), False) 629 assert_equal(result["request_id"].string_value(), "rewrite-bad-dual-1") 630 assert_equal(result["error"]["code"].string_value(), "invalid_request") 631 assert_true( 632 result["error"]["message"].string_value().find("exactly one") >= 0 633 ) 634 635 636 def test_semantic_rank_returns_ranked_ids_and_reasons() raises: 637 var result = _dispatch( 638 load_scenario_request_json( 639 "scenarios/semantic_rank_local_pickup_weekend.json" 640 ) 641 ) 642 assert_matches_scenario_response( 643 result, "scenarios/semantic_rank_local_pickup_weekend.json" 644 ) 645 646 647 def test_semantic_rank_scope_listing_ids_remains_effective() raises: 648 var result = _dispatch( 649 '{"version":1,"request_id":"rank-scope-1","capability":"semantic_rank","context":{"scope":{"listing_ids":["lst_8k1p"]}},"input":{"query":"eggs","candidates":[{"id":"lst_7ak2","title":"Pasture' 650 ' eggs","farm":"La Huerta del' 651 ' Sur","delivery":"pickup","distance_km":3.2,"freshness_minutes":2},{"id":"lst_8k1p","title":"Free' 652 ' range eggs","farm":"Santa' 653 ' Elena","delivery":"delivery","distance_km":8.7,"freshness_minutes":18}]}}' 654 ) 655 656 assert_equal(Int(result["version"].int_value()), 1) 657 assert_equal(result["ok"].bool_value(), True) 658 assert_equal( 659 result["output"]["ranked_ids"][0].string_value(), 660 "lst_8k1p", 661 ) 662 assert_equal( 663 result["output"]["scored_candidates"][0]["scope_match"].bool_value(), 664 True, 665 ) 666 assert_true( 667 _has_key(result["output"]["scored_candidates"][0], "heuristic_score") 668 ) 669 670 671 def test_semantic_rank_rejects_unknown_top_level_field() raises: 672 var result = _dispatch( 673 '{"version":1,"request_id":"rank-bad-top-1","capability":"semantic_rank","input":{"query":"eggs' 674 ' near me","candidates":[{"id":"lst_7ak2","title":"Pasture' 675 ' eggs","farm":"La Huerta del' 676 ' Sur","delivery":"pickup","distance_km":3.2,"freshness_minutes":2}],"tone":"brief"}}' 677 ) 678 679 assert_equal(Int(result["version"].int_value()), 1) 680 assert_equal(result["ok"].bool_value(), False) 681 assert_equal(result["request_id"].string_value(), "rank-bad-top-1") 682 assert_equal(result["error"]["code"].string_value(), "invalid_request") 683 assert_true( 684 result["error"]["message"].string_value().find("unexpected field") >= 0 685 ) 686 687 688 def test_semantic_rank_rejects_unknown_candidate_field() raises: 689 var result = _dispatch( 690 '{"version":1,"request_id":"rank-bad-candidate-1","capability":"semantic_rank","input":{"query":"eggs' 691 ' near me","candidates":[{"id":"lst_7ak2","title":"Pasture' 692 ' eggs","farm":"La Huerta del' 693 ' Sur","delivery":"pickup","distance_km":3.2,"freshness_minutes":2,"rating":5}]}}' 694 ) 695 696 assert_equal(Int(result["version"].int_value()), 1) 697 assert_equal(result["ok"].bool_value(), False) 698 assert_equal(result["request_id"].string_value(), "rank-bad-candidate-1") 699 assert_equal(result["error"]["code"].string_value(), "invalid_request") 700 assert_true( 701 result["error"]["message"].string_value().find("unexpected field") >= 0 702 ) 703 704 705 def test_semantic_rank_rejects_duplicate_candidate_ids() raises: 706 var result = _dispatch( 707 '{"version":1,"request_id":"rank-dup-1","capability":"semantic_rank","input":{"query":"eggs' 708 ' near me","candidates":[{"id":"lst_dup","title":"Pasture' 709 ' eggs","farm":"La Huerta del' 710 ' Sur","delivery":"pickup","distance_km":3.2,"freshness_minutes":2},{"id":"lst_dup","title":"Free' 711 ' range eggs","farm":"Santa' 712 ' Elena","delivery":"delivery","distance_km":8.7,"freshness_minutes":18}]}}' 713 ) 714 715 assert_equal(Int(result["version"].int_value()), 1) 716 assert_equal(result["ok"].bool_value(), False) 717 assert_equal(result["request_id"].string_value(), "rank-dup-1") 718 assert_equal(result["error"]["code"].string_value(), "invalid_request") 719 assert_true( 720 result["error"]["message"].string_value().find("duplicate candidate id") 721 >= 0 722 ) 723 724 725 def test_semantic_rank_rejects_invalid_delivery_value() raises: 726 var result = _dispatch( 727 '{"version":1,"request_id":"rank-bad-delivery-1","capability":"semantic_rank","input":{"query":"eggs' 728 ' near me","candidates":[{"id":"lst_7ak2","title":"Pasture' 729 ' eggs","farm":"La Huerta del' 730 ' Sur","delivery":"ship","distance_km":3.2,"freshness_minutes":2}]}}' 731 ) 732 733 assert_equal(Int(result["version"].int_value()), 1) 734 assert_equal(result["ok"].bool_value(), False) 735 assert_equal(result["request_id"].string_value(), "rank-bad-delivery-1") 736 assert_equal(result["error"]["code"].string_value(), "invalid_request") 737 assert_true( 738 result["error"]["message"].string_value().find("must be one of") >= 0 739 ) 740 741 742 def test_explain_result_returns_deterministic_summary_and_provenance() raises: 743 var result = _dispatch( 744 load_scenario_request_json( 745 "scenarios/explain_result_local_pickup_weekend.json" 746 ) 747 ) 748 assert_matches_scenario_response( 749 result, "scenarios/explain_result_local_pickup_weekend.json" 750 ) 751 752 753 def test_explain_result_accepts_result_alias() raises: 754 var result = _dispatch( 755 '{"version":1,"request_id":"explain-result-1","capability":"explain_result","input":{"query":"eggs' 756 " near me with weekend" 757 ' pickup","result":{"id":"lst_7ak2","title":"Pasture eggs","farm":"La' 758 " Huerta del" 759 ' Sur","delivery":"pickup","distance_km":3.2,"freshness_minutes":2}}}' 760 ) 761 762 assert_equal(Int(result["version"].int_value()), 1) 763 assert_equal(result["ok"].bool_value(), True) 764 assert_equal( 765 result["output"]["result_id"].string_value(), 766 "lst_7ak2", 767 ) 768 assert_equal( 769 result["output"]["explanation_kind"].string_value(), 770 "deterministic", 771 ) 772 773 774 def test_explain_result_rejects_unknown_top_level_field() raises: 775 var result = _dispatch( 776 '{"version":1,"request_id":"explain-bad-top-1","capability":"explain_result","input":{"query":"eggs' 777 ' near me","candidate":{"id":"lst_7ak2","title":"Pasture' 778 ' eggs","farm":"La Huerta del' 779 ' Sur","delivery":"pickup","distance_km":3.2,"freshness_minutes":2},"tone":"brief"}}' 780 ) 781 782 assert_equal(Int(result["version"].int_value()), 1) 783 assert_equal(result["ok"].bool_value(), False) 784 assert_equal(result["request_id"].string_value(), "explain-bad-top-1") 785 assert_equal(result["error"]["code"].string_value(), "invalid_request") 786 assert_true( 787 result["error"]["message"].string_value().find("unexpected field") >= 0 788 ) 789 790 791 def test_explain_result_rejects_unknown_candidate_field() raises: 792 var result = _dispatch( 793 '{"version":1,"request_id":"explain-bad-candidate-1","capability":"explain_result","input":{"query":"eggs' 794 ' near me","candidate":{"id":"lst_7ak2","title":"Pasture' 795 ' eggs","farm":"La Huerta del' 796 ' Sur","delivery":"pickup","distance_km":3.2,"freshness_minutes":2,"rating":5}}}' 797 ) 798 799 assert_equal(Int(result["version"].int_value()), 1) 800 assert_equal(result["ok"].bool_value(), False) 801 assert_equal(result["request_id"].string_value(), "explain-bad-candidate-1") 802 assert_equal(result["error"]["code"].string_value(), "invalid_request") 803 assert_true( 804 result["error"]["message"].string_value().find("unexpected field") >= 0 805 ) 806 807 808 def test_explain_result_rejects_invalid_delivery_value() raises: 809 var result = _dispatch( 810 '{"version":1,"request_id":"explain-bad-delivery-1","capability":"explain_result","input":{"query":"eggs' 811 ' near me","candidate":{"id":"lst_7ak2","title":"Pasture' 812 ' eggs","farm":"La Huerta del' 813 ' Sur","delivery":"ship","distance_km":3.2,"freshness_minutes":2}}}' 814 ) 815 816 assert_equal(Int(result["version"].int_value()), 1) 817 assert_equal(result["ok"].bool_value(), False) 818 assert_equal(result["request_id"].string_value(), "explain-bad-delivery-1") 819 assert_equal(result["error"]["code"].string_value(), "invalid_request") 820 assert_true( 821 result["error"]["message"].string_value().find("must be one of") >= 0 822 ) 823 824 825 def test_semantic_rank_invalid_input_returns_invalid_request() raises: 826 var result = _dispatch( 827 '{"version":1,"request_id":"rank-bad-1","trace_id":"trace-rank-bad-1","capability":"semantic_rank","input":{"query":"eggs' 828 ' near me with weekend pickup","candidates":[]}}' 829 ) 830 831 assert_equal(Int(result["version"].int_value()), 1) 832 assert_equal(result["ok"].bool_value(), False) 833 assert_equal(result["request_id"].string_value(), "rank-bad-1") 834 assert_equal(result["trace_id"].string_value(), "trace-rank-bad-1") 835 assert_equal(result["error"]["code"].string_value(), "invalid_request") 836 assert_true( 837 result["error"]["message"].string_value().find("must not be empty") >= 0 838 ) 839 840 841 def test_missing_input_returns_invalid_request() raises: 842 var result = _dispatch( 843 '{"version":1,"request_id":"missing-input-1","trace_id":"trace-missing-input-1","capability":"query_rewrite"}' 844 ) 845 846 assert_equal(Int(result["version"].int_value()), 1) 847 assert_equal(result["ok"].bool_value(), False) 848 assert_equal(result["request_id"].string_value(), "missing-input-1") 849 assert_equal(result["trace_id"].string_value(), "trace-missing-input-1") 850 assert_equal(result["error"]["code"].string_value(), "invalid_request") 851 assert_true( 852 result["error"]["message"] 853 .string_value() 854 .find("field 'input' is required") 855 >= 0 856 ) 857 858 859 def test_assisted_request_falls_back_deterministically_when_provider_is_unavailable() raises: 860 var result = _dispatch( 861 load_scenario_request_json( 862 "scenarios/assisted_backend_unavailable.json" 863 ) 864 ) 865 assert_matches_scenario_response( 866 result, "scenarios/assisted_backend_unavailable.json" 867 ) 868 869 870 def test_invalid_request_preserves_request_and_trace_correlation() raises: 871 var result = _dispatch(status_request_with_invalid_version_json()) 872 873 assert_equal(Int(result["version"].int_value()), 1) 874 assert_equal(result["request_id"].string_value(), "status-fixture-1") 875 assert_equal(result["trace_id"].string_value(), "trace-status-fixture-1") 876 assert_equal(result["ok"].bool_value(), False) 877 assert_equal(result["error"]["code"].string_value(), "invalid_request") 878 assert_true( 879 result["error"]["message"].string_value().find("unsupported") >= 0 880 ) 881 882 883 def test_internal_error_is_bounded_on_wire() raises: 884 with TemporaryDirectory() as temp_dir: 885 var diagnostics_dir = Path(temp_dir) / "hyf-internal-diagnostics" 886 with ScopedEnvVar( 887 _HYF_DIAGNOSTICS_DIR_ENV, diagnostics_dir.__fspath__() 888 ): 889 var result = run_stdio_entrypoint( 890 "tests/internal_error_stdio_main.mojo", 891 '{"version":1,"request_id":"status-internal-1","trace_id":"trace-status-internal-1","capability":"sys.status","input":{}}', 892 ) 893 894 _assert_internal_error_is_bounded(result) 895 896 897 def _assert_internal_error_is_bounded(result: Value) raises: 898 assert_equal(Int(result["version"].int_value()), 1) 899 assert_equal(result["request_id"].string_value(), "status-internal-1") 900 assert_equal(result["trace_id"].string_value(), "trace-status-internal-1") 901 assert_equal(result["ok"].bool_value(), False) 902 assert_equal(result["error"]["code"].string_value(), "internal_error") 903 assert_equal( 904 result["error"]["message"].string_value(), 905 _EXPECTED_INTERNAL_ERROR_MESSAGE, 906 ) 907 assert_true( 908 result["error"]["message"].string_value().find("simulated test-only") 909 < 0 910 ) 911 912 913 def test_internal_error_diagnostics_records_detail() raises: 914 with TemporaryDirectory() as temp_dir: 915 var diagnostics_dir = Path(temp_dir) / "hyf-internal-diagnostics" 916 917 with ScopedEnvVar( 918 _HYF_DIAGNOSTICS_DIR_ENV, diagnostics_dir.__fspath__() 919 ): 920 _ = run_stdio_entrypoint( 921 "tests/internal_error_stdio_main.mojo", 922 '{"version":1,"request_id":"status-internal-diag-1","trace_id":"trace-status-internal-diag-1","capability":"sys.status","input":{}}', 923 ) 924 925 assert_true(exists(diagnostics_dir)) 926 var entries = std.os.listdir(diagnostics_dir) 927 assert_equal(len(entries), 1) 928 assert_true(entries[0].startswith("hyf-internal-error-pid-")) 929 930 var content = (diagnostics_dir / entries[0]).read_text() 931 var lines = content.splitlines() 932 assert_equal(len(lines), 1) 933 assert_true( 934 content.find('request_id="status-internal-diag-1"') >= 0 935 ) 936 assert_true( 937 content.find( 938 'detail="simulated test-only status builder failure"' 939 ) 940 >= 0 941 ) 942 943 944 def main() raises: 945 TestSuite.discover_tests[__functions_in_module()]().run()