test_application.mojo (29809B)
1 from std.testing import TestSuite, assert_true, assert_equal, assert_raises 2 3 from hyf_application.orchestration import ( 4 application_layer_owns_business_state, 5 application_layer_uses_transport_types, 6 operation_is_supported, 7 supported_operations, 8 ) 9 10 11 def test_application_layer_is_transport_independent() raises: 12 assert_equal(len(supported_operations()), 3) 13 assert_true(operation_is_supported("farm_update.interpret")) 14 assert_true(operation_is_supported("buyer_request.match")) 15 assert_true(not operation_is_supported("query_rewrite")) 16 assert_true(not application_layer_uses_transport_types()) 17 assert_true(not application_layer_owns_business_state()) 18 19 20 def main() raises: 21 TestSuite.discover_tests[__functions_in_module()]().run() 22 23 24 from hyf_application.context import ( 25 context_is_trusted_host_supplied, 26 interpretation_source, 27 source_text_is_data_not_instruction, 28 ) 29 30 31 def test_interpretation_source_context_validation() raises: 32 var source = interpretation_source( 33 "farm-source-1", 34 "r1", 35 "Got about 80 lb of Roma tomatoes.", 36 "2026-09-21T09:00:00-07:00", 37 "America/Vancouver", 38 "farm-1", 39 "farm-1", 40 ) 41 assert_equal(source.revision, "r1") 42 assert_true(context_is_trusted_host_supplied()) 43 assert_true(source_text_is_data_not_instruction()) 44 with assert_raises(): 45 _ = interpretation_source("", "r1", "x", "t", "z", "a", "f") 46 with assert_raises(): 47 _ = interpretation_source("s", "r1", "x", "t", "", "a", "f") 48 49 50 from hyf_application.farm_status import ( 51 interpret_product_statuses, 52 status_is_confirmed_inventory, 53 status_is_forecast, 54 ) 55 56 57 def test_product_specific_supply_status_per_crop() raises: 58 var products = List[String]() 59 products.append("roma tomatoes") 60 products.append("basil") 61 var statuses = interpret_product_statuses(products, "offered") 62 assert_equal(len(statuses), 2) 63 assert_equal(statuses[0].product_phrase, "roma tomatoes") 64 assert_equal(statuses[1].product_phrase, "basil") 65 assert_true(not status_is_confirmed_inventory(statuses[0].status)) 66 var forecast = interpret_product_statuses(products, "forecast") 67 assert_true(status_is_forecast(forecast[0].status)) 68 var unknown = interpret_product_statuses(products, "probably") 69 assert_equal(unknown[0].status, "unclear") 70 71 72 from hyf_application.farm_quantity import ( 73 ProductQuantityAssociation, 74 associate_quantity, 75 reported_quantity_is_unreserved_stock, 76 ) 77 78 79 def test_quantity_association_per_product_without_swap() raises: 80 var tomatoes = associate_quantity( 81 "roma tomatoes", 80, 0, "lb", "approximate" 82 ) 83 var basil = associate_quantity("basil", 0, 0, "bunch", "exact") 84 assert_equal(tomatoes.product_phrase, "roma tomatoes") 85 assert_equal(tomatoes.quantity_value, 80) 86 assert_equal(tomatoes.qualifier, "approximate") 87 assert_equal(basil.product_phrase, "basil") 88 assert_true(tomatoes.quantity_value != basil.quantity_value) 89 assert_true(not reported_quantity_is_unreserved_stock()) 90 with assert_raises(): 91 _ = associate_quantity("", 1, 0, "kg", "exact") 92 93 94 from hyf_application.farm_changes import ( 95 interpret_update_change, 96 interpret_update_operation, 97 operation_is_proposal, 98 ) 99 100 101 def test_supply_update_operation_semantics() raises: 102 assert_equal(interpret_update_operation("another"), "addition") 103 assert_equal(interpret_update_operation("left"), "remaining") 104 assert_equal(interpret_update_operation("total"), "replacement") 105 assert_equal(interpret_update_operation("sold out"), "withdrawal") 106 assert_equal(interpret_update_operation("actually"), "correction") 107 assert_equal(interpret_update_operation("maybe"), "unresolved") 108 var addition = interpret_update_change( 109 "another", "listing", Optional[String]("b1") 110 ) 111 assert_equal(addition.operation, "addition") 112 var ambiguous = interpret_update_change("sold out", "listing", None) 113 assert_equal(ambiguous.operation, "unresolved") 114 assert_true(operation_is_proposal()) 115 116 117 from hyf_application.farm_targets import resolve_change_target 118 119 120 def test_authorized_change_target_resolution() raises: 121 var authorized = List[String]() 122 authorized.append("b1") 123 var resolved = resolve_change_target( 124 "withdrawal", Optional[String]("b1"), authorized 125 ) 126 assert_equal(resolved.operation, "withdrawal") 127 assert_equal(resolved.target_id.value(), "b1") 128 var unauthorized = resolve_change_target( 129 "withdrawal", Optional[String]("b9"), authorized 130 ) 131 assert_equal(unauthorized.operation, "unresolved") 132 assert_true(unauthorized.unresolved) 133 var ambiguous = resolve_change_target("withdrawal", None, authorized) 134 assert_equal(ambiguous.operation, "unresolved") 135 136 137 from hyf_application.farm_fulfillment import interpret_fulfillment 138 from hyf_core.domain.price import price_is_known 139 from hyf_core.domain.supply_change import ProposedSupplyChange 140 from hyf_core.domain.time import date_only 141 142 143 def test_farm_fulfillment_and_timing_claims() raises: 144 var monday = date_only(2026, 9, 21) 145 var delivery = interpret_fulfillment( 146 "delivery", "Friday", monday, "America/Vancouver" 147 ) 148 assert_equal(delivery.resolved_date, "2026-9-25") 149 assert_equal(delivery.ambiguity, "none") 150 assert_true(not delivery.area_verified) 151 var no_zone = interpret_fulfillment("delivery", "Friday", monday, "") 152 assert_equal(no_zone.ambiguity, "missing_zone") 153 var none = interpret_fulfillment("pickup", "", monday, "America/Vancouver") 154 assert_equal(none.window_expression, "") 155 156 157 from hyf_application.farm_review_output import ( 158 ambiguous_withdrawal_blocks_apply, 159 assemble_farm_output, 160 missing_optional_price_blocks_draft, 161 ) 162 from hyf_core.domain.execution import execution_meta 163 from hyf_core.domain.review import review_required 164 165 166 def test_farm_review_output_is_proposal_only() raises: 167 var products = List[String]() 168 products.append("roma tomatoes") 169 var statuses = interpret_product_statuses(products, "offered") 170 var changes = List[ProposedSupplyChange]() 171 var review = review_required("withdrawal.target", "ambiguous_target") 172 var execution = execution_meta("complete", 0, None, None, None) 173 var output = assemble_farm_output(statuses, changes, review, execution) 174 assert_equal(len(output.claims), 1) 175 assert_true(output.review.required) 176 assert_true(output.original_source_preserved) 177 assert_equal(output.hyf_business_writes, 0) 178 assert_true(not missing_optional_price_blocks_draft()) 179 assert_true(ambiguous_withdrawal_blocks_apply()) 180 181 182 from hyf_application.farm_clarification import ( 183 apply_farm_clarification, 184 clarification_overwrites_original, 185 farm_clarification_is_stale, 186 ) 187 188 189 def test_farm_clarification_is_revisioned_new_evidence() raises: 190 var refined = apply_farm_clarification( 191 "80", 192 "quantity.unreserved", 193 "farm-source-1", 194 "r2", 195 "60 lb unreserved", 196 "60", 197 ) 198 assert_equal(refined.value.value(), "60") 199 assert_equal(refined.method, "clarification") 200 assert_true(not clarification_overwrites_original()) 201 assert_true( 202 not farm_clarification_is_stale( 203 "quantity.unreserved", "farm-source-1", "r2", "60 lb", "r2" 204 ) 205 ) 206 assert_true( 207 farm_clarification_is_stale( 208 "quantity.unreserved", "farm-source-1", "r2", "60 lb", "r3" 209 ) 210 ) 211 212 213 from hyf_application.farm_failure import ( 214 farm_inference_degraded, 215 farm_inference_failure, 216 inference_failure_confirms_stock, 217 ) 218 219 220 def test_farm_inference_failure_never_confirms_stock() raises: 221 var failed = farm_inference_failure("provider_timeout") 222 assert_equal(failed.status, "failed") 223 assert_equal(failed.confirmed_claims, 0) 224 assert_equal(failed.unresolved_claims, 1) 225 var degraded = farm_inference_degraded("provider_degraded") 226 assert_equal(degraded.status, "degraded") 227 assert_true(not inference_failure_confirms_stock()) 228 with assert_raises(): 229 _ = farm_inference_failure("") 230 231 232 from hyf_application.buyer_lines import DemandLineDraft, discover_demand_lines 233 234 235 def test_buyer_discovers_multiple_demand_lines() raises: 236 var phrases = List[String]() 237 phrases.append("tomatoes") 238 phrases.append("basil") 239 var lines = discover_demand_lines(phrases) 240 assert_equal(len(lines), 2) 241 assert_equal(lines[0].product_phrase, "tomatoes") 242 assert_equal(lines[1].product_phrase, "basil") 243 assert_equal(lines[0].line_id, "line-1") 244 245 246 from hyf_application.buyer_conditions import ( 247 delivery_exclusion_means_pickup, 248 interpret_buyer_condition, 249 interpret_condition_strength, 250 missing_information_is_prohibition, 251 ) 252 from std.collections import Optional 253 254 255 def test_buyer_condition_strength_and_negation() raises: 256 assert_equal(interpret_condition_strength("required"), "mandatory") 257 assert_equal(interpret_condition_strength("ideally"), "preferred") 258 assert_equal(interpret_condition_strength("not"), "excluded") 259 assert_equal(interpret_condition_strength("fine"), "permitted") 260 var required = interpret_buyer_condition( 261 "fulfillment", "required", Optional[String]("delivery") 262 ) 263 assert_equal(required.strength, "mandatory") 264 var excluded = interpret_buyer_condition( 265 "fulfillment", "not", Optional[String]("pickup") 266 ) 267 assert_equal(excluded.strength, "excluded") 268 assert_true(not delivery_exclusion_means_pickup()) 269 assert_true(not missing_information_is_prohibition()) 270 271 272 from hyf_application.buyer_normalization import ( 273 normalize_buyer_price, 274 normalize_buyer_quantity, 275 unknown_price_is_free, 276 unsupported_conversion_is_zero, 277 ) 278 279 280 def test_buyer_quantity_and_price_normalization() raises: 281 var quantity = normalize_buyer_quantity(25, 0, "kg", "exact") 282 assert_equal(quantity.value, 25) 283 assert_equal(quantity.dimension, "mass") 284 var price = normalize_buyer_price(0, 2, "", "per_unit") 285 assert_true(not price_is_known(price)) 286 assert_true(not unknown_price_is_free()) 287 assert_true(not unsupported_conversion_is_zero()) 288 289 290 from hyf_application.buyer_contradictions import ( 291 contradictions_are_visible, 292 detect_contradictions, 293 ) 294 from hyf_core.domain.demand import Condition, condition 295 296 297 def test_buyer_contradiction_detection() raises: 298 var conditions = List[Condition]() 299 conditions.append( 300 condition("fulfillment", "mandatory", Optional[String]("delivery")) 301 ) 302 conditions.append( 303 condition("fulfillment", "excluded", Optional[String]("delivery")) 304 ) 305 var contradictions = detect_contradictions(conditions) 306 assert_equal(len(contradictions), 1) 307 assert_true(contradictions_are_visible()) 308 309 var clean = List[Condition]() 310 clean.append( 311 condition("fulfillment", "mandatory", Optional[String]("delivery")) 312 ) 313 clean.append( 314 condition("fulfillment", "excluded", Optional[String]("pickup")) 315 ) 316 assert_equal(len(detect_contradictions(clean)), 0) 317 318 319 from hyf_application.buyer_needs import ( 320 BuyerNeedOutput, 321 assemble_buyer_need, 322 buyer_need_creates_order, 323 needs_reparse_rewritten_text, 324 ) 325 from hyf_core.domain.demand import DemandLine, demand_line 326 from hyf_core.domain.execution import execution_meta 327 from hyf_core.domain.product import resolved_product 328 from hyf_core.domain.review import review_clear 329 330 331 def test_assemble_reviewable_typed_buyer_need() raises: 332 var tomatoes = resolved_product("tomatoes", "tomato") 333 var conditions = List[Condition]() 334 conditions.append( 335 condition("fulfillment", "mandatory", Optional[String]("delivery")) 336 ) 337 var lines = List[DemandLine]() 338 lines.append(demand_line("l1", tomatoes, "known", 25, 0, conditions)) 339 var output = assemble_buyer_need( 340 lines, review_clear(), execution_meta("complete", 0, None, None, None) 341 ) 342 assert_equal(len(output.demand_lines), 1) 343 assert_true(not needs_reparse_rewritten_text()) 344 assert_true(not buyer_need_creates_order()) 345 with assert_raises(): 346 _ = assemble_buyer_need( 347 List[DemandLine](), 348 review_clear(), 349 execution_meta("complete", 0, None, None, None), 350 ) 351 352 353 from hyf_application.buyer_failure import ( 354 buyer_failure_means_unavailable_supply, 355 buyer_inference_degraded, 356 buyer_inference_failure, 357 ) 358 359 360 def test_buyer_inference_failure_is_not_market_absence() raises: 361 var failed = buyer_inference_failure("provider_timeout") 362 assert_equal(failed.status, "failed") 363 assert_equal(failed.resolved_lines, 0) 364 var degraded = buyer_inference_degraded("provider_degraded") 365 assert_equal(degraded.status, "degraded") 366 assert_true(not buyer_failure_means_unavailable_supply()) 367 368 369 from hyf_application.match_input import ( 370 caller_name_is_authentication, 371 validate_match_scope, 372 validate_supplied_lots, 373 ) 374 375 376 def test_match_input_scope_and_lot_validation() raises: 377 validate_match_scope("tenant-1", "tenant-1") 378 with assert_raises(): 379 validate_match_scope("tenant-1", "tenant-2") 380 with assert_raises(): 381 validate_match_scope("", "tenant-1") 382 var keys = List[String]() 383 keys.append("lot-1@l1") 384 keys.append("lot-2@l1") 385 assert_equal(len(validate_supplied_lots(keys)), 2) 386 var dupes = List[String]() 387 dupes.append("lot-1@l1") 388 dupes.append("lot-1@l1") 389 with assert_raises(): 390 _ = validate_supplied_lots(dupes) 391 assert_true(not caller_name_is_authentication()) 392 393 394 from hyf_application.match_index import ( 395 duplicate_records_double_stock, 396 index_supplied_lots, 397 ) 398 399 400 def test_index_supplied_lots_rejects_duplicates_and_conflicts() raises: 401 var ids = List[String]() 402 ids.append("lot-1") 403 ids.append("lot-2") 404 var revisions = List[String]() 405 revisions.append("l1") 406 revisions.append("l1") 407 assert_equal(len(index_supplied_lots(ids, revisions)), 2) 408 409 var dup_ids = List[String]() 410 dup_ids.append("lot-1") 411 dup_ids.append("lot-1") 412 var dup_revs = List[String]() 413 dup_revs.append("l1") 414 dup_revs.append("l1") 415 with assert_raises(): 416 _ = index_supplied_lots(dup_ids, dup_revs) 417 418 var conflict_ids = List[String]() 419 conflict_ids.append("lot-1") 420 conflict_ids.append("lot-1") 421 var conflict_revs = List[String]() 422 conflict_revs.append("l1") 423 conflict_revs.append("l2") 424 with assert_raises(): 425 _ = index_supplied_lots(conflict_ids, conflict_revs) 426 assert_true(not duplicate_records_double_stock()) 427 428 429 from hyf_application.match_checks import ( 430 check_product, 431 semantic_score_can_rescue_product, 432 ) 433 from hyf_core.domain.product import resolved_product, unresolved_product 434 435 436 def test_product_and_substitution_check() raises: 437 var tomato = resolved_product("tomatoes", "tomato") 438 var roma = resolved_product("roma tomatoes", "tomato") 439 pass_check = check_product(tomato, roma, False) 440 assert_equal(pass_check.result, "pass") 441 var carrot = resolved_product("carrots", "carrot") 442 fail_check = check_product(tomato, carrot, False) 443 assert_equal(fail_check.result, "fail") 444 assert_equal(fail_check.reason, "product_mismatch") 445 var substitution = check_product(tomato, carrot, True) 446 assert_equal(substitution.result, "unknown") 447 var unknown = check_product(unresolved_product("mystery"), roma, False) 448 assert_equal(unknown.result, "unknown") 449 assert_true(not semantic_score_can_rescue_product()) 450 451 452 from hyf_application.match_checks import ( 453 check_required_attributes, 454 model_confidence_verifies_certification, 455 ) 456 457 458 def test_grade_and_required_attribute_checks() raises: 459 var required = List[String]() 460 required.append("organic") 461 var verified = List[String]() 462 verified.append("organic") 463 assert_equal(check_required_attributes(required, verified).result, "pass") 464 assert_equal( 465 check_required_attributes(required, List[String]()).result, "unknown" 466 ) 467 assert_equal( 468 check_required_attributes(List[String](), verified).result, "pass" 469 ) 470 assert_true(not model_confidence_verifies_certification()) 471 472 473 from hyf_application.match_checks import ( 474 check_area, 475 check_fulfillment, 476 delivery_mention_verifies_area, 477 ) 478 479 480 def test_fulfillment_method_and_area_checks() raises: 481 assert_equal(check_fulfillment("delivery", "delivery").result, "pass") 482 assert_equal(check_fulfillment("delivery", "pickup").result, "fail") 483 assert_equal(check_fulfillment("delivery", "").result, "unknown") 484 assert_equal(check_fulfillment("", "pickup").result, "pass") 485 assert_equal(check_area("Vancouver", "").result, "unknown") 486 assert_equal(check_area("", "").result, "pass") 487 assert_true(not delivery_mention_verifies_area()) 488 489 490 from hyf_application.match_checks import ( 491 check_availability, 492 check_window, 493 weekend_similarity_satisfies_specific_window, 494 ) 495 496 497 def test_availability_and_window_checks() raises: 498 assert_equal(check_availability("known").result, "pass") 499 assert_equal(check_availability("unknown").result, "unknown") 500 assert_equal( 501 check_window( 502 "2026-09-25", "2026-09-25", "2026-09-25", "2026-09-25" 503 ).result, 504 "pass", 505 ) 506 assert_equal( 507 check_window( 508 "2026-09-25", "2026-09-25", "2026-09-27", "2026-09-27" 509 ).result, 510 "fail", 511 ) 512 assert_equal( 513 check_window("2026-09-25", "2026-09-25", "", "").result, "unknown" 514 ) 515 assert_equal(check_window("", "", "", "").result, "pass") 516 assert_true(not weekend_similarity_satisfies_specific_window()) 517 518 519 from hyf_application.match_checks import check_price 520 from hyf_core.domain.price import ( 521 known_price as _known_price, 522 unknown_price as _unknown_price, 523 ) 524 525 526 def test_applicable_price_and_minimum_order_checks() raises: 527 var ceiling = _known_price(500, 2, "CAD", "per_unit") 528 assert_equal( 529 check_price(ceiling, _known_price(450, 2, "CAD", "per_unit")).result, 530 "pass", 531 ) 532 assert_equal( 533 check_price(ceiling, _known_price(550, 2, "CAD", "per_unit")).result, 534 "fail", 535 ) 536 assert_equal(check_price(ceiling, _unknown_price()).result, "unknown") 537 assert_equal( 538 check_price( 539 _unknown_price(), _known_price(1, 2, "CAD", "per_unit") 540 ).result, 541 "pass", 542 ) 543 544 545 from hyf_application.match_checks import check_quantity 546 from hyf_core.domain.quantity import new_quantity 547 548 549 def test_per_lot_quantity_feasibility() raises: 550 var required = new_quantity(50, 0, "kg", "mass", "exact") 551 var enough = new_quantity(50, 0, "kg", "mass", "exact") 552 var short = new_quantity(30, 0, "kg", "mass", "exact") 553 assert_equal(check_quantity(required, enough, True, False).result, "pass") 554 assert_equal(check_quantity(required, short, True, False).result, "fail") 555 assert_equal(check_quantity(required, short, True, True).result, "pass") 556 assert_equal( 557 check_quantity(required, short, False, False).result, "unknown" 558 ) 559 560 561 from hyf_application.match_checks import ( 562 compose_applicable_checks, 563 scores_affect_feasibility, 564 ) 565 from hyf_core.domain.eligibility import ( 566 ConstraintAssessment, 567 constraint_assessment, 568 ) 569 570 571 def test_compose_applicable_checks_before_ranking() raises: 572 var checks = List[ConstraintAssessment]() 573 checks.append( 574 constraint_assessment("product", "pass", True, "product_match") 575 ) 576 checks.append( 577 constraint_assessment("quantity", "fail", True, "quantity_insufficient") 578 ) 579 checks.append( 580 constraint_assessment("window", "unknown", True, "window_mismatch") 581 ) 582 assert_equal(compose_applicable_checks(checks), "ineligible") 583 var only_unknown = List[ConstraintAssessment]() 584 only_unknown.append( 585 constraint_assessment("quantity", "unknown", True, "stock_unknown") 586 ) 587 assert_equal(compose_applicable_checks(only_unknown), "conditional") 588 assert_true(not scores_affect_feasibility()) 589 590 591 from hyf_application.match_plan import ( 592 allocate_single_line, 593 group_lots_by_supplier, 594 multi_supplier_is_supported, 595 ) 596 from hyf_core.domain.plan import ( 597 LotCapacity, 598 MatchPlan, 599 plan_conservation_violations, 600 ) 601 602 603 def test_supplier_grouping_and_bounded_allocation() raises: 604 var lots = List[String]() 605 lots.append("lot-1") 606 lots.append("lot-2") 607 var suppliers = List[String]() 608 suppliers.append("farm-1") 609 suppliers.append("farm-1") 610 var grouped = group_lots_by_supplier(lots, suppliers) 611 assert_equal(len(grouped), 1) 612 assert_equal(grouped[0], "farm-1") 613 614 var capacities = List[LotCapacity]() 615 capacities.append( 616 LotCapacity(lot_id="lot-1", revision="l1", value=30, scale=0) 617 ) 618 capacities.append( 619 LotCapacity(lot_id="lot-2", revision="l1", value=40, scale=0) 620 ) 621 var plan = allocate_single_line("p1", "line-1", "farm-1", 50, 0, capacities) 622 assert_equal(len(plan.allocations), 2) 623 assert_equal(len(plan_conservation_violations(plan, capacities)), 0) 624 assert_true(not multi_supplier_is_supported()) 625 626 627 from hyf_application.match_plan import ( 628 PlannerBounds, 629 enforce_plan_bound, 630 planner_bounds, 631 ) 632 633 634 def test_bounded_single_line_allocation() raises: 635 var bounds = planner_bounds(10, 3) 636 assert_equal(bounds.max_plans, 3) 637 enforce_plan_bound(2, bounds) 638 with assert_raises(): 639 enforce_plan_bound(4, bounds) 640 with assert_raises(): 641 _ = planner_bounds(0, 3) 642 643 644 from hyf_application.match_plan import ( 645 allocate_multiple_lines, 646 shared_lot_allows_concurrent_over_allocation, 647 ) 648 649 650 def test_conservation_across_multiple_demand_lines() raises: 651 var capacities = List[LotCapacity]() 652 capacities.append( 653 LotCapacity(lot_id="lot-1", revision="l1", value=50, scale=0) 654 ) 655 var lines = List[String]() 656 lines.append("line-1") 657 lines.append("line-2") 658 var required = List[Int]() 659 required.append(30) 660 required.append(30) 661 var plan = allocate_multiple_lines( 662 "p1", "farm-1", lines, required, capacities 663 ) 664 # 50 kg lot cannot satisfy two 30 kg lines: total allocated is capped at 50. 665 var total = 0 666 for entry in plan.allocations: 667 total += entry.value 668 assert_equal(total, 50) 669 assert_equal(len(plan_conservation_violations(plan, capacities)), 0) 670 assert_true(not shared_lot_allows_concurrent_over_allocation()) 671 672 673 from hyf_application.match_plan import ( 674 partial_outcome, 675 partial_discloses_deficit, 676 ) 677 678 679 def test_explicit_partial_fulfillment_outcome() raises: 680 var full = partial_outcome(50, 50, False) 681 assert_true(full.fulfilled) 682 assert_equal(full.uncovered_value, 0) 683 var partial = partial_outcome(50, 30, True) 684 assert_true(not partial.fulfilled) 685 assert_equal(partial.uncovered_value, 20) 686 assert_true(partial.permitted) 687 var disallowed = partial_outcome(50, 30, False) 688 assert_true(not disallowed.permitted) 689 assert_true(partial_discloses_deficit()) 690 691 692 from hyf_application.match_plan import ( 693 alternative_plans, 694 unsupported_mode_means_no_supply, 695 ) 696 697 698 def test_alternative_plans_and_planner_limitations() raises: 699 var capacities = List[LotCapacity]() 700 capacities.append( 701 LotCapacity(lot_id="lot-1", revision="l1", value=50, scale=0) 702 ) 703 var plans = List[MatchPlan]() 704 plans.append( 705 allocate_single_line("p1", "line-1", "farm-1", 25, 0, capacities) 706 ) 707 plans.append( 708 allocate_single_line("p2", "line-1", "farm-1", 30, 0, capacities) 709 ) 710 var unsupported = List[String]() 711 unsupported.append("multi_supplier") 712 var offer = alternative_plans(plans, unsupported) 713 assert_equal(len(offer.plans), 2) 714 assert_true(not offer.alternatives_are_simultaneous) 715 assert_equal(len(offer.unsupported), 1) 716 assert_true(not unsupported_mode_means_no_supply()) 717 718 719 from hyf_application.match_semantic import ( 720 evidence_sufficient, 721 gated_semantic_suitability, 722 unknown_evidence_is_midpoint_score, 723 ) 724 725 726 def test_semantic_suitability_gated_on_evidence() raises: 727 assert_true(evidence_sufficient(2, 1)) 728 assert_equal(gated_semantic_suitability(3, 2, 1).result, "pass") 729 assert_equal(gated_semantic_suitability(3, 0, 1).result, "unknown") 730 assert_equal( 731 gated_semantic_suitability(3, 0, 1).reason, "evidence_insufficient" 732 ) 733 assert_true(not unknown_evidence_is_midpoint_score()) 734 735 736 from hyf_application.match_semantic import ( 737 culinary_score_affects_feasibility, 738 culinary_use_score, 739 ) 740 from hyf_assist.evaluator import typed_score 741 742 743 def test_culinary_use_semantic_scoring_gated() raises: 744 var answer = typed_score("culinary_fit", 2, 3, 1.0) 745 assert_equal(culinary_use_score(answer, 3, 1, 1), 1.0) 746 assert_equal( 747 culinary_use_score(typed_score("culinary_fit", 1, 3, 1.0), 3, 1, 1), 0.5 748 ) 749 with assert_raises(): 750 _ = culinary_use_score(answer, 3, 0, 1) 751 assert_true(not culinary_score_affects_feasibility()) 752 753 754 from hyf_application.match_ranking import ( 755 PreferenceComponent, 756 compose_preference, 757 preference_component, 758 preference_is_success_probability, 759 rank_by_preference, 760 ) 761 762 763 def test_versioned_preference_composition_and_stable_ties() raises: 764 var components = List[PreferenceComponent]() 765 components.append(preference_component("culinary", 1.0, 1.0)) 766 components.append(preference_component("distance", 0.5, 1.0)) 767 assert_equal(compose_preference(components), 75) 768 assert_true(not preference_is_success_probability()) 769 var ids = List[String]() 770 ids.append("plan-b") 771 ids.append("plan-a") 772 ids.append("plan-c") 773 var scores = List[Int]() 774 scores.append(50) 775 scores.append(50) 776 scores.append(70) 777 var ranked = rank_by_preference(ids, scores) 778 assert_equal(ranked[0], "plan-c") 779 assert_equal(ranked[1], "plan-a") 780 assert_equal(ranked[2], "plan-b") 781 782 783 from hyf_application.match_ranking import ( 784 rank_match_plans, 785 ranking_is_order_independent, 786 ) 787 788 789 def test_deterministic_ranking_and_tie_breaks() raises: 790 var capacities = List[LotCapacity]() 791 capacities.append( 792 LotCapacity(lot_id="lot-1", revision="l1", value=50, scale=0) 793 ) 794 var plans = List[MatchPlan]() 795 plans.append( 796 allocate_single_line("plan-b", "line-1", "farm-1", 25, 0, capacities) 797 ) 798 plans.append( 799 allocate_single_line("plan-a", "line-1", "farm-1", 25, 0, capacities) 800 ) 801 var scores = List[Int]() 802 scores.append(50) 803 scores.append(50) 804 var ranked = rank_match_plans(plans, scores) 805 assert_equal(ranked[0].plan_id, "plan-a") 806 assert_equal(ranked[1].plan_id, "plan-b") 807 assert_true(ranking_is_order_independent()) 808 809 810 from hyf_application.match_explain import ( 811 explanation_claims_global_availability, 812 explanation_claims_reservation, 813 explanation_reveals_private_source, 814 match_explanation, 815 ) 816 817 818 def test_evidence_backed_match_explanations() raises: 819 var lines = List[String]() 820 lines.append("line-1") 821 var text = match_explanation("farm-1", lines, "supplied_only") 822 assert_true(text.find("farm-1") >= 0) 823 assert_true(text.find("line-1") >= 0) 824 assert_true(text.find("not a reservation") >= 0) 825 assert_true(not explanation_reveals_private_source()) 826 assert_true(not explanation_claims_reservation()) 827 assert_true(not explanation_claims_global_availability()) 828 829 830 from hyf_application.match_outage import ( 831 RankingOutcome, 832 outage_changes_feasibility, 833 ranking_outage, 834 ) 835 836 837 def test_semantic_ranking_failure_preserves_feasibility() raises: 838 var outcome = ranking_outage("eligible", "provider_degraded") 839 assert_equal(outcome.feasibility, "eligible") 840 assert_equal(outcome.advisory, "degraded") 841 var conditional = ranking_outage("conditional", "provider_unavailable") 842 assert_equal(conditional.feasibility, "conditional") 843 assert_true(not outage_changes_feasibility()) 844 with assert_raises(): 845 _ = ranking_outage("eligible", "") 846 847 848 from hyf_application.farm_operation import execute_farm_update_interpret 849 from json import loads as _json_loads 850 851 852 def test_farm_update_operation_returns_proposal_output() raises: 853 var input = _json_loads( 854 '{"source":{"source_id":"s1","revision":"r1","text":"Got about 80 lb of' 855 " Roma" 856 ' tomatoes.","source_time":"2026-09-21T09:00:00-07:00","timezone":"America/Vancouver","actor_id":"farm-1","farm_id":"farm-1"},"taxonomy":{"products":["roma' 857 ' tomatoes"],"units":["lb"],"dates":[]}}' 858 ) 859 var output = execute_farm_update_interpret(input) 860 assert_equal(len(output["claims"].array_items()), 1) 861 assert_true(output["review"]["required"].bool_value()) 862 assert_equal(output["execution"]["status"].string_value(), "complete") 863 assert_true(output["original_source_preserved"].bool_value()) 864 with assert_raises(): 865 _ = execute_farm_update_interpret(_json_loads("{}")) 866 867 868 from hyf_application.buyer_operation import ( 869 execute_buyer_request_interpret, 870 execute_buyer_request_match, 871 ) 872 873 874 def test_buyer_request_operations_return_proposals() raises: 875 var source = _json_loads( 876 '{"source":{"source_id":"b1","revision":"r1","text":"Need 25 kg of' 877 ' tomatoes.",' 878 '"source_time":"2026-09-21T09:05:00-07:00","timezone":"America/Vancouver",' 879 '"actor_id":"buyer-1","farm_id":"buyer-1"}}' 880 ) 881 var interpreted = execute_buyer_request_interpret(source) 882 assert_true(interpreted["review"]["required"].bool_value()) 883 var match_input = _json_loads( 884 '{"need":{"need_id":"n1"},"snapshots":[{"lot_id":"lot-1"}]}' 885 ) 886 var matched = execute_buyer_request_match(match_input) 887 assert_equal( 888 matched["limitations"]["scope"].string_value(), "supplied_only" 889 ) 890 with assert_raises(): 891 _ = execute_buyer_request_match(_json_loads("{}"))