compounding-intelligence/scripts/test_dependency_freshness.py

#!/usr/bin/env python3
"""Tests for scripts/dependency_freshness.py — 9.7 Dependency Freshness."""

import json
import os
import sys
from unittest.mock import patch, MagicMock

# Import target module
sys.path.insert(0, os.path.dirname(__file__) or ".")
import importlib.util
spec = importlib.util.spec_from_file_location(
    "dependency_freshness",
    os.path.join(os.path.dirname(__file__) or ".", "dependency_freshness.py")
)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)

parse_requirements = mod.parse_requirements
get_major_version = mod.get_major_version
is_more_than_two_majors_behind = mod.is_more_than_two_majors_behind
analyze_dependencies = mod.analyze_dependencies


def test_parse_requirements_simple():
    """Parse a simple package line."""
    import tempfile
    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
        f.write("requests\n")
        tmp = f.name
    try:
        pkgs = parse_requirements(tmp)
        assert pkgs == ["requests"], f"got {pkgs}"
        print("PASS: test_parse_requirements_simple")
    finally:
        os.unlink(tmp)


def test_parse_requirements_with_specifiers():
    """Parse lines with version specifiers."""
    import tempfile
    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
        f.write("pytest>=8,<9\n")
        f.write("aiohttp>=3.8\n")
        tmp = f.name
    try:
        pkgs = parse_requirements(tmp)
        assert pkgs == ["pytest", "aiohttp"], f"got {pkgs}"
        print("PASS: test_parse_requirements_with_specifiers")
    finally:
        os.unlink(tmp)


def test_parse_requirements_ignores_comments_and_blanks():
    """Comments and blank lines are skipped."""
    import tempfile
    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
        f.write("# This is a comment\n")
        f.write("\n")
        f.write("   \n")
        f.write("numpy\n")
        f.write("# another comment\n")
        tmp = f.name
    try:
        pkgs = parse_requirements(tmp)
        assert pkgs == ["numpy"], f"got {pkgs}"
        print("PASS: test_parse_requirements_ignores_comments_and_blanks")
    finally:
        os.unlink(tmp)


def test_get_major_version_normal():
    """Extract major version from typical semantic strings."""
    assert get_major_version("1.2.3") == 1
    assert get_major_version("3.4.5") == 3
    assert get_major_version("0.11.0") == 0
    print("PASS: test_get_major_version_normal")


def test_get_major_version_with_rc():
    """Prerelease versions still yield major number."""
    assert get_major_version("2.0.0rc1") == 2
    assert get_major_version("1.0.0a1") == 1
    print("PASS: test_get_major_version_with_rc")


def test_is_more_than_two_majors_behind():
    """Difference >2 triggers True; <=2 triggers False."""
    assert is_more_than_two_majors_behind("1.2.3", "4.0.0") is True
    assert is_more_than_two_majors_behind("3.9.0", "4.0.0") is False
    assert is_more_than_two_majors_behind("2.1.0", "5.2.0") is True
    assert is_more_than_two_majors_behind("8.0.0", "9.0.0") is False
    assert is_more_than_two_majors_behind("4.0.0", "4.0.0") is False
    print("PASS: test_is_more_than_two_majors_behind")


def test_analyze_dependencies_very_outdated():
    """Flag packages more than 2 major versions behind."""
    required = ["pkg_a", "pkg_b"]
    installed = {"pkg_a": "1.0.0", "pkg_b": "3.5.2"}
    outdated = {
        "pkg_a": {"installed": "1.0.0", "latest": "4.0.0"},
        "pkg_b": {"installed": "3.5.2", "latest": "4.0.0"},
    }
    very_out, missing, outdated_ok = analyze_dependencies(required, installed, outdated)
    assert len(very_out) == 1 and very_out[0]["package"] == "pkg_a"
    assert len(missing) == 0
    assert len(outdated_ok) == 1 and outdated_ok[0]["package"] == "pkg_b"
    print("PASS: test_analyze_dependencies_very_outdated")


def test_analyze_dependencies_missing():
    """Detect packages not installed at all."""
    required = ["pkg_a", "pkg_missing"]
    installed = {"pkg_a": "2.0.0"}
    outdated = {"pkg_a": {"installed": "2.0.0", "latest": "3.0.0"}}
    very_out, missing, outdated_ok = analyze_dependencies(required, installed, outdated)
    assert "pkg_missing" in missing
    assert len(very_out) == 0
    assert len(outdated_ok) == 1
    print("PASS: test_analyze_dependencies_missing")


def test_analyze_dependencies_up_to_date():
    """Packages up-to-date are not flagged."""
    required = ["pkg_good"]
    installed = {"pkg_good": "5.0.0"}
    outdated = {}
    very_out, missing, outdated_ok = analyze_dependencies(required, installed, outdated)
    assert len(very_out) == 0
    assert len(missing) == 0
    assert len(outdated_ok) == 0
    print("PASS: test_analyze_dependencies_up_to_date")


def test_generate_human_report_contains_very_outdated():
    """Human report includes very outdated packages."""
    very_out = [
        {"package": "oldpkg", "installed": "1.0", "latest": "4.0", "major_diff": 3}
    ]
    missing = []
    outdated_ok = []
    report = mod.generate_human_report(very_out, missing, outdated_ok, "requirements.txt")
    assert "oldpkg" in report
    assert "Installed: 1.0" in report
    assert "Latest:    4.0" in report
    assert "Major diff: 3" in report
    print("PASS: test_generate_human_report_contains_very_outdated")


def test_generate_json_report_structure():
    """JSON report contains required keys."""
    very_out = [{"package": "oldpkg", "installed": "1.0", "latest": "4.0", "major_diff": 3}]
    missing = ["missing_pkg"]
    outdated_ok = []
    report_json = mod.generate_json_report(very_out, missing, outdated_ok, "requirements.txt")
    data = json.loads(report_json)
    assert "summary" in data
    assert data["summary"]["very_outdated_count"] == 1
    assert data["summary"]["missing_count"] == 1
    assert "very_outdated" in data
    assert "missing" in data
    print("PASS: test_generate_json_report_structure")


if __name__ == '__main__':
    print("Running dependency_freshness test suite...")
    test_parse_requirements_simple()
    test_parse_requirements_with_specifiers()
    test_parse_requirements_ignores_comments_and_blanks()
    test_get_major_version_normal()
    test_get_major_version_with_rc()
    test_is_more_than_two_majors_behind()
    test_analyze_dependencies_very_outdated()
    test_analyze_dependencies_missing()
    test_analyze_dependencies_up_to_date()
    test_generate_human_report_contains_very_outdated()
    test_generate_json_report_structure()
    print("ALL TESTS PASSED.")