iop/agent-ops/skills/common/finalize-task-routing/tests/test_finalize_task_routing.py

#!/usr/bin/env python3
from __future__ import annotations

import itertools
import subprocess
import unittest
from pathlib import Path


SKILL_DIR = Path(__file__).resolve().parents[1]
FORMATTER = SKILL_DIR / "scripts" / "finalize-task-route.sh"
POLICY_FINALIZER = SKILL_DIR / "scripts" / "finalize-task-policy.sh"

GRADE_VECTORS = {
    1: (0, 0, 0, 0, 0),
    2: (2, 0, 0, 0, 0),
    3: (2, 1, 0, 0, 0),
    4: (2, 2, 0, 0, 0),
    5: (2, 2, 1, 0, 0),
    6: (2, 2, 2, 0, 0),
    7: (2, 2, 2, 1, 0),
    8: (2, 2, 2, 2, 0),
    9: (2, 2, 2, 2, 1),
    10: (2, 2, 2, 2, 2),
}


def run(
    script: Path, *args: object, check: bool = True
) -> subprocess.CompletedProcess[str]:
    return subprocess.run(
        [str(script), *(str(arg) for arg in args)],
        check=check,
        capture_output=True,
        text=True,
        timeout=5,
    )


def fields(stdout: str) -> dict[str, str]:
    return dict(line.split("=", 1) for line in stdout.splitlines())


def expected_build_route(basis: str, grade: int) -> tuple[str, bool]:
    if basis == "local-fit":
        return "local", grade <= 8
    if basis == "capability-gap":
        return "cloud", True
    return "cloud", grade >= 9


def pair_args(
    build_basis: str,
    build_grade: int,
    review_grade: int,
    risk: str = "false",
    review_basis: str = "official-review",
) -> tuple[object, ...]:
    return (
        "pair",
        build_basis,
        risk,
        *GRADE_VECTORS[build_grade],
        review_basis,
        *GRADE_VECTORS[review_grade],
    )


class FinalizeTaskRoutingTests(unittest.TestCase):
    def assert_route(
        self,
        result: dict[str, str],
        target: str,
        basis: str,
        lane: str,
        grade: int,
    ) -> None:
        prefix = "PLAN" if target == "build" else "CODE_REVIEW"
        self.assertEqual(result[f"{target}_route_basis"], basis)
        self.assertEqual(result[f"{target}_lane"], lane)
        self.assertEqual(result[f"{target}_grade"], f"G{grade:02d}")
        self.assertEqual(
            result[f"{target}_filename"], f"{prefix}-{lane}-G{grade:02d}.md"
        )

    def test_formatter_grade_and_filename_matrix(self) -> None:
        for target, lane, grade in itertools.product(
            ("build", "review"), ("local", "cloud"), range(1, 11)
        ):
            with self.subTest(target=target, lane=lane, grade=grade):
                result = fields(run(FORMATTER, target, lane, *GRADE_VECTORS[grade]).stdout)
                prefix = "PLAN" if target == "build" else "CODE_REVIEW"
                self.assertEqual(result["grade"], f"G{grade:02d}")
                self.assertEqual(
                    result["filename"], f"{prefix}-{lane}-G{grade:02d}.md"
                )

    def test_formatter_invalid_inputs_are_rejected(self) -> None:
        valid = list(GRADE_VECTORS[4])
        invalid_cases: list[tuple[object, ...]] = [
            ("deploy", "local", *valid),
            ("build", "hybrid", *valid),
            ("build", "local", *valid[:-1]),
            ("build", "local", *valid, 1),
        ]
        for index in range(5):
            scores = valid.copy()
            scores[index] = 3
            invalid_cases.append(("build", "local", *scores))
        for args in invalid_cases:
            with self.subTest(args=args):
                self.assertEqual(run(FORMATTER, *args, check=False).returncode, 2)

    def test_pair_policy_validates_each_build_basis_and_grade(self) -> None:
        for basis, grade in itertools.product(
            ("local-fit", "capability-gap", "grade-boundary"), range(1, 11)
        ):
            with self.subTest(basis=basis, grade=grade):
                completed = run(
                    POLICY_FINALIZER,
                    *pair_args(basis, grade, 1),
                    check=False,
                )
                lane, valid = expected_build_route(basis, grade)
                if not valid:
                    self.assertEqual(completed.returncode, 2)
                    continue
                self.assertEqual(completed.returncode, 0, completed.stderr)
                result = fields(completed.stdout)
                self.assertEqual(result["finalizer_mode"], "pair")
                self.assert_route(result, "build", basis, lane, grade)

    def test_official_review_keeps_grade_and_fixes_execution_target(self) -> None:
        for grade in range(1, 11):
            with self.subTest(grade=grade):
                result = fields(
                    run(POLICY_FINALIZER, *pair_args("local-fit", 1, grade)).stdout
                )
                self.assert_route(
                    result, "review", "official-review", "cloud", grade
                )
                self.assertEqual(result["review_adapter"], "codex")
                self.assertEqual(result["review_model"], "gpt-5.6-sol")
                self.assertEqual(result["review_reasoning_effort"], "xhigh")

    def test_low_grade_cloud_requires_capability_gap_basis(self) -> None:
        rejected = run(
            POLICY_FINALIZER,
            *pair_args("grade-boundary", 4, 4),
            check=False,
        )
        self.assertEqual(rejected.returncode, 2)

        accepted = fields(
            run(
                POLICY_FINALIZER,
                *pair_args("capability-gap", 4, 4),
            ).stdout
        )
        self.assert_route(accepted, "build", "capability-gap", "cloud", 4)

    def test_loop_risk_is_audit_only(self) -> None:
        outputs = []
        for risk in ("false", "true"):
            result = fields(
                run(
                    POLICY_FINALIZER,
                    *pair_args("local-fit", 7, 6, risk),
                ).stdout
            )
            outputs.append(result)
            self.assertEqual(result["build_risk_triggered"], risk)
        for key in ("build_lane", "build_grade", "build_filename"):
            self.assertEqual(outputs[0][key], outputs[1][key])

    def test_policy_invalid_inputs_are_rejected(self) -> None:
        valid = GRADE_VECTORS[4]
        invalid_cases = (
            ("pair", "local-fit", "unknown", *valid, "official-review", *valid),
            ("pair", "local", "false", *valid, "official-review", *valid),
            ("pair", "local-fit", "false", *valid, "cloud", *valid),
            ("build", "local-fit", "false", *valid),
            ("pair", "local-fit", "false", *valid, "official-review", *valid[:-1]),
        )
        for args in invalid_cases:
            with self.subTest(args=args):
                self.assertEqual(
                    run(POLICY_FINALIZER, *args, check=False).returncode,
                    2,
                )


if __name__ == "__main__":
    unittest.main()