synth-ai 0.2.14__py3-none-any.whl → 0.4.1__py3-none-any.whl

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

@@ -1,311 +0,0 @@
-#!/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

@@ -1,259 +0,0 @@
-#!/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"])