ci: unit: add model tests

Author: elopez

tests/unit/models/__init__.py

@@ -0,0 +1,92 @@
+"""Unit tests for artifact-related domain models."""
+
+from pathlib import Path
+
+import pytest
+
+from solc_select.models.artifacts import SolcArtifact
+from solc_select.models.platforms import Platform
+from solc_select.models.versions import SolcVersion
+
+
+def create_artifact(
+    version: str = "0.8.19",
+    platform: Platform | None = None,
+    checksum_sha256: str = "abc123",
+    checksum_keccak256: str | None = None,
+    download_url: str = "https://example.com/solc",
+) -> SolcArtifact:
+    """Helper to create SolcArtifact with sensible defaults."""
+    if platform is None:
+        platform = Platform("linux", "amd64")
+    return SolcArtifact(
+        version=SolcVersion(version),
+        platform=platform,
+        file_path=Path(f"/tmp/solc-{version}"),
+        download_url=download_url,
+        checksum_sha256=checksum_sha256,
+        checksum_keccak256=checksum_keccak256,
+    )
+
+
+class TestSolcArtifact:
+    """Tests for SolcArtifact domain model."""
+
+    @pytest.mark.parametrize(
+        "version,expected",
+        [
+            ("0.6.12", True),  # Old Windows version - should be ZIP
+            ("0.7.1", True),  # Boundary - still ZIP
+            ("0.7.2", False),  # First non-ZIP version
+            ("0.8.19", False),  # Modern version
+        ],
+    )
+    def test_is_zip_archive_windows(self, version: str, expected: bool) -> None:
+        """Windows ZIP archive detection based on version boundary (0.7.1)."""
+        artifact = create_artifact(version=version, platform=Platform("windows", "amd64"))
+        assert artifact.is_zip_archive == expected
+
+    @pytest.mark.parametrize("os_type", ["linux", "darwin"])
+    def test_is_zip_archive_non_windows(self, os_type: str) -> None:
+        """Non-Windows platforms should never have ZIP archives."""
+        artifact = create_artifact(version="0.6.12", platform=Platform(os_type, "amd64"))
+        assert not artifact.is_zip_archive
+
+    def test_checksum_prefix_removal(self) -> None:
+        """Checksums with 0x prefix should be stripped in __post_init__."""
+        artifact = create_artifact(
+            checksum_sha256="0xabc123def456",
+            checksum_keccak256="0x789xyz",
+        )
+        assert artifact.checksum_sha256 == "abc123def456"
+        assert artifact.checksum_keccak256 == "789xyz"
+
+    def test_get_binary_name_in_zip(self) -> None:
+        """Binary name inside ZIP archives should be solc.exe."""
+        artifact = create_artifact(version="0.6.12", platform=Platform("windows", "amd64"))
+        assert artifact.get_binary_name_in_zip() == "solc.exe"
+
+    def test_get_binary_name_in_zip_raises_for_non_zip(self) -> None:
+        """Calling get_binary_name_in_zip on non-ZIP should raise ValueError."""
+        artifact = create_artifact(version="0.8.19", platform=Platform("windows", "amd64"))
+        with pytest.raises(ValueError, match="Not a ZIP archive"):
+            artifact.get_binary_name_in_zip()
+
+    @pytest.mark.parametrize(
+        "download_url,checksum,error_msg",
+        [
+            ("", "abc123", "Download URL cannot be empty"),
+            ("https://example.com", "", "SHA256 checksum cannot be empty"),
+        ],
+    )
+    def test_validation_errors(self, download_url: str, checksum: str, error_msg: str) -> None:
+        """Empty URL or checksum should raise ValueError."""
+        with pytest.raises(ValueError, match=error_msg):
+            SolcArtifact(
+                version=SolcVersion("0.8.19"),
+                platform=Platform("linux", "amd64"),
+                file_path=Path("/tmp/solc-0.8.19"),
+                download_url=download_url,
+                checksum_sha256=checksum,
+                checksum_keccak256=None,
+            )

tests/unit/models/test_artifacts.py

