data/tests/test_database.py

"""
Tests for ProgramDatabase in openevolve.database
"""

import unittest
import uuid
from openevolve.config import Config
from openevolve.database import Program, ProgramDatabase


class TestProgramDatabase(unittest.TestCase):
    """Tests for program database"""

    def setUp(self):
        """Set up test database"""
        config = Config()
        config.database.in_memory = True
        self.db = ProgramDatabase(config.database)

    def test_add_and_get(self):
        """Test adding and retrieving a program"""
        program = Program(
            id="test1",
            code="def test(): pass",
            language="python",
            metrics={"score": 0.5},
        )

        self.db.add(program)

        retrieved = self.db.get("test1")
        self.assertIsNotNone(retrieved)
        self.assertEqual(retrieved.id, "test1")
        self.assertEqual(retrieved.code, "def test(): pass")
        self.assertEqual(retrieved.metrics["score"], 0.5)

    def test_get_best_program(self):
        """Test getting the best program"""
        program1 = Program(
            id="test1",
            code="def test1(): pass",
            language="python",
            metrics={"score": 0.5},
        )

        program2 = Program(
            id="test2",
            code="def test2(): pass",
            language="python",
            metrics={"score": 0.7},
        )

        self.db.add(program1)
        self.db.add(program2)

        best = self.db.get_best_program()
        self.assertIsNotNone(best)
        self.assertEqual(best.id, "test2")

    def test_sample(self):
        """Test sampling from the database"""
        program1 = Program(
            id="test1",
            code="def test1(): pass",
            language="python",
            metrics={"score": 0.5},
        )

        program2 = Program(
            id="test2",
            code="def test2(): pass",
            language="python",
            metrics={"score": 0.7},
        )

        self.db.add(program1)
        self.db.add(program2)

        parent, inspirations = self.db.sample()

        self.assertIsNotNone(parent)
        self.assertIn(parent.id, ["test1", "test2"])

    def test_island_operations_basic(self):
        """Test basic island operations"""
        # Test with default islands (should be 5 by default)
        self.assertEqual(len(self.db.islands), 5)

        program = Program(
            id="island_test",
            code="def island_test(): pass",
            language="python",
            metrics={"score": 0.6},
        )

        self.db.add(program)

        # Should be in island 0
        self.assertIn("island_test", self.db.islands[0])
        self.assertEqual(program.metadata.get("island"), 0)

    def test_multi_island_setup(self):
        """Test database with multiple islands"""
        # Create new database with multiple islands
        config = Config()
        config.database.in_memory = True
        config.database.num_islands = 3
        multi_db = ProgramDatabase(config.database)

        self.assertEqual(len(multi_db.islands), 3)
        self.assertEqual(len(multi_db.island_best_programs), 3)

        # Add programs to specific islands
        for i in range(3):
            program = Program(
                id=f"test_island_{i}",
                code=f"def test_{i}(): pass",
                language="python",
                metrics={"score": 0.5 + i * 0.1},
            )
            multi_db.add(program, target_island=i)

            # Verify assignment
            self.assertIn(f"test_island_{i}", multi_db.islands[i])
            self.assertEqual(program.metadata.get("island"), i)

    def test_feature_coordinates_calculation(self):
        """Test MAP-Elites feature coordinate calculation"""
        program = Program(
            id="feature_test",
            code="def test(): pass",  # Short code
            language="python",
            metrics={"score": 0.8},
        )

        coords = self.db._calculate_feature_coords(program)

        # Should return list of coordinates
        self.assertIsInstance(coords, list)
        self.assertEqual(len(coords), len(self.db.config.feature_dimensions))

        # All coordinates should be within valid range
        for coord in coords:
            self.assertGreaterEqual(coord, 0)
            self.assertLess(coord, self.db.feature_bins)

    def test_feature_map_operations(self):
        """Test per-island feature map operations for MAP-Elites"""
        # Add some initial programs to establish diversity reference set
        for i in range(3):
            init_program = Program(
                id=f"init_{i}",
                code=f"def init_{i}(): return {i}",
                language="python",
                metrics={"score": 0.3},
            )
            self.db.add(init_program)

        program1 = Program(
            id="map_test1",
            code="def short(): pass",  # Similar complexity
            language="python",
            metrics={"score": 0.5},
        )

        program2 = Program(
            id="map_test2",
            code="def also_short(): pass",  # Similar complexity
            language="python",
            metrics={"score": 0.8},  # Better score
        )

        self.db.add(program1)
        self.db.add(program2)

        # Both programs should be in the database
        self.assertIn("map_test1", self.db.programs)
        self.assertIn("map_test2", self.db.programs)

        # Check that programs are represented in island feature maps
        all_feature_map_values = []
        for island_map in self.db.island_feature_maps:
            all_feature_map_values.extend(island_map.values())

        # At least one of our test programs should be in some island's feature map
        test_programs_in_map = [v for v in all_feature_map_values if v in ["map_test1", "map_test2"]]
        self.assertGreater(
            len(test_programs_in_map), 0, "At least one test program should be in island feature maps"
        )

        # If both are in the same island's map with the same feature coordinates, 
        # verify the better program is kept
        for island_map in self.db.island_feature_maps:
            if "map_test1" in island_map.values() and "map_test2" in island_map.values():
                # Find their keys in this island
                key1 = key2 = None
                for k, v in island_map.items():
                    if v == "map_test1":
                        key1 = k
                    elif v == "map_test2":
                        key2 = k
                
                # If they have the same key, the better program should be kept
                if key1 == key2:
                    self.assertEqual(island_map[key1], "map_test2")

    def test_get_top_programs_with_metrics(self):
        """Test get_top_programs with specific metrics"""
        program1 = Program(
            id="metric_test1",
            code="def test1(): pass",
            language="python",
            metrics={"accuracy": 0.9, "speed": 0.3},
        )

        program2 = Program(
            id="metric_test2",
            code="def test2(): pass",
            language="python",
            metrics={"accuracy": 0.7, "speed": 0.8},
        )

        self.db.add(program1)
        self.db.add(program2)

        # Test sorting by specific metric
        top_by_accuracy = self.db.get_top_programs(n=2, metric="accuracy")
        self.assertEqual(top_by_accuracy[0].id, "metric_test1")  # Higher accuracy

        top_by_speed = self.db.get_top_programs(n=2, metric="speed")
        self.assertEqual(top_by_speed[0].id, "metric_test2")  # Higher speed

    def test_archive_operations(self):
        """Test archive functionality"""
        # Add programs that should go into archive
        for i in range(5):
            program = Program(
                id=f"archive_test_{i}",
                code=f"def test_{i}(): return {i}",
                language="python",
                metrics={"score": i * 0.1},
            )
            self.db.add(program)

        # Archive should contain program IDs
        self.assertGreater(len(self.db.archive), 0)
        self.assertLessEqual(len(self.db.archive), self.db.config.archive_size)

        # Archive should contain program IDs that exist
        for program_id in self.db.archive:
            self.assertIn(program_id, self.db.programs)

    def test_best_program_tracking(self):
        """Test absolute best program tracking"""
        program1 = Program(
            id="best_test1",
            code="def test1(): pass",
            language="python",
            metrics={"combined_score": 0.6},
        )

        program2 = Program(
            id="best_test2",
            code="def test2(): pass",
            language="python",
            metrics={"combined_score": 0.9},
        )

        self.db.add(program1)
        self.assertEqual(self.db.best_program_id, "best_test1")

        self.db.add(program2)
        self.assertEqual(self.db.best_program_id, "best_test2")  # Should update to better program

    def test_population_limit_enforcement(self):
        """Test population size limit enforcement"""
        # Set small population limit
        original_limit = self.db.config.population_size
        self.db.config.population_size = 3

        # Add more programs than limit
        for i in range(5):
            program = Program(
                id=f"limit_test_{i}",
                code=f"def test_{i}(): pass",
                language="python",
                metrics={"score": i * 0.1},
            )
            self.db.add(program)

        # Population should be at or below limit
        self.assertLessEqual(len(self.db.programs), 3)

        # Restore original limit
        self.db.config.population_size = original_limit

    def test_calculate_complexity_bin_adaptive(self):
        """Test adaptive complexity binning with multiple programs"""
        # Add programs with different complexities
        programs = [
            Program(id="short", code="x=1", metrics={"score": 0.5}),
            Program(
                id="medium", code="def func():\n    return x*2\n    pass", metrics={"score": 0.5}
            ),
            Program(
                id="long",
                code="def complex_function():\n    result = []\n    for i in range(100):\n        result.append(i*2)\n    return result",
                metrics={"score": 0.5},
            ),
        ]

        for program in programs:
            self.db.add(program)

        # Test binning for different complexity values
        short_bin = self.db._calculate_complexity_bin(len("x=1"))
        medium_bin = self.db._calculate_complexity_bin(len("def func():\n    return x*2\n    pass"))
        long_bin = self.db._calculate_complexity_bin(
            len(
                "def complex_function():\n    result = []\n    for i in range(100):\n        result.append(i*2)\n    return result"
            )
        )

        # Bins should be different and within valid range
        self.assertNotEqual(short_bin, long_bin)
        self.assertGreaterEqual(short_bin, 0)
        self.assertLess(short_bin, self.db.feature_bins)
        self.assertGreaterEqual(long_bin, 0)
        self.assertLess(long_bin, self.db.feature_bins)

    def test_calculate_complexity_bin_cold_start(self):
        """Test complexity binning during cold start (< 2 programs)"""
        # Empty database - should use fixed range
        bin_idx = self.db._calculate_complexity_bin(500)

        self.assertGreaterEqual(bin_idx, 0)
        self.assertLess(bin_idx, self.db.feature_bins)

        # Add one program - still cold start
        program = Program(id="single", code="x=1", metrics={"score": 0.5})
        self.db.add(program)

        bin_idx = self.db._calculate_complexity_bin(500)
        self.assertGreaterEqual(bin_idx, 0)
        self.assertLess(bin_idx, self.db.feature_bins)

    def test_calculate_diversity_bin_adaptive(self):
        """Test adaptive diversity binning with multiple programs"""
        # Add programs with different code structures for diversity testing
        programs = [
            Program(id="simple", code="x = 1", metrics={"score": 0.5}),
            Program(id="function", code="def add(a, b):\n    return a + b", metrics={"score": 0.5}),
            Program(
                id="loop",
                code="for i in range(10):\n    print(i)\n    x += i",
                metrics={"score": 0.5},
            ),
            Program(
                id="complex",
                code="class MyClass:\n    def __init__(self):\n        self.data = []\n    def process(self, items):\n        return [x*2 for x in items]",
                metrics={"score": 0.5},
            ),
        ]

        for program in programs:
            self.db.add(program)

        # Test binning for different diversity values
        # Use fast diversity to calculate test values
        simple_prog = programs[0]
        complex_prog = programs[3]

        # Calculate diversity for simple vs complex programs
        simple_diversity = self.db._fast_code_diversity(simple_prog.code, complex_prog.code)

        # Test the binning
        bin_idx = self.db._calculate_diversity_bin(simple_diversity)

        # Should be within valid range
        self.assertGreaterEqual(bin_idx, 0)
        self.assertLess(bin_idx, self.db.feature_bins)

    def test_calculate_diversity_bin_cold_start(self):
        """Test diversity binning during cold start (< 2 programs)"""
        # Empty database - should use fixed range
        bin_idx = self.db._calculate_diversity_bin(500.0)

        self.assertGreaterEqual(bin_idx, 0)
        self.assertLess(bin_idx, self.db.feature_bins)

        # Add one program - still cold start
        program = Program(id="single", code="x=1", metrics={"score": 0.5})
        self.db.add(program)

        bin_idx = self.db._calculate_diversity_bin(500.0)
        self.assertGreaterEqual(bin_idx, 0)
        self.assertLess(bin_idx, self.db.feature_bins)

    def test_calculate_diversity_bin_identical_programs(self):
        """Test diversity binning when all programs have identical diversity"""
        # Add multiple identical programs
        for i in range(3):
            program = Program(
                id=f"identical_{i}", code="x = 1", metrics={"score": 0.5}  # Same code
            )
            self.db.add(program)

        # Test binning - should handle zero range gracefully
        bin_idx = self.db._calculate_diversity_bin(0.0)

        self.assertGreaterEqual(bin_idx, 0)
        self.assertLess(bin_idx, self.db.feature_bins)

    def test_fast_code_diversity_function(self):
        """Test the _fast_code_diversity function"""
        # Test identical code
        code1 = "def test(): pass"
        code2 = "def test(): pass"
        diversity = self.db._fast_code_diversity(code1, code2)
        self.assertEqual(diversity, 0.0)

        # Test different code
        code1 = "x = 1"
        code2 = "def complex_function():\n    return [i*2 for i in range(100)]"
        diversity = self.db._fast_code_diversity(code1, code2)
        self.assertGreater(diversity, 0.0)

        # Test length difference
        short_code = "x = 1"
        long_code = "x = 1" + "a" * 100
        diversity = self.db._fast_code_diversity(short_code, long_code)
        self.assertGreater(diversity, 0.0)

    def test_diversity_feature_integration(self):
        """Test diversity feature calculation in feature coordinates"""
        # Add programs with different structures
        programs = [
            Program(id="prog1", code="x = 1", metrics={"score": 0.5}),
            Program(id="prog2", code="def func():\n    return 2", metrics={"score": 0.5}),
            Program(id="prog3", code="for i in range(5):\n    print(i)", metrics={"score": 0.5}),
        ]

        for program in programs:
            self.db.add(program)

        # Create a test program with diversity feature enabled
        test_config = self.db.config
        test_config.feature_dimensions = ["score", "complexity", "diversity"]

        test_program = Program(id="test", code="def test(): return 42", metrics={"score": 0.7})

        # Calculate feature coordinates - should include diversity dimension
        coords = self.db._calculate_feature_coords(test_program)

        # Should have 3 coordinates for score, complexity, and diversity
        self.assertEqual(len(coords), 3)

        # All coordinates should be within valid range
        for coord in coords:
            self.assertGreaterEqual(coord, 0)
            self.assertLess(coord, self.db.feature_bins)

    def test_migration_prevents_re_migration(self):
        """Test that programs marked as migrants don't migrate again"""
        # Create database with multiple islands
        config = Config()
        config.database.in_memory = True
        config.database.num_islands = 3
        config.database.migration_interval = 1  # Migrate every generation
        multi_db = ProgramDatabase(config.database)

        # Add programs to each island (avoid "migrant" in original IDs)
        for i in range(3):
            program = Program(
                id=f"test_prog_{i}",
                code=f"def test_{i}(): return {i}",
                language="python",
                metrics={"score": 0.5 + i * 0.1},
            )
            multi_db.add(program, target_island=i)

        # Manually mark one as a migrant
        migrant_program = multi_db.get("test_prog_0")
        migrant_program.metadata["migrant"] = True

        # Store original ID
        original_id = migrant_program.id

        # Count initial programs (no _migrant suffixes should exist)
        initial_programs = set(multi_db.programs.keys())
        initial_migrant_count = sum(1 for pid in initial_programs if "_migrant_" in pid)
        self.assertEqual(initial_migrant_count, 0)  # Should be none with new implementation

        # Run migration
        multi_db.island_generations[0] = config.database.migration_interval
        multi_db.island_generations[1] = config.database.migration_interval
        multi_db.island_generations[2] = config.database.migration_interval
        multi_db.migrate_programs()

        # Check that the migrant program wasn't re-migrated
        # It should still exist with the same ID
        still_exists = multi_db.get(original_id)
        self.assertIsNotNone(still_exists)

        # With new implementation, no programs should have _migrant_ suffixes
        new_programs = set(multi_db.programs.keys())
        new_migrant_ids = [pid for pid in new_programs if "_migrant_" in pid]
        self.assertEqual(len(new_migrant_ids), 0, "New implementation should not create _migrant suffix programs")
        
        # Verify that programs are still distributed across islands (migration occurred)
        total_programs_in_maps = sum(len(island_map) for island_map in multi_db.island_feature_maps)
        self.assertGreaterEqual(total_programs_in_maps, 3, "Programs should be distributed in island feature maps")

    def test_empty_island_initialization_creates_copies(self):
        """Test that empty islands are initialized with copies, not shared references"""
        # Create database with multiple islands
        config = Config()
        config.database.in_memory = True
        config.database.num_islands = 3
        # Force exploration mode to test empty island handling
        config.database.exploration_ratio = 1.0
        config.database.exploitation_ratio = 0.0
        multi_db = ProgramDatabase(config.database)

        # Add a single program to island 1
        program = Program(
            id="original_program",
            code="def original(): return 42",
            language="python",
            metrics={"score": 0.9, "combined_score": 0.9},
        )
        multi_db.add(program, target_island=1)

        # Make it the best program
        multi_db.best_program_id = "original_program"

        # Switch to empty island 0 and sample
        multi_db.set_current_island(0)
        sampled_parent, _ = multi_db.sample()

        # The sampled program should be a copy, not the original
        self.assertNotEqual(sampled_parent.id, "original_program")
        self.assertEqual(sampled_parent.code, program.code)  # Same code
        self.assertEqual(sampled_parent.parent_id, "original_program")  # Parent is the original

        # Check island membership
        self.assertIn("original_program", multi_db.islands[1])
        self.assertNotIn("original_program", multi_db.islands[0])
        self.assertIn(sampled_parent.id, multi_db.islands[0])

        # Run validation - should not raise any errors
        multi_db._validate_migration_results()

    def test_no_program_assigned_to_multiple_islands(self):
        """Test that programs are never assigned to multiple islands"""
        # Create database with multiple islands
        config = Config()
        config.database.in_memory = True
        config.database.num_islands = 4
        multi_db = ProgramDatabase(config.database)

        # Add programs to different islands
        program_ids = []
        for i in range(4):
            program = Program(
                id=f"island_test_{i}",
                code=f"def test_{i}(): return {i}",
                language="python",
                metrics={"score": 0.5 + i * 0.1, "combined_score": 0.5 + i * 0.1},
            )
            multi_db.add(program, target_island=i)
            program_ids.append(program.id)

        # Make the best program from island 3
        multi_db.best_program_id = "island_test_3"

        # Sample from empty islands - this should create copies
        for empty_island in range(4):
            if len(multi_db.islands[empty_island]) == 0:
                multi_db.set_current_island(empty_island)
                parent, _ = multi_db.sample()

        # Check that no program ID appears in multiple islands
        all_island_programs = {}
        for island_idx, island_programs in enumerate(multi_db.islands):
            for program_id in island_programs:
                if program_id in all_island_programs:
                    self.fail(
                        f"Program {program_id} found in both island {all_island_programs[program_id]} "
                        f"and island {island_idx}"
                    )
                all_island_programs[program_id] = island_idx

        # Run validation - should not raise any errors
        multi_db._validate_migration_results()

    def test_migration_validation_passes(self):
        """Test that migration validation passes after our fixes"""
        # Create database with multiple islands
        config = Config()
        config.database.in_memory = True
        config.database.num_islands = 3
        config.database.migration_interval = 1
        multi_db = ProgramDatabase(config.database)

        # Add programs and run several migration cycles
        for i in range(6):
            program = Program(
                id=f"test_program_{i}",
                code=f"def test_{i}(): return {i * 2}",
                language="python",
                metrics={"score": 0.4 + i * 0.1, "combined_score": 0.4 + i * 0.1},
            )
            multi_db.add(program, target_island=i % 3)

        # Run multiple migration cycles
        for cycle in range(3):
            # Increment generations to trigger migration
            for island in range(3):
                multi_db.island_generations[island] += 1

            # Migrate programs
            multi_db.migrate_programs()

            # Validation should pass without warnings
            multi_db._validate_migration_results()

            # Verify no program has exponential ID growth
            for program_id in multi_db.programs:
                # Count occurrences of "migrant" in ID
                migrant_count = program_id.count("migrant")
                self.assertLessEqual(
                    migrant_count, 1, f"Program ID {program_id} has been migrated multiple times"
                )


if __name__ == "__main__":
    unittest.main()