safekeep 0.5.0__tar.gz → 0.5.2__tar.gz

{safekeep-0.5.0/safekeep.egg-info → safekeep-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: safekeep
-Version: 0.5.0
+Version: 0.5.2
 Summary: Selective always-on backups for macOS and Linux: fswatch-driven copy of allow-listed files, never deletes
 License-Expression: MIT
 Project-URL: Repository, https://github.com/foxhound87/safekeep
@@ -190,7 +190,7 @@ safekeep <command> [--config PATH] [-v]
 python3 -m unittest discover -s tests
 ```
 
-Stdlib (`unittest`) suite, zero dependencies: 206 tests covering the matcher,
+Stdlib (`unittest`) suite, zero dependencies: 221 tests covering the matcher,
 config, atomic copy, volumes, daemon, auto-discovery, CLI, the permission-trend
 wrapper and the POSIX portability layer (platform helper, per-OS fswatch
 monitor, systemd template).

{safekeep-0.5.0 → safekeep-0.5.2}/README.md

@@ -165,7 +165,7 @@ safekeep <command> [--config PATH] [-v]
 python3 -m unittest discover -s tests
 ```
 
-Stdlib (`unittest`) suite, zero dependencies: 206 tests covering the matcher,
+Stdlib (`unittest`) suite, zero dependencies: 221 tests covering the matcher,
 config, atomic copy, volumes, daemon, auto-discovery, CLI, the permission-trend
 wrapper and the POSIX portability layer (platform helper, per-OS fswatch
 monitor, systemd template).

{safekeep-0.5.0 → safekeep-0.5.2}/safekeep/__init__.py

@@ -3,4 +3,4 @@ import logging
 
 logging.getLogger('safekeep').addHandler(logging.NullHandler())
 
-__version__ = '0.5.0'
+__version__ = '0.5.2'

{safekeep-0.5.0 → safekeep-0.5.2}/safekeep/cli.py

@@ -19,6 +19,7 @@ from safekeep.daemon import Daemon, setup_logging
 from safekeep.platform import (
     INOTIFY_MIN_WATCHES,
     LOG_PATH,
+    daemon_exe,
     fswatch_monitor,
     inotify_limit,
     install_hint,
@@ -65,8 +66,8 @@ def build_parser():
     doc = sub.add_parser('doctor', parents=[common],
                          help='diagnostica: config, fswatch + monitor di piattaforma, '
                               'python, errori di permesso recenti nel log, TCC/plist '
-                              '(macOS), inotify/systemd/linger (Linux) — exit ≠ 0 se '
-                              'un check fatale fallisce')
+                              'ed exe del daemon (macOS), inotify/systemd/linger (Linux) '
+                              '— exit ≠ 0 se un check fatale fallisce')
     doc.add_argument('--json', action='store_true',
                      help='stessi check, stesso exit code, ma un documento JSON su '
                           'stdout (SPEC.md §9.1)')
@@ -369,6 +370,24 @@ def cmd_doctor(args):
                            'senza login → loginctl enable-linger $USER — '
                            'warning non fatale')
 
+    # exe del daemon ancora su disco (SPEC.md §8.4/§14.4, 0.5.1): un processo
+    # può girare su un eseguibile cancellato da un upgrade sotto un daemon vivo
+    # → TCC (Transparency, Consent and Control) non lo identifica più e ogni
+    # copia fallisce con EPERM. Guarda il PROCESSO, non il plist (funziona
+    # anche col plist renderizzato col vecchio default). Non fatale: sintomo
+    # con rimedio manuale di una riga, e doctor deve girare anche in quello stato.
+    if is_darwin():
+        exe = daemon_exe()
+        if exe is None:
+            out(True, 'exe del daemon: processo non determinabile — check saltato')
+        elif os.path.exists(exe):
+            out(True, f'exe del daemon: {exe} presente su disco')
+        else:
+            out(False, f'exe del daemon: {exe} NON esiste su disco — il processo '
+                       'gira su un eseguibile cancellato (upgrade sotto un daemon '
+                       'vivo, SPEC §8.4) → launchctl kickstart -k '
+                       'gui/$(id -u)/com.safekeep.agent — warning non fatale')
+
     code = 1 if fatal else 0
     if args.json:
         count, last = recent if recent is not None else (0, None)

