safekeep 0.3.1__tar.gz → 0.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: safekeep
-Version: 0.3.1
+Version: 0.5.0
 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
@@ -182,7 +182,7 @@ safekeep <command> [--config PATH] [-v]
 | `run` | daemon: initial reconcile, fswatch loop, event dispatch, 24h timer |
 | `sync-once [--dry-run] [--project PATH] [--prune]` | a single pass: walks the source and copies whatever differs (`--dry-run` only prints what it would copy; `--prune` also removes dest files whose source still exists but is no longer included) |
 | `status` | read-only: config, sources, discovered projects with N rules, destination states |
-| `doctor` | diagnostics: config, fswatch + platform monitor, python, TCC/launchd plist (macOS), inotify limit and systemd unit (Linux) — exits non-zero if a fatal check fails |
+| `doctor [--json]` | diagnostics: config, fswatch + platform monitor, python, TCC/launchd plist (macOS), inotify limit and systemd unit (Linux) — exits non-zero if a fatal check fails; `--json` prints the same checks as one JSON document on stdout with the same exit code, including a structured `permission_errors` count of the last 24h |
 
 ## Tests
 
@@ -190,9 +190,10 @@ safekeep <command> [--config PATH] [-v]
 python3 -m unittest discover -s tests
 ```
 
-Stdlib (`unittest`) suite, zero dependencies: 175 tests covering the matcher,
-config, atomic copy, volumes, daemon, auto-discovery, CLI and the POSIX
-portability layer (platform helper, per-OS fswatch monitor, systemd template).
+Stdlib (`unittest`) suite, zero dependencies: 206 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).
 `fswatch` is not needed to run the suite — the few `doctor` checks that talk to
 the real binary are skipped when it's missing — but CI installs it so the
 Linux job exercises the real `inotify` monitor.

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

@@ -157,7 +157,7 @@ safekeep <command> [--config PATH] [-v]
 | `run` | daemon: initial reconcile, fswatch loop, event dispatch, 24h timer |
 | `sync-once [--dry-run] [--project PATH] [--prune]` | a single pass: walks the source and copies whatever differs (`--dry-run` only prints what it would copy; `--prune` also removes dest files whose source still exists but is no longer included) |
 | `status` | read-only: config, sources, discovered projects with N rules, destination states |
-| `doctor` | diagnostics: config, fswatch + platform monitor, python, TCC/launchd plist (macOS), inotify limit and systemd unit (Linux) — exits non-zero if a fatal check fails |
+| `doctor [--json]` | diagnostics: config, fswatch + platform monitor, python, TCC/launchd plist (macOS), inotify limit and systemd unit (Linux) — exits non-zero if a fatal check fails; `--json` prints the same checks as one JSON document on stdout with the same exit code, including a structured `permission_errors` count of the last 24h |
 
 ## Tests
 
@@ -165,9 +165,10 @@ safekeep <command> [--config PATH] [-v]
 python3 -m unittest discover -s tests
 ```
 
-Stdlib (`unittest`) suite, zero dependencies: 175 tests covering the matcher,
-config, atomic copy, volumes, daemon, auto-discovery, CLI and the POSIX
-portability layer (platform helper, per-OS fswatch monitor, systemd template).
+Stdlib (`unittest`) suite, zero dependencies: 206 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).
 `fswatch` is not needed to run the suite — the few `doctor` checks that talk to
 the real binary are skipped when it's missing — but CI installs it so the
 Linux job exercises the real `inotify` monitor.

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

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

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

