Add tests

Author: zooba

src/manage/firstrun.py

@@ -17,9 +17,13 @@
 from .pathutils import Path
 
 
+def _package_name():
+    from _native import get_current_package
+    return get_current_package()
+
+
 def check_app_alias(cmd):
     LOGGER.debug("Checking app execution aliases")
-    from _native import get_current_package, read_alias_package
     # Expected identities:
     # Side-loaded MSIX
     # * "PythonSoftwareFoundation.PythonManager_3847v3x7pw1km",
@@ -30,13 +34,15 @@ def check_app_alias(cmd):
     # MSI/dev install
     # * None
     try:
-        pkg = get_current_package()
+        pkg = _package_name()
     except OSError:
         LOGGER.debug("Failed to get current package name.", exc_info=True)
         pkg = None
     if not pkg:
         LOGGER.debug("Check skipped: MSI install can't do this check")
         return "skip"
+
+    from _native import read_alias_package
     LOGGER.debug("Checking for %s", pkg)
     root = Path(os.environ["LocalAppData"]) / "Microsoft/WindowsApps"
     for name in ["py.exe", "pyw.exe", "python.exe", "pythonw.exe", "python3.exe", "pymanager.exe"]:
@@ -59,7 +65,8 @@ def check_long_paths(cmd):
     LOGGER.debug("Checking long paths setting")
     import winreg
     try:
-        with winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE, r"System\CurrentControlSet\Control\FileSystem") as key:
+        with winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE,
+                              r"System\CurrentControlSet\Control\FileSystem") as key:
             if winreg.QueryValueEx(key, "LongPathsEnabled") == (1, winreg.REG_DWORD):
                 LOGGER.debug("Check passed: registry key is OK")
                 return True
@@ -71,9 +78,14 @@ def check_long_paths(cmd):
 
 def check_py_on_path(cmd):
     LOGGER.debug("Checking for legacy py.exe on PATH")
-    from _native import get_current_package, read_alias_package
-    if not get_current_package():
-        LOGGER.debug("Check skipped: MSI install can't do this check")
+    from _native import read_alias_package
+    try:
+        if not _package_name():
+            LOGGER.debug("Check skipped: MSI install can't do this check")
+            return "skip"
+    except OSError:
+        LOGGER.debug("Failed to get current package name.", exc_info=True)
+        LOGGER.debug("Check skipped: can't do this check")
         return "skip"
     for p in os.environ["PATH"].split(";"):
         if not p:
@@ -90,6 +102,8 @@ def check_py_on_path(cmd):
             # Probably not an alias, so we're not good
             LOGGER.debug("Check failed: found %s on PATH", py)
             return False
+    LOGGER.debug("Check passed: no py.exe on PATH at all")
+    return True
 
 
 def check_global_dir(cmd):
@@ -104,28 +118,35 @@ def check_global_dir(cmd):
             LOGGER.debug("Check passed: %s is on PATH", p)
             return True
     # In case user has updated their registry but not the terminal
-    import winreg
     try:
-        with winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER, "Environment") as key:
-            path, kind = winreg.QueryValueEx(key, "Path")
-        LOGGER.debug("Current registry path: %s", path)
-        if kind == winreg.REG_EXPAND_SZ:
-            path = os.path.expandvars(path)
-        elif kind != winreg.REG_SZ:
-            LOGGER.debug("Check skipped: PATH registry key is not a string.")
-            return "skip"
-        for p in path.split(";"):
-            if not p:
-                continue
-            if Path(p).absolute().match(cmd.global_dir):
-                LOGGER.debug("Check skipped: %s will be on PATH after restart", p)
-                return True
+        r = _check_global_dir_registry(cmd)
+        if r:
+            return r
     except Exception:
         LOGGER.debug("Failed to read PATH setting from registry", exc_info=True)
     LOGGER.debug("Check failed: %s not found in PATH", cmd.global_dir)
     return False
 
 
+def _check_global_dir_registry(cmd):
+    import winreg
+    with winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER, "Environment") as key:
+        path, kind = winreg.QueryValueEx(key, "Path")
+    LOGGER.debug("Current registry path: %s", path)
+    if kind == winreg.REG_EXPAND_SZ:
+        path = os.path.expandvars(path)
+    elif kind != winreg.REG_SZ:
+        LOGGER.debug("Check skipped: PATH registry key is not a string.")
+        return "skip"
+    for p in path.split(";"):
+        if not p:
+            continue
+        if Path(p).absolute().match(cmd.global_dir):
+            LOGGER.debug("Check skipped: %s will be on PATH after restart", p)
+            return True
+    return False
+
+
 def do_global_dir_on_path(cmd):
     import winreg
     added = notified = False

tests/conftest.py

@@ -66,6 +66,9 @@ def skip_until(self, pattern, args=()):
     def not_logged(self, pattern, args=()):
         return ('not', pattern, args)
 
+    def end_of_log(self):
+        return ('eol', None, None)
+
     def __call__(self, *cmp):
         i = 0
         for y in cmp:
