Testing Documentation

import pytest
from unittest.mock import Mock, patch
from eiplgrader.codegen import CodeGenerator

class TestCodeGenerator:
    """Unit tests for CodeGenerator."""
    
    def setup_method(self):
        """Set up test fixtures."""
        self.api_key = "test-key"
        self.generator = CodeGenerator(self.api_key, client_type="openai")
    
    def test_initialization(self):
        """Test proper initialization."""
        assert self.generator.api_key == self.api_key
        assert self.generator.language == "python"
        assert self.generator.client_type == "openai"
    
    @patch('eiplgrader.codegen.OpenAIRequest')
    def test_generate_code(self, mock_openai):
        """Test code generation."""
        # Mock LLM response
        mock_openai.return_value.request_function_generation.return_value = {
            "choices": [{
                "message": {
                    "content": "def factorial(n):\n    return 1"
                }
            }]
        }
        
        # Generate code
        result = self.generator.generate_code(
            student_response="calculate factorial",
            function_name="factorial"
        )
        
        # Assertions
        assert len(result["code"]) == 1
        assert "factorial" in result["code"][0]
        mock_openai.return_value.request_function_generation.assert_called_once()
    
    def test_invalid_client_type(self):
        """Test error handling for invalid client type."""
        with pytest.raises(ValueError):
            CodeGenerator(self.api_key, client_type="invalid_client")
    
    @pytest.mark.parametrize("gen_type,expected", [
        ("cgbg", True),
        ("redef", True),
        ("invalid", False)
    ])
    def test_generation_types(self, gen_type, expected):
        """Test different generation types."""
        if expected:
            # Should not raise
            self.generator._validate_gen_type(gen_type)
        else:
            with pytest.raises(ValueError):
                self.generator._validate_gen_type(gen_type)

class TestCodeGenerationIntegration:
    """Integration tests for code generation and testing."""
    
    @pytest.fixture
    def generator(self):
        """Create generator fixture."""
        return CodeGenerator(os.getenv("TEST_API_KEY", "dummy"))
    
    @pytest.fixture
    def test_cases(self):
        """Create test case fixture."""
        return [
            {"parameters": {"n": 5}, "expected": 120},
            {"parameters": {"n": 0}, "expected": 1}
        ]
    
    def test_generate_and_test_python(self, generator, test_cases):
        """Test Python code generation and execution."""
        # Generate code
        result = generator.generate_code(
            student_response="calculate factorial recursively",
            function_name="factorial",
            language="python"
        )
        
        assert result.success
        assert len(result.codes) > 0
        
        # Test generated code
        for code in result.codes:
            tester = CodeTester(
                code=code,
                test_cases=test_cases,
                function_name="factorial",
                language="python"
            )
            
            results = tester.run_tests()
            assert results.was_successful(), f"Tests failed for code:
{code}"

class TestJavaLanguageSupport:
    """Test Java language support."""
    
    def test_java_type_requirements(self):
        """Test that Java requires explicit types."""
        executor = JavaExecutor()
        
        # Missing types should raise error
        test_case = {
            "parameters": {"x": 5},
            "expected": 10
        }
        
        with pytest.raises(ValueError, match="parameter_types"):
            executor.validate_types_provided(test_case)
    
    def test_java_value_formatting(self):
        """Test Java value formatting."""
        executor = JavaExecutor()
        
        # Test various type conversions
        assert executor.format_value(True, "boolean") == "true"
        assert executor.format_value("hello", "String") == '"hello"'
        assert executor.format_value([1, 2, 3], "int[]") == "new int[]{1, 2, 3}"
    
    def test_java_compilation(self):
        """Test Java code compilation."""
        code = """
        public class Solution {
            public int add(int a, int b) {
                return a + b;
            }
        }
        """
        
        test_case = {
            "parameters": {"a": 5, "b": 3},
            "parameter_types": {"a": "int", "b": "int"},
            "expected": 8,
            "expected_type": "int"
        }
        
        executor = JavaExecutor()
        result = executor.execute_test(code, test_case)
        
        assert result["passed"]
        assert result["actual"] == 8

class TestEdgeCases:
    """Test edge cases and error conditions."""
    
    def test_empty_code(self):
        """Test handling of empty code."""
        tester = CodeTester(
            code="",
            test_cases=[{"parameters": {"x": 1}, "expected": 1}],
            function_name="test"
        )
        
        results = tester.run_tests()
        assert not results.was_successful()
        assert any("runtime" in str(r.get("error", "")).lower() 
                  for r in results.test_results if not r["pass"])
    
    def test_infinite_loop(self):
        """Test timeout handling."""
        code = """
def infinite():
    while True:
        pass
"""
        
        tester = CodeTester(
            code=code,
            test_cases=[{"parameters": {}, "expected": None}],
            function_name="infinite",
            timeout=1
        )
        
        results = tester.run_tests()
        assert not results.was_successful()
        assert any("timeout" in str(r.get("error", "")).lower() 
                  for r in results.test_results if not r["pass"])
    
    def test_large_output(self):
        """Test output size limits."""
        code = """
def large_output():
    return "x" * 10000000  # 10MB string
"""
        
        tester = CodeTester(
            code=code,
            test_cases=[{"parameters": {}, "expected": "x"}],
            function_name="large_output",

        )
        
        results = tester.run_tests()
        assert not results.was_successful()
        assert any("output size" in str(r.get("error", "")).lower() 
                  for r in results.test_results if not r["pass"])

