tests/test_qa.py

"""Quality Assurance Testing Suite

Comprehensive QA tests for burme-coder-max project.
Covers: Code Quality, Functionality, Performance, Security.
"""

import pytest
import ast
import os
import re
import sys
from pathlib import Path
from typing import List, Dict, Tuple

sys.path.insert(0, str(Path(__file__).parent.parent / "src"))


class TestCodeQuality:
    """Code quality validation tests."""

    PROJECT_ROOT = Path(__file__).parent.parent

    def test_python_syntax(self):
        """Verify all Python files have valid syntax."""
        errors = []
        for py_file in self.PROJECT_ROOT.rglob("*.py"):
            if ".venv" in str(py_file) or "venv" in str(py_file):
                continue
            try:
                content = py_file.read_text(encoding="utf-8")
                ast.parse(content)
            except SyntaxError as e:
                errors.append(f"{py_file}: {e}")

        assert not errors, f"Syntax errors found:\n" + "\n".join(errors)

    def test_docstrings_present(self):
        """Check module-level docstrings exist."""
        missing_docs = []
        for py_file in (self.PROJECT_ROOT / "src").rglob("*.py"):
            if py_file.name == "__init__.py":
                continue
            content = py_file.read_text(encoding="utf-8")
            if '"""' not in content and "'''" not in content:
                missing_docs.append(py_file.name)

        assert not missing_docs, f"Missing docstrings in: {missing_docs}"

    def test_imports_are_valid(self):
        """Verify all imports can be resolved."""
        for py_file in (self.PROJECT_ROOT / "src").rglob("*.py"):
            content = py_file.read_text(encoding="utf-8")
            tree = ast.parse(content)
            for node in ast.walk(tree):
                if isinstance(node, ast.Import):
                    for alias in node.names:
                        # Skip relative imports and external packages
                        if not alias.name.startswith(".") and not alias.name.startswith("_"):
                            pass  # External packages assumed valid
                elif isinstance(node, ast.ImportFrom):
                    module = node.module or ""
                    if module.startswith("_"):
                        pytest.fail(f"Import from private module: {module} in {py_file}")

    def test_no_debug_code(self):
        """Check for debug/ad-hoc code."""
        debug_patterns = [
            r"print\s*\(\s*debug",
            r"print\s*\(\s*TODO",
            r"print\s*\(\s*FIXME",
            r"print\s*\(\s*console\.log",
            r"import\s+pdb",
            r"import\s+ipdb",
        ]
        violations = []
        for py_file in (self.PROJECT_ROOT / "src").rglob("*.py"):
            content = py_file.read_text(encoding="utf-8")
            for pattern in debug_patterns:
                if re.search(pattern, content, re.IGNORECASE):
                    violations.append(f"{py_file.name}: {pattern}")

        assert not violations, f"Debug code found:\n{violations}"


class TestFunctionality:
    """Functional tests for core modules."""

    def test_agent_initialization(self):
        """Test CoderAgent can be initialized."""
        from core.agent import CoderAgent
        agent = CoderAgent()
        assert agent is not None
        assert agent.model == "gpt-4"
        assert agent.session_id is not None

    def test_agent_generate_response(self):
        """Test response generation returns expected structure."""
        from core.agent import CoderAgent
        agent = CoderAgent()
        response = agent.generate_response("test instruction")

        assert "session_id" in response
        assert "instruction" in response
        assert "response" in response
        assert "timestamp" in response
        assert "model" in response

    def test_executor_initialization(self):
        """Test CodeExecutor initialization."""
        from core.executor import CodeExecutor, ExecutionResult
        executor = CodeExecutor(timeout=10)
        assert executor.timeout == 10
        assert executor.execution_count == 0

    def test_validator_initialization(self):
        """Test ResponseValidator initialization."""
        from core.validator import ResponseValidator, ValidationResult
        validator = ResponseValidator()
        result = validator.validate("def test(): pass", "test function")

        assert isinstance(result, ValidationResult)
        assert hasattr(result, "quality")
        assert hasattr(result, "score")
        assert hasattr(result, "issues")

    def test_animation_configs(self):
        """Test all animation classes are importable."""
        from animations import Spinner, ProgressBar, ParticleBurst, TypingEffect
        assert Spinner is not None
        assert ProgressBar is not None
        assert ParticleBurst is not None
        assert TypingEffect is not None

    def test_knowledge_base_search(self):
        """Test LocalKB search functionality."""
        from knowledge import LocalKB
        kb = LocalKB()
        results = kb.search("python")
        assert isinstance(results, list)


