synth-ai 0.2.13.dev1__py3-none-any.whl → 0.2.13.dev2__py3-none-any.whl

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/tests/test_server_map_validation.py

@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""
+Pytest tests for server-based map validation
+Tests different game states and saves reference outputs for regression testing
+"""
+
+import pytest
+import requests
+import time
+import subprocess
+import os
+import json
+from pathlib import Path
+from tests.test_memory_map import format_map_data
+
+
+class ServerMapTester:
+    """Helper class for testing server-based map reading"""
+    
+    def __init__(self, port=8010):
+        self.port = port
+        self.server_url = f"http://127.0.0.1:{port}"
+        self.server_process = None
+        
+    def start_server(self, state_file):
+        """Start server with a specific state file"""
+        self.stop_server()  # Ensure clean state
+        
+        server_cmd = [
+            "python", "-m", "server.app",
+            "--load-state", state_file,
+            "--port", str(self.port),
+            "--manual"
+        ]
+        
+        self.server_process = subprocess.Popen(
+            server_cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        # Wait for server to start
+        for i in range(30):
+            try:
+                response = requests.get(f"{self.server_url}/status", timeout=2)
+                if response.status_code == 200:
+                    return True
+            except requests.exceptions.RequestException:
+                time.sleep(1)
+        
+        self.stop_server()
+        return False
+    
+    def stop_server(self):
+        """Stop the server process"""
+        if self.server_process:
+            self.server_process.terminate()
+            try:
+                self.server_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.server_process.kill()
+                self.server_process.wait()
+            self.server_process = None
+    
+    def get_map_data(self):
+        """Get current map data from server"""
+        try:
+            response = requests.get(f"{self.server_url}/state", timeout=10)
+            if response.status_code == 200:
+                state = response.json()
+                return {
+                    'location': state['player']['location'],
+                    'position': state['player']['position'],
+                    'tiles': state['map']['tiles']
+                }
+        except Exception as e:
+            pytest.fail(f"Failed to get map data: {e}")
+        return None
+    
+    def execute_actions(self, actions):
+        """Execute a sequence of actions"""
+        for action in actions:
+            try:
+                response = requests.post(f"{self.server_url}/action", json=action, timeout=5)
+                if response.status_code != 200:
+                    pytest.fail(f"Action failed: {action}, status: {response.status_code}")
+                time.sleep(0.3)  # Allow action to process
+            except Exception as e:
+                pytest.fail(f"Failed to execute action {action}: {e}")
+
+
+@pytest.fixture
+def server_tester():
+    """Pytest fixture providing a server tester instance"""
+    tester = ServerMapTester()
+    yield tester
+    tester.stop_server()
+
+
+def save_reference_map(location_name, map_data, reference_dir):
+    """Save map data as reference for future comparisons"""
+    reference_dir = Path(reference_dir)
+    reference_dir.mkdir(exist_ok=True)
+    
+    # Clean filename
+    filename = location_name.replace(' ', '_').replace("'", '').lower()
+    filename = f"{filename}_reference.json"
+    
+    reference_file = reference_dir / filename
+    
+    reference_data = {
+        'location': map_data['location'],
+        'position': map_data['position'],
+        'tiles': map_data['tiles'],
+        'formatted_map': format_map_data(map_data['tiles'], map_data['location'])
+    }
+    
+    with open(reference_file, 'w') as f:
+        json.dump(reference_data, f, indent=2)
+    
+    return reference_file
+
+
+def compare_with_reference(current_map, reference_file):
+    """Compare current map with saved reference"""
+    if not reference_file.exists():
+        return False, f"Reference file {reference_file} does not exist"
+    
+    with open(reference_file, 'r') as f:
+        reference = json.load(f)
+    
+    # Compare location
+    if current_map['location'] != reference['location']:
+        return False, f"Location mismatch: {current_map['location']} != {reference['location']}"
+    
+    # Compare map dimensions
+    current_tiles = current_map['tiles']
+    reference_tiles = reference['tiles']
+    
+    if len(current_tiles) != len(reference_tiles):
+        return False, f"Height mismatch: {len(current_tiles)} != {len(reference_tiles)}"
+    
+    if len(current_tiles[0]) != len(reference_tiles[0]):
+        return False, f"Width mismatch: {len(current_tiles[0])} != {len(reference_tiles[0])}"
+    
+    # Compare tile data (allow some tolerance for minor differences)
+    differences = 0
+    total_tiles = len(current_tiles) * len(current_tiles[0])
+    
+    for y, (current_row, reference_row) in enumerate(zip(current_tiles, reference_tiles)):
+        for x, (current_tile, reference_tile) in enumerate(zip(current_row, reference_row)):
+            if current_tile != reference_tile:
+                differences += 1
+    
+    difference_ratio = differences / total_tiles if total_tiles > 0 else 0
+    
+    # Allow up to 5% differences for minor variations
+    if difference_ratio > 0.05:
+        return False, f"Too many tile differences: {differences}/{total_tiles} ({difference_ratio:.1%})"
+    
+    return True, f"Maps match (differences: {differences}/{total_tiles}, {difference_ratio:.1%})"
+
+
+class TestServerMapValidation:
+    """Test server-based map reading for different scenarios"""
+    
+    def test_house_state_map(self, server_tester):
+        """Test map reading from house state"""
+        assert server_tester.start_server("tests/states/house.state"), "Failed to start server"
+        
+        map_data = server_tester.get_map_data()
+        assert map_data is not None, "Failed to get map data"
+        
+        # Validate basic properties
+        assert "BRENDAN" in map_data['location'].upper(), f"Unexpected location: {map_data['location']}"
+        assert "HOUSE" in map_data['location'].upper(), f"Not in house: {map_data['location']}"
+        assert len(map_data['tiles']) > 0, "Empty map tiles"
+        
+        # Save as reference
+        reference_file = save_reference_map(map_data['location'], map_data, "tests/map_references")
+        assert reference_file.exists(), "Failed to save reference file"
+        
+        print(f"✅ House state map validated and saved to {reference_file}")
+    
+    def test_upstairs_state_map(self, server_tester):
+        """Test map reading from upstairs state"""
+        assert server_tester.start_server("tests/states/upstairs.state"), "Failed to start server"
+        
+        map_data = server_tester.get_map_data()
+        assert map_data is not None, "Failed to get map data"
+        
+        # Validate upstairs properties
+        assert "2F" in map_data['location'] or "UPSTAIRS" in map_data['location'].upper(), f"Not upstairs: {map_data['location']}"
+        
+        tiles = map_data['tiles']
+        assert len(tiles) >= 10, "Map too small"
+        assert len(tiles[0]) >= 10, "Map too narrow"
+        
+        # Check for reasonable tile diversity (indoor areas should have various behavior types)
+        total_tiles = sum(len(row) for row in tiles)
+        behavior_counts = {}
+        for row in tiles:
+            for tile in row:
+                if len(tile) >= 2:
+                    behavior = tile[1]
+                    behavior_counts[behavior] = behavior_counts.get(behavior, 0) + 1
+        
+        # Should have at least 3 different behavior types for a proper indoor area
+        unique_behaviors = len(behavior_counts)
+        assert unique_behaviors >= 3, f"Too few behavior types: {unique_behaviors} (behaviors: {list(behavior_counts.keys())})"
+        
+        # Should not be dominated by a single behavior type (>90%)
+        max_behavior_count = max(behavior_counts.values()) if behavior_counts else 0
+        dominance_ratio = max_behavior_count / total_tiles if total_tiles > 0 else 0
+        assert dominance_ratio < 0.9, f"Single behavior dominates: {dominance_ratio:.1%}"
+        
+        # Save as reference
+        reference_file = save_reference_map(map_data['location'], map_data, "tests/map_references")
+        assert reference_file.exists(), "Failed to save reference file"
+        
+        print(f"✅ Upstairs state map validated and saved to {reference_file}")
+    
+    def test_house_to_outside_transition(self, server_tester):
+        """Test area transition from house to outside"""
+        assert server_tester.start_server("tests/states/house.state"), "Failed to start server"
+        
+        # Get initial house map
+        house_map = server_tester.get_map_data()
+        assert "HOUSE" in house_map['location'].upper(), f"Not in house: {house_map['location']}"
+        
+        # Move outside
+        actions = [{"buttons": ["down"]} for _ in range(3)]
+        server_tester.execute_actions(actions)
+        
+        # Get outside map
+        outside_map = server_tester.get_map_data()
+        assert outside_map is not None, "Failed to get outside map"
+        assert "TOWN" in outside_map['location'].upper(), f"Not in town: {outside_map['location']}"
+        
+        # Validate outside map quality
+        tiles = outside_map['tiles']
+        total_tiles = sum(len(row) for row in tiles)
+        unknown_tiles = sum(1 for row in tiles for tile in row if len(tile) >= 2 and tile[1] == 0)  # UNKNOWN = 0
+        
+        unknown_ratio = unknown_tiles / total_tiles if total_tiles > 0 else 0
+        
+        # Log the unknown ratio for debugging
+        print(f"Outside map unknown ratio: {unknown_ratio:.1%}")
+        
+        # If too many unknown tiles, this indicates the area transition bug
+        if unknown_ratio > 0.3:
+            print(f"⚠️  DETECTED AREA TRANSITION ISSUE: {unknown_ratio:.1%} unknown tiles")
+            print("This test demonstrates that the area transition bug still occurs sometimes")
+            # For now, save this as a reference anyway to track the issue
+        else:
+            print(f"✅ Area transition successful: {unknown_ratio:.1%} unknown tiles")
+        
+        # Save as reference
+        reference_file = save_reference_map(outside_map['location'], outside_map, "tests/map_references")
+        assert reference_file.exists(), "Failed to save reference file"
+        
+        print(f"✅ House-to-outside transition validated and saved to {reference_file}")
+    
+    def test_regression_against_references(self, server_tester):
+        """Test current maps against saved references"""
+        reference_dir = Path("tests/map_references")
+        if not reference_dir.exists():
+            pytest.skip("No reference files exist yet - run other tests first")
+        
+        reference_files = list(reference_dir.glob("*_reference.json"))
+        if not reference_files:
+            pytest.skip("No reference files found")
+        
+        # Test each reference
+        for reference_file in reference_files:
+            with open(reference_file, 'r') as f:
+                reference = json.load(f)
+            
+            location = reference['location']
+            
+            # Determine which state file to use based on location
+            if "BRENDAN" in location.upper() and "HOUSE" in location.upper() and "2F" not in location:
+                state_file = "tests/states/house.state"
+            elif "2F" in location or "UPSTAIRS" in location.upper():
+                state_file = "tests/states/upstairs.state"
+            else:
+                # For outdoor locations, start from house and transition
+                state_file = "tests/states/house.state"
+            
+            assert server_tester.start_server(state_file), f"Failed to start server for {location}"
+            
+            # If outdoor location, perform transition
+            if "TOWN" in location.upper():
+                actions = [{"buttons": ["down"]} for _ in range(3)]
+                server_tester.execute_actions(actions)
+            
+            current_map = server_tester.get_map_data()
+            assert current_map is not None, f"Failed to get map for {location}"
+            
+            # Compare with reference
+            matches, message = compare_with_reference(current_map, reference_file)
+            assert matches, f"Map regression for {location}: {message}"
+            
+            print(f"✅ Regression test passed for {location}: {message}")
+
+
+if __name__ == "__main__":
+    # Run tests manually for development
+    import sys
+    sys.exit(pytest.main([__file__, "-v", "-s"]))

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/tests/test_torchic_state.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""
+Test for torchic state and milestone reading
+
+This test verifies that:
+1. The torchic state loads correctly
+2. The state contains the expected data (player in Littleroot Town, has Torchic)
+3. The milestones are correctly detected and include Littleroot Town
+"""
+
+import pytest
+import subprocess
+import time
+import requests
+import json
+import os
+
+class ServerManager:
+    """Manages server startup and shutdown for tests"""
+    
+    def __init__(self):
+        self.server_process = None
+    
+    def start_server(self, state_file):
+        """Start the server with a specific state file"""
+        print(f"🚀 Starting server with state: {state_file}")
+        cmd = ["python", "-m", "server.app", "--manual", "--load-state", state_file]
+        
+        try:
+            self.server_process = subprocess.Popen(
+                cmd, 
+                stdout=subprocess.PIPE, 
+                stderr=subprocess.PIPE
+            )
+            
+            # Wait for server to start
+            print("⏳ Waiting for server to start...")
+            time.sleep(5)
+            
+            # Test if server is responding
+            response = requests.get("http://localhost:8000/status", timeout=5)
+            if response.status_code == 200:
+                print("✅ Server started successfully")
+                return True
+            else:
+                print(f"❌ Server not responding: {response.status_code}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Failed to start server: {e}")
+            return False
+    
+    def stop_server(self):
+        """Stop the server cleanly"""
+        if self.server_process:
+            print("🛑 Stopping server...")
+            try:
+                # Try graceful shutdown first
+                requests.post("http://localhost:8000/stop", timeout=2)
+                time.sleep(1)
+            except:
+                pass
+            
+            # Force terminate if still running
+            try:
+                self.server_process.terminate()
+                self.server_process.wait(timeout=5)
+                print("✅ Server stopped gracefully")
+            except subprocess.TimeoutExpired:
+                print("⚠️  Server didn't stop gracefully, force killing...")
+                self.server_process.kill()
+                self.server_process.wait()
+                print("✅ Server force killed")
+
+@pytest.fixture(scope="session", autouse=True)
+def check_environment():
+    """Check that required files exist"""
+    torchic_state = "tests/states/torchic.state"
+    if not os.path.exists(torchic_state):
+        pytest.skip(f"Torchic state file not found: {torchic_state}")
+    
+    print(f"✅ Found torchic state file: {torchic_state}")
+
+def test_torchic_state_loading():
+    """Test that the torchic state loads correctly"""
+    server_manager = ServerManager()
+    
+    try:
+        # Start server with torchic state
+        assert server_manager.start_server("tests/states/torchic.state"), "Failed to start server"
+        
+        # Get comprehensive state
+        response = requests.get("http://localhost:8000/state", timeout=10)
+        assert response.status_code == 200, f"Failed to get state: {response.status_code}"
+        
+        state_data = response.json()
+        
+        # Test basic state structure
+        assert "player" in state_data, "State missing player data"
+        assert "game" in state_data, "State missing game data"
+        assert "visual" in state_data, "State missing visual data"
+        
+        # Test player data
+        player = state_data["player"]
+        assert "name" in player, "Player data missing name"
+        assert "location" in player, "Player data missing location"
+        assert "position" in player, "Player data missing position"
+        assert "party" in player, "Player data missing party"
+        
+        # Test that player is in Route 101 (where the torchic state is)
+        location = player["location"]
+        print(f"📍 Player location: {location}")
+        assert "ROUTE 101" in location.upper(), f"Expected player to be in Route 101, but found: {location}"
+        
+        # Test party data
+        party = player["party"]
+        assert isinstance(party, list), "Party should be a list"
+        assert len(party) > 0, "Party should not be empty"
+        
+        # Test that first Pokemon is Torchic
+        first_pokemon = party[0]
+        assert "species_name" in first_pokemon, "Pokemon missing species_name"
+        species_name = first_pokemon["species_name"]
+        print(f"🔥 First Pokemon: {species_name}")
+        assert species_name.upper() == "TORCHIC", f"Expected Torchic, but found: {species_name}"
+        
+        # Test Pokemon data structure
+        assert "level" in first_pokemon, "Pokemon missing level"
+        assert "current_hp" in first_pokemon, "Pokemon missing current_hp"
+        assert "max_hp" in first_pokemon, "Pokemon missing max_hp"
+        assert "moves" in first_pokemon, "Pokemon missing moves"
+        
+        print(f"✅ Torchic level: {first_pokemon['level']}")
+        print(f"✅ Torchic HP: {first_pokemon['current_hp']}/{first_pokemon['max_hp']}")
+        print(f"✅ Torchic moves: {first_pokemon['moves']}")
+        
+    finally:
+        server_manager.stop_server()
+
+def test_torchic_milestones():
+    """Test that milestones are correctly detected for torchic state"""
+    server_manager = ServerManager()
+    
+    try:
+        # Start server with torchic state
+        assert server_manager.start_server("tests/states/torchic.state"), "Failed to start server"
+        
+        # Get milestones
+        response = requests.get("http://localhost:8000/milestones", timeout=10)
+        assert response.status_code == 200, f"Failed to get milestones: {response.status_code}"
+        
+        milestones_data = response.json()
+        
+        # Test milestones structure
+        assert "milestones" in milestones_data, "Milestones data missing milestones list"
+        assert "completed" in milestones_data, "Milestones data missing completed count"
+        assert "total" in milestones_data, "Milestones data missing total count"
+        assert "progress" in milestones_data, "Milestones data missing progress"
+        assert "current_location" in milestones_data, "Milestones data missing current_location"
+        
+        milestones = milestones_data["milestones"]
+        completed = milestones_data["completed"]
+        total = milestones_data["total"]
+        progress = milestones_data["progress"]
+        current_location = milestones_data["current_location"]
+        
+        print(f"📊 Milestones progress: {completed}/{total} ({progress:.1%})")
+        print(f"📍 Current location: {current_location}")
+        
+        # Test that Littleroot Town milestone exists (but may not be completed since we're in Route 101)
+        littleroot_milestone = None
+        for milestone in milestones:
+            if "LITTLEROOT" in milestone["name"].upper():
+                littleroot_milestone = milestone
+                break
+        
+        assert littleroot_milestone is not None, "Littleroot Town milestone not found"
+        print(f"🏘️  Littleroot milestone: {littleroot_milestone}")
+        
+        # Test that current location is Route 101
+        assert "ROUTE 101" in current_location.upper(), f"Current location should be Route 101, but found: {current_location}"
+        
+        # Test that basic milestones are completed
+        basic_milestones = ["GAME_RUNNING", "HAS_PARTY", "STARTER_CHOSEN", "TORCHIC_OBTAINED", "ROUTE_101_VISITED"]
+        for milestone_name in basic_milestones:
+            milestone = next((m for m in milestones if m["name"] == milestone_name), None)
+            assert milestone is not None, f"Basic milestone {milestone_name} not found"
+            assert milestone["completed"] == True, f"Basic milestone {milestone_name} should be completed"
+            print(f"✅ {milestone_name}: Completed")
+        
+        # Test that some milestones are not yet completed (game just started)
+        incomplete_milestones = ["STONE_BADGE", "POKEDEX_RECEIVED", "FIRST_WILD_ENCOUNTER", "LITTLEROOT_TOWN"]
+        for milestone_name in incomplete_milestones:
+            milestone = next((m for m in milestones if m["name"] == milestone_name), None)
+            assert milestone is not None, f"Milestone {milestone_name} not found"
+            assert milestone["completed"] == False, f"Milestone {milestone_name} should not be completed yet"
+            print(f"⏳ {milestone_name}: Not completed yet")
+        
+    finally:
+        server_manager.stop_server()
+
+def test_torchic_state_summary():
+    """Test that the torchic state provides a comprehensive summary"""
+    server_manager = ServerManager()
+    
+    try:
+        # Start server with torchic state
+        assert server_manager.start_server("tests/states/torchic.state"), "Failed to start server"
+        
+        # Get comprehensive state
+        response = requests.get("http://localhost:8000/state", timeout=10)
+        assert response.status_code == 200, f"Failed to get state: {response.status_code}"
+        
+        state_data = response.json()
+        
+        # Test game state
+        game = state_data["game"]
+        assert "money" in game, "Game data missing money"
+        assert "game_state" in game, "Game data missing game_state"
+        assert "is_in_battle" in game, "Game data missing is_in_battle"
+        assert "badges" in game, "Game data missing badges"
+        assert "dialog_text" in game, "Game data missing dialog_text"
+        
+        # Test that player has some money (starter money)
+        money = game["money"]
+        print(f"💰 Player money: {money}")
+        assert money >= 0, "Player should have non-negative money"
+        
+        # Test that player is not in battle
+        is_in_battle = game["is_in_battle"]
+        print(f"⚔️  In battle: {is_in_battle}")
+        assert is_in_battle == False, "Player should not be in battle at start"
+        
+        # Test that player has no badges yet
+        badges = game["badges"]
+        print(f"🏆 Badges: {badges}")
+        assert len(badges) == 0, "Player should have no badges at start"
+        
+        # Test visual data
+        visual = state_data["visual"]
+        assert "screenshot_base64" in visual, "Visual data missing screenshot"
+        assert "resolution" in visual, "Visual data missing resolution"
+        
+        resolution = visual["resolution"]
+        print(f"📺 Resolution: {resolution}")
+        assert resolution == [240, 160], f"Expected resolution [240, 160], got {resolution}"
+        
+        # Test that screenshot is present
+        screenshot = visual["screenshot_base64"]
+        assert len(screenshot) > 0, "Screenshot should not be empty"
+        print(f"📸 Screenshot size: {len(screenshot)} characters")
+        
+        print("✅ Torchic state test completed successfully")
+        
+    finally:
+        server_manager.stop_server()
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])