gitpulse/tests/conftest.py

"""Test configuration and fixtures for depcheck tests."""

import json
import tempfile
from pathlib import Path

import pytest

from depcheck.models import Dependency, PackageManager, ScanResult, Severity, Vulnerability


@pytest.fixture
def temp_dir():
    """Create a temporary directory for tests."""
    with tempfile.TemporaryDirectory() as tmpdir:
        yield tmpdir


@pytest.fixture
def sample_package_json():
    """Create a sample package.json file content."""
    return """{
    "name": "test-project",
    "version": "1.0.0",
    "dependencies": {
        "express": "4.18.2",
        "lodash": "4.17.20"
    },
    "devDependencies": {
        "jest": "29.7.0"
    }
}"""


@pytest.fixture
def sample_requirements_txt():
    """Create a sample requirements.txt file content."""
    return """requests>=2.31.0
flask>=2.0.0
numpy==1.24.0
"""


@pytest.fixture
def sample_go_mod():
    """Create a sample go.mod file content."""
    return """
module github.com/example/project

go 1.21

require (
    github.com/stretchr/testify v1.8.4
    golang.org/x/crypto v0.17.0
)
"""


@pytest.fixture
def sample_cargo_toml():
    """Create a sample Cargo.toml file content."""
    return """
[package]
name = "my-project"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = "1.0"
tokio = "1.36"
"""


@pytest.fixture
def sample_vulnerable_dependencies():
    """Create scan result with vulnerable dependencies."""
    dep1 = Dependency(
        name="lodash",
        current_version="4.17.20",
        package_manager=PackageManager.NPM,
    )
    dep2 = Dependency(
        name="requests",
        current_version="2.28.0",
        package_manager=PackageManager.PIP,
    )

    vuln1 = Vulnerability(
        cve_id="CVE-2021-23337",
        severity=Severity.HIGH,
        description="Command Injection",
        affected_versions="<4.17.21",
        fixed_version="4.17.21",
    )

    vuln2 = Vulnerability(
        cve_id="CVE-2024-35195",
        severity=Severity.MEDIUM,
        description="Auth bypass",
        affected_versions="<2.32.0",
        fixed_version="2.32.0",
    )

    result = ScanResult()
    result.dependencies = [dep1, dep2]
    result.vulnerabilities = [(dep1, vuln1), (dep2, vuln2)]

    return result


@pytest.fixture
def sample_outdated_dependencies():
    """Create scan result with outdated dependencies."""
    deps = [
        Dependency(
            name="express",
            current_version="4.18.2",
            latest_version="4.19.2",
            package_manager=PackageManager.NPM,
            is_outdated=True,
        ),
        Dependency(
            name="flask",
            current_version="2.0.0",
            latest_version="3.0.0",
            package_manager=PackageManager.PIP,
            is_outdated=True,
        ),
    ]

    return ScanResult(dependencies=deps)


@pytest.fixture
def empty_scan_result():
    """Create an empty scan result."""
    return ScanResult()


@pytest.fixture
def sample_request():
    """Create a sample recorded request."""
    from api_snapshot.recorder.recorder import RecordedRequest
    return RecordedRequest(
        method="GET",
        url="https://api.example.com/users",
        headers={"Accept": "application/json"},
        body=None,
    )


@pytest.fixture
def sample_response():
    """Create a sample recorded response."""
    from api_snapshot.recorder.recorder import RecordedResponse
    return RecordedResponse(
        status_code=200,
        headers={"Content-Type": "application/json"},
        body='{"success": true}',
        latency_ms=150,
    )


@pytest.fixture
def sample_pair(sample_request, sample_response):
    """Create a sample request-response pair."""
    from api_snapshot.recorder.recorder import RequestResponsePair
    return RequestResponsePair(
        request=sample_request,
        response=sample_response,
    )


@pytest.fixture
def sample_snapshot(sample_pair):
    """Create a sample snapshot."""
    from api_snapshot.snapshot.manager import Snapshot, SnapshotMetadata
    meta = SnapshotMetadata(description="Test snapshot")
    return Snapshot(metadata=meta, requests=[sample_pair])


@pytest.fixture
def sample_snapshot_dict():
    """Create a sample snapshot dictionary."""
    return {
        "metadata": {
            "version": "1.0",
            "timestamp": "2024-01-01T00:00:00",
            "description": "Test snapshot",
            "source_url": "https://api.example.com",
            "latency_mode": "original",
            "custom_latency_ms": None,
            "tags": []
        },
        "requests": [
            {
                "request": {
                    "method": "GET",
                    "url": "https://api.example.com/users",
                    "headers": {"Accept": "application/json"},
                    "body": None,
                    "timestamp": "2024-01-01T00:00:00"
                },
                "response": {
                    "status_code": 200,
                    "headers": {"Content-Type": "application/json"},
                    "body": '{"success": true}',
                    "latency_ms": 150
                }
            }
        ]
    }


@pytest.fixture
def snapshot_manager(temp_dir):
    """Create a snapshot manager with a test snapshot."""
    from api_snapshot.snapshot.manager import SnapshotManager
    manager = SnapshotManager(temp_dir)
    return manager


@pytest.fixture
def snapshot_file(temp_dir, sample_pair):
    """Create a snapshot file for testing."""
    from api_snapshot.snapshot.manager import SnapshotManager
    import json

    manager = SnapshotManager(temp_dir)
    manager.save_snapshot(
        name="test_snapshot",
        requests=[sample_pair, sample_pair],
        description="Test snapshot"
    )

    path = manager._get_path("test_snapshot")
    return path