- collecte : collecter_meteofrance, extraire_infoclimat, extraire_vp2, archiver_historique, importer_opendata ; WeatherLink allégé (alleger) - tests : meteofrance, infoclimat, vp2, archive, opendata (tous verts) - maquettes/accueil-carte : sources de la maquette (générateurs de tuiles, page, À propos, CGU, confidentialité) - forum : noyau local (rôles, droits, SQLite, serveur de test, 18 tests) - deploy : Caddyfile.vercors.me.v2 (non appliqué) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
249 lignes
11 KiB
Python
249 lignes
11 KiB
Python
"""Tests du forum. Lancer : python -I forum/tests/test_forum.py"""
|
|
import http.client
|
|
import os
|
|
import sys
|
|
import threading
|
|
import unittest
|
|
from urllib.parse import urlencode
|
|
|
|
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
|
|
import roles # noqa: E402
|
|
import server # noqa: E402
|
|
from forum import Forum, Invalide, Refus # noqa: E402
|
|
|
|
RECAP = "recapitulatif-semaine"
|
|
|
|
|
|
def faire():
|
|
f = Forum()
|
|
u = {"membre": f.utilisateur("m1")}
|
|
for hub, r in (("a1", "adherent"), ("mo1", "moderateur"), ("ad1", "admin")):
|
|
u[r] = f.utilisateur(hub)
|
|
f.con.execute("UPDATE users SET role=? WHERE hub_id=?", (r, hub))
|
|
f.con.commit()
|
|
u = {r: f.utilisateur(x["hub_id"]) for r, x in u.items()}
|
|
u["visiteur"] = None
|
|
return f, u
|
|
|
|
|
|
class TestRoles(unittest.TestCase):
|
|
def test_tableau_des_droits(self):
|
|
attendu = {
|
|
"lire": [1, 1, 1, 1, 1],
|
|
"repondre": [0, 1, 1, 1, 1],
|
|
"signaler": [0, 1, 1, 1, 1],
|
|
"creer_sujet": [0, 0, 1, 1, 1],
|
|
"masquer": [0, 0, 0, 1, 1],
|
|
"verrouiller": [0, 0, 0, 1, 1],
|
|
"voir_signalements": [0, 0, 0, 1, 1],
|
|
"changer_role": [0, 0, 0, 0, 1],
|
|
}
|
|
for droit, lignes in attendu.items():
|
|
for r, ok in zip(roles.ORDRE, lignes):
|
|
self.assertEqual(roles.peut(r, droit), bool(ok), (droit, r))
|
|
|
|
def test_inconnus(self):
|
|
with self.assertRaises(ValueError):
|
|
roles.peut("roi", "lire")
|
|
with self.assertRaises(ValueError):
|
|
roles.peut("membre", "tout")
|
|
|
|
|
|
class TestForum(unittest.TestCase):
|
|
def setUp(self):
|
|
self.f, self.u = faire()
|
|
|
|
def test_visiteur_lit_mais_ne_cree_pas(self):
|
|
t = self.f.creer_sujet(self.u["adherent"], RECAP, "Semaine 44", "Pluie.")
|
|
self.assertEqual(len(self.f.sujets(None)), 1)
|
|
self.assertEqual(len(self.f.sujet(None, t)[1]), 1)
|
|
with self.assertRaises(Refus):
|
|
self.f.creer_sujet(None, RECAP, "x", "y")
|
|
with self.assertRaises(Refus):
|
|
self.f.repondre(None, t, "x")
|
|
with self.assertRaises(Refus):
|
|
self.f.signaler(None, 1, "x")
|
|
|
|
def test_membre_repond_mais_ne_publie_pas(self):
|
|
with self.assertRaises(Refus):
|
|
self.f.creer_sujet(self.u["membre"], RECAP, "x", "y")
|
|
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Vent")
|
|
self.f.repondre(self.u["membre"], t, "Merci")
|
|
self.assertEqual(len(self.f.sujet(None, t)[1]), 2)
|
|
with self.assertRaises(Refus):
|
|
self.f.masquer_message(self.u["membre"], 1)
|
|
with self.assertRaises(Refus):
|
|
self.f.verrouiller(self.u["membre"], t)
|
|
with self.assertRaises(Refus):
|
|
self.f.signalements(self.u["membre"])
|
|
|
|
def test_adherent_publie_recap(self):
|
|
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Texte", ip="1.2.3.4")
|
|
s, m = self.f.sujet(None, t)
|
|
self.assertEqual(s["cat_name"], "Récapitulatif de la semaine")
|
|
self.assertEqual(m[0]["auteur"], "a1")
|
|
with self.assertRaises(Refus):
|
|
self.f.masquer_sujet(self.u["adherent"], t)
|
|
with self.assertRaises(Refus):
|
|
self.f.changer_role(self.u["adherent"], "m1", "admin")
|
|
|
|
def test_modifier_seulement_son_message(self):
|
|
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Texte")
|
|
p = self.f.repondre(self.u["membre"], t, "a")
|
|
self.f.modifier_message(self.u["membre"], p, "b")
|
|
self.assertEqual(self.f.sujet(None, t)[1][1]["body"], "b")
|
|
with self.assertRaises(Refus):
|
|
self.f.modifier_message(self.u["adherent"], p, "pirate")
|
|
with self.assertRaises(Refus):
|
|
self.f.modifier_message(None, p, "pirate")
|
|
|
|
def test_moderation_masquage_et_signalement(self):
|
|
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Texte")
|
|
p = self.f.repondre(self.u["membre"], t, "spam")
|
|
self.f.signaler(self.u["adherent"], p, "publicité")
|
|
self.f.signaler(self.u["adherent"], p, "publicité") # doublon ignoré
|
|
sig = self.f.signalements(self.u["moderateur"])
|
|
self.assertEqual(len(sig), 1)
|
|
self.f.masquer_message(self.u["moderateur"], p)
|
|
self.assertEqual(len(self.f.sujet(None, t)[1]), 1) # invisible au public
|
|
self.assertEqual(len(self.f.sujet(self.u["membre"], t)[1]), 1)
|
|
self.assertEqual(len(self.f.sujet(self.u["moderateur"], t)[1]), 2)
|
|
self.f.masquer_message(self.u["moderateur"], p, False)
|
|
self.assertEqual(len(self.f.sujet(None, t)[1]), 2)
|
|
|
|
def test_sujet_masque_et_verrouille(self):
|
|
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Texte")
|
|
self.f.verrouiller(self.u["moderateur"], t)
|
|
with self.assertRaises(Refus):
|
|
self.f.repondre(self.u["membre"], t, "x")
|
|
self.f.verrouiller(self.u["moderateur"], t, False)
|
|
self.f.masquer_sujet(self.u["moderateur"], t)
|
|
self.assertEqual(self.f.sujets(None), [])
|
|
with self.assertRaises(Invalide):
|
|
self.f.sujet(None, t)
|
|
self.assertEqual(len(self.f.sujets(self.u["moderateur"])), 1)
|
|
|
|
def test_admin_change_les_roles(self):
|
|
self.f.changer_role(self.u["admin"], "m1", "adherent")
|
|
m = self.f.utilisateur("m1")
|
|
self.f.creer_sujet(m, RECAP, "ok", "ok")
|
|
with self.assertRaises(Refus):
|
|
self.f.changer_role(self.u["moderateur"], "m1", "membre")
|
|
with self.assertRaises(Refus):
|
|
self.f.changer_role(self.u["admin"], "ad1", "membre") # pas d'auto-rétrogradation
|
|
with self.assertRaises(Invalide):
|
|
self.f.changer_role(self.u["admin"], "m1", "visiteur")
|
|
with self.assertRaises(Invalide):
|
|
self.f.changer_role(self.u["admin"], "inconnu", "membre")
|
|
|
|
def test_validation_des_champs(self):
|
|
with self.assertRaises(Invalide):
|
|
self.f.creer_sujet(self.u["adherent"], RECAP, " ", "x")
|
|
with self.assertRaises(Invalide):
|
|
self.f.creer_sujet(self.u["adherent"], "nope", "t", "x")
|
|
with self.assertRaises(Invalide):
|
|
self.f.creer_sujet(self.u["adherent"], RECAP, "t" * 200, "x")
|
|
|
|
def test_purge_ip_13_mois(self):
|
|
t = self.f.creer_sujet(self.u["adherent"], RECAP, "S44", "Texte", ip="1.2.3.4")
|
|
self.f.repondre(self.u["membre"], t, "récent", ip="5.6.7.8")
|
|
self.f.con.execute("UPDATE posts SET created_at=datetime('now','-14 months') WHERE id=1")
|
|
self.f.con.commit()
|
|
self.assertEqual(self.f.purger_ips(13), 1)
|
|
ips = [r["ip"] for r in self.f.con.execute("SELECT ip FROM posts ORDER BY id")]
|
|
self.assertEqual(ips, [None, "5.6.7.8"])
|
|
|
|
|
|
class TestHTTP(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.f, cls.u = faire()
|
|
cls.srv = server.creer_serveur(cls.f)
|
|
cls.port = cls.srv.server_address[1]
|
|
threading.Thread(target=cls.srv.serve_forever, daemon=True).start()
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
cls.srv.shutdown()
|
|
cls.srv.server_close()
|
|
|
|
def req(self, methode, chemin, user=None, data=None, origine=True):
|
|
c = http.client.HTTPConnection("127.0.0.1", self.port, timeout=5)
|
|
h = {}
|
|
if user:
|
|
h["Cookie"] = "%s=%s" % (server.COOKIE, user)
|
|
body = None
|
|
if data is not None:
|
|
body = urlencode(data)
|
|
h["Content-Type"] = "application/x-www-form-urlencoded"
|
|
if origine:
|
|
h["Origin"] = "http://127.0.0.1:%d" % self.port
|
|
c.request(methode, chemin, body, h)
|
|
r = c.getresponse()
|
|
txt = r.read().decode("utf-8")
|
|
c.close()
|
|
return r, txt
|
|
|
|
def test_visiteur_lit_sans_formulaire(self):
|
|
r, txt = self.req("GET", "/")
|
|
self.assertEqual(r.status, 200)
|
|
self.assertIn("lecture seule", txt)
|
|
self.assertNotIn("Nouveau sujet", txt)
|
|
self.assertIn("light", txt)
|
|
self.assertNotIn("http://", txt.replace("http://127.0.0.1", "")) # aucune ressource distante
|
|
self.assertIn("default-src 'none'", r.getheader("Content-Security-Policy"))
|
|
|
|
def test_membre_ne_peut_pas_publier(self):
|
|
r, txt = self.req("GET", "/", "m1")
|
|
self.assertNotIn("Nouveau sujet", txt)
|
|
r, _ = self.req("POST", "/sujet", "m1",
|
|
{"categorie": RECAP, "titre": "x", "corps": "y"})
|
|
self.assertEqual(r.status, 403)
|
|
|
|
def test_adherent_publie_et_echappement(self):
|
|
r, txt = self.req("GET", "/", "a1")
|
|
self.assertIn("Nouveau sujet", txt)
|
|
r, _ = self.req("POST", "/sujet", "a1", {
|
|
"categorie": RECAP, "titre": "Semaine <b>44</b>", "corps": "<script>x()</script>"})
|
|
self.assertEqual(r.status, 303)
|
|
r, txt = self.req("GET", r.getheader("Location"))
|
|
self.assertEqual(r.status, 200)
|
|
self.assertIn("<script>", txt)
|
|
self.assertNotIn("<script>", txt)
|
|
self.assertNotIn("<b>44", txt)
|
|
|
|
def test_post_sans_connexion_ou_sans_origine(self):
|
|
r, _ = self.req("POST", "/sujet", None, {"categorie": RECAP, "titre": "x", "corps": "y"})
|
|
self.assertEqual(r.status, 403)
|
|
r, _ = self.req("POST", "/sujet", "a1",
|
|
{"categorie": RECAP, "titre": "x", "corps": "y"}, origine=False)
|
|
self.assertEqual(r.status, 403)
|
|
|
|
def test_moderation_reservee(self):
|
|
self.assertEqual(self.req("GET", "/moderation")[0].status, 403)
|
|
self.assertEqual(self.req("GET", "/moderation", "m1")[0].status, 403)
|
|
self.assertEqual(self.req("GET", "/moderation", "a1")[0].status, 403)
|
|
self.assertEqual(self.req("GET", "/moderation", "mo1")[0].status, 200)
|
|
self.assertEqual(self.req("GET", "/moderation", "ad1")[0].status, 200)
|
|
|
|
def test_masquage_http(self):
|
|
tid = self.f.creer_sujet(self.u["adherent"], RECAP, "S45", "Texte")
|
|
pid = self.f.repondre(self.u["membre"], tid, "contenu-douteux")
|
|
r, _ = self.req("POST", "/masquer", "m1", {"post": pid, "etat": "1"})
|
|
self.assertEqual(r.status, 403)
|
|
r, _ = self.req("POST", "/masquer", "mo1", {"post": pid, "etat": "1"})
|
|
self.assertEqual(r.status, 303)
|
|
self.assertNotIn("contenu-douteux", self.req("GET", "/t/%d" % tid)[1])
|
|
self.assertIn("contenu-douteux", self.req("GET", "/t/%d" % tid, "mo1")[1])
|
|
|
|
def test_login_test_cookie(self):
|
|
r, _ = self.req("GET", "/test-login?u=a1")
|
|
self.assertEqual(r.status, 303)
|
|
self.assertIn("HttpOnly", r.getheader("Set-Cookie"))
|
|
self.assertEqual(self.req("GET", "/test-login?u=../x")[0].status, 400)
|
|
self.assertEqual(self.req("GET", "/t/99999")[0].status, 404)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main(verbosity=2)
|