Testing¶

import pytest
from pathlib import Path
from depkeeper.core.parser import RequirementsParser


@pytest.fixture
def parser() -> RequirementsParser:
    """Provide a fresh parser instance."""
    return RequirementsParser()


@pytest.fixture
def sample_requirements_file(tmp_path: Path) -> Path:
    """Create a temporary requirements file with common packages."""
    content = """\
# Production dependencies
requests>=2.28.0
flask==2.3.0
click>=8.0.0

# Development tools
pytest>=7.0.0
"""
    file_path = tmp_path / "requirements.txt"
    file_path.write_text(content)
    return file_path


@pytest.fixture
def complex_requirements_file(tmp_path: Path) -> Path:
    """Create a requirements file with advanced syntax."""
    content = """\
requests[security,socks]>=2.28.0,<3.0
Django>=4.0; python_version >= '3.10'
-e git+https://github.com/user/repo.git@main#egg=package
./local-package
"""
    file_path = tmp_path / "requirements.txt"
    file_path.write_text(content)
    return file_path

def test_parse_file_counts_packages(parser, sample_requirements_file):
    """Parser extracts all package requirements from file."""
    requirements = parser.parse_file(sample_requirements_file)

    # Should find 4 packages (comments excluded)
    assert len(requirements) == 4
    assert requirements[0].name == "requests"


def test_parse_complex_syntax(parser, complex_requirements_file):
    """Parser handles advanced requirement syntax."""
    requirements = parser.parse_file(complex_requirements_file)

    # Check extras are parsed
    assert "security" in requirements[0].extras
    assert "socks" in requirements[0].extras

    # Check environment markers
    assert requirements[1].markers is not None

import pytest


@pytest.mark.asyncio
async def test_checker_returns_latest_version(httpx_mock):
    """VersionChecker identifies the latest available version."""
    # Arrange: Mock PyPI response
    httpx_mock.add_response(
        url="https://pypi.org/pypi/requests/json",
        json={
            "info": {"name": "requests", "version": "2.31.0"},
            "releases": {
                "2.28.0": [{"upload_time": "2023-01-01"}],
                "2.31.0": [{"upload_time": "2023-06-15"}],
            },
        },
    )

    # Act
    from depkeeper.core import PyPIDataStore, VersionChecker
    from depkeeper.utils import HTTPClient

    async with HTTPClient() as http:
        store = PyPIDataStore(http)
        checker = VersionChecker(data_store=store)
        pkg = await checker.get_package_info("requests", "2.28.0")

    # Assert
    assert pkg.latest_version == "2.31.0"
    assert pkg.current_version == "2.28.0"
    assert pkg.update_available is True

import pytest


@pytest.mark.asyncio
async def test_batch_check_multiple_packages(httpx_mock):
    """Checker efficiently handles multiple package queries."""
    # Mock responses for multiple packages
    packages = ["requests", "flask", "click"]
    for pkg in packages:
        httpx_mock.add_response(
            url=f"https://pypi.org/pypi/{pkg}/json",
            json={
                "info": {"name": pkg, "version": "1.0.0"},
                "releases": {"1.0.0": [{}]},
            },
        )

    # ... test implementation

import pytest
import httpx


@pytest.mark.asyncio
async def test_checker_handles_not_found(httpx_mock):
    """VersionChecker gracefully handles missing packages."""
    httpx_mock.add_response(
        url="https://pypi.org/pypi/nonexistent-pkg/json",
        status_code=404,
    )

    from depkeeper.core import PyPIDataStore, VersionChecker
    from depkeeper.utils import HTTPClient
    from depkeeper.exceptions import PackageNotFoundError

    async with HTTPClient() as http:
        store = PyPIDataStore(http)
        checker = VersionChecker(data_store=store)

        with pytest.raises(PackageNotFoundError) as exc:
            await checker.get_package_info("nonexistent-pkg")

        assert "nonexistent-pkg" in str(exc.value)


@pytest.mark.asyncio
async def test_checker_handles_timeout(httpx_mock):
    """VersionChecker handles network timeouts gracefully."""
    httpx_mock.add_exception(
        httpx.TimeoutException("Connection timed out")
    )

    # ... test implementation

import pytest


@pytest.mark.parametrize(
    "input_line,expected_name,expected_specs",
    [
        ("requests==2.28.0", "requests", [("==", "2.28.0")]),
        ("flask>=2.0,<3.0", "flask", [(">=", "2.0"), ("<", "3.0")]),
        ("click~=8.0", "click", [("~=", "8.0")]),
        ("numpy", "numpy", []),
        ("Django>=4.0", "django", [(">=", "4.0")]),  # Normalized
    ],
    ids=[
        "pinned-version",
        "version-range",
        "compatible-release",
        "no-version",
        "case-normalization",
    ],
)
def test_parse_version_specifiers(parser, input_line, expected_name, expected_specs):
    """Parser correctly handles various version specifier formats."""
    result = parser.parse_line(input_line, line_number=1)

    assert result.name == expected_name
    assert result.specs == expected_specs

