834 lignes
43 KiB
Python
834 lignes
43 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, 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 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_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 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 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("action='/forum/sujet'", b)
|
|
self.assertIn("href='/forum/'", b)
|
|
self.assertNotIn("href='/'", b)
|
|
self.assertNotIn("action='/sujet'", b)
|
|
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_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)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|