fix(beta): API admin limitee a admin.jobrunner.fr, effacement et purge des testeurs, plafonds des captures, deconnexion en POST

- X-Admin seul ne suffit plus : Host doit etre admin.jobrunner.fr (le vhost public transmet les en-tetes du visiteur)
- feedback.tester_id : retours lies au testeur, effaces avec lui (captures comprises)
- codes.py effacer-testeur / purger (simulation par defaut)
- captures : 30/jour/auteur, 500 Mo au total, 5 Go libres minimum
- /__beta/logout en POST avec X-Beta (F5)
- 5 tests ajoutes (30 au total)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Théo GastineletClaude Opus 5.5 a révisé 2026-10-31 11:45:45 +01:00
1 Parent 7148f3d04b
révision 1228bf47aa
5 fichiers modifiés
+233 -28

Aucun fichier ne correspond à votre recherche

+22
Voir le fichier
@@ -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 <id> [--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"
+54 -1
Voir le fichier
@@ -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
+58 -18
Voir le fichier
@@ -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()
+6 -1
Voir le fichier
@@ -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 ---
+93 -8
Voir le fichier
@@ -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<?", (avant,)).fetchone()[0], 0)
self.assertEqual(self.conn.execute("SELECT COUNT(*) FROM audit WHERE event='ancien'").fetchone()[0], 0)
self.assertGreater(self.conn.execute("SELECT COUNT(*) FROM testers").fetchone()[0], 0) # les récents restent
def test_8j_plafond_captures(self):
i, code = db.creer_code(self.conn, "Captures", 7)
_, ck, _ = self.entrer(code)
ancien = server.MAX_CAPTURES_JOUR
server.MAX_CAPTURES_JOUR = 2
try:
for _ in range(2):
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "capture ok", "screenshot": PNG}, ck)[0], 200)
s, _, d = self.req("POST", "/__beta/api/feedback", {"text": "capture de trop", "screenshot": PNG}, ck)
self.assertEqual(s, 429, d)
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "texte seul toujours accepte"}, ck)[0], 200)
finally:
server.MAX_CAPTURES_JOUR = ancien
ancien = server.MIN_LIBRE_OCTETS
server.MIN_LIBRE_OCTETS = 10 ** 18 # disque « plein »
try:
_, ck2, _ = self.entrer(db.creer_code(self.conn, "Disque", 7)[1])
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "disque plein", "screenshot": PNG}, ck2)[0], 507)
finally:
server.MIN_LIBRE_OCTETS = ancien
if __name__ == "__main__":
unittest.main(verbosity=2)