@@ -84,6 +87,11 @@ def __call__(self, *cmp):
                         return
                 continue
 
+            if op == 'eol':
+                if i < len(self):
+                    pytest.fail(f"Expected end of log; found {self[i]}")
+                return
+
             while True:
                 try:
                     x = self[i]
@@ -92,7 +100,10 @@ def __call__(self, *cmp):
                     pytest.fail(f"Not enough elements were logged looking for {pat}")
                 if op == 'until' and not re.match(pat, x[0], flags=re.S):
                     continue
-                assert re.match(pat, x[0], flags=re.S)
+                if not pat:
+                    assert not x[0]
+                else:
+                    assert re.match(pat, x[0], flags=re.S)
                 if args is not None:
                     assert tuple(x[1]) == tuple(args)
                 break
@@ -140,7 +151,7 @@ def __init__(self, installs=[]):
         self.shebang_can_run_anything = True
         self.shebang_can_run_anything_silently = False
 
-    def get_installs(self):
+    def get_installs(self, *, include_unmanaged=True, set_default=True):
         return self.installs
 
     def get_install_to_run(self, tag):

tests/test_firstrun.py

@@ -0,0 +1,99 @@
+import os
+import pytest
+
+from pathlib import Path
+
+from manage import firstrun
+from _native import get_current_package, read_alias_package
+
+def test_get_current_package():
+    # The only circumstance where this may be different is if we're running
+    # tests in a Store install of Python without a virtualenv. That should never
+    # happen, because we run with 3.14 and there are no more Store installs.
+    assert get_current_package() is None
+
+
+def test_read_alias_package():
+    # Hopefully there's at least one package add with an alias on this machine.
+    root = Path(os.environ["LocalAppData"]) / "Microsoft/WindowsApps"
+    if not root.is_dir() or not any(root.rglob("*.exe")):
+        pytest.skip("Requires an installed app")
+    for f in root.rglob("*.exe"):
+        print("Reading package name from", f)
+        p = read_alias_package(f)
+        print("Read:", p)
+        # One is sufficient
+        return
+    pytest.skip("Requires an installed app")
+
+
+def fake_package_name():
+    return "PythonSoftwareFoundation.PythonManager_m8z88z54g2w36"
+
+
+def fake_package_name_error():
+    raise OSError("injected failure")
+
+
+def fake_package_name_none():
+    return None
+
+
+def test_check_app_alias(fake_config, monkeypatch):
+    monkeypatch.setattr(firstrun, "_package_name", fake_package_name)
+    assert firstrun.check_app_alias(fake_config) in (True, False)
+
+    monkeypatch.setattr(firstrun, "_package_name", fake_package_name_error)
+    assert firstrun.check_app_alias(fake_config) == "skip"
+
+    monkeypatch.setattr(firstrun, "_package_name", fake_package_name_none)
+    assert firstrun.check_app_alias(fake_config) == "skip"
+
+
+def test_check_long_paths(fake_config):
+    assert firstrun.check_long_paths(fake_config) in (True, False)
+
+
+def test_check_py_on_path(fake_config, monkeypatch):
+    monkeypatch.setattr(firstrun, "_package_name", fake_package_name)
+    assert firstrun.check_py_on_path(fake_config) in (True, False)
+
+    monkeypatch.setattr(firstrun, "_package_name", fake_package_name_error)
+    assert firstrun.check_py_on_path(fake_config) == "skip"
+
+    monkeypatch.setattr(firstrun, "_package_name", fake_package_name_none)
+    assert firstrun.check_py_on_path(fake_config) == "skip"
+
+
+def test_check_global_dir(fake_config, monkeypatch, tmp_path):
+    fake_config.global_dir = str(tmp_path)
+    assert firstrun.check_global_dir(fake_config) == False
+
+    monkeypatch.setattr(firstrun, "_check_global_dir_registry", lambda *a: "called")
+    assert firstrun.check_global_dir(fake_config) == "called"
+
+    monkeypatch.setitem(os.environ, "PATH", f"{os.environ['PATH']};{tmp_path}")
+    assert firstrun.check_global_dir(fake_config) == True
+
+
+def test_check_global_dir_registry(fake_config, monkeypatch, tmp_path):
+    fake_config.global_dir = str(tmp_path)
+    assert firstrun._check_global_dir_registry(fake_config) == False
+    # Deliberately not going to modify the registry for this test.
+    # Integration testing will verify that it reads correctly.
+
+
+def test_check_any_install(fake_config):
+    assert firstrun.check_any_install(fake_config) == False
+
+    fake_config.installs.append("an install")
+    assert firstrun.check_any_install(fake_config) == True
+
+
+def test_welcome(assert_log):
+    welcome = firstrun._Welcome()
+    assert_log(assert_log.end_of_log())
+    welcome()
+    assert_log(".*Welcome.*", "", assert_log.end_of_log())
+    welcome()
+    assert_log(".*Welcome.*", "", assert_log.end_of_log())