Merge pull request #1 from OOCAZ/dev/add-linux

added testing support for mac and linux

Author: OOCAZ

.github/workflows/tests.yml

@@ -11,12 +11,41 @@ on:
     workflow_dispatch:
 
 jobs:
-    test:
-        runs-on: ${{ matrix.os }}
+    test-windows:
+        runs-on: windows-latest
         strategy:
-            fail-fast: false
+            fail-fast: true
+            matrix:
+                python-version: ["3.9", "3.10", "3.11", "3.12"]
+
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Set up Python ${{ matrix.python-version }}
+              uses: actions/setup-python@v5
+              with:
+                  python-version: ${{ matrix.python-version }}
+
+            - name: Install dependencies
+              run: |
+                  python -m pip install --upgrade pip
+                  pip install pytest pytest-cov
+
+            - name: Install project dependencies
+              run: |
+                  pip install pyautogui ttkbootstrap darkdetect
+
+            - name: Run tests with pytest
+              run: |
+                  pytest tests/ -v --cov=src --cov-report=xml --cov-report=term
+
+    test-ubuntu:
+        runs-on: ubuntu-latest
+        needs: test-windows
+        strategy:
+            fail-fast: true
             matrix:
-                os: [windows-latest]
                 python-version: ["3.9", "3.10", "3.11", "3.12"]
 
         steps:
@@ -29,7 +58,6 @@ jobs:
                   python-version: ${{ matrix.python-version }}
 
             - name: Install system dependencies (Linux)
-              if: runner.os == 'Linux'
               run: |
                   sudo apt-get update
                   sudo apt-get install -y python3-tk python3-dev xvfb
@@ -51,10 +79,40 @@ jobs:
                   pytest tests/ -v --cov=src --cov-report=xml --cov-report=term
 
             - name: Upload coverage to Codecov
-              if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11'
+              if: matrix.python-version == '3.11'
               uses: codecov/codecov-action@v4
               with:
                   file: ./coverage.xml
                   flags: unittests
                   name: codecov-umbrella
                   fail_ci_if_error: false
+
+    test-macos:
+        runs-on: macos-latest
+        needs: test-ubuntu
+        strategy:
+            fail-fast: true
+            matrix:
+                python-version: ["3.9", "3.10", "3.11", "3.12"]
+
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Set up Python ${{ matrix.python-version }}
+              uses: actions/setup-python@v5
+              with:
+                  python-version: ${{ matrix.python-version }}
+
+            - name: Install dependencies
+              run: |
+                  python -m pip install --upgrade pip
+                  pip install pytest pytest-cov
+
+            - name: Install project dependencies
+              run: |
+                  pip install pyautogui ttkbootstrap darkdetect
+
+            - name: Run tests with pytest
+              run: |
+                  pytest tests/ -v --cov=src --cov-report=xml --cov-report=term

src/loctight.py

@@ -2,7 +2,6 @@
 # Written by OOCAZ (Zac Poorman)
 # LOCTight - A simple timer to keep your computer active and open.
 
-import ctypes
 import os
 import subprocess
 import sys
@@ -11,6 +10,10 @@
 from sys import platform
 from tkinter import messagebox
 
+# Windows-specific import
+if sys.platform == "win32":
+    import ctypes
+
 import darkdetect
 import pyautogui
 import ttkbootstrap as tb
@@ -22,6 +25,40 @@
         sys.exit(1)
 
 
