Merge pull request #542 from aclist/chore/test-typehints

chore: typehint tests

dzgui/init/proc.py

@@ -30,19 +30,16 @@ def is_steam_running(cmd: str) -> bool:
 def is_sandboxed() -> bool:
     return bool(os.environ.get("FLATPAK_ID"))
 
-def get_flatpak_output() -> list[str]:
-    proc = subprocess.check_output(
-        [FLATPAK_CMD, "ps", "--columns=application"], text=True
-    )
-    lines = proc.splitlines()
-    return lines
 
 def is_flatpak_steam_running() -> bool:
     if is_sandboxed():
         return True
     if has_cmd(FLATPAK_CMD) is False:
         return False
-    lines = get_flatpak_output()
+    proc = subprocess.check_output(
+        [FLATPAK_CMD, "ps", "--columns=application"], text=True
+    )
+    lines = proc.splitlines()
     if FLATPAK_APPID in lines:
         return True
     return False

scripts/parse_toml.py

@@ -1,9 +1,8 @@
 import tomllib
 from shared import get_git_root
-from typing import Any
 
 
-def get_entrypoint() -> Any:
+def get_entrypoint() -> None:
     root = get_git_root()
     p = root.joinpath("pyproject.toml")
     with open(p, "rb") as f:

scripts/prebuild.py

@@ -52,7 +52,7 @@ def untar(file: str, glob: str, renamed: str) -> None:
         os.rename(_dir, build_dir.joinpath(renamed))
 
 
-def install_deps() -> int:
+def install_deps() -> None:
     pip = build_dir.joinpath(f"{CPYTHON_BUILD}/bin/pip")
     proc = subprocess.run([pip, "install", root])
     return proc.returncode
@@ -65,12 +65,12 @@ def repackage() -> None:
         tar.add(build_dir.joinpath(CPYTHON_BUILD), arcname="python")
 
 
-def rebuild_cpython() -> str:
+def rebuild_cpython() -> None:
     if cpython_dir.is_dir() is False:
         get_cpython()
     code = install_deps()
     if code != 0:
-        return ""
+        return
     repackage()
     return get_packaged_version()
 

scripts/release.py

@@ -92,8 +92,8 @@ with tarfile.open(tarpath, "w:gz") as tar:
     tar.add(subfolder, arcname=appname, filter=update_uname)
     print(f"Wrote tarfile to '{tarpath}'")
 
-built_proc = subprocess.run([release_exe, "-v"], capture_output=True, text=True)
-assert str(built_proc.stdout).rstrip() == version
+proc = subprocess.run([release_exe, "-v"], capture_output=True, text=True)
+assert proc.stdout.rstrip() == version
 
 # TODO: clean up staging directory
 release_exe.unlink()

scripts/scrot.py

@@ -8,13 +8,7 @@ def get_image_path() -> Path:
     return get_git_root().joinpath("dzgui/data/images/example.png")
 
 
-def take_screenshot() -> None:
-    p = get_image_path()
-    app = build_gui("", False)
-    if app is None:
-        return
-    app.set_automation_param("screenshot_path", p)
-    app.run(None)
-
-
-take_screenshot()
+p = get_image_path()
+app = build_gui("", False)
+app.set_automation_param("screenshot_path", p)
+app.run(None)

scripts/untracked.py

@@ -3,11 +3,14 @@ import subprocess
 import sys
 
 cmd = ["git", "ls-files", "--others", "--exclude-standard"]
