Fichiers
meteo-vercors/forum/tests/test_forum.py
T
Théo GastineletClaude Opus 5.5 617ca808a2 Forum : menu Sujets/Stations/Se connecter retiré, bouton « Retour » dans le chemin du sujet
Demande de Théo. Connecté : le pseudo mène au compte, le menu ne garde que
Mon compte, Adhésion et les liens de gestion selon le rôle. Le bouton Retour
renvoie à la page précédente du forum (même site), sinon à la liste. 70 tests OK.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 23:15:35 +01:00

1021 lignes
53 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, urlparse
ICI = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
sys.path.insert(0, ICI)
import connexion # 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 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_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)
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_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/nouveau'", b)
self.assertIn("href='/forum/'", b)
self.assertNotIn("href='/'", b)
self.assertNotIn("action='/sujet'", b)
formulaire = self.req("/forum/nouveau", "a1")[2].decode()
self.assertIn("action='/forum/sujet'", 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/"))
self.assertIn("Path=/forum;", h["Set-Cookie"])
st, _, b = self.req("/forum/t/1")
self.assertEqual(st, 200)
self.assertIn("href='/forum/'", b.decode())
def test_connexion_cookies_et_retour(self):
st, h, _ = self.req("/forum/connexion/gastinel")
self.assertEqual(st, 303)
self.assertIn("Path=/forum;", [c for c in h.get_all("Set-Cookie") if c.startswith("forum_etat=")][0])
def test_defaut_et_validation(self):
self.assertEqual(connexion.Reglages(prefixe="forum/").prefixe, "/forum")
self.assertEqual(connexion.Reglages(prefixe="/forum", ).redirect_uri, "https://vercors.me/forum/connexion/retour")
self.assertEqual(connexion.Reglages().redirect_uri, "https://vercors.me/connexion/retour")
self.assertEqual(connexion.Reglages.depuis_env({"FORUM_PREFIXE": "/f"}).redirect_uri, "https://vercors.me/f/connexion/retour")
with self.assertRaises(ValueError):
connexion.Reglages(prefixe="/a'b")
class TestPanneau(BaseHTTP):
"""Panneau LAN : second serveur sur la même base, cookie panneau_session, CSRF, propriétaires seulement."""
def setUp(self):
super().setUp()
self.pan = panneau.creer_serveur(self.f, 0, reglages=connexion.Reglages(
hub_url=self.reglages.hub_url, redirect_uri="http://127.0.0.1:1/connexion/retour"))
self.pport = self.pan.server_address[1]
threading.Thread(target=self.pan.serve_forever, daemon=True).start()
self.psess = {}
def tearDown(self):
self.pan.shutdown()
self.pan.server_close()
super().tearDown()
def preq(self, chemin, qui=None, corps=None, csrf=True, entetes=None, cookie=None):
h = dict(entetes or {})
if qui:
if qui not in self.psess:
self.psess[qui] = self.f.ouvrir_session(self.f.utilisateur(qui), 1, panneau.PORTEE)
h["Cookie"] = "panneau_session=" + self.psess[qui]
if cookie:
h["Cookie"] = cookie
if corps is not None:
h["Content-Type"] = "application/x-www-form-urlencoded"
h["Origin"] = "http://127.0.0.1:%d" % self.pport
if csrf and qui:
corps = corps + "&csrf=" + self.csrf(qui)
corps = corps.encode()
c = http.client.HTTPConnection("127.0.0.1", self.pport, timeout=10)
c.request("POST" if corps is not None else "GET", chemin, body=corps, headers=h)
r = c.getresponse()
return r.status, r.headers, r.read()
def csrf(self, qui):
b = self.preq("/", qui)[2].decode()
return b.split("name='csrf' value='")[1].split("'")[0]
def test_refus_hors_lan(self):
for ip in ("8.8.8.8", "172.16.0.5", "2001:db8::1", "192.169.0.1", "11.0.0.1"):
self.assertFalse(connexion.est_locale(ip), ip)
for ip in ("127.0.0.1", "10.1.2.3", "192.168.1.20", "::1"):
self.assertTrue(connexion.est_locale(ip), ip)
h = self.pan.RequestHandlerClass
h.ip = lambda self: "203.0.113.9" # connexion venue d'Internet
try:
self.assertEqual(self.preq("/")[0], 403)
self.assertEqual(self.preq("/utilisateurs", "theo")[0], 403)
self.assertEqual(self.preq("/role", "theo", "hub_id=m1&role=adherent&action=donner", csrf=False)[0], 403)
finally:
del h.ip
self.assertEqual(self.preq("/")[0], 200)
def test_x_forwarded_for_ignore(self):
h = self.pan.RequestHandlerClass
h.ip = lambda self: "203.0.113.9"
try:
self.assertEqual(self.preq("/", entetes={"X-Forwarded-For": "192.168.1.5"})[0], 403) # pas cru
finally:
del h.ip
self.assertEqual(self.preq("/", entetes={"X-Forwarded-For": "8.8.8.8"})[0], 200) # ne retire pas l'accès LAN
def test_refus_non_proprietaire(self):
self.assertEqual(self.preq("/")[0], 200) # page de connexion
self.assertEqual(self.preq("/utilisateurs")[0], 403) # visiteur
for qui in ("m1", "a1", "mo1", "s1"):
for chemin in ("/utilisateurs", "/adhesions", "/stations", "/signalements"):
self.assertEqual(self.preq(chemin, qui)[0], 403, (qui, chemin))
self.assertEqual(self.preq("/role", "m1", "hub_id=m1&role=adherent&action=donner")[0], 403)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
# le cookie du forum ne vaut rien dans le panneau
jeton = self.f.ouvrir_session(self.theo)
self.assertEqual(self.preq("/utilisateurs", cookie="panneau_session=" + jeton)[0], 403)
self.assertEqual(self.preq("/utilisateurs", "theo")[0], 200)
self.assertEqual(self.preq("/utilisateurs", "pere")[0], 200)
def test_csrf_obligatoire(self):
corps = "hub_id=m1&role=adherent&action=donner"
self.assertEqual(self.preq("/role", "theo", corps, csrf=False)[0], 403)
self.assertEqual(self.preq("/role", "theo", corps + "&csrf=faux", csrf=False)[0], 403)
autre = self.csrf("pere") # jeton d'une autre session
self.assertEqual(self.preq("/role", "theo", corps + "&csrf=" + autre, csrf=False)[0], 403)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
st, h, _ = self.preq("/role", "theo", corps)
self.assertEqual((st, h["Location"]), (303, "/utilisateurs"))
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
def test_liste_utilisateurs_et_badges(self):
b = self.preq("/utilisateurs", "theo")[2].decode()
for nom in ("Marie", "Alex", "Richard", "Sam"):
self.assertIn(nom, b)
self.assertIn("aria-label='Propriétaire adjoint'", b)
self.assertIn("Propriétaire de station · Gêve", b)
self.assertNotIn("<script", b)
def test_filtre_et_retrait_cible_dans_le_panneau(self):
b = self.preq("/utilisateurs?q=s1", "theo")[2].decode()
self.assertIn("href='/utilisateurs' aria-current='page'", b)
self.assertIn("Sam", b)
self.assertNotIn("Marie", b)
self.assertIn("<summary>Gérer les rôles</summary>", b)
self.assertIn("<summary>Retirer Station · Gêve…</summary>", b)
self.assertIn("name='station' value='geve'", b)
self.assertIn("Confirmer le retrait", b)
self.assertIn("Aucun compte trouvé", self.preq("/utilisateurs?q=inconnu", "theo")[2].decode())
def test_don_de_role_respecte_peut_donner(self):
base = "hub_id=m1&station="
# l'adjoint donne adhérent, mais pas adjoint ; personne ne donne propriétaire
self.assertEqual(self.preq("/role", "pere", base + "&role=adherent&action=donner")[0], 303)
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "pere", base + "&role=proprietaire_adjoint&action=donner")[0], 403)
self.assertEqual(self.preq("/role", "theo", base + "&role=proprietaire&action=donner")[0], 403)
self.assertNotIn(roles.ADJOINT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "theo", base + "&role=proprietaire_adjoint&action=donner")[0], 303)
self.assertIn(roles.ADJOINT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "theo", base + "geve&role=proprietaire_station&action=donner")[0], 303)
self.assertEqual(self.f.stations_de(self.membre), {"geve"})
self.assertEqual(self.preq("/role", "theo", base + "&role=adherent&action=retirer")[0], 303)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/role", "theo", "hub_id=inconnu&role=adherent&action=donner")[0], 400)
# l'adjoint ne voit pas l'option « adjoint » dans son formulaire
self.assertNotIn("value='proprietaire_adjoint'", self.preq("/utilisateurs", "pere")[2].decode())
self.assertIn("value='proprietaire_adjoint'", self.preq("/utilisateurs", "theo")[2].decode())
def test_decision_adhesion(self):
d = self.f.demander_adhesion(self.membre, "Station à Lans", [("n.png", png())])
b = self.preq("/adhesions", "theo")[2].decode()
self.assertIn("Station à Lans", b)
nom = b.split("/adhesion-photo/")[1].split("'")[0]
st, h, img = self.preq("/adhesion-photo/" + nom, "pere")
self.assertEqual((st, h["Content-Type"]), (200, "image/png"))
self.assertNotIn(b"GPS", img)
self.assertEqual(self.preq("/adhesion-photo/" + nom, "m1")[0], 403)
self.assertEqual(self.preq("/adhesion-photo/" + nom)[0], 403)
self.assertEqual(self.preq("/adhesion/decider", "mo1", "demande=%d&ok=1" % d)[0], 403)
self.assertNotIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertEqual(self.preq("/adhesion/decider", "pere", "demande=%d&ok=1" % d)[0], 303)
self.assertIn(roles.ADHERENT, self.f.roles_de(self.membre))
self.assertIn("Aucune demande", self.preq("/adhesions", "theo")[2].decode())
d2 = self.f.demander_adhesion(self.modo, "Je modère déjà")
self.assertEqual(self.preq("/adhesion/decider", "theo", "demande=%d&ok=0" % d2)[0], 303)
self.assertEqual(self.f.ma_demande_adhesion(self.modo)["status"], "refusee")
def test_stations_et_signalements(self):
t = self.f.creer_sujet_station(self.prop, "geve", "Ma station au col")
b = self.preq("/stations", "theo")[2].decode()
self.assertIn("Ma station au col", b)
self.assertEqual(self.preq("/valider", "theo", "sujet=%d&ok=1" % t)[0], 303)
self.assertEqual(self.f.sujet(None, t)[0]["status"], "publie")
p = self.f.repondre(self.adh, self.f.creer_sujet(self.adh, "Neige", "x"), "message douteux")
self.f.signaler(self.membre, p, "Insultes")
b = self.preq("/signalements", "pere")[2].decode()
self.assertIn("Insultes", b)
self.assertIn("message douteux", b)
def test_echappement_et_en_tetes(self):
self.f.utilisateur("x1", "<script>alert(1)</script>")
st, h, b = self.preq("/utilisateurs", "theo")
self.assertNotIn("<script>alert", b.decode())
self.assertIn("&lt;script&gt;", b.decode())
self.assertIn("default-src 'none'", h["Content-Security-Policy"])
self.assertEqual(h["Cache-Control"], "private, no-store")
def test_connexion_gastinel_propre_au_panneau(self):
redir = "http://127.0.0.1:1/connexion/retour"
st, h, _ = self.preq("/connexion/gastinel")
self.assertEqual(st, 303)
q = {k: v[0] for k, v in parse_qs(urlparse(h["Location"]).query).items()}
self.assertEqual(q["redirect_uri"], redir) # adresse de retour distincte
etat = [c for c in h.get_all("Set-Cookie") if c.startswith("panneau_etat=")][0]
self.assertNotIn("Secure", etat) # panneau en http sur le LAN
self.hub.RequestHandlerClass.codes["c1"] = (q["code_challenge"], "forum-vercors", redir, {"id": "pere", "pseudo": "Richard"})
st, h, _ = self.preq("/connexion/retour?code=c1&state=" + q["state"], cookie="panneau_etat=" + q["state"])
self.assertEqual(st, 303)
cookie = [c for c in h.get_all("Set-Cookie") if c.startswith("panneau_session=") and "Max-Age=0" not in c][0]
jeton = cookie.split(";")[0].split("=", 1)[1]
self.assertEqual(self.preq("/utilisateurs", cookie="panneau_session=" + jeton)[0], 200)
# un simple membre Gastinel (ou un inconnu) ne passe pas, et aucun compte n'est créé
for hub_id in ("m1", "inconnu"):
st, h, _ = self.preq("/connexion/gastinel")
q = {k: v[0] for k, v in parse_qs(urlparse(h["Location"]).query).items()}
self.hub.RequestHandlerClass.codes["c2"] = (q["code_challenge"], "forum-vercors", redir, {"id": hub_id, "pseudo": "X"})
st, h, _ = self.preq("/connexion/retour?code=c2&state=" + q["state"], cookie="panneau_etat=" + q["state"])
self.assertEqual(st, 403)
self.assertFalse([c for c in h.get_all("Set-Cookie") if c.startswith("panneau_session=") and "Max-Age=0" not in c])
self.assertIsNone(self.f.utilisateur_existant("inconnu"))
def test_deconnexion(self):
self.assertEqual(self.preq("/deconnexion", "theo", "")[0], 303)
self.assertEqual(self.preq("/utilisateurs", "theo")[0], 403)
if __name__ == "__main__":
unittest.main()