| """End-to-end harness behaviour: dataset loading, run loop, reporting, failures.""" |
|
|
| from __future__ import annotations |
|
|
| import json |
|
|
| from tooluse1.cases_build import build |
| from tooluse1.harness import load_cases, run_cases, slugify |
| from tooluse1.report import build_report, leaderboard_row, render_markdown |
| from tooluse1.runners import FencedRunner, NullRunner, OracleRunner, Prompt, Runner |
|
|
|
|
| class ExplodingRunner(Runner): |
| name = "exploding" |
|
|
| def complete(self, prompt: Prompt) -> str: |
| raise RuntimeError("connection reset") |
|
|
|
|
| def test_dataset_matches_builder(): |
| cases = load_cases() |
| assert [case.id for case in cases] == [case.id for case in build()] |
| assert len(cases) == len(build()) |
|
|
|
|
| def test_filters(): |
| assert all(case.lang == "en" for case in load_cases(langs=["en"])) |
| assert all(case.category == "negative" for case in load_cases(categories=["negative"])) |
| assert len(load_cases(limit=5)) == 5 |
|
|
|
|
| def test_oracle_runner_is_perfect_on_a_subset(): |
| cases = load_cases(limit=24) |
| results = run_cases(cases, OracleRunner(), protocols=("json",)) |
| summary = build_report(results, model_id="oracle")["summary"] |
| assert summary["overall"]["score"] == 1.0 |
|
|
|
|
| def test_parse_stress_runners_are_perfect(): |
| cases = load_cases(limit=24) |
| for runner in (FencedRunner(),): |
| results = run_cases(cases, runner, protocols=("json", "xml", "plain")) |
| assert build_report(results, model_id=runner.name)["summary"]["overall"]["score"] == 1.0 |
|
|
|
|
| def test_null_runner_abstains_on_everything(): |
| results = run_cases(load_cases(limit=40), NullRunner(), protocols=("json",)) |
| summary = build_report(results, model_id="null")["summary"]["overall"] |
| assert summary["correct_call_when_expected"] == 0.0 |
| assert summary["spurious_call_rate"] == 0.0 |
|
|
|
|
| def test_runner_errors_become_failed_cases(): |
| results = run_cases(load_cases(limit=10), ExplodingRunner(), protocols=("json",)) |
| assert results |
| assert all(not result.passed for result in results) |
| assert all("runner error" in result.detail for result in results) |
|
|
|
|
| def test_run_records_protocol_and_language_dimensions(): |
| results = run_cases(load_cases(limit=12), OracleRunner(), protocols=("json", "xml")) |
| summary = build_report(results, model_id="oracle")["summary"] |
| assert set(summary["by_protocol"]) == {"json", "xml"} |
| assert summary["n_cases"] == 24 |
|
|
|
|
| def test_skip_set_is_honoured(): |
| cases = load_cases(limit=6) |
| skip = {(case.id, "json") for case in cases} |
| results = run_cases(cases, OracleRunner(), protocols=("json",), skip=skip) |
| assert results == [] |
|
|
|
|
| def test_report_markdown_mentions_metrics(): |
| results = run_cases(load_cases(limit=18), OracleRunner(), protocols=("json",)) |
| report = build_report(results, model_id="HardcoreAI/Nova-1.1-0.8B", protocol="json") |
| markdown = render_markdown(report["summary"], report) |
| assert "HardcoreAI/Nova-1.1-0.8B" in markdown |
| assert "Spurious-call rate" in markdown |
| assert "By category" in markdown |
|
|
|
|
| def test_leaderboard_row_shape(): |
| results = run_cases(load_cases(limit=18), OracleRunner(), protocols=("json",)) |
| report = build_report(results, model_id="oracle", protocol="json") |
| row = leaderboard_row(report, "oracle", link="https://example.invalid", protocol="json") |
| assert row["score"] == 1.0 |
| assert row["n_cases"] == 18 |
| assert len(row["score_ci95"]) == 2 |
|
|
|
|
| def test_slugify_is_filesystem_safe(): |
| assert slugify("HardcoreAI/Nova-1.1-0.8B") == "HardcoreAI__Nova-1.1-0.8B" |
|
|
|
|
| def test_scripted_runner_overrides_specific_cases(): |
| from tooluse1.runners import ScriptedRunner |
|
|
| cases = load_cases(limit=3) |
| overrides = {cases[0].id: '{"name": "calculator", "arguments": {"expression": "1+1"}}'} |
| results = run_cases(cases, ScriptedRunner(overrides), protocols=("json",)) |
| assert len(results) == 3 |
| assert results[0].called and results[0].output == overrides[cases[0].id] |
| assert not results[1].called |
|
|
|
|
| def test_unknown_backend_is_rejected(): |
| import pytest |
|
|
| from tooluse1.runners import build_runner |
|
|
| with pytest.raises(ValueError): |
| build_runner("does-not-exist", model="x") |
|
|
|
|
| class BatchRecordingRunner(OracleRunner): |
| """Records the batch shape it was asked for, and can poison one batch.""" |
|
|
| name = "recording" |
|
|
| def __init__(self, poison_at: int | None = None): |
| self.batches: list[int] = [] |
| self._poison_at = poison_at |
| self.calls = 0 |
|
|
| def complete_many(self, prompts): |
| self.calls += 1 |
| self.batches.append(len(prompts)) |
| if self._poison_at is not None and self.calls == self._poison_at: |
| raise RuntimeError("simulated CUDA OOM on a batch") |
| return [super(BatchRecordingRunner, self).complete(prompt) for prompt in prompts] |
|
|
|
|
| def test_batching_splits_into_batch_sized_chunks(): |
| cases = load_cases(limit=10) |
| runner = BatchRecordingRunner() |
| results = run_cases(cases, runner, protocols=("json",), batch_size=4) |
| assert runner.batches == [4, 4, 2] |
| assert len(results) == 10 |
| assert all(result.passed for result in results) |
|
|
|
|
| def test_batched_and_unbatched_agree(): |
| cases = load_cases(limit=12) |
| batched = run_cases(cases, OracleRunner(), protocols=("json", "xml"), batch_size=5) |
| single = run_cases(cases, OracleRunner(), protocols=("json", "xml"), batch_size=1) |
| assert [(r.case_id, r.protocol, r.passed) for r in batched] == [(r.case_id, r.protocol, r.passed) for r in single] |
|
|
|
|
| def test_poisoned_batch_falls_back_to_single_calls(): |
| cases = load_cases(limit=8) |
| runner = BatchRecordingRunner(poison_at=1) |
| results = run_cases(cases, runner, protocols=("json",), batch_size=4) |
| assert len(results) == 8 |
| assert all(result.passed for result in results), "per-item fallback must recover the batch" |
| assert runner.batches[0] == 4 |
|
|
|
|
| def test_batch_size_is_capped_by_remaining_cases(): |
| cases = load_cases(limit=3) |
| runner = BatchRecordingRunner() |
| run_cases(cases, runner, protocols=("json",), batch_size=16) |
| assert runner.batches == [3] |
|
|
