Fichiers
meteo-vercors/forum/tests/test_forum.py
T
Théo GastineletClaude Opus 5.5 0cf0b78822 forum : bouton « Supprimer » pour le propriétaire et l'adjoint
- nouveau droit `supprimer` (PROPRIOS seulement), vérifié côté serveur ;
- message : supprimé avec commentaires, réactions, signalements, photos ;
  le premier message d'un sujet renvoie à la suppression du sujet entier ;
- commentaire : suppression par le propriétaire / l'adjoint ;
- sujet : messages, commentaires, réactions, signalements, lectures et
  fichiers photo orphelins effacés ; Bulletin et sujets de station protégés
  (seulement leurs messages) ;
- confirmation <details> « Supprimer définitivement ? », POST sans JS,
  contrôle Origin existant ;
- journal : table journal_suppressions (qui, quoi, quand, extrait).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 21:52:50 +01:00

1904 lignes
101 KiB
Python

"""Tests du forum (rôles, sujets, Bulletin, stations, photos, connexion Gastinel simulée, adhésions).
python -m unittest discover -s forum/tests (ou python -I forum/tests/test_forum.py)
"""
import hashlib
import http.client
import json
import os
import shutil
import struct
import subprocess
import sys
import tempfile
import threading
import unittest
import zlib
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import parse_qs, quote, unquote, urlparse
ICI = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
sys.path.insert(0, ICI)
import connexion # noqa: E402
import forum as forum_mod # noqa: E402
import panneau # noqa: E402
import photos # noqa: E402
import roles # noqa: E402
import server # noqa: E402
from forum import EPINGLES_MAX, FICHE_PHOTOS_MAX, Forum, Invalide, Refus # noqa: E402
STATIONS = {"geve": "Gêve", "oscence": "Combe de l'Oscence"}
def png(meta=True):
def bloc(nom, data):
return struct.pack(">I", len(data)) + nom + data + struct.pack(">I", zlib.crc32(nom + data))
ihdr = struct.pack(">IIBBBBB", 1, 1, 8, 2, 0, 0, 0)
corps = bloc(b"IHDR", ihdr)
if meta:
corps += bloc(b"tEXt", b"GPS\x0045.1,5.5")
corps += bloc(b"IDAT", zlib.compress(b"\x00\x00\x00\x00")) + bloc(b"IEND", b"")
return b"\x89PNG\r\n\x1a\n" + corps
def jpeg():
app1 = b"\xff\xe1" + struct.pack(">H", 2 + 10) + b"Exif\x00\x00GPS!"
app0 = b"\xff\xe0" + struct.pack(">H", 2 + 5) + b"JFIF\x00"
sos = b"\xff\xda" + struct.pack(">H", 2 + 2) + b"\x00\x00" + b"\x12\x34" + b"\xff\xd9"
return b"\xff\xd8" + app0 + app1 + sos
class Base(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.mkdtemp()
self.f = Forum(stations=STATIONS, dossier_photos=os.path.join(self.tmp, "photos"))
self.theo = self.f.fixer_proprietaire("theo", "Théo")
self.pere = self.f.utilisateur("pere", "Richard")
self.f.donner_role(self.theo, "pere", roles.ADJOINT)
self.f.donner_role(self.theo, "pere", roles.MODERATEUR)
self.membre = self.f.utilisateur("m1", "Marie")
self.adh = self.f.utilisateur("a1", "Alex")
self.f.donner_role(self.pere, "a1", roles.ADHERENT)
self.modo = self.f.utilisateur("mo1", "Momo")
self.f.donner_role(self.theo, "mo1", roles.MODERATEUR)
self.prop = self.f.utilisateur("s1", "Sam")
self.f.donner_role(self.pere, "s1", roles.STATION, "geve")
def tearDown(self):
shutil.rmtree(self.tmp, ignore_errors=True)
def bulletin(self):
return [t for t in self.f.sujets(None) if t["fixed"]][0]
class TestRoles(Base):
def test_cumul_et_badges(self):
self.assertEqual(self.f.roles_de(self.pere), {roles.MEMBRE, roles.ADJOINT, roles.MODERATEUR})
self.assertEqual([lib for _, lib in self.f.badges(self.pere["id"])], ["Propriétaire adjoint", "Modérateur"])
self.assertEqual([lib for _, lib in self.f.badges(self.membre["id"])], ["Membre"])
self.assertEqual([lib for _, lib in self.f.badges(self.prop["id"])], ["Propriétaire de station · Gêve"])
def test_qui_donne_quoi(self):
with self.assertRaises(Refus): # l'adjoint ne nomme pas d'adjoint
self.f.donner_role(self.pere, "m1", roles.ADJOINT)
with self.assertRaises(Refus): # personne ne donne « propriétaire »
self.f.donner_role(self.theo, "m1", roles.PROPRIETAIRE)
with self.assertRaises(Refus): # un modérateur ne gère pas les rôles
self.f.donner_role(self.modo, "m1", roles.ADHERENT)
with self.assertRaises(Invalide):
self.f.donner_role(self.theo, "m1", roles.STATION, "inconnue")
self.f.retirer_role(self.theo, "a1", roles.ADHERENT)
self.assertEqual(self.f.roles_de(self.f.utilisateur("a1")), {roles.MEMBRE})
def test_compte_systeme_reserve(self):
with self.assertRaises(Invalide):
self.f.utilisateur("systeme")
class TestSujets(Base):
def test_bulletin_fixe_en_tete_et_ferme(self):
self.f.creer_sujet(self.adh, "Givre à Gêve", "Photo ce matin")
liste = self.f.sujets(None)
self.assertEqual(liste[0]["title"], "Bulletin de la semaine du Vercors")
b = self.bulletin()["id"]
with self.assertRaises(Refus):
self.f.repondre(self.membre, b, "coucou")
self.f.repondre(self.adh, b, "Bilan de la semaine…") # un adhérent publie le bulletin
self.f.repondre(self.pere, b, "Complément") # le propriétaire adjoint aussi
with self.assertRaises(Refus):
self.f.epingler(self.theo, b, False)
with self.assertRaises(Refus):
self.f.masquer_sujet(self.theo, b)
def test_membre_repond_seulement(self):
with self.assertRaises(Refus):
self.f.creer_sujet(self.membre, "Mon sujet", "texte")
t = self.f.creer_sujet(self.adh, "Neige", "Il neige")
self.f.repondre(self.membre, t, "Ici aussi")
with self.assertRaises(Refus):
self.f.repondre(None, t, "visiteur")
def test_moderateur_seul_ne_cree_pas(self):
if roles.MODERATEUR_CREE_SUJETS:
self.skipTest("réglage modifié")
with self.assertRaises(Refus):
self.f.creer_sujet(self.modo, "Sujet", "texte")
t = self.f.creer_sujet(self.adh, "Neige", "x")
self.f.verrouiller(self.modo, t)
with self.assertRaises(Refus):
self.f.repondre(self.membre, t, "trop tard")
def test_epingles_maximum(self):
ids = [self.f.creer_sujet(self.adh, "S%d" % i, "x") for i in range(6)]
for t in ids[:EPINGLES_MAX - 1]:
self.f.epingler(self.theo, t)
with self.assertRaises(Refus):
self.f.epingler(self.pere, ids[-1])
with self.assertRaises(Refus):
self.f.epingler(self.adh, ids[-1])
tetes = [t["title"] for t in self.f.sujets(None)[:EPINGLES_MAX]]
self.assertEqual(tetes, ["Bulletin de la semaine du Vercors", "S0", "S1", "S2", "S3"])
class TestStation(Base):
def test_sujet_de_station_valide(self):
t = self.f.creer_sujet_station(self.prop, "geve", "Ma station à 1353 m")
self.assertNotIn(t, [s["id"] for s in self.f.sujets(None)]) # en attente : invisible
self.assertIn(t, [s["id"] for s in self.f.sujets(self.prop)]) # sauf pour son auteur
with self.assertRaises(Invalide): # en attente : introuvable pour un membre
self.f.repondre(self.membre, t, "x")
self.assertEqual([s["id"] for s in self.f.en_attente(self.pere)], [t])
self.f.valider_sujet(self.pere, t)
s = [x for x in self.f.sujets(None) if x["id"] == t][0]
self.assertEqual(s["title"], "Station · Gêve")
self.f.repondre(self.membre, t, "Belle station")
def test_une_seule_et_la_sienne(self):
self.f.creer_sujet_station(self.prop, "geve", "x")
with self.assertRaises(Invalide):
self.f.creer_sujet_station(self.prop, "geve", "encore")
with self.assertRaises(Refus):
self.f.creer_sujet_station(self.prop, "oscence", "pas à moi")
with self.assertRaises(Refus):
self.f.creer_sujet_station(self.membre, "geve", "x")
with self.assertRaises(Refus):
self.f.valider_sujet(self.modo, 1)
def test_refus_puis_nouvel_essai(self):
t = self.f.creer_sujet_station(self.prop, "geve", "x")
self.f.valider_sujet(self.theo, t, accepte=False)
self.f.creer_sujet_station(self.prop, "geve", "deuxième essai")
class TestPhotos(Base):
def test_metadonnees_retirees(self):
mime, propre = photos.nettoyer(png())
self.assertEqual(mime, "image/png")
self.assertNotIn(b"GPS", propre)
mime, propre = photos.nettoyer(jpeg())
self.assertEqual(mime, "image/jpeg")
self.assertNotIn(b"Exif", propre)
self.assertTrue(propre.startswith(b"\xff\xd8") and propre.endswith(b"\xff\xd9"))
with self.assertRaises(photos.PhotoInvalide):
photos.nettoyer(b"<svg onload=alert(1)>")
def test_limites(self):
t = self.f.creer_sujet(self.adh, "Photos", "x")
p = self.f.repondre(self.membre, t, "voici")
self.f.ajouter_photos(self.membre, p, [("a.png", png())] * 10)
with self.assertRaises(Refus):
self.f.ajouter_photos(self.membre, p, [("b.png", png())])
with self.assertRaises(Refus):
self.f.ajouter_photos(self.adh, p, [("c.png", png())]) # pas son message
gros = self.f.repondre(self.membre, t, "gros")
with self.assertRaises(Refus):
self.f.ajouter_photos(self.membre, gros, [("g.png", png() + b"\x00" * (26 * 1024 * 1024))])
def test_proprietaire_sans_limite(self):
t = self.f.creer_sujet(self.theo, "Album", "x")
p = self.f.repondre(self.theo, t, "beaucoup")
self.f.ajouter_photos(self.theo, p, [("a.png", png())] * 12)
self.assertEqual(len(self.f.photos_de(p)), 12)
class TestFichePhotos(Base):
"""Photos du sujet de station épinglées sur la fiche publique de vercors.me (3 au plus)."""
def sujet_geve(self, n=4):
t = self.f.creer_sujet_station(self.prop, "geve", "Ma station")
self.f.valider_sujet(self.theo, t)
p = self.f.repondre(self.prop, t, "Photos de la station")
ids = self.f.ajouter_photos(self.prop, p, [("p%d.png" % i, png() + bytes([i])) for i in range(n)])
return t, p, ids
def test_qui_epingle(self):
t, p, ids = self.sujet_geve()
self.f.epingler_photo(self.prop, ids[0]) # propriétaire de la station
self.f.epingler_photo(self.pere, ids[1]) # adjoint
self.f.epingler_photo(self.theo, ids[2]) # propriétaire
for qui in (self.membre, self.modo, self.adh, None):
with self.assertRaises(Refus):
self.f.epingler_photo(qui, ids[3])
autre = self.f.utilisateur("s2", "Oscar")
self.f.donner_role(self.theo, "s2", roles.STATION, "oscence")
with self.assertRaises(Refus): # propriétaire d'une autre station
self.f.epingler_photo(autre, ids[0], False)
self.assertEqual(self.f.photos_fiche_ids("geve"), set(ids[:3]))
def test_trois_au_plus_et_retrait(self):
t, p, ids = self.sujet_geve()
for i in ids[:FICHE_PHOTOS_MAX]:
self.f.epingler_photo(self.prop, i)
self.f.epingler_photo(self.prop, ids[0]) # déjà épinglée : sans effet
with self.assertRaises(Refus):
self.f.epingler_photo(self.prop, ids[3])
self.f.epingler_photo(self.prop, ids[0], False)
self.f.epingler_photo(self.prop, ids[3])
self.assertEqual(len(self.f.fiche_station("geve")["photos"]), 3)
def test_hors_sujet_de_station_refuse(self):
t = self.f.creer_sujet(self.adh, "Neige", "x")
p = self.f.repondre(self.adh, t, "photo")
i = self.f.ajouter_photos(self.adh, p, [("a.png", png())])[0]
with self.assertRaises(Invalide):
self.f.epingler_photo(self.theo, i)
with self.assertRaises(Invalide):
self.f.epingler_photo(self.theo, 9999)
def test_fiche_publique(self):
self.assertEqual(self.f.fiche_station("geve"), {"station": "geve", "sujet": None, "photos": []})
with self.assertRaises(Invalide):
self.f.fiche_station("inconnue")
t, p, ids = self.sujet_geve(2)
self.f.epingler_photo(self.prop, ids[1])
self.f.epingler_photo(self.prop, ids[0])
d = self.f.fiche_station("geve")
self.assertEqual(d["sujet"], t)
self.assertEqual([x["auteur"] for x in d["photos"]], ["Sam", "Sam"])
self.f.masquer_message(self.modo, p) # message masqué : ses photos quittent la fiche
self.assertEqual(self.f.fiche_station("geve")["photos"], [])
self.f.masquer_sujet(self.modo, t) # sujet masqué : plus de lien
self.assertEqual(self.f.fiche_station("geve")["sujet"], None)
class TestModeration(Base):
def test_signalement_et_masquage(self):
t = self.f.creer_sujet(self.adh, "Sujet", "x")
p = self.f.repondre(self.membre, t, "message limite")
self.f.signaler(self.adh, p, "hors sujet")
with self.assertRaises(Refus):
self.f.signalements(self.membre)
self.assertEqual(len(self.f.signalements(self.modo)), 1)
self.f.masquer_message(self.modo, p)
_, msgs = self.f.sujet(self.membre, t)
self.assertNotIn(p, [m["id"] for m in msgs])
_, msgs = self.f.sujet(self.pere, t)
self.assertIn(p, [m["id"] for m in msgs])
def test_purge_ip(self):
t = self.f.creer_sujet(self.adh, "S", "x", ip="192.0.2.1")
self.f.con.execute("UPDATE posts SET created_at=datetime('now','-13 months') WHERE topic_id=?", (t,))
self.assertEqual(self.f.purger_ips(), 1)
class TestPurge(Base):
"""Purge de conservation (purge.py / Forum.purger) : IP 12 mois, brouillons 30 jours, signalements traités 12 mois."""
def _donnees(self):
f, vieux = self.f, "datetime('now','-13 months')"
t = f.creer_sujet(self.adh, "S", "x", ip="192.0.2.1")
p_vieux = f.con.execute("SELECT id FROM posts WHERE topic_id=?", (t,)).fetchone()[0]
f.con.execute("UPDATE posts SET created_at=%s WHERE id=?" % vieux, (p_vieux,))
p_neuf = f.repondre(self.membre, t, "récent", ip="192.0.2.2")
c_vieux = f.commenter(self.membre, p_neuf, "vieux com", ip="192.0.2.3")
f.con.execute("UPDATE comments SET created_at=%s WHERE id=?" % vieux, (c_vieux,))
c_neuf = f.commenter(self.membre, p_neuf, "com récent", ip="192.0.2.4")
# brouillons : un de 31 jours, un de 29 jours
for jours in (31, 29):
f.con.execute("INSERT INTO brouillons(user_id, titre, maj) VALUES (?, ?, datetime('now', ?))",
(self.adh["id"], "b%d" % jours, "-%d days" % jours))
# signalements : un traité (message masqué) et ancien, un ancien non traité, un traité récent
f.con.execute("UPDATE posts SET hidden=1 WHERE id=?", (p_vieux,))
f.con.execute("INSERT INTO reports(post_id, reporter_id, reason, created_at) VALUES (?, ?, 'a', %s)" % vieux,
(p_vieux, self.membre["id"]))
f.con.execute("INSERT INTO reports(post_id, reporter_id, reason, created_at) VALUES (?, ?, 'b', %s)" % vieux,
(p_neuf, self.membre["id"]))
f.con.execute("INSERT INTO reports(post_id, reporter_id, reason) VALUES (?, ?, 'c')", (p_vieux, self.modo["id"]))
# lectures : compte supprimé et compte actif
f.con.execute("INSERT INTO lectures(user_id, topic_id, dernier_post) VALUES (?, ?, 1)", (self.membre["id"], t))
f.con.execute("INSERT INTO lectures(user_id, topic_id, dernier_post) VALUES (?, ?, 1)", (self.adh["id"], t))
f.con.execute("UPDATE users SET supprime=1 WHERE id=?", (self.membre["id"],))
f.con.commit()
return p_vieux, p_neuf, c_vieux, c_neuf
def _compte(self, sql):
return self.f.con.execute(sql).fetchone()[0]
def test_purge_complete_et_idempotente(self):
p_vieux, p_neuf, c_vieux, c_neuf = self._donnees()
r = self.f.purger()
self.assertEqual(r["ip"], 2) # message et commentaire de 13 mois
self.assertEqual(r["brouillons"], 1)
self.assertEqual(r["signalements"], 1)
self.assertEqual(r["lectures"], 1)
ip = lambda table, i: self.f.con.execute("SELECT ip FROM %s WHERE id=?" % table, (i,)).fetchone()[0]
self.assertIsNone(ip("posts", p_vieux))
self.assertIsNone(ip("comments", c_vieux))
self.assertEqual(ip("posts", p_neuf), "192.0.2.2") # récents : gardés
self.assertEqual(ip("comments", c_neuf), "192.0.2.4")
self.assertEqual(self._compte("SELECT COUNT(*) FROM brouillons"), 1)
self.assertEqual(self._compte("SELECT COUNT(*) FROM reports"), 2)
self.assertEqual(self._compte("SELECT COUNT(*) FROM lectures"), 1)
self.assertEqual(sum(self.f.purger().values()), 0) # deuxième passage : rien à faire
def test_purge_ip_toute_table(self):
self.f.con.execute("CREATE TABLE essai (id INTEGER PRIMARY KEY, ip TEXT, created_at TEXT)")
self.f.con.execute("INSERT INTO essai(ip, created_at) VALUES ('203.0.113.9', datetime('now','-14 months'))")
self.f.con.execute("INSERT INTO essai(ip, created_at) VALUES ('203.0.113.8', datetime('now'))")
self.assertEqual(self.f.purger_ips(), 1)
self.assertEqual(self._compte("SELECT COUNT(*) FROM essai WHERE ip IS NOT NULL"), 1)
def test_signalement_commentaire_traite(self):
t = self.f.creer_sujet(self.adh, "S", "x")
p = self.f.repondre(self.membre, t, "r")
c = self.f.commenter(self.membre, p, "c")
for hidden in (1, 0):
self.f.con.execute("INSERT INTO comment_reports(comment_id, reporter_id, reason, created_at)"
" VALUES (?, ?, 'x', datetime('now','-13 months'))", (c, self.modo["id"] if hidden else self.pere["id"]))
self.f.con.execute("UPDATE comments SET hidden=0 WHERE id=?", (c,))
self.assertEqual(self.f.purger()["signalements"], 0) # commentaire non masqué : signalement non traité
self.f.con.execute("UPDATE comments SET hidden=1 WHERE id=?", (c,))
self.assertEqual(self.f.purger()["signalements"], 2)
def test_commande(self):
import io
from contextlib import redirect_stdout
import purge
base = os.path.join(self.tmp, "p.sqlite3")
f = Forum(base)
f.con.execute("INSERT INTO brouillons(user_id, titre, maj) VALUES (1, 'b', datetime('now','-40 days'))")
f.con.commit()
f.con.close()
sortie = io.StringIO()
with redirect_stdout(sortie):
self.assertEqual(purge.main(["--db", base]), 0)
self.assertIn("brouillons=1", sortie.getvalue())
self.assertEqual(len(sortie.getvalue().strip().splitlines()), 1) # journal court : une ligne
self.assertEqual(purge.main(["--db", os.path.join(self.tmp, "absente.sqlite3")]), 1)
class FauxHub(BaseHTTPRequestHandler):
"""Hub simulé : /oauth/jeton (vérifie PKCE S256, code à usage unique) et /oauth/moi."""
codes = {} # code -> (code_challenge, client_id, redirect_uri, profil)
jetons = {} # jeton -> profil
def log_message(self, *a):
pass
def repondre(self, code, d):
data = json.dumps(d).encode()
self.send_response(code)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(data)))
self.end_headers()
self.wfile.write(data)
def do_POST(self):
if self.path != "/oauth/jeton":
return self.repondre(404, {})
f = {k: v[0] for k, v in parse_qs(self.rfile.read(int(self.headers["Content-Length"])).decode()).items()}
entree = self.codes.pop(f.get("code"), None) # usage unique
if (entree is None or f.get("grant_type") != "authorization_code"
or (f.get("client_id"), f.get("redirect_uri")) != entree[1:3]
or connexion._b64(hashlib.sha256(f.get("code_verifier", "").encode()).digest()) != entree[0]):
return self.repondre(400, {"error": "invalid_grant"})
jeton = "jeton-%d" % len(self.jetons)
self.jetons[jeton] = entree[3]
self.repondre(200, {"access_token": jeton, "token_type": "Bearer", "expires_in": 3600})
def do_GET(self):
jeton = self.headers.get("Authorization", "")[7:]
if self.path != "/oauth/moi" or jeton not in self.jetons:
return self.repondre(401, {})
self.repondre(200, self.jetons[jeton])
class BaseHTTP(Base):
def setUp(self):
super().setUp()
self.hub = ThreadingHTTPServer(("127.0.0.1", 0), type("Hub", (FauxHub,), {"codes": {}, "jetons": {}}))
threading.Thread(target=self.hub.serve_forever, daemon=True).start()
self.srv = server.creer_serveur(self.f, 0)
self.port = self.srv.server_address[1]
self.reglages = connexion.Reglages(hub_url="http://127.0.0.1:%d" % self.hub.server_address[1],
redirect_uri="http://127.0.0.1:%d/connexion/retour" % self.port,
mode_test=True)
self.srv.RequestHandlerClass.app.reglages = self.reglages
threading.Thread(target=self.srv.serve_forever, daemon=True).start()
self.sessions = {}
def tearDown(self):
for s in (self.srv, self.hub):
s.shutdown()
s.server_close()
super().tearDown()
def session(self, qui):
if qui not in self.sessions:
self.sessions[qui] = self.f.ouvrir_session(self.f.utilisateur(qui))
return "forum_session=" + self.sessions[qui]
def req(self, chemin, qui=None, corps=None, ct=None, origine=True, cookie=None, entetes=None):
c = http.client.HTTPConnection("127.0.0.1", self.port, timeout=10)
h = dict(entetes or {})
if qui:
h["Cookie"] = self.session(qui)
if cookie is not None:
h["Cookie"] = cookie
if corps is not None:
h["Content-Type"] = ct or "application/x-www-form-urlencoded"
if origine:
h["Origin"] = "http://127.0.0.1:%d" % self.port
c.request("POST" if corps is not None else "GET", chemin, body=corps, headers=h)
r = c.getresponse()
return r.status, r.headers, r.read()
class TestHTTP(BaseHTTP):
def test_recherche_et_navigation_du_forum(self):
self.f.creer_sujet(self.adh, "Neige au col", "Bulletin local")
self.f.creer_sujet(self.theo, "Pluie dans la vallée", "Cumuls")
st, _, corps = self.req("/?q=nEIgE")
self.assertEqual(st, 200)
page = corps.decode()
self.assertNotIn("class='nav'", page)
self.assertIn("Neige au col", page)
self.assertNotIn("Pluie dans la vallée", page)
self.assertIn("Aucun sujet ne correspond", self.req("/?q=inconnu")[2].decode())
def test_signalement_saisissable_et_retour_au_message(self):
sujet = self.f.creer_sujet(self.adh, "Neige", "Échanges")
message = self.f.repondre(self.adh, sujet, "Premiers flocons")
chemin = "/t/%d" % sujet
page = self.req(chemin, "m1")[2].decode()
self.assertIn("name='motif' maxlength='500' required", page)
self.assertIn("id='message-%d'" % message, page)
st, h, _ = self.req("/signaler", "m1", "post=%d&motif=Hors+sujet" % message)
self.assertEqual((st, h["Location"]), (303, "%s?suite=signalement#message-%d" % (chemin, message)))
self.assertIn("Signalement pris en compte", self.req(chemin + "?suite=signalement", "m1")[2].decode())
moderation = self.req("/moderation", "mo1")[2].decode()
self.assertIn("Hors sujet", moderation)
self.assertIn("href='%s#message-%d'" % (chemin, message), moderation)
def test_visiteur_limite_100_messages(self):
sujet = self.f.creer_sujet(self.adh, "Long sujet", "Premier message")
auteur = self.f.utilisateur("m1")["id"]
for i in range(120):
self.f.con.execute("INSERT INTO posts (topic_id, author_id, body, created_at) VALUES (?,?,?,datetime('now'))",
(sujet, auteur, "réponse n°%d" % i))
self.f.con.commit()
visiteur = self.req("/t/%d" % sujet)[2].decode()
self.assertEqual(visiteur.count("class='msg"), 100)
self.assertIn("Premier message", visiteur)
self.assertIn("réponse n°119", visiteur)
self.assertNotIn("réponse n°5<", visiteur)
self.assertIn("21 messages plus anciens", visiteur)
membre = self.req("/t/%d" % sujet, "m1")[2].decode()
self.assertEqual(membre.count("class='msg"), 121)
self.assertNotIn("id='invite-compte'", membre)
self.assertIn("id='invite-compte'", visiteur)
def test_liste_visiteur(self):
st, h, b = self.req("/")
self.assertEqual(st, 200)
self.assertIn("Bulletin de la semaine du Vercors", b.decode())
self.assertIn("default-src 'none'", h["Content-Security-Policy"])
def test_reponse_avec_photo(self):
t = self.f.creer_sujet(self.adh, "Photos", "x")
frontiere = "XyZ"
corps = ("--%s\r\nContent-Disposition: form-data; name=\"sujet\"\r\n\r\n%d\r\n"
"--%s\r\nContent-Disposition: form-data; name=\"corps\"\r\n\r\nVoici le givre\r\n"
"--%s\r\nContent-Disposition: form-data; name=\"photos\"; filename=\"givre.png\"\r\nContent-Type: image/png\r\n\r\n"
% (frontiere, t, frontiere, frontiere)).encode() + png() + ("\r\n--%s--\r\n" % frontiere).encode()
st, _, _ = self.req("/repondre", "m1", corps, "multipart/form-data; boundary=" + frontiere)
self.assertEqual(st, 303)
st, _, b = self.req("/t/%d" % t)
self.assertIn("/photo/", b.decode())
nom = b.decode().split("/photo/")[1].split("'")[0]
st, h, img = self.req("/photo/" + nom)
self.assertEqual((st, h["Content-Type"], h["X-Content-Type-Options"]), (200, "image/png", "nosniff"))
self.assertNotIn(b"GPS", img)
def test_origine_et_droits(self):
st, _, _ = self.req("/sujet", "a1", b"titre=x&corps=y", origine=False)
self.assertEqual(st, 403)
st, _, _ = self.req("/sujet", "m1", b"titre=x&corps=y")
self.assertEqual(st, 403)
st, _, _ = self.req("/sujet", "a1", b"titre=Neige&corps=Il+neige")
self.assertEqual(st, 303)
st, _, _ = self.req("/roles", "mo1")
self.assertEqual(st, 403)
st, _, _ = self.req("/photo/../../etc/passwd")
self.assertEqual(st, 404)
def test_badges_svg_avec_texte_alternatif(self):
t = self.f.creer_sujet(self.adh, "Neige", "x")
self.f.repondre(self.pere, t, "réponse")
self.f.repondre(self.prop, t, "ma station")
b = self.req("/t/%d" % t)[2].decode()
for lib in ("Adhérent météo", "Propriétaire adjoint", "Modérateur", "Propriétaire de station · Gêve"):
self.assertIn("role='img' aria-label='%s'" % lib, b)
self.assertIn("<title>%s</title>" % lib, b)
self.assertIn("aria-label='Propriétaire'", server.badge(roles.PROPRIETAIRE, "Propriétaire"))
self.assertNotIn("<script", b.replace("<script src='/apercu.js' defer></script>", "").replace("<script src='/reactions.js' defer></script>", ""))
def test_moderateur_sans_bouton_epingler(self):
t = self.f.creer_sujet(self.adh, "Neige", "x")
self.assertNotIn("action='/epingler'", self.req("/t/%d" % t, "mo1")[2].decode())
self.assertIn("action='/epingler'", self.req("/t/%d" % t, "pere")[2].decode())
st, _, _ = self.req("/epingler", "mo1", ("sujet=%d&etat=1" % t).encode())
self.assertEqual(st, 403)
class TestConnexionGastinel(BaseHTTP):
def setUp(self):
super().setUp()
self.reglages.mode_test = False # comme en production : cookies Secure
def depart(self):
st, h, _ = self.req("/connexion/gastinel")
self.assertEqual(st, 303)
loc = urlparse(h["Location"])
q = {k: v[0] for k, v in parse_qs(loc.query).items()}
self.assertEqual(loc.path, "/oauth/autoriser")
self.assertEqual((q["response_type"], q["client_id"], q["code_challenge_method"]), ("code", "forum-vercors", "S256"))
self.assertEqual(q["redirect_uri"], self.reglages.redirect_uri)
cookie = [c for c in h.get_all("Set-Cookie") if c.startswith("forum_etat=")][0]
for attr in ("HttpOnly", "Secure", "SameSite=Lax"):
self.assertIn(attr, cookie)
return q["state"], q["code_challenge"]
def hub_accepte(self, code, challenge, profil):
self.hub.RequestHandlerClass.codes[code] = (challenge, "forum-vercors", self.reglages.redirect_uri, profil)
def retour(self, etat, code="c1", cookie_etat=None):
cookie = "forum_etat=" + (etat if cookie_etat is None else cookie_etat)
return self.req("/connexion/retour?code=%s&state=%s" % (code, etat), cookie=cookie)
@staticmethod
def jeton_session(h):
for c in h.get_all("Set-Cookie") or []:
if c.startswith("forum_session=") and not c.startswith("forum_session=;"):
return c.split(";")[0].split("=", 1)[1], c
return None, None
def test_connexion_complete(self):
etat, ch = self.depart()
self.hub_accepte("c1", ch, {"id": "g-42", "pseudo": "Lucie"})
st, h, _ = self.retour(etat)
self.assertEqual(st, 303)
jeton, cookie = self.jeton_session(h)
self.assertIsNotNone(jeton)
for attr in ("HttpOnly", "Secure", "SameSite=Lax", "Path=/"):
self.assertIn(attr, cookie)
u = self.f.con.execute("SELECT * FROM users WHERE hub_id='g-42'").fetchone()
self.assertEqual(u["display_name"], "Lucie")
stocke = self.f.con.execute("SELECT id_hache FROM sessions WHERE user_id=?", (u["id"],)).fetchone()[0]
self.assertEqual(stocke, hashlib.sha256((":" + jeton).encode()).hexdigest()) # seul le haché est en base
b = self.req("/", cookie="forum_session=" + jeton)[2].decode()
self.assertIn("Lucie", b)
self.assertIn("action='/deconnexion'", b)
# nouvelle connexion : le pseudo suit le compte Gastinel, le state précédent ne resert pas
st, _, _ = self.retour(etat)
self.assertEqual(st, 400)
etat2, ch2 = self.depart()
self.hub_accepte("c2", ch2, {"id": "g-42", "pseudo": "Lucie V."})
self.retour(etat2, "c2")
self.assertEqual(self.f.utilisateur("g-42")["display_name"], "Lucie V.")
def test_proprietaire_par_variable(self):
self.f.proprietaire_id = "g-theo"
for code, ident in (("c1", "g-theo"), ("c2", "g-autre")):
etat, ch = self.depart()
self.hub_accepte(code, ch, {"id": ident, "pseudo": ident})
self.assertEqual(self.retour(etat, code)[0], 303)
self.assertIn(roles.PROPRIETAIRE, self.f.roles_de(self.f.utilisateur("g-theo")))
self.assertNotIn(roles.PROPRIETAIRE, self.f.roles_de(self.f.utilisateur("g-autre")))
def test_state_invalide(self):
etat, ch = self.depart()
self.hub_accepte("c1", ch, {"id": "g-1", "pseudo": "X"})
for st, h, _ in (self.retour("faux-state", cookie_etat="faux-state"), # inconnu du serveur
self.retour(etat, cookie_etat="autre-navigateur"), # pas le navigateur qui a commencé
self.req("/connexion/retour?code=c1&state=" + etat)): # sans cookie
self.assertEqual(st, 400)
self.assertIsNone(self.jeton_session(h)[0])
self.assertIsNone(self.f.con.execute("SELECT 1 FROM users WHERE hub_id='g-1'").fetchone())
st, _, _ = self.req("/connexion/retour?error=access_denied&state=" + etat, cookie="forum_etat=" + etat)
self.assertEqual(st, 400)
def test_pkce_faux_ou_hub_en_panne(self):
etat, _ = self.depart()
self.hub_accepte("c1", "challenge-qui-ne-correspond-pas", {"id": "g-1", "pseudo": "X"})
st, h, _ = self.retour(etat)
self.assertEqual(st, 502)
self.assertIsNone(self.jeton_session(h)[0])
self.reglages.hub_url = "http://127.0.0.1:1" # Hub injoignable
etat, ch = self.depart()
self.assertEqual(self.retour(etat)[0], 502)
def test_session_courte_puis_rafraichie_par_le_hub(self):
"""Revue sécu 06/11 : la session du forum ne dure qu'une heure (jeton du Hub). Au-delà, le forum repasse
par le Hub ; un compte banni ou déconnecté côté Hub n'est donc plus reconnu après au plus 1 h."""
etat, ch = self.depart()
self.hub_accepte("c1", ch, {"id": "g-7", "pseudo": "Zoé"})
jeton = self.jeton_session(self.retour(etat)[1])[0]
u = self.f.utilisateur("g-7")
reste = self.f.con.execute("SELECT (julianday(expires_at) - julianday('now')) * 1440 FROM sessions"
" WHERE user_id=?", (u["id"],)).fetchone()[0]
self.assertLessEqual(reste, forum_mod.SESSION_MINUTES + 1)
# Session échue : une page HTML repasse par le Hub, efface le cookie et garde la page demandée.
self.f.con.execute("UPDATE sessions SET expires_at=datetime('now', '-1 minute')")
self.f.con.commit()
cookie = "forum_session=" + jeton
st, h, _ = self.req("/t/1?page=2", cookie=cookie, entetes={"Accept": "text/html"})
self.assertEqual(st, 303)
self.assertEqual(urlparse(h["Location"]).path, "/oauth/autoriser")
poses = h.get_all("Set-Cookie")
self.assertTrue(any(c.startswith("forum_session=;") and "Max-Age=0" in c for c in poses))
retour = [c for c in poses if c.startswith("forum_retour=")][0].split(";")[0].split("=", 1)[1]
etat2 = [c for c in poses if c.startswith("forum_etat=")][0].split(";")[0].split("=", 1)[1]
q = {k: v[0] for k, v in parse_qs(urlparse(h["Location"]).query).items()}
# Le Hub accepte (session Gastinel valable) : retour sur la page demandée, nouvelle session.
self.hub_accepte("c2", q["code_challenge"], {"id": "g-7", "pseudo": "Zoé"})
st, h, _ = self.req("/connexion/retour?code=c2&state=" + etat2, cookie="forum_etat=%s; forum_retour=%s" % (etat2, retour))
self.assertEqual((st, h["Location"]), (303, "/t/1?page=2"))
self.assertIsNotNone(self.jeton_session(h)[0])
# Le Hub refuse (banni, jetons révoqués) : pas de nouvelle session, et le cookie est déjà effacé.
st, h, _ = self.req("/connexion/retour?code=inconnu&state=" + etat2, cookie="forum_etat=" + etat2)
self.assertIsNone(self.jeton_session(h)[0])
# Sans page HTML demandée (ressource, POST) : pas de détour, simple visiteur.
self.assertEqual(self.req("/", cookie=cookie)[0], 200)
def test_page_de_retour_reste_sur_le_site(self):
for mauvais in ("//evil.example/x", "https://evil.example/", "/%5Cevil", "/a%0d%0aSet-Cookie:x", "x"):
etat, ch = self.depart()
self.hub_accepte("c1", ch, {"id": "g-8", "pseudo": "Max"})
st, h, _ = self.req("/connexion/retour?code=c1&state=" + etat,
cookie="forum_etat=%s; forum_retour=%s" % (etat, quote(unquote(mauvais), safe="/")))
self.assertEqual((st, h["Location"]), (303, "/"), mauvais)
def test_deconnexion_en_post(self):
cookie = self.session("m1")
self.assertEqual(self.req("/deconnexion", cookie=cookie)[0], 404) # pas en GET
self.assertEqual(self.req("/deconnexion", corps=b"", cookie=cookie, origine=False)[0], 403)
st, h, _ = self.req("/deconnexion", corps=b"", cookie=cookie)
self.assertEqual(st, 303)
self.assertIn("Max-Age=0", h["Set-Cookie"])
self.assertIsNone(self.f.utilisateur_de_session(self.sessions["m1"]))
def test_cookies_forges_ignores(self):
for c in ("forum_test=theo", "forum_session=" + "A" * 43, "forum_session=theo"):
b = self.req("/", cookie=c)[2].decode()
self.assertIn("Se connecter avec Gastinel", b)
self.assertEqual(self.req("/roles", cookie="forum_test=theo")[0], 403)
def test_non_configuree(self):
self.reglages.hub_url = ""
self.assertEqual(self.req("/connexion/gastinel")[0], 503)
def test_reglages(self):
with self.assertRaises(ValueError):
connexion.Reglages(hub_url="http://hub.gastinel.me")
r = connexion.Reglages.depuis_env({"FORUM_HUB_URL": "https://hub.gastinel.me/", "FORUM_MODE_TEST": "1",
"FORUM_CLIENT_ID": "x", "FORUM_REDIRECT_URI": "https://v/retour"})
self.assertEqual((r.hub_url, r.client_id, r.redirect_uri, r.mode_test), ("https://hub.gastinel.me", "x", "https://v/retour", True))
self.assertFalse(connexion.Reglages.depuis_env({}).mode_test)
v, c = connexion.pkce()
self.assertTrue(43 <= len(v) <= 128)
self.assertEqual(c, connexion._b64(hashlib.sha256(v.encode()).digest()))
class TestModeEssai(BaseHTTP):
def test_test_login_lan_et_variable(self):
st, h, _ = self.req("/test-login?u=theo")
self.assertEqual(st, 303)
self.assertIn("forum_session=", h["Set-Cookie"])
# derrière Caddy local : l'adresse réelle (Internet) est refusée
st, h, _ = self.req("/test-login?u=theo", entetes={"X-Forwarded-For": "203.0.113.5"})
self.assertEqual(st, 404)
self.assertIsNone(h["Set-Cookie"])
st, _, _ = self.req("/test-login?u=theo", entetes={"X-Forwarded-For": "192.168.1.20"})
self.assertEqual(st, 303)
self.reglages.mode_test = False # sans FORUM_MODE_TEST=1 : jamais
self.assertEqual(self.req("/test-login?u=theo")[0], 404)
self.assertNotIn("/test-login", self.req("/")[2].decode())
def test_ip_client(self):
ip = connexion.ip_client
self.assertEqual(ip("203.0.113.9", "127.0.0.1"), "203.0.113.9") # X-Forwarded-For ignoré hors relais
self.assertEqual(ip("10.8.0.1", "192.168.1.2"), "10.8.0.1")
self.assertEqual(ip("127.0.0.1", "192.168.1.5, 203.0.113.7"), "203.0.113.7") # dernière adresse : celle vue par Caddy
self.assertEqual(ip("127.0.0.1", "pas-une-ip"), "127.0.0.1")
self.assertEqual(ip("10.8.0.1", "203.0.113.7", relais={"10.8.0.1"}), "203.0.113.7")
loc = connexion.est_locale
for a in ("127.0.0.1", "10.1.2.3", "192.168.0.10", "::1", "::ffff:127.0.0.1"):
self.assertTrue(loc(a), a)
for a in ("203.0.113.5", "172.16.0.1", "8.8.8.8", "2001:db8::1", "x"):
self.assertFalse(loc(a), a)
def test_seed_refuse_sans_mode_test(self):
env = {k: v for k, v in os.environ.items() if k != "FORUM_MODE_TEST"}
p = subprocess.run([sys.executable, "-I", os.path.join(ICI, "server.py"), "--seed",
"--db", os.path.join(self.tmp, "x.sqlite3"), "--port", "0"],
env=env, capture_output=True, text=True, timeout=30)
self.assertNotEqual(p.returncode, 0)
self.assertIn("FORUM_MODE_TEST", p.stderr)
self.assertFalse(os.path.exists(os.path.join(self.tmp, "x.sqlite3")))
class TestDecisions(Base):
def test_moderateur_non_adherent(self):
self.assertFalse(roles.MODERATEUR_CREE_SUJETS)
with self.assertRaises(Refus):
self.f.creer_sujet(self.modo, "Sujet", "texte")
t = self.f.creer_sujet(self.adh, "Neige", "x")
p = self.f.repondre(self.modo, t, "Je réponds") # il répond
self.f.masquer_message(self.modo, p) # et modère
self.f.verrouiller(self.modo, t)
with self.assertRaises(Refus): # pas de Bulletin pour lui
self.f.repondre(self.modo, self.bulletin()["id"], "bilan")
self.f.creer_sujet(self.pere, "Sujet du père", "x") # l'adjoint (aussi modérateur) crée, lui
def test_epinglage_reserve_aux_proprietaires(self):
t = self.f.creer_sujet(self.adh, "Neige", "x")
for qui in (self.modo, self.adh, self.membre, self.prop, None):
with self.assertRaises(Refus):
self.f.epingler(qui, t)
self.f.epingler(self.pere, t) # propriétaire adjoint
self.f.epingler(self.theo, t, False) # propriétaire
self.assertEqual(roles.DROITS["epingler"], {roles.PROPRIETAIRE, roles.ADJOINT})
class TestAdhesion(Base):
def test_demande_puis_acceptation(self):
d = self.f.demander_adhesion(self.membre, "Je photographie le givre", [("a.png", png()), ("b.jpg", jpeg())])
with self.assertRaises(Invalide): # une seule en cours
self.f.demander_adhesion(self.membre, "encore")
for qui in (self.modo, self.adh, self.membre):
with self.assertRaises(Refus):
self.f.demandes_adhesion(qui)
with self.assertRaises(Refus):
self.f.decider_adhesion(self.modo, d, True)
liste = self.f.demandes_adhesion(self.pere)
self.assertEqual([(x["id"], x["pseudo"], x["n_photos"]) for x in liste], [(d, "Marie", 2)])
_, ph = self.f.demande_adhesion(self.theo, d)
for p in ph:
self.assertEqual(os.path.dirname(p["stored_path"]), self.f.dossier_demandes)
with open(p["stored_path"], "rb") as fh:
contenu = fh.read()
self.assertNotIn(b"GPS", contenu)
self.assertEqual(self.f.photo_adhesion(self.pere, os.path.basename(p["stored_path"])), p["stored_path"])
self.f.decider_adhesion(self.pere, d, True)
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
with self.assertRaises(Invalide):
self.f.decider_adhesion(self.theo, d, False) # déjà traitée
with self.assertRaises(Invalide):
self.f.demander_adhesion(self.membre, "re") # déjà adhérent
self.assertEqual(self.f.demandes_adhesion(self.theo), [])
self.assertEqual(len(self.f.demandes_adhesion(self.theo, None)), 1)
def test_refus_puis_nouvelle_demande(self):
d = self.f.demander_adhesion(self.modo, "Modérateur, j'aimerais publier")
self.f.decider_adhesion(self.theo, d, False)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.modo))
self.assertEqual(self.f.ma_demande_adhesion(self.modo)["status"], "refusee")
self.f.demander_adhesion(self.modo, "deuxième essai")
def test_limites(self):
with self.assertRaises(Refus):
self.f.demander_adhesion(None, "visiteur")
with self.assertRaises(Invalide):
self.f.demander_adhesion(self.membre, " ")
with self.assertRaises(Refus):
self.f.demander_adhesion(self.membre, "trop", [("a.png", png())] * 11)
with self.assertRaises(Refus):
self.f.demander_adhesion(self.membre, "lourd", [("g.png", png() + b"\x00" * (26 * 1024 * 1024))])
with self.assertRaises(Invalide):
self.f.demander_adhesion(self.membre, "pas une image", [("x.svg", b"<svg/>")])
self.assertIsNone(self.f.ma_demande_adhesion(self.membre)) # rien n'a été enregistré
class TestAdhesionHTTP(BaseHTTP):
def test_parcours(self):
b = self.req("/", "m1")[2].decode()
self.assertIn("Demander à devenir adhérent", b)
frontiere = "AbC"
corps = ("--%s\r\nContent-Disposition: form-data; name=\"message\"\r\n\r\nBonjour, je suis à Autrans\r\n"
"--%s\r\nContent-Disposition: form-data; name=\"photos\"; filename=\"neige.png\"\r\nContent-Type: image/png\r\n\r\n"
% (frontiere, frontiere)).encode() + png() + ("\r\n--%s--\r\n" % frontiere).encode()
self.assertEqual(self.req("/adhesion", "m1", corps, "multipart/form-data; boundary=" + frontiere)[0], 303)
self.assertIn("en attente", self.req("/adhesion", "m1")[2].decode())
self.assertEqual(self.req("/adhesions", "mo1")[0], 403)
st, _, b = self.req("/adhesions", "pere")
self.assertEqual(st, 200)
self.assertIn("Bonjour, je suis à Autrans", b.decode())
nom = b.decode().split("/adhesion-photo/")[1].split("'")[0]
st, h, img = self.req("/adhesion-photo/" + nom, "pere")
self.assertEqual((st, h["Content-Type"], h["Cache-Control"]), (200, "image/png", "private, no-store"))
self.assertNotIn(b"GPS", img)
self.assertEqual(self.req("/adhesion-photo/" + nom, "m1")[0], 403)
self.assertEqual(self.req("/adhesion-photo/" + nom)[0], 403)
self.assertEqual(self.req("/photo/" + nom)[0], 404) # pas dans les photos publiques
d = self.f.ma_demande_adhesion(self.membre)["id"]
self.assertEqual(self.req("/adhesion/decider", "mo1", ("demande=%d&ok=1" % d).encode())[0], 403)
self.assertEqual(self.req("/adhesion/decider", "pere", ("demande=%d&ok=1" % d).encode())[0], 303)
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
class TestFicheHTTP(BaseHTTP):
def setUp(self):
super().setUp()
self.reglages.prefixe = "/forum"
self.t = self.f.creer_sujet_station(self.prop, "geve", "Ma station")
self.f.valider_sujet(self.theo, self.t)
self.p = self.f.repondre(self.prop, self.t, "Photos")
self.ids = self.f.ajouter_photos(self.prop, self.p, [("a.png", png()), ("b.png", png(False))])
def test_route_json_publique_et_cache(self):
st, h, b = self.req("/forum/api/station/geve.json")
self.assertEqual(st, 200)
self.assertTrue(h["Content-Type"].startswith("application/json"))
self.assertIn("max-age=300", h["Cache-Control"])
self.assertIsNone(h["Set-Cookie"])
d = json.loads(b)
self.assertEqual(d, {"station": "geve", "sujet": "/forum/t/%d" % self.t, "photos": []})
self.f.epingler_photo(self.prop, self.ids[0]) # le cache est vidé au changement
d = json.loads(self.req("/api/station/geve.json")[2])
self.assertEqual(len(d["photos"]), 1)
url = d["photos"][0]["url"]
self.assertTrue(url.startswith("/forum/photo/"), url)
st, _, img = self.req(url)
self.assertEqual(st, 200)
self.assertNotIn(b"GPS", img) # photo déjà nettoyée à l'envoi
self.assertEqual(self.req("/forum/api/station/inconnue.json")[0], 404)
self.assertEqual(self.req("/forum/api/station/../db.json")[0], 404)
self.assertEqual(self.req("/forum/api/station/geve.json", corps=b"x=1")[0], 403) # lecture seule
def test_boutons_et_epinglage(self):
chemin = "/forum/t/%d" % self.t
self.assertIn("action='/forum/fiche-photo'", self.req(chemin, "s1")[2].decode())
self.assertIn("action='/forum/fiche-photo'", self.req(chemin, "pere")[2].decode())
self.assertNotIn("fiche-photo", self.req(chemin, "m1")[2].decode())
self.assertNotIn("fiche-photo", self.req(chemin, "mo1")[2].decode())
self.assertNotIn("fiche-photo", self.req(chemin)[2].decode())
st, h, _ = self.req("/forum/fiche-photo", "s1", ("photo=%d&etat=1" % self.ids[1]).encode())
self.assertEqual((st, h["Location"]), (303, "/forum/t/%d#message-%d" % (self.t, self.p)))
self.assertIn("Retirer de la fiche", self.req(chemin, "s1")[2].decode())
self.assertEqual(self.req("/forum/fiche-photo", "m1", ("photo=%d&etat=1" % self.ids[0]).encode())[0], 403)
self.assertEqual(self.req("/forum/fiche-photo", "s1", ("photo=%d&etat=1" % self.ids[0]).encode(), origine=False)[0], 403)
self.assertEqual(self.f.photos_fiche_ids("geve"), {self.ids[1]})
class TestUneHTTP(BaseHTTP):
def setUp(self):
super().setUp()
self.reglages.prefixe = "/forum"
self.chemin = "/forum/api/une.json"
self.bulletin = self.f.sujets(None)[0]["id"]
def test_bulletin_public_et_lien(self):
self.assertEqual(json.loads(self.req(self.chemin)[2]), {"n": 0})
self.f.repondre(self.pere, self.bulletin, "Ancien bulletin")
self.f.repondre(self.adh, self.bulletin, "Neige\n à Gêve")
masque = self.f.repondre(self.pere, self.bulletin, "Bulletin masqué")
self.f.masquer_message(self.modo, masque)
st, h, b = self.req(self.chemin, "mo1")
self.assertEqual(st, 200)
self.assertEqual(h["Content-Type"], "application/json; charset=utf-8")
self.assertEqual(h["Cache-Control"], "no-store")
self.assertIsNone(h["Set-Cookie"])
d = json.loads(b)
self.assertEqual(d, {"n": 0, "titre": "Bulletin de la semaine du Vercors", "auteur": "Alex",
"extrait": "Neige à Gêve", "url": "/forum/t/%d" % self.bulletin})
self.assertEqual(json.loads(self.req("/api/une.json")[2]), d)
self.assertEqual(self.req(d["url"])[0], 200)
message = self.f.repondre(self.adh, self.bulletin, "x" * 181)
self.assertEqual(json.loads(self.req(self.chemin)[2])["extrait"], "x" * 179 + "…")
self.f.masquer_message(self.modo, message)
self.assertEqual(json.loads(self.req(self.chemin)[2]), d)
def test_compte_des_sujets_publics_recents_sans_bulletin(self):
self.f.creer_sujet(self.adh, "Public", "Texte")
masque = self.f.creer_sujet(self.adh, "Masqué", "Texte")
self.f.masquer_sujet(self.modo, masque)
self.f.creer_sujet_station(self.prop, "geve", "En attente")
ancien = self.f.creer_sujet(self.adh, "Ancien", "Texte")
self.f.con.execute("UPDATE topics SET created_at=datetime('now', '-8 days') WHERE id=?", (ancien,))
self.f.con.commit()
self.assertEqual(json.loads(self.req(self.chemin, "theo")[2]), {"n": 1})
class TestPrefixe(BaseHTTP):
def setUp(self):
super().setUp()
self.reglages.prefixe = "/forum"
def test_liens_formulaires_et_cookies(self):
for chemin in ("/forum/", "/forum", "/"): # avec ou sans préfixe (Caddy le retire ou non)
st, _, b = self.req(chemin, "a1")
self.assertEqual(st, 200, chemin)
b = b.decode()
self.assertIn("action='/forum/deconnexion'", b)
self.assertIn("href='/forum/publier'", b)
self.assertIn("href='/forum/'", b)
self.assertNotIn("href='/'", b)
self.assertNotIn("action='/sujet'", b)
formulaire = self.req("/forum/publier", "a1")[2].decode()
self.assertIn("action='/forum/publier'", formulaire)
self.assertNotIn("action='/sujet'", formulaire)
b = self.req("/forum/")[2].decode()
self.assertIn("href='/forum/connexion/gastinel'", b)
def test_redirections_et_posts(self):
for chemin in ("/forum/sujet", "/sujet"):
st, h, _ = self.req(chemin, "a1", b"titre=Neige&corps=Il+neige")
self.assertEqual(st, 303)
self.assertTrue(h["Location"].startswith("/forum/t/"), h["Location"])
st, h, _ = self.req("/forum/deconnexion", "a1", b"")
self.assertEqual((st, h["Location"]), (303, "/forum/deconnecte"))
self.assertIn("Path=/forum;", h["Set-Cookie"])
st, _, b = self.req("/forum/t/1")
self.assertEqual(st, 200)
self.assertIn("href='/forum/'", b.decode())
def test_connexion_cookies_et_retour(self):
st, h, _ = self.req("/forum/connexion/gastinel")
self.assertEqual(st, 303)
self.assertIn("Path=/forum;", [c for c in h.get_all("Set-Cookie") if c.startswith("forum_etat=")][0])
def test_defaut_et_validation(self):
self.assertEqual(connexion.Reglages(prefixe="forum/").prefixe, "/forum")
self.assertEqual(connexion.Reglages(prefixe="/forum", ).redirect_uri, "https://vercors.me/forum/connexion/retour")
self.assertEqual(connexion.Reglages().redirect_uri, "https://vercors.me/connexion/retour")
self.assertEqual(connexion.Reglages.depuis_env({"FORUM_PREFIXE": "/f"}).redirect_uri, "https://vercors.me/f/connexion/retour")
with self.assertRaises(ValueError):
connexion.Reglages(prefixe="/a'b")
class TestPanneau(BaseHTTP):
"""Panneau LAN : second serveur sur la même base, cookie panneau_session, CSRF, propriétaires seulement."""
def setUp(self):
super().setUp()
self.pan = panneau.creer_serveur(self.f, 0, reglages=connexion.Reglages(
hub_url=self.reglages.hub_url, redirect_uri="http://127.0.0.1:1/connexion/retour"))
self.pport = self.pan.server_address[1]
threading.Thread(target=self.pan.serve_forever, daemon=True).start()
self.psess = {}
def tearDown(self):
self.pan.shutdown()
self.pan.server_close()
super().tearDown()
def preq(self, chemin, qui=None, corps=None, csrf=True, entetes=None, cookie=None):
h = dict(entetes or {})
if qui:
if qui not in self.psess:
self.psess[qui] = self.f.ouvrir_session(self.f.utilisateur(qui), 1, panneau.PORTEE)
h["Cookie"] = "panneau_session=" + self.psess[qui]
if cookie:
h["Cookie"] = cookie
if corps is not None:
h["Content-Type"] = "application/x-www-form-urlencoded"
h["Origin"] = "http://127.0.0.1:%d" % self.pport
if csrf and qui:
corps = corps + "&csrf=" + self.csrf(qui)
corps = corps.encode()
c = http.client.HTTPConnection("127.0.0.1", self.pport, timeout=10)
c.request("POST" if corps is not None else "GET", chemin, body=corps, headers=h)
r = c.getresponse()
return r.status, r.headers, r.read()
def csrf(self, qui):
b = self.preq("/", qui)[2].decode()
return b.split("name='csrf' value='")[1].split("'")[0]
def test_refus_hors_lan(self):
for ip in ("8.8.8.8", "172.16.0.5", "2001:db8::1", "192.169.0.1", "11.0.0.1"):
self.assertFalse(connexion.est_locale(ip), ip)
for ip in ("127.0.0.1", "10.1.2.3", "192.168.1.20", "::1"):
self.assertTrue(connexion.est_locale(ip), ip)
h = self.pan.RequestHandlerClass
h.ip = lambda self: "203.0.113.9" # connexion venue d'Internet
try:
self.assertEqual(self.preq("/")[0], 403)
self.assertEqual(self.preq("/utilisateurs", "theo")[0], 403)
self.assertEqual(self.preq("/role", "theo", "hub_id=m1&role=adherent&action=donner", csrf=False)[0], 403)
finally:
del h.ip
self.assertEqual(self.preq("/")[0], 200)
def test_x_forwarded_for_ignore(self):
h = self.pan.RequestHandlerClass
h.ip = lambda self: "203.0.113.9"
try:
self.assertEqual(self.preq("/", entetes={"X-Forwarded-For": "192.168.1.5"})[0], 403) # pas cru
finally:
del h.ip
self.assertEqual(self.preq("/", entetes={"X-Forwarded-For": "8.8.8.8"})[0], 200) # ne retire pas l'accès LAN
def test_refus_non_proprietaire(self):
self.assertEqual(self.preq("/")[0], 200) # page de connexion
self.assertEqual(self.preq("/utilisateurs")[0], 403) # visiteur
for qui in ("m1", "a1", "mo1", "s1"):
for chemin in ("/utilisateurs", "/adhesions", "/stations", "/signalements"):
self.assertEqual(self.preq(chemin, qui)[0], 403, (qui, chemin))
self.assertEqual(self.preq("/role", "m1", "hub_id=m1&role=adherent&action=donner")[0], 403)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
# le cookie du forum ne vaut rien dans le panneau
jeton = self.f.ouvrir_session(self.theo)
self.assertEqual(self.preq("/utilisateurs", cookie="panneau_session=" + jeton)[0], 403)
self.assertEqual(self.preq("/utilisateurs", "theo")[0], 200)
self.assertEqual(self.preq("/utilisateurs", "pere")[0], 200)
def test_csrf_obligatoire(self):
corps = "hub_id=m1&role=adherent&action=donner"
self.assertEqual(self.preq("/role", "theo", corps, csrf=False)[0], 403)
self.assertEqual(self.preq("/role", "theo", corps + "&csrf=faux", csrf=False)[0], 403)
autre = self.csrf("pere") # jeton d'une autre session
self.assertEqual(self.preq("/role", "theo", corps + "&csrf=" + autre, csrf=False)[0], 403)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
st, h, _ = self.preq("/role", "theo", corps)
self.assertEqual((st, h["Location"]), (303, "/utilisateurs"))
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
def test_liste_utilisateurs_et_badges(self):
b = self.preq("/utilisateurs", "theo")[2].decode()
for nom in ("Marie", "Alex", "Richard", "Sam"):
self.assertIn(nom, b)
self.assertIn("aria-label='Propriétaire adjoint'", b)
self.assertIn("Propriétaire de station · Gêve", b)
self.assertNotIn("<script", b)
def test_filtre_et_retrait_cible_dans_le_panneau(self):
b = self.preq("/utilisateurs?q=s1", "theo")[2].decode()
self.assertIn("href='/utilisateurs' aria-current='page'", b)
self.assertIn("Sam", b)
self.assertNotIn("Marie", b)
self.assertIn("<summary>Gérer les rôles</summary>", b)
self.assertIn("<summary>Retirer Station · Gêve…</summary>", b)
self.assertIn("name='station' value='geve'", b)
self.assertIn("Confirmer le retrait", b)
self.assertIn("Aucun compte trouvé", self.preq("/utilisateurs?q=inconnu", "theo")[2].decode())
def test_don_de_role_respecte_peut_donner(self):
base = "hub_id=m1&station="
# l'adjoint donne adhérent, mais pas adjoint ; personne ne donne propriétaire
self.assertEqual(self.preq("/role", "pere", base + "&role=adherent&action=donner")[0], 303)
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "pere", base + "&role=proprietaire_adjoint&action=donner")[0], 403)
self.assertEqual(self.preq("/role", "theo", base + "&role=proprietaire&action=donner")[0], 403)
self.assertNotIn(roles.ADJOINT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "theo", base + "&role=proprietaire_adjoint&action=donner")[0], 303)
self.assertIn(roles.ADJOINT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "theo", base + "geve&role=proprietaire_station&action=donner")[0], 303)
self.assertEqual(self.f.stations_de(self.membre), {"geve"})
self.assertEqual(self.preq("/role", "theo", base + "&role=adherent&action=retirer")[0], 303)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "theo", "hub_id=inconnu&role=adherent&action=donner")[0], 400)
# l'adjoint ne voit pas l'option « adjoint » dans son formulaire
self.assertNotIn("value='proprietaire_adjoint'", self.preq("/utilisateurs", "pere")[2].decode())
self.assertIn("value='proprietaire_adjoint'", self.preq("/utilisateurs", "theo")[2].decode())
def test_decision_adhesion(self):
d = self.f.demander_adhesion(self.membre, "Station à Lans", [("n.png", png())])
b = self.preq("/adhesions", "theo")[2].decode()
self.assertIn("Station à Lans", b)
nom = b.split("/adhesion-photo/")[1].split("'")[0]
st, h, img = self.preq("/adhesion-photo/" + nom, "pere")
self.assertEqual((st, h["Content-Type"]), (200, "image/png"))
self.assertNotIn(b"GPS", img)
self.assertEqual(self.preq("/adhesion-photo/" + nom, "m1")[0], 403)
self.assertEqual(self.preq("/adhesion-photo/" + nom)[0], 403)
self.assertEqual(self.preq("/adhesion/decider", "mo1", "demande=%d&ok=1" % d)[0], 403)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/adhesion/decider", "pere", "demande=%d&ok=1" % d)[0], 303)
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertIn("Aucune demande", self.preq("/adhesions", "theo")[2].decode())
d2 = self.f.demander_adhesion(self.modo, "Je modère déjà")
self.assertEqual(self.preq("/adhesion/decider", "theo", "demande=%d&ok=0" % d2)[0], 303)
self.assertEqual(self.f.ma_demande_adhesion(self.modo)["status"], "refusee")
def test_stations_et_signalements(self):
t = self.f.creer_sujet_station(self.prop, "geve", "Ma station au col")
b = self.preq("/stations", "theo")[2].decode()
self.assertIn("Ma station au col", b)
self.assertEqual(self.preq("/valider", "theo", "sujet=%d&ok=1" % t)[0], 303)
self.assertEqual(self.f.sujet(None, t)[0]["status"], "publie")
p = self.f.repondre(self.adh, self.f.creer_sujet(self.adh, "Neige", "x"), "message douteux")
self.f.signaler(self.membre, p, "Insultes")
b = self.preq("/signalements", "pere")[2].decode()
self.assertIn("Insultes", b)
self.assertIn("message douteux", b)
def test_echappement_et_en_tetes(self):
self.f.utilisateur("x1", "<script>alert(1)</script>")
st, h, b = self.preq("/utilisateurs", "theo")
self.assertNotIn("<script>alert", b.decode())
self.assertIn("&lt;script&gt;", b.decode())
self.assertIn("default-src 'none'", h["Content-Security-Policy"])
self.assertEqual(h["Cache-Control"], "private, no-store")
def test_connexion_gastinel_propre_au_panneau(self):
redir = "http://127.0.0.1:1/connexion/retour"
st, h, _ = self.preq("/connexion/gastinel")
self.assertEqual(st, 303)
q = {k: v[0] for k, v in parse_qs(urlparse(h["Location"]).query).items()}
self.assertEqual(q["redirect_uri"], redir) # adresse de retour distincte
etat = [c for c in h.get_all("Set-Cookie") if c.startswith("panneau_etat=")][0]
self.assertNotIn("Secure", etat) # panneau en http sur le LAN
self.hub.RequestHandlerClass.codes["c1"] = (q["code_challenge"], "forum-vercors", redir, {"id": "pere", "pseudo": "Richard"})
st, h, _ = self.preq("/connexion/retour?code=c1&state=" + q["state"], cookie="panneau_etat=" + q["state"])
self.assertEqual(st, 303)
cookie = [c for c in h.get_all("Set-Cookie") if c.startswith("panneau_session=") and "Max-Age=0" not in c][0]
jeton = cookie.split(";")[0].split("=", 1)[1]
self.assertEqual(self.preq("/utilisateurs", cookie="panneau_session=" + jeton)[0], 200)
# un simple membre Gastinel (ou un inconnu) ne passe pas, et aucun compte n'est créé
for hub_id in ("m1", "inconnu"):
st, h, _ = self.preq("/connexion/gastinel")
q = {k: v[0] for k, v in parse_qs(urlparse(h["Location"]).query).items()}
self.hub.RequestHandlerClass.codes["c2"] = (q["code_challenge"], "forum-vercors", redir, {"id": hub_id, "pseudo": "X"})
st, h, _ = self.preq("/connexion/retour?code=c2&state=" + q["state"], cookie="panneau_etat=" + q["state"])
self.assertEqual(st, 403)
self.assertFalse([c for c in h.get_all("Set-Cookie") if c.startswith("panneau_session=") and "Max-Age=0" not in c])
self.assertIsNone(self.f.utilisateur_existant("inconnu"))
def test_deconnexion(self):
self.assertEqual(self.preq("/deconnexion", "theo", "")[0], 303)
self.assertEqual(self.preq("/utilisateurs", "theo")[0], 403)
# --- Écran de bienvenue et profil public (étapes 1 et 2, 06/11/2026) --------------------------------------------
import profil as profil_mod # noqa: E402
def multipart(champs, fichier=None):
"""(corps, type) d'un formulaire multipart ; fichier : (nom du champ, nom de fichier, octets)."""
fr = "Fr0nt1ere"
morceaux = [("--%s\r\nContent-Disposition: form-data; name=\"%s\"\r\n\r\n%s\r\n" % (fr, k, v)).encode() for k, v in champs.items()]
if fichier:
morceaux.append(("--%s\r\nContent-Disposition: form-data; name=\"%s\"; filename=\"%s\"\r\n"
"Content-Type: application/octet-stream\r\n\r\n" % (fr, fichier[0], fichier[1])).encode() + fichier[2] + b"\r\n")
return b"".join(morceaux) + ("--%s--\r\n" % fr).encode(), "multipart/form-data; boundary=" + fr
class TestUsername(unittest.TestCase):
def test_regles(self):
self.assertEqual(profil_mod.verifier_username("neige.du.col"), "neige.du.col")
self.assertEqual(profil_mod.verifier_username("Élodie_38!"), "Élodie_38!")
for mauvais, attendu in (("abc", "Trop court"), ("a" * 21, "Trop long"), ("neige col", "espace"),
("neige#col", "« # »"), ("!!!!!", "au moins une lettre")):
with self.assertRaises(profil_mod.UsernameInvalide) as ctx:
profil_mod.verifier_username(mauvais)
self.assertIn(attendu, str(ctx.exception))
def test_noms_bloques_a_l_envers_sans_separateurs_et_variantes(self):
for nom in ("Admin", "le.admin.38", "nimda", "Modérateur", "Meteo-Vercors", "srocrevoetem", "Théo.Gastinel",
"l3nitsag", "adm1n", "4dmin", "R.Gastinel", "Direction", "connard", "drannoc", "con__", "branleur38"):
self.assertTrue(profil_mod.est_bloque(nom), nom)
for nom in ("neige.du.col", "Contamines", "habite_ici", "Corrençon", "Lans38"):
self.assertFalse(profil_mod.est_bloque(nom), nom)
def test_fichier_des_noms_bloques(self):
reserves, mots = profil_mod.charger_bloques()
self.assertIn("richardgastinel", reserves)
self.assertIn("connard", mots)
self.assertNotIn("connard", reserves)
def test_bio_liens_cliquables_et_echappee(self):
h = profil_mod.bio_html("Voir https://vercors.me/a?b=1. <script>x</script>")
self.assertIn("<a href='https://vercors.me/a?b=1' rel='nofollow ugc noopener noreferrer'>", h)
self.assertIn("&lt;script&gt;", h)
self.assertNotIn("<script>", h)
with self.assertRaises(ValueError):
profil_mod.verifier_bio("x" * (profil_mod.BIO_MAX + 1))
def test_notifs_par_defaut(self):
d = profil_mod.notifs_defaut()
self.assertTrue(d["posts.reponse_sujet"] and d["posts.reponse_post"] and d["autre.bulletin"])
self.assertFalse(d["posts.reponse_reponse"] or d["posts.reactions"] or d["autre.nouveautes"])
self.assertEqual(profil_mod.notifs_lire(profil_mod.notifs_du_formulaire({"notif_posts": "1"}))["posts.reponse_sujet"], False)
def test_avatars_svg(self):
for nom in profil_mod.AVATARS:
self.assertTrue(profil_mod.svg_avatar(nom).startswith("<svg xmlns="))
self.assertIsNone(profil_mod.svg_avatar("autre"))
class TestProfil(Base):
def nouveau(self, hub_id="n1", nom="Nina Dupont"):
return self.f.connexion_gastinel(hub_id, nom)
def test_migration_idempotente_et_anciens_comptes(self):
chemin = os.path.join(self.tmp, "f.sqlite3")
f1 = Forum(chemin, stations=STATIONS)
f1.utilisateur("ancien", "Ancien Nom")
f1.con.close()
f2 = Forum(chemin, stations=STATIONS) # deuxième ouverture : aucune erreur, données gardées
u = f2.utilisateur("ancien")
self.assertEqual((u["bienvenue"], u["profil"]), (2, None)) # déjà là : pas d'écran, nom inchangé
self.assertIsNone(f2.bienvenue_a_montrer(u))
f2.con.close()
def test_nouveau_compte_voit_l_ecran_une_fois(self):
u = self.nouveau()
self.assertEqual(self.f.bienvenue_a_montrer(u), 1)
self.assertIsNone(self.f.bienvenue_a_montrer(u, explicite=False)) # rafraîchissement silencieux
with self.assertRaises(Invalide):
self.f.choisir_profil(u, "prive", False, "{}") # règles non cochées
with self.assertRaises(Invalide):
self.f.choisir_profil(u, "", True, "{}") # pas de choix par défaut
self.f.choisir_profil(u, "prive", True, profil_mod.notifs_du_formulaire({"notif_autre": "1"}))
self.assertIsNone(self.f.bienvenue_a_montrer(u))
self.assertTrue(profil_mod.notifs_lire(self.f._frais(u)["notifs"])["autre"])
def test_nom_affiche_jamais_le_compte_gastinel(self):
u = self.nouveau()
self.f.choisir_profil(u, "prive", True, "{}")
t = self.f.creer_sujet(self.adh, "Neige", "x")
self.f.repondre(u, t, "Il neige")
_, msgs = self.f.sujet(None, t)
self.assertEqual(msgs[-1]["auteur"], "Membre privé")
self.f.enregistrer_profil(u, "neige.du.col", choix="public")
self.assertEqual(self.f.sujet(None, t)[1][-1]["auteur"], "neige.du.col")
self.f.enregistrer_profil(u, choix="prive") # public -> privé : username gardé mais caché
self.assertEqual(self.f._frais(u)["username"], "neige.du.col")
self.assertEqual(self.f.sujet(None, t)[1][-1]["auteur"], "Membre privé")
self.assertEqual(self.f.sujet(None, t)[1][0]["auteur"], "Alex") # ancien compte : comme avant
def test_prive_ne_cree_pas_de_sujet(self):
u = self.nouveau()
self.f.donner_role(self.theo, "n1", roles.ADHERENT)
self.f.choisir_profil(u, "prive", True, "{}")
self.assertFalse(self.f.peut_creer_sujet(u))
with self.assertRaises(Refus):
self.f.creer_sujet(u, "Titre", "x")
t = self.f.creer_sujet(self.adh, "Neige", "x")
self.f.repondre(u, t, "Je réponds quand même") # répondre reste possible
with self.assertRaises(Invalide):
self.f.enregistrer_profil(u, choix="public") # privé -> public : username obligatoire
self.f.enregistrer_profil(u, "neige.du.col", choix="public")
self.assertTrue(self.f.peut_creer_sujet(u))
self.f.creer_sujet(u, "Titre", "x")
def test_username_unique_sans_majuscules_et_30_jours(self):
a, b = self.nouveau("n1"), self.nouveau("n2")
self.f.enregistrer_profil(a, "Neige.du.col", choix="public")
with self.assertRaises(Invalide) as ctx:
self.f.enregistrer_profil(b, "neige.DU.col", choix="public")
self.assertIn("déjà pris", str(ctx.exception))
self.f.enregistrer_profil(a, "neige.du.col") # majuscules seulement : permis
with self.assertRaises(Invalide) as ctx:
self.f.enregistrer_profil(a, "brume.du.col")
self.assertIn("30 jours", str(ctx.exception))
self.f.con.execute("UPDATE users SET username_le=datetime('now', '-31 days') WHERE hub_id='n1'")
self.f.enregistrer_profil(a, "brume.du.col")
self.assertEqual(self.f.resume_profil(self.membre, self.f._frais(a))["anciens"], ["neige.du.col"])
self.assertEqual(self.f.resume_profil(None, self.f._frais(a))["anciens"], []) # visiteurs : pas d'historique
self.f.enregistrer_profil(b, "neige.du.col", choix="public") # l'ancien nom est libre
def test_plus_tard_trois_fois_puis_ignorer(self):
u = self.nouveau()
self.f.choisir_profil(u, "public", True, "{}")
self.assertEqual(self.f.bienvenue_a_montrer(u), 2)
self.assertEqual(self.f.plus_tard(u), "ok")
self.assertIsNone(self.f.bienvenue_a_montrer(u, explicite=False)) # pas avant la prochaine connexion
self.assertEqual(self.f.bienvenue_a_montrer(u), 2)
self.assertEqual(self.f.plus_tard(u), "ok")
self.assertEqual(self.f.plus_tard(u), "username") # 3e fois, sans username : fenêtre OK
with self.assertRaises(Invalide):
self.f.plus_tard(u)
self.assertEqual(self.f.bienvenue_a_montrer(u), 2) # 4e connexion, sans « Plus tard »
self.assertEqual(self.f.ignorer_bienvenue(u), "suspendu")
u = self.f._frais(u)
self.assertEqual((u["profil"], u["bienvenue"]), ("prive", 2))
self.assertIsNone(self.f.bienvenue_a_montrer(u))
def test_plus_tard_decompte_si_username_sans_photo_ni_bio(self):
u = self.nouveau()
self.f.choisir_profil(u, "public", True, "{}")
self.f.enregistrer_profil(u, "neige.du.col")
self.f.plus_tard(u)
self.f.plus_tard(u)
self.assertEqual(self.f.plus_tard(u), "decompte")
self.assertEqual(self.f.ignorer_bienvenue(u), "ok")
self.assertEqual(self.f._frais(u)["profil"], "public")
def test_profil_complet_termine_l_ecran(self):
u = self.nouveau()
self.f.choisir_profil(u, "public", True, "{}")
self.f.enregistrer_profil(u, "neige.du.col", "Bonjour", avatar="neige")
self.assertIsNone(self.f.bienvenue_a_montrer(u))
def test_visibilite_des_profils(self):
u = self.nouveau()
self.f.enregistrer_profil(u, "neige.du.col", choix="public")
self.assertEqual(self.f.profil_public(self.membre, "NEIGE.du.col")["id"], u["id"])
with self.assertRaises(Invalide):
self.f.profil_public(None, "neige.du.col") # simple membre : invisible sans compte
self.f.donner_role(self.theo, "n1", roles.ADHERENT)
self.assertEqual(self.f.profil_public(None, "neige.du.col")["id"], u["id"])
self.f.enregistrer_profil(u, choix="prive")
with self.assertRaises(Invalide):
self.f.profil_public(self.membre, "neige.du.col")
def test_photo_controlee_et_cachee_si_prive(self):
u = self.nouveau()
self.f.enregistrer_profil(u, "neige.du.col", choix="public", photo=png())
nom = self.f._frais(u)["photo"]
self.assertRegex(nom, r"^[0-9a-f]{64}\.png$")
with open(self.f.photo_profil_publique(None, nom), "rb") as fh:
self.assertNotIn(b"GPS", fh.read()) # métadonnées retirées
with self.assertRaises(Invalide):
self.f.enregistrer_profil(u, photo=b"GIF89a....")
with self.assertRaises(Invalide):
self.f.enregistrer_profil(u, photo=png() + b"\0" * profil_mod.PHOTO_MAX)
self.f.enregistrer_profil(u, choix="prive")
with self.assertRaises(Invalide):
self.f.photo_profil_publique(None, nom)
self.assertTrue(self.f.photo_profil_publique(u, nom)) # le membre voit toujours la sienne
def test_resume_profil(self):
self.f.enregistrer_profil(self.prop, "station.geve", choix="public")
t = self.f.creer_sujet_station(self.prop, "geve", "Ma station")
r = self.f.resume_profil(None, self.f._frais(self.prop))
self.assertEqual(r["stations"][0][:2], ("geve", "Gêve"))
self.assertIn(r["stations"][0][2], (t, None))
def test_suppression_ancien_membre(self):
u = self.nouveau()
self.f.enregistrer_profil(u, "neige.du.col", "Ma bio", choix="public")
t = self.f.creer_sujet(self.adh, "Neige", "x")
self.f.repondre(u, t, "Bonjour")
jeton = self.f.ouvrir_session(u)
self.f.supprimer_profil(u)
self.assertIsNone(self.f.utilisateur_de_session(jeton))
self.assertEqual(self.f.sujet(None, t)[1][-1]["auteur"], "Ancien membre")
c = self.f.con.execute("SELECT * FROM users WHERE id=?", (u["id"],)).fetchone()
self.assertEqual((c["username"], c["bio"], c["photo"]), (None, "", None))
self.f.enregistrer_profil(self.nouveau("n2"), "neige.du.col", choix="public") # nom libéré
with self.assertRaises(Refus):
self.f.supprimer_profil(self.theo)
self.assertEqual(self.f.bienvenue_a_montrer(self.nouveau("n1")), 1) # revient : nouveau compte
class TestBienvenueHTTP(BaseHTTP):
def essai(self, qui="lea"):
st, h, _ = self.req("/test-login?u=%s&nouveau=1" % qui)
self.assertEqual((st, h["Location"]), (303, "/bienvenue?retour=%2F"))
return [c for c in h.get_all("Set-Cookie") if c.startswith("forum_session=")][0].split(";")[0]
def test_visiteur_redirige(self):
st, h, _ = self.req("/bienvenue")
self.assertEqual((st, h["Location"]), (303, "/"))
def test_ancien_compte_ne_voit_pas_l_ecran(self):
st, h, _ = self.req("/bienvenue?retour=%2Ft%2F1", "m1")
self.assertEqual((st, h["Location"]), (303, "/t/1"))
def test_connexion_gastinel_mene_a_l_ecran_puis_retour(self):
self.reglages.mode_test = False
hote = "127.0.0.1:%d" % self.port
def connexion(code):
st, h, _ = self.req("/connexion/gastinel", entetes={"Referer": "http://%s/t/1" % hote})
q = {k: v[0] for k, v in parse_qs(urlparse(h["Location"]).query).items()}
depuis = [c for c in h.get_all("Set-Cookie") if c.startswith("forum_depuis=")][0].split(";")[0]
self.hub.RequestHandlerClass.codes[code] = (q["code_challenge"], "forum-vercors", self.reglages.redirect_uri,
{"id": "g-99", "pseudo": "Paul"})
return self.req("/connexion/retour?code=%s&state=%s" % (code, q["state"]),
cookie="forum_etat=%s; %s" % (q["state"], depuis))
st, h, _ = connexion("c9")
self.assertEqual((st, h["Location"]), (303, "/bienvenue?retour=%2Ft%2F1"))
self.f.choisir_profil(self.f.utilisateur("g-99"), "prive", True, "{}")
st, h, _ = connexion("c10") # deuxième connexion : directement sur la page d'avant
self.assertEqual((st, h["Location"]), (303, "/t/1"))
def test_parcours_public(self):
ck = self.essai()
b = self.req("/bienvenue?retour=%2Ft%2F1", cookie=ck)[2].decode()
for texte in ("Bienvenue sur le forum, lea", "Voici comment cela fonctionne", "Notre promesse", "Réponse à ton sujet",
"name='regles' value='1' required", "Bulletin de la semaine"):
self.assertIn(texte, b)
self.assertNotIn("required checked", b) # pas de choix par défaut
st, _, b = self.req("/bienvenue", corps=b"etape=1&retour=%2Ft%2F1&profil=public", cookie=ck)
self.assertEqual(st, 400)
self.assertIn("ai lu les règles", b.decode())
st, h, _ = self.req("/bienvenue", corps=b"etape=1&retour=%2Ft%2F1&profil=public&regles=1&notif_posts=1", cookie=ck)
self.assertEqual(h["Location"], "/bienvenue?etape=2&retour=%2Ft%2F1")
b = self.req(h["Location"], cookie=ck)[2].decode()
self.assertIn("Ton profil public", b)
self.assertIn("value='plus_tard'", b)
corps, ct = multipart({"etape": "2", "retour": "/t/1", "action": "enregistrer", "username": "adm1n.vercors", "bio": ""})
st, _, b = self.req("/bienvenue", corps=corps, ct=ct, cookie=ck)
self.assertEqual(st, 400)
self.assertIn("réservé", b.decode())
corps, ct = multipart({"etape": "2", "retour": "/t/1", "action": "enregistrer", "username": "lea.du.col",
"bio": "Voir https://vercors.me", "avatar": ""}, ("photo", "moi.png", png()))
st, h, _ = self.req("/bienvenue", corps=corps, ct=ct, cookie=ck)
self.assertEqual((st, h["Location"]), (303, "/t/1"))
u = self.f.utilisateur("lea")
self.assertEqual((u["username"], u["profil"], u["bienvenue"]), ("lea.du.col", "public", 2))
b = self.req("/@lea.du.col", "m1")[2].decode()
for texte in ("<h1>lea.du.col</h1>", "Membre depuis", "href='https://vercors.me'", "/profil-photo/", "noindex"):
self.assertIn(texte, b)
self.assertEqual(self.req("/@lea.du.col")[0], 404) # visiteur : simple membre invisible
self.assertEqual(self.req("/profil-photo/" + u["photo"])[0], 200)
def test_plus_tard_et_fenetres(self):
ck = self.essai()
self.req("/bienvenue", corps=b"etape=1&profil=public&regles=1", cookie=ck)
for n in range(2):
b = self.req("/bienvenue?etape=2", cookie=ck)[2].decode()
self.assertEqual("(1 fois restante)" in b, n == 1)
st, h, _ = self.req("/bienvenue", corps=b"etape=2&action=plus_tard&retour=%2F", cookie=ck)
self.assertEqual((st, h["Location"]), (303, "/"))
st, _, b = self.req("/bienvenue", corps=b"etape=2&action=plus_tard&retour=%2F", cookie=ck)
self.assertIn("Ton profil ne contient pas de username", b.decode())
b = self.req("/bienvenue?etape=2", cookie=ck)[2].decode()
self.assertNotIn("plus_tard", b)
self.assertIn("value='ignorer'", b)
st, _, b = self.req("/bienvenue", corps=b"etape=2&action=ignorer&retour=%2F", cookie=ck)
self.assertIn("Nous avons suspendu", b.decode())
self.assertEqual(self.f.utilisateur("lea")["profil"], "prive")
def test_decompte_au_troisieme_plus_tard(self):
ck = self.essai()
self.req("/bienvenue", corps=b"etape=1&profil=public&regles=1", cookie=ck)
self.f.enregistrer_profil(self.f.utilisateur("lea"), "lea.du.col")
for _ in range(2):
self.req("/bienvenue", corps=b"etape=2&action=plus_tard", cookie=ck)
b = self.req("/bienvenue", corps=b"etape=2&action=plus_tard", cookie=ck)[2].decode()
self.assertIn("id='toast-decompte'", b)
self.assertIn("de biographie ni de photo de profil", b)
def test_prive_sans_bouton_nouveau_sujet(self):
self.f.enregistrer_profil(self.adh, choix="prive") # un adhérent passe en privé
b = self.req("/", "a1")[2].decode()
self.assertNotIn("href='/publier'", b)
self.assertIn("Ton profil est privé", b)
st, _, _ = self.req("/publier", "a1", b"titre=T&corps=x&action=publier")
self.assertEqual(st, 403)
self.assertEqual(self.req("/publier", "a1")[0], 403)
def test_menu_profil_public_et_modifier(self):
ck = self.essai()
self.req("/bienvenue", corps=b"etape=1&profil=prive&regles=1", cookie=ck)
b = self.req("/profil-public", cookie=ck)[2].decode()
self.assertIn("Activer votre profil public", b)
self.assertIn("href='/profil-public'", self.req("/", cookie=ck)[2].decode())
b = self.req("/profil-public/modifier?activer=1", cookie=ck)[2].decode()
for texte in ("Être visible sur Google", "Cette fonction sera bientôt ajoutée", "Réactions", "/avatar/neige.svg"):
self.assertIn(texte, b)
corps, ct = multipart({"profil": "public", "username": "", "bio": ""})
st, _, b = self.req("/profil-public/modifier", corps=corps, ct=ct, cookie=ck)
self.assertEqual(st, 400)
self.assertIn("abord un username", b.decode())
corps, ct = multipart({"profil": "public", "username": "Lea.Vercors", "bio": "Bonjour", "avatar": "station",
"notif_autre": "1", "notif_autre_station": "1"})
st, h, _ = self.req("/profil-public/modifier", corps=corps, ct=ct, cookie=ck)
self.assertEqual((st, h["Location"]), (303, "/profil-public?suite=enregistre"))
u = self.f.utilisateur("lea")
self.assertEqual((u["profil"], u["avatar_illustre"]), ("public", "station"))
self.assertTrue(profil_mod.notifs_lire(u["notifs"])["autre.station"])
self.assertFalse(profil_mod.notifs_lire(u["notifs"])["posts"])
self.assertIn("/@Lea.Vercors", self.req("/profil-public", cookie=ck)[2].decode())
def test_avatar_et_cadres_dans_les_messages(self):
t = self.f.creer_sujet(self.adh, "Neige", "x")
self.f.repondre(self.pere, t, "Moi aussi")
self.f.repondre(self.modo, t, "Et moi")
b = self.req("/t/%d" % t)[2].decode()
self.assertIn("/avatar/brume.svg", b)
self.assertIn("c-couronne", b)
self.assertIn("c-moderateur", b)
st, h, _ = self.req("/avatar/neige.svg")
self.assertEqual((st, h["Content-Type"]), (200, "image/svg+xml; charset=utf-8"))
self.assertEqual(self.req("/avatar/autre.svg")[0], 404)
def test_supprimer_profil(self):
ck = self.essai()
self.req("/bienvenue", corps=b"etape=1&profil=prive&regles=1", cookie=ck)
st, _, _ = self.req("/profil-public/supprimer", corps=b"", cookie=ck)
self.assertEqual(st, 400)
st, h, _ = self.req("/profil-public/supprimer", corps=b"confirmer=1", cookie=ck)
self.assertEqual((st, h["Location"]), (303, "/deconnecte"))
self.assertEqual(self.f.con.execute("SELECT supprime FROM users WHERE hub_id='lea'").fetchone()[0], 1)
class TestCommentaires(Base):
def setUp(self):
super().setUp()
self.t = self.f.creer_sujet(self.adh, "Neige", "Premier")
self.p = self.f.repondre(self.membre, self.t, "Une réponse")
def test_membre_commente_visiteur_non(self):
c = self.f.commenter(self.membre, self.p, " Bien vu https://vercors.me ", "1.2.3.4")
rows = self.f.commentaires(None, [self.p])[self.p]
self.assertEqual([(r["id"], r["body"]) for r in rows], [(c, "Bien vu https://vercors.me")])
with self.assertRaises(Refus):
self.f.commenter(None, self.p, "x")
def test_longueur_et_vide(self):
self.f.commenter(self.membre, self.p, "a" * forum_mod.COMMENTAIRE_MAX)
for corps in ("", " ", "a" * (forum_mod.COMMENTAIRE_MAX + 1)):
with self.assertRaises(Invalide):
self.f.commenter(self.membre, self.p, corps)
def test_profil_prive_commente(self):
self.f.con.execute("UPDATE users SET profil='prive' WHERE id=?", (self.membre["id"],))
self.f.commenter(self.membre, self.p, "En privé")
self.assertEqual(self.f.commentaires(None, [self.p])[self.p][0]["auteur"], "Membre privé")
def test_pas_dans_le_bulletin_ni_verrouille_ni_masque(self):
b = self.bulletin()["id"]
pb = self.f.repondre(self.theo, b, "Bulletin")
with self.assertRaises(Refus):
self.f.commenter(self.membre, pb, "x")
self.f.masquer_message(self.modo, self.p)
with self.assertRaises((Refus, Invalide)):
self.f.commenter(self.membre, self.p, "x")
self.f.masquer_message(self.modo, self.p, False)
self.f.verrouiller(self.modo, self.t)
with self.assertRaises(Refus):
self.f.commenter(self.membre, self.p, "x")
def test_ne_compte_pas_comme_message(self):
for i in range(5):
self.f.commenter(self.membre, self.p, "c%d" % i)
s = [r for r in self.f.sujets(None) if r["id"] == self.t][0]
self.assertEqual(s["n"], 2)
self.assertEqual(len(self.f.sujet(None, self.t)[1]), 2)
def test_suppression_par_l_auteur_seulement(self):
c = self.f.commenter(self.membre, self.p, "Oups")
self.f.signaler_commentaire(self.adh, c, "spam")
with self.assertRaises(Refus):
self.f.supprimer_commentaire(self.adh, c)
with self.assertRaises(Refus):
self.f.supprimer_commentaire(self.modo, c)
self.assertEqual(self.f.supprimer_commentaire(self.membre, c), (self.t, self.p))
self.assertEqual(self.f.commentaires(self.theo, [self.p])[self.p], [])
self.assertEqual(self.f.con.execute("SELECT COUNT(*) FROM comment_reports").fetchone()[0], 0)
def test_signaler_et_masquer(self):
c = self.f.commenter(self.membre, self.p, "Douteux")
self.f.signaler_commentaire(self.adh, c, "hors sujet")
self.f.signaler_commentaire(self.adh, c, "encore") # un seul signalement par compte
self.assertEqual(len(self.f.signalements_commentaires(self.modo)), 1)
with self.assertRaises(Refus):
self.f.signalements_commentaires(self.membre)
with self.assertRaises(Refus):
self.f.masquer_commentaire(self.adh, c)
self.f.masquer_commentaire(self.modo, c)
self.assertEqual(self.f.commentaires(None, [self.p])[self.p], [])
self.assertEqual(len(self.f.commentaires(self.modo, [self.p])[self.p]), 1)
with self.assertRaises(Invalide):
self.f.signaler_commentaire(self.adh, c, "x")
def test_migration_idempotente(self):
chemin = os.path.join(self.tmp, "f.db")
f1 = Forum(chemin)
u = f1.utilisateur("x1", "X")
t = f1.creer_sujet(f1.fixer_proprietaire("x1", "X"), "S", "corps")
p = f1.repondre(u, t, "r")
f1.commenter(u, p, "garde-moi")
f1.con.close()
f2 = Forum(chemin)
self.assertEqual(f2.commentaires(None, [p])[p][0]["body"], "garde-moi")
f2.con.close()
def test_purge_ip(self):
c = self.f.commenter(self.membre, self.p, "x", "1.2.3.4")
self.f.con.execute("UPDATE comments SET created_at=datetime('now','-13 months') WHERE id=?", (c,))
self.f.purger_ips()
self.assertIsNone(self.f.con.execute("SELECT ip FROM comments WHERE id=?", (c,)).fetchone()[0])
class TestCommentairesHTTP(BaseHTTP):
def setUp(self):
super().setUp()
self.t = self.f.creer_sujet(self.adh, "Neige", "Premier")
self.p = self.f.repondre(self.membre, self.t, "Une réponse")
def test_parcours(self):
b = self.req("/t/%d" % self.t, "m1")[2].decode()
self.assertIn("<summary>Répondre</summary>", b)
self.assertNotIn("<summary>Répondre</summary>", self.req("/t/%d" % self.t)[2].decode())
st, h, _ = self.req("/commenter", "m1", corps=("post=%d&corps=%s" % (self.p, quote("Voir https://vercors.me/ <b> 100%"))).encode())
self.assertEqual(st, 303)
self.assertRegex(h["Location"], r"^/t/%d#commentaire-\d+$" % self.t)
b = self.req("/t/%d" % self.t)[2].decode()
self.assertIn("<a href='https://vercors.me/' rel='nofollow ugc noopener noreferrer'>", b)
self.assertIn("&lt;b&gt; 100%", b)
self.assertNotIn("action='/commentaire/supprimer'", b) # visiteur : rien à faire
def test_csrf_et_visiteur(self):
corps = ("post=%d&corps=x" % self.p).encode()
self.assertEqual(self.req("/commenter", "m1", corps=corps, origine=False)[0], 403)
self.assertEqual(self.req("/commenter", corps=corps)[0], 403)
self.assertEqual(self.f.con.execute("SELECT COUNT(*) FROM comments").fetchone()[0], 0)
def test_repli_trois_derniers(self):
for i in range(5):
self.f.commenter(self.membre, self.p, "numero%d" % i)
b = self.req("/t/%d" % self.t)[2].decode()
self.assertIn("Voir les 2 autres commentaires", b)
repli = b.split("class='plus-commentaires'")[1].split("</details>")[0]
self.assertIn("numero0", repli)
self.assertNotIn("numero2", repli)
def test_bulletin_sans_commentaires(self):
b = self.bulletin()["id"]
self.f.repondre(self.theo, b, "Bulletin")
self.assertNotIn("Commenter", self.req("/t/%d" % b, "m1")[2].decode())
def test_moderation(self):
c = self.f.commenter(self.membre, self.p, "Douteux")
st, h, _ = self.req("/commentaire/signaler", "a1", corps=("commentaire=%d&motif=spam" % c).encode())
self.assertEqual(st, 303)
self.assertIn("Commentaire #%d" % c, self.req("/moderation", "mo1")[2].decode())
st, _, _ = self.req("/commentaire/masquer", "mo1", corps=("commentaire=%d&etat=1" % c).encode())
self.assertEqual(st, 303)
self.assertNotIn("Douteux", self.req("/t/%d" % self.t)[2].decode())
self.assertIn("Douteux", self.req("/t/%d" % self.t, "mo1")[2].decode())
self.assertEqual(self.req("/commentaire/supprimer", "a1", corps=("commentaire=%d" % c).encode())[0], 403)
self.assertEqual(self.req("/commentaire/supprimer", "m1", corps=("commentaire=%d" % c).encode())[0], 303)
class TestReactions(Base):
def setUp(self):
super().setUp()
self.t = self.f.creer_sujet(self.adh, "Givre", "Premier")
self.p0 = self.f.sujet(None, self.t)[1][0]["id"]
self.p = self.f.repondre(self.membre, self.t, "Une réponse")
def etat(self, pid=None, qui=None):
pid = pid or self.p
return self.f.reactions(qui, [pid])[pid]
def test_basculer_remplacer_retirer(self):
self.f.reagir(self.adh, self.p, "soleil")
self.f.reagir(self.modo, self.p, "soleil")
self.assertEqual([(k, len(n)) for k, n in self.etat()["liste"]], [("soleil", 2)])
self.assertEqual(self.etat(qui=self.adh)["mien"], "soleil")
self.f.reagir(self.adh, self.p, "oeil") # remplace
self.assertEqual([(k, len(n)) for k, n in self.etat()["liste"]], [("soleil", 1), ("oeil", 1)])
self.f.reagir(self.adh, self.p, "oeil") # recliquer : enlève
self.assertEqual(self.etat(qui=self.adh)["mien"], None)
self.assertEqual(self.f.con.execute("SELECT COUNT(*) FROM reactions").fetchone()[0], 1)
def test_premier_message_et_date(self):
self.f.reagir(self.membre, self.p0, "flocon")
self.assertIsNotNone(self.f.con.execute("SELECT created_at FROM reactions WHERE post_id=?", (self.p0,)).fetchone()[0])
def test_visiteur_et_inconnue(self):
with self.assertRaises(Refus):
self.f.reagir(None, self.p, "soleil")
with self.assertRaises(Invalide):
self.f.reagir(self.membre, self.p, "pouce")
def test_noms_prive_et_ancien(self):
self.f.con.execute("UPDATE users SET profil='prive' WHERE id=?", (self.membre["id"],))
self.f.reagir(self.membre, self.p, "sommet")
self.f.reagir(self.adh, self.p, "sommet")
self.f.con.execute("UPDATE users SET supprime=1 WHERE id=?", (self.adh["id"],))
self.assertEqual(self.etat()["liste"][0][1], ["Membre privé", "Ancien membre"])
def test_pas_dans_le_bulletin_ni_verrouille_ni_masque(self):
b = self.bulletin()["id"]
pb = self.f.repondre(self.theo, b, "Bulletin")
with self.assertRaises(Refus):
self.f.reagir(self.membre, pb, "soleil")
self.f.masquer_message(self.modo, self.p)
with self.assertRaises((Refus, Invalide)):
self.f.reagir(self.membre, self.p, "soleil")
self.f.masquer_message(self.modo, self.p, False)
self.f.verrouiller(self.modo, self.t)
with self.assertRaises(Refus):
self.f.reagir(self.membre, self.p, "soleil")
def test_ne_compte_pas_comme_message(self):
for qui in (self.membre, self.adh, self.modo):
self.f.reagir(qui, self.p, "eclair")
s = [r for r in self.f.sujets(None) if r["id"] == self.t][0]
self.assertEqual(s["n"], 2)
def test_migration_idempotente(self):
chemin = os.path.join(self.tmp, "r.db")
f1 = Forum(chemin)
u = f1.utilisateur("x1", "X")
t = f1.creer_sujet(f1.fixer_proprietaire("x1", "X"), "S", "corps")
p = f1.repondre(u, t, "r")
f1.reagir(u, p, "goutte")
f1.con.close()
f2 = Forum(chemin)
self.assertEqual(f2.reactions(None, [p])[p]["liste"][0][0], "goutte")
f2.con.close()
class TestReactionsHTTP(BaseHTTP):
def setUp(self):
super().setUp()
self.t = self.f.creer_sujet(self.adh, "Givre", "Premier")
self.p = self.f.repondre(self.membre, self.t, "Une réponse")
def test_sans_js_redirige_vers_le_message(self):
st, h, _ = self.req("/reagir", "m1", corps=("post=%d&reaction=soleil" % self.p).encode())
self.assertEqual(st, 303)
self.assertEqual(h["Location"], "/t/%d#message-%d" % (self.t, self.p))
b = self.req("/t/%d" % self.t, "m1")[2].decode()
self.assertIn("aria-pressed='true' title='Merci : Marie'", b)
self.assertIn("+ Réagir", b)
self.assertIn("<g id='r-soleil'>", b)
self.assertIn("/reactions.js", b)
def test_fetch_json(self):
st, h, corps = self.req("/reagir", "m1", corps=("post=%d&reaction=flocon" % self.p).encode(),
entetes={"Accept": "application/json"})
self.assertEqual(st, 200)
d = json.loads(corps)
self.assertEqual(d["mien"], "flocon")
self.assertEqual([(r["k"], r["n"], r["titre"]) for r in d["liste"]], [("flocon", 1, "Superbe : Marie")])
def test_visiteur_voit_sans_cliquer(self):
self.f.reagir(self.membre, self.p, "soleil")
b = self.req("/t/%d" % self.t)[2].decode()
self.assertIn("<span class='reac' data-k='soleil' title='Merci : Marie'", b)
self.assertNotIn("action='/reagir'", b)
self.assertNotIn("+ Réagir", b)
def test_csrf_et_visiteur(self):
corps = ("post=%d&reaction=soleil" % self.p).encode()
self.assertEqual(self.req("/reagir", "m1", corps=corps, origine=False)[0], 403)
self.assertEqual(self.req("/reagir", corps=corps)[0], 403)
self.assertEqual(self.f.con.execute("SELECT COUNT(*) FROM reactions").fetchone()[0], 0)
def test_bulletin_et_commentaires_sans_reactions(self):
b = self.bulletin()["id"]
self.f.repondre(self.theo, b, "Bulletin")
self.assertNotIn("Réagir", self.req("/t/%d" % b, "m1")[2].decode())
self.f.commenter(self.membre, self.p, "un commentaire")
page = self.req("/t/%d" % self.t, "m1")[2].decode()
self.assertEqual(page.count("+ Réagir"), 2) # premier message et réponse, pas le commentaire
def test_verrouille_compteurs_seuls(self):
self.f.reagir(self.membre, self.p, "oeil")
self.f.verrouiller(self.modo, self.t)
b = self.req("/t/%d" % self.t, "m1")[2].decode()
self.assertIn("title='Vu aussi : Marie'", b)
self.assertNotIn("action='/reagir'", b)
def test_script_servi(self):
st, h, corps = self.req("/reactions.js")
self.assertEqual(st, 200)
self.assertTrue(h["Content-Type"].startswith("text/javascript"))
self.assertIn(b"form.reactions", corps)
class TestSuppression(Base):
def _sujet_complet(self):
t = self.f.creer_sujet(self.adh, "Orage", "Premier message")
p = self.f.repondre(self.membre, t, "Une réponse")
self.f.ajouter_photos(self.membre, p, [("o.png", png())])
c = self.f.commenter(self.adh, p, "Un commentaire")
self.f.reagir(self.adh, p, sorted(forum_mod.REACTIONS)[0])
self.f.signaler(self.adh, p, "test")
self.f.signaler_commentaire(self.membre, c, "test")
self.f.noter_lecture(self.membre, t, p)
return t, p, c
def _n(self, sql, *a):
return self.f.con.execute(sql, a).fetchone()[0]
def test_droit_reserve_aux_proprietaires(self):
self.assertEqual(roles.DROITS["supprimer"], {roles.PROPRIETAIRE, roles.ADJOINT})
t, p, c = self._sujet_complet()
for qui in (self.membre, self.adh, self.modo, self.prop):
with self.assertRaises(Refus):
self.f.supprimer_message(qui, p)
with self.assertRaises(Refus):
self.f.supprimer_sujet(qui, t)
with self.assertRaises(Refus):
self.f.supprimer_commentaire(self.modo, c) # le modérateur masque, il ne supprime pas
self.assertEqual(self._n("SELECT COUNT(*) FROM posts WHERE topic_id=?", t), 2)
self.f.supprimer_commentaire(self.pere, c) # adjoint
self.assertEqual(self._n("SELECT COUNT(*) FROM comments"), 0)
self.assertEqual(self._n("SELECT COUNT(*) FROM comment_reports"), 0)
self.assertEqual(self.f.supprimer_message(self.theo, p), t)
self.assertEqual(self._n("SELECT COUNT(*) FROM posts WHERE id=?", p), 0)
j = self.f.journal_suppressions(self.theo)
self.assertEqual([r["quoi"] for r in j], ["message", "commentaire"])
self.assertEqual(j[0]["acteur_id"], self.theo["id"])
self.assertTrue(j[0]["quand"])
with self.assertRaises(Refus):
self.f.journal_suppressions(self.modo)
def test_premier_message_renvoie_au_sujet(self):
t, _, _ = self._sujet_complet()
premier = self.f._premier_message(t)
with self.assertRaises(Invalide):
self.f.supprimer_message(self.theo, premier)
def test_suppression_en_cascade(self):
t, p, _ = self._sujet_complet()
fichier = self.f.photos_de(p)[0]["stored_path"]
self.assertTrue(os.path.isfile(fichier))
autre = self.f.creer_sujet(self.adh, "Autre", "Reste")
self.f.supprimer_sujet(self.pere, t)
for table in ("posts", "comments", "reactions", "reports", "comment_reports", "attachments", "lectures"):
col = "topic_id" if table in ("posts", "lectures") else None
if col:
self.assertEqual(self._n("SELECT COUNT(*) FROM %s WHERE topic_id=?" % table, t), 0, table)
else:
self.assertEqual(self._n("SELECT COUNT(*) FROM %s" % table), 0, table)
self.assertEqual(self._n("SELECT COUNT(*) FROM topics WHERE id=?", t), 0)
self.assertFalse(os.path.exists(fichier))
self.assertEqual(self._n("SELECT COUNT(*) FROM topics WHERE id=?", autre), 1)
self.assertEqual(self.f.journal_suppressions(self.theo)[0]["quoi"], "sujet")
def test_photo_partagee_gardee(self):
t1 = self.f.creer_sujet(self.adh, "Un", "x")
t2 = self.f.creer_sujet(self.adh, "Deux", "y")
p1 = self.f.repondre(self.membre, t1, "a")
p2 = self.f.repondre(self.membre, t2, "b")
self.f.ajouter_photos(self.membre, p1, [("a.png", png())])
self.f.ajouter_photos(self.membre, p2, [("a.png", png())])
fichier = self.f.photos_de(p2)[0]["stored_path"]
self.f.supprimer_sujet(self.theo, t1)
self.assertTrue(os.path.isfile(fichier))
def test_sujets_fixes_proteges(self):
b = self.bulletin()
with self.assertRaises(Refus):
self.f.supprimer_sujet(self.theo, b["id"])
self.f.creer_sujets_stations()
st = self.f.con.execute("SELECT id FROM topics WHERE station='geve'").fetchone()[0]
with self.assertRaises(Refus):
self.f.supprimer_sujet(self.theo, st)
pid = self.f.repondre(self.theo, b["id"], "Bulletin du lundi") # leurs messages, oui (même le premier)
self.f.supprimer_message(self.theo, pid)
self.assertEqual(self._n("SELECT COUNT(*) FROM topics WHERE id=?", b["id"]), 1)
class TestSuppressionHTTP(BaseHTTP):
def test_boutons_et_post(self):
t = self.f.creer_sujet(self.adh, "Neige", "Premier")
p = self.f.repondre(self.adh, t, "Deuxième")
page = self.req("/t/%d" % t, "theo")[2].decode()
self.assertIn("action='/sujet/supprimer'", page)
self.assertIn("action='/supprimer'", page)
self.assertIn("Supprimer définitivement ?", page)
for qui in ("mo1", "m1"):
pg = self.req("/t/%d" % t, qui)[2].decode()
self.assertNotIn("action='/supprimer'", pg)
self.assertNotIn("action='/sujet/supprimer'", pg)
self.assertEqual(self.req("/supprimer", qui, "post=%d" % p)[0], 403)
self.assertEqual(self.req("/supprimer", "theo", "post=%d" % p, origine=False)[0], 403) # contrôle Origin
st, h, _ = self.req("/supprimer", "theo", "post=%d" % p)
self.assertEqual((st, h["Location"]), (303, "/t/%d?suite=supprime" % t))
st, h, _ = self.req("/sujet/supprimer", "pere", "sujet=%d" % t)
self.assertEqual(st, 303)
self.assertEqual(self.req("/t/%d" % t, "theo")[0], 404)
b = self.bulletin()["id"]
self.assertNotIn("action='/sujet/supprimer'", self.req("/t/%d" % b, "theo")[2].decode())
self.assertEqual(self.req("/sujet/supprimer", "theo", "sujet=%d" % b)[0], 403)
if __name__ == "__main__":
unittest.main()