diff --git a/beta/codes.py b/beta/codes.py index 85b225a..620af95 100644 --- a/beta/codes.py +++ b/beta/codes.py @@ -7,6 +7,8 @@ python beta/codes.py journal [--n 30] python beta/codes.py retours [--n 30] python beta/codes.py testeurs + python beta/codes.py effacer-testeur [--oui] + python beta/codes.py purger --avant AAAA-MM-JJ [--appliquer] Le code en clair n'est affiché qu'une seule fois, à la génération. """ @@ -56,6 +58,9 @@ def main(argv=None): j = sp.add_parser("journal"); j.add_argument("--n", type=int, default=30) f = sp.add_parser("retours"); f.add_argument("--n", type=int, default=30) sp.add_parser("testeurs") + e = sp.add_parser("effacer-testeur"); e.add_argument("id", type=int); e.add_argument("--oui", action="store_true") + pu = sp.add_parser("purger"); pu.add_argument("--avant", required=True, help="AAAA-MM-JJ") + pu.add_argument("--appliquer", action="store_true", help="sans cette option : simulation seulement") a = ap.parse_args(argv) c = db.connect() @@ -102,6 +107,23 @@ def main(argv=None): for r_ in c.execute("SELECT f.*, c.label FROM feedback f LEFT JOIN codes c ON c.id=f.code_id ORDER BY f.id DESC LIMIT ?", (a.n,)): print(f"#{r_['id']} {fmt(r_['ts'])} [{propre(r_['kind'])}] {propre(r_['label'])} sur {propre(r_['page'])} ({propre(r_['viewport'])})" f"{' capture: ' + propre(r_['shot']) if r_['shot'] else ''}\n {propre(r_['text'])}") + elif a.cmd == "effacer-testeur": + row = c.execute("SELECT * FROM testers WHERE id=?", (a.id,)).fetchone() + if not row: + sys.exit("Testeur introuvable.") + if not a.oui: + sys.exit(f"Effacerait #{a.id} {propre(row['prenom'])} {propre(row['nom'])}, ses sessions, retours et captures. Relancer avec --oui.") + n = db.effacer_testeur(c, a.id) + db.journal(c, "testeur_supprime", None, None, f"id={a.id} retours={n} (cli)") + print(f"Testeur #{a.id} effacé ({n} retours).") + elif a.cmd == "purger": + try: + avant = datetime.strptime(a.avant, "%Y-%m-%d").timestamp() + except ValueError: + sys.exit("Date attendue : AAAA-MM-JJ") + bilan = db.purger(c, avant, simulation=not a.appliquer) + print(("PURGE APPLIQUÉE : " if a.appliquer else "Simulation (rien supprimé) : ") + + ", ".join(f"{k} {v}" for k, v in bilan.items())) elif a.cmd == "testeurs": for r_ in c.execute("SELECT * FROM testers ORDER BY id"): st = "ACTIF" if r_["actif"] else "SUSPENDU" diff --git a/beta/db.py b/beta/db.py index 55c4562..0f03fc9 100644 --- a/beta/db.py +++ b/beta/db.py @@ -63,7 +63,7 @@ CREATE TABLE IF NOT EXISTS attempts( CREATE TABLE IF NOT EXISTS audit( id INTEGER PRIMARY KEY, ts REAL NOT NULL, event TEXT NOT NULL, code_id INTEGER, ip_hash TEXT, detail TEXT); CREATE TABLE IF NOT EXISTS feedback( - id INTEGER PRIMARY KEY, ts REAL NOT NULL, code_id INTEGER, page TEXT, text TEXT NOT NULL, + id INTEGER PRIMARY KEY, ts REAL NOT NULL, code_id INTEGER, tester_id INTEGER, page TEXT, text TEXT NOT NULL, shot TEXT, viewport TEXT, ua TEXT, kind TEXT); CREATE TABLE IF NOT EXISTS testers( id INTEGER PRIMARY KEY, ts REAL NOT NULL, nom TEXT, prenom TEXT, email TEXT, tel TEXT, @@ -109,6 +109,11 @@ def _migrer(c): if "last_seen" not in cols_t: c.execute("ALTER TABLE testers ADD COLUMN last_seen REAL") + cols_f = [r[1] for r in c.execute("PRAGMA table_info(feedback)").fetchall()] + if "tester_id" not in cols_f: + c.execute("ALTER TABLE feedback ADD COLUMN tester_id INTEGER") + # Avant ce correctif, un testeur libre était rangé dans code_id avec son id de testeur : + # impossible de les distinguer à coup sûr, ces lignes anciennes sont laissées telles quelles. cols_s = [r[1] for r in c.execute("PRAGMA table_info(sessions)").fetchall()] if "tester_id" not in cols_s: c.execute("ALTER TABLE sessions ADD COLUMN tester_id INTEGER") @@ -130,6 +135,54 @@ def purger_anciennes_ip(c): pass +def _supprimer_captures(c, where, args): + n = 0 + for r in c.execute(f"SELECT shot FROM feedback WHERE shot IS NOT NULL AND ({where})", args).fetchall(): + f = Path(str(DATA)) / "retours" / Path(str(r[0])).name # nom de fichier seul, jamais de chemin + try: + f.unlink() + n += 1 + except FileNotFoundError: + pass + return n + + +def effacer_testeur(c, tester_id): + """Effacement individuel (droit RGPD) : testeur, sessions, retours et captures liés. Renvoie le nb de retours.""" + _supprimer_captures(c, "tester_id=?", (tester_id,)) + n = c.execute("DELETE FROM feedback WHERE tester_id=?", (tester_id,)).rowcount + c.execute("DELETE FROM sessions WHERE tester_id=?", (tester_id,)) + c.execute("DELETE FROM testers WHERE id=?", (tester_id,)) + c.commit() + return n + + +def purger(c, avant_ts, journaux_jours=30, audit_jours=183, simulation=True): + """Purge des testeurs inscrits avant `avant_ts` (avec leurs retours et captures), des retours par code + antérieurs, des tentatives de plus de `journaux_jours` et du journal de plus de `audit_jours`. + Simulation par défaut : renvoie seulement le bilan.""" + now = time.time() + ids = [r[0] for r in c.execute("SELECT id FROM testers WHERE ts < ?", (avant_ts,)).fetchall()] + bilan = { + "testeurs": len(ids), + "retours_testeurs": sum(c.execute("SELECT COUNT(*) FROM feedback WHERE tester_id=?", (i,)).fetchone()[0] for i in ids), + "retours_codes": c.execute("SELECT COUNT(*) FROM feedback WHERE tester_id IS NULL AND ts < ?", (avant_ts,)).fetchone()[0], + "tentatives": c.execute("SELECT COUNT(*) FROM attempts WHERE ts < ?", (now - journaux_jours * 86400,)).fetchone()[0], + "audit": c.execute("SELECT COUNT(*) FROM audit WHERE ts < ?", (now - audit_jours * 86400,)).fetchone()[0], + } + if simulation: + return bilan + for i in ids: + effacer_testeur(c, i) + _supprimer_captures(c, "tester_id IS NULL AND ts < ?", (avant_ts,)) + c.execute("DELETE FROM feedback WHERE tester_id IS NULL AND ts < ?", (avant_ts,)) + c.execute("DELETE FROM attempts WHERE ts < ?", (now - journaux_jours * 86400,)) + c.execute("DELETE FROM audit WHERE ts < ?", (now - audit_jours * 86400,)) + c.commit() + journal(c, "purge", None, None, " ".join(f"{k}={v}" for k, v in bilan.items())) + return bilan + + def _ouvrir(path, check_same_thread): c = sqlite3.connect(str(path or dossier_prive() / "beta.sqlite"), timeout=10, check_same_thread=check_same_thread) c.row_factory = sqlite3.Row diff --git a/beta/server.py b/beta/server.py index ca76c6a..42de3ca 100644 --- a/beta/server.py +++ b/beta/server.py @@ -17,6 +17,7 @@ import secrets import sys import threading import time +import shutil import unicodedata from datetime import date from http import cookies @@ -38,6 +39,12 @@ DELAI_ECHEC = 0.4 DELAI_TOTAL = 20 # secondes : ligne de requête + en-têtes + corps, puis la socket est fermée MAX_ECHECS_GLOBAL = int(os.environ.get("BETA_MAX_ECHECS_GLOBAL", "60")) FAIT_CONFIANCE_PROXY = os.environ.get("BETA_TRUST_PROXY") == "1" +# Hôte de l'espace projet. Le vhost public de Caddy ne transmet comme Host que jobrunner.fr / www / beta : +# un en-tête X-Admin envoyé par un visiteur du site public ne suffit donc plus. +ADMIN_HOST = os.environ.get("BETA_ADMIN_HOST", "admin.jobrunner.fr").lower() +MAX_CAPTURES_JOUR = int(os.environ.get("BETA_MAX_CAPTURES_JOUR", "30")) # par testeur ou par code +MAX_CAPTURES_OCTETS = int(os.environ.get("BETA_MAX_CAPTURES_MO", "500")) * 1_000_000 # total du dossier +MIN_LIBRE_OCTETS = int(os.environ.get("BETA_MIN_LIBRE_GO", "5")) * 1_000_000_000 EXT_OK = {".html", ".css", ".js", ".woff2", ".png", ".jpg", ".jpeg", ".svg", ".webp", ".ico", ".mp4", ".webm", ".gif", ".pdf"} DOSSIERS_INTERDITS = {"beta", ".git", "docs", "node_modules", "design"} CSP_APP = ("default-src 'self'; img-src 'self' https: data: blob:; media-src 'self' https: blob:; " @@ -74,6 +81,7 @@ LIMITES_POST = { "/_admin/api/codes/supprimer": 1000, "/_admin/api/testeurs/statut": 1000, "/_admin/api/testeurs/supprimer": 1000, + "/__beta/logout": 100, } @@ -142,6 +150,14 @@ class Handler(BaseHTTPRequestHandler): return xf.split(",")[-1].strip() # dernier saut = ajouté par Caddy return self.client_address[0] + def est_admin(self): + if self.headers.get("X-Admin") != "1": + return False + hote = (self.headers.get("Host") or "").strip().lower() + if ":" in hote and not hote.startswith("["): + hote = hote.rsplit(":", 1)[0] # port éventuel ; une IPv6 entre crochets ne vaut jamais ADMIN_HOST + return hote == ADMIN_HOST + def https(self): return FAIT_CONFIANCE_PROXY and self.headers.get("X-Forwarded-Proto") == "https" @@ -207,7 +223,7 @@ class Handler(BaseHTTPRequestHandler): return None def csrf_ok(self): - if self.headers.get("X-Admin") == "1": + if self.est_admin(): return True if self.headers.get("X-Beta") != "1": return False @@ -311,8 +327,8 @@ class Handler(BaseHTTPRequestHandler): return self.json(200, self.flux_demo()) if p == "/__beta/api/me": return self.json(200, {"label": s["code"]["label"]}) - if p == "/__beta/logout": - return self.deconnecter(s) + if p == "/__beta/logout": # F5 : un GET ne change plus l'état, déconnexion par POST seulement + return self.envoyer(405, "Utiliser le bouton Quitter.", "text/plain; charset=utf-8", extra=[("Allow", "POST")]) if p.startswith("/__beta/"): return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8") self.fichier(RACINE, p.lstrip("/") or "index.html", app=True) @@ -340,6 +356,8 @@ class Handler(BaseHTTPRequestHandler): return self.json(401, {"erreur": "session expirée, ressaisir le code"}) if p == "/__beta/api/feedback": return self.retour(s) + if p == "/__beta/logout": + return self.deconnecter(s) self.json(404, {"erreur": "inconnu"}) # --- fichiers ---------------------------------------------------- @@ -430,8 +448,8 @@ class Handler(BaseHTTPRequestHandler): self.c.execute("DELETE FROM sessions WHERE token_hash=?", (s["hash"],)) self.c.commit() db.journal(self.c, "sortie", s["code"]["id"], db.hacher_ip(self.ip())) - self.envoyer(302, b"", extra=[("Location", "/__beta/gate"), - ("Set-Cookie", f"{COOKIE}=; Path=/; Max-Age=0; HttpOnly; SameSite=Lax")]) + self.json(200, {"ok": True, "suite": "/__beta/gate"}, + [("Set-Cookie", f"{COOKIE}=; Path=/; Max-Age=0; HttpOnly; SameSite=Lax")]) # --- retours ----------------------------------------------------- def retour(self, s): @@ -442,7 +460,7 @@ class Handler(BaseHTTPRequestHandler): if len(texte) < 3: return self.json(400, {"erreur": "Écrivez au moins quelques mots."}) now = time.time() - n = self.c.execute("SELECT COUNT(*) FROM feedback WHERE code_id=? AND ts>?", (s["code"]["id"], now - 60)).fetchone()[0] + n = self.c.execute(*self._filtre_auteur(s, "SELECT COUNT(*) FROM feedback WHERE ts>?", (now - 60,))).fetchone()[0] if n >= 10: return self.json(429, {"erreur": "Un peu de calme : 10 retours par minute maximum."}) kind = d.get("kind") if d.get("kind") in ("garder", "changer", "bug", "autre") else "autre" @@ -460,15 +478,39 @@ class Handler(BaseHTTPRequestHandler): return self.json(400, {"erreur": "capture invalide"}) dossier = db.DATA / "retours" dossier.mkdir(parents=True, exist_ok=True) + refus = self.capture_refusee(s, dossier, len(brut), now) + if refus: + return self.json(507 if "espace" in refus else 429, {"erreur": refus}) shot = f"{int(now)}-{secrets.token_hex(4)}.{'jpg' if m.group(1) == 'jpeg' else m.group(1)}" (dossier / shot).write_bytes(brut) + tid = s["tester"]["id"] if s.get("tester") else None + cid = None if tid else s["code"]["id"] # testeur libre : pas de code, on ne mélange plus les deux identifiants cur = self.c.execute( - "INSERT INTO feedback(ts,code_id,page,text,shot,viewport,ua,kind) VALUES(?,?,?,?,?,?,?,?)", - (now, s["code"]["id"], "".join(ch for ch in str(d.get("page", "")) if unicodedata.category(ch)[0] != "C")[:200], texte, shot, + "INSERT INTO feedback(ts,code_id,tester_id,page,text,shot,viewport,ua,kind) VALUES(?,?,?,?,?,?,?,?,?)", + (now, cid, tid, "".join(ch for ch in str(d.get("page", "")) if unicodedata.category(ch)[0] != "C")[:200], texte, shot, "".join(ch for ch in str(d.get("viewport", "")) if unicodedata.category(ch)[0] != "C")[:30], self.headers.get("User-Agent", "")[:200], kind)) self.c.commit() self.json(200, {"ok": True, "id": cur.lastrowid}) + @staticmethod + def _filtre_auteur(s, sql, args): + if s.get("tester"): + return sql + " AND tester_id=?", args + (s["tester"]["id"],) + return sql + " AND code_id=? AND tester_id IS NULL", args + (s["code"]["id"],) + + def capture_refusee(self, s, dossier, taille, now): + """Plafonds de stockage des captures (M4) : par jour et par auteur, total du dossier, espace libre.""" + n = self.c.execute(*self._filtre_auteur(s, "SELECT COUNT(*) FROM feedback WHERE shot IS NOT NULL AND ts>?", + (now - 86400,))).fetchone()[0] + if n >= MAX_CAPTURES_JOUR: + return f"{MAX_CAPTURES_JOUR} captures par jour maximum : envoyez le texte seul." + total = sum(f.stat().st_size for f in dossier.iterdir() if f.is_file()) + if total + taille > MAX_CAPTURES_OCTETS: + return "Stockage des captures plein : envoyez le texte seul." + if shutil.disk_usage(dossier).free - taille < MIN_LIBRE_OCTETS: + return "Plus assez d'espace disque pour les captures : envoyez le texte seul." + return None + # --- formulaire testeur (version web du PDF) --------------------- def formulaire_testeur(self): raw_ip = self.ip() @@ -551,7 +593,7 @@ class Handler(BaseHTTPRequestHandler): # --- administration (depuis admin.jobrunner.fr) ------------------- def admin_creer_code(self): - if self.headers.get("X-Admin") != "1": + if not self.est_admin(): return self.json(403, {"erreur": "accès réservé à l'administration"}) try: d = json.loads(self._corps.decode("utf-8")) @@ -596,7 +638,7 @@ class Handler(BaseHTTPRequestHandler): }) def admin_supprimer_code(self): - if self.headers.get("X-Admin") != "1": + if not self.est_admin(): return self.json(403, {"erreur": "accès réservé à l'administration"}) try: d = json.loads(self._corps.decode("utf-8")) @@ -612,7 +654,7 @@ class Handler(BaseHTTPRequestHandler): return self.json(200, {"ok": True, "id": code_id}) def admin_liste_candidatures(self): - if self.headers.get("X-Admin") != "1": + if not self.est_admin(): return self.json(403, {"erreur": "accès réservé à l'administration"}) now = time.time() @@ -640,7 +682,7 @@ class Handler(BaseHTTPRequestHandler): return self.json(200, {"ok": True, "candidatures": lignes}) def admin_statut_testeur(self): - if self.headers.get("X-Admin") != "1": + if not self.est_admin(): return self.json(403, {"erreur": "accès réservé à l'administration"}) try: d = json.loads(self._corps.decode("utf-8")) @@ -657,7 +699,7 @@ class Handler(BaseHTTPRequestHandler): return self.json(200, {"ok": True, "id": tester_id, "actif": actif}) def admin_supprimer_testeur(self): - if self.headers.get("X-Admin") != "1": + if not self.est_admin(): return self.json(403, {"erreur": "accès réservé à l'administration"}) try: d = json.loads(self._corps.decode("utf-8")) @@ -665,14 +707,12 @@ class Handler(BaseHTTPRequestHandler): except Exception: return self.json(400, {"erreur": "ID invalide"}) - self.c.execute("DELETE FROM sessions WHERE tester_id=?", (tester_id,)) - self.c.execute("DELETE FROM testers WHERE id=?", (tester_id,)) - self.c.commit() - db.journal(self.c, "testeur_supprime", None, None, f"id={tester_id}") + n = db.effacer_testeur(self.c, tester_id) + db.journal(self.c, "testeur_supprime", None, None, f"id={tester_id} retours={n}") return self.json(200, {"ok": True, "id": tester_id}) def admin_liste_codes(self): - if self.headers.get("X-Admin") != "1": + if not self.est_admin(): return self.json(403, {"erreur": "accès réservé à l'administration"}) now = time.time() diff --git a/beta/static/beta.js b/beta/static/beta.js index 0fbccef..ca0c37e 100644 --- a/beta/static/beta.js +++ b/beta/static/beta.js @@ -9,7 +9,12 @@ var b = el('div', { id: 'jrb-bandeau', role: 'status' }); var badge = el('b', {}, 'BÊTA'); b.appendChild(badge); b.appendChild(document.createTextNode('Données fictives · paiement SIMULÉ')); - var out = el('a', { href: '/__beta/logout' }, 'Quitter'); b.appendChild(out); + var out = el('a', { href: '#' }, 'Quitter'); b.appendChild(out); + out.addEventListener('click', function (ev) { + ev.preventDefault(); + fetch('/__beta/logout', { method: 'POST', headers: { 'X-Beta': '1' }, credentials: 'same-origin' }) + .then(function () { location.href = '/__beta/gate'; }, function () { location.href = '/__beta/gate'; }); + }); document.body.insertBefore(b, document.body.firstChild); // --- Garde-fou paiement : aucun appel vers un prestataire de paiement --- diff --git a/beta/tests/test_http.py b/beta/tests/test_http.py index e18b0b4..c5649ab 100644 --- a/beta/tests/test_http.py +++ b/beta/tests/test_http.py @@ -14,6 +14,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) os.environ["BETA_DATA"] = str(Path(tempfile.mkdtemp()) / "data") import db, server # noqa: E402 +ADMIN = {"X-Admin": "1", "Host": "admin.jobrunner.fr"} CRLF = bytes([13, 10]) PNG = "data:image/png;base64," + base64.b64encode(b"\x89PNG\r\n\x1a\n" + b"0" * 50).decode() @@ -234,7 +235,7 @@ class T(unittest.TestCase): self.assertEqual(s, 403) # 2. Avec header X-Admin : succès 200 - s, _, d = self.req("POST", "/_admin/api/codes/creer", {"label": "Testeur Admin", "jours": 14}, headers={"X-Admin": "1"}) + s, _, d = self.req("POST", "/_admin/api/codes/creer", {"label": "Testeur Admin", "jours": 14}, headers=ADMIN) self.assertEqual(s, 200) res = json.loads(d.decode()) self.assertTrue(res.get("ok")) @@ -243,7 +244,7 @@ class T(unittest.TestCase): self.assertEqual(res.get("label"), "Testeur Admin") # 3. Liste des codes - s, _, d = self.req("GET", "/_admin/api/codes/liste", headers={"X-Admin": "1"}) + s, _, d = self.req("GET", "/_admin/api/codes/liste", headers=ADMIN) self.assertEqual(s, 200) res = json.loads(d.decode()) self.assertTrue(res.get("ok")) @@ -252,21 +253,21 @@ class T(unittest.TestCase): code_id = res["codes"][0]["id"] # 4. Supprimer le code - s, _, d = self.req("POST", "/_admin/api/codes/supprimer", {"id": code_id}, headers={"X-Admin": "1"}) + s, _, d = self.req("POST", "/_admin/api/codes/supprimer", {"id": code_id}, headers=ADMIN) self.assertEqual(s, 200) res = json.loads(d.decode()) self.assertTrue(res.get("ok")) self.assertEqual(res.get("id"), code_id) # Vérification qu'il n'est plus dans la liste - s, _, d = self.req("GET", "/_admin/api/codes/liste", headers={"X-Admin": "1"}) + s, _, d = self.req("GET", "/_admin/api/codes/liste", headers=ADMIN) self.assertEqual(s, 200) res = json.loads(d.decode()) labels_after = [c["label"] for c in res.get("codes", [])] self.assertNotIn("Testeur Admin", labels_after) # 5. Liste des testeurs (inscriptions) - s, _, d = self.req("GET", "/_admin/api/candidatures/liste", headers={"X-Admin": "1"}) + s, _, d = self.req("GET", "/_admin/api/candidatures/liste", headers=ADMIN) self.assertEqual(s, 200) res = json.loads(d.decode()) self.assertTrue(res.get("ok")) @@ -279,21 +280,105 @@ class T(unittest.TestCase): # 6. Suspendre le testeur tid = testeur["id"] - s, _, d = self.req("POST", "/_admin/api/testeurs/statut", {"id": tid, "actif": 0}, headers={"X-Admin": "1"}) + s, _, d = self.req("POST", "/_admin/api/testeurs/statut", {"id": tid, "actif": 0}, headers=ADMIN) self.assertEqual(s, 200) res = json.loads(d.decode()) self.assertEqual(res.get("actif"), 0) # 7. Réactiver le testeur - s, _, d = self.req("POST", "/_admin/api/testeurs/statut", {"id": tid, "actif": 1}, headers={"X-Admin": "1"}) + s, _, d = self.req("POST", "/_admin/api/testeurs/statut", {"id": tid, "actif": 1}, headers=ADMIN) self.assertEqual(s, 200) res = json.loads(d.decode()) self.assertEqual(res.get("actif"), 1) # 8. Supprimer le testeur - s, _, d = self.req("POST", "/_admin/api/testeurs/supprimer", {"id": tid}, headers={"X-Admin": "1"}) + s, _, d = self.req("POST", "/_admin/api/testeurs/supprimer", {"id": tid}, headers=ADMIN) self.assertEqual(s, 200) + def test_admin_refuse_depuis_le_site_public(self): + # Le vhost public de Caddy transmet tout en-tête du visiteur : X-Admin seul ne doit rien ouvrir. + for host in ("jobrunner.fr", "beta.jobrunner.fr", "www.jobrunner.fr", "127.0.0.1", "admin.jobrunner.fr.evil.com", "[::1]"): + h = {"X-Admin": "1", "Host": host} + self.assertEqual(self.req("GET", "/_admin/api/candidatures/liste", headers=h)[0], 403, host) + self.assertEqual(self.req("GET", "/_admin/api/codes/liste", headers=h)[0], 403, host) + self.assertEqual(self.req("POST", "/_admin/api/codes/creer", {"label": "Pirate"}, headers=h)[0], 403, host) + self.assertEqual(self.req("POST", "/_admin/api/testeurs/supprimer", {"id": 1}, headers=h)[0], 403, host) + self.assertEqual(self.req("GET", "/_admin/api/codes/liste", headers={"X-Admin": "1", "Host": "ADMIN.jobrunner.fr:443"})[0], 200) + self.assertEqual(self.req("GET", "/_admin/api/codes/liste", headers={"Host": "admin.jobrunner.fr"})[0], 403) + + def test_8i_logout_post_seulement(self): + _, ck, _ = self.entrer() + self.assertEqual(self.req("GET", "/__beta/logout", cookie=ck)[0], 405) + self.assertEqual(self.req("GET", "/__beta/api/me", cookie=ck)[0], 200) # GET n'a rien coupé + self.assertEqual(self.req("POST", "/__beta/logout", cookie=ck, headers={"X-Beta": "0"})[0], 403) # sans X-Beta + s, r, _ = self.req("POST", "/__beta/logout", cookie=ck) + self.assertEqual(s, 200) + self.assertIn("Max-Age=0", r.getheader("Set-Cookie")) + self.assertEqual(self.req("GET", "/__beta/api/me", cookie=ck)[0], 401) + + def test_effacement_testeur_avec_retours_et_captures(self): + base = {"nom": "Efface", "prenom": "Moi", "email": "efface@example.org", "tel": "06 00 00 00 00", "naissance": "1991-01-01", + "accord_participation": True, "rgpd": True, "confidentialite": True} + s, r, _ = self.req("POST", "/__beta/api/tester", base) + self.assertEqual(s, 200) + ck = r.getheader("Set-Cookie").split(";")[0] + s, _, d = self.req("POST", "/__beta/api/feedback", {"text": "retour a effacer", "screenshot": PNG}, ck) + self.assertEqual(s, 200, d) + fid = json.loads(d)["id"] + row = self.conn.execute("SELECT code_id, tester_id, shot FROM feedback WHERE id=?", (fid,)).fetchone() + self.assertIsNone(row[0]) # plus d'id de testeur rangé dans code_id + tid = row[1] + capture = db.DATA / "retours" / row[2] + self.assertTrue(capture.exists()) + s, _, _ = self.req("POST", "/_admin/api/testeurs/supprimer", {"id": tid}, headers=ADMIN) + self.assertEqual(s, 200) + self.assertFalse(capture.exists()) + self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM feedback WHERE id=?", (fid,)).fetchone()[0], 0) + self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM testers WHERE id=?", (tid,)).fetchone()[0], 0) + self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM sessions WHERE tester_id=?", (tid,)).fetchone()[0], 0) + + def test_purge_simulation_puis_application(self): + now = time.time() + vieux = now - 400 * 86400 + cur = self.conn.execute("INSERT INTO testers(ts,nom,prenom,email,actif) VALUES(?,?,?,?,1)", (vieux, "Vieux", "T", "v@example.org")) + tid = cur.lastrowid + self.conn.execute("INSERT INTO feedback(ts,code_id,tester_id,text) VALUES(?,?,?,?)", (vieux, None, tid, "ancien")) + self.conn.execute("INSERT INTO attempts(ts,ip_hash,ok) VALUES(?,?,0)", (vieux, "x")) + self.conn.execute("INSERT INTO audit(ts,event) VALUES(?,?)", (vieux, "ancien")) + self.conn.commit() + avant = now - 200 * 86400 + b = db.purger(self.conn, avant) # simulation par défaut + self.assertGreaterEqual(b["testeurs"], 1) + self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM testers WHERE id=?", (tid,)).fetchone()[0], 1) + db.purger(self.conn, avant, simulation=False) + self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM testers WHERE id=?", (tid,)).fetchone()[0], 0) + self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM feedback WHERE tester_id=?", (tid,)).fetchone()[0], 0) + self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM attempts WHERE ts