# conftest.py
import pytest
import tempfile
import shutil

@pytest.fixture
def temp_dir():
    """Create temporary directory for tests."""
    temp = tempfile.mkdtemp()
    yield temp
    shutil.rmtree(temp, ignore_errors=True)

@pytest.fixture
def sample_code():
    """Provide sample code for testing."""
    return {
        "python": """
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)
""",
        "java": """
public class Solution {
    public int factorial(int n) {
        if (n <= 1) return 1;
        return n * factorial(n - 1);
    }
}
""",
        "javascript": """
function factorial(n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}
"""
    }

@pytest.fixture
def api_key():
    """Get API key for testing."""
    key = os.getenv("OPENAI_API_KEY")
    if not key:
        pytest.skip("API key not available")
    return key

@pytest.fixture(params=["python", "javascript"])
def dynamic_language(request):
    """Parametrized fixture for dynamic languages."""
    return request.param

@pytest.fixture(params=["java", "cpp", "go"])
def static_language(request):
    """Parametrized fixture for static languages."""
    return request.param

@pytest.fixture
def language_test_cases():
    """Test cases for each language."""
    return {
        "python": {
            "simple": {
                "parameters": {"x": 5},
                "expected": 10
            }
        },
        "java": {
            "simple": {
                "parameters": {"x": 5},
                "parameter_types": {"x": "int"},
                "expected": 10,
                "expected_type": "int"
            }
        }
    }

def create_test_case(language: str, params: dict, expected: Any) -> dict:
    """Create test case with appropriate format for language."""
    test_case = {
        "parameters": params,
        "expected": expected
    }
    
    # Add types for static languages
    if language in ["java", "cpp", "c", "go", "haskell"]:
        test_case["parameter_types"] = infer_types(params, language)
        test_case["expected_type"] = infer_type(expected, language)
    
    return test_case

def infer_types(params: dict, language: str) -> dict:
    """Infer parameter types for a language."""
    type_map = get_type_mapping(language)
    return {
        name: type_map[type(value).__name__]
        for name, value in params.items()
    }

class MockLLMResponse:
    """Mock LLM response for testing."""
    
    def __init__(self, codes: List[str]):
        self.codes = codes
        self.call_count = 0
    
    def __call__(self, *args, **kwargs):
        """Return next code in sequence."""
        if self.call_count < len(self.codes):
            code = self.codes[self.call_count]
            self.call_count += 1
            return {"choices": [{"message": {"content": code}}]}
        raise ValueError("No more mock responses")

def mock_llm_response(monkeypatch, codes: List[str]):
    """Patch LLM calls with mock responses."""
    mock = MockLLMResponse(codes)
    monkeypatch.setattr(
        "eiplgrader.codegen.OpenAIRequest.request_function_generation",
        mock
    )
    return mock

import pytest

@pytest.mark.benchmark
def test_code_generation_performance(benchmark):
    """Benchmark code generation."""
    generator = CodeGenerator("key")
    
    result = benchmark(
        generator.generate_code,
        student_response="calculate factorial",
        function_name="factorial",
        num_to_gen=1
    )
    
    assert result.success

@pytest.mark.benchmark
def test_execution_performance(benchmark):
    """Benchmark code execution."""
    code = "def add(a, b): return a + b"
    test_case = {"parameters": {"a": 1, "b": 2}, "expected": 3}
    
    tester = CodeTester(
        code=code,
        test_cases=[test_case],
        function_name="add"
    )
    
    # Individual test benchmarking not available - use run_tests() instead
    result = benchmark(lambda: tester.run_tests(), None)
    assert result.passed

def test_concurrent_execution_load():
    """Test system under load."""
    import concurrent.futures
    
    # Create many test cases
    test_cases = [
        {"parameters": {"n": i}, "expected": factorial(i)}
        for i in range(100)
    ]
    
    tester = CodeTester(
        code="def factorial(n): ...",  # Implementation
        test_cases=test_cases,
        function_name="factorial"
    )
    
    # Run with different worker counts
    for workers in [1, 4, 8, 16]:
        start = time.time()
        results = tester.run_tests()
        duration = time.time() - start
        
        print(f"Workers: {workers}, Time: {duration:.2f}s")
        assert results.was_successful()

@patch('requests.post')
def test_api_call(mock_post):
    mock_post.return_value.json.return_value = {"result": "success"}
    # Test code that uses requests.post

@pytest.mark.parametrize("input,expected", [
    (0, 1),
    (1, 1),
    (5, 120),
    (10, 3628800)
])
def test_factorial_values(input, expected):
    assert factorial(input) == expected

def test_error_handling():
    with pytest.raises(ValueError, match="negative"):
        factorial(-1)

def test_with_debugging():
    """Test with debugging helpers."""
    # Add breakpoint
    import pdb; pdb.set_trace()
    
    # Print debug info
    print(f"Debug: {variable}")
    
    # Use pytest's capsys
    def test_output(capsys):
        print("Hello")
        captured = capsys.readouterr()
        assert captured.out == "Hello\n"