@@ -4,11 +4,15 @@ Entry point del package (`safekeep.cli:main`): `bin/safekeep.py` è solo lo
 shim che usano launchd/systemd e i test.
 """
 import argparse
+import json
 import os
+import re
 import shutil
 import subprocess
 import sys
+from datetime import datetime
 
+from safekeep import __version__
 from safekeep.config import ConfigError, discover_projects, parse_sync
 from safekeep.copier import TMP_INFIX
 from safekeep.daemon import Daemon, setup_logging
@@ -20,8 +24,11 @@ from safekeep.platform import (
     install_hint,
     is_darwin,
     is_linux,
+    is_wsl,
     linger_enabled,
     recent_permission_errors,
+    systemd_user_available,
+    wsl_distro,
 )
 from safekeep.volumes import dest_state
 
@@ -55,11 +62,14 @@ def build_parser():
                            'non è più incluso dal matcher (default: mai cancellare)')
     sub.add_parser('status', parents=[common],
                    help='config, progetti e stato delle dest — sola lettura')
-    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')
+    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')
+    doc.add_argument('--json', action='store_true',
+                     help='stessi check, stesso exit code, ma un documento JSON su '
+                          'stdout (SPEC.md §9.1)')
     return parser
 
 
@@ -141,12 +151,28 @@ def check_sync_files(daemon):
 
 
 def cmd_doctor(args):
-    """Un check per riga con esito ✔/✗; exit 1 se almeno un check fatale fallisce."""
+    """Un check per riga con esito ✔/✗; exit 1 se almeno un check fatale fallisce.
+
+    Con `--json` le righe non vengono stampate: la stessa sequenza di check finisce
+    in un documento JSON su stdout, con lo stesso exit code (SPEC.md §9.1)."""
     fatal = False
+    checks, ids = [], {}
 
     def out(ok, msg, is_fatal=False):
         nonlocal fatal
-        print(('✔ ' if ok else '✗ ') + msg)
+        if args.json:
+            # id = slug del messaggio (prefisso fino a ':' o '('), id uguali
+            # ripetuti suffissati _2/_3 così restano chiave usabile (SPEC §9.1)
+            base = re.split(r'[:\(]', msg, maxsplit=1)[0]
+            ident = re.sub(r'[^a-z0-9]+', '_', base.lower()).strip('_') or 'check'
+            ids[ident] = ids.get(ident, 0) + 1
+            if ids[ident] > 1:
+                ident = f'{ident}_{ids[ident]}'
+            checks.append({'id': ident,
+                           'status': 'ok' if ok else ('fail' if is_fatal else 'warn'),
+                           'message': msg})
+        else:
+            print(('✔ ' if ok else '✗ ') + msg)
         if not ok and is_fatal:
             fatal = True
 
@@ -244,6 +270,23 @@ def cmd_doctor(args):
     else:
         out(True, f'errori di permesso recenti: nessuno nelle ultime 24h — log: {log}')
 
+    # WSL (SPEC.md §17.2): tre righe informative — nessuna è mai fatale
+    if is_wsl():
+        out(True, f'WSL rilevato: {wsl_distro() or "sconosciuta"} '
+                  '(supporto best-effort, SPEC §17)')
+        if not systemd_user_available():
+            out(False, 'systemd user non disponibile (WSL1 o systemd spento) — '
+                       'abilita systemd in /etc/wsl.conf: [boot] systemd=true '
+                       '(poi wsl --shutdown da Windows) oppure esegui '
+                       '`safekeep run` a mano — warning non fatale')
+        if daemon is not None:
+            sotto_mnt = [p for p in list(daemon.cfg.sources)
+                         + list(daemon.cfg.dests) if p.startswith('/mnt/')]
+            if sotto_mnt:
+                out(True, f'drvfs: {len(sotto_mnt)} path sotto /mnt/ — I/O lento '
+                          'e case-insensitive di default: valuta una dest su ext4 '
+                          'nativa della distro (SPEC §17.2)')
+
     # Linux: il limite di watch di inotify è il rischio #1 sugli alberi grandi
     # (SPEC.md §14.4) — informativo, NON fatale
     if is_linux():
@@ -326,7 +369,20 @@ def cmd_doctor(args):
                            'senza login → loginctl enable-linger $USER — '
                            'warning non fatale')
 
-    return 1 if fatal else 0
+    code = 1 if fatal else 0
+    if args.json:
+        count, last = recent if recent is not None else (0, None)
+        print(json.dumps({
+            'safekeep': __version__,
+            'timestamp': datetime.now().isoformat(timespec='seconds'),
+            'exit': code,
+            'checks': checks,
+            'permission_errors': {
+                'count_24h': count,
+                'last': last.strftime('%Y-%m-%d %H:%M:%S') if last else None,
+            },
+        }, ensure_ascii=False, indent=2))
+    return code
 
 
 def main(argv=None):

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

@@ -1,9 +1,10 @@
 """Rilevamento piattaforma (SPEC.md §14.1): l'unico posto che legge `sys.platform`.
 
 Funzioni/constanti minime: monitor fswatch atteso, hint di installazione,
