ShinkaEvolve/tests/test_prompt_evolution.py

"""
Tests for the meta-prompt evolution system.

Tests cover:
1. SystemPromptDatabase CRUD operations
2. SystemPrompt dataclass
3. Prompt fitness tracking and selection
4. Integration with Program tracking
"""

import pytest
import tempfile
from pathlib import Path

from shinka.database.prompt_dbase import (
    SystemPromptDatabase,
    SystemPromptConfig,
    SystemPrompt,
    create_system_prompt,
)
from shinka.database import Program
from shinka.core.prompt_evolver import SystemPromptSampler


class TestSystemPromptDataclass:
    """Test SystemPrompt dataclass functionality."""

    def test_create_system_prompt(self):
        """Test creating a new SystemPrompt."""
        prompt = create_system_prompt(
            prompt_text="You are an expert programmer.",
            generation=0,
            patch_type="init",
        )

        assert prompt.id is not None
        assert len(prompt.id) == 36  # UUID length
        assert prompt.prompt_text == "You are an expert programmer."
        assert prompt.generation == 0
        assert prompt.patch_type == "init"
        assert prompt.fitness == 0.0
        assert prompt.program_count == 0

    def test_prompt_to_dict(self):
        """Test serialization to dictionary."""
        prompt = create_system_prompt(
            prompt_text="Test prompt",
            generation=1,
            patch_type="diff",
            metadata={"test_key": "test_value"},
        )

        data = prompt.to_dict()
        assert data["prompt_text"] == "Test prompt"
        assert data["generation"] == 1
        assert data["patch_type"] == "diff"
        assert data["metadata"]["test_key"] == "test_value"

    def test_prompt_from_dict(self):
        """Test deserialization from dictionary."""
        data = {
            "id": "test-id-123",
            "prompt_text": "Test prompt",
            "generation": 2,
            "patch_type": "full",
            "fitness": 0.5,
            "program_count": 10,
            "metadata": {"key": "value"},
        }

        prompt = SystemPrompt.from_dict(data)
        assert prompt.id == "test-id-123"
        assert prompt.prompt_text == "Test prompt"
        assert prompt.generation == 2
        assert prompt.fitness == 0.5
        assert prompt.program_count == 10

    def test_update_fitness(self):
        """Test fitness update calculation using percentiles."""
        prompt = create_system_prompt(
            prompt_text="Test",
            generation=0,
            patch_type="init",
        )

        # Initial state
        assert prompt.fitness == 0.0
        assert prompt.program_count == 0

        # First percentile update (e.g., program beats 50% of others)
        prompt.update_fitness(percentile=0.5, program_score=0.75)
        assert prompt.program_count == 1
        assert prompt.correct_program_count == 1
        assert prompt.fitness == 0.5
        assert prompt.total_percentile == 0.5
        assert prompt.program_scores == [0.75]

        # Second percentile update (beats 80% of others)
        prompt.update_fitness(percentile=0.8, program_score=0.95)
        assert prompt.program_count == 2
        assert prompt.correct_program_count == 2
        assert prompt.fitness == 0.65  # (0.5 + 0.8) / 2
        assert prompt.total_percentile == 1.3
        assert prompt.program_scores == [0.75, 0.95]

        # Third percentile update (beats 30% of others)
        prompt.update_fitness(percentile=0.3, program_score=0.4)
        assert prompt.program_count == 3
        assert prompt.correct_program_count == 3
        assert abs(prompt.fitness - 0.5333) < 0.01  # (0.5 + 0.8 + 0.3) / 3
        assert prompt.program_scores == [0.75, 0.95, 0.4]

    def test_update_fitness_correct_only(self):
        """Test that only correct programs contribute to fitness."""
        prompt = create_system_prompt(
            prompt_text="Test",
            generation=0,
            patch_type="init",
        )

        # Add a correct program with 80% percentile
        prompt.update_fitness(percentile=0.8, correct=True, program_score=0.9)
        assert prompt.program_count == 1
        assert prompt.correct_program_count == 1
        assert prompt.fitness == 0.8
        assert prompt.program_scores == [0.9]

        # Add an incorrect program - should not affect fitness or scores
        prompt.update_fitness(percentile=0.0, correct=False, program_score=0.1)
        assert prompt.program_count == 2
        assert prompt.correct_program_count == 1  # Still 1
        assert prompt.fitness == 0.8  # Unchanged
        assert prompt.program_scores == [0.9]  # No new score added