import pytest
from depkeeper.utils.version_utils import get_update_type


@pytest.mark.parametrize("current,target,expected", [
    # Major version changes
    ("1.0.0", "2.0.0", "major"),
    ("1.9.9", "2.0.0", "major"),
    # Minor version changes
    ("1.0.0", "1.1.0", "minor"),
    ("1.0.5", "1.2.0", "minor"),
    # Patch version changes
    ("1.0.0", "1.0.1", "patch"),
    ("1.2.3", "1.2.5", "patch"),
    # Edge cases
    ("1.0.0", "1.0.0", "same"),
    ("2.0.0", "1.0.0", "downgrade"),
    (None, "1.0.0", "new"),
])
def test_get_update_type(current, target, expected):
    """get_update_type correctly classifies version changes."""
    result = get_update_type(current, target)
    assert result == expected

import pytest


@pytest.fixture(params=[
    "requirements.txt",
    "requirements-dev.txt",
    "requirements/base.txt",
])
def requirements_filename(request):
    """Test with various requirements file naming conventions."""
    return request.param

import pytest
from click.testing import CliRunner
from depkeeper.cli import cli


class TestCheckCommand:
    """E2E tests for the check command."""

    @pytest.fixture
    def runner(self):
        return CliRunner()

    def test_check_shows_outdated_packages(self, runner, httpx_mock):
        """Check command displays outdated packages."""
        with runner.isolated_filesystem():
            # Create requirements file
            with open("requirements.txt", "w") as f:
                f.write("requests==2.28.0\n")

            # Mock PyPI
            # Note: May need to configure httpx_mock for CLI tests

            result = runner.invoke(cli, ["check"])

            assert result.exit_code == 0
            assert "requests" in result.output

    def test_check_returns_success_with_outdated(self, runner):
        """Check returns exit code 0 even when updates are available."""
        with runner.isolated_filesystem():
            with open("requirements.txt", "w") as f:
                f.write("requests==2.28.0\n")

            result = runner.invoke(cli, ["check"])

            # Exit code 0 indicates successful execution
            assert result.exit_code == 0

    def test_check_missing_file_shows_error(self, runner):
        """Check command shows helpful error for missing file."""
        with runner.isolated_filesystem():
            result = runner.invoke(cli, ["check"])

            assert result.exit_code != 0
            assert "requirements.txt" in result.output
            assert "not found" in result.output.lower()

import json
import pytest
from click.testing import CliRunner
from depkeeper.cli import cli


class TestOutputFormats:
    """Tests for different output format options."""

    @pytest.fixture
    def runner(self):
        return CliRunner()

    def test_json_output_is_valid(self, runner):
        """JSON output is valid and parseable."""
        with runner.isolated_filesystem():
            with open("requirements.txt", "w") as f:
                f.write("requests==2.28.0\n")

            result = runner.invoke(cli, ["check", "--format", "json"])

            # Should be valid JSON
            data = json.loads(result.output)
            assert isinstance(data, list)
            assert all("name" in pkg for pkg in data)

    def test_quiet_mode_minimal_output(self, runner):
        """Quiet mode produces minimal output."""
        with runner.isolated_filesystem():
            with open("requirements.txt", "w") as f:
                f.write("requests==2.28.0\n")

            result = runner.invoke(cli, ["check", "-q"])

            # Should have minimal output
            lines = [l for l in result.output.strip().split("\n") if l]
            assert len(lines) <= 5

    def test_verbose_shows_debug_info(self, runner):
        """Verbose mode includes debug information."""
        with runner.isolated_filesystem():
            with open("requirements.txt", "w") as f:
                f.write("requests==2.28.0\n")

            result = runner.invoke(cli, ["check", "-v"])

            # Should include extra info
            assert "Parsing" in result.output or "Checking" in result.output

import pytest
from click.testing import CliRunner
from depkeeper.cli import cli


class TestInteractiveCommands:
    """Tests for commands requiring user input."""

    @pytest.fixture
    def runner(self):
        return CliRunner(mix_stderr=False)

    def test_update_prompts_for_confirmation(self, runner):
        """Update command asks for confirmation by default."""
        with runner.isolated_filesystem():
            with open("requirements.txt", "w") as f:
                f.write("requests==2.28.0\n")

            # Simulate user typing 'n' for no
            result = runner.invoke(cli, ["update"], input="n\n")

            assert "Proceed?" in result.output or "Continue?" in result.output
            assert "Aborted" in result.output or "Cancelled" in result.output

    def test_update_yes_flag_skips_prompt(self, runner):
        """Update --yes flag bypasses confirmation."""
        with runner.isolated_filesystem():
            with open("requirements.txt", "w") as f:
                f.write("requests==2.28.0\n")

            result = runner.invoke(cli, ["update", "--yes", "--dry-run"])

            # Should not ask for confirmation
            assert "Proceed?" not in result.output