mcp-skills

"""Pytest configuration and fixtures for integration tests."""

import json
from collections.abc import Generator
from pathlib import Path

import git
import pytest

from mcp_skills.services.indexing import IndexingEngine
from mcp_skills.services.repository_manager import RepositoryManager
from mcp_skills.services.skill_manager import SkillManager
from mcp_skills.services.toolchain_detector import ToolchainDetector


@pytest.fixture
def temp_repos_dir(tmp_path: Path) -> Generator[Path, None, None]:
    """Create temporary directory for test repositories.

    Args:
        tmp_path: Pytest temporary path fixture

    Yields:
        Path to temporary repos directory
    """
    repos_dir = tmp_path / "repos"
    repos_dir.mkdir()
    yield repos_dir


@pytest.fixture
def temp_storage_dir(tmp_path: Path) -> Generator[Path, None, None]:
    """Create temporary directory for ChromaDB storage.

    Args:
        tmp_path: Pytest temporary path fixture

    Yields:
        Path to temporary storage directory
    """
    storage_dir = tmp_path / "storage"
    storage_dir.mkdir()
    yield storage_dir


@pytest.fixture
def sample_skill_content() -> dict[str, str]:
    """Return sample SKILL.md content for different skill types.

    Returns:
        Dictionary mapping skill type to SKILL.md content
    """
    return {
        "pytest": """---
name: pytest-testing
description: Run tests with pytest framework
category: testing
tags:
  - python
  - pytest
  - testing
dependencies: []
version: "1.0.0"
author: Test Author
---

# Pytest Testing Skill

Use pytest to run Python tests with proper fixtures and assertions.

## Usage

Run pytest with:
```bash
pytest tests/
```

## Examples

```python
def test_example():
    assert 1 + 1 == 2
```
""",
        "flask": """---
name: flask-development
description: Build web applications with Flask
category: architecture
tags:
  - python
  - flask
  - web
dependencies: []
version: "1.0.0"
author: Test Author
---

# Flask Development Skill

Build Flask web applications following best practices.

## Usage

Create Flask app:
```python
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello World!'
```

## Examples

Run development server:
```bash
flask run --debug
```
""",
        "debugging": """---
name: python-debugging
description: Debug Python applications effectively
category: debugging
tags:
  - python
  - debugging
  - pdb
dependencies:
  - sample-repo/testing/pytest
version: "1.0.0"
author: Test Author
---

# Python Debugging Skill

Use pdb and debugging tools to troubleshoot Python code.

## Usage

Insert breakpoint:
```python
import pdb; pdb.set_trace()
```

## Examples

Debug with breakpoint():
```python
def buggy_function():
    breakpoint()  # Python 3.7+
    return result
```
""",
    }


@pytest.fixture
def sample_skill_repo(
    tmp_path: Path, sample_skill_content: dict[str, str]
) -> Generator[Path, None, None]:
    """Create a sample skill repository with multiple skills.

    This creates a git repository with realistic skill structure:
    - sample-repo/testing/pytest/SKILL.md
    - sample-repo/web/flask/SKILL.md
    - sample-repo/debugging/python/SKILL.md

    Args:
        tmp_path: Pytest temporary path fixture
        sample_skill_content: Sample SKILL.md content fixture

    Yields:
        Path to the created git repository
    """
    # Create repo directory
    repo_dir = tmp_path / "sample_repo"
    repo_dir.mkdir()

    # Initialize git repo
    repo = git.Repo.init(repo_dir)

    # Create skill files
    skills = {
        "testing/pytest": sample_skill_content["pytest"],
        "web/flask": sample_skill_content["flask"],
        "debugging/python": sample_skill_content["debugging"],
    }

    for skill_path, content in skills.items():
        skill_dir = repo_dir / skill_path
        skill_dir.mkdir(parents=True, exist_ok=True)
        skill_file = skill_dir / "SKILL.md"
        skill_file.write_text(content)

    # Create README
    readme = repo_dir / "README.md"
    readme.write_text(
        "# Test Skills Repository\n\nTest skills for integration testing."
    )

    # Commit files
    repo.index.add(["*"])
    repo.index.commit("Initial commit with test skills")

    yield repo_dir

    # Cleanup is handled by tmp_path