-result = subprocess.run(
-    cmd, capture_output=True, text=True
+result = subprocess.Popen(
+    cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
 )
-untracked = [os.path.basename(line.rstrip()) for line in result.stdout.splitlines()]
-if bool(untracked):
-    print(f"The following files are untracked. Add to .gitignore if this is intended.")
-    print("\n".join(untracked))
-    sys.exit(1)
+with open(".gitignore", "r") as f:
+    ignored = [line.rstrip() for line in f]
+
+untracked = [os.path.basename(line.rstrip()) for line in result.stdout]
+for file in untracked:
+    if not any(file in item for item in ignored):
+        print(f"File '{file}' is untracked. Add to .gitignore file if this is intended.")
+        sys.exit(1)

tests/test_process_detection.py

@@ -1,93 +1,80 @@
 import pytest
+import unittest
 
-from typing import Literal, TYPE_CHECKING
+from unittest.mock import patch
+from typing import Any
 
 from dzgui.const.constants import (
     FLATPAK_APPID,
     FLATPAK_ROOT_PATH,
+    FLATPAK_RUN_CMD,
+    FLATPAK_SANDBOX,
 )
 from dzgui.init import proc
 
-if TYPE_CHECKING:
-    from _pytest.monkeypatch import MonkeyPatch
-
 pytestmark = pytest.mark.flatpak
 
 
-def mock_has_cmd(cmd: str) -> Literal[True]:
-    return True
+class TestSteamDetection(unittest.TestCase):
+    def test_flatpak_detection_with_multiple_running_apps(self) -> None:
+        def flatpak_output(args: Any, *, text: str) -> str:
+            # Default 'flatpak ps' includes instance, PID, app and runtime columns.
+            if args == ["flatpak", "ps", "--columns=application"]:
+                return f"com.spotify.Client\n{FLATPAK_APPID}\n{FLATPAK_APPID}\n"
+            return f"3904921611\t1257689\t{FLATPAK_APPID}\torg.freedesktop.Platform\n"
 
+        with (
+            patch.object(proc, "has_cmd", return_value=True),
+            patch.object(proc.subprocess, "check_output", side_effect=flatpak_output),
+        ):
+            for client in (FLATPAK_RUN_CMD, FLATPAK_SANDBOX):
+                with self.subTest(client=client):
+                    self.assertTrue(proc.is_steam_running(client))
 
-def mock_has_not_cmd(cmd: str) -> Literal[False]:
-    return False
+    def test_flatpak_not_running(self) -> None:
+        with patch.object(proc, "has_cmd", return_value=True):
+            for output in ("", "com.spotify.Client\n", f"{FLATPAK_APPID}Helper\n"):
+                with (
+                    self.subTest(output=output),
+                    patch.object(proc.subprocess, "check_output", return_value=output),
+                ):
+                    self.assertFalse(proc.is_flatpak_steam_running())
 
+    def test_flatpak_not_installed(self) -> None:
+        with (
+            patch.object(proc, "has_cmd", return_value=False),
+            patch.object(proc.subprocess, "check_output") as check_output,
+        ):
+            self.assertFalse(proc.is_flatpak_steam_running())
+            check_output.assert_not_called()
 
-def mock_get_flatpak_output() -> list[str]:
-    lines = ["Application", "com.freedesktop.Platform", f"{FLATPAK_APPID}"]
-    return lines
+    def test_native_steam(self) -> None:
+        with patch.object(proc, "has_cmd", return_value=True):
+            for output, expected in (
+                (
+                    [
+                        [FLATPAK_ROOT_PATH],
+                        "/home/user/.local/share/Steam/ubuntu12_64/steamwebhelper",
+                    ],
+                    True,
+                ),
+                ([[FLATPAK_ROOT_PATH]], False),
+                ([[FLATPAK_ROOT_PATH], ["steam-runtime-launcher-service"]], False),
+                ([["/home/user/.local/share/Steam/ubuntu12_64/steamwebhelper"]], True),
+                (
+                    [
+                        ["/home/user/.local/share/Steam/ubuntu12_64/steamwebhelper"],
+                        "steam-runtime-launcher-service",
+                    ],
+                    True,
+                ),
+            ):
+                with (
+                    self.subTest(running=output),
+                    patch.object(proc, "get_steam_procs", return_value=output),
+                ):
+                    self.assertEqual(proc.is_native_steam_running(), expected)
 
-
-@pytest.mark.parametrize(
-    "output, expected",
-    [
-        (
-            [
-                [f"/home/user/{FLATPAK_ROOT_PATH}/.local/share/Steam"],
-                ["/home/user/.local/share/Steam/ubuntu12_64/steamwebhelper"],
-            ],
-            True,
-        ),
-        (
-            [
-                [f"/home/user/{FLATPAK_ROOT_PATH}/.local/share/Steam"],
-                ["steam-runtime-launcher-service"],
-            ],
-            False,
-        ),
-        ([[f"/home/user/{FLATPAK_ROOT_PATH}/.local/share/Steam"]], False),
-        ([["/home/user/.local/share/Steam/ubuntu12_64/steamwebhelper"]], True),
-        (
-            [
-                ["/home/user/.local/share/Steam/ubuntu12_64/steamwebhelper"],
-                ["steam-runtime-launcher-service"],
-            ],
-            True,
-        ),
-    ],
-)
-def test_native_steam_running(
-    monkeypatch: "MonkeyPatch", output: list[list[str]], expected: bool
-) -> None:
-    def mock_get_steam_procs() -> list[list[str]]:
-        return output
-
-    monkeypatch.setattr("dzgui.init.proc.has_cmd", mock_has_cmd)
-    monkeypatch.setattr("dzgui.init.proc.get_steam_procs", mock_get_steam_procs)
-    assert proc.is_native_steam_running() == expected
-
-
-def test_flatpak_running(monkeypatch: "MonkeyPatch") -> None:
-    monkeypatch.setattr("dzgui.init.proc.has_cmd", mock_has_cmd)
-    monkeypatch.setattr("dzgui.init.proc.get_flatpak_output", mock_get_flatpak_output)
-    assert proc.is_flatpak_steam_running()
-
-
-def test_flatpak_sandboxed(monkeypatch: "MonkeyPatch") -> None:
-    monkeypatch.setattr("dzgui.init.proc.has_cmd", mock_has_not_cmd)
-    monkeypatch.setenv("FLATPAK_ID", FLATPAK_APPID)
-    assert proc.is_flatpak_steam_running()
-
-
-def test_flatpak_not_installed(monkeypatch: "MonkeyPatch") -> None:
-    monkeypatch.setattr("dzgui.init.proc.has_cmd", mock_has_not_cmd)
-    assert not proc.is_flatpak_steam_running()
-
-
-def test_steam_not_installed(monkeypatch: "MonkeyPatch") -> None:
-    monkeypatch.setattr("dzgui.init.proc.has_cmd", mock_has_not_cmd)
-    assert not proc.is_native_steam_running()
-
-
-def test_invalid_client() -> None:
-    with pytest.raises(TypeError):
-        proc.is_steam_running("invalid-client")
+    def test_invalid_client(self) -> None:
+        with self.assertRaises(TypeError):
+            proc.is_steam_running("invalid-client")