class TestSystemPromptDatabase:
    """Test SystemPromptDatabase operations."""

    @pytest.fixture
    def temp_db(self):
        """Create a temporary database for testing."""
        with tempfile.TemporaryDirectory() as tmpdir:
            db_path = Path(tmpdir) / "test_prompts.db"
            config = SystemPromptConfig(
                db_path=str(db_path),
                archive_size=5,
            )
            db = SystemPromptDatabase(config)
            yield db
            db.close()

    @pytest.fixture
    def memory_db(self):
        """Create an in-memory database for testing."""
        config = SystemPromptConfig(
            db_path=None,  # In-memory
            archive_size=5,
        )
        db = SystemPromptDatabase(config)
        yield db
        db.close()

    def test_add_and_get_prompt(self, memory_db):
        """Test adding and retrieving a prompt."""
        prompt = create_system_prompt(
            prompt_text="Test prompt",
            generation=0,
            patch_type="init",
        )

        memory_db.add(prompt)
        retrieved = memory_db.get(prompt.id)

        assert retrieved is not None
        assert retrieved.id == prompt.id
        assert retrieved.prompt_text == "Test prompt"

    def test_get_nonexistent_prompt(self, memory_db):
        """Test getting a prompt that doesn't exist."""
        result = memory_db.get("nonexistent-id")
        assert result is None

    def test_get_all_prompts(self, memory_db):
        """Test getting all prompts."""
        prompts = []
        for i in range(3):
            prompt = create_system_prompt(
                prompt_text=f"Test prompt {i}",
                generation=i,
                patch_type="init",
            )
            memory_db.add(prompt)
            prompts.append(prompt)

        all_prompts = memory_db.get_all_prompts()
        assert len(all_prompts) == 3

    def test_archive_management(self, memory_db):
        """Test archive size management."""
        # Add prompts up to archive size
        for i in range(5):
            prompt = create_system_prompt(
                prompt_text=f"Prompt {i}",
                generation=i,
                patch_type="init",
            )
            memory_db.add(prompt)

        archive = memory_db.get_archive()
        assert len(archive) == 5

        # Add one more - should replace worst
        prompt = create_system_prompt(
            prompt_text="New prompt",
            generation=5,
            patch_type="init",
        )
        # Give it a higher fitness
        prompt.fitness = 10.0
        prompt.program_count = 5
        memory_db.add(prompt)

        archive = memory_db.get_archive()
        assert len(archive) <= 5

    def test_update_fitness(self, memory_db):
        """Test updating prompt fitness with percentiles."""
        prompt = create_system_prompt(
            prompt_text="Test",
            generation=0,
            patch_type="init",
        )
        memory_db.add(prompt)

        # Update fitness using percentiles with program scores
        memory_db.update_fitness(
            prompt.id, percentile=0.5, program_id="prog1", program_score=0.7
        )
        memory_db.update_fitness(
            prompt.id, percentile=0.9, program_id="prog2", program_score=0.95
        )

        updated = memory_db.get(prompt.id)
        assert updated.program_count == 2
        assert updated.correct_program_count == 2
        assert updated.fitness == 0.7  # (0.5 + 0.9) / 2
        assert len(updated.program_ids) == 2
        assert updated.program_scores == [0.7, 0.95]

    def test_sample_prompt(self, memory_db):
        """Test sampling prompts from archive."""
        # Add prompts with different fitness values (using percentiles)
        for i in range(3):
            prompt = create_system_prompt(
                prompt_text=f"Prompt {i}",
                generation=i,
                patch_type="init",
            )
            memory_db.add(prompt)
            # Update fitness with increasing percentiles and scores
            percentile = (i + 1) * 0.25  # 0.25, 0.5, 0.75
            score = (i + 1) * 0.3  # 0.3, 0.6, 0.9
            memory_db.update_fitness(
                prompt.id, percentile=percentile, program_score=score
            )
            memory_db.update_fitness(
                prompt.id, percentile=percentile, program_score=score
            )
            memory_db.update_fitness(
                prompt.id, percentile=percentile, program_score=score
            )

        # Sample multiple times
        samples = [memory_db.sample() for _ in range(10)]
        assert all(s is not None for s in samples)

    def test_get_best_prompt(self, memory_db):
        """Test getting the best prompt."""
        # Add prompts with different fitness
        prompt1 = create_system_prompt("Prompt 1", generation=0, patch_type="init")
        prompt2 = create_system_prompt("Prompt 2", generation=1, patch_type="init")
        prompt3 = create_system_prompt("Prompt 3", generation=2, patch_type="init")

        memory_db.add(prompt1)
        memory_db.add(prompt2)
        memory_db.add(prompt3)

        # Update fitness with different percentiles and scores
        for _ in range(3):
            memory_db.update_fitness(prompt1.id, percentile=0.3, program_score=0.4)
            memory_db.update_fitness(prompt2.id, percentile=0.9, program_score=0.95)
            memory_db.update_fitness(prompt3.id, percentile=0.5, program_score=0.6)

        best = memory_db.get_best_prompt()
        assert best is not None
        assert best.id == prompt2.id

    def test_prompt_lineage(self, memory_db):
        """Test getting prompt lineage."""
        # Create chain of prompts
        prompt0 = create_system_prompt("Prompt 0", generation=0, patch_type="init")
        memory_db.add(prompt0)

        prompt1 = create_system_prompt(
            "Prompt 1", parent_id=prompt0.id, generation=1, patch_type="diff"
        )
        memory_db.add(prompt1)

        prompt2 = create_system_prompt(
            "Prompt 2", parent_id=prompt1.id, generation=2, patch_type="full"
        )
        memory_db.add(prompt2)

        # Get lineage
        lineage = memory_db.get_lineage(prompt2.id)
        assert len(lineage) == 2
        assert lineage[0].id == prompt0.id
        assert lineage[1].id == prompt1.id

    def test_persistence(self, temp_db):
        """Test database persistence."""
        prompt = create_system_prompt(
            prompt_text="Persistent prompt",
            generation=0,
            patch_type="init",
        )
        temp_db.add(prompt)
        temp_db.save()

        # Get the db_path before closing
        db_path = temp_db.config.db_path

        temp_db.close()

        # Reopen and verify
        config = SystemPromptConfig(db_path=db_path, archive_size=5)
        db2 = SystemPromptDatabase(config)

        retrieved = db2.get(prompt.id)
        assert retrieved is not None
        assert retrieved.prompt_text == "Persistent prompt"
        db2.close()