{safekeep-0.5.0 → safekeep-0.5.2}/safekeep/copier.py

@@ -20,6 +20,36 @@ MTIME_TOLERANCE = 1.0      # secondi: tolleranza mtime per volumi a risoluzione
 TMP_INFIX = '.safekeep.tmp.'
 # errori che dicono "questa dest non è usabile adesso" → pending + backoff (§8.3)
 MOUNT_ERRNOS = (errno.ENODEV, errno.EBUSY, errno.ENOSPC)
+# throttle delle copie fallite (SPEC.md §10.1, 0.5.1): stessa (path, errno) →
+# una riga + `— ripetuto N volte` ogni THROTTLE_INTERVAL, non una riga a fallimento
+THROTTLE_INTERVAL = 300.0       # secondi
+_copy_errors = {}               # (src, errno) → [ultimo log monotonic, non loggati]
+
+
+def log_copy_error(src, dst, e, now=None):
+    """`copia fallita src → dst: e` con dedup per **(path, errno)** (SPEC.md §10.1).
+
+    Prima occorrenza: riga storica invariata. Poi al massimo una riga ogni
+    `THROTTLE_INTERVAL` per chiave, col suffisso `— ripetuto N volte` (N =
+    fallimenti non loggati da quell'ultima riga). `recent_permission_errors`
+    (§14.4) somma N+1 su queste righe: `count_24h` resta il conteggio vero,
+    sono solo le righe sul file a essere di meno. I conteggi in memoria
+    (`stats['errati']`, `sync-once`) non leggono da qui.
+    """
+    if now is None:
+        now = time.monotonic()
+    key = (src, e.errno)
+    entry = _copy_errors.get(key)
+    if entry is None or now - entry[0] >= THROTTLE_INTERVAL:
+        pending = 0 if entry is None else entry[1]
+        if pending:
+            log.error('copia fallita %s → %s: %s — ripetuto %d volte',
+                      src, dst, e, pending)
+        else:
+            log.error('copia fallita %s → %s: %s', src, dst, e)
+        _copy_errors[key] = [now, 0]
+    else:
+        entry[1] += 1
 
 
 def _tmp_path(dst):
@@ -215,7 +245,7 @@ def reconcile_project(source_root, dest_root, matcher, layout, dest_path_fn,
             log.error('errore di mount su %s → %s: %s: la dest va in pending',
                       src, dst, e)
             return True
-        log.error('copia fallita %s → %s: %s', src, dst, e)
+        log_copy_error(src, dst, e)
         return False
 
     for dirpath, dirnames, filenames in os.walk(root):

{safekeep-0.5.0 → safekeep-0.5.2}/safekeep/daemon.py

@@ -25,7 +25,14 @@ from .config import (
     source_root_for,
     validate_dests,
 )
-from .copier import MOUNT_ERRNOS, copy_one, needs_copy, prune_project, reconcile_project
+from .copier import (
+    MOUNT_ERRNOS,
+    copy_one,
+    log_copy_error,
+    needs_copy,
+    prune_project,
+    reconcile_project,
+)
 from .matcher import BUILTIN_RULES, Matcher, _glob, parse_rule
 from .platform import LOG_PATH, fswatch_monitor, init_system
 from .volumes import backoff_schedule, dest_state, partition_dests
@@ -411,9 +418,13 @@ class Daemon:
     # --- fswatch ---------------------------------------------------------
 
     def fswatch_argv(self):
-        """`fswatch -0 -m <monitor> -r -l 1.0 -e <regex> -- <roots>` (§6.4, §14.2):
-        il monitor è dichiarato per piattaforma, mai il default implicito."""
-        argv = ['fswatch', '-0', '-m', fswatch_monitor(), '-r', '-l', '1.0']
+        """`fswatch -0 -m <monitor> -r -l 1.0 -E -e <regex> -- <roots>` (§6.4, §14.2):
+        il monitor è dichiarato per piattaforma, mai il default implicito;
+        `-E` = regex ERE (Extended Regular Expressions): senza, fswatch legge le
+        `-e` come BRE (Basic Regular Expressions) dove `(`/`|` sono letterali e
+        NESSUNA esclusione filtra (con un `.sync` in `$HOME` i path di `Library`
+        entrano nel matcher e il daemon satura in `walk_dir`)."""
+        argv = ['fswatch', '-0', '-m', fswatch_monitor(), '-r', '-l', '1.0', '-E']
         for regex in self.exclude_regexes():
             argv += ['-e', regex]
         return argv + ['--'] + self.discovery_roots()[0]
@@ -629,7 +640,7 @@ class Daemon:
                                 src, dst, e)
                     self.mark_pending(project, dest)
                 else:
-                    log.error('copia fallita %s → %s: %s', src, dst, e)
+                    log_copy_error(src, dst, e)
 
     def walk_dir(self, dirpath, project):
         """Mini-walk: i figli di una directory appena creata potrebbero non

{safekeep-0.5.0 → safekeep-0.5.2}/safekeep/platform.py

@@ -15,6 +15,7 @@ import os
 import platform as _platform
 import re
 import shutil
+import subprocess
 import sys
 from datetime import datetime
 
@@ -26,6 +27,9 @@ SYSTEMD_RUN_PATH = '/run/systemd/system'            # assente su WSL1/systemd of
 # EPERM (Errno 1) / EACCES (Errno 13) come li scrive il logger: codice errno
 # + testo del kernel (SPEC.md §14.4)
 PERM_ERR_RE = re.compile(r'\[Errno (?:1|13)\]|Operation not permitted|Permission denied')
+# suffisso del throttle (SPEC.md §10.1, 0.5.1): la riga rappresenta se stessa
+# + i N fallimenti compressi → count_24h la conta come N+1, non 1 (onesto)
+REPEAT_RE = re.compile(r'ripetuto (\d+) volte')
 
 
 def is_darwin():
@@ -75,7 +79,10 @@ def recent_permission_errors(path=None, now=None, window=86400):
     (SPEC.md §14.4: check non fatale, finestra 24h — segue l'incidente EPERM).
 
     Il timestamp è il prefisso `%(asctime)s` della riga (`YYYY-MM-DD HH:MM:SS`,
-    prime 19 posizioni). **Limite dichiarato**: una riga senza timestamp
+    prime 19 posizioni). Le righe col suffisso del throttle `— ripetuto N volte`
+    (§10.1) valgono **N + 1**: la riga stessa + i N fallimenti compressi, così
+    il conteggio resta il numero vero di errori anche con le righe throttolate.
+    **Limite dichiarato**: una riga senza timestamp
     parsificabile o fuori dalla finestra (clock skew incluso) non viene contata —
     non essendo sicuri che sia recente, non la contiamo: il conteggio è un minimo."""
     if path is None:
@@ -95,7 +102,8 @@ def recent_permission_errors(path=None, now=None, window=86400):
                 age = (now - ts).total_seconds()
                 if not 0 <= age <= window:
                     continue        # troppo vecchio (o nel futuro: clock skew)
-                count += 1
+                rep = REPEAT_RE.search(line)
+                count += 1 + (int(rep.group(1)) if rep else 0)
                 if last is None or ts > last:
                     last = ts
     except OSError:
@@ -103,6 +111,38 @@ def recent_permission_errors(path=None, now=None, window=86400):
     return count, last
 
 
