toki
deea59d035
- add finalize-task-routing skill with policy and test scripts - add execution target selection scripts and tests for orchestrate-agent-task-loop - add quota probe adapter and CLI status for node app - update plan, finalize-task-routing, and orchestration skill files - add agent-task archive for runtime target selector - update stream-evidence-gate-core milestone
318 lines
12 KiB
Python
Executable file
318 lines
12 KiB
Python
Executable file
#!/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())
|
|
|
|
|
|
class FinalizeTaskRoutingTests(unittest.TestCase):
|
|
def test_formatter_all_score_vectors_without_floor(self) -> None:
|
|
for target, lane, scores in itertools.product(
|
|
("build", "review"),
|
|
("local", "cloud"),
|
|
itertools.product(range(3), repeat=5),
|
|
):
|
|
with self.subTest(target=target, lane=lane, scores=scores):
|
|
result = fields(run(FORMATTER, target, lane, *scores).stdout)
|
|
expected_grade = max(1, sum(scores))
|
|
prefix = "PLAN" if target == "build" else "CODE_REVIEW"
|
|
self.assertEqual(result["grade"], f"G{expected_grade:02d}")
|
|
self.assertEqual(
|
|
result["filename"],
|
|
f"{prefix}-{lane}-G{expected_grade:02d}.md",
|
|
)
|
|
|
|
def test_formatter_exhaustive_grade_floor_matrix(self) -> None:
|
|
for target, lane, base_grade, floor in itertools.product(
|
|
("build", "review"),
|
|
("local", "cloud"),
|
|
range(1, 11),
|
|
range(1, 11),
|
|
):
|
|
with self.subTest(
|
|
target=target,
|
|
lane=lane,
|
|
base_grade=base_grade,
|
|
floor=floor,
|
|
):
|
|
result = fields(
|
|
run(
|
|
FORMATTER,
|
|
target,
|
|
lane,
|
|
*GRADE_VECTORS[base_grade],
|
|
floor,
|
|
).stdout
|
|
)
|
|
expected_grade = max(base_grade, floor)
|
|
prefix = "PLAN" if target == "build" else "CODE_REVIEW"
|
|
self.assertEqual(result["target"], target)
|
|
self.assertEqual(result["lane"], lane)
|
|
self.assertEqual(result["grade"], f"G{expected_grade:02d}")
|
|
self.assertEqual(
|
|
result["filename"],
|
|
f"{prefix}-{lane}-G{expected_grade:02d}.md",
|
|
)
|
|
|
|
def test_pair_exhaustive_route_matrix(self) -> None:
|
|
for (
|
|
build_lane,
|
|
risk_triggered,
|
|
build_base_grade,
|
|
review_base_lane,
|
|
review_base_grade,
|
|
) in itertools.product(
|
|
("local", "cloud"),
|
|
("false", "true"),
|
|
range(1, 11),
|
|
("local", "cloud"),
|
|
range(1, 11),
|
|
):
|
|
with self.subTest(
|
|
build_lane=build_lane,
|
|
risk_triggered=risk_triggered,
|
|
build_base_grade=build_base_grade,
|
|
review_base_lane=review_base_lane,
|
|
review_base_grade=review_base_grade,
|
|
):
|
|
result = fields(
|
|
run(
|
|
POLICY_FINALIZER,
|
|
"pair",
|
|
build_lane,
|
|
risk_triggered,
|
|
*GRADE_VECTORS[build_base_grade],
|
|
review_base_lane,
|
|
*GRADE_VECTORS[review_base_grade],
|
|
).stdout
|
|
)
|
|
if risk_triggered == "true":
|
|
expected_build_lane = "cloud"
|
|
expected_build_grade = max(build_base_grade, 7)
|
|
expected_build_floor = "G07"
|
|
else:
|
|
expected_build_lane = build_lane
|
|
expected_build_grade = build_base_grade
|
|
expected_build_floor = "none"
|
|
|
|
expected_review_floor = (
|
|
10 if expected_build_grade >= 9 else 9
|
|
)
|
|
expected_review_grade = max(
|
|
review_base_grade,
|
|
expected_review_floor,
|
|
)
|
|
|
|
self.assertEqual(result["build_base_lane"], build_lane)
|
|
self.assertEqual(
|
|
result["finalizer"],
|
|
"finalize-task-policy.sh",
|
|
)
|
|
self.assertEqual(result["finalizer_mode"], "pair")
|
|
self.assertEqual(
|
|
result["build_base_grade"],
|
|
f"G{build_base_grade:02d}",
|
|
)
|
|
self.assertEqual(
|
|
result["build_risk_triggered"],
|
|
risk_triggered,
|
|
)
|
|
self.assertEqual(result["build_floor"], expected_build_floor)
|
|
self.assertEqual(result["build_lane"], expected_build_lane)
|
|
self.assertEqual(
|
|
result["build_grade"],
|
|
f"G{expected_build_grade:02d}",
|
|
)
|
|
self.assertEqual(
|
|
result["build_filename"],
|
|
f"PLAN-{expected_build_lane}-G{expected_build_grade:02d}.md",
|
|
)
|
|
self.assertEqual(result["review_base_lane"], review_base_lane)
|
|
self.assertEqual(
|
|
result["review_base_grade"],
|
|
f"G{review_base_grade:02d}",
|
|
)
|
|
self.assertEqual(
|
|
result["review_floor"],
|
|
f"G{expected_review_floor:02d}",
|
|
)
|
|
self.assertEqual(result["review_lane"], "cloud")
|
|
self.assertEqual(
|
|
result["review_grade"],
|
|
f"G{expected_review_grade:02d}",
|
|
)
|
|
self.assertEqual(
|
|
result["review_filename"],
|
|
f"CODE_REVIEW-cloud-G{expected_review_grade:02d}.md",
|
|
)
|
|
|
|
def test_raw_sum_one_stays_g01(self) -> None:
|
|
result = fields(
|
|
run(FORMATTER, "build", "local", 1, 0, 0, 0, 0).stdout
|
|
)
|
|
self.assertEqual(result["grade"], "G01")
|
|
|
|
def test_single_target_policy_matrix(self) -> None:
|
|
for lane, risk_triggered, base_grade in itertools.product(
|
|
("local", "cloud"),
|
|
("false", "true"),
|
|
range(1, 11),
|
|
):
|
|
with self.subTest(
|
|
target="build",
|
|
lane=lane,
|
|
risk_triggered=risk_triggered,
|
|
base_grade=base_grade,
|
|
):
|
|
result = fields(
|
|
run(
|
|
POLICY_FINALIZER,
|
|
"build",
|
|
lane,
|
|
risk_triggered,
|
|
*GRADE_VECTORS[base_grade],
|
|
).stdout
|
|
)
|
|
expected_lane = "cloud" if risk_triggered == "true" else lane
|
|
expected_grade = (
|
|
max(base_grade, 7)
|
|
if risk_triggered == "true"
|
|
else base_grade
|
|
)
|
|
expected_floor = (
|
|
"G07" if risk_triggered == "true" else "none"
|
|
)
|
|
self.assertEqual(
|
|
result["finalizer"],
|
|
"finalize-task-policy.sh",
|
|
)
|
|
self.assertEqual(result["finalizer_mode"], "build")
|
|
self.assertEqual(result["build_base_lane"], lane)
|
|
self.assertEqual(
|
|
result["build_base_grade"],
|
|
f"G{base_grade:02d}",
|
|
)
|
|
self.assertEqual(
|
|
result["build_risk_triggered"],
|
|
risk_triggered,
|
|
)
|
|
self.assertEqual(result["build_floor"], expected_floor)
|
|
self.assertEqual(result["build_lane"], expected_lane)
|
|
self.assertEqual(
|
|
result["build_grade"],
|
|
f"G{expected_grade:02d}",
|
|
)
|
|
self.assertEqual(
|
|
result["build_filename"],
|
|
f"PLAN-{expected_lane}-G{expected_grade:02d}.md",
|
|
)
|
|
|
|
for lane, base_grade in itertools.product(
|
|
("local", "cloud"),
|
|
range(1, 11),
|
|
):
|
|
with self.subTest(
|
|
target="review",
|
|
lane=lane,
|
|
base_grade=base_grade,
|
|
):
|
|
result = fields(
|
|
run(
|
|
POLICY_FINALIZER,
|
|
"review",
|
|
lane,
|
|
*GRADE_VECTORS[base_grade],
|
|
).stdout
|
|
)
|
|
expected_grade = max(base_grade, 9)
|
|
self.assertEqual(
|
|
result["finalizer"],
|
|
"finalize-task-policy.sh",
|
|
)
|
|
self.assertEqual(result["finalizer_mode"], "review")
|
|
self.assertEqual(result["review_base_lane"], lane)
|
|
self.assertEqual(
|
|
result["review_base_grade"],
|
|
f"G{base_grade:02d}",
|
|
)
|
|
self.assertEqual(result["review_floor"], "G09")
|
|
self.assertEqual(result["review_lane"], "cloud")
|
|
self.assertEqual(
|
|
result["review_grade"],
|
|
f"G{expected_grade:02d}",
|
|
)
|
|
self.assertEqual(
|
|
result["review_filename"],
|
|
f"CODE_REVIEW-cloud-G{expected_grade:02d}.md",
|
|
)
|
|
|
|
def test_invalid_inputs_are_rejected(self) -> None:
|
|
invalid_formatter_cases = (
|
|
("deploy", "local", 0, 0, 0, 0, 0),
|
|
("build", "hybrid", 0, 0, 0, 0, 0),
|
|
("build", "local", 3, 0, 0, 0, 0),
|
|
("build", "local", 0, 0, 0, 0, 0, 0),
|
|
("review", "cloud", 0, 0, 0, 0, 0, 11),
|
|
("review", "cloud", 0, 0, 0, 0, 0, "G09"),
|
|
)
|
|
for args in invalid_formatter_cases:
|
|
with self.subTest(formatter_args=args):
|
|
self.assertEqual(run(FORMATTER, *args, check=False).returncode, 2)
|
|
|
|
valid_scores = GRADE_VECTORS[4]
|
|
invalid_policy_cases = (
|
|
("pair", "local", "yes", *valid_scores, "local", *valid_scores),
|
|
("pair", "local", "unknown", *valid_scores, "local", *valid_scores),
|
|
("pair", "hybrid", "true", *valid_scores, "local", *valid_scores),
|
|
("pair", "local", "true", *valid_scores, "remote", *valid_scores),
|
|
("pair", "local", "true", 3, 0, 0, 0, 0, "local", *valid_scores),
|
|
("pair", "local", "true", *valid_scores, "local", *valid_scores, 2),
|
|
("build", "local", "unknown", *valid_scores),
|
|
("review", "local", "false", *valid_scores),
|
|
("review", "local", *valid_scores[:-1]),
|
|
("deploy", "local", *valid_scores),
|
|
)
|
|
for args in invalid_policy_cases:
|
|
with self.subTest(policy_args=args):
|
|
self.assertEqual(
|
|
run(POLICY_FINALIZER, *args, check=False).returncode,
|
|
2,
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|