class TestSecurity:
    """Security validation tests."""

    PROJECT_ROOT = Path(__file__).parent.parent

    def test_no_hardcoded_secrets(self):
        """Check for hardcoded passwords/secrets in code."""
        secret_patterns = [
            r"password\s*=\s*['\"][^'\"]{8,}['\"]",
            r"api_key\s*=\s*['\"][^'\"]{20,}['\"]",
            r"secret\s*=\s*['\"][^'\"]{20,}['\"]",
            r"token\s*=\s*['\"][A-Za-z0-9_\-]{30,}['\"]",
        ]
        violations = []
        for py_file in (self.PROJECT_ROOT / "src").rglob("*.py"):
            content = py_file.read_text(encoding="utf-8")
            for pattern in secret_patterns:
                if re.search(pattern, content, re.IGNORECASE):
                    violations.append(f"{py_file.name}")

        assert not violations, f"Hardcoded secrets found in: {violations}"

    def test_sql_injection_protection(self):
        """Verify SQL queries use parameterized inputs."""
        dangerous_sql = ["SELECT * FROM users WHERE name = '" + "' + user_input + '"]
        violations = []
        for py_file in (self.PROJECT_ROOT / "src").rglob("*.py"):
            content = py_file.read_text(encoding="utf-8")
            if "sql" in content.lower() or "query" in content.lower():
                for dangerous in dangerous_sql:
                    if dangerous in content:
                        violations.append(py_file.name)

        assert not violations, f"SQL injection vulnerable code: {violations}"

    def test_shell_injection_protection(self):
        """Verify shell commands are safe."""
        from core.executor import CodeExecutor
        executor = CodeExecutor()

        # Should detect potentially malicious code
        malicious = "__import__('os').system('rm -rf /')"
        result = executor._contains_malicious_code(malicious)
        assert result == True

    def test_input_validation(self):
        """Test input validation in key modules."""
        from core.validator import ResponseValidator

        # Empty response should still validate
        validator = ResponseValidator()
        result = validator.validate("", "test")
        assert result.score >= 0  # Score should be defined


class TestPerformance:
    """Performance-related tests."""

    def test_import_time(self):
        """Measure import time for core modules."""
        import time

        start = time.time()
        from core.agent import CoderAgent
        from core.executor import CodeExecutor
        from core.validator import ResponseValidator
        import_duration = time.time() - start

        # Should import in under 2 seconds
        assert import_duration < 2.0, f"Import took {import_duration}s"

    def test_agent_response_time(self):
        """Test response generation time."""
        import time
        from core.agent import CoderAgent

        agent = CoderAgent()
        start = time.time()
        response = agent.generate_response("test")
        duration = time.time() - start

        # Should complete in reasonable time
        assert duration < 5.0, f"Response took {duration}s"


class TestIntegration:
    """Integration tests across modules."""

    def test_full_agent_workflow(self):
        """Test complete agent workflow."""
        from core.agent import CoderAgent
        from core.validator import ResponseValidator

        agent = CoderAgent()
        validator = ResponseValidator()

        instruction = "Write a Python hello world function"
        response = agent.generate_response(instruction)
        validation = validator.validate(response["response"], instruction)

        assert validation.score > 0
        assert len(response["response"]) > 0

    def test_animation_with_agent(self):
        """Test animations working with agent."""
        import time
        from animations import Spinner
        from core.agent import CoderAgent

        agent = CoderAgent()
        with Spinner("Testing..."):
            response = agent.generate_response("test")
            time.sleep(0.1)

        assert len(response["response"]) > 0

    def test_knowledge_with_agent(self):
        """Test knowledge base integration."""
        from core.agent import CoderAgent
        from knowledge import LocalKB

        agent = CoderAgent()
        kb = LocalKB()

        # Create agent with knowledge dir
        agent_with_kb = CoderAgent(
            knowledge_dir=str(Path(__file__).parent.parent / "data" / "knowledge")
        )
        response = agent_with_kb.generate_response("python decorator hta ya")

        assert len(response["response"]) > 0


class TestDocumentation:
    """Documentation quality tests."""

    PROJECT_ROOT = Path(__file__).parent.parent

    def test_readme_exists(self):
        """Verify README.md exists."""
        readme = self.PROJECT_ROOT / "README.md"
        assert readme.exists(), "README.md not found"

    def test_readme_has_install_section(self):
        """Check README has installation instructions."""
        readme = (self.PROJECT_ROOT / "README.md").read_text(encoding="utf-8")
        assert "install" in readme.lower(), "Install section missing"

    def test_readme_has_usage_section(self):
        """Check README has usage examples."""
        readme = (self.PROJECT_ROOT / "README.md").read_text(encoding="utf-8")
        assert "usage" in readme.lower() or "example" in readme.lower()

    def test_docs_directory_exists(self):
        """Verify docs directory exists."""
        docs_dir = self.PROJECT_ROOT / "docs"
        assert docs_dir.exists(), "docs/ directory not found"

    def test_all_md_files_have_content(self):
        """Check all markdown files have substantial content."""
        small_files = []
        for md_file in self.PROJECT_ROOT.rglob("*.md"):
            content = md_file.read_text(encoding="utf-8")
            if len(content) < 100:
                small_files.append(md_file.name)

        assert not small_files, f"Very short markdown files: {small_files}"


class QAReport:
    """Generate QA report."""

    CLASSES = [
        TestCodeQuality,
        TestFunctionality,
        TestSecurity,
        TestPerformance,
        TestIntegration,
        TestDocumentation,
    ]

    @classmethod
    def run_all(cls) -> Dict:
        """Run all test classes and generate report."""
        from collections import defaultdict

        results = defaultdict(list)
        for test_class in cls.CLASSES:
            class_name = test_class.__name__
            for method_name in dir(test_class):
                if method_name.startswith("test_"):
                    try:
                        instance = test_class()
                        method = getattr(instance, method_name)
                        method()
                        results[class_name].append({
                            "name": method_name,
                            "status": "PASS"
                        })
                    except Exception as e:
                        results[class_name].append({
                            "name": method_name,
                            "status": "FAIL",
                            "error": str(e)
                        })

        return dict(results)


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