class TestSystemPromptSampler:
    """Test SystemPromptSampler functionality."""

    @pytest.fixture
    def sampler_with_prompts(self):
        """Create a sampler with some prompts."""
        config = SystemPromptConfig(db_path=None, archive_size=10)
        db = SystemPromptDatabase(config)

        # Add prompts with varying fitness (using percentiles)
        for i in range(5):
            prompt = create_system_prompt(
                prompt_text=f"Prompt {i}",
                generation=i,
                patch_type="init",
            )
            db.add(prompt)
            # Give each prompt different percentile-based fitness with scores
            percentile = (i + 1) * 0.15  # 0.15, 0.30, 0.45, 0.60, 0.75
            score = (i + 1) * 0.18  # Corresponding scores
            for _ in range(3):
                db.update_fitness(prompt.id, percentile=percentile, program_score=score)

        sampler = SystemPromptSampler(prompt_db=db, exploration_constant=1.0)
        yield sampler, db
        db.close()

    def test_sample(self, sampler_with_prompts):
        """Test sampling prompts."""
        sampler, db = sampler_with_prompts

        # Sample should return a prompt
        prompt = sampler.sample()
        assert prompt is not None
        assert isinstance(prompt, SystemPrompt)

    def test_get_best_prompt(self, sampler_with_prompts):
        """Test getting best prompt through sampler."""
        sampler, db = sampler_with_prompts

        best = sampler.get_best_prompt()
        assert best is not None

    def test_get_archive(self, sampler_with_prompts):
        """Test getting archive through sampler."""
        sampler, db = sampler_with_prompts

        archive = sampler.get_archive()
        assert len(archive) == 5

    def test_ucb_exploration_effect(self):
        """Test that UCB exploration constant affects selection."""
        config = SystemPromptConfig(db_path=None, archive_size=10)
        db = SystemPromptDatabase(config)

        # Add prompts with very different percentile-based fitness
        low_fit = create_system_prompt("Low", generation=0, patch_type="init")
        high_fit = create_system_prompt("High", generation=1, patch_type="init")

        db.add(low_fit)
        db.add(high_fit)

        # Give very different percentile-based fitness with scores
        for _ in range(5):
            db.update_fitness(low_fit.id, percentile=0.2, program_score=0.3)
            db.update_fitness(high_fit.id, percentile=0.9, program_score=0.95)

        # Low exploration = more greedy (exploit high fitness)
        low_explore_sampler = SystemPromptSampler(
            db, exploration_constant=0.1, epsilon=0.0
        )
        high_explore_sampler = SystemPromptSampler(
            db, exploration_constant=10.0, epsilon=0.0
        )

        # Count how often high-fitness is selected
        # With low exploration, UCB should favor exploitation (high fitness prompt)
        low_explore_high_count = sum(
            1 for _ in range(100) if low_explore_sampler.sample().id == high_fit.id
        )

        # With high exploration, UCB should explore more evenly
        # (both prompts have same number of samples, so exploration term is equal,
        # but high exploration makes fitness difference matter less relatively)
        high_explore_high_count = sum(
            1 for _ in range(100) if high_explore_sampler.sample().id == high_fit.id
        )

        # Low exploration should select high fitness more often
        # (exploitation dominates over exploration)
        assert low_explore_high_count >= high_explore_high_count

        db.close()


