about summary refs log tree commit diff stats
path: root/tests
diff options
context:
space:
mode:
authorAndrew Dolgov <fox@fakecake.org>2026-07-05 01:50:14 +0300
committerAndrew Dolgov <fox@fakecake.org>2026-07-05 01:50:14 +0300
commit83a535270f1eb486cdce82a4f9062b49977e8426 (patch)
treee436860e9c76c532f94314639437665f49ad1824 /tests
parent4c86ef68ecaa2abed6c8cc324352e71acae158d8 (diff)
downloadfungus-launcher-83a535270f1eb486cdce82a4f9062b49977e8426.tar.gz
fungus-launcher-83a535270f1eb486cdce82a4f9062b49977e8426.tar.xz
add tests for umu-manager
Diffstat (limited to 'tests')
-rw-r--r--tests/test_umu_manager.py881
1 files changed, 881 insertions, 0 deletions
diff --git a/tests/test_umu_manager.py b/tests/test_umu_manager.py
new file mode 100644
index 0000000..293622c
--- /dev/null
+++ b/tests/test_umu_manager.py
@@ -0,0 +1,881 @@
+"""Tests for fungus.umu_manager — UMU-Launcher installation and update management."""
+
+import io
+import os
+import re
+import subprocess
+import tarfile
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_tar_bytes(version: str = "1.4.0") -> bytes:
+    """Create a tar archive containing ``umu/umu-run`` as bytes."""
+    buf = tempfile.NamedTemporaryFile(suffix=".tar", delete=False)
+    buf.close()
+    with tarfile.open(buf.name, "w:") as tar:
+        data = b"#!/bin/bash\necho umu-run\n"
+        # The source code extracts with tar.extractfile("umu/umu-run")
+        info = tarfile.TarInfo(name="umu/umu-run")
+        info.size = len(data)
+        info.mode = 0o755
+        tar.addfile(info, fileobj=io.BytesIO(data))
+    with open(buf.name, "rb") as f:
+        tar_bytes = f.read()
+    os.remove(buf.name)
+    return tar_bytes
+
+
+def _make_bad_tar_bytes() -> bytes:
+    """Create a tar archive WITHOUT umu/umu-run."""
+    buf = tempfile.NamedTemporaryFile(suffix=".tar", delete=False)
+    buf.close()
+    with tarfile.open(buf.name, "w:") as tar:
+        data = b"wrong content"
+        info = tarfile.TarInfo(name="wrong/path/file.txt")
+        info.size = len(data)
+        tar.addfile(info, fileobj=io.BytesIO(data))
+    with open(buf.name, "rb") as f:
+        tar_bytes = f.read()
+    os.remove(buf.name)
+    return tar_bytes
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture()
+def umu_install_dir(tmp_path):
+    """Provide a temporary UMU install directory and patch module-level constants."""
+    install_dir = tmp_path / "fungus-launcher"
+    install_dir.mkdir()
+
+    with patch("fungus.umu_manager.UMU_INSTALL_DIR", str(install_dir)):
+        with patch("fungus.umu_manager.UMU_VERSION_FILE", str(install_dir / "version.txt")):
+            with patch("fungus.umu_manager.UMU_BIN_PATH", str(install_dir / "umu-run")):
+                with patch("fungus.umu_manager.STEAMRT_CHECK_FILE", str(install_dir / "steamrt.txt")):
+                    yield install_dir
+
+
+@pytest.fixture()
+def mock_requests_get():
+    """Provide a mock for requests.get that can be configured per-test."""
+    with patch("fungus.umu_manager.requests.get") as mock_get:
+        yield mock_get
+
+
+@pytest.fixture()
+def fake_proton_path(umu_install_dir):
+    """Create a fake Proton directory under the temp data dir.
+
+    The update_steam_runtime function builds the proton path from XDG_DATA_HOME
+    (or ~/.local/share).  We patch that so the directory exists under tmp_path.
+    """
+    share_dir = umu_install_dir / "Steam" / "compatibilitytools.d"
+    share_dir.mkdir(parents=True, exist_ok=True)
+
+    with patch.dict(os.environ, {"XDG_DATA_HOME": str(umu_install_dir)}):
+        yield share_dir
+
+
+# ---------------------------------------------------------------------------
+# Test get_umu_run_path
+# ---------------------------------------------------------------------------
+
+
+class TestGetUmuRunPath:
+    def test_returns_path_from_constants(self):
+        """get_umu_run_path should return the umu_run path from constants."""
+        from fungus.umu_manager import get_umu_run_path
+
+        with patch("fungus.constants.umu_run", Path("/custom/path/umu-run")):
+            result = get_umu_run_path()
+            assert result == "/custom/path/umu-run"
+
+    def test_returns_string(self):
+        """The result should be a string, not a Path object."""
+        from fungus.umu_manager import get_umu_run_path
+
+        with patch("fungus.constants.umu_run", Path("/some/path")):
+            result = get_umu_run_path()
+            assert isinstance(result, str)
+
+
+# ---------------------------------------------------------------------------
+# Test get_latest_umu_version
+# ---------------------------------------------------------------------------
+
+
+class TestGetLatestUmuVersion:
+    def test_returns_tag_on_success(self, mock_requests_get):
+        """Should return the tag_name from the first release."""
+        from fungus.umu_manager import get_latest_umu_version
+
+        mock_requests_get.return_value = MagicMock(
+            status_code=200,
+            json=lambda: [{"tag_name": "1.4.0"}],
+            text="ok",
+        )
+
+        result = get_latest_umu_version()
+        assert result == "1.4.0"
+
+    def test_returns_none_on_empty_releases(self, mock_requests_get):
+        """Should return None when the releases list is empty."""
+        from fungus.umu_manager import get_latest_umu_version
+
+        mock_requests_get.return_value = MagicMock(
+            status_code=200,
+            json=lambda: [],
+            text="",
+        )
+
+        result = get_latest_umu_version()
+        assert result is None
+
+    def test_returns_none_on_non_200_status(self, mock_requests_get):
+        """Should return None when the API returns a non-200 status."""
+        from fungus.umu_manager import get_latest_umu_version
+
+        mock_requests_get.return_value = MagicMock(
+            status_code=403,
+            json=lambda: [],
+            text="forbidden",
+        )
+
+        result = get_latest_umu_version()
+        assert result is None
+
+    def test_returns_none_on_request_exception(self, mock_requests_get):
+        """Should return None when requests.get raises an exception."""
+        from fungus.umu_manager import get_latest_umu_version
+
+        mock_requests_get.side_effect = Exception("network error")
+
+        result = get_latest_umu_version()
+        assert result is None
+
+    def test_calls_api_with_timeout(self, mock_requests_get):
+        """Should pass a timeout to requests.get."""
+        from fungus.umu_manager import get_latest_umu_version
+
+        mock_requests_get.return_value = MagicMock(
+            status_code=200,
+            json=lambda: [{"tag_name": "1.0.0"}],
+            text="ok",
+        )
+
+        get_latest_umu_version()
+        mock_requests_get.assert_called_once()
+        call_kwargs = mock_requests_get.call_args[1]
+        assert call_kwargs.get("timeout") == 5
+
+
+# ---------------------------------------------------------------------------
+# Test get_installed_umu_version
+# ---------------------------------------------------------------------------
+
+
+class TestGetInstalledUmuVersion:
+    def test_returns_version_from_file(self, umu_install_dir):
+        """Should return the version string from the version file."""
+        version_file = umu_install_dir / "version.txt"
+        version_file.write_text("1.4.0", encoding="utf-8")
+
+        from fungus.umu_manager import get_installed_umu_version
+
+        result = get_installed_umu_version()
+        assert result == "1.4.0"
+
+    def test_strips_whitespace(self, umu_install_dir):
+        """Should strip leading/trailing whitespace from the version file."""
+        version_file = umu_install_dir / "version.txt"
+        version_file.write_text("  1.3.0  \n", encoding="utf-8")
+
+        from fungus.umu_manager import get_installed_umu_version
+
+        result = get_installed_umu_version()
+        assert result == "1.3.0"
+
+    def test_returns_none_when_file_missing(self, umu_install_dir):
+        """Should return None when the version file does not exist."""
+        from fungus.umu_manager import get_installed_umu_version
+
+        result = get_installed_umu_version()
+        assert result is None
+
+
+# ---------------------------------------------------------------------------
+# Test is_umu_installed
+# ---------------------------------------------------------------------------
+
+
+class TestIsUmuInstalled:
+    def test_returns_true_when_binary_exists_and_executable(self, umu_install_dir):
+        """Should return True when the binary exists and is executable."""
+        bin_path = umu_install_dir / "umu-run"
+        bin_path.write_text("#!/bin/bash\necho hello\n", encoding="utf-8")
+        bin_path.chmod(0o755)
+
+        from fungus.umu_manager import is_umu_installed
+
+        assert is_umu_installed() is True
+
+    def test_returns_false_when_binary_missing(self, umu_install_dir):
+        """Should return False when the binary does not exist."""
+        from fungus.umu_manager import is_umu_installed
+
+        assert is_umu_installed() is False
+
+    def test_returns_false_when_not_executable(self, umu_install_dir):
+        """Should return False when the binary exists but is not executable."""
+        bin_path = umu_install_dir / "umu-run"
+        bin_path.write_text("#!/bin/bash\necho hello\n", encoding="utf-8")
+        bin_path.chmod(0o644)
+
+        from fungus.umu_manager import is_umu_installed
+
+        assert is_umu_installed() is False
+
+
+# ---------------------------------------------------------------------------
+# Test get_steamrt_last_check
+# ---------------------------------------------------------------------------
+
+
+class TestGetSteamrtLastCheck:
+    def test_returns_timestamp_from_file(self, umu_install_dir):
+        """Should return the timestamp string from the file."""
+        check_file = umu_install_dir / "steamrt.txt"
+        check_file.write_text("2025-07-01 14:30", encoding="utf-8")
+
+        from fungus.umu_manager import get_steamrt_last_check
+
+        result = get_steamrt_last_check()
+        assert result == "2025-07-01 14:30"
+
+    def test_returns_none_when_file_missing(self, umu_install_dir):
+        """Should return None when the check file does not exist."""
+        from fungus.umu_manager import get_steamrt_last_check
+
+        result = get_steamrt_last_check()
+        assert result is None
+
+    def test_returns_none_when_file_empty(self, umu_install_dir):
+        """Should return None when the file exists but is empty."""
+        check_file = umu_install_dir / "steamrt.txt"
+        check_file.write_text("", encoding="utf-8")
+
+        from fungus.umu_manager import get_steamrt_last_check
+
+        result = get_steamrt_last_check()
+        assert result is None
+
+    def test_returns_none_on_os_error(self, umu_install_dir):
+        """Should return None when reading the file raises an OSError."""
+        check_file = umu_install_dir / "steamrt.txt"
+        check_file.write_text("2025-07-01 14:30", encoding="utf-8")
+
+        with patch("builtins.open", side_effect=OSError("permission denied")):
+            from fungus.umu_manager import get_steamrt_last_check
+            result = get_steamrt_last_check()
+            assert result is None
+
+
+# ---------------------------------------------------------------------------
+# Test save_steamrt_last_check
+# ---------------------------------------------------------------------------
+
+
+class TestSaveSteamrtLastCheck:
+    def test_writes_timestamp_and_returns_true(self, umu_install_dir):
+        """Should write a timestamp and return True on success."""
+        from fungus.umu_manager import save_steamrt_last_check
+
+        result = save_steamrt_last_check()
+        assert result is True
+
+        check_file = umu_install_dir / "steamrt.txt"
+        assert check_file.exists()
+        content = check_file.read_text(encoding="utf-8").strip()
+        # Should match YYYY-MM-DD HH:MM format
+        assert re.match(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}", content)
+
+    def test_creates_directory_if_missing(self, umu_install_dir):
+        """Should create the install directory if it does not exist."""
+        import shutil
+        shutil.rmtree(umu_install_dir)
+
+        with patch("fungus.umu_manager.UMU_INSTALL_DIR", str(umu_install_dir)):
+            with patch("fungus.umu_manager.STEAMRT_CHECK_FILE", str(umu_install_dir / "steamrt.txt")):
+                from fungus.umu_manager import save_steamrt_last_check
+                result = save_steamrt_last_check()
+                assert result is True
+                assert umu_install_dir.exists()
+
+    def test_returns_false_on_os_error(self, umu_install_dir):
+        """Should return False when writing raises an OSError."""
+        with patch("builtins.open", side_effect=OSError("permission denied")):
+            with patch("os.makedirs", side_effect=OSError("permission denied")):
+                from fungus.umu_manager import save_steamrt_last_check
+                result = save_steamrt_last_check()
+                assert result is False
+
+
+# ---------------------------------------------------------------------------
+# Test download_umu_run
+# ---------------------------------------------------------------------------
+
+
+class TestDownloadUmuRun:
+    def test_successful_download_and_install(self, umu_install_dir, mock_requests_get):
+        """Should download, extract, and install umu-run successfully."""
+        tar_bytes = _make_tar_bytes()
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-length": str(len(tar_bytes))}
+        mock_response.iter_content.return_value = [tar_bytes]
+        mock_requests_get.return_value = mock_response
+
+        from fungus.umu_manager import download_umu_run
+
+        result = download_umu_run("1.4.0")
+        assert result is True
+
+        bin_path = umu_install_dir / "umu-run"
+        assert bin_path.exists()
+        assert os.access(str(bin_path), os.X_OK)
+
+        version_file = umu_install_dir / "version.txt"
+        assert version_file.read_text(encoding="utf-8").strip() == "1.4.0"
+
+    def test_returns_false_on_non_200_response(self, umu_install_dir, mock_requests_get):
+        """Should return False when the download returns a non-200 status."""
+        mock_requests_get.return_value = MagicMock(
+            status_code=404,
+            headers={},
+            text="not found",
+        )
+
+        from fungus.umu_manager import download_umu_run
+
+        result = download_umu_run("9.9.9")
+        assert result is False
+
+    def test_returns_false_on_request_exception(self, umu_install_dir, mock_requests_get):
+        """Should return False when the download request fails."""
+        mock_requests_get.side_effect = Exception("connection refused")
+
+        from fungus.umu_manager import download_umu_run
+
+        result = download_umu_run("1.4.0")
+        assert result is False
+
+    def test_returns_false_when_tar_missing_member(self, umu_install_dir, mock_requests_get):
+        """Should return False when the tar archive doesn't contain umu/umu-run."""
+        tar_bytes = _make_bad_tar_bytes()
+
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-length": str(len(tar_bytes))}
+        mock_response.iter_content.return_value = [tar_bytes]
+        mock_requests_get.return_value = mock_response
+
+        from fungus.umu_manager import download_umu_run
+
+        result = download_umu_run("1.4.0")
+        assert result is False
+
+    def test_calls_progress_callback(self, umu_install_dir, mock_requests_get):
+        """Should call the progress callback with percentage values."""
+        tar_bytes = _make_tar_bytes()
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-length": str(len(tar_bytes))}
+        mock_response.iter_content.return_value = [tar_bytes]
+        mock_requests_get.return_value = mock_response
+
+        callback = MagicMock()
+
+        from fungus.umu_manager import download_umu_run
+
+        download_umu_run("1.4.0", progress_callback=callback)
+
+        callback.assert_called()
+        # Should have been called with 100 at the end
+        calls = [c[0][0] for c in callback.call_args_list]
+        assert 100 in calls
+
+    def test_returns_false_on_chmod_failure(self, umu_install_dir, mock_requests_get):
+        """Should return False if setting executable permission fails."""
+        tar_bytes = _make_tar_bytes()
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-length": str(len(tar_bytes))}
+        mock_response.iter_content.return_value = [tar_bytes]
+        mock_requests_get.return_value = mock_response
+
+        with patch("os.chmod", side_effect=OSError("permission denied")):
+            from fungus.umu_manager import download_umu_run
+            result = download_umu_run("1.4.0")
+            assert result is False
+
+    def test_returns_false_on_version_file_write_failure(self, umu_install_dir, mock_requests_get):
+        """Should return False if writing the version file fails."""
+        tar_bytes = _make_tar_bytes()
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-length": str(len(tar_bytes))}
+        mock_response.iter_content.return_value = [tar_bytes]
+        mock_requests_get.return_value = mock_response
+
+        # Patch only the open call that writes the version file
+        original_open = open
+        def failing_open(*args, **kwargs):
+            if args and "version.txt" in str(args[0]):
+                raise OSError("disk full")
+            return original_open(*args, **kwargs)
+
+        with patch("builtins.open", failing_open):
+            from fungus.umu_manager import download_umu_run
+            result = download_umu_run("1.4.0")
+            assert result is False
+
+    def test_creates_install_directory(self, umu_install_dir, mock_requests_get):
+        """Should create the install directory if it doesn't exist."""
+        import shutil
+        shutil.rmtree(umu_install_dir)
+
+        tar_bytes = _make_tar_bytes()
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-length": str(len(tar_bytes))}
+        mock_response.iter_content.return_value = [tar_bytes]
+        mock_requests_get.return_value = mock_response
+
+        from fungus.umu_manager import download_umu_run
+        result = download_umu_run("1.4.0")
+        assert result is True
+        assert umu_install_dir.exists()
+
+    def test_cleans_up_temp_file_on_failure(self, umu_install_dir, mock_requests_get):
+        """Should clean up the temporary download file on failure."""
+        mock_requests_get.return_value = MagicMock(status_code=404, headers={}, text="not found")
+
+        from fungus.umu_manager import download_umu_run
+
+        download_umu_run("9.9.9")
+
+        # No temp files should remain in /tmp matching our pattern
+        # (hard to verify precisely, but at least it shouldn't crash)
+
+
+# ---------------------------------------------------------------------------
+# Test check_and_install_if_needed
+# ---------------------------------------------------------------------------
+
+
+class TestCheckAndInstallIfNeeded:
+    def test_up_to_date(self, umu_install_dir):
+        """Should return (True, 'up_to_date') when already at the latest version."""
+        bin_path = umu_install_dir / "umu-run"
+        bin_path.write_text("#!/bin/bash\n", encoding="utf-8")
+        bin_path.chmod(0o755)
+        (umu_install_dir / "version.txt").write_text("1.4.0", encoding="utf-8")
+
+        with patch("fungus.umu_manager.get_latest_umu_version", return_value="1.4.0"):
+            from fungus.umu_manager import check_and_install_if_needed
+
+            result = check_and_install_if_needed()
+            assert result == (True, "up_to_date")
+
+    def test_updates_when_outdated(self, umu_install_dir, mock_requests_get):
+        """Should download and update when a newer version is available."""
+        bin_path = umu_install_dir / "umu-run"
+        bin_path.write_text("#!/bin/bash\n", encoding="utf-8")
+        bin_path.chmod(0o755)
+        (umu_install_dir / "version.txt").write_text("1.3.0", encoding="utf-8")
+
+        tar_bytes = _make_tar_bytes("1.4.0")
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-length": str(len(tar_bytes))}
+        mock_response.iter_content.return_value = [tar_bytes]
+        mock_requests_get.return_value = mock_response
+
+        with patch("fungus.umu_manager.get_latest_umu_version", return_value="1.4.0"):
+            from fungus.umu_manager import check_and_install_if_needed
+
+            result = check_and_install_if_needed()
+            assert result[1] == "updated"
+            assert result[0] is True
+
+    def test_installs_when_not_installed(self, umu_install_dir, mock_requests_get):
+        """Should download and install when umu-run is not present."""
+        tar_bytes = _make_tar_bytes("1.4.0")
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-length": str(len(tar_bytes))}
+        mock_response.iter_content.return_value = [tar_bytes]
+        mock_requests_get.return_value = mock_response
+
+        with patch("fungus.umu_manager.get_latest_umu_version", return_value="1.4.0"):
+            from fungus.umu_manager import check_and_install_if_needed
+
+            result = check_and_install_if_needed()
+            assert result[1] == "installed"
+            assert result[0] is True
+
+    def test_returns_failed_when_latest_version_fetch_fails(self, umu_install_dir):
+        """Should return (False, 'failed') when the version API is unreachable."""
+        with patch("fungus.umu_manager.get_latest_umu_version", return_value=None):
+            from fungus.umu_manager import check_and_install_if_needed
+
+            result = check_and_install_if_needed()
+            assert result == (False, "failed")
+
+    def test_returns_failed_when_update_download_fails(self, umu_install_dir, mock_requests_get):
+        """Should return (False, 'failed') when the download fails during update."""
+        bin_path = umu_install_dir / "umu-run"
+        bin_path.write_text("#!/bin/bash\n", encoding="utf-8")
+        bin_path.chmod(0o755)
+        (umu_install_dir / "version.txt").write_text("1.3.0", encoding="utf-8")
+
+        mock_requests_get.return_value = MagicMock(status_code=404, headers={}, text="not found")
+
+        with patch("fungus.umu_manager.get_latest_umu_version", return_value="1.4.0"):
+            from fungus.umu_manager import check_and_install_if_needed
+
+            result = check_and_install_if_needed()
+            assert result == (False, "failed")
+
+    def test_returns_failed_when_install_download_fails(self, umu_install_dir, mock_requests_get):
+        """Should return (False, 'failed') when the download fails during install."""
+        mock_requests_get.return_value = MagicMock(status_code=404, headers={}, text="not found")
+
+        with patch("fungus.umu_manager.get_latest_umu_version", return_value="1.4.0"):
+            from fungus.umu_manager import check_and_install_if_needed
+
+            result = check_and_install_if_needed()
+            assert result == (False, "failed")
+
+    def test_returns_failed_when_latest_api_returns_none_during_update(self, umu_install_dir):
+        """Should return (False, 'failed') when API returns None during update check."""
+        bin_path = umu_install_dir / "umu-run"
+        bin_path.write_text("#!/bin/bash\n", encoding="utf-8")
+        bin_path.chmod(0o755)
+        (umu_install_dir / "version.txt").write_text("1.3.0", encoding="utf-8")
+
+        with patch("fungus.umu_manager.get_latest_umu_version", return_value=None):
+            from fungus.umu_manager import check_and_install_if_needed
+
+            result = check_and_install_if_needed()
+            assert result == (False, "failed")
+
+    def test_calls_progress_callback_on_update(self, umu_install_dir, mock_requests_get):
+        """Progress callback should be forwarded during update."""
+        bin_path = umu_install_dir / "umu-run"
+        bin_path.write_text("#!/bin/bash\n", encoding="utf-8")
+        bin_path.chmod(0o755)
+        (umu_install_dir / "version.txt").write_text("1.3.0", encoding="utf-8")
+
+        tar_bytes = _make_tar_bytes("1.4.0")
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-length": str(len(tar_bytes))}
+        mock_response.iter_content.return_value = [tar_bytes]
+        mock_requests_get.return_value = mock_response
+
+        callback = MagicMock()
+
+        with patch("fungus.umu_manager.get_latest_umu_version", return_value="1.4.0"):
+            from fungus.umu_manager import check_and_install_if_needed
+
+            check_and_install_if_needed(progress_callback=callback)
+
+            callback.assert_called()
+
+    def test_calls_progress_callback_on_install(self, umu_install_dir, mock_requests_get):
+        """Progress callback should be forwarded during initial install."""
+        tar_bytes = _make_tar_bytes("1.4.0")
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-length": str(len(tar_bytes))}
+        mock_response.iter_content.return_value = [tar_bytes]
+        mock_requests_get.return_value = mock_response
+
+        callback = MagicMock()
+
+        with patch("fungus.umu_manager.get_latest_umu_version", return_value="1.4.0"):
+            from fungus.umu_manager import check_and_install_if_needed
+
+            check_and_install_if_needed(progress_callback=callback)
+
+            callback.assert_called()
+
+
+# ---------------------------------------------------------------------------
+# Test update_steam_runtime
+# ---------------------------------------------------------------------------
+
+
+class TestUpdateSteamRuntime:
+    def test_returns_error_when_proton_path_not_found(self):
+        """Should return an error when the Proton directory does not exist."""
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            from fungus.umu_manager import update_steam_runtime
+
+            result = update_steam_runtime("Proton-9.0")
+            assert result[0] is False
+            assert "Proton path not found" in result[1]
+
+    def test_runs_wineprefixcreate_command(self, umu_install_dir, fake_proton_path):
+        """Should run umu-run with wineprefixcreate and correct env vars."""
+        (fake_proton_path / "Proton-9.0").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["Already up to date\n"])
+        mock_proc.wait.return_value = 0
+        mock_proc.returncode = 0
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                result = update_steam_runtime("Proton-9.0")
+                assert result[0] is True
+                assert result[1] == "Already up to date"
+
+                subprocess.Popen.assert_called_once()  # pyright: ignore[reportAttributeAccessIssue]
+                call_args = subprocess.Popen.call_args  # pyright: ignore[reportAttributeAccessIssue]
+                cmd = call_args[0][0]
+                assert cmd[0] == "/fake/umu-run"
+                assert "wineprefixcreate" in cmd
+                assert "/usr/bin/true" in cmd
+
+    def test_sets_proton_version_env(self, umu_install_dir, fake_proton_path):
+        """Should set PROTONVERSION env var for Proton 9.x."""
+        (fake_proton_path / "Proton-9.0").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["Done\n"])
+        mock_proc.wait.return_value = 0
+        mock_proc.returncode = 0
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                update_steam_runtime("Proton-9.0")
+
+                call_kwargs = subprocess.Popen.call_args[1]  # pyright: ignore[reportAttributeAccessIssue]
+                env = call_kwargs["env"]
+                assert env.get("PROTONVERSION") == "9"
+
+    def test_sets_proton_version_env_for_proton_11(self, umu_install_dir, fake_proton_path):
+        """Should set PROTONVERSION for Proton 11.x."""
+        (fake_proton_path / "Proton-11.0-1").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["Done\n"])
+        mock_proc.wait.return_value = 0
+        mock_proc.returncode = 0
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                update_steam_runtime("Proton-11.0-1")
+
+                call_kwargs = subprocess.Popen.call_args[1]  # pyright: ignore[reportAttributeAccessIssue]
+                env = call_kwargs["env"]
+                assert env.get("PROTONVERSION") == "11"
+
+    def test_does_not_set_proton_version_for_unknown_format(self, umu_install_dir, fake_proton_path):
+        """Should not set PROTONVERSION if version cannot be parsed."""
+        (fake_proton_path / "UnknownFormat").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["Done\n"])
+        mock_proc.wait.return_value = 0
+        mock_proc.returncode = 0
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                update_steam_runtime("UnknownFormat")
+
+                call_kwargs = subprocess.Popen.call_args[1]  # pyright: ignore[reportAttributeAccessIssue]
+                env = call_kwargs["env"]
+                assert "PROTONVERSION" not in env
+
+    def test_returns_update_ok_on_success(self, umu_install_dir, fake_proton_path):
+        """Should return (True, 'Update OK') on successful runtime update."""
+        (fake_proton_path / "Proton-9.0").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["Downloading steamrt...\n", "Extracting...\n", "Done\n"])
+        mock_proc.wait.return_value = 0
+        mock_proc.returncode = 0
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                result = update_steam_runtime("Proton-9.0")
+                assert result == (True, "Update OK")
+
+    def test_calls_progress_callback_on_download(self, umu_install_dir, fake_proton_path):
+        """Progress callback should be called when Downloading/Extracting is seen."""
+        (fake_proton_path / "Proton-9.0").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["Downloading steamrt...\n", "Done\n"])
+        mock_proc.wait.return_value = 0
+        mock_proc.returncode = 0
+
+        callback = MagicMock()
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                update_steam_runtime("Proton-9.0", progress_callback=callback)
+
+                callback.assert_any_call(50)
+
+    def test_calls_on_success_callback(self, umu_install_dir, fake_proton_path):
+        """on_success callback should be called on 'Already up to date'."""
+        (fake_proton_path / "Proton-9.0").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["Already up to date\n"])
+        mock_proc.wait.return_value = 0
+        mock_proc.returncode = 0
+
+        on_success = MagicMock()
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                result = update_steam_runtime(
+                    "Proton-9.0",
+                    on_success=on_success,
+                )
+                assert result[0] is True
+                on_success.assert_called_once()
+
+    def test_calls_on_success_on_update_ok(self, umu_install_dir, fake_proton_path):
+        """on_success callback should be called on successful update."""
+        (fake_proton_path / "Proton-9.0").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["Done\n"])
+        mock_proc.wait.return_value = 0
+        mock_proc.returncode = 0
+
+        on_success = MagicMock()
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                result = update_steam_runtime(
+                    "Proton-9.0",
+                    on_success=on_success,
+                )
+                assert result[0] is True
+                on_success.assert_called_once()
+
+    def test_returns_failed_on_nonzero_exit(self, umu_install_dir, fake_proton_path):
+        """Should return (False, message) when umu-run exits with non-zero code."""
+        (fake_proton_path / "Proton-9.0").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["Error occurred\n"])
+        mock_proc.wait.return_value = 1
+        mock_proc.returncode = 1
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                result = update_steam_runtime("Proton-9.0")
+                assert result[0] is False
+                assert "exit code 1" in result[1]
+
+    def test_returns_failed_on_subprocess_exception(self, umu_install_dir, fake_proton_path):
+        """Should return (False, str(e)) when subprocess.Popen raises an exception."""
+        (fake_proton_path / "Proton-9.0").mkdir(parents=True, exist_ok=True)
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", side_effect=FileNotFoundError("bwrap not found")):
+                from fungus.umu_manager import update_steam_runtime
+
+                result = update_steam_runtime("Proton-9.0")
+                assert result[0] is False
+                assert "bwrap not found" in result[1]
+
+    def test_returns_failed_when_no_stdout(self, umu_install_dir, fake_proton_path):
+        """Should return (False, 'No output from umu-run') when stdout is None."""
+        (fake_proton_path / "Proton-9.0").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = None
+        mock_proc.wait.return_value = 0
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                result = update_steam_runtime("Proton-9.0")
+                assert result == (False, "No output from umu-run")
+
+    def test_sets_gameid_env(self, umu_install_dir, fake_proton_path):
+        """Should set GAMEID environment variable."""
+        (fake_proton_path / "Proton-9.0").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["Done\n"])
+        mock_proc.wait.return_value = 0
+        mock_proc.returncode = 0
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                update_steam_runtime("Proton-9.0")
+
+                call_kwargs = subprocess.Popen.call_args[1]  # pyright: ignore[reportAttributeAccessIssue]
+                env = call_kwargs["env"]
+                assert env.get("GAMEID") == "umu-update-handshake"
+
+    def test_sets_protonpath_env(self, umu_install_dir, fake_proton_path):
+        """Should set PROTONPATH to the full path of the Proton directory."""
+        (fake_proton_path / "Proton-9.0").mkdir(parents=True, exist_ok=True)
+
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["Done\n"])
+        mock_proc.wait.return_value = 0
+        mock_proc.returncode = 0
+
+        with patch("fungus.umu_manager.get_umu_run_path", return_value="/fake/umu-run"):
+            with patch("subprocess.Popen", return_value=mock_proc):
+                from fungus.umu_manager import update_steam_runtime
+
+                update_steam_runtime("Proton-9.0")
+
+                call_kwargs = subprocess.Popen.call_args[1]  # pyright: ignore[reportAttributeAccessIssue]
+                env = call_kwargs["env"]
+                assert env.get("PROTONPATH") == str(fake_proton_path / "Proton-9.0")