+def lock_workstation():
+    """Lock the workstation based on the current platform."""
+    if platform == "linux" or platform == "linux2":
+        # Try multiple Linux screen lockers in order of preference
+        lockers = [
+            ["loginctl", "lock-session"],
+            ["xdg-screensaver", "lock"],
+            ["gnome-screensaver-command", "--lock"],
+            ["dm-tool", "lock"],
+            ["xscreensaver-command", "-lock"],
+        ]
+        for locker in lockers:
+            try:
+                subprocess.run(locker, check=True, capture_output=True)
+                return  # Success, exit function
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                continue  # Try next locker
+        # If all fail, show warning but don't crash
+        messagebox.showwarning(
+            "Screen Lock Failed",
+            "Could not lock screen. No supported screen locker found.",
+        )
+    elif platform == "darwin":
+        subprocess.run(
+            [
+                "/System/Library/CoreServices/Menu Extras/User.menu/Contents/Resources/CGSession",
+                "-suspend",
+            ],
+            check=True,
+        )
+    else:  # Windows
+        ctypes.windll.user32.LockWorkStation()
+
+
 def jiggle(x, checks):
     a = 0
     while a < x and timer_running[0]:
@@ -32,18 +69,7 @@ def jiggle(x, checks):
             b += 1
         a += 1
     if checks == 0 and timer_running[0]:
-        if platform == "linux" or platform == "linux2":
-            subprocess.call(
-                r"/System/Library/CoreServices/Menu\ Extras/User.menu/Contents/Resources/CGSession -suspend",
-                shell=True,
-            )
-        elif platform == "darwin":
-            subprocess.call(
-                r"/System/Library/CoreServices/Menu\ Extras/User.menu/Contents/Resources/CGSession -suspend",
-                shell=True,
-            )
-        else:
-            ctypes.windll.user32.LockWorkStation()
+        lock_workstation()
 
 
 paused = [False]
@@ -76,18 +102,7 @@ def countdown(variable, checks):
         update_time_label(0, 0)
         # Check the IntVar at the end, not at the start! That way user can change mind
         if checks.get() == 0:
-            if platform == "linux" or platform == "linux2":
-                subprocess.call(
-                    r"/System/Library/CoreServices/Menu\ Extras/User.menu/Contents/Resources/CGSession -suspend",
-                    shell=True,
-                )
-            elif platform == "darwin":
-                subprocess.call(
-                    r"/System/Library/CoreServices/Menu\ Extras/User.menu/Contents/Resources/CGSession -suspend",
-                    shell=True,
-                )
-            else:
-                ctypes.windll.user32.LockWorkStation()
+            lock_workstation()
     timer_running[0] = False
     paused[0] = False
     pause_button.config(text="Pause Timer", state=tb.DISABLED)

tests/test_core_logic.py