class TestPromptEvolutionPrompts:
    """Test the prompt evolution prompt templates."""

    def test_diff_prompt_construction(self):
        """Test constructing diff evolution prompts."""
        from shinka.prompts.prompts_prompt_evo import (
            construct_diff_evolution_prompt,
        )

        prompt = create_system_prompt(
            prompt_text="Original prompt",
            generation=0,
            patch_type="init",
        )
        prompt.fitness = 0.5
        prompt.program_count = 10

        # New signature takes top_programs list instead of recent_improvements
        sys_msg, user_msg = construct_diff_evolution_prompt(prompt, top_programs=[])

        assert "expert prompt engineer" in sys_msg.lower()
        assert "Original prompt" in user_msg
        assert (
            "targeted" in sys_msg.lower()
        )  # Diff should mention targeted modifications

    def test_full_prompt_construction(self):
        """Test constructing full rewrite prompts."""
        from shinka.prompts.prompts_prompt_evo import (
            construct_full_evolution_prompt,
        )

        prompt = create_system_prompt(
            prompt_text="Original prompt",
            generation=0,
            patch_type="init",
        )

        # New signature takes top_programs list instead of best_program_info
        sys_msg, user_msg = construct_full_evolution_prompt(prompt, top_programs=[])

        assert "rewrite" in sys_msg.lower()
        assert "Original prompt" in user_msg

    def test_inspiration_prompt_formatting(self):
        """Test formatting inspiration prompts for prompt evolution context."""
        from shinka.prompts.prompts_prompt_evo import format_inspiration_prompts

        inspirations = [
            create_system_prompt(
                prompt_text=f"Inspiration {i}",
                generation=i,
                patch_type="diff",
            )
            for i in range(3)
        ]
        for i, insp in enumerate(inspirations):
            insp.fitness = 0.3 * (i + 1)
            insp.program_count = 5

        formatted = format_inspiration_prompts(inspirations, max_inspirations=2)

        assert "Inspiration 1" in formatted
        assert "Inspiration 2" in formatted
        assert "Inspiration 3" not in formatted
        assert "Performance: fitness=" in formatted


class TestEvolutionConfigPromptSettings:
    """Test EvolutionConfig prompt evolution settings."""

    def test_default_prompt_evolution_config(self):
        """Test default prompt evolution settings."""
        from shinka.core.config import EvolutionConfig

        config = EvolutionConfig()

        assert config.evolve_prompts is False
        assert config.prompt_patch_types == ["diff", "full"]
        assert config.prompt_patch_type_probs == [0.7, 0.3]
        assert config.prompt_evolution_interval is None
        assert config.prompt_archive_size == 10

    def test_custom_prompt_evolution_config(self):
        """Test custom prompt evolution settings."""
        from shinka.core.config import EvolutionConfig

        config = EvolutionConfig(
            evolve_prompts=True,
            prompt_patch_types=["diff", "full", "cross"],
            prompt_patch_type_probs=[0.5, 0.3, 0.2],
            prompt_evolution_interval=20,
            prompt_archive_size=15,
        )

        assert config.evolve_prompts is True
        assert "cross" in config.prompt_patch_types
        assert config.prompt_evolution_interval == 20
        assert config.prompt_archive_size == 15


class TestProgramSystemPromptId:
    """Test Program dataclass with system_prompt_id."""

    def test_program_with_prompt_id(self):
        """Test creating a program with system_prompt_id."""
        program = Program(
            id="test-program-id",
            code="print('hello')",
            generation=1,
            system_prompt_id="test-prompt-id",
        )

        assert program.system_prompt_id == "test-prompt-id"

    def test_program_without_prompt_id(self):
        """Test creating a program without system_prompt_id."""
        program = Program(
            id="test-program-id",
            code="print('hello')",
            generation=1,
        )

        assert program.system_prompt_id is None

    def test_program_to_dict_with_prompt_id(self):
        """Test program serialization with system_prompt_id."""
        program = Program(
            id="test-id",
            code="code",
            generation=1,
            system_prompt_id="prompt-id",
        )

        data = program.to_dict()
        assert data["system_prompt_id"] == "prompt-id"


if __name__ == "__main__":
    pytest.main([__file__, "-v"])