-init system, limite di watch di inotify, log corrente, linger systemd.
-Tutto letto **a chiamata** (mai a import), così i test patchano `sys.platform`
-ed esercitano entrambi i rami anche girando su una sola piattaforma.
+init system, limite di watch di inotify, log corrente, linger systemd,
+rilevamento WSL. Tutto letto **a chiamata** (mai a import), così i test
+patchano `sys.platform` ed esercitano entrambi i rami anche girando su una
+sola piattaforma.
 
 I nomi dei monitor sono quelli stampati da `fswatch -M`: `fsevents_monitor`
 (FSEvents, macOS) e `inotify_monitor` (inotify, Linux) — attenzione, su Linux
@@ -11,6 +12,7 @@ il nome NON è `inotify` (SPEC.md §14.2).
 """
 import getpass
 import os
+import platform as _platform
 import re
 import shutil
 import sys
@@ -20,6 +22,7 @@ INOTIFY_LIMIT_PATH = '/proc/sys/fs/inotify/max_user_watches'
 INOTIFY_MIN_WATCHES = 16384        # sotto questa soglia un home medio lo supera
 LOG_PATH = '~/.local/state/safekeep/safekeep.log'   # log corrente (SPEC.md §3)
 LINGER_DIR = '/var/lib/systemd/linger'
+SYSTEMD_RUN_PATH = '/run/systemd/system'            # assente su WSL1/systemd off
 # 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')
@@ -117,3 +120,28 @@ def linger_enabled(user=None, linger_dir=None):
         except OSError:
             return None
     return user in entries
+
+
+def is_wsl():
+    """True dentro WSL (Windows Subsystem for Linux) — SPEC.md §17.1.
+
+    `sys.platform` resta `linux` su WSL: il rilevamento passa dall'env
+    `WSL_DISTRO_NAME` (ogni distro WSL lo settà) oppure dal kernel
+    (`platform.release()` contiene `microsoft` su WSL1 e WSL2)."""
+    if os.environ.get('WSL_DISTRO_NAME'):
+        return True
+    return 'microsoft' in _platform.release().lower()
+
+
+def wsl_distro():
+    """Nome della distro WSL (env `WSL_DISTRO_NAME`), vuoto se assente —
+    SPEC.md §17.1."""
+    return os.environ.get('WSL_DISTRO_NAME', '')
+
+
+def systemd_user_available(path=None):
+    """True se c'è un init systemd vivo (`/run/systemd/system`): assente su
+    WSL1 o con systemd spento in WSL2 — SPEC.md §17.2."""
+    if path is None:
+        path = SYSTEMD_RUN_PATH
+    return os.path.exists(path)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: safekeep
-Version: 0.3.1
+Version: 0.5.0
 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
@@ -182,7 +182,7 @@ safekeep <command> [--config PATH] [-v]
 | `run` | daemon: initial reconcile, fswatch loop, event dispatch, 24h timer |
 | `sync-once [--dry-run] [--project PATH] [--prune]` | a single pass: walks the source and copies whatever differs (`--dry-run` only prints what it would copy; `--prune` also removes dest files whose source still exists but is no longer included) |
 | `status` | read-only: config, sources, discovered projects with N rules, destination states |
-| `doctor` | diagnostics: config, fswatch + platform monitor, python, TCC/launchd plist (macOS), inotify limit and systemd unit (Linux) — exits non-zero if a fatal check fails |
+| `doctor [--json]` | diagnostics: config, fswatch + platform monitor, python, TCC/launchd plist (macOS), inotify limit and systemd unit (Linux) — exits non-zero if a fatal check fails; `--json` prints the same checks as one JSON document on stdout with the same exit code, including a structured `permission_errors` count of the last 24h |
 
 ## Tests
 
@@ -190,9 +190,10 @@ safekeep <command> [--config PATH] [-v]
 python3 -m unittest discover -s tests
 ```
 
-Stdlib (`unittest`) suite, zero dependencies: 175 tests covering the matcher,
-config, atomic copy, volumes, daemon, auto-discovery, CLI and the POSIX
-portability layer (platform helper, per-OS fswatch monitor, systemd template).
+Stdlib (`unittest`) suite, zero dependencies: 206 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).
 `fswatch` is not needed to run the suite — the few `doctor` checks that talk to
 the real binary are skipped when it's missing — but CI installs it so the
 Linux job exercises the real `inotify` monitor.

{safekeep-0.3.1 → safekeep-0.5.0}/safekeep.egg-info/SOURCES.txt

@@ -20,4 +20,5 @@ tests/test_copier.py
 tests/test_daemon.py
 tests/test_matcher.py
 tests/test_platform.py
+tests/test_trend.py
 tests/test_volumes.py

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

@@ -6,6 +6,7 @@ import argparse
 import contextlib
 import getpass
 import io
+import json
 import os
 import shutil
 import subprocess
@@ -110,7 +111,7 @@ class DoctorTest(CliTestCase):
         """SPEC.md §14.4: su Linux il limite di watch basso è informativo —
         doctor esce 0, non 1. I rami Linux si esercitano patchando l'helper,
         senza girare su Linux."""
-        args = argparse.Namespace(config=self.cfg, v=False)
+        args = argparse.Namespace(config=self.cfg, v=False, json=False)
         buf = io.StringIO()
         with mock.patch.object(cli, 'is_linux', return_value=True), \
                 mock.patch.object(cli, 'is_darwin', return_value=False), \
@@ -329,7 +330,7 @@ class DoctorLingerTest(CliTestCase):
         self.addCleanup(shutil.rmtree, linger_dir, ignore_errors=True)
         for name in linger:
             open(os.path.join(linger_dir, name), 'w').close()
-        args = argparse.Namespace(config=self.cfg, v=False)
+        args = argparse.Namespace(config=self.cfg, v=False, json=False)
         buf = io.StringIO()
         with mock.patch.dict(os.environ, {'HOME': self.home}), \
                 mock.patch.object(cli, 'is_linux', return_value=True), \
@@ -363,5 +364,144 @@ class DoctorLingerTest(CliTestCase):
         self.assertEqual(code, 0, out)
 
 
+class DoctorWslTest(CliTestCase):
+    """SPEC.md §17.2: le tre righe WSL di `doctor` sono informative e non fatali."""
+
+    def doctor_wsl(self, distro='Ubuntu', systemd=False, dest='/mnt/c/backup'):
+        cfg = write(os.path.join(self.tmp, 'wsl.cfg'), f'dest: {dest}\n')
+        args = argparse.Namespace(config=cfg, v=False, json=False)
+        buf = io.StringIO()
+        with mock.patch.dict(os.environ, {'HOME': self.home}), \
+                mock.patch.object(cli, 'is_wsl', return_value=True), \
+                mock.patch.object(cli, 'wsl_distro', return_value=distro), \
+                mock.patch.object(cli, 'systemd_user_available',
+                                  return_value=systemd), \
+                contextlib.redirect_stdout(buf):
+            code = cli.cmd_doctor(args)
+        return code, buf.getvalue()
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_wsle_righe_con_hint_systemd_e_drvfs(self):
+        code, out = self.doctor_wsl()
+        self.assertIn('✔ WSL rilevato: Ubuntu', out)
+        hint = next(l for l in out.splitlines()
+                    if 'systemd user non disponibile' in l)
+        self.assertTrue(hint.startswith('✗'), hint)
+        for needle in ('/etc/wsl.conf', 'systemd=true', 'safekeep run',
+                       'warning non fatale'):
+            self.assertIn(needle, hint, needle)
+        drvfs = next(l for l in out.splitlines() if 'drvfs' in l)
+        self.assertIn('/mnt/', drvfs)
+        self.assertEqual(code, 0, out)                     # mai fatale
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_systemd_attivo_nessun_hint(self):
+        code, out = self.doctor_wsl(systemd=True)
+        self.assertNotIn('systemd user non disponibile', out)
+        self.assertIn('WSL rilevato', out)
+        self.assertEqual(code, 0, out)
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_nessun_path_sotto_mnt_niente_drvfs(self):
+        code, out = self.doctor_wsl(dest=os.path.join(self.tmp, 'dst'))
+        self.assertNotIn('drvfs', out)
+        self.assertEqual(code, 0, out)
+
+    def test_detection_reale_via_env_fino_a_doctor(self):
+        """Detection reale (env) fino all'output di doctor: niente patch."""
+        env = dict(os.environ, HOME=self.home, WSL_DISTRO_NAME='Debian')
+        r = subprocess.run([sys.executable, CLI, 'doctor', '--config', self.cfg],
+                           capture_output=True, text=True, env=env, cwd=REPO,
+                           timeout=60)
+        self.assertIn('WSL rilevato: Debian', r.stdout)
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_senza_wsl_nulla_cambia(self):
+        """Su Linux/macOS non-WSL nessuna riga WSL compare (SPEC §17)."""
+        env = {k: v for k, v in os.environ.items() if k != 'WSL_DISTRO_NAME'}
+        env['HOME'] = self.home
+        r = subprocess.run([sys.executable, CLI, 'doctor', '--config', self.cfg],
+                           capture_output=True, text=True, env=env, cwd=REPO,
+                           timeout=60)
+        self.assertNotIn('WSL', r.stdout)
+        self.assertNotIn('drvfs', r.stdout)
+
+
+class DoctorJsonTest(CliTestCase):
+    """SPEC.md §9.1: `doctor --json` — stessi check, stesso ordine, stesso exit
+    code della modalità normale, tutto in un documento JSON su stdout."""
+
+    def json_doctor(self, *args):
+        r = self.cli('doctor', '--json', *args)
+        # json.loads sul stdout intero: basta una riga di log mista e cade qui
+        return r, json.loads(r.stdout)
+
+    @staticmethod
+    def righe(stdout):
+        """`(status_atteso, message)` di ogni riga della modalità normale."""
+        out = []
+        for line in stdout.splitlines():
+            if not line.strip():
+                continue
+            status = 'ok' if line.startswith('✔') else 'fail-o-warn'
+            out.append((status, line[2:]))
+        return out
+
+    def test_checks_1a1_con_la_modalita_normale(self):
+        normale = self.cli('doctor', '--config', self.cfg)
+        r, doc = self.json_doctor('--config', self.cfg)
+        attese = self.righe(normale.stdout)
+        self.assertEqual([c['message'] for c in doc['checks']],
+                         [msg for _, msg in attese],
+                         'stessi check, stesso ordine della modalità normale')
+        for (atteso, _), check in zip(attese, doc['checks']):
+            if atteso == 'ok':
+                self.assertEqual(check['status'], 'ok', check)
+            else:                                   # riga ✗: warn o fail
+                self.assertIn(check['status'], ('warn', 'fail'), check)
+        self.assertEqual(len({c['id'] for c in doc['checks']}),
+                         len(doc['checks']), 'id duplicati')
+        self.assertEqual(r.returncode, normale.returncode, 'stesso exit code')
+        self.assertEqual(doc['exit'], r.returncode)
+
+    def test_header_e_campi_decisionali(self):
+        _, doc = self.json_doctor('--config', self.cfg)
+        self.assertEqual(doc['safekeep'], cli.__version__)
+        datetime.fromisoformat(doc['timestamp'])            # ISO 8601 valido
+        self.assertIsInstance(doc['checks'], list)
+        self.assertTrue(doc['checks'])
+        for check in doc['checks']:
+            self.assertEqual(set(check), {'id', 'status', 'message'})
+            self.assertIn(check['status'], ('ok', 'warn', 'fail'))
+        self.assertEqual(set(doc['permission_errors']), {'count_24h', 'last'})
+
+    def test_permission_errors_strutturati_sul_log_recente(self):
+        log = os.path.join(self.home, '.local/state/safekeep/safekeep.log')
+        stamp = (datetime.now() - timedelta(hours=3)).strftime('%Y-%m-%d %H:%M:%S')
+        write(log, f'{stamp},000 ERROR copia fallita: [Errno 1] Operation not permitted\n')
+        r, doc = self.json_doctor('--config', self.cfg)
+        perm = doc['permission_errors']
+        self.assertEqual(perm['count_24h'], 1)
+        self.assertEqual(perm['last'], stamp)               # ultimo timestamp
+        check = next(c for c in doc['checks']
+                     if 'errori di permesso' in c['message'])
+        self.assertEqual(check['status'], 'warn')           # warning, NON fatale
+        self.assertEqual(r.returncode, 0, r.stdout)
+
+    def test_log_assente_count_zero_last_null(self):
+        _, doc = self.json_doctor('--config', self.cfg)     # HOME finto: niente log
+        self.assertEqual(doc['permission_errors'],
+                         {'count_24h': 0, 'last': None})
+
+    @unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+    def test_check_fatale_esce_1_e_lo_dichiara(self):
+        bad = write(os.path.join(self.tmp, 'bad.cfg'), 'riga nuda invalida\n')
+        r, doc = self.json_doctor('--config', bad)
+        self.assertEqual(r.returncode, 1, r.stdout)
+        self.assertEqual(doc['exit'], 1)
+        self.assertTrue(any(c['status'] == 'fail' for c in doc['checks']),
+                        'il check fatale deve comparire come fail')
+
+
 if __name__ == '__main__':
     unittest.main()

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

