- 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>
1904 lignes
101 KiB
Python
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("<script>", 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("<script>", 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®les=1¬if_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®les=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®les=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®les=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®les=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("<b> 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()
|