fix: Bugsweep providers.py + watcher.py (3 Bugs, 4 Regressionstests)

Bug #BW-1 (providers.py): GoogleDriveProvider.resume() nutzte lexikografische
Sortierung fuer versionierte Installationsordner; '9.0.0' rangierte vor '62.0.1'.
Neue Hilfsfunktion _gdrive_version_key() parst Versionskomponenten als Integer-Tupel;
_RESUME_BASE als Klassenattribut ermoeglicht sauberes Monkeypatching in Tests.

Bug #BW-2 (watcher.py): PreventiveWatcher.tick() ignorierte den Rueckgabewert
von resume(). Bei Fehlschlag blieb _paused_by_us=False + _last_activity=None;
der Provider pausierte dauerhaft bis zum App-Neustart. Fix: bei resume()==False
werden beide Zustandsfelder wiederhergestellt (Retry nach naechstem Cooldown).
Symmetrisch zum in v0.2.2 behobenen pause()-Bug.

Robustheit #BW-R (providers.py): _check_process() verglich exe_name case-sensitiv
gegen tasklist-Output; Windows gibt Prozessnamen in Original-Schreibweise zurueck
(z.B. 'Nextcloud.exe', nicht 'nextcloud.exe'). Fix: .lower() beidseitig.

Tests: 4 neue Regressionstests, 115/115 gruen (Baseline war 111).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: lukisch

CHANGELOG.md

@@ -13,11 +13,37 @@ Format basiert auf [Keep a Changelog](https://keepachangelog.com/de/1.1.0/).
   `0x8007016A`, and cloud-sync locked-folder retry workflows.
 
 ### Behoben / Fixed
+- **Tray task dialog now supports files as well as folders:** the GUI no longer
+  forces source selection through a folder-only picker, so delayed rename/move/delete
+  actions cover the same file/folder scope that the product documentation promises.
 - **Autostart in packaged builds:** PyInstaller/Frozen builds now register the
   packaged executable instead of the source-tree `clf_launcher.pyw`.
 - `tests/source_platform_smoke.py`: headless Smoke-Tests für Linux und macOS — prüft Modul-Import, Version, `ops`-Operationen (rename/move/delete), `models.Queue`-Persistenz, `paths.data_dir()` und `worker.run_once()` ohne Cloud-Client oder GUI.
 - `.github/workflows/source-platform-smoke.yml`: CI-Matrix für `ubuntu-latest` und `macos-latest`, die die Smoke-Tests bei jedem Push/PR auf `main` ausführt.
 
+### Behoben / Fixed
+- **Bug #BW-1 — GoogleDriveProvider.resume() semantische Versionssortierung:**
+  `sorted(glob("*/GoogleDriveFS.exe"), reverse=True)` nutzte lexikografische Sortierung;
+  Versionsordner wie `"9.0.0"` rangierten dabei über `"62.0.1"` (`'9' > '6'`
+  zeichenweise). Fix: neue Hilfsfunktion `_gdrive_version_key(p)` parst den
+  Verzeichnisnamen als Integer-Tupel; `_RESUME_BASE` als Klassenattribut ermöglicht
+  zudem sauberes Monkeypatching in Tests. Betrifft nur Installationen mit mehreren
+  parallelen Google-Drive-Versionen (z. B. nach unvollständigem Update). Test:
+  `test_googledrive_version_sort_key_is_semantic`, `test_googledrive_resume_picks_highest_semantic_version`.
+- **Bug #BW-2 — PreventiveWatcher.tick() ignorierte resume()-Rückgabewert:**
+  `self.provider.resume()` wurde ohne Prüfung des Rückgabewerts aufgerufen. Bei
+  Fehlschlag (z. B. Prozess-Start verweigert) blieb `_paused_by_us=False` und
+  `_last_activity=None` — der Watcher lief keinen neuen Cooldown, der Provider
+  pausierte dauerhaft bis zum App-Neustart. Symmetrisch zum bereits in v0.2.2
+  behobenen `pause()`-Bug. Fix: bei `resume() == False` werden `_paused_by_us=True`
+  und `_last_activity=self._time()` wiederhergestellt, um nach dem nächsten
+  Cooldown einen Retry zu ermöglichen. Test: `test_watcher_tick_retries_resume_after_failure`.
+- **Robustheit #BW-R — _check_process() Groß-/Kleinschreibungsvergleich:**
+  `exe_name in out` war case-sensitiv; Windows' `tasklist` gibt Prozessnamen in der
+  tatsächlichen Binär-Schreibweise zurück (z. B. `Nextcloud.exe`, nicht
+  `nextcloud.exe`). Fix: `exe_name.lower() in out.lower()`. Test:
+  `test_check_process_case_insensitive_exe_name`.
+
 ### Behoben / Fixed
 - **Bug 4 — falsches „completed" bei leerem Verzeichnis mit gesperrtem Eigen-Handle:**
   `_delete_dir_skip_locked()` meldete Erfolg anhand von `len(locked) == 0`. Ein

src/cloudlockfixer/providers.py

@@ -69,6 +69,19 @@ def _dedup_paths(paths: list[Path]) -> list[Path]:
     return out
 
 
+def _gdrive_version_key(p: Path) -> tuple[int, ...]:
+    """Semantischer Sortier-Schlüssel für versionierte GoogleDriveFS.exe-Pfade.
+
+    Parst den Verzeichnisnamen des exe-Pfads als Integer-Tupel, damit z. B.
+    '62.0.1' numerisch über '9.0.0' sortiert ('9' > '6' lexikografisch wäre falsch).
+    Ungültige Komponenten werden auf (0,) normiert.
+    """
+    try:
+        return tuple(int(x) for x in p.parent.name.split("."))
+    except ValueError:
+        return (0,)
+
+
 def _check_process(exe_name: str) -> bool:
     if sys.platform != "win32":
         return False
@@ -78,7 +91,7 @@ def _check_process(exe_name: str) -> bool:
             capture_output=True, text=True, timeout=10,
             encoding="utf-8", errors="ignore",
         ).stdout or ""
