| """Router logic, tested with a controlled embedder rather than the real model. |
| |
| Model quality is a separate concern; what matters here is that ambiguity falls |
| back to the full profile instead of silently answering without evidence. |
| """ |
|
|
| import numpy as np |
| import pytest |
|
|
| from router import FULL, SPECIFIC, TRIVIAL, SemanticRouter |
|
|
| REFERENCES = {TRIVIAL: ["GREET"], SPECIFIC: ["NARROW"], FULL: ["BROAD"]} |
| AXIS = {"GREET": 0, "NARROW": 1, "BROAD": 2} |
|
|
|
|
| def fake_embed(texts): |
| """One-hot per route keyword; anything else is equidistant from all three.""" |
| vectors = [] |
| for text in texts: |
| vector = np.zeros(3, dtype=np.float32) |
| for token, axis in AXIS.items(): |
| if token in text: |
| vector[axis] = 1.0 |
| if not vector.any(): |
| vector[:] = 1 / np.sqrt(3) |
| vectors.append(vector) |
| return np.array(vectors, dtype=np.float32) |
|
|
|
|
| @pytest.fixture |
| def router(): |
| return SemanticRouter(fake_embed, references=REFERENCES) |
|
|
|
|
| @pytest.mark.parametrize( |
| "query,expected", |
| [("GREET", TRIVIAL), ("NARROW", SPECIFIC), ("BROAD", FULL)], |
| ) |
| def test_confident_queries_reach_their_route(router, query, expected): |
| assert router.route(query) == expected |
|
|
|
|
| def test_ambiguous_queries_fall_back_to_full(router): |
| """Equidistant from every route: answering without the profile is the costly error.""" |
| assert router.route("nothing in particular") == FULL |
|
|
|
|
| def test_a_tie_between_trivial_and_specific_falls_back_to_full(router): |
| assert router.route("GREET NARROW") == FULL |
|
|
|
|
| @pytest.mark.parametrize("query", ["", " ", None]) |
| def test_empty_queries_fall_back_to_full(router, query): |
| assert router.route(query) == FULL |
|
|
|
|
| def test_a_high_threshold_forces_the_safe_route(): |
| """An exact match scores 1.0 here, so the bar has to sit above it.""" |
| strict = SemanticRouter(fake_embed, references=REFERENCES, min_score=1.1) |
| assert strict.route("GREET") == FULL |
|
|
|
|
| def test_a_wide_margin_requirement_forces_the_safe_route(): |
| strict = SemanticRouter(fake_embed, references=REFERENCES, min_margin=1.1) |
| assert strict.route("NARROW") == FULL |
|
|
|
|
| def test_shipped_thresholds_leave_room_for_a_confident_match(): |
| from router import MIN_MARGIN, MIN_SCORE |
|
|
| assert 0 < MIN_SCORE < 1 |
| assert 0 < MIN_MARGIN < 1 |
|
|
|
|
| class TestRouteLogging: |
| """Answers do not reveal which tier produced them, so the log is the only |
| way to tell a full-profile answer from one built on five excerpts.""" |
|
|
| def test_the_chosen_route_is_logged(self, router, caplog): |
| with caplog.at_level("INFO", logger="router"): |
| router.route("NARROW") |
| assert "Route specific" in caplog.text |
|
|
| def test_the_log_records_every_score(self, router, caplog): |
| with caplog.at_level("INFO", logger="router"): |
| router.route("NARROW") |
| for route in (TRIVIAL, SPECIFIC, FULL): |
| assert f"{route}=" in caplog.text |
|
|
| def test_a_fallback_says_which_rule_rejected_the_winner(self, router, caplog): |
| """'Route full' alone cannot be told apart from a genuine full match.""" |
| with caplog.at_level("INFO", logger="router"): |
| router.route("GREET NARROW") |
| assert "min_margin" in caplog.text |
|
|
| def test_a_low_score_fallback_names_the_score_rule(self, caplog): |
| strict = SemanticRouter(fake_embed, references=REFERENCES, min_score=1.1) |
| with caplog.at_level("INFO", logger="router"): |
| strict.route("GREET") |
| assert "min_score" in caplog.text |
|
|
| def test_an_unroutable_query_still_logs(self, router, caplog): |
| with caplog.at_level("INFO", logger="router"): |
| router.route(None) |
| assert "Route full" in caplog.text |
|
|
|
|
| def test_scores_cover_every_route(router): |
| assert set(router.scores("GREET")) == {TRIVIAL, SPECIFIC, FULL} |
|
|
|
|
| def test_centroids_are_normalised(router): |
| assert np.allclose(np.linalg.norm(router.centroids, axis=1), 1.0) |
|
|
|
|
| class TestRealReferenceSet: |
| """The shipped reference queries must be well formed.""" |
|
|
| def test_every_route_has_examples(self): |
| from router import REFERENCE_QUERIES, SKILL_ROUTES |
|
|
| assert set(REFERENCE_QUERIES) == {TRIVIAL, SPECIFIC, FULL, *SKILL_ROUTES} |
| for examples in REFERENCE_QUERIES.values(): |
| assert len(examples) >= 5 |
|
|
| def test_examples_are_unique_across_routes(self): |
| from router import REFERENCE_QUERIES |
|
|
| seen = [q for examples in REFERENCE_QUERIES.values() for q in examples] |
| assert len(seen) == len(set(seen)) |
|
|