@pytest.fixture
def populated_repos_dir(
    temp_repos_dir: Path, sample_skill_content: dict[str, str]
) -> Generator[Path, None, None]:
    """Create a temporary repos directory with pre-populated skills.

    This fixture creates skills directly in the repos directory structure
    without needing git operations, making it faster for testing.

    Args:
        temp_repos_dir: Temporary repos directory fixture
        sample_skill_content: Sample SKILL.md content fixture

    Yields:
        Path to populated repos directory
    """
    # Create sample-repo structure directly in repos_dir
    repo_dir = temp_repos_dir / "sample-repo"
    repo_dir.mkdir()

    # Create skill files
    skills = {
        "testing/pytest": sample_skill_content["pytest"],
        "web/flask": sample_skill_content["flask"],
        "debugging/python": sample_skill_content["debugging"],
    }

    for skill_path, content in skills.items():
        skill_dir = repo_dir / skill_path
        skill_dir.mkdir(parents=True, exist_ok=True)
        skill_file = skill_dir / "SKILL.md"
        skill_file.write_text(content)

    yield temp_repos_dir


@pytest.fixture
def configured_repository_manager(
    temp_repos_dir: Path,
) -> Generator[RepositoryManager, None, None]:
    """Create and configure a RepositoryManager for testing.

    Args:
        temp_repos_dir: Temporary repos directory fixture

    Yields:
        Configured RepositoryManager instance
    """
    # Create base directory for metadata
    manager = RepositoryManager(base_dir=temp_repos_dir)

    yield manager

    # Cleanup is handled by temp_repos_dir


@pytest.fixture
def configured_skill_manager(
    temp_repos_dir: Path,
) -> Generator[SkillManager, None, None]:
    """Create and configure a SkillManager for testing.

    Args:
        temp_repos_dir: Temporary repos directory fixture

    Yields:
        Configured SkillManager instance
    """
    manager = SkillManager(repos_dir=temp_repos_dir)
    yield manager


@pytest.fixture
def configured_indexing_engine(
    configured_skill_manager: SkillManager,
    temp_storage_dir: Path,
) -> Generator[IndexingEngine, None, None]:
    """Create and configure an IndexingEngine for testing.

    Args:
        configured_skill_manager: Configured SkillManager fixture
        temp_storage_dir: Temporary storage directory fixture

    Yields:
        Configured IndexingEngine instance
    """
    engine = IndexingEngine(
        skill_manager=configured_skill_manager,
        storage_path=temp_storage_dir,
    )
    yield engine


@pytest.fixture
def configured_services(
    configured_repository_manager: RepositoryManager,
    configured_skill_manager: SkillManager,
    configured_indexing_engine: IndexingEngine,
) -> tuple[RepositoryManager, SkillManager, IndexingEngine]:
    """Provide fully configured service instances.

    Args:
        configured_repository_manager: Repository manager fixture
        configured_skill_manager: Skill manager fixture
        configured_indexing_engine: Indexing engine fixture

    Returns:
        Tuple of (repository_manager, skill_manager, indexing_engine)
    """
    return (
        configured_repository_manager,
        configured_skill_manager,
        configured_indexing_engine,
    )


@pytest.fixture
def populated_services(
    populated_repos_dir: Path,
    temp_storage_dir: Path,
) -> tuple[RepositoryManager, SkillManager, IndexingEngine]:
    """Provide fully configured services with pre-populated skills.

    This fixture is optimized for tests that need skills but don't need
    to test repository operations.

    Args:
        populated_repos_dir: Repos directory with pre-populated skills
        temp_storage_dir: Temporary storage directory

    Returns:
        Tuple of (repository_manager, skill_manager, indexing_engine)
    """
    repo_manager = RepositoryManager(base_dir=populated_repos_dir)
    skill_manager = SkillManager(repos_dir=populated_repos_dir)
    indexing_engine = IndexingEngine(
        skill_manager=skill_manager,
        storage_path=temp_storage_dir,
    )
    return repo_manager, skill_manager, indexing_engine