@@ -227,5 +227,70 @@ class LingerTest(unittest.TestCase):
             self.assertFalse(plat.linger_enabled(linger_dir=self._dir()))
 
 
+class WslTest(unittest.TestCase):
+    """SPEC.md §17.1: rilevamento WSL via env o kernel, letto a chiamata."""
+
+    def test_env_wsl_distro_name(self):
+        with mock.patch.dict(os.environ, {'WSL_DISTRO_NAME': 'Ubuntu'}):
+            self.assertTrue(plat.is_wsl())
+            self.assertEqual(plat.wsl_distro(), 'Ubuntu')
+
+    def test_kernel_microsoft_senza_env(self):
+        for release in ('5.15.167.4-microsoft-standard-WSL2',   # WSL2
+                        '4.4.0-19041-Microsoft'):              # WSL1 (maiuscolo)
+            with self.subTest(release=release), \
+                    mock.patch.dict(os.environ, {'WSL_DISTRO_NAME': ''}), \
+                    mock.patch.object(plat, '_platform') as p:
+                p.release.return_value = release
+                self.assertTrue(plat.is_wsl())
+                self.assertEqual(plat.wsl_distro(), '')
+
+    def test_non_wsl(self):
+        with mock.patch.dict(os.environ, {'WSL_DISTRO_NAME': ''}), \
+                mock.patch.object(plat, '_platform') as p:
+            p.release.return_value = '24.6.0'             # macOS, niente microsoft
+            self.assertFalse(plat.is_wsl())
+            self.assertEqual(plat.wsl_distro(), '')
+
+    def test_systemd_user_available(self):
+        with tempfile.TemporaryDirectory() as d:
+            self.assertTrue(plat.systemd_user_available(path=d))
+        self.assertFalse(
+            plat.systemd_user_available(path='/non/esiste/qui'),
+            '/run/systemd/system assente = WSL1 o systemd spento (SPEC §17.2)')
+
+
+@unittest.skipUnless(shutil.which('fswatch'), 'fswatch non installato')
+class InstallShSenzaSystemdTest(unittest.TestCase):
+    """SPEC.md §17.3: `install.sh` su Linux senza systemd → unit NON installata,
+    istruzioni di avvio manuale ed exit 0 (nessun errore duro)."""
+
+    def test_ramo_linux_senza_systemd_esce_0(self):
+        if os.path.isdir('/run/systemd/system'):
+            self.skipTest('questa macchina ha systemd: ramo diverso')
+        tmp = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, tmp, ignore_errors=True)
+        home, fake_bin = os.path.join(tmp, 'home'), os.path.join(tmp, 'bin')
+        os.makedirs(home)
+        os.makedirs(fake_bin)
+        uname = os.path.join(fake_bin, 'uname')            # uname finto → Linux
+        with open(uname, 'w') as fh:
+            fh.write('#!/bin/bash\necho Linux\n')
+        os.chmod(uname, 0o755)
+        env = dict(os.environ, HOME=home,
+                   PATH=fake_bin + os.pathsep + os.environ['PATH'])
+        r = subprocess.run(['bash', os.path.join(REPO, 'install.sh')],
+                           capture_output=True, text=True, env=env, timeout=60)
+        self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+        self.assertIn('systemd non disponibile', r.stdout)
+        self.assertIn('safekeep.py run', r.stdout)         # avvio manuale
+        self.assertIn('systemd=true', r.stdout)            # hint /etc/wsl.conf
+        self.assertTrue(os.path.exists(os.path.join(home, '.safekeep')),
+                        'la config viene creata comunque')
+        self.assertFalse(os.path.exists(
+            os.path.join(home, '.config/systemd/user/safekeep.service')),
+            'niente unit senza systemd')
+
+
 if __name__ == '__main__':
     unittest.main()