@@ -3,11 +3,18 @@
 Tests the timer and mouse jiggle functions in isolation
 """
 
+import subprocess
 import sys
 import time
 import unittest
 from unittest.mock import MagicMock, Mock, patch
 
+# Mock pyautogui to avoid X11/display requirements in CI
+# Create a proper mock module with the attributes we need
+mock_pyautogui = MagicMock()
+mock_pyautogui.moveRel = MagicMock()
+sys.modules["pyautogui"] = mock_pyautogui
+
 
 class TestTimerFunctions(unittest.TestCase):
     """Test the core timer logic"""
@@ -182,41 +189,101 @@ def test_preset_timers(self):
 class TestPlatformLocking(unittest.TestCase):
     """Test platform-specific lock commands"""
 
-    @patch("ctypes.windll.user32.LockWorkStation")
     @patch("sys.platform", "win32")
-    def test_windows_lock(self, mock_lock):
+    @patch("src.loctight.platform", "win32")
+    def test_windows_lock(self):
         """Test Windows lock workstation call"""
-        import ctypes
+        # Mock ctypes module
+        mock_ctypes = MagicMock()
+        with patch.dict("sys.modules", {"ctypes": mock_ctypes}):
+            # Import after mocking to ensure ctypes is available
+            import importlib
+
+            import src.loctight
+
+            # Inject the mock into the module
+            src.loctight.ctypes = mock_ctypes
 
-        # Simulate Windows lock
-        if sys.platform == "win32":
-            mock_lock()
+            from src.loctight import lock_workstation
 
-        mock_lock.assert_called_once()
+            lock_workstation()
+            mock_ctypes.windll.user32.LockWorkStation.assert_called_once()
 
-    @patch("subprocess.call")
-    @patch("sys.platform", "darwin")
+    @patch("src.loctight.subprocess.run")
+    @patch("src.loctight.platform", "darwin")
     def test_macos_lock(self, mock_subprocess):
         """Test macOS lock command"""
-        if sys.platform == "darwin":
-            mock_subprocess(
-                r"/System/Library/CoreServices/Menu\ Extras/User.menu/Contents/Resources/CGSession -suspend",
-                shell=True,
-            )
-
-        self.assertTrue(mock_subprocess.called)
-
-    @patch("subprocess.call")
-    @patch("sys.platform", "linux")
-    def test_linux_lock(self, mock_subprocess):
-        """Test Linux lock command"""
-        if sys.platform.startswith("linux"):
-            mock_subprocess(
-                r"/System/Library/CoreServices/Menu\ Extras/User.menu/Contents/Resources/CGSession -suspend",
-                shell=True,
-            )
-
-        self.assertTrue(mock_subprocess.called)
+        from src.loctight import lock_workstation
+
+        lock_workstation()
+
+        mock_subprocess.assert_called_once_with(
+            [
+                "/System/Library/CoreServices/Menu Extras/User.menu/Contents/Resources/CGSession",
+                "-suspend",
+            ],
+            check=True,
+        )
+
+    @patch("src.loctight.subprocess.run")
+    @patch("src.loctight.platform", "linux")
+    def test_linux_lock_first_locker_succeeds(self, mock_subprocess):
+        """Test Linux lock succeeds on first locker"""
+        from src.loctight import lock_workstation
+
+        # Mock successful lock on first try
+        mock_subprocess.return_value = MagicMock()
+
+        lock_workstation()
+
+        # Should only call the first locker
+        mock_subprocess.assert_called_once_with(
+            ["loginctl", "lock-session"], check=True, capture_output=True
+        )
+
+    @patch("src.loctight.subprocess.run")
+    @patch("src.loctight.platform", "linux")
+    def test_linux_lock_fallback_mechanism(self, mock_subprocess):
+        """Test Linux lock tries multiple lockers on failure"""
+        from src.loctight import lock_workstation
+
+        # First two lockers fail, third succeeds
+        mock_subprocess.side_effect = [
+            FileNotFoundError(),  # loginctl not found
+            subprocess.CalledProcessError(1, "xdg-screensaver"),  # xdg fails
+            MagicMock(),  # gnome-screensaver succeeds
+        ]
+
+        lock_workstation()
+
+        # Should have tried three lockers
+        self.assertEqual(mock_subprocess.call_count, 3)
+        calls = mock_subprocess.call_args_list
+        self.assertEqual(calls[0][0][0], ["loginctl", "lock-session"])  # First attempt
+        self.assertEqual(calls[1][0][0], ["xdg-screensaver", "lock"])  # Second attempt
+        self.assertEqual(
+            calls[2][0][0], ["gnome-screensaver-command", "--lock"]
+        )  # Third attempt
+
+    @patch("src.loctight.subprocess.run")
+    @patch("src.loctight.platform", "linux")
+    @patch("src.loctight.messagebox.showwarning")
+    def test_linux_lock_all_fail(self, mock_messagebox, mock_subprocess):
+        """Test Linux lock handles all lockers failing gracefully"""
+        from src.loctight import lock_workstation
+
+        # All lockers fail
+        mock_subprocess.side_effect = FileNotFoundError()
+
+        lock_workstation()
+
+        # Should have tried all 5 lockers
+        self.assertEqual(mock_subprocess.call_count, 5)
+        # Should show warning messagebox
+        mock_messagebox.assert_called_once_with(
+            "Screen Lock Failed",
+            "Could not lock screen. No supported screen locker found.",
+        )
 
 
 class TestButtonStateManagement(unittest.TestCase):