-        return exe_name in out
+        return exe_name.lower() in out.lower()
     except (OSError, subprocess.SubprocessError):
         return False
 
@@ -182,6 +195,7 @@ def resume(self) -> bool:
 class GoogleDriveProvider(SyncProvider):
     name = "Google Drive"
     mount_type = "virtual"
+    _RESUME_BASE: Path = Path(r"C:\Program Files\Google\Drive File Stream")
 
     def _detect_roots(self) -> list[Path]:
         if sys.platform != "win32":
@@ -204,10 +218,11 @@ def pause(self) -> bool:
     def resume(self) -> bool:
         if sys.platform != "win32":
             return False
-        base = Path(r"C:\Program Files\Google\Drive File Stream")
+        base = self._RESUME_BASE
         if not base.exists():
             return False
-        versions = sorted(base.glob("*/GoogleDriveFS.exe"), reverse=True)
+        versions = sorted(base.glob("*/GoogleDriveFS.exe"),
+                          key=_gdrive_version_key, reverse=True)
         for exe in versions:
             try:
                 subprocess.Popen([str(exe)])

src/cloudlockfixer/watcher.py

@@ -95,9 +95,16 @@ def tick(self) -> str:
             else:
                 self._paused_by_us = False
         elif action == "resume":
-            self.provider.resume()
-            log.info("Preventive watcher: %s resumed (idle).",
-                     self.provider.name)
+            if self.provider.resume():
+                log.info("Preventive watcher: %s resumed (idle).",
+                         self.provider.name)
+            else:
+                # resume() fehlgeschlagen — Zustand wiederherstellen damit
+                # nach dem nächsten Cooldown ein neuer Versuch gestartet wird.
+                self._paused_by_us = True
+                self._last_activity = self._time()
+                log.warning("Preventive watcher: resume %s fehlgeschlagen, "
+                            "Retry nach Cooldown.", self.provider.name)
         return action
 
 

tests/test_p2_p3.py

@@ -262,3 +262,54 @@ def tick(self):
         assert False, f"tick_all() darf keinen RuntimeError erzeugen: {e}"
 
     assert ticked, "Watcher muss aufgerufen worden sein"
+
+
+# ── Bug #BW-2: tick() ignoriert resume()-Rückgabewert ─────────────────────────
+
+def test_watcher_tick_retries_resume_after_failure(monkeypatch):
+    """Bug #BW-2: resume() Rückgabewert wurde in tick() ignoriert.
+    Wenn resume() False zurückgibt, blieb _paused_by_us=False und der Provider
+    pausierte dauerhaft bis zum App-Neustart — symmetrisch zum bereits behobenen
+    pause()-Bug (v0.2.1 CHANGELOG).
+    Fix: nach gescheitertem resume() _paused_by_us und _last_activity
+    wiederherstellen, damit nach dem nächsten Cooldown ein Retry-Versuch erfolgt."""
+    clock = [0.0]
+
+    class FailResumeProvider(FakeProvider):
+        resume_calls = 0
+
+        def resume(self) -> bool:
+            self.resume_calls += 1
+            return False  # simuliert Prozess-Start-Fehler
+
+    prov = FailResumeProvider()
+    w = PreventiveWatcher(prov, threshold=3, cooldown_s=10,
+                          time_fn=lambda: clock[0])
+
+    # Phase 1: hohe Aktivität → pause() erfolgreich (FakeProvider.pause() gibt True)
+    monkeypatch.setattr(w, "count_recent_changes", lambda: 10)
+    assert w.tick() == "pause"
+    assert w._paused_by_us
+
+    # Phase 2: Cooldown abgewartet → resume() schlägt fehl
+    monkeypatch.setattr(w, "count_recent_changes", lambda: 0)
+    clock[0] += 11
+    assert w.tick() == "resume"
+    assert prov.resume_calls == 1
+
+    # Kern-Assert: Zustand muss nach gescheitertem resume() wiederhergestellt sein
+    assert w._paused_by_us, (
+        "_paused_by_us muss nach gescheitertem resume() True sein — "
+        "sonst bleibt der Provider dauerhaft pausiert"
+    )
+    assert w._last_activity is not None, (
+        "_last_activity muss nach gescheitertem resume() gesetzt sein — "
+        "sonst läuft kein neuer Cooldown und kein Retry erfolgt"
+    )
+
+    # Phase 3: zweiter Cooldown → resume() wird erneut versucht (Retry)
+    clock[0] += 11
+    assert w.tick() == "resume", (
+        "Nach erneutem Cooldown muss resume() erneut versucht werden"
+    )
+    assert prov.resume_calls == 2, "resume() muss ein zweites Mal aufgerufen worden sein"