@pytest.fixture
def sample_python_project(tmp_path: Path) -> Generator[Path, None, None]:
    """Create a sample Python project for toolchain detection.

    Args:
        tmp_path: Pytest temporary path fixture

    Yields:
        Path to sample Python project
    """
    project_dir = tmp_path / "python_project"
    project_dir.mkdir()

    # Create Python project markers
    (project_dir / "pyproject.toml").write_text(
        """[project]
name = "test-project"
version = "1.0.0"
dependencies = ["flask>=3.0.0", "pytest>=7.0"]
"""
    )

    (project_dir / "requirements.txt").write_text("flask>=3.0.0\npytest>=7.0\n")

    (project_dir / "pytest.ini").write_text("[pytest]\ntestpaths = tests\n")

    # Create source files
    src_dir = project_dir / "src"
    src_dir.mkdir()
    (src_dir / "app.py").write_text(
        """from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello World!'
"""
    )

    # Create test directory
    tests_dir = project_dir / "tests"
    tests_dir.mkdir()
    (tests_dir / "test_app.py").write_text(
        """def test_example():
    assert 1 + 1 == 2
"""
    )

    yield project_dir


@pytest.fixture
def sample_typescript_project(tmp_path: Path) -> Generator[Path, None, None]:
    """Create a sample TypeScript project for toolchain detection.

    Args:
        tmp_path: Pytest temporary path fixture

    Yields:
        Path to sample TypeScript project
    """
    project_dir = tmp_path / "typescript_project"
    project_dir.mkdir()

    # Create TypeScript project markers
    (project_dir / "package.json").write_text(
        json.dumps(
            {
                "name": "test-project",
                "version": "1.0.0",
                "devDependencies": {
                    "typescript": "^5.0.0",
                    "jest": "^29.0.0",
                    "@types/node": "^20.0.0",
                },
            }
        )
    )

    (project_dir / "tsconfig.json").write_text(
        json.dumps(
            {
                "compilerOptions": {
                    "target": "ES2020",
                    "module": "commonjs",
                    "strict": True,
                }
            }
        )
    )

    # Create source files
    src_dir = project_dir / "src"
    src_dir.mkdir()
    (src_dir / "index.ts").write_text(
        """export function greet(name: string): string {
    return `Hello, ${name}!`;
}
"""
    )

    yield project_dir


@pytest.fixture
def old_json_metadata(tmp_path: Path) -> Generator[Path, None, None]:
    """Create old-style JSON metadata file for migration testing.

    Args:
        tmp_path: Pytest temporary path fixture

    Yields:
        Path to JSON metadata file
    """
    json_file = tmp_path / "repos.json"

    metadata = {
        "repositories": [
            {
                "id": "test/repo1",
                "url": "https://github.com/test/repo1.git",
                "local_path": str(tmp_path / "repos" / "test" / "repo1"),
                "priority": 100,
                "last_updated": "2024-01-01T00:00:00Z",
                "skill_count": 5,
                "license": "MIT",
            },
            {
                "id": "test/repo2",
                "url": "https://github.com/test/repo2.git",
                "local_path": str(tmp_path / "repos" / "test" / "repo2"),
                "priority": 90,
                "last_updated": "2024-01-01T00:00:00Z",
                "skill_count": 3,
                "license": "Apache-2.0",
            },
        ]
    }

    json_file.write_text(json.dumps(metadata, indent=2))
    yield json_file


@pytest.fixture
def configured_toolchain_detector() -> ToolchainDetector:
    """Create a configured ToolchainDetector instance.

    Returns:
        ToolchainDetector instance
    """
    return ToolchainDetector()