- 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>
385 lignes
20 KiB
Python
385 lignes
20 KiB
Python
"""Tests HTTP de la porte d'entrée, des retours et du formulaire (serveur réel, port libre)."""
|
|
import base64
|
|
import http.client
|
|
import json
|
|
import os
|
|
import sys
|
|
import tempfile
|
|
import threading
|
|
import time
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
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()
|
|
|
|
|
|
class T(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.conn = db.connect(check_same_thread=False)
|
|
server.Handler.timeout = 3
|
|
server.Handler.protocol_version = "HTTP/1.0"
|
|
cls.srv = server.Serveur(("127.0.0.1", 0), cls.conn)
|
|
cls.port = cls.srv.server_address[1]
|
|
threading.Thread(target=cls.srv.serve_forever, daemon=True).start()
|
|
cls.id, cls.code = db.creer_code(cls.conn, "Testeur", 7)
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
cls.srv.shutdown()
|
|
|
|
def req(self, method, path, body=None, cookie=None, headers=None):
|
|
c = http.client.HTTPConnection("127.0.0.1", self.port, timeout=10)
|
|
h = {"X-Beta": "1", "Content-Type": "application/json"}
|
|
h.update(headers or {})
|
|
if cookie:
|
|
h["Cookie"] = cookie
|
|
c.request(method, path, json.dumps(body) if body is not None else None, h)
|
|
r = c.getresponse()
|
|
data = r.read()
|
|
return r.status, r, data
|
|
|
|
def entrer(self, code=None):
|
|
s, r, d = self.req("POST", "/__beta/api/enter", {"code": code or self.code})
|
|
ck = (r.getheader("Set-Cookie") or "").split(";")[0]
|
|
return s, ck, r
|
|
|
|
def test_1_sans_code(self):
|
|
s, r, _ = self.req("GET", "/app.html")
|
|
self.assertEqual((s, r.getheader("Location")), (302, "/__beta/formulaire"))
|
|
self.assertEqual(self.req("GET", "/assets/css/app.css")[0], 401)
|
|
self.assertEqual(self.req("GET", "/__beta/api/demo")[0], 401)
|
|
# La gate redirige vers le formulaire
|
|
s_g, r_g, _ = self.req("GET", "/__beta/gate")
|
|
self.assertEqual((s_g, r_g.getheader("Location")), (302, "/__beta/formulaire"))
|
|
self.assertEqual(self.req("GET", "/__beta/formulaire")[0], 200)
|
|
self.assertEqual(self.req("GET", "/assets/fonts/chillax-latin-400-normal.woff2")[0], 200)
|
|
|
|
def test_1b_traversee_sans_code(self):
|
|
chemins = ["/assets/fonts/../../beta/db.py", "/assets/fonts/%2e%2e/%2e%2e/beta/db.py", "/assets/fonts/..%2f..%2fbeta/db.py",
|
|
"/assets/fonts/%252e%252e/%252e%252e/beta/db.py", "/assets/img/logo.png/../../../beta/db.py",
|
|
"/assets/css/../../beta/server.py", "/assets/fonts/./chillax-latin-400-normal.woff2",
|
|
"/assets/fonts/..%5c..%5cbeta%5cdb.py", "/__beta/static/../../db.py", "/__beta/static/%2e%2e/db.py",
|
|
"/assets/img/logo-x.png", "/assets/fonts/chillax-latin-400-normal.woff2/../../css/app.css"]
|
|
for ch in chemins:
|
|
c = http.client.HTTPConnection("127.0.0.1", self.port)
|
|
c.putrequest("GET", ch, skip_accept_encoding=True); c.endheaders()
|
|
r = c.getresponse(); r.read()
|
|
self.assertIn(r.status, (404, 401), ch)
|
|
|
|
def test_2_csrf(self):
|
|
c = http.client.HTTPConnection("127.0.0.1", self.port)
|
|
c.request("POST", "/__beta/api/enter", "{}", {"Content-Type": "application/json"})
|
|
self.assertEqual(c.getresponse().status, 403)
|
|
|
|
def test_3_entree_et_acces(self):
|
|
s, ck, r = self.entrer(self.code.lower().replace("-", " "))
|
|
self.assertEqual(s, 200)
|
|
self.assertIn("HttpOnly", r.getheader("Set-Cookie"))
|
|
self.assertIn("SameSite=Lax", r.getheader("Set-Cookie"))
|
|
s, r, d = self.req("GET", "/app.html", cookie=ck)
|
|
self.assertEqual(s, 200)
|
|
self.assertIn(b"/__beta/static/beta.js", d)
|
|
self.assertIn("connect-src 'self'", r.getheader("Content-Security-Policy"))
|
|
for interdit in ("/beta/db.py", "/.git/config", "/docs/conv.nils.md", "/DOCUMENTATION.md", "/package.json",
|
|
"/../beta/db.py", "/%2e%2e/beta/db.py", "/beta/data/beta.sqlite"):
|
|
self.assertIn(self.req("GET", interdit, cookie=ck)[0], (404, 401), interdit)
|
|
s, _, d = self.req("GET", "/__beta/api/demo", cookie=ck)
|
|
self.assertEqual(s, 200)
|
|
self.assertIn("profiles", json.loads(d))
|
|
|
|
def test_4_retour(self):
|
|
_, ck, _ = self.entrer()
|
|
s, _, d = self.req("POST", "/__beta/api/feedback", {"text": "Le bouton est trop petit", "kind": "changer", "page": "/app.html\x1b", "viewport": "375x812", "screenshot": PNG}, ck)
|
|
self.assertEqual(s, 200, d)
|
|
self.assertTrue(list((db.DATA / "retours").glob("*.png")))
|
|
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "x"}, ck)[0], 400)
|
|
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "abc", "screenshot": "data:image/png;base64,AAAA"}, ck)[0], 400)
|
|
self.assertEqual(self.req("POST", "/__beta/api/feedback", {"text": "abc"})[0], 401)
|
|
row = self.conn.execute("SELECT page FROM feedback ORDER BY id DESC").fetchone()
|
|
self.assertNotIn("\x1b", row[0])
|
|
|
|
def test_5_revocation_immediate(self):
|
|
i, code = db.creer_code(self.conn, "Jetable", 7)
|
|
_, ck, _ = self.entrer(code)
|
|
self.assertEqual(self.req("GET", "/__beta/api/me", cookie=ck)[0], 200)
|
|
self.conn.execute("UPDATE codes SET revoked_at=? WHERE id=?", (time.time(), i)); self.conn.commit()
|
|
self.assertEqual(self.req("GET", "/__beta/api/me", cookie=ck)[0], 401)
|
|
self.assertEqual(self.entrer(code)[0], 401)
|
|
|
|
def test_6_expiration(self):
|
|
i, code = db.creer_code(self.conn, "Court", 7)
|
|
self.conn.execute("UPDATE codes SET expires_at=? WHERE id=?", (time.time() - 5, i)); self.conn.commit()
|
|
self.assertEqual(self.entrer(code)[0], 401)
|
|
|
|
def test_7_journal(self):
|
|
ev = {r[0] for r in self.conn.execute("SELECT event FROM audit")}
|
|
self.assertTrue({"code_cree", "entree_ok"} <= ev)
|
|
|
|
def test_8_formulaire(self):
|
|
base = {"nom": "Durand", "prenom": "Zoé", "email": "zoe@example.org", "tel": "06 12 34 56 78", "naissance": "1990-04-02",
|
|
"accord_participation": True, "rgpd": True, "confidentialite": True}
|
|
s, r, d = self.req("POST", "/__beta/api/tester", base)
|
|
self.assertEqual(s, 200)
|
|
res = json.loads(d.decode())
|
|
self.assertTrue(res.get("ok"))
|
|
self.assertEqual(res.get("suite"), "/app.html")
|
|
cookie = r.getheader("Set-Cookie")
|
|
self.assertTrue(cookie and "jrb_s=" in cookie)
|
|
|
|
# Accès direct avec le cookie délivré à l'inscription
|
|
self.assertEqual(self.req("GET", "/app.html", cookie=cookie)[0], 200)
|
|
|
|
self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, naissance="2016-01-01"))[0], 400) # < 15 ans
|
|
mineur = dict(base, naissance=f"{time.localtime().tm_year - 16}-01-01", email="mineur@example.org")
|
|
self.assertEqual(self.req("POST", "/__beta/api/tester", mineur)[0], 400) # sans accord parental
|
|
ok = dict(mineur, parent_nom="Parent Durand", parent_email="p@example.org", accord_parental=True)
|
|
self.assertEqual(self.req("POST", "/__beta/api/tester", ok)[0], 200)
|
|
self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, rgpd=False))[0], 400)
|
|
self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, nom="A\x1b[2J"))[0], 400) # contrôle
|
|
self.assertEqual(self.req("POST", "/__beta/api/tester", dict(base, email="pas-un-mail"))[0], 400)
|
|
|
|
def test_8b_client_lent_ne_bloque_pas(self):
|
|
import socket
|
|
lent = socket.create_connection(("127.0.0.1", self.port))
|
|
lent.sendall(b"POST /__beta/api/enter HTTP/1.1"+CRLF+b"Host: x"+CRLF+b"X-Beta: 1"+CRLF+b"Content-Length: 100"+CRLF+CRLF+b"{")
|
|
t0 = time.time()
|
|
s, _, _ = self.req("GET", "/__beta/healthz")
|
|
s2, ck, _ = self.entrer()
|
|
self.assertEqual((s, s2), (200, 200))
|
|
self.assertLess(time.time() - t0, 2)
|
|
lent.close()
|
|
|
|
def test_8c_saturation_globale_laisse_passer_code_valide(self):
|
|
self.conn.execute("DELETE FROM attempts")
|
|
for i in range(server.MAX_ECHECS_GLOBAL + 5):
|
|
self.conn.execute("INSERT INTO attempts(ts,ip_hash,ok,reason) VALUES(?,?,0,'x')", (time.time(), f"autre{i}"))
|
|
self.conn.commit()
|
|
s, ck, _ = self.entrer()
|
|
self.assertEqual(s, 200)
|
|
|
|
def test_8d_limites_de_corps_avant_authentification(self):
|
|
import socket
|
|
for chemin, taille, attendu in (("/__beta/api/enter", 5000, 413), ("/__beta/api/tester", 20000, 413), ("/__beta/api/feedback", 100000, 401), ("/__beta/api/inconnu", 10, 404)):
|
|
sk = socket.create_connection(("127.0.0.1", self.port)); sk.settimeout(5)
|
|
sk.sendall(("POST " + chemin + " HTTP/1.1").encode() + CRLF + b"Host: x" + CRLF + b"X-Beta: 1" + CRLF + ("Content-Length: %d" % taille).encode() + CRLF + CRLF)
|
|
self.assertEqual(sk.recv(100)[9:12], str(attendu).encode(), chemin) # refusé sans lire le corps
|
|
sk.close()
|
|
|
|
def test_8e_limite_atomique_sous_concurrence(self):
|
|
self.conn.execute("DELETE FROM attempts"); self.conn.commit()
|
|
res = []
|
|
def tente():
|
|
res.append(self.entrer("JRB-ZZZZ-ZZZZ-ZZZZ")[0])
|
|
th = [threading.Thread(target=tente) for _ in range(20)]
|
|
[x.start() for x in th]; [x.join() for x in th]
|
|
self.assertLessEqual(res.count(401), server.MAX_ECHECS_IP, res) # jamais plus de N essais effectifs
|
|
self.assertGreaterEqual(res.count(429), 20 - server.MAX_ECHECS_IP - 4)
|
|
self.conn.execute("DELETE FROM attempts"); self.conn.commit()
|
|
|
|
def test_8f_delai_total_goutte_a_goutte(self):
|
|
import socket
|
|
server.DELAI_TOTAL = 2
|
|
try:
|
|
sk = socket.create_connection(("127.0.0.1", self.port)); sk.settimeout(8)
|
|
sk.sendall(b"GET /__beta/healthz HTTP/1.1" + CRLF + b"Host: x") # en-têtes jamais terminés
|
|
t0 = time.time()
|
|
fin = False
|
|
for _ in range(6):
|
|
try:
|
|
sk.sendall(b"X"); time.sleep(0.5)
|
|
except OSError:
|
|
fin = True; break
|
|
self.assertTrue(fin or sk.recv(10) == b"")
|
|
self.assertLess(time.time() - t0, 6)
|
|
finally:
|
|
server.DELAI_TOTAL = 20
|
|
|
|
def test_8g_pas_de_keepalive(self):
|
|
s, r, _ = self.req("GET", "/__beta/healthz")
|
|
self.assertEqual(r.getheader("Connection"), "close")
|
|
|
|
def test_8h_delai_hors_semaphore_et_concurrence_par_ip(self):
|
|
self.conn.execute("DELETE FROM attempts"); self.conn.commit()
|
|
old, oldd = server.MAX_CONC_IP, server.DELAI_ECHEC
|
|
server.MAX_CONC_IP, server.DELAI_ECHEC = 1, 1.5
|
|
try:
|
|
th = threading.Thread(target=lambda: self.entrer("JRB-AAAA-AAAA-AAAA")); th.start()
|
|
time.sleep(0.4) # le raté dort (1,5 s) mais ne tient plus aucune place
|
|
t0 = time.time(); s, _, _ = self.entrer()
|
|
self.assertEqual(s, 200); self.assertLess(time.time() - t0, 1.0)
|
|
th.join()
|
|
finally:
|
|
server.MAX_CONC_IP, server.DELAI_ECHEC = old, oldd
|
|
self.assertEqual(self.srv.conc, {}) # compteurs nettoyés
|
|
|
|
def test_9_limite_tentatives_en_dernier(self):
|
|
self.conn.execute("DELETE FROM attempts"); self.conn.commit()
|
|
for _ in range(server.MAX_ECHECS_IP):
|
|
self.assertEqual(self.entrer("JRB-AAAA-AAAA-AAAA")[0], 401)
|
|
s, _, r = self.entrer() # même le bon code est refusé pendant le blocage
|
|
self.assertEqual(s, 429)
|
|
self.assertTrue(r.getheader("Retry-After"))
|
|
|
|
def test_admin_api(self):
|
|
# 1. Sans header X-Admin : refus 403
|
|
s, _, _ = self.req("POST", "/_admin/api/codes/creer", {"label": "Test 1"})
|
|
self.assertEqual(s, 403)
|
|
s, _, _ = self.req("GET", "/_admin/api/codes/liste")
|
|
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=ADMIN)
|
|
self.assertEqual(s, 200)
|
|
res = json.loads(d.decode())
|
|
self.assertTrue(res.get("ok"))
|
|
code = res.get("code")
|
|
self.assertTrue(code and code.startswith("JRB-"))
|
|
self.assertEqual(res.get("label"), "Testeur Admin")
|
|
|
|
# 3. Liste des codes
|
|
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"))
|
|
labels = [c["label"] for c in res.get("codes", [])]
|
|
self.assertIn("Testeur Admin", labels)
|
|
code_id = res["codes"][0]["id"]
|
|
|
|
# 4. Supprimer le code
|
|
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=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=ADMIN)
|
|
self.assertEqual(s, 200)
|
|
res = json.loads(d.decode())
|
|
self.assertTrue(res.get("ok"))
|
|
cands = res.get("candidatures", [])
|
|
self.assertIsInstance(cands, list)
|
|
self.assertTrue(len(cands) >= 1)
|
|
testeur = cands[0]
|
|
self.assertTrue(testeur.get("ip"))
|
|
self.assertTrue(testeur.get("expire_ip_at") > 0)
|
|
|
|
# 6. Suspendre le testeur
|
|
tid = testeur["id"]
|
|
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=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=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)
|