"""Tests for dependency resolver."""
|
|
import pytest
|
from unittest.mock import AsyncMock, patch
|
|
from archrepobuild.resolver import DependencyResolver, Dependency, DependencyType, BuildOrder
|
|
|
class TestDependency:
|
"""Tests for Dependency class."""
|
|
def test_parse_simple(self):
|
"""Test parsing simple dependency name."""
|
dep = Dependency.parse("packagename")
|
assert dep.name == "packagename"
|
assert dep.version_constraint is None
|
assert dep.dep_type == DependencyType.RUNTIME
|
|
def test_parse_with_gte(self):
|
"""Test parsing with >= constraint."""
|
dep = Dependency.parse("package>=1.0")
|
assert dep.name == "package"
|
assert dep.version_constraint == ">=1.0"
|
|
def test_parse_with_lte(self):
|
"""Test parsing with <= constraint."""
|
dep = Dependency.parse("package<=2.0")
|
assert dep.name == "package"
|
assert dep.version_constraint == "<=2.0"
|
|
def test_parse_build_dep(self):
|
"""Test parsing as build dependency."""
|
dep = Dependency.parse("makedep", DependencyType.BUILD)
|
assert dep.dep_type == DependencyType.BUILD
|
|
|
class TestBuildOrder:
|
"""Tests for BuildOrder class."""
|
|
def test_iteration(self):
|
"""Test BuildOrder iteration."""
|
order = BuildOrder(packages=["a", "b", "c"])
|
assert list(order) == ["a", "b", "c"]
|
|
def test_length(self):
|
"""Test BuildOrder length."""
|
order = BuildOrder(packages=["a", "b"])
|
assert len(order) == 2
|
|
|
class TestDependencyResolver:
|
"""Tests for DependencyResolver."""
|
|
@pytest.fixture
|
def mock_aur_client(self):
|
"""Create mock AUR client."""
|
client = AsyncMock()
|
return client
|
|
def test_topological_sort_simple(self, mock_aur_client):
|
"""Test topological sort with simple graph."""
|
resolver = DependencyResolver(mock_aur_client)
|
|
# A depends on B, B depends on C
|
graph = {
|
"A": {"B"},
|
"B": {"C"},
|
"C": set(),
|
}
|
|
order = resolver._topological_sort(graph)
|
|
# C must come before B, B must come before A
|
assert order.index("C") < order.index("B")
|
assert order.index("B") < order.index("A")
|
|
def test_topological_sort_parallel(self, mock_aur_client):
|
"""Test topological sort with parallel dependencies."""
|
resolver = DependencyResolver(mock_aur_client)
|
|
# A depends on B and C (parallel)
|
graph = {
|
"A": {"B", "C"},
|
"B": set(),
|
"C": set(),
|
}
|
|
order = resolver._topological_sort(graph)
|
|
# B and C must come before A
|
assert order.index("B") < order.index("A")
|
assert order.index("C") < order.index("A")
|
|
def test_detect_cycles_no_cycle(self, mock_aur_client):
|
"""Test cycle detection with no cycles."""
|
resolver = DependencyResolver(mock_aur_client)
|
|
graph = {
|
"A": {"B"},
|
"B": {"C"},
|
"C": set(),
|
}
|
|
cycles = resolver.detect_cycles(graph)
|
assert len(cycles) == 0
|
|
def test_detect_cycles_with_cycle(self, mock_aur_client):
|
"""Test cycle detection with cycle."""
|
resolver = DependencyResolver(mock_aur_client)
|
|
# A -> B -> C -> A (cycle)
|
graph = {
|
"A": {"B"},
|
"B": {"C"},
|
"C": {"A"},
|
}
|
|
cycles = resolver.detect_cycles(graph)
|
assert len(cycles) > 0
|
|
@patch("archrepobuild.resolver.subprocess.run")
|
def test_is_in_official_repos(self, mock_run, mock_aur_client):
|
"""Test checking official repos."""
|
mock_run.return_value.returncode = 0
|
mock_run.return_value.stdout = "base\ngit\nvim\n"
|
|
resolver = DependencyResolver(mock_aur_client)
|
resolver._refresh_pacman_cache()
|
|
assert resolver.is_in_official_repos("git")
|
assert not resolver.is_in_official_repos("yay")
|
