import json import tempfile import unittest from pathlib import Path from swarm_ctf_eval.arena import ( Action, AgentState, ArenaEnv, GameState, Node, WAIT, legal_actions, observe_node, redundant_agents, state_to_dict, step, ) from swarm_ctf_eval.arena_generation import generate_state from swarm_ctf_eval.arena_eval import OracleArenaModel, evaluate_case from swarm_ctf_eval.arena_oracle import deterministic_policy, solve_joint_action from swarm_ctf_eval.arena_protocol import ( action_prompt, encode_action, parse_action, parse_broadcast, ) from swarm_ctf_eval.arena_sft import generate_dataset, oracle_broadcast, write_dataset def two_node_state() -> GameState: nodes = { "X": Node("X", ("Y",), "BLUE"), "Y": Node("Y", ("X",), "RED"), } agents = {} for team, position in (("BLUE", "X"), ("RED", "Y")): for index in range(4): aid = f"{team.lower()}-{index}" agents[aid] = AgentState(aid, team, position, 2) knowledge = { aid: {node_id: observe_node(node, 0) for node_id, node in nodes.items()} for aid in agents } state = GameState(0, nodes, agents, knowledge) state.validate() return state class ArenaTests(unittest.TestCase): def test_generation_is_deterministic_and_valid(self) -> None: first = generate_state(17) second = generate_state(17) other = generate_state(18) self.assertEqual(state_to_dict(first), state_to_dict(second)) self.assertNotEqual(state_to_dict(first), state_to_dict(other)) first.validate() def test_probe_capture_is_complementary_not_duplicate(self) -> None: state = two_node_state() actions = {aid: WAIT for aid in state.agents} actions["blue-0"] = Action("PROBE", "Y") actions["blue-1"] = Action("CAPTURE", "Y") result = step(state, actions) self.assertEqual(result.state.nodes["Y"].owner, "BLUE") self.assertEqual(result.duplicate_targets["BLUE"], ()) self.assertEqual(redundant_agents(state, actions, "BLUE"), ()) def test_simultaneous_fortify_blocks_one_probe(self) -> None: state = two_node_state() actions = {aid: WAIT for aid in state.agents} actions["blue-0"] = Action("PROBE", "Y") actions["blue-1"] = Action("CAPTURE", "Y") actions["red-0"] = Action("FORTIFY", "Y") result = step(state, actions) self.assertEqual(result.state.nodes["Y"].owner, "RED") self.assertFalse(result.state.nodes["Y"].exposed) def test_resolution_does_not_depend_on_action_dict_order(self) -> None: state = generate_state(3) actions = { **deterministic_policy(state, "BLUE"), **deterministic_policy(state, "RED"), } forward = step(state, actions) reverse = step(state, dict(reversed(list(actions.items())))) self.assertEqual(state_to_dict(forward.state), state_to_dict(reverse.state)) self.assertEqual(forward.rewards, reverse.rewards) self.assertEqual(forward.duplicate_targets, reverse.duplicate_targets) self.assertAlmostEqual(forward.rewards["BLUE"] + forward.rewards["RED"], 0.0) def test_invalid_action_is_rejected_and_penalized(self) -> None: state = two_node_state() baseline = step(state, {aid: WAIT for aid in state.agents}) invalid = {aid: WAIT for aid in state.agents} invalid["blue-0"] = Action("CAPTURE", "NOT_A_NODE") result = step(state, invalid) self.assertEqual(result.invalid_agents, ("blue-0",)) self.assertEqual(result.rewards["BLUE"], baseline.rewards["BLUE"] - 1.0) def test_exact_solver_returns_only_optimal_actions(self) -> None: state = generate_state(5) red = deterministic_policy(state, "RED") solution = solve_joint_action(state, "BLUE", red) self.assertGreater(solution.explored, 0) self.assertGreaterEqual(solution.optimal_count, len(solution.assignments)) for assignment in solution.assignments: result = step(state, {**red, **dict(assignment)}) self.assertAlmostEqual(result.rewards["BLUE"], solution.reward) def test_strict_protocol_rejects_extra_text_and_unsupported_facts(self) -> None: state = generate_state(9) aid = "blue-0" self.assertFalse(parse_broadcast('answer: {"facts":[],"intent":null,"request_resource":0}', state, aid).valid) hallucination = json.dumps( { "facts": [{"node": "ZZ", "owner": "RED", "status": "EXPOSED", "value": 3, "critical": False, "observed_turn": 0}], "intent": None, "request_resource": 0, } ) self.assertEqual(parse_broadcast(hallucination, state, aid).errors, ("unsupported_fact",)) known = next(iter(state.knowledge[aid].values())) stale_lie = json.dumps( { "facts": [{"node": known.node, "owner": known.owner, "status": known.status, "value": known.value, "critical": known.critical, "observed_turn": known.observed_turn + 1}], "intent": None, "request_resource": 0, } ) self.assertEqual(parse_broadcast(stale_lie, state, aid).errors, ("unsupported_fact",)) def test_action_protocol_accepts_exactly_displayed_action(self) -> None: state = generate_state(4) prompt, displayed = action_prompt(state, "blue-0", [], permutation=2) self.assertEqual(prompt[0]["role"], "system") target = encode_action(displayed[-1], displayed) parsed = parse_action(target, displayed) self.assertTrue(parsed.valid) self.assertEqual(parsed.value, displayed[-1]) self.assertFalse(parse_action(target + "\nthanks", displayed).valid) def test_sft_dataset_is_valid_deduplicated_and_seed_isolated(self) -> None: rows, manifest = generate_dataset(0, 3) self.assertEqual(manifest["num_examples"], len(rows)) self.assertEqual(len({row["id"] for row in rows}), len(rows)) for row in rows: self.assertEqual([message["role"] for message in row["messages"]], ["system", "user", "assistant"]) with tempfile.TemporaryDirectory() as directory: output = Path(directory) write_dataset(rows, manifest, output) self.assertTrue((output / "manifest.json").is_file()) written = sum(len((output / f"{split}.jsonl").read_text().splitlines()) for split in ("train", "validation", "test")) self.assertEqual(written, len(rows)) def test_targeted_sft_covers_wait_scan_and_transfer(self) -> None: rows, _ = generate_dataset(0, 1, mechanics_per_kind=1, silence_examples=1) skills = { row["metadata"].get("targeted_skill") for row in rows if row["metadata"].get("generator_mode") == "targeted_mechanics" } self.assertEqual(skills, {"WAIT", "SCAN", "TRANSFER", "SILENCE"}) silence = next(row for row in rows if row["metadata"].get("targeted_skill") == "SILENCE") self.assertEqual( json.loads(silence["messages"][-1]["content"]), {"facts": [], "intent": None, "request_resource": 0}, ) def test_every_generated_agent_has_wait_and_legal_policy_action(self) -> None: state = generate_state(21) for team in ("BLUE", "RED"): policy = deterministic_policy(state, team) for aid, action in policy.items(): self.assertIn(WAIT, legal_actions(state, aid)) self.assertIn(action, legal_actions(state, aid)) def test_parallel_environment_runs_to_fixed_horizon(self) -> None: env = ArenaEnv(seed=44, horizon=2) observations = env.reset() self.assertEqual(len(observations), 8) for turn in range(2): actions = {agent_id: WAIT for agent_id in observations} observations, rewards, terminated, truncated, info = env.advance(actions) self.assertAlmostEqual(rewards["BLUE"] + rewards["RED"], 0.0) self.assertEqual(len(observations), 8) self.assertIn("team_value", info) if turn == 0: self.assertFalse(truncated) self.assertTrue(terminated or truncated) def test_oracle_has_no_protocol_false_negatives_and_reaches_optimum(self) -> None: state = generate_state(101) reference = deterministic_policy(state, "BLUE") shuffled = { aid: oracle_broadcast(state, aid, reference[aid]) for aid in reference } row = evaluate_case(OracleArenaModel(), 101, 12, "balanced", shuffled) self.assertEqual(row["message_strict_rate"], 1.0) self.assertTrue(row["action_order_consistent"]) for condition in row["conditions"]: self.assertEqual(condition["strict_action_rate"], 1.0) self.assertTrue(condition["optimal_outcome"]) if __name__ == "__main__": unittest.main()