+DAEMON_LABEL = 'com.safekeep.agent'          # label launchd dell'agent (§8.1)
+
+
+def daemon_exe(label=DAEMON_LABEL):
+    """→ eseguibile assoluto del processo launchd `label`, o None se non
+    determinabile (SPEC.md §8.4/§14.4, 0.5.1: job non caricato, processo non
+    trovato, `launchctl`/`ps` assenti o falliti, non-Darwin). Solo lettura.
+
+    Serve al check `doctor` (§14.4): un processo può girare su un eseguibile
+    **cancellato** da un upgrade sotto un daemon vivo (brew upgrade → path
+    Cellar sparito → TCC non identifica il processo → EPERM su ogni copia).
+    """
+    if not is_darwin():
+        return None
+    try:
+        job = subprocess.run(
+            ['launchctl', 'print', f'gui/{os.getuid()}/{label}'],
+            capture_output=True, text=True, timeout=10)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    pid = re.search(r'^\s*pid = (\d+)', job.stdout, re.M)
+    if job.returncode != 0 or pid is None:
+        return None                      # job non caricato o senza processo
+    try:
+        ps = subprocess.run(['ps', '-p', pid.group(1), '-o', 'comm='],
+                            capture_output=True, text=True, timeout=10)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    exe = ps.stdout.strip().splitlines()[0].strip() if ps.stdout.strip() else ''
+    return exe if ps.returncode == 0 and exe else None
+
+
 def linger_enabled(user=None, linger_dir=None):
     """`True`/`False` se l'utente è in `/var/lib/systemd/linger/`, None se la
     directory non c'è (niente systemd → non determinabile, SPEC.md §14.4).

{safekeep-0.5.0 → safekeep-0.5.2/safekeep.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: safekeep
-Version: 0.5.0
+Version: 0.5.2
 Summary: Selective always-on backups for macOS and Linux: fswatch-driven copy of allow-listed files, never deletes
 License-Expression: MIT
 Project-URL: Repository, https://github.com/foxhound87/safekeep
@@ -190,7 +190,7 @@ safekeep <command> [--config PATH] [-v]
 python3 -m unittest discover -s tests
 ```
 
-Stdlib (`unittest`) suite, zero dependencies: 206 tests covering the matcher,
+Stdlib (`unittest`) suite, zero dependencies: 221 tests covering the matcher,
 config, atomic copy, volumes, daemon, auto-discovery, CLI, the permission-trend
 wrapper and the POSIX portability layer (platform helper, per-OS fswatch
 monitor, systemd template).

{safekeep-0.5.0 → safekeep-0.5.2}/tests/test_cli.py

@@ -147,6 +147,42 @@ class DoctorTest(CliTestCase):
             self.assertEqual(r.returncode, 0, r.stdout)
 
 
+class DoctorExeDaemonTest(CliTestCase):
+    """SPEC.md §8.4/§14.4 (0.5.1): exe del processo launchd su disco —
+    esistente ✔, cancellato ✗ **non fatale**, non determinabile → saltato."""
+
+    def doctor_darwin(self, exe):
+        args = argparse.Namespace(config=self.cfg, v=False, json=False)
+        buf = io.StringIO()
+        with mock.patch.object(cli, 'is_darwin', return_value=True), \
+                mock.patch.object(cli, 'daemon_exe', return_value=exe), \
+                contextlib.redirect_stdout(buf):
+            code = cli.cmd_doctor(args)
+        line = next((l for l in buf.getvalue().splitlines()
+                     if 'exe del daemon' in l), '')
+        return code, buf.getvalue(), line
+
+    def test_exe_esistente_verde(self):
+        code, _, line = self.doctor_darwin(sys.executable)
+        self.assertTrue(line.startswith('✔'), line)
+        self.assertIn('presente su disco', line)
+        self.assertEqual(code, 0)
+
+    def test_exe_cancellato_warning_non_fatale(self):
+        exe = os.path.join(self.tmp, 'Cellar', 'python@3.14', '3.14.6', 'Python')
+        code, _, line = self.doctor_darwin(exe)          # non creato: inesistente
+        self.assertTrue(line.startswith('✗'), line)
+        for needle in ('NON esiste su disco', 'kickstart', 'warning non fatale'):
+            self.assertIn(needle, line)
+        self.assertEqual(code, 0, 'sintomo con rimedio manuale: NON fatale')
+
+    def test_non_determinabile_check_saltato(self):
+        code, _, line = self.doctor_darwin(None)
+        self.assertTrue(line.startswith('✔'), line)
+        self.assertIn('check saltato', line)
+        self.assertEqual(code, 0)
+
+
 class AutoDiscoveryCliTest(CliTestCase):
     """Config SENZA `source:` → modalità auto-discovery (SPEC.md §6)."""
 

{safekeep-0.5.0 → safekeep-0.5.2}/tests/test_copier.py

@@ -296,6 +296,27 @@ class ErroriPerFileTest(CopierTestCase):
         self.assertFalse(os.path.exists(self.dst_root),
                          'il walk si ferma: niente scritture a metà')
 
+    def test_reconcile_ripetuti_stessi_errori_pochissime_righe(self):
+        """SPEC.md §10.1 (0.5.1): 5 reconcile con gli stessi 3 file negati
+        (EPERM) → 3 righe di log (una per (path, errno)), non 15. I conteggi
+        in memoria restano intatti: 3 errori per passata."""
+        copier._copy_errors.clear()
+        self.addCleanup(copier._copy_errors.clear)
+
+        def boom(*args, **kwargs):
+            raise OSError(1, 'Operation not permitted')
+
+        with mock.patch.object(copier, 'copy_one', new=boom), \
+                mock.patch.object(copier.log, 'error') as errlog:
+            for _ in range(5):
+                stats = {}
+                reconcile_project(stats=stats, **self.kwargs)
+                self.assertEqual(stats['errati'], 3,
+                                 'il conteggio non passa dal log')
+        self.assertEqual(errlog.call_count, 3,
+                         'una riga per (path, errno), le 4 passate successive '
+                         'rientrano nell\'intervallo di throttle')
+
 
 class PruneTest(CopierTestCase):
     """`sync-once --prune`: cancellazione solo certa e solo sotto il prefisso."""
@@ -332,5 +353,51 @@ class PruneTest(CopierTestCase):
         self.assertTrue(os.path.exists(os.path.join(self.dst_root, 'proj/old.txt')))
 
 
+class ThrottleLogTest(CopierTestCase):
+    """SPEC.md §10.1 (0.5.1): stessa (path, errno) → ≤1 riga ogni
+    THROTTLE_INTERVAL con `— ripetuto N volte`, non una riga a fallimento."""
+
+    def setUp(self):
+        super().setUp()
+        copier._copy_errors.clear()
+        self.addCleanup(copier._copy_errors.clear)
+
+    @staticmethod
+    def err(no=1):
+        return OSError(no, 'Operation not permitted')
+
+    def test_50_failimenti_stesso_path_una_sola_riga(self):
+        with self.assertLogs(LOGGER, 'ERROR') as cm:
+            for _ in range(50):
+                copier.log_copy_error('/s/a', '/d/a', self.err(), now=1000.0)
+        self.assertEqual(len(cm.output), 1, cm.output)
+        self.assertNotIn('ripetuto', cm.output[0], 'nessun suffisso sulla 1ª riga')
+
+    def test_dopo_intervallo_una_riga_con_il_conteggio(self):
+        now = 1000.0
+        copier.log_copy_error('/s/a', '/d/a', self.err(), now=now)
+        with mock.patch.object(copier.log, 'error') as errlog:   # 9 dentro la finestra
+            for _ in range(9):
+                copier.log_copy_error('/s/a', '/d/a', self.err(), now=now)
+            errlog.assert_not_called()
+        with self.assertLogs(LOGGER, 'ERROR') as cm:             # finestra scaduta
+            copier.log_copy_error('/s/a', '/d/a', self.err(),
+                                  now=now + copier.THROTTLE_INTERVAL + 1)
+            for _ in range(5):                                   # poi di nuovo silenzio
+                copier.log_copy_error('/s/a', '/d/a', self.err(),
+                                      now=now + copier.THROTTLE_INTERVAL + 1)
+        self.assertEqual(len(cm.output), 1, cm.output)
+        self.assertIn('ripetuto 9 volte', cm.output[0])
+
+    def test_chiavi_distinte_indipendenti(self):
+        now = 1000.0
+        with self.assertLogs(LOGGER, 'ERROR') as cm:
+            copier.log_copy_error('/s/a', '/d/a', self.err(1), now=now)
+            copier.log_copy_error('/s/a', '/d/a', self.err(1), now=now)
+            copier.log_copy_error('/s/b', '/d/b', self.err(1), now=now)
+            copier.log_copy_error('/s/a', '/d/a', self.err(13), now=now)
+        self.assertEqual(len(cm.output), 3, cm.output)      # (a,1) una + b + (a,13)
+
+
 if __name__ == '__main__':
     unittest.main()

{safekeep-0.5.0 → safekeep-0.5.2}/tests/test_daemon.py

@@ -433,6 +433,10 @@ class FswatchArgvTest(unittest.TestCase):
         self.assertEqual(argv[:3], ['fswatch', '-0', '-m'])
         self.assertIn(argv[3], ('fsevents_monitor', 'inotify_monitor'))
         self.assertEqual(argv[4:7], ['-r', '-l', '1.0'])
+        # `-E` obbligatorio: fswatch legge le `-e` come BRE (gruppi/alternanze
+        # letterali) e le esclusioni non filtrerebbero più nulla
+        self.assertIn('-E', argv)
+        self.assertLess(argv.index('-E'), argv.index('-e') if '-e' in argv else len(argv))
         regexes = [argv[i + 1] for i, a in enumerate(argv) if a == '-e']
         self.assertTrue(regexes)
         self.assertTrue(any(re.search(rx, '/qualcuno/node_modules/x') for rx in regexes))

{safekeep-0.5.0 → safekeep-0.5.2}/tests/test_platform.py

@@ -146,6 +146,21 @@ class AgentTemplateTest(unittest.TestCase):
         for needle in ('RunAtLoad', 'KeepAlive', '__REPO__', '__PYTHON__'):
             self.assertIn(needle, text, needle)
 
+    def test_install_sh_interprete_stabile(self):
+        """SPEC.md §8.4 (0.5.1): il default renderizzato è lo shim di sistema
+        /usr/bin/python3, MAI un path Cellar di Homebrew — un `brew upgrade`
+        cancella il Cellar sotto il processo vivo e TCC non lo identifica più."""
+        with open(os.path.join(REPO, 'install.sh'), encoding='utf-8') as fh:
+            text = fh.read()
+        self.assertIn('SAFEKEEP_PYTHON:-/usr/bin/python3', text)
+        self.assertNotIn('/opt/homebrew/bin/python3', text,
+                         'il default non deve più puntare al Cellar di brew')
+        self.assertIn('py_ok', text, "validazione ≥ 3.9 dell'interprete")
+        for name in ('com.safekeep.agent.plist', 'com.safekeep.trend.plist'):
+            with open(os.path.join(REPO, 'launchd', name), encoding='utf-8') as fh:
+                tpl = fh.read()
+            self.assertIn('default: /usr/bin/python3', tpl, name)
+
 
 class RecentPermissionErrorsTest(unittest.TestCase):
     """SPEC.md §14.4: errori di permesso recenti nel log, finestra 24h,
