about summary refs log tree commit diff stats
path: root/tests/test_proton_manager.py
diff options
context:
space:
mode:
Diffstat (limited to 'tests/test_proton_manager.py')
-rw-r--r--tests/test_proton_manager.py768
1 files changed, 768 insertions, 0 deletions
diff --git a/tests/test_proton_manager.py b/tests/test_proton_manager.py
new file mode 100644
index 0000000..773d595
--- /dev/null
+++ b/tests/test_proton_manager.py
@@ -0,0 +1,768 @@
+"""Tests for fungus.proton_manager — pure logic helpers.
+
+Covers:
+  - _cache_key
+  - get_arch_asset
+  - get_cache_dir
+  - clear_cache
+  - get_installed_path
+  - remove_path
+  - fetch_releases (via mocked requests.get)
+  - _fetch_with_cache (via mocked requests.get + tmp cache)
+"""
+
+import json
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture()
+def mock_user_config(tmp_path):
+    """Patch PathManager.user_config to return a controlled path.
+
+    Returns the patched config directory path.
+    """
+    from fungus import path_manager as pm
+
+    config_dir = tmp_path / "test_config"
+    config_dir.mkdir()
+
+    original = pm.PathManager.user_config
+    pm.PathManager.user_config = staticmethod(lambda *a: str(config_dir / a[0]) if a else str(config_dir))
+    yield config_dir
+    pm.PathManager.user_config = original
+
+
+@pytest.fixture()
+def mock_compat_path(tmp_path):
+    """Patch STEAM_COMPATIBILITY_PATH to point to a controlled directory.
+
+    Returns (patched_path, original_path).
+    """
+    from fungus import proton_manager as pm
+
+    compat_dir = tmp_path / "compatibilitytools.d"
+    compat_dir.mkdir()
+    original = pm.STEAM_COMPATIBILITY_PATH
+    pm.STEAM_COMPATIBILITY_PATH = compat_dir
+    yield compat_dir
+    pm.STEAM_COMPATIBILITY_PATH = original
+
+
+# ---------------------------------------------------------------------------
+# _cache_key
+# ---------------------------------------------------------------------------
+
+
+class TestCacheKey:
+    """Tests for fungus.proton_manager._cache_key."""
+
+    def test_deterministic(self):
+        """Same URL always produces the same key."""
+        from fungus.proton_manager import _cache_key
+
+        key1 = _cache_key("https://example.com/releases")
+        key2 = _cache_key("https://example.com/releases")
+        assert key1 == key2
+
+    def test_different_urls_different_keys(self):
+        from fungus.proton_manager import _cache_key
+
+        key1 = _cache_key("https://url-a.com/releases")
+        key2 = _cache_key("https://url-b.com/releases")
+        assert key1 != key2
+
+    def test_safe_filename(self):
+        """Key should be a safe filename (prefix + hex hash + .json)."""
+        from fungus.proton_manager import _cache_key
+
+        key = _cache_key("https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases")
+        assert key.startswith("proton-releases-")
+        assert key.endswith(".json")
+        hash_part = key[len("proton-releases-"):-len(".json")]
+        assert all(c in "0123456789abcdef" for c in hash_part)
+        assert len(hash_part) == 16
+
+    def test_empty_url(self):
+        from fungus.proton_manager import _cache_key
+
+        key = _cache_key("")
+        assert key.startswith("proton-releases-")
+
+
+# ---------------------------------------------------------------------------
+# get_arch_asset
+# ---------------------------------------------------------------------------
+
+
+class TestGetArchAsset:
+    """Tests for fungus.proton_manager.get_arch_asset."""
+
+    def _make_asset(self, name, size=1234):
+        return {"name": name, "size": size}
+
+    def test_exact_arch_match(self):
+        """Asset with arch suffix is selected first."""
+        from fungus.proton_manager import get_arch_asset
+
+        assets = [
+            self._make_asset("GE-Proton11-1.tar.gz"),
+            self._make_asset("GE-Proton11-1-x86_64.tar.gz"),
+        ]
+        result = get_arch_asset(assets)
+        assert result is not None
+        assert result["name"] == "GE-Proton11-1-x86_64.tar.gz"
+
+    def test_aarch64_exact_match(self, monkeypatch):
+        """On aarch64, the -aarch64 asset is selected."""
+        from fungus.proton_manager import get_arch_asset
+
+        monkeypatch.setattr("fungus.proton_manager.MACHINE_ARCH", "aarch64")
+        assets = [
+            self._make_asset("GE-Proton11-1.tar.gz"),
+            self._make_asset("GE-Proton11-1-aarch64.tar.gz"),
+        ]
+        result = get_arch_asset(assets)
+        assert result is not None
+        assert result["name"] == "GE-Proton11-1-aarch64.tar.gz"
+
+    def test_default_build_for_x86_64(self, monkeypatch):
+        """On x86_64, the default build (no arch suffix) is selected
+        when no explicit arch match exists."""
+        from fungus.proton_manager import get_arch_asset
+
+        monkeypatch.setattr("fungus.proton_manager.MACHINE_ARCH", "x86_64")
+        assets = [
+            self._make_asset("GE-Proton11-1-aarch64.tar.gz"),
+            self._make_asset("GE-Proton11-1.tar.gz"),
+        ]
+        result = get_arch_asset(assets)
+        assert result is not None
+        assert result["name"] == "GE-Proton11-1.tar.gz"
+
+    def test_default_build_not_selected_when_aarch64_exists(self, monkeypatch):
+        """On x86_64, the default build is NOT selected if an aarch64
+        variant is available (it's a false match)."""
+        from fungus.proton_manager import get_arch_asset
+
+        monkeypatch.setattr("fungus.proton_manager.MACHINE_ARCH", "x86_64")
+        assets = [
+            self._make_asset("GE-Proton11-1-aarch64.tar.gz"),
+        ]
+        result = get_arch_asset(assets)
+        # Falls through to fallback (first tar archive)
+        assert result is not None
+        assert result["name"] == "GE-Proton11-1-aarch64.tar.gz"
+
+    def test_fallback_to_first_tar(self, monkeypatch):
+        """When no arch match, returns the first tar archive."""
+        from fungus.proton_manager import get_arch_asset
+
+        monkeypatch.setattr("fungus.proton_manager.MACHINE_ARCH", "armv7l")
+        assets = [
+            self._make_asset("GE-Proton11-1.tar.gz"),
+            self._make_asset("GE-Proton11-1-x86_64.tar.gz"),
+        ]
+        result = get_arch_asset(assets)
+        assert result is not None
+        assert result["name"] == "GE-Proton11-1.tar.gz"
+
+    def test_no_matching_extensions_returns_none(self):
+        """No tar.gz/tar.xz assets → None."""
+        from fungus.proton_manager import get_arch_asset
+
+        assets = [
+            self._make_asset("GE-Proton11-1.zip"),
+            self._make_asset("GE-Proton11-1.sha256"),
+        ]
+        result = get_arch_asset(assets)
+        assert result is None
+
+    def test_empty_list_returns_none(self):
+        from fungus.proton_manager import get_arch_asset
+
+        result = get_arch_asset([])
+        assert result is None
+
+    def test_tar_xz_extension(self, monkeypatch):
+        """Works with .tar.xz files too."""
+        from fungus.proton_manager import get_arch_asset
+
+        monkeypatch.setattr("fungus.proton_manager.MACHINE_ARCH", "x86_64")
+        assets = [
+            self._make_asset("GE-Proton11-1-x86_64.tar.xz"),
+        ]
+        result = get_arch_asset(assets)
+        assert result is not None
+        assert result["name"] == "GE-Proton11-1-x86_64.tar.xz"
+
+    def test_exact_arch_preferred_over_default(self, monkeypatch):
+        """Explicit arch match is always preferred over default build."""
+        from fungus.proton_manager import get_arch_asset
+
+        monkeypatch.setattr("fungus.proton_manager.MACHINE_ARCH", "x86_64")
+        assets = [
+            self._make_asset("GE-Proton11-1.tar.gz"),
+            self._make_asset("GE-Proton11-1-x86_64.tar.gz"),
+            self._make_asset("GE-Proton11-1-aarch64.tar.gz"),
+        ]
+        result = get_arch_asset(assets)
+        assert result is not None
+        assert result["name"] == "GE-Proton11-1-x86_64.tar.gz"
+
+
+# ---------------------------------------------------------------------------
+# get_cache_dir
+# ---------------------------------------------------------------------------
+
+
+class TestGetCacheDir:
+    """Tests for fungus.proton_manager.get_cache_dir."""
+
+    def test_creates_cache_directory(self, mock_user_config):
+        from fungus.proton_manager import get_cache_dir
+
+        result = get_cache_dir()
+        assert result.exists()
+        assert result.is_dir()
+        assert result.name == "cache"
+
+    def test_returns_correct_path(self, mock_user_config):
+        from fungus.proton_manager import get_cache_dir
+
+        result = get_cache_dir()
+        assert str(result).startswith(str(mock_user_config))
+        assert result.name == "cache"
+
+
+# ---------------------------------------------------------------------------
+# clear_cache
+# ---------------------------------------------------------------------------
+
+
+class TestClearCache:
+    """Tests for fungus.proton_manager.clear_cache."""
+
+    def test_clears_specific_url(self, mock_user_config):
+        from fungus.proton_manager import _cache_key, clear_cache, get_cache_dir
+
+        cache_dir = get_cache_dir()
+        # Create a fake cache file
+        cache_file = cache_dir / _cache_key("https://example.com/releases")
+        cache_file.write_text("{}")
+        assert cache_file.exists()
+
+        clear_cache(["https://example.com/releases"])
+        assert not cache_file.exists()
+
+    def test_clears_all_urls_by_default(self, mock_user_config):
+        """Calling clear_cache() with no args clears all known upstreams."""
+        from fungus.proton_manager import (
+            DEFAULT_UPSTREAM_URLS,
+            _cache_key,
+            clear_cache,
+            get_cache_dir,
+        )
+
+        cache_dir = get_cache_dir()
+        # Create fake cache files for all upstreams
+        for url in DEFAULT_UPSTREAM_URLS:
+            (cache_dir / _cache_key(url)).write_text("{}")
+
+        clear_cache()
+        for url in DEFAULT_UPSTREAM_URLS:
+            assert not (cache_dir / _cache_key(url)).exists()
+
+    def test_clears_nonexistent_file_is_noop(self, mock_user_config):
+        """Clearing a cache file that doesn't exist is a no-op."""
+        from fungus.proton_manager import clear_cache
+
+        # Should not raise
+        clear_cache(["https://nonexistent.com/releases"])
+
+    def test_clears_corrupt_file(self, mock_user_config):
+        """Corrupt cache files are still removed."""
+        from fungus.proton_manager import _cache_key, clear_cache, get_cache_dir
+
+        cache_dir = get_cache_dir()
+        cache_file = cache_dir / _cache_key("https://example.com/releases")
+        cache_file.write_text("not json {{{")
+        assert cache_file.exists()
+
+        clear_cache(["https://example.com/releases"])
+        assert not cache_file.exists()
+
+
+# ---------------------------------------------------------------------------
+# get_installed_path
+# ---------------------------------------------------------------------------
+
+
+class TestGetInstalledPath:
+    """Tests for fungus.proton_manager.get_installed_path."""
+
+    def test_exact_match(self, mock_compat_path):
+        """Existing directory with matching name is returned."""
+        from fungus.proton_manager import get_installed_path
+
+        (mock_compat_path / "GE-Proton11-1").mkdir()
+        result = get_installed_path("GE-Proton11-1")
+        assert str(result).endswith("GE-Proton11-1")
+
+    def test_ends_with_match(self, mock_compat_path):
+        """Directory ending with tag name is matched."""
+        from fungus.proton_manager import get_installed_path
+
+        (mock_compat_path / "my-GE-Proton11-1").mkdir()
+        result = get_installed_path("GE-Proton11-1")
+        assert str(result).endswith("my-GE-Proton11-1")
+
+    def test_proton_prefix_match(self, mock_compat_path):
+        """'proton-11' matches folder ending with 'proton-11' suffix."""
+        from fungus.proton_manager import get_installed_path
+
+        # Folder must end with 'proton-11' for the endswith check to match
+        (mock_compat_path / "my-proton-11").mkdir()
+        result = get_installed_path("proton-11")
+        assert str(result).endswith("my-proton-11")
+
+    def test_no_match_returns_expected_path(self, mock_compat_path):
+        """No matching directory → returns expected path."""
+        from fungus.proton_manager import get_installed_path
+
+        result = get_installed_path("NonExistent")
+        assert str(result).endswith("NonExistent")
+
+    def test_case_insensitive(self, mock_compat_path):
+        """Matching is case-insensitive."""
+        from fungus.proton_manager import get_installed_path
+
+        (mock_compat_path / "ge-proton11-1").mkdir()
+        result = get_installed_path("GE-Proton11-1")
+        assert str(result).endswith("ge-proton11-1")
+
+    def test_empty_compat_dir(self, mock_compat_path):
+        """Empty compatibilitytools.d → returns expected path."""
+        from fungus.proton_manager import get_installed_path
+
+        result = get_installed_path("GE-Proton11-1")
+        assert str(result).endswith("GE-Proton11-1")
+
+
+# ---------------------------------------------------------------------------
+# remove_path
+# ---------------------------------------------------------------------------
+
+
+class TestRemovePath:
+    """Tests for fungus.proton_manager.remove_path."""
+
+    def test_removes_existing_directory(self, tmp_path):
+        from fungus.proton_manager import remove_path
+
+        target = tmp_path / "to_remove"
+        target.mkdir()
+        (target / "file.txt").write_text("data")
+        assert target.exists()
+
+        remove_path(str(target))
+        assert not target.exists()
+
+    def test_noop_on_nonexistent_path(self, tmp_path):
+        """Removing a non-existent path is a no-op."""
+        from fungus.proton_manager import remove_path
+
+        # Should not raise
+        remove_path(str(tmp_path / "does_not_exist"))
+
+    def test_noop_on_empty_string(self):
+        from fungus.proton_manager import remove_path
+
+        # Should not raise
+        remove_path("")
+
+    def test_noop_on_none(self):
+        from fungus.proton_manager import remove_path
+
+        # Should not raise
+        remove_path(None)
+
+
+# ---------------------------------------------------------------------------
+# fetch_releases
+# ---------------------------------------------------------------------------
+
+
+def _mock_response(status_code, json_data):
+    """Create a mock requests.Response."""
+    resp = MagicMock()
+    resp.status_code = status_code
+    resp.json.return_value = json_data
+    return resp
+
+
+def _make_release(tag_name, assets=None):
+    """Create a mock release dict."""
+    if assets is None:
+        assets = []
+    return {
+        "tag_name": tag_name,
+        "assets": assets,
+    }
+
+
+def _make_asset(name):
+    return {"name": name, "size": 1234}
+
+
+class TestFetchReleases:
+    """Tests for fungus.proton_manager.fetch_releases (mocked requests.get)."""
+
+    def _fetch_with_mocked_requests(self, url, responses):
+        """Helper to call fetch_releases with mocked requests.get."""
+        with patch("fungus.proton_manager.requests.get", side_effect=responses):
+            from fungus.proton_manager import fetch_releases
+            return fetch_releases(url)
+
+    def test_single_page_ge_proton(self):
+        """Single page of GE-Proton releases is fetched and filtered."""
+        releases = [
+            _make_release("GE-Proton11-1", [_make_asset("GE-Proton11-1.tar.gz")]),
+            _make_release("GE-Proton10-1", [_make_asset("GE-Proton10-1.tar.gz")]),
+            _make_release("GE-Proton9-11", [_make_asset("GE-Proton9-11.tar.gz")]),
+        ]
+        responses = [_mock_response(200, releases), _mock_response(200, [])]
+
+        result = self._fetch_with_mocked_requests(
+            "https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases",
+            responses,
+        )
+        assert len(result) == 3
+        tags = [r["tag_name"] for r in result]
+        assert "GE-Proton11-1" in tags
+        assert "GE-Proton10-1" in tags
+        assert "GE-Proton9-11" in tags
+
+    def test_skips_old_ge_proton_versions(self):
+        """GE-Proton versions < 9.1 are filtered out."""
+        releases = [
+            _make_release("GE-Proton8-22", [_make_asset("GE-Proton8-22.tar.gz")]),
+            _make_release("GE-Proton9-0", [_make_asset("GE-Proton9-0.tar.gz")]),
+            _make_release("GE-Proton9-1", [_make_asset("GE-Proton9-1.tar.gz")]),
+            _make_release("GE-Proton9-2", [_make_asset("GE-Proton9-2.tar.gz")]),
+        ]
+        responses = [_mock_response(200, releases), _mock_response(200, [])]
+
+        result = self._fetch_with_mocked_requests(
+            "https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases",
+            responses,
+        )
+        assert len(result) == 2
+        tags = [r["tag_name"] for r in result]
+        assert "GE-Proton9-1" in tags
+        assert "GE-Proton9-2" in tags
+
+    def test_skips_non_ge_proton_releases(self):
+        """Non-GE-Proton releases are filtered out."""
+        releases = [
+            _make_release("GE-Proton11-1", [_make_asset("GE-Proton11-1.tar.gz")]),
+            _make_release("SomeOther-1.0", [_make_asset("SomeOther-1.0.tar.gz")]),
+            _make_release("Proton-11.0-1", [_make_asset("Proton-11.0-1.tar.gz")]),
+        ]
+        responses = [_mock_response(200, releases), _mock_response(200, [])]
+
+        result = self._fetch_with_mocked_requests(
+            "https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases",
+            responses,
+        )
+        assert len(result) == 1
+        assert result[0]["tag_name"] == "GE-Proton11-1"
+
+    def test_skips_releases_without_tar_assets(self):
+        """Releases without .tar.gz/.tar.xz assets are filtered out."""
+        releases = [
+            _make_release("GE-Proton11-1", [_make_asset("GE-Proton11-1.zip")]),
+            _make_release("GE-Proton11-2", [_make_asset("GE-Proton11-2.tar.gz")]),
+        ]
+        responses = [_mock_response(200, releases), _mock_response(200, [])]
+
+        result = self._fetch_with_mocked_requests(
+            "https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases",
+            responses,
+        )
+        assert len(result) == 1
+        assert result[0]["tag_name"] == "GE-Proton11-2"
+
+    def test_duplicate_tags_deduplicated(self):
+        """Duplicate tag names are deduplicated (first wins)."""
+        releases = [
+            _make_release("GE-Proton11-1", [_make_asset("GE-Proton11-1.tar.gz")]),
+            _make_release("GE-Proton11-1", [_make_asset("GE-Proton11-1-v2.tar.gz")]),
+        ]
+        responses = [_mock_response(200, releases), _mock_response(200, [])]
+
+        result = self._fetch_with_mocked_requests(
+            "https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases",
+            responses,
+        )
+        assert len(result) == 1
+        assert result[0]["tag_name"] == "GE-Proton11-1"
+
+    def test_etaash_em_releases(self):
+        """EM releases from Etaash-mathamsetty are filtered correctly."""
+        releases = [
+            _make_release("EM-1.0", [_make_asset("EM-1.0.tar.gz")]),
+            _make_release("EM-2.0", [_make_asset("EM-2.0.tar.gz")]),
+            _make_release("Other-1.0", [_make_asset("Other-1.0.tar.gz")]),
+        ]
+        responses = [_mock_response(200, releases), _mock_response(200, [])]
+
+        result = self._fetch_with_mocked_requests(
+            "https://api.github.com/repos/Etaash-mathamsetty/Proton/releases",
+            responses,
+        )
+        assert len(result) == 2
+        tags = [r["tag_name"] for r in result]
+        assert "EM-1.0" in tags
+        assert "EM-2.0" in tags
+
+    def test_rate_limit_raises_error(self):
+        """403 with rate limit message raises RateLimitError."""
+        from fungus.proton_manager import RateLimitError
+
+        rate_limited = _mock_response(
+            403,
+            {"message": "API rate limit exceeded"},
+        )
+        responses = [rate_limited]
+
+        with patch("fungus.proton_manager.requests.get", side_effect=responses):
+            with pytest.raises(RateLimitError, match="rate limit"):
+                from fungus.proton_manager import fetch_releases
+                fetch_releases("https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases")
+
+    def test_empty_response_breaks_loop(self):
+        """Empty response list ends pagination."""
+        responses = [_mock_response(200, []), _mock_response(200, [])]
+
+        result = self._fetch_with_mocked_requests(
+            "https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases",
+            responses,
+        )
+        assert result == []
+
+    def test_two_page_pagination(self):
+        """Multi-page releases are fetched and combined."""
+        page1 = [
+            _make_release("GE-Proton11-1", [_make_asset("GE-Proton11-1.tar.gz")]),
+        ]
+        page2 = [
+            _make_release("GE-Proton10-1", [_make_asset("GE-Proton10-1.tar.gz")]),
+        ]
+        responses = [
+            _mock_response(200, page1),
+            _mock_response(200, page2),
+            _mock_response(200, []),
+        ]
+
+        result = self._fetch_with_mocked_requests(
+            "https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases",
+            responses,
+        )
+        assert len(result) == 2
+
+    def test_non_200_status_breaks_loop(self):
+        """Non-200 status code ends the fetch loop."""
+        responses = [
+            _mock_response(500, {"error": "server error"}),
+        ]
+
+        result = self._fetch_with_mocked_requests(
+            "https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases",
+            responses,
+        )
+        assert result == []
+
+    def test_ge_proton_version_parse_error_skipped(self):
+        """Malformed tag names that can't be parsed are skipped."""
+        releases = [
+            _make_release("GE-Proton", [_make_asset("GE-Proton.tar.gz")]),
+            _make_release("GE-Proton11-1", [_make_asset("GE-Proton11-1.tar.gz")]),
+        ]
+        responses = [_mock_response(200, releases), _mock_response(200, [])]
+
+        result = self._fetch_with_mocked_requests(
+            "https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases",
+            responses,
+        )
+        assert len(result) == 1
+        assert result[0]["tag_name"] == "GE-Proton11-1"
+
+
+# ---------------------------------------------------------------------------
+# _fetch_with_cache
+# ---------------------------------------------------------------------------
+
+
+class TestFetchWithCache:
+    """Tests for fungus.proton_manager._fetch_with_cache."""
+
+    def _fetch_with_mocked_requests(self, url, cache_dir, responses):
+        """Helper to call _fetch_with_cache with mocked requests.get."""
+        with patch("fungus.proton_manager.requests.get", side_effect=responses):
+            from fungus.proton_manager import _fetch_with_cache
+            return _fetch_with_cache(url, cache_dir=cache_dir)
+
+    def test_cache_hit_returns_cached_data(self, tmp_path):
+        """Valid cached data is returned without calling network."""
+        cache_dir = tmp_path / "cache"
+        cache_dir.mkdir()
+
+        from fungus.proton_manager import _cache_key
+
+        cached_data = [
+            {"tag_name": "GE-Proton11-1", "assets": []},
+        ]
+        cache_file = cache_dir / _cache_key("https://example.com/releases")
+        import time
+        cache_file.write_text(json.dumps({"time": time.time(), "data": cached_data}))
+
+        # requests.get should NOT be called
+        with patch("fungus.proton_manager.requests.get") as mock_get:
+            result = self._fetch_with_mocked_requests(
+                "https://example.com/releases", cache_dir, []
+            )
+
+        assert result == cached_data
+        mock_get.assert_not_called()
+
+    def test_cache_expired_fetches_fresh(self, tmp_path):
+        """Expired cached data triggers a fresh fetch."""
+        import time
+
+        cache_dir = tmp_path / "cache"
+        cache_dir.mkdir()
+
+        from fungus.proton_manager import _cache_key, CACHE_TTL
+
+        cache_file = cache_dir / _cache_key("https://example.com/releases")
+        cache_file.write_text(
+            json.dumps({"time": time.time() - CACHE_TTL - 100, "data": []})
+        )
+
+        # Must include tar.gz asset so fetch_releases doesn't filter it out
+        fresh_data = [
+            {"tag_name": "GE-Proton11-1", "assets": [{"name": "GE-Proton11-1.tar.gz"}]},
+        ]
+        # fetch_releases calls requests.get twice (pagination loop: page 1 + empty page 2)
+        responses = [
+            _mock_response(200, fresh_data),
+            _mock_response(200, []),
+        ]
+
+        result = self._fetch_with_mocked_requests(
+            "https://example.com/releases", cache_dir, responses
+        )
+        assert result == fresh_data
+
+    def test_corrupt_cache_ignored(self, tmp_path):
+        """Corrupt cache file is ignored and fresh data is fetched."""
+        cache_dir = tmp_path / "cache"
+        cache_dir.mkdir()
+
+        from fungus.proton_manager import _cache_key
+
+        cache_file = cache_dir / _cache_key("https://example.com/releases")
+        cache_file.write_text("not valid json {{{")
+
+        # Must include tar.gz asset so fetch_releases doesn't filter it out
+        fresh_data = [
+            {"tag_name": "GE-Proton11-1", "assets": [{"name": "GE-Proton11-1.tar.gz"}]},
+        ]
+        # fetch_releases calls requests.get twice (pagination loop)
+        responses = [
+            _mock_response(200, fresh_data),
+            _mock_response(200, []),
+        ]
+
+        result = self._fetch_with_mocked_requests(
+            "https://example.com/releases", cache_dir, responses
+        )
+        assert result == fresh_data
+
+    def test_cache_miss_fetches_fresh(self, tmp_path):
+        """No cache file → fresh fetch."""
+        cache_dir = tmp_path / "cache"
+        cache_dir.mkdir()
+
+        # Must include tar.gz asset so fetch_releases doesn't filter it out
+        fresh_data = [
+            {"tag_name": "GE-Proton11-1", "assets": [{"name": "GE-Proton11-1.tar.gz"}]},
+        ]
+        # fetch_releases calls requests.get twice (pagination loop)
+        responses = [
+            _mock_response(200, fresh_data),
+            _mock_response(200, []),
+        ]
+
+        result = self._fetch_with_mocked_requests(
+            "https://example.com/releases", cache_dir, responses
+        )
+        assert result == fresh_data
+
+    def test_cache_write_after_fetch(self, tmp_path):
+        """Fetched data is saved to cache."""
+        cache_dir = tmp_path / "cache"
+        cache_dir.mkdir()
+
+        # Must include tar.gz asset so fetch_releases doesn't filter it out
+        fresh_data = [
+            {"tag_name": "GE-Proton11-1", "assets": [{"name": "GE-Proton11-1.tar.gz"}]},
+        ]
+        # fetch_releases calls requests.get twice (pagination loop)
+        responses = [
+            _mock_response(200, fresh_data),
+            _mock_response(200, []),
+        ]
+
+        self._fetch_with_mocked_requests(
+            "https://example.com/releases", cache_dir, responses
+        )
+
+        from fungus.proton_manager import _cache_key
+        cache_file = cache_dir / _cache_key("https://example.com/releases")
+        assert cache_file.exists()
+        data = json.loads(cache_file.read_text())
+        assert data["data"] == fresh_data
+
+    def test_cache_read_error_continues(self, tmp_path):
+        """KeyError on cache read falls through to fetch."""
+        cache_dir = tmp_path / "cache"
+        cache_dir.mkdir()
+
+        from fungus.proton_manager import _cache_key
+
+        # Valid JSON but missing 'data' key → KeyError → falls through
+        cache_file = cache_dir / _cache_key("https://example.com/releases")
+        cache_file.write_text('{"time": 0}')
+
+        # Must include tar.gz asset so fetch_releases doesn't filter it out
+        fresh_data = [
+            {"tag_name": "GE-Proton11-1", "assets": [{"name": "GE-Proton11-1.tar.gz"}]},
+        ]
+        # fetch_releases calls requests.get twice (pagination loop)
+        responses = [
+            _mock_response(200, fresh_data),
+            _mock_response(200, []),
+        ]
+
+        result = self._fetch_with_mocked_requests(
+            "https://example.com/releases", cache_dir, responses
+        )
+        assert result == fresh_data