tests/test_providers_multi.py

@@ -249,3 +249,71 @@ def test_available_providers_returns_list():
     result = available_providers()
     assert isinstance(result, list)
     assert all(isinstance(p, SyncProvider) for p in result)
+
+
+# ── Bug #BW-1: GoogleDrive resume() — semantische Versionssortierung ──────────
+
+def test_googledrive_version_sort_key_is_semantic():
+    """Bug #BW-1: sorted(glob, reverse=True) nutzt lexikografische Sortierung;
+    '9.0.0' > '62.0.1' als String — '9' > '6' zeichenweise. Numerisch gilt
+    62 > 9. Die extrahierte _gdrive_version_key-Funktion muss integer-basiert
+    sortieren."""
+    from cloudlockfixer.providers import _gdrive_version_key
+
+    paths = [
+        Path("9.0.0") / "GoogleDriveFS.exe",
+        Path("62.0.1") / "GoogleDriveFS.exe",
+        Path("8.99.9") / "GoogleDriveFS.exe",
+    ]
+    ordered = sorted(paths, key=_gdrive_version_key, reverse=True)
+    names = [p.parent.name for p in ordered]
+    assert names == ["62.0.1", "9.0.0", "8.99.9"], (
+        f"Erwartet semantische Reihenfolge [62.0.1, 9.0.0, 8.99.9], war: {names}"
+    )
+
+
+def test_googledrive_resume_picks_highest_semantic_version(tmp_path, monkeypatch):
+    """Integration: resume() muss die semantisch höchste Version zuerst versuchen.
+    Bug #BW-1: ohne Fix startet lexikografisches '9.0.0' vor semantisch höherem '62.0.1'."""
+    import subprocess as sp
+
+    base = tmp_path / "Drive File Stream"
+    for ver in ("9.0.0", "62.0.1", "8.99.9"):
+        (base / ver).mkdir(parents=True)
+        (base / ver / "GoogleDriveFS.exe").write_text("x", encoding="utf-8")
+
+    started: list[str] = []
+
+    def fake_popen(cmd):
+        started.append(Path(cmd[0]).parent.name)
+        raise OSError("Testumgebung: kein echter Start")
+
+    monkeypatch.setattr(sp, "Popen", fake_popen)
+    monkeypatch.setattr(GoogleDriveProvider, "_RESUME_BASE", base, raising=False)
+
+    GoogleDriveProvider().resume()
+
+    assert started, "Popen wurde nicht aufgerufen — _RESUME_BASE-Patch prüfen"
+    assert started[0] == "62.0.1", (
+        f"Höchste semantische Version '62.0.1' muss zuerst versucht werden, "
+        f"war: {started[0]!r}"
+    )
+
+
+# ── Robustheit: _check_process() — Groß-/Kleinschreibung ──────────────────────
+
+def test_check_process_case_insensitive_exe_name(monkeypatch):
+    """Robustheit: tasklist gibt Prozessnamen in System-Schreibweise zurück
+    (z.B. 'Nextcloud.exe'). Wenn wir mit 'nextcloud.exe' suchen, muss der
+    Vergleich trotzdem True liefern (case-insensitive)."""
+    from cloudlockfixer.providers import _check_process
+
+    class _Fake:
+        stdout = "Nextcloud.exe  6789 Console   1   5.564 K\n"
+
+    monkeypatch.setattr(subprocess, "run", lambda *a, **k: _Fake())
+
+    # Suche mit Kleinbuchstaben — muss True ergeben trotz Groß-N in der Ausgabe
+    assert _check_process("nextcloud.exe") is True, (
+        "case-insensitive Suche muss Treffer finden wenn Ausgabe 'Nextcloud.exe' enthält"
+    )