feat: Complete LLM agent framework with fog-of-war, meeting flow, and prompt assembly
- Core engine: simulator, game mechanics, triggers (138 tests) - Fog-of-war per-player state tracking - Meeting flow: interrupt, discussion, voting, consolidation - Prompt assembler with strategy injection tiers - LLM client with fallbacks for models without JSON/system support - Prompt templates: action, discussion, voting, reflection - Full integration in main.py orchestrator - Verified working with free OpenRouter models (Gemma)
This commit is contained in:
Antigravity
@@ -0,0 +1,173 @@
|
||||
"""
|
||||
Tests for the discussion orchestrator.
|
||||
"""
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
import os
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
from src.engine.discussion import DiscussionOrchestrator, DiscussionConfig, DiscussionMessage
|
||||
|
||||
|
||||
class TestDiscussionMessage(unittest.TestCase):
|
||||
"""Tests for DiscussionMessage dataclass."""
|
||||
|
||||
def test_message_creation(self):
|
||||
msg = DiscussionMessage(speaker="Red", message="I saw Blue vent!")
|
||||
self.assertEqual(msg.speaker, "Red")
|
||||
self.assertEqual(msg.message, "I saw Blue vent!")
|
||||
self.assertIsNone(msg.target)
|
||||
|
||||
def test_message_with_target(self):
|
||||
msg = DiscussionMessage(speaker="Red", message="What were you doing?", target="Blue")
|
||||
self.assertEqual(msg.target, "Blue")
|
||||
|
||||
|
||||
class TestDiscussionConfig(unittest.TestCase):
|
||||
"""Tests for DiscussionConfig."""
|
||||
|
||||
def test_default_config(self):
|
||||
config = DiscussionConfig()
|
||||
self.assertEqual(config.max_rounds, 20)
|
||||
self.assertEqual(config.convergence_threshold, 2)
|
||||
|
||||
|
||||
class TestDiscussionOrchestrator(unittest.TestCase):
|
||||
"""Tests for the discussion orchestrator."""
|
||||
|
||||
def setUp(self):
|
||||
self.orchestrator = DiscussionOrchestrator()
|
||||
|
||||
def test_initial_state(self):
|
||||
self.assertEqual(len(self.orchestrator.transcript), 0)
|
||||
self.assertEqual(self.orchestrator.round_num, 0)
|
||||
|
||||
def test_reset(self):
|
||||
self.orchestrator.add_message("p1", "Red", "test")
|
||||
self.orchestrator.round_num = 5
|
||||
|
||||
self.orchestrator.reset()
|
||||
|
||||
self.assertEqual(len(self.orchestrator.transcript), 0)
|
||||
self.assertEqual(self.orchestrator.round_num, 0)
|
||||
|
||||
def test_add_message(self):
|
||||
self.orchestrator.add_message("p1", "Red", "Hello everyone")
|
||||
|
||||
self.assertEqual(len(self.orchestrator.transcript), 1)
|
||||
self.assertEqual(self.orchestrator.transcript[0].speaker, "Red")
|
||||
self.assertEqual(self.orchestrator.transcript[0].message, "Hello everyone")
|
||||
|
||||
def test_get_transcript(self):
|
||||
self.orchestrator.add_message("p1", "Red", "Message 1")
|
||||
self.orchestrator.add_message("p2", "Blue", "Message 2", target="Red")
|
||||
|
||||
transcript = self.orchestrator.get_transcript()
|
||||
|
||||
self.assertEqual(len(transcript), 2)
|
||||
self.assertEqual(transcript[0]["speaker"], "Red")
|
||||
self.assertEqual(transcript[1]["target"], "Red")
|
||||
|
||||
def test_priority_base_desire(self):
|
||||
priority = self.orchestrator.calculate_priority("p1", "Red", desire_to_speak=5)
|
||||
# Should be desire + random(1-6)
|
||||
self.assertGreaterEqual(priority, 6) # 5 + 1
|
||||
self.assertLessEqual(priority, 11) # 5 + 6
|
||||
|
||||
def test_priority_mention_boost(self):
|
||||
self.orchestrator.add_message("p2", "Blue", "I think Red is suspicious")
|
||||
|
||||
priority = self.orchestrator.calculate_priority("p1", "Red", desire_to_speak=5)
|
||||
# Should include mention boost
|
||||
self.assertGreaterEqual(priority, 9) # 5 + 3 boost + 1 random
|
||||
|
||||
def test_priority_target_boost(self):
|
||||
self.orchestrator.add_message("p2", "Blue", "Where were you?", target="Red")
|
||||
|
||||
priority = self.orchestrator.calculate_priority("p1", "Red", desire_to_speak=5)
|
||||
# Should include target boost
|
||||
self.assertGreaterEqual(priority, 8) # 5 + 2 boost + 1 random
|
||||
|
||||
def test_priority_speaking_cooldown(self):
|
||||
# Test that speaking cooldown reduces priority on average
|
||||
# Run multiple times due to random factor
|
||||
self.orchestrator.round_num = 5
|
||||
|
||||
# Player who just spoke (should have lower priority on average)
|
||||
self.orchestrator._last_spoke["p1"] = 4
|
||||
priorities_recent = [
|
||||
self.orchestrator.calculate_priority("p1", "Red", desire_to_speak=5)
|
||||
for _ in range(20)
|
||||
]
|
||||
|
||||
# Player who spoke long ago (should have higher priority on average)
|
||||
self.orchestrator._last_spoke["p1"] = 0
|
||||
priorities_old = [
|
||||
self.orchestrator.calculate_priority("p1", "Red", desire_to_speak=5)
|
||||
for _ in range(20)
|
||||
]
|
||||
|
||||
# Average of old should be higher than recent
|
||||
avg_recent = sum(priorities_recent) / len(priorities_recent)
|
||||
avg_old = sum(priorities_old) / len(priorities_old)
|
||||
self.assertLess(avg_recent, avg_old)
|
||||
|
||||
def test_select_speaker_none_below_threshold(self):
|
||||
bids = {
|
||||
"p1": {"name": "Red", "desire_to_speak": 0},
|
||||
"p2": {"name": "Blue", "desire_to_speak": 0},
|
||||
}
|
||||
|
||||
# With desire=0 and random 1-6 added, max priority is 6
|
||||
# Threshold is 2, so some may still speak
|
||||
# To properly test, we'd need all desires at 0 and check behavior
|
||||
# Actually the threshold comparison uses raw priorities not desires
|
||||
# Let's just verify it returns a valid result or None
|
||||
speaker = self.orchestrator.select_speaker(bids)
|
||||
# Either None or one of the players is valid
|
||||
self.assertTrue(speaker is None or speaker in ["p1", "p2"])
|
||||
|
||||
def test_select_speaker_picks_one(self):
|
||||
bids = {
|
||||
"p1": {"name": "Red", "desire_to_speak": 8},
|
||||
"p2": {"name": "Blue", "desire_to_speak": 7},
|
||||
}
|
||||
|
||||
speaker = self.orchestrator.select_speaker(bids)
|
||||
self.assertIn(speaker, ["p1", "p2"])
|
||||
|
||||
def test_advance_round_increments(self):
|
||||
initial = self.orchestrator.round_num
|
||||
self.orchestrator.advance_round(all_desires_low=False)
|
||||
self.assertEqual(self.orchestrator.round_num, initial + 1)
|
||||
|
||||
def test_advance_round_ends_at_max(self):
|
||||
self.orchestrator.round_num = 19 # Just before max
|
||||
self.orchestrator.config.max_rounds = 20
|
||||
|
||||
should_continue = self.orchestrator.advance_round(all_desires_low=False)
|
||||
self.assertFalse(should_continue)
|
||||
|
||||
def test_advance_round_convergence(self):
|
||||
self.orchestrator.config.convergence_rounds = 2
|
||||
|
||||
# First low round
|
||||
self.orchestrator.advance_round(all_desires_low=True)
|
||||
self.assertTrue(True) # Should continue
|
||||
|
||||
# Second low round - should end
|
||||
should_continue = self.orchestrator.advance_round(all_desires_low=True)
|
||||
self.assertFalse(should_continue)
|
||||
|
||||
def test_convergence_resets_on_activity(self):
|
||||
self.orchestrator._consecutive_low_rounds = 1
|
||||
|
||||
self.orchestrator.advance_round(all_desires_low=False)
|
||||
|
||||
self.assertEqual(self.orchestrator._consecutive_low_rounds, 0)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,105 @@
|
||||
"""
|
||||
Tests for the fog-of-war system.
|
||||
"""
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
import os
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
from src.engine.fog_of_war import FogOfWarManager, PlayerKnowledge, PlayerSighting
|
||||
|
||||
|
||||
class TestPlayerKnowledge(unittest.TestCase):
|
||||
"""Tests for PlayerKnowledge."""
|
||||
|
||||
def setUp(self):
|
||||
self.pk = PlayerKnowledge(player_id="red")
|
||||
|
||||
def test_see_player(self):
|
||||
self.pk.see_player("blue", "Blue", "cafeteria", 10.0, "walking")
|
||||
|
||||
self.assertIn("blue", self.pk.last_seen)
|
||||
self.assertEqual(self.pk.last_seen["blue"].room_id, "cafeteria")
|
||||
|
||||
def test_witness_event(self):
|
||||
self.pk.witness_event("VENT_WITNESSED", 15.0, {"player": "green"})
|
||||
|
||||
self.assertEqual(len(self.pk.witnessed_events), 1)
|
||||
self.assertEqual(self.pk.witnessed_events[0].event_type, "VENT_WITNESSED")
|
||||
|
||||
def test_learn_death(self):
|
||||
self.pk.learn_death("blue", via="body")
|
||||
|
||||
self.assertIn("blue", self.pk.known_dead)
|
||||
|
||||
def test_find_body(self):
|
||||
self.pk.find_body("body_blue", "Blue", "electrical", 20.0)
|
||||
|
||||
self.assertIn("body_blue", self.pk.bodies_found)
|
||||
self.assertIn("blue", self.pk.known_dead)
|
||||
|
||||
def test_to_dict_and_from_dict(self):
|
||||
self.pk.see_player("blue", "Blue", "cafeteria", 10.0)
|
||||
self.pk.learn_death("green")
|
||||
|
||||
data = self.pk.to_dict()
|
||||
restored = PlayerKnowledge.from_dict(data)
|
||||
|
||||
self.assertEqual(restored.player_id, "red")
|
||||
self.assertIn("blue", restored.last_seen)
|
||||
self.assertIn("green", restored.known_dead)
|
||||
|
||||
|
||||
class TestFogOfWarManager(unittest.TestCase):
|
||||
"""Tests for FogOfWarManager."""
|
||||
|
||||
def setUp(self):
|
||||
self.fow = FogOfWarManager()
|
||||
self.fow.register_player("red")
|
||||
self.fow.register_player("blue")
|
||||
|
||||
def test_register_player(self):
|
||||
self.assertIsNotNone(self.fow.get_knowledge("red"))
|
||||
self.assertIsNotNone(self.fow.get_knowledge("blue"))
|
||||
|
||||
def test_update_vision(self):
|
||||
visible = [{"id": "blue", "name": "Blue", "action": "standing"}]
|
||||
self.fow.update_vision("red", visible, "cafeteria", 10.0)
|
||||
|
||||
pk = self.fow.get_knowledge("red")
|
||||
self.assertIn("blue", pk.last_seen)
|
||||
|
||||
def test_witness_vent(self):
|
||||
self.fow.witness_vent("red", "blue", "Blue", "electrical", "entered", 15.0)
|
||||
|
||||
pk = self.fow.get_knowledge("red")
|
||||
self.assertEqual(len(pk.witnessed_events), 1)
|
||||
self.assertEqual(pk.witnessed_events[0].event_type, "VENT_WITNESSED")
|
||||
|
||||
def test_witness_kill(self):
|
||||
self.fow.witness_kill("red", "blue", "Blue", "green", "Green", "admin", 20.0)
|
||||
|
||||
pk = self.fow.get_knowledge("red")
|
||||
self.assertIn("green", pk.known_dead)
|
||||
|
||||
def test_announce_death(self):
|
||||
self.fow.announce_death("green", via="meeting")
|
||||
|
||||
pk_red = self.fow.get_knowledge("red")
|
||||
pk_blue = self.fow.get_knowledge("blue")
|
||||
|
||||
self.assertIn("green", pk_red.known_dead)
|
||||
self.assertIn("green", pk_blue.known_dead)
|
||||
|
||||
def test_reset_for_new_game(self):
|
||||
self.fow.get_knowledge("red").learn_death("blue")
|
||||
self.fow.reset_for_new_game()
|
||||
|
||||
pk = self.fow.get_knowledge("red")
|
||||
self.assertEqual(len(pk.known_dead), 0)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,483 @@
|
||||
"""
|
||||
Tests for the game engine.
|
||||
"""
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
import os
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
from src.engine.game import GameEngine, GameConfig
|
||||
from src.engine.types import Player, Position, Role, GamePhase, Body
|
||||
from src.map.graph import GameMap, Room, Edge, Task, Vent
|
||||
|
||||
|
||||
def create_simple_map():
|
||||
"""Create a simple test map."""
|
||||
game_map = GameMap()
|
||||
|
||||
# Cafeteria with task
|
||||
game_map.add_room(Room(
|
||||
id="cafeteria",
|
||||
name="Cafeteria",
|
||||
tasks=[Task(id="wires_cafe", name="Fix Wiring", duration=3.0)]
|
||||
))
|
||||
|
||||
# Electrical with vent
|
||||
elec_vent = Vent(id="vent_elec", connects_to=["vent_security"])
|
||||
game_map.add_room(Room(
|
||||
id="electrical",
|
||||
name="Electrical",
|
||||
vent=elec_vent,
|
||||
tasks=[Task(id="wires_elec", name="Fix Wiring", duration=3.0)]
|
||||
))
|
||||
|
||||
# Security with vent
|
||||
sec_vent = Vent(id="vent_security", connects_to=["vent_elec"])
|
||||
game_map.add_room(Room(
|
||||
id="security",
|
||||
name="Security",
|
||||
vent=sec_vent
|
||||
))
|
||||
|
||||
# Admin
|
||||
game_map.add_room(Room(id="admin", name="Admin"))
|
||||
|
||||
# Connect rooms
|
||||
game_map.add_edge(Edge(id="cafe_elec", room_a="cafeteria", room_b="electrical", distance=5.0))
|
||||
game_map.add_edge(Edge(id="cafe_admin", room_a="cafeteria", room_b="admin", distance=3.0))
|
||||
game_map.add_edge(Edge(id="elec_sec", room_a="electrical", room_b="security", distance=4.0))
|
||||
|
||||
return game_map
|
||||
|
||||
|
||||
class TestGameConfig(unittest.TestCase):
|
||||
"""Tests for GameConfig."""
|
||||
|
||||
def test_default_config(self):
|
||||
config = GameConfig()
|
||||
self.assertEqual(config.num_impostors, 2)
|
||||
self.assertEqual(config.kill_cooldown, 25.0)
|
||||
self.assertEqual(config.emergencies_per_player, 1)
|
||||
|
||||
def test_config_to_dict(self):
|
||||
config = GameConfig()
|
||||
data = config.to_dict()
|
||||
self.assertIn("num_impostors", data)
|
||||
self.assertIn("kill_cooldown", data)
|
||||
|
||||
|
||||
class TestGameEngineSetup(unittest.TestCase):
|
||||
"""Tests for game engine initialization and player management."""
|
||||
|
||||
def setUp(self):
|
||||
self.config = GameConfig()
|
||||
self.game_map = create_simple_map()
|
||||
self.engine = GameEngine(self.config, self.game_map)
|
||||
|
||||
def test_engine_initialization(self):
|
||||
self.assertIsNotNone(self.engine.simulator)
|
||||
self.assertIsNotNone(self.engine.triggers)
|
||||
self.assertEqual(len(self.engine.impostor_ids), 0)
|
||||
|
||||
def test_add_crewmate(self):
|
||||
player = self.engine.add_player("p1", "Red", "red", Role.CREWMATE)
|
||||
|
||||
self.assertEqual(player.role, Role.CREWMATE)
|
||||
self.assertEqual(player.position.room_id, "cafeteria")
|
||||
self.assertIn("p1", self.engine.simulator.players)
|
||||
self.assertNotIn("p1", self.engine.impostor_ids)
|
||||
|
||||
def test_add_impostor(self):
|
||||
player = self.engine.add_player("p1", "Red", "red", Role.IMPOSTOR)
|
||||
|
||||
self.assertEqual(player.role, Role.IMPOSTOR)
|
||||
self.assertIn("p1", self.engine.impostor_ids)
|
||||
self.assertEqual(player.kill_cooldown, self.config.kill_cooldown)
|
||||
|
||||
def test_custom_player_speed(self):
|
||||
player = self.engine.add_player("p1", "Red", "red", speed=3.0)
|
||||
self.assertEqual(player.speed, 3.0)
|
||||
|
||||
def test_impostor_context(self):
|
||||
self.engine.add_player("p1", "Red", "red", Role.IMPOSTOR)
|
||||
self.engine.add_player("p2", "Blue", "blue", Role.IMPOSTOR)
|
||||
self.engine.add_player("p3", "Green", "green", Role.CREWMATE)
|
||||
|
||||
context = self.engine.get_impostor_context("p1")
|
||||
|
||||
self.assertIn("fellow_impostors", context)
|
||||
self.assertEqual(len(context["fellow_impostors"]), 1)
|
||||
self.assertEqual(context["fellow_impostors"][0]["id"], "p2")
|
||||
|
||||
def test_impostor_context_for_crewmate(self):
|
||||
self.engine.add_player("p1", "Red", "red", Role.CREWMATE)
|
||||
context = self.engine.get_impostor_context("p1")
|
||||
self.assertEqual(context, {})
|
||||
|
||||
|
||||
class TestActionQueue(unittest.TestCase):
|
||||
"""Tests for action queueing and resolution."""
|
||||
|
||||
def setUp(self):
|
||||
self.config = GameConfig()
|
||||
self.game_map = create_simple_map()
|
||||
self.engine = GameEngine(self.config, self.game_map)
|
||||
self.engine.add_player("p1", "Red", "red", Role.CREWMATE)
|
||||
self.engine.add_player("p2", "Blue", "blue", Role.IMPOSTOR)
|
||||
|
||||
def test_queue_action(self):
|
||||
pos = self.engine.queue_action("p1", "MOVE", {"destination": "electrical"})
|
||||
self.assertEqual(pos, 0)
|
||||
self.assertEqual(len(self.engine._action_queue), 1)
|
||||
|
||||
def test_action_priority(self):
|
||||
# Queue in wrong priority order
|
||||
self.engine.queue_action("p1", "MOVE", {"destination": "electrical"})
|
||||
self.engine.queue_action("p2", "KILL", {"target_id": "p1"})
|
||||
self.engine.queue_action("p2", "SABOTAGE", {"system": "lights"})
|
||||
|
||||
# Resolve - should process in priority order
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
# SABOTAGE should be first, then KILL, then MOVE
|
||||
self.assertEqual(results[0]["action"], "SABOTAGE")
|
||||
self.assertEqual(results[1]["action"], "KILL")
|
||||
self.assertEqual(results[2]["action"], "MOVE")
|
||||
|
||||
def test_queue_clears_after_resolve(self):
|
||||
self.engine.queue_action("p1", "MOVE", {"destination": "admin"})
|
||||
self.engine.resolve_actions()
|
||||
|
||||
self.assertEqual(len(self.engine._action_queue), 0)
|
||||
|
||||
|
||||
class TestMovement(unittest.TestCase):
|
||||
"""Tests for player movement."""
|
||||
|
||||
def setUp(self):
|
||||
self.config = GameConfig()
|
||||
self.game_map = create_simple_map()
|
||||
self.engine = GameEngine(self.config, self.game_map)
|
||||
self.engine.add_player("p1", "Red", "red", Role.CREWMATE)
|
||||
|
||||
def test_move_to_adjacent_room(self):
|
||||
self.engine.queue_action("p1", "MOVE", {"destination": "electrical"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertTrue(results[0]["success"])
|
||||
|
||||
def test_move_same_room(self):
|
||||
self.engine.queue_action("p1", "MOVE", {"destination": "cafeteria"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertTrue(results[0]["success"])
|
||||
|
||||
def test_move_no_path(self):
|
||||
# Add isolated room
|
||||
self.game_map.add_room(Room(id="isolated", name="Isolated"))
|
||||
|
||||
self.engine.queue_action("p1", "MOVE", {"destination": "isolated"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
def test_dead_player_cannot_move(self):
|
||||
player = self.engine.simulator.get_player("p1")
|
||||
player.is_alive = False
|
||||
|
||||
self.engine.queue_action("p1", "MOVE", {"destination": "electrical"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
|
||||
class TestKill(unittest.TestCase):
|
||||
"""Tests for kill mechanics."""
|
||||
|
||||
def setUp(self):
|
||||
self.config = GameConfig()
|
||||
self.game_map = create_simple_map()
|
||||
self.engine = GameEngine(self.config, self.game_map)
|
||||
|
||||
self.engine.add_player("imp", "Red", "red", Role.IMPOSTOR)
|
||||
self.engine.add_player("crew", "Blue", "blue", Role.CREWMATE)
|
||||
|
||||
# Reset kill cooldown for tests
|
||||
imp = self.engine.simulator.get_player("imp")
|
||||
imp.kill_cooldown = 0
|
||||
|
||||
def test_successful_kill(self):
|
||||
self.engine.queue_action("imp", "KILL", {"target_id": "crew"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertTrue(results[0]["success"])
|
||||
|
||||
def test_crewmate_cannot_kill(self):
|
||||
self.engine.queue_action("crew", "KILL", {"target_id": "imp"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
def test_cannot_kill_different_room(self):
|
||||
crew = self.engine.simulator.get_player("crew")
|
||||
crew.position = Position(room_id="electrical")
|
||||
|
||||
self.engine.queue_action("imp", "KILL", {"target_id": "crew"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
def test_kill_cooldown_blocks(self):
|
||||
imp = self.engine.simulator.get_player("imp")
|
||||
imp.kill_cooldown = 10.0
|
||||
|
||||
self.engine.queue_action("imp", "KILL", {"target_id": "crew"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
def test_kill_creates_body(self):
|
||||
self.engine.queue_action("imp", "KILL", {"target_id": "crew"})
|
||||
self.engine.resolve_actions()
|
||||
|
||||
# Process kill event
|
||||
self.engine.simulator.run_until_empty()
|
||||
|
||||
self.assertEqual(len(self.engine.simulator.bodies), 1)
|
||||
self.assertFalse(self.engine.simulator.get_player("crew").is_alive)
|
||||
|
||||
|
||||
class TestVenting(unittest.TestCase):
|
||||
"""Tests for vent mechanics."""
|
||||
|
||||
def setUp(self):
|
||||
self.config = GameConfig()
|
||||
self.game_map = create_simple_map()
|
||||
self.engine = GameEngine(self.config, self.game_map)
|
||||
|
||||
self.engine.add_player("imp", "Red", "red", Role.IMPOSTOR)
|
||||
self.engine.add_player("crew", "Blue", "blue", Role.CREWMATE)
|
||||
|
||||
# Place impostor in electrical (has vent)
|
||||
imp = self.engine.simulator.get_player("imp")
|
||||
imp.position = Position(room_id="electrical")
|
||||
|
||||
def test_impostor_can_vent(self):
|
||||
self.engine.queue_action("imp", "VENT", {"destination": "security"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertTrue(results[0]["success"])
|
||||
|
||||
def test_crewmate_cannot_vent(self):
|
||||
crew = self.engine.simulator.get_player("crew")
|
||||
crew.position = Position(room_id="electrical")
|
||||
|
||||
self.engine.queue_action("crew", "VENT", {"destination": "security"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
def test_cannot_vent_unconnected(self):
|
||||
# Cafeteria has no vent
|
||||
imp = self.engine.simulator.get_player("imp")
|
||||
imp.position = Position(room_id="cafeteria")
|
||||
|
||||
self.engine.queue_action("imp", "VENT", {"destination": "security"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
|
||||
class TestTasks(unittest.TestCase):
|
||||
"""Tests for task mechanics."""
|
||||
|
||||
def setUp(self):
|
||||
self.config = GameConfig()
|
||||
self.game_map = create_simple_map()
|
||||
self.engine = GameEngine(self.config, self.game_map)
|
||||
|
||||
player = self.engine.add_player("p1", "Red", "red", Role.CREWMATE)
|
||||
player.tasks_assigned = ["wires_cafe", "wires_elec"]
|
||||
|
||||
def test_start_task_in_current_room(self):
|
||||
self.engine.queue_action("p1", "TASK", {"task_id": "wires_cafe"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertTrue(results[0]["success"])
|
||||
|
||||
def test_cannot_do_task_in_wrong_room(self):
|
||||
# wires_elec is in electrical, player is in cafeteria
|
||||
self.engine.queue_action("p1", "TASK", {"task_id": "wires_elec"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
def test_cannot_do_unassigned_task(self):
|
||||
self.engine.queue_action("p1", "TASK", {"task_id": "nonexistent"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
|
||||
class TestReporting(unittest.TestCase):
|
||||
"""Tests for body reporting."""
|
||||
|
||||
def setUp(self):
|
||||
self.config = GameConfig()
|
||||
self.game_map = create_simple_map()
|
||||
self.engine = GameEngine(self.config, self.game_map)
|
||||
|
||||
self.engine.add_player("p1", "Red", "red", Role.CREWMATE)
|
||||
|
||||
# Create a body in cafeteria
|
||||
body = Body(
|
||||
id="body1",
|
||||
player_id="dead",
|
||||
player_name="Blue",
|
||||
position=Position(room_id="cafeteria"),
|
||||
time_of_death=0.0
|
||||
)
|
||||
self.engine.simulator.bodies.append(body)
|
||||
|
||||
def test_report_body_in_room(self):
|
||||
self.engine.queue_action("p1", "REPORT", {"body_id": "body1"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertTrue(results[0]["success"])
|
||||
|
||||
def test_cannot_report_body_in_different_room(self):
|
||||
player = self.engine.simulator.get_player("p1")
|
||||
player.position = Position(room_id="electrical")
|
||||
|
||||
self.engine.queue_action("p1", "REPORT", {"body_id": "body1"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
def test_cannot_report_already_reported(self):
|
||||
self.engine.simulator.bodies[0].reported = True
|
||||
|
||||
self.engine.queue_action("p1", "REPORT", {"body_id": "body1"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
|
||||
class TestEmergency(unittest.TestCase):
|
||||
"""Tests for emergency button."""
|
||||
|
||||
def setUp(self):
|
||||
self.config = GameConfig()
|
||||
self.game_map = create_simple_map()
|
||||
self.engine = GameEngine(self.config, self.game_map)
|
||||
|
||||
self.engine.add_player("p1", "Red", "red", Role.CREWMATE)
|
||||
|
||||
def test_call_emergency_in_cafeteria(self):
|
||||
self.engine.queue_action("p1", "EMERGENCY", {})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertTrue(results[0]["success"])
|
||||
|
||||
def test_cannot_call_emergency_outside_cafeteria(self):
|
||||
player = self.engine.simulator.get_player("p1")
|
||||
player.position = Position(room_id="electrical")
|
||||
|
||||
self.engine.queue_action("p1", "EMERGENCY", {})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
def test_emergency_limit_per_player(self):
|
||||
# Use up emergency
|
||||
self.engine.queue_action("p1", "EMERGENCY", {})
|
||||
self.engine.resolve_actions()
|
||||
|
||||
# Try again
|
||||
self.engine.queue_action("p1", "EMERGENCY", {})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
|
||||
class TestSabotage(unittest.TestCase):
|
||||
"""Tests for sabotage mechanics."""
|
||||
|
||||
def setUp(self):
|
||||
self.config = GameConfig()
|
||||
self.game_map = create_simple_map()
|
||||
self.engine = GameEngine(self.config, self.game_map)
|
||||
|
||||
self.engine.add_player("imp", "Red", "red", Role.IMPOSTOR)
|
||||
|
||||
def test_impostor_can_sabotage(self):
|
||||
self.engine.queue_action("imp", "SABOTAGE", {"system": "lights"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertTrue(results[0]["success"])
|
||||
|
||||
def test_cannot_double_sabotage(self):
|
||||
self.engine.active_sabotage = "lights"
|
||||
|
||||
self.engine.queue_action("imp", "SABOTAGE", {"system": "o2"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
def test_invalid_sabotage_system(self):
|
||||
self.engine.queue_action("imp", "SABOTAGE", {"system": "invalid"})
|
||||
results = self.engine.resolve_actions()
|
||||
|
||||
self.assertFalse(results[0]["success"])
|
||||
|
||||
|
||||
class TestWinConditions(unittest.TestCase):
|
||||
"""Tests for win condition checking."""
|
||||
|
||||
def setUp(self):
|
||||
self.config = GameConfig()
|
||||
self.game_map = create_simple_map()
|
||||
self.engine = GameEngine(self.config, self.game_map)
|
||||
|
||||
def test_no_win_yet(self):
|
||||
self.engine.add_player("imp", "Red", "red", Role.IMPOSTOR)
|
||||
self.engine.add_player("c1", "Blue", "blue", Role.CREWMATE)
|
||||
self.engine.add_player("c2", "Green", "green", Role.CREWMATE)
|
||||
|
||||
self.assertIsNone(self.engine.check_win_condition())
|
||||
|
||||
def test_impostor_wins_by_parity(self):
|
||||
self.engine.add_player("imp", "Red", "red", Role.IMPOSTOR)
|
||||
self.engine.add_player("crew", "Blue", "blue", Role.CREWMATE)
|
||||
|
||||
self.assertEqual(self.engine.check_win_condition(), "impostor")
|
||||
|
||||
def test_crewmate_wins_all_impostors_dead(self):
|
||||
self.engine.add_player("imp", "Red", "red", Role.IMPOSTOR)
|
||||
self.engine.add_player("crew", "Blue", "blue", Role.CREWMATE)
|
||||
|
||||
imp = self.engine.simulator.get_player("imp")
|
||||
imp.is_alive = False
|
||||
|
||||
self.assertEqual(self.engine.check_win_condition(), "crewmate")
|
||||
|
||||
def test_crewmate_wins_all_tasks(self):
|
||||
self.engine.add_player("imp", "Red", "red", Role.IMPOSTOR)
|
||||
self.engine.add_player("c1", "Blue", "blue", Role.CREWMATE)
|
||||
self.engine.add_player("c2", "Green", "green", Role.CREWMATE)
|
||||
|
||||
c1 = self.engine.simulator.get_player("c1")
|
||||
c2 = self.engine.simulator.get_player("c2")
|
||||
|
||||
c1.tasks_assigned = ["t1"]
|
||||
c1.tasks_completed = ["t1"]
|
||||
c2.tasks_assigned = ["t2"]
|
||||
c2.tasks_completed = ["t2"]
|
||||
|
||||
self.assertEqual(self.engine.check_win_condition(), "crewmate")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,293 @@
|
||||
"""
|
||||
The Glass Box League — LLM Integration Test
|
||||
|
||||
Tests the full LLM integration with OpenRouter using free models.
|
||||
"""
|
||||
|
||||
import sys
|
||||
import json
|
||||
sys.path.insert(0, '.')
|
||||
|
||||
from src.llm.client import OpenRouterClient, get_client
|
||||
from src.agents.agent import Agent, AgentConfig
|
||||
from src.agents.prompt_assembler import PromptAssembler, PromptConfig
|
||||
from src.main import GameOrchestrator
|
||||
from src.engine.types import Role
|
||||
|
||||
|
||||
def test_basic_llm_call():
|
||||
"""Test basic LLM API call."""
|
||||
print("\n=== Test 1: Basic LLM Call ===")
|
||||
|
||||
client = get_client()
|
||||
|
||||
response = client.generate(
|
||||
system_prompt="You are a helpful assistant. Respond with valid JSON only.",
|
||||
user_prompt='Say hello in JSON format: {"greeting": "..."}',
|
||||
model="google/gemma-3-4b-it:free"
|
||||
)
|
||||
|
||||
print(f"Raw response: {response[:200] if response else 'None'}...")
|
||||
|
||||
if response:
|
||||
try:
|
||||
parsed = json.loads(response)
|
||||
print(f"✓ Parsed JSON: {parsed}")
|
||||
return True
|
||||
except:
|
||||
print(f"✗ Failed to parse JSON")
|
||||
return False
|
||||
return False
|
||||
|
||||
|
||||
def test_action_prompt():
|
||||
"""Test action phase prompt generation and LLM response."""
|
||||
print("\n=== Test 2: Action Phase Prompt ===")
|
||||
|
||||
# Build prompt
|
||||
config = PromptConfig(
|
||||
model_name="Gemini-Flash",
|
||||
persona="You are a cautious crewmate who trusts no one.",
|
||||
strategy_level="basic",
|
||||
meta_level="direct",
|
||||
is_impostor=False
|
||||
)
|
||||
assembler = PromptAssembler(config)
|
||||
|
||||
game_settings = {"num_impostors": 1, "kill_cooldown": 25}
|
||||
|
||||
system_prompt = assembler.build_system_prompt(
|
||||
phase="action",
|
||||
game_settings=game_settings,
|
||||
map_name="The Skeld",
|
||||
learned={}
|
||||
)
|
||||
|
||||
player_state = {
|
||||
"id": "red",
|
||||
"name": "Red",
|
||||
"role": "CREWMATE",
|
||||
"location": "cafeteria",
|
||||
"tasks_total": 3,
|
||||
"tasks_completed": 0
|
||||
}
|
||||
|
||||
vision = {
|
||||
"room": "cafeteria",
|
||||
"players_visible": [
|
||||
{"id": "blue", "name": "Blue", "color": "blue"}
|
||||
],
|
||||
"bodies_visible": [],
|
||||
"exits": ["weapons", "admin", "medbay"]
|
||||
}
|
||||
|
||||
available_actions = {
|
||||
"can_move_to": ["weapons", "admin", "medbay"],
|
||||
"can_interact": ["emergency_button"]
|
||||
}
|
||||
|
||||
user_prompt = assembler.build_action_prompt(
|
||||
player_state=player_state,
|
||||
recent_history=[],
|
||||
vision=vision,
|
||||
available_actions=available_actions,
|
||||
trigger={"type": "GAME_START", "t": 0}
|
||||
)
|
||||
|
||||
print(f"System prompt: {len(system_prompt)} chars")
|
||||
print(f"User prompt: {len(user_prompt)} chars")
|
||||
|
||||
# Call LLM
|
||||
client = get_client()
|
||||
response = client.generate_json(
|
||||
system_prompt=system_prompt,
|
||||
user_prompt=user_prompt,
|
||||
model="google/gemma-3-4b-it:free"
|
||||
)
|
||||
|
||||
if response:
|
||||
print(f"✓ LLM response: {json.dumps(response, indent=2)[:500]}...")
|
||||
|
||||
# Check response structure
|
||||
has_action = "action" in response
|
||||
has_thought = "internal_thought" in response
|
||||
|
||||
print(f" Has action: {has_action}")
|
||||
print(f" Has internal_thought: {has_thought}")
|
||||
|
||||
return has_action
|
||||
else:
|
||||
print("✗ No response from LLM")
|
||||
return False
|
||||
|
||||
|
||||
def test_discussion_prompt():
|
||||
"""Test discussion phase prompt and LLM response."""
|
||||
print("\n=== Test 3: Discussion Phase Prompt ===")
|
||||
|
||||
config = PromptConfig(
|
||||
model_name="Gemini-Flash",
|
||||
persona="You are suspicious of everyone.",
|
||||
is_impostor=False
|
||||
)
|
||||
assembler = PromptAssembler(config)
|
||||
|
||||
game_settings = {"num_impostors": 1}
|
||||
|
||||
system_prompt = assembler.build_system_prompt(
|
||||
phase="discussion",
|
||||
game_settings=game_settings,
|
||||
map_name="The Skeld"
|
||||
)
|
||||
|
||||
player_state = {
|
||||
"id": "red",
|
||||
"name": "Red",
|
||||
"role": "CREWMATE",
|
||||
"location": "cafeteria"
|
||||
}
|
||||
|
||||
transcript = [
|
||||
{"speaker": "Blue", "message": "I found the body in electrical!"},
|
||||
{"speaker": "Green", "message": "Where was everyone?"}
|
||||
]
|
||||
|
||||
user_prompt = assembler.build_discussion_prompt(
|
||||
player_state=player_state,
|
||||
transcript=transcript,
|
||||
meeting_scratchpad={}
|
||||
)
|
||||
|
||||
print(f"System prompt: {len(system_prompt)} chars")
|
||||
print(f"User prompt: {len(user_prompt)} chars")
|
||||
|
||||
client = get_client()
|
||||
response = client.generate_json(
|
||||
system_prompt=system_prompt,
|
||||
user_prompt=user_prompt,
|
||||
model="google/gemma-3-4b-it:free"
|
||||
)
|
||||
|
||||
if response:
|
||||
print(f"✓ LLM response: {json.dumps(response, indent=2)[:500]}...")
|
||||
|
||||
has_desire = "desire_to_speak" in response
|
||||
has_message = "message" in response
|
||||
|
||||
print(f" Has desire_to_speak: {has_desire}")
|
||||
print(f" Has message: {has_message}")
|
||||
|
||||
return has_desire and has_message
|
||||
else:
|
||||
print("✗ No response from LLM")
|
||||
return False
|
||||
|
||||
|
||||
def test_impostor_action():
|
||||
"""Test impostor action with kill available."""
|
||||
print("\n=== Test 4: Impostor Action ===")
|
||||
|
||||
config = PromptConfig(
|
||||
model_name="Gemini-Flash",
|
||||
persona="You are a ruthless impostor.",
|
||||
is_impostor=True,
|
||||
fellow_impostors=["Purple"],
|
||||
strategy_level="intermediate"
|
||||
)
|
||||
assembler = PromptAssembler(config)
|
||||
|
||||
system_prompt = assembler.build_system_prompt(
|
||||
phase="action",
|
||||
game_settings={"num_impostors": 2},
|
||||
map_name="The Skeld"
|
||||
)
|
||||
|
||||
player_state = {
|
||||
"id": "red",
|
||||
"name": "Red",
|
||||
"role": "IMPOSTOR",
|
||||
"location": "electrical",
|
||||
"kill_cooldown": 0
|
||||
}
|
||||
|
||||
vision = {
|
||||
"room": "electrical",
|
||||
"players_visible": [
|
||||
{"id": "blue", "name": "Blue", "color": "blue", "action": "doing_task"}
|
||||
],
|
||||
"bodies_visible": [],
|
||||
"exits": ["security"]
|
||||
}
|
||||
|
||||
available_actions = {
|
||||
"can_move_to": ["security"],
|
||||
"can_interact": ["vent_elec"],
|
||||
"can_kill": ["blue"],
|
||||
"can_sabotage": ["lights", "o2", "reactor"]
|
||||
}
|
||||
|
||||
user_prompt = assembler.build_action_prompt(
|
||||
player_state=player_state,
|
||||
recent_history=[],
|
||||
vision=vision,
|
||||
available_actions=available_actions,
|
||||
trigger={"type": "PERIODIC", "t": 30.0}
|
||||
)
|
||||
|
||||
client = get_client()
|
||||
response = client.generate_json(
|
||||
system_prompt=system_prompt,
|
||||
user_prompt=user_prompt,
|
||||
model="google/gemma-3-4b-it:free"
|
||||
)
|
||||
|
||||
if response:
|
||||
print(f"✓ LLM response: {json.dumps(response, indent=2)[:600]}...")
|
||||
|
||||
action = response.get("action", {})
|
||||
action_type = action.get("type")
|
||||
|
||||
print(f" Action type: {action_type}")
|
||||
print(f" Thought: {response.get('internal_thought', '')[:100]}...")
|
||||
|
||||
return True
|
||||
else:
|
||||
print("✗ No response from LLM")
|
||||
return False
|
||||
|
||||
|
||||
def main():
|
||||
"""Run all LLM integration tests."""
|
||||
print("=" * 60)
|
||||
print("THE GLASS BOX LEAGUE — LLM INTEGRATION TESTS")
|
||||
print("Using free Gemini model via OpenRouter")
|
||||
print("=" * 60)
|
||||
|
||||
results = []
|
||||
|
||||
# Run tests
|
||||
results.append(("Basic LLM Call", test_basic_llm_call()))
|
||||
results.append(("Action Phase", test_action_prompt()))
|
||||
results.append(("Discussion Phase", test_discussion_prompt()))
|
||||
results.append(("Impostor Action", test_impostor_action()))
|
||||
|
||||
# Summary
|
||||
print("\n" + "=" * 60)
|
||||
print("RESULTS")
|
||||
print("=" * 60)
|
||||
|
||||
passed = 0
|
||||
for name, result in results:
|
||||
status = "✓ PASS" if result else "✗ FAIL"
|
||||
print(f" {status}: {name}")
|
||||
if result:
|
||||
passed += 1
|
||||
|
||||
print(f"\nTotal: {passed}/{len(results)} tests passed")
|
||||
|
||||
return passed == len(results)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = main()
|
||||
sys.exit(0 if success else 1)
|
||||
@@ -0,0 +1,219 @@
|
||||
"""
|
||||
Tests for the map/graph system.
|
||||
"""
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
import os
|
||||
import tempfile
|
||||
import json
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
from src.map.graph import GameMap, Room, Edge, Task, Vent
|
||||
|
||||
|
||||
class TestRoom(unittest.TestCase):
|
||||
"""Tests for Room dataclass."""
|
||||
|
||||
def test_room_creation(self):
|
||||
room = Room(id="test", name="Test Room")
|
||||
self.assertEqual(room.id, "test")
|
||||
self.assertEqual(room.name, "Test Room")
|
||||
self.assertEqual(room.tasks, [])
|
||||
self.assertIsNone(room.vent)
|
||||
|
||||
def test_room_with_tasks(self):
|
||||
task = Task(id="task1", name="Do Thing", duration=5.0)
|
||||
room = Room(id="test", name="Test Room", tasks=[task])
|
||||
self.assertEqual(len(room.tasks), 1)
|
||||
self.assertEqual(room.tasks[0].duration, 5.0)
|
||||
|
||||
def test_room_with_vent(self):
|
||||
vent = Vent(id="vent1", connects_to=["vent2", "vent3"])
|
||||
room = Room(id="test", name="Test Room", vent=vent)
|
||||
self.assertIsNotNone(room.vent)
|
||||
self.assertEqual(len(room.vent.connects_to), 2)
|
||||
|
||||
|
||||
class TestEdge(unittest.TestCase):
|
||||
"""Tests for Edge dataclass."""
|
||||
|
||||
def test_edge_creation(self):
|
||||
edge = Edge(id="e1", room_a="a", room_b="b", distance=5.0)
|
||||
self.assertEqual(edge.id, "e1")
|
||||
self.assertEqual(edge.distance, 5.0)
|
||||
|
||||
def test_edge_other_room(self):
|
||||
edge = Edge(id="e1", room_a="a", room_b="b", distance=5.0)
|
||||
self.assertEqual(edge.other_room("a"), "b")
|
||||
self.assertEqual(edge.other_room("b"), "a")
|
||||
|
||||
|
||||
class TestGameMap(unittest.TestCase):
|
||||
"""Tests for GameMap class."""
|
||||
|
||||
def setUp(self):
|
||||
"""Create a simple test map."""
|
||||
self.game_map = GameMap()
|
||||
|
||||
# Create rooms: A -- B -- C
|
||||
# |
|
||||
# D
|
||||
self.game_map.add_room(Room(id="a", name="Room A"))
|
||||
self.game_map.add_room(Room(id="b", name="Room B"))
|
||||
self.game_map.add_room(Room(id="c", name="Room C"))
|
||||
self.game_map.add_room(Room(id="d", name="Room D"))
|
||||
|
||||
self.game_map.add_edge(Edge(id="ab", room_a="a", room_b="b", distance=3.0))
|
||||
self.game_map.add_edge(Edge(id="bc", room_a="b", room_b="c", distance=4.0))
|
||||
self.game_map.add_edge(Edge(id="bd", room_a="b", room_b="d", distance=2.0))
|
||||
|
||||
def test_add_room(self):
|
||||
self.assertEqual(len(self.game_map.rooms), 4)
|
||||
self.assertIn("a", self.game_map.rooms)
|
||||
|
||||
def test_add_edge(self):
|
||||
self.assertEqual(len(self.game_map.edges), 3)
|
||||
self.assertIn("ab", self.game_map.edges)
|
||||
|
||||
def test_get_room(self):
|
||||
room = self.game_map.get_room("a")
|
||||
self.assertIsNotNone(room)
|
||||
self.assertEqual(room.name, "Room A")
|
||||
|
||||
self.assertIsNone(self.game_map.get_room("nonexistent"))
|
||||
|
||||
def test_get_edge(self):
|
||||
edge = self.game_map.get_edge("ab")
|
||||
self.assertIsNotNone(edge)
|
||||
self.assertEqual(edge.distance, 3.0)
|
||||
|
||||
def test_get_neighbors(self):
|
||||
neighbors = self.game_map.get_neighbors("b")
|
||||
self.assertEqual(len(neighbors), 3) # a, c, d
|
||||
neighbor_rooms = [n[1] for n in neighbors]
|
||||
self.assertIn("a", neighbor_rooms)
|
||||
self.assertIn("c", neighbor_rooms)
|
||||
self.assertIn("d", neighbor_rooms)
|
||||
|
||||
def test_find_edge(self):
|
||||
edge = self.game_map.find_edge("a", "b")
|
||||
self.assertIsNotNone(edge)
|
||||
self.assertEqual(edge.id, "ab")
|
||||
|
||||
# Reverse direction
|
||||
edge = self.game_map.find_edge("b", "a")
|
||||
self.assertIsNotNone(edge)
|
||||
|
||||
# Non-adjacent
|
||||
self.assertIsNone(self.game_map.find_edge("a", "c"))
|
||||
|
||||
def test_find_path_adjacent(self):
|
||||
path = self.game_map.find_path("a", "b")
|
||||
self.assertEqual(path, ["ab"])
|
||||
|
||||
def test_find_path_multi_hop(self):
|
||||
path = self.game_map.find_path("a", "c")
|
||||
self.assertEqual(path, ["ab", "bc"])
|
||||
|
||||
def test_find_path_same_room(self):
|
||||
path = self.game_map.find_path("a", "a")
|
||||
self.assertEqual(path, [])
|
||||
|
||||
def test_find_path_no_path(self):
|
||||
# Add isolated room
|
||||
self.game_map.add_room(Room(id="isolated", name="Isolated"))
|
||||
path = self.game_map.find_path("a", "isolated")
|
||||
self.assertIsNone(path)
|
||||
|
||||
def test_path_distance(self):
|
||||
path = self.game_map.find_path("a", "c")
|
||||
distance = self.game_map.path_distance(path)
|
||||
self.assertEqual(distance, 7.0) # 3 + 4
|
||||
|
||||
def test_shortest_path(self):
|
||||
# Add direct edge from a to d (should be longer)
|
||||
self.game_map.add_edge(Edge(id="ad", room_a="a", room_b="d", distance=10.0))
|
||||
|
||||
# Shortest path should still go through b
|
||||
path = self.game_map.find_path("a", "d")
|
||||
distance = self.game_map.path_distance(path)
|
||||
self.assertEqual(distance, 5.0) # 3 + 2 via b
|
||||
|
||||
|
||||
class TestMapSerialization(unittest.TestCase):
|
||||
"""Tests for map serialization."""
|
||||
|
||||
def test_to_dict(self):
|
||||
game_map = GameMap()
|
||||
game_map.add_room(Room(id="a", name="A"))
|
||||
game_map.add_room(Room(id="b", name="B"))
|
||||
game_map.add_edge(Edge(id="ab", room_a="a", room_b="b", distance=5.0))
|
||||
|
||||
data = game_map.to_dict()
|
||||
self.assertEqual(len(data["rooms"]), 2)
|
||||
self.assertEqual(len(data["edges"]), 1)
|
||||
|
||||
def test_save_and_load(self):
|
||||
game_map = GameMap()
|
||||
task = Task(id="t1", name="Task", duration=3.0)
|
||||
vent = Vent(id="v1", connects_to=["v2"])
|
||||
game_map.add_room(Room(id="a", name="A", tasks=[task], vent=vent))
|
||||
game_map.add_room(Room(id="b", name="B"))
|
||||
game_map.add_edge(Edge(id="ab", room_a="a", room_b="b", distance=5.0))
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
|
||||
game_map.save(f.name)
|
||||
|
||||
loaded = GameMap.load(f.name)
|
||||
self.assertEqual(len(loaded.rooms), 2)
|
||||
self.assertEqual(len(loaded.edges), 1)
|
||||
self.assertEqual(loaded.rooms["a"].tasks[0].duration, 3.0)
|
||||
self.assertIsNotNone(loaded.rooms["a"].vent)
|
||||
|
||||
os.unlink(f.name)
|
||||
|
||||
|
||||
class TestSkeldMap(unittest.TestCase):
|
||||
"""Tests for the actual Skeld map."""
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
map_path = os.path.join(
|
||||
os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
|
||||
"data", "maps", "skeld.json"
|
||||
)
|
||||
cls.skeld = GameMap.load(map_path)
|
||||
|
||||
def test_skeld_has_all_rooms(self):
|
||||
expected_rooms = [
|
||||
"cafeteria", "weapons", "navigation", "o2", "admin",
|
||||
"storage", "communications", "shields", "electrical",
|
||||
"lower_engine", "security", "reactor", "upper_engine", "medbay"
|
||||
]
|
||||
for room_id in expected_rooms:
|
||||
self.assertIn(room_id, self.skeld.rooms, f"Missing room: {room_id}")
|
||||
|
||||
def test_skeld_connectivity(self):
|
||||
# Every room should be reachable from cafeteria
|
||||
for room_id in self.skeld.rooms:
|
||||
path = self.skeld.find_path("cafeteria", room_id)
|
||||
self.assertIsNotNone(path, f"No path to {room_id}")
|
||||
|
||||
def test_skeld_has_vents(self):
|
||||
vent_rooms = ["weapons", "navigation", "admin", "electrical",
|
||||
"lower_engine", "security", "reactor", "upper_engine", "medbay", "shields"]
|
||||
for room_id in vent_rooms:
|
||||
room = self.skeld.get_room(room_id)
|
||||
self.assertIsNotNone(room.vent, f"{room_id} should have a vent")
|
||||
|
||||
def test_vent_connectivity(self):
|
||||
# Check medbay-security-electrical vent network
|
||||
medbay = self.skeld.get_room("medbay")
|
||||
self.assertIn("vent_security", medbay.vent.connects_to)
|
||||
self.assertIn("vent_elec", medbay.vent.connects_to)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,108 @@
|
||||
"""
|
||||
Tests for the meeting flow manager.
|
||||
"""
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
import os
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
from src.engine.meeting_flow import MeetingFlowManager
|
||||
|
||||
|
||||
class TestMeetingFlowManager(unittest.TestCase):
|
||||
"""Tests for MeetingFlowManager."""
|
||||
|
||||
def setUp(self):
|
||||
self.meeting = MeetingFlowManager()
|
||||
|
||||
def test_start_meeting(self):
|
||||
state = self.meeting.start_meeting("red", "body_report", "electrical")
|
||||
|
||||
self.assertTrue(self.meeting.is_meeting_active())
|
||||
self.assertEqual(state.called_by, "red")
|
||||
self.assertEqual(state.reason, "body_report")
|
||||
|
||||
def test_submit_interrupt_note(self):
|
||||
self.meeting.start_meeting("red", "emergency")
|
||||
self.meeting.submit_interrupt_note("blue", {"was_doing": "going to electrical"})
|
||||
|
||||
note = self.meeting.current_meeting.interrupt_notes.get("blue")
|
||||
self.assertIsNotNone(note)
|
||||
self.assertEqual(note["was_doing"], "going to electrical")
|
||||
|
||||
def test_meeting_scratchpad(self):
|
||||
self.meeting.start_meeting("red", "emergency")
|
||||
self.meeting.init_meeting_scratchpad("blue", {"suspects": []})
|
||||
self.meeting.update_meeting_scratchpad("blue", {"suspects": ["red"]})
|
||||
|
||||
pad = self.meeting.get_meeting_scratchpad("blue")
|
||||
self.assertEqual(pad["suspects"], ["red"])
|
||||
|
||||
def test_add_message(self):
|
||||
self.meeting.start_meeting("red", "emergency")
|
||||
self.meeting.add_message("red", "Red", "Where was everyone?")
|
||||
self.meeting.add_message("blue", "Blue", "I was in medbay", target="Red")
|
||||
|
||||
transcript = self.meeting.get_transcript()
|
||||
self.assertEqual(len(transcript), 2)
|
||||
self.assertEqual(transcript[1]["target"], "Red")
|
||||
|
||||
def test_voting(self):
|
||||
self.meeting.start_meeting("red", "emergency")
|
||||
|
||||
self.meeting.submit_vote("red", "blue")
|
||||
self.meeting.submit_vote("blue", "skip")
|
||||
self.meeting.submit_vote("green", "blue")
|
||||
|
||||
self.assertTrue(self.meeting.has_voted("red"))
|
||||
self.assertTrue(self.meeting.all_voted(["red", "blue", "green"]))
|
||||
|
||||
def test_tally_votes_ejection(self):
|
||||
self.meeting.start_meeting("red", "emergency")
|
||||
self.meeting.submit_vote("red", "blue")
|
||||
self.meeting.submit_vote("green", "blue")
|
||||
self.meeting.submit_vote("blue", "skip")
|
||||
|
||||
ejected, details = self.meeting.tally_votes()
|
||||
|
||||
self.assertEqual(ejected, "blue")
|
||||
self.assertEqual(details["counts"]["blue"], 2)
|
||||
|
||||
def test_tally_votes_tie(self):
|
||||
self.meeting.start_meeting("red", "emergency")
|
||||
self.meeting.submit_vote("red", "blue")
|
||||
self.meeting.submit_vote("blue", "red")
|
||||
self.meeting.submit_vote("green", "skip")
|
||||
|
||||
ejected, details = self.meeting.tally_votes()
|
||||
|
||||
self.assertIsNone(ejected)
|
||||
self.assertTrue(details["was_tie"])
|
||||
|
||||
def test_tally_votes_skip_wins(self):
|
||||
self.meeting.start_meeting("red", "emergency")
|
||||
self.meeting.submit_vote("red", "skip")
|
||||
self.meeting.submit_vote("blue", "skip")
|
||||
self.meeting.submit_vote("green", "blue")
|
||||
|
||||
ejected, details = self.meeting.tally_votes()
|
||||
|
||||
self.assertIsNone(ejected)
|
||||
|
||||
def test_end_meeting(self):
|
||||
self.meeting.start_meeting("red", "emergency")
|
||||
self.meeting.submit_vote("red", "blue")
|
||||
self.meeting.submit_vote("green", "blue")
|
||||
|
||||
state = self.meeting.end_meeting("blue", was_impostor=True)
|
||||
|
||||
self.assertFalse(self.meeting.is_meeting_active())
|
||||
self.assertEqual(len(self.meeting.meeting_history), 1)
|
||||
self.assertEqual(state.ejected, "blue")
|
||||
self.assertTrue(state.was_impostor)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,212 @@
|
||||
"""
|
||||
Tests for the discrete event simulator.
|
||||
"""
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
import os
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
from src.engine.simulator import Simulator
|
||||
from src.engine.types import Event, Player, Position, Role, GamePhase
|
||||
|
||||
|
||||
class TestEvent(unittest.TestCase):
|
||||
"""Tests for Event dataclass."""
|
||||
|
||||
def test_event_creation(self):
|
||||
event = Event(time=10.0, event_type="TEST", data={"key": "value"})
|
||||
self.assertEqual(event.time, 10.0)
|
||||
self.assertEqual(event.event_type, "TEST")
|
||||
self.assertEqual(event.data["key"], "value")
|
||||
|
||||
def test_event_ordering(self):
|
||||
e1 = Event(time=5.0, event_type="A")
|
||||
e2 = Event(time=10.0, event_type="B")
|
||||
e3 = Event(time=5.0, event_type="C")
|
||||
|
||||
self.assertTrue(e1 < e2)
|
||||
self.assertFalse(e2 < e1)
|
||||
# Same time - order undefined but should not error
|
||||
self.assertFalse(e1 < e3 and e3 < e1)
|
||||
|
||||
|
||||
class TestPlayer(unittest.TestCase):
|
||||
"""Tests for Player dataclass."""
|
||||
|
||||
def test_player_creation(self):
|
||||
player = Player(
|
||||
id="p1", name="Red", color="red",
|
||||
role=Role.CREWMATE,
|
||||
position=Position(room_id="cafeteria")
|
||||
)
|
||||
self.assertEqual(player.id, "p1")
|
||||
self.assertEqual(player.role, Role.CREWMATE)
|
||||
self.assertTrue(player.is_alive)
|
||||
|
||||
def test_position_in_room(self):
|
||||
pos = Position(room_id="cafeteria")
|
||||
self.assertTrue(pos.is_in_room())
|
||||
self.assertFalse(pos.is_on_edge())
|
||||
|
||||
def test_position_on_edge(self):
|
||||
pos = Position(edge_id="ab", progress=0.5)
|
||||
self.assertFalse(pos.is_in_room())
|
||||
self.assertTrue(pos.is_on_edge())
|
||||
|
||||
|
||||
class TestSimulator(unittest.TestCase):
|
||||
"""Tests for the Simulator class."""
|
||||
|
||||
def setUp(self):
|
||||
self.sim = Simulator()
|
||||
|
||||
def test_initial_state(self):
|
||||
self.assertEqual(self.sim.time, 0.0)
|
||||
self.assertEqual(self.sim.phase, GamePhase.LOBBY)
|
||||
self.assertEqual(len(self.sim.players), 0)
|
||||
|
||||
def test_schedule_event(self):
|
||||
event = Event(time=5.0, event_type="TEST")
|
||||
self.sim.schedule(event)
|
||||
self.assertEqual(self.sim.peek_next_time(), 5.0)
|
||||
|
||||
def test_schedule_at(self):
|
||||
event = self.sim.schedule_at(10.0, "TEST", {"data": 1})
|
||||
self.assertEqual(event.time, 10.0)
|
||||
self.assertEqual(self.sim.peek_next_time(), 10.0)
|
||||
|
||||
def test_schedule_in(self):
|
||||
self.sim.time = 5.0
|
||||
event = self.sim.schedule_in(3.0, "TEST")
|
||||
self.assertEqual(event.time, 8.0)
|
||||
|
||||
def test_step_processes_event(self):
|
||||
self.sim.schedule_at(5.0, "TEST")
|
||||
event = self.sim.step()
|
||||
|
||||
self.assertIsNotNone(event)
|
||||
self.assertEqual(event.event_type, "TEST")
|
||||
self.assertEqual(self.sim.time, 5.0)
|
||||
|
||||
def test_step_empty_queue(self):
|
||||
event = self.sim.step()
|
||||
self.assertIsNone(event)
|
||||
|
||||
def test_event_ordering(self):
|
||||
self.sim.schedule_at(10.0, "SECOND")
|
||||
self.sim.schedule_at(5.0, "FIRST")
|
||||
self.sim.schedule_at(15.0, "THIRD")
|
||||
|
||||
e1 = self.sim.step()
|
||||
e2 = self.sim.step()
|
||||
e3 = self.sim.step()
|
||||
|
||||
self.assertEqual(e1.event_type, "FIRST")
|
||||
self.assertEqual(e2.event_type, "SECOND")
|
||||
self.assertEqual(e3.event_type, "THIRD")
|
||||
|
||||
def test_event_handler(self):
|
||||
received = []
|
||||
|
||||
def handler(event):
|
||||
received.append(event.data.get("value"))
|
||||
|
||||
self.sim.on("TEST", handler)
|
||||
self.sim.schedule_at(5.0, "TEST", {"value": 42})
|
||||
self.sim.step()
|
||||
|
||||
self.assertEqual(received, [42])
|
||||
|
||||
def test_multiple_handlers(self):
|
||||
calls = []
|
||||
|
||||
self.sim.on("TEST", lambda e: calls.append("A"))
|
||||
self.sim.on("TEST", lambda e: calls.append("B"))
|
||||
|
||||
self.sim.schedule_at(5.0, "TEST")
|
||||
self.sim.step()
|
||||
|
||||
self.assertEqual(calls, ["A", "B"])
|
||||
|
||||
def test_wildcard_handler(self):
|
||||
events = []
|
||||
|
||||
self.sim.on("*", lambda e: events.append(e.event_type))
|
||||
|
||||
self.sim.schedule_at(1.0, "A")
|
||||
self.sim.schedule_at(2.0, "B")
|
||||
self.sim.step()
|
||||
self.sim.step()
|
||||
|
||||
self.assertEqual(events, ["A", "B"])
|
||||
|
||||
def test_run_until(self):
|
||||
self.sim.schedule_at(5.0, "A")
|
||||
self.sim.schedule_at(10.0, "B")
|
||||
self.sim.schedule_at(15.0, "C")
|
||||
|
||||
self.sim.run_until(10.0)
|
||||
|
||||
self.assertEqual(self.sim.time, 10.0)
|
||||
self.assertEqual(self.sim.peek_next_time(), 15.0)
|
||||
|
||||
def test_run_until_empty(self):
|
||||
self.sim.schedule_at(5.0, "A")
|
||||
self.sim.run_until_empty()
|
||||
|
||||
self.assertEqual(self.sim.time, 5.0)
|
||||
self.assertIsNone(self.sim.peek_next_time())
|
||||
|
||||
def test_event_log(self):
|
||||
self.sim.schedule_at(5.0, "TEST", {"foo": "bar"})
|
||||
self.sim.step()
|
||||
|
||||
self.assertEqual(len(self.sim.event_log), 1)
|
||||
self.assertEqual(self.sim.event_log[0]["type"], "TEST")
|
||||
self.assertEqual(self.sim.event_log[0]["t"], 5.0)
|
||||
|
||||
def test_add_player(self):
|
||||
player = Player(id="p1", name="Red", color="red")
|
||||
self.sim.add_player(player)
|
||||
|
||||
self.assertEqual(len(self.sim.players), 1)
|
||||
self.assertIn("p1", self.sim.players)
|
||||
|
||||
def test_get_player(self):
|
||||
player = Player(id="p1", name="Red", color="red")
|
||||
self.sim.add_player(player)
|
||||
|
||||
found = self.sim.get_player("p1")
|
||||
self.assertEqual(found.name, "Red")
|
||||
|
||||
self.assertIsNone(self.sim.get_player("nonexistent"))
|
||||
|
||||
def test_get_living_players(self):
|
||||
p1 = Player(id="p1", name="Red", color="red")
|
||||
p2 = Player(id="p2", name="Blue", color="blue", is_alive=False)
|
||||
p3 = Player(id="p3", name="Green", color="green")
|
||||
|
||||
self.sim.add_player(p1)
|
||||
self.sim.add_player(p2)
|
||||
self.sim.add_player(p3)
|
||||
|
||||
living = self.sim.get_living_players()
|
||||
self.assertEqual(len(living), 2)
|
||||
|
||||
def test_players_at(self):
|
||||
p1 = Player(id="p1", name="Red", color="red", position=Position(room_id="cafeteria"))
|
||||
p2 = Player(id="p2", name="Blue", color="blue", position=Position(room_id="cafeteria"))
|
||||
p3 = Player(id="p3", name="Green", color="green", position=Position(room_id="admin"))
|
||||
|
||||
self.sim.add_player(p1)
|
||||
self.sim.add_player(p2)
|
||||
self.sim.add_player(p3)
|
||||
|
||||
at_cafe = self.sim.players_at("cafeteria")
|
||||
self.assertEqual(len(at_cafe), 2)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,192 @@
|
||||
"""
|
||||
Tests for the trigger system.
|
||||
"""
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
import os
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
from src.engine.triggers import (
|
||||
TriggerRegistry, TriggerType, TriggerCondition, Trigger,
|
||||
MANDATORY_TRIGGERS, STANDARD_TRIGGERS
|
||||
)
|
||||
|
||||
|
||||
class TestTriggerType(unittest.TestCase):
|
||||
"""Tests for TriggerType enum."""
|
||||
|
||||
def test_mandatory_triggers_defined(self):
|
||||
self.assertIn(TriggerType.DISCUSSION_START, MANDATORY_TRIGGERS)
|
||||
self.assertIn(TriggerType.VOTE_START, MANDATORY_TRIGGERS)
|
||||
self.assertIn(TriggerType.GAME_START, MANDATORY_TRIGGERS)
|
||||
|
||||
def test_standard_triggers_defined(self):
|
||||
self.assertIn(TriggerType.BODY_IN_FOV, STANDARD_TRIGGERS)
|
||||
self.assertIn(TriggerType.PLAYER_ENTERS_FOV, STANDARD_TRIGGERS)
|
||||
|
||||
|
||||
class TestTriggerRegistry(unittest.TestCase):
|
||||
"""Tests for TriggerRegistry class."""
|
||||
|
||||
def setUp(self):
|
||||
self.registry = TriggerRegistry()
|
||||
self.registry.register_agent("agent1")
|
||||
self.registry.register_agent("agent2")
|
||||
|
||||
def test_register_agent(self):
|
||||
# Agents should have standard triggers subscribed
|
||||
self.assertIn(TriggerType.BODY_IN_FOV, self.registry._subscriptions["agent1"])
|
||||
self.assertIn(TriggerType.PLAYER_ENTERS_FOV, self.registry._subscriptions["agent1"])
|
||||
|
||||
def test_subscribe(self):
|
||||
self.registry.subscribe("agent1", TriggerType.INTERSECTION)
|
||||
self.assertIn(TriggerType.INTERSECTION, self.registry._subscriptions["agent1"])
|
||||
|
||||
def test_unsubscribe(self):
|
||||
self.registry.unsubscribe("agent1", TriggerType.BODY_IN_FOV)
|
||||
self.assertNotIn(TriggerType.BODY_IN_FOV, self.registry._subscriptions["agent1"])
|
||||
|
||||
def test_cannot_unsubscribe_mandatory(self):
|
||||
self.registry.unsubscribe("agent1", TriggerType.DISCUSSION_START)
|
||||
# Should still fire because mandatory
|
||||
self.assertTrue(
|
||||
self.registry.should_fire("agent1", TriggerType.DISCUSSION_START, 0.0)
|
||||
)
|
||||
|
||||
def test_should_fire_standard(self):
|
||||
# Standard triggers should fire by default
|
||||
self.assertTrue(
|
||||
self.registry.should_fire("agent1", TriggerType.BODY_IN_FOV, 0.0)
|
||||
)
|
||||
|
||||
def test_should_fire_optional_not_subscribed(self):
|
||||
# Optional triggers don't fire unless subscribed
|
||||
self.assertFalse(
|
||||
self.registry.should_fire("agent1", TriggerType.INTERSECTION, 0.0)
|
||||
)
|
||||
|
||||
def test_should_fire_mandatory_always(self):
|
||||
# Mandatory triggers always fire
|
||||
self.assertTrue(
|
||||
self.registry.should_fire("agent1", TriggerType.GAME_START, 0.0)
|
||||
)
|
||||
|
||||
def test_mute_trigger(self):
|
||||
condition = TriggerCondition(
|
||||
trigger_type=TriggerType.PLAYER_ENTERS_FOV,
|
||||
until_time=10.0
|
||||
)
|
||||
self.registry.mute("agent1", condition)
|
||||
|
||||
# Should be muted before time expires
|
||||
self.assertTrue(
|
||||
self.registry.is_muted("agent1", TriggerType.PLAYER_ENTERS_FOV, 5.0)
|
||||
)
|
||||
|
||||
# Should not fire while muted
|
||||
self.assertFalse(
|
||||
self.registry.should_fire("agent1", TriggerType.PLAYER_ENTERS_FOV, 5.0)
|
||||
)
|
||||
|
||||
def test_mute_expires(self):
|
||||
condition = TriggerCondition(
|
||||
trigger_type=TriggerType.PLAYER_ENTERS_FOV,
|
||||
until_time=10.0
|
||||
)
|
||||
self.registry.mute("agent1", condition)
|
||||
|
||||
# Should not be muted after time expires
|
||||
self.assertFalse(
|
||||
self.registry.is_muted("agent1", TriggerType.PLAYER_ENTERS_FOV, 15.0)
|
||||
)
|
||||
|
||||
def test_cannot_mute_mandatory(self):
|
||||
condition = TriggerCondition(
|
||||
trigger_type=TriggerType.DISCUSSION_START,
|
||||
until_time=100.0
|
||||
)
|
||||
self.registry.mute("agent1", condition)
|
||||
|
||||
# Mandatory should still fire
|
||||
self.assertTrue(
|
||||
self.registry.should_fire("agent1", TriggerType.DISCUSSION_START, 50.0)
|
||||
)
|
||||
|
||||
def test_target_specific_mute(self):
|
||||
condition = TriggerCondition(
|
||||
trigger_type=TriggerType.PLAYER_ENTERS_FOV,
|
||||
until_time=10.0,
|
||||
target_id="player_blue"
|
||||
)
|
||||
self.registry.mute("agent1", condition)
|
||||
|
||||
# Should be muted for specific target
|
||||
self.assertTrue(
|
||||
self.registry.is_muted("agent1", TriggerType.PLAYER_ENTERS_FOV, 5.0, "player_blue")
|
||||
)
|
||||
|
||||
# Should NOT be muted for different target
|
||||
self.assertFalse(
|
||||
self.registry.is_muted("agent1", TriggerType.PLAYER_ENTERS_FOV, 5.0, "player_red")
|
||||
)
|
||||
|
||||
def test_clear_expired_mutes(self):
|
||||
cond1 = TriggerCondition(trigger_type=TriggerType.PLAYER_ENTERS_FOV, until_time=5.0)
|
||||
cond2 = TriggerCondition(trigger_type=TriggerType.PLAYER_EXITS_FOV, until_time=15.0)
|
||||
|
||||
self.registry.mute("agent1", cond1)
|
||||
self.registry.mute("agent1", cond2)
|
||||
|
||||
self.assertEqual(len(self.registry._mutes["agent1"]), 2)
|
||||
|
||||
self.registry.clear_expired_mutes("agent1", 10.0)
|
||||
|
||||
self.assertEqual(len(self.registry._mutes["agent1"]), 1)
|
||||
|
||||
def test_get_agents_for_trigger(self):
|
||||
# Add a third agent
|
||||
self.registry.register_agent("agent3")
|
||||
|
||||
# Mute agent2
|
||||
self.registry.mute("agent2", TriggerCondition(
|
||||
trigger_type=TriggerType.BODY_IN_FOV,
|
||||
until_time=10.0
|
||||
))
|
||||
|
||||
agents = self.registry.get_agents_for_trigger(TriggerType.BODY_IN_FOV, 5.0)
|
||||
|
||||
self.assertIn("agent1", agents)
|
||||
self.assertNotIn("agent2", agents) # muted
|
||||
self.assertIn("agent3", agents)
|
||||
|
||||
def test_get_agents_with_exclude(self):
|
||||
agents = self.registry.get_agents_for_trigger(
|
||||
TriggerType.BODY_IN_FOV,
|
||||
0.0,
|
||||
exclude={"agent1"}
|
||||
)
|
||||
|
||||
self.assertNotIn("agent1", agents)
|
||||
self.assertIn("agent2", agents)
|
||||
|
||||
|
||||
class TestTrigger(unittest.TestCase):
|
||||
"""Tests for Trigger dataclass."""
|
||||
|
||||
def test_trigger_creation(self):
|
||||
trigger = Trigger(
|
||||
trigger_type=TriggerType.BODY_IN_FOV,
|
||||
target_agent_id="agent1",
|
||||
time=10.5,
|
||||
data={"victim": "Blue"}
|
||||
)
|
||||
|
||||
self.assertEqual(trigger.trigger_type, TriggerType.BODY_IN_FOV)
|
||||
self.assertEqual(trigger.target_agent_id, "agent1")
|
||||
self.assertEqual(trigger.time, 10.5)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user