@@ -199,6 +214,78 @@ class RecentPermissionErrorsTest(unittest.TestCase):
                 self.assertIsNotNone(plat.PERM_ERR_RE.search(riga))
         self.assertIsNone(plat.PERM_ERR_RE.search('INFO reconcile: 0 copie'))
 
+    def test_suffisso_ripetuto_del_throttle_contato_come_N_piu_1(self):
+        """SPEC.md §10.1/§14.4 (0.5.1): una riga `— ripetuto N volte`
+        rappresenta se stessa + i N fallimenti compressi → count_24h resta il
+        numero VERO di errori anche con le righe throttolate."""
+        text = (
+            f'{self._stamp(self.NOW - timedelta(hours=2))} ERROR copia fallita '
+            "a → b: [Errno 1] Operation not permitted: '/x.tmp.1'\n"
+            f'{self._stamp(self.NOW - timedelta(hours=1))} ERROR copia fallita '
+            "a → b: [Errno 1] Operation not permitted: '/x.tmp.1' — ripetuto 49 volte\n"
+        )
+        count, last = plat.recent_permission_errors(self._log(text), now=self.NOW)
+        self.assertEqual(count, 1 + 1 + 49, 'riga base + (riga suffisso + 49)')
+        self.assertEqual(last, self.NOW - timedelta(hours=1))
+
+    def test_riga_senza_suffisso_restano_una_ciascuna(self):
+        text = (f'{self._stamp(self.NOW - timedelta(hours=2))} ERROR copia fallita '
+                "a → b: [Errno 1] Operation not permitted: '/x'\n"
+                f'{self._stamp(self.NOW - timedelta(hours=1))} ERROR copia fallita '
+                "a → b: [Errno 1] Operation not permitted: '/y'\n")
+        count, _ = plat.recent_permission_errors(self._log(text), now=self.NOW)
+        self.assertEqual(count, 2)
+
+
+class DaemonExeTest(unittest.TestCase):
+    """SPEC.md §14.4 (0.5.1): exe del processo launchd, None se non
+    determinabile — Darwin-only, solo lettura, casi finti."""
+
+    LAUNCHCTL_OK = subprocess.CompletedProcess(
+        [], 0, stdout='\tstate = running\n\tpid = 4242\n', stderr='')
+    PS_OK = subprocess.CompletedProcess(
+        [], 0, stdout='/opt/shim/python3\n', stderr='')
+
+    def run_mock(self, results):
+        with mock.patch('sys.platform', 'darwin'), \
+                mock.patch.object(plat.subprocess, 'run',
+                                  side_effect=results) as run:
+            return plat.daemon_exe(), run
+
+    def test_non_darwin_ritorna_none_senza_lanciare_niente(self):
+        with mock.patch('sys.platform', 'linux'), \
+                mock.patch.object(plat.subprocess, 'run') as run:
+            self.assertIsNone(plat.daemon_exe())
+            run.assert_not_called()
+
+    def test_job_non_caricato_o_senza_pid(self):
+        for result in (subprocess.CompletedProcess([], 1, stdout='slot absent', stderr=''),
+                       subprocess.CompletedProcess([], 0, stdout='state = not running\n',
+                                                   stderr='')):
+            with self.subTest(result=result.stdout):
+                exe, run = self.run_mock([result])
+                self.assertIsNone(exe)
+        # job ok ma `ps` fallito → non determinabile
+        exe, _ = self.run_mock([self.LAUNCHCTL_OK,
+                                subprocess.CompletedProcess([], 1, stdout='', stderr='x')])
+        self.assertIsNone(exe)
+
+    def test_launchctl_o_ps_assenti(self):
+        exe, run = self.run_mock([OSError('launchctl mancante')])
+        self.assertIsNone(exe)
+
+    def test_eseguibile_letto_da_ps(self):
+        exe, run = self.run_mock([self.LAUNCHCTL_OK, self.PS_OK])
+        self.assertEqual(exe, '/opt/shim/python3')
+        self.assertEqual(run.call_args_list[1].args[0][:4],
+                         ['ps', '-p', '4242', '-o'])
+
+    def test_ps_senza_output(self):
+        exe, _ = self.run_mock([self.LAUNCHCTL_OK,
+                                subprocess.CompletedProcess([], 0, stdout='\n',
+                                                            stderr='')])
+        self.assertIsNone(exe)
+
 
 class LingerTest(unittest.TestCase):
     """SPEC.md §14.4: linger systemd, directory finta al posto di