safekeep-0.5.0/tests/test_trend.py

@@ -0,0 +1,80 @@
+"""SPEC.md §9.2: `bin/safekeep-trend.sh` — wrapper trend errori di permesso.
+
+Ogni run è un subprocess con HOME finto: niente scritture nella home reale e
+niente tocco ai log reali. Copre: header scritto una sola volta (idempotente),
+riga parseabile a 4 campi, riga appendata anche quando `doctor` esce 1, override
+del path CSV via env.
+"""
+import os
+import shutil
+import subprocess
+import tempfile
+import unittest
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+TREND = os.path.join(REPO, 'bin', 'safekeep-trend.sh')
+HEADER = 'timestamp,exit,count_24h,last'
+
+
+@unittest.skipUnless(shutil.which('bash'), 'bash non disponibile')
+class TrendTestCase(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, self.tmp, ignore_errors=True)
+        self.home = os.path.join(self.tmp, 'home')        # HOME finto
+        os.makedirs(self.home)
+        self.csv = os.path.join(self.home, '.local', 'state', 'safekeep',
+                                'permission-trend.csv')
+
+    def trend(self, *args, csv=None):
+        env = dict(os.environ, HOME=self.home)
+        if csv is not None:
+            env['SAFEKEEP_TREND_CSV'] = csv
+        return subprocess.run(['bash', TREND, *args], capture_output=True,
+                              text=True, env=env, cwd=REPO, timeout=120)
+
+    def lines(self, path=None):
+        with open(path or self.csv, encoding='utf-8') as fh:
+            return fh.read().splitlines()
+
+    def test_header_e_riga_parseabile(self):
+        r = self.trend()
+        self.assertEqual(r.returncode, 0, r.stderr)
+        lines = self.lines()
+        self.assertEqual(lines[0], HEADER)
+        self.assertEqual(len(lines), 2)                   # header + 1 run
+        row = lines[1].split(',')
+        self.assertEqual(len(row), 4)                     # split campi, niente quoting
+        self.assertEqual(row[1], '0')                     # exit di doctor (JSON §9.1)
+        self.assertEqual(int(row[2]), int(row[2]))        # count_24h intero
+        self.assertTrue(row[0].startswith('20'))          # timestamp ISO 8601
+
+    def test_run_multipla_non_duplica_header(self):
+        self.assertEqual(self.trend().returncode, 0)
+        self.assertEqual(self.trend().returncode, 0)
+        lines = self.lines()
+        self.assertEqual(len(lines), 3)                   # header + 2 run
+        self.assertEqual(lines.count(HEADER), 1)          # header una sola volta
+        self.assertEqual(lines[0], HEADER)
+
+    def test_doctor_exit_1_genera_comunque_riga(self):
+        # config inesistente passata esplicitamente → check fatale → exit 1,
+        # ma l'exit code è un dato: la riga va scritta (SPEC §9.2)
+        missing = os.path.join(self.tmp, 'non-esiste.cfg')
+        r = self.trend('--config', missing)
+        self.assertEqual(r.returncode, 0, r.stderr)
+        row = self.lines()[1].split(',')
+        self.assertEqual(row[1], '1')
+        self.assertEqual(int(row[2]), int(row[2]))
+
+    def test_override_csv_path(self):
+        alt = os.path.join(self.tmp, 'alt', 'trend.csv')
+        r = self.trend(csv=alt)
+        self.assertEqual(r.returncode, 0, r.stderr)
+        self.assertTrue(os.path.exists(alt))
+        self.assertFalse(os.path.exists(self.csv))        # default non toccato
+        self.assertEqual(self.lines(alt)[0], HEADER)
+
+
+if __name__ == '__main__':
+    unittest.main()