@@ -0,0 +1,95 @@
+"""Unit tests for version-related domain models."""
+
+import pytest
+
+from solc_select.models.versions import SolcVersion, VersionRange
+
+
+class TestVersionRange:
+    """Tests for VersionRange domain model."""
+
+    @pytest.mark.parametrize(
+        "version,expected",
+        [
+            ("0.8.10", True),  # Within bounds
+            ("0.8.0", True),  # Exact minimum (inclusive)
+            ("0.8.20", True),  # Exact maximum (inclusive)
+            ("0.7.6", False),  # Below minimum
+            ("0.8.21", False),  # Above maximum
+        ],
+    )
+    def test_contains_bounded_range(self, version: str, expected: bool) -> None:
+        """VersionRange with both bounds should be inclusive [min, max]."""
+        version_range = VersionRange(
+            min_version=SolcVersion("0.8.0"),
+            max_version=SolcVersion("0.8.20"),
+        )
+        assert version_range.contains(SolcVersion(version)) == expected
+
+    def test_contains_unbounded_min(self) -> None:
+        """None as minimum means no lower bound."""
+        version_range = VersionRange(min_version=None, max_version=SolcVersion("0.8.20"))
+        assert version_range.contains(SolcVersion("0.4.0"))
+        assert version_range.contains(SolcVersion("0.8.20"))
+        assert not version_range.contains(SolcVersion("0.8.21"))
+
+    def test_contains_unbounded_max(self) -> None:
+        """None as maximum means no upper bound."""
+        version_range = VersionRange(min_version=SolcVersion("0.8.0"), max_version=None)
+        assert version_range.contains(SolcVersion("0.8.0"))
+        assert version_range.contains(SolcVersion("0.9.0"))
+        assert not version_range.contains(SolcVersion("0.7.6"))
+
+    def test_contains_unbounded_both(self) -> None:
+        """None for both means all versions are valid."""
+        version_range = VersionRange(min_version=None, max_version=None)
+        assert version_range.contains(SolcVersion("0.4.0"))
+        assert version_range.contains(SolcVersion("0.9.0"))
+
+    def test_from_min_factory(self) -> None:
+        """Creates open-ended range [min, infinity)."""
+        version_range = VersionRange.from_min("0.8.5")
+        assert version_range.min_version == SolcVersion("0.8.5")
+        assert version_range.max_version is None
+        assert version_range.contains(SolcVersion("0.8.5"))
+        assert not version_range.contains(SolcVersion("0.8.4"))
+
+    def test_exact_range_factory(self) -> None:
+        """Creates closed range [min, max]."""
+        version_range = VersionRange.exact_range("0.8.5", "0.8.23")
+        assert version_range.min_version == SolcVersion("0.8.5")
+        assert version_range.max_version == SolcVersion("0.8.23")
+        assert version_range.contains(SolcVersion("0.8.5"))
+        assert version_range.contains(SolcVersion("0.8.23"))
+        assert not version_range.contains(SolcVersion("0.8.4"))
+        assert not version_range.contains(SolcVersion("0.8.24"))
+
+
+class TestSolcVersion:
+    """Tests for SolcVersion domain model."""
+
+    def test_parse_valid_version(self) -> None:
+        """Parse valid version string."""
+        version = SolcVersion.parse("0.8.19")
+        assert version == SolcVersion("0.8.19")
+        assert isinstance(version, SolcVersion)
+
+    def test_parse_latest_raises_error(self) -> None:
+        """Parse 'latest' should raise ValueError with clear message."""
+        with pytest.raises(ValueError) as exc_info:
+            SolcVersion.parse("latest")
+        assert "Cannot parse 'latest'" in str(exc_info.value)
+        assert "resolve to actual version first" in str(exc_info.value)
+
+    def test_version_comparison(self) -> None:
+        """SolcVersion should support comparison operations."""
+        v1 = SolcVersion("0.8.19")
+        v2 = SolcVersion("0.8.20")
+        v3 = SolcVersion("0.8.19")
+
+        assert v1 < v2
+        assert v2 > v1
+        assert v1 == v3
+        assert v1 <= v3
+        assert v1 >= v3
+        assert v1 != v2