tests/test_grade.py

"""Grading semantics: semantic argument comparison, abstention, scoring."""

from __future__ import annotations

from tooluse1.cases_build import call, none
from tooluse1.grade import grade_case, match_args, summarize, wilson_interval
from tooluse1.schema import Case, ExpectCall, ExpectNoCall


def make_case(expect, user="do it", tools=("calculator", "get_weather"), category="calculator", lang="en") -> Case:
    return Case(
        id="t-001",
        lang=lang,
        category=category,
        difficulty="easy",
        tools=tuple(tools),
        user=user,
        expect=expect,
    )


def test_expression_equivalence():
    match = match_args("calculator", {"expression": "45 + 12"}, {"expression": "45+12"})
    assert match.ok


def test_expression_evaluated_not_string_matched():
    assert match_args("calculator", {"expression": "(1000/8)**2"}, {"expression": "125 ** 2"}).ok


def test_expression_with_multiplication_symbols():
    assert match_args("calculator", {"expression": "45 * 12"}, {"expression": "45 × 12"}).ok


def test_expression_mismatch_detected():
    match = match_args("calculator", {"expression": "45 + 12"}, {"expression": "45 - 12"})
    assert not match.ok
    assert match.mismatched == ("expression",)


def test_numeric_tolerance():
    assert match_args("convert_currency", {"amount": 100, "from_currency": "USD", "to_currency": "EUR"}, {"amount": "100.0", "from_currency": "usd", "to_currency": "eur"}).ok


def test_currency_symbols_normalise():
    assert match_args("convert_currency", {"amount": 100, "from_currency": "USD", "to_currency": "EUR"}, {"amount": 100, "from_currency": "$", "to_currency": "€"}).ok


def test_language_name_normalises_to_code():
    assert match_args("translate", {"text": "hi", "target_language": "fr"}, {"text": "Hi", "target_language": "French"}).ok


def test_russian_language_name_normalises():
    assert match_args("translate", {"text": "привет", "target_language": "en"}, {"text": "привет", "target_language": "английский"}).ok


def test_city_alias_normalises():
    assert match_args("get_weather", {"city": "Saint Petersburg"}, {"city": "СПб"}).ok


def test_timezone_alias_normalises():
    assert match_args("get_time", {"timezone": "Europe/Moscow"}, {"timezone": "Moscow"}).ok


def test_unit_alias_normalises():
    assert match_args("convert_units", {"value": 5, "from_unit": "km", "to_unit": "mi"}, {"value": 5, "from_unit": "километров", "to_unit": "miles"}).ok


def test_seconds_accepts_float():
    assert match_args("set_timer", {"seconds": 300}, {"seconds": 300.0}).ok


def test_missing_argument_is_reported():
    match = match_args("get_weather", {"city": "Berlin"}, {})
    assert not match.ok
    assert match.missing == ("city",)


def test_extra_optional_argument_is_tolerated_but_flagged():
    match = match_args("get_weather", {"city": "Berlin"}, {"city": "Berlin", "unit": "celsius"})
    assert match.ok
    assert "unit" in match.extra


def test_unknown_extra_argument_is_flagged():
    match = match_args("get_weather", {"city": "Berlin"}, {"city": "Berlin", "force": True})
    assert match.ok
    assert match.extra == ("force",)


def test_name_aliases_are_accepted():
    case = make_case(call("calculator", expression="45+12"))
    result = grade_case(case, "json", '{"name": "calc", "arguments": {"expression": "45+12"}}')
    assert result.passed


def test_wrong_tool_fails_but_records_the_name():
    case = make_case(call("get_weather", city="Berlin"))
    result = grade_case(case, "json", '{"name": "calculator", "arguments": {"expression": "1+1"}}')
    assert not result.passed
    assert not result.name_correct


def test_two_calls_fail_a_single_call_case():
    case = make_case(call("get_time", timezone="UTC"), tools=("get_time",), category="get_time")
    raw = "TOOL get_time | timezone=UTC\nTOOL get_time | timezone=UTC"
    assert not grade_case(case, "plain", raw).passed


def test_abstention_passes_on_prose():
    case = make_case(none(all_=["canberra"]), tools=("calculator",), category="negative")
    result = grade_case(case, "json", "The capital of Australia is Canberra.")
    assert result.passed
    assert result.answer_ok is True


def test_spurious_call_fails_a_negative_case():
    case = make_case(none(all_=["57"]), tools=("get_weather",), category="negative")
    result = grade_case(case, "json", '{"name": "get_weather", "arguments": {"city": "Paris"}}')
    assert not result.passed
    assert result.called


def test_abstention_with_wrong_answer_fails():
    case = make_case(none(all_=["canberra"]), tools=("calculator",), category="negative")
    result = grade_case(case, "json", "The capital of Australia is Sydney.")
    assert not result.passed
    assert result.answer_ok is False


def test_unconstrained_negative_accepts_any_prose():
    case = make_case(none(), tools=("calculator",), category="negative")
    assert grade_case(case, "json", "Here is a joke.").passed


def test_answer_constraint_allows_language_variants():
    case = make_case(
        ExpectNoCall(answer_contains_any=(("который", "какой город"),)),
        tools=("get_weather",),
        category="clarification",
        lang="ru",
    )
    assert grade_case(case, "json", "Какой город вас интересует?").passed


def test_summary_metrics_shape():
    pass_case = make_case(call("calculator", expression="1+1"))
    fail_case = make_case(none(all_=["x"]), tools=("calculator",), category="negative")
    results = [
        grade_case(pass_case, "json", '{"name": "calculator", "arguments": {"expression": "1+1"}}'),
        grade_case(fail_case, "json", '{"name": "calculator", "arguments": {"expression": "1+1"}}'),
    ]
    summary = summarize(results, model_id="m")
    assert summary["n_cases"] == 2
    assert summary["overall"]["score"] == 0.5
    assert summary["overall"]["correct_call_when_expected"] == 1.0
    assert summary["overall"]["spurious_call_rate"] == 1.0
    assert summary["by_protocol"]["json"]["cases"] == 2


def test_wilson_interval_bounds():
    low, high = wilson_interval(50, 100)
    assert 0.39 < low < 0.41
    assert 0.59 < high < 0.61
    assert wilson_interval(0, 0) == (0.0, 0.0)


def test_every_protocol_grades_identically():
    case = make_case(call("calculator", expression="45 + 12"))
    for protocol, raw in (
        ("json", '{"name": "calculator", "arguments": {"expression": "45+12"}}'),
        ("xml", "<tool_call><function=calculator><parameter=expression>45+12</parameter></function></tool_call>"),
        ("plain", "TOOL calculator | expression=45+12"),
    ):
        assert grade_case(case, protocol, raw).passed, protocol