VocabulAyr/jeu/tests.py
VocabulAyr 05335d39a6 VocabulAyr 0.03
Menu utilisateur du rail identique au mobile (Mon avatar, Paramètres, Admin, Déconnexion) ; titre du site masqué sur téléphone/tablette.
Fragment réutilisable _image_upload.html pour le fond (Paramètres) et l'avatar, à la façon BibliothequAyr ; nouvelle route POST /api/fond/ (admin, Pillow, plafond 5 Mo) ; retrait du fond via BoiteDialog.
Icônes SVG du site à la place des Bootstrap Icons jamais chargées ; les 9 favicons voyagent dans le projet.
Aucune migration ; moteur, anti-régression et journal intacts.
2026-11-08 15:32:06 +00:00

384 lines
17 KiB
Python
Executable file
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""Tests de VocabulAyr : site fermé, première installation, progression en base."""
import io
import json
import shutil
import tempfile
from pathlib import Path
from django.contrib.auth.models import User
from django.core.files.base import ContentFile
from django.core.files.uploadedfile import SimpleUploadedFile
from django.core.management import call_command
from django.test import Client, TestCase, override_settings
from jeu.controle import verifier_base
from jeu.models import Mot, Progression, SiteConfig
REPCAT = Path(__file__).resolve().parent / "catalogue"
class SiteFermeTests(TestCase):
def test_accueil_redirige_vers_connexion(self):
r = self.client.get("/")
self.assertEqual(r.status_code, 302)
self.assertTrue(r.url.startswith("/login/"))
def test_historique_redirige_vers_connexion(self):
r = self.client.get("/historique/")
self.assertEqual(r.status_code, 302)
def test_api_etat_refuse_sans_compte(self):
r = self.client.post("/api/etat/", data='{"data":{}}', content_type="application/json")
self.assertEqual(r.status_code, 401)
class PremiereInstallationTests(TestCase):
def test_ecran_de_premiere_installation(self):
r = self.client.get("/login/")
self.assertEqual(r.status_code, 200)
self.assertContains(r, "Première installation")
self.assertContains(r, "Créer le compte administrateur")
def test_creation_du_compte_admin(self):
r = self.client.post("/login/", {
"username": "Ayr", "password1": "motsdepasse", "password2": "motsdepasse",
})
self.assertRedirects(r, "/", fetch_redirect_response=False)
self.assertTrue(User.objects.filter(username="Ayr", is_superuser=True).exists())
self.assertTrue(SiteConfig.objects.filter(pk=1).exists())
def test_apres_installation_lecran_devient_connexion(self):
User.objects.create_superuser("Ayr", "", "motsdepasse")
r = self.client.get("/login/")
self.assertEqual(r.status_code, 200)
self.assertNotContains(r, "Créer le compte administrateur")
self.assertContains(r, "Se connecter")
class JeuEtProgressionTests(TestCase):
def setUp(self):
self.user = User.objects.create_user("Elvire", password="clef1234")
self.client.force_login(self.user)
def test_page_jeu_sert_etat_et_menu(self):
r = self.client.get("/")
self.assertEqual(r.status_code, 200)
self.assertContains(r, "Le Fil des Mots")
self.assertContains(r, "window.MOTS=")
self.assertContains(r, "window.ETAT=")
self.assertContains(r, 'class="sidebar"')
self.assertContains(r, 'class="entete"')
self.assertContains(r, "Historique")
def test_sauvegarde_et_relecture_de_la_progression(self):
data = {"_g": {"idx": 1, "theme": "dark"},
"pyjama": {"p": {"sens": 1}, "solved": 1, "badge": "improvisée"}}
r = self.client.post("/api/etat/", data=json.dumps({"data": data}),
content_type="application/json")
self.assertEqual(r.status_code, 200)
self.assertEqual(Progression.load(self.user).data, data)
# l'état est de retour dans la page du jeu
r = self.client.get("/")
self.assertContains(r, '"solved": 1')
def test_api_etat_refuse_non_dict(self):
r = self.client.post("/api/etat/", data='{"data":"x"}', content_type="application/json")
self.assertEqual(r.status_code, 400)
def test_reinitialisation(self):
Progression.load(self.user).data = {"pyjama": {"solved": 1}}
r = self.client.post("/api/reinitialiser/")
self.assertEqual(r.status_code, 200)
self.assertEqual(Progression.load(self.user).data, {})
def test_historique_affiche_les_mots_en_poche(self):
data = {"pyjama": {"p": {"sens": 1}, "solved": 1, "badge": "parfaite"}}
self.client.post("/api/etat/", data=json.dumps({"data": data}),
content_type="application/json")
r = self.client.get("/historique/")
self.assertEqual(r.status_code, 200)
self.assertContains(r, "voca-donnees")
def _png_minuscule():
"""Une vraie image PNG de 4×4 pixels, pour tester l'envoi du fond."""
from PIL import Image
tampon = io.BytesIO()
Image.new("RGB", (4, 4), (178, 60, 42)).save(tampon, format="PNG")
return tampon.getvalue()
_REP_MEDIA_TESTS = tempfile.mkdtemp(prefix="vocabulayr-tests-media-")
@override_settings(MEDIA_ROOT=_REP_MEDIA_TESTS)
class ParametresTests(TestCase):
@classmethod
def tearDownClass(cls):
super().tearDownClass()
shutil.rmtree(_REP_MEDIA_TESTS, ignore_errors=True)
def setUp(self):
self.admin = User.objects.create_superuser("Ayr", "", "motsdepasse")
self.joueur = User.objects.create_user("Elvire", password="clef1234")
def test_page_reservee_a_l_administrateur(self):
self.client.force_login(self.joueur)
r = self.client.get("/parametres/")
self.assertRedirects(r, "/", fetch_redirect_response=False)
self.client.force_login(self.admin)
r = self.client.get("/parametres/")
self.assertEqual(r.status_code, 200)
self.assertContains(r, "Titre du site")
self.assertContains(r, "Image de fond")
def test_menu_parametres_visible_par_l_admin_seulement(self):
self.client.force_login(self.admin)
self.assertContains(self.client.get("/"), "/parametres/")
self.client.force_login(self.joueur)
self.assertNotContains(self.client.get("/"), "/parametres/")
def test_changer_le_titre_du_site(self):
self.client.force_login(self.admin)
r = self.client.post("/parametres/", {"action": "nom", "site_name": "Mots et Merveilles"})
self.assertRedirects(r, "/parametres/")
self.assertEqual(SiteConfig.load().site_name, "Mots et Merveilles")
# le nouveau titre apparaît sur la page de connexion et dans le menu
self.assertContains(self.client.get("/login/"), "Mots et Merveilles")
self.assertContains(self.client.get("/"), "Mots et Merveilles")
def test_installer_puis_retirer_le_fond(self):
self.client.force_login(self.admin)
image = SimpleUploadedFile("fond.png", _png_minuscule(), content_type="image/png")
r = self.client.post("/api/fond/", {"image": image})
self.assertEqual(r.status_code, 200)
self.assertEqual(r.json()["status"], "ok")
cfg = SiteConfig.load()
self.assertTrue(cfg.background_image, "l'image doit être enregistrée")
# la page de connexion utilise l'image
login = self.client.get("/login/")
self.assertContains(login, cfg.background_image.url)
# le fragment est en place sur la page des Paramètres
self.assertContains(self.client.get("/parametres/"), cfg.background_image.url)
# rejet d'un fichier qui n'est pas une image
faux = SimpleUploadedFile("faux.png", b"pas une image", content_type="image/png")
r = self.client.post("/api/fond/", {"image": faux})
self.assertEqual(r.status_code, 400)
self.assertEqual(r.json()["status"], "pas_image")
# retrait (après confirmation côté client)
url_image = cfg.background_image.url
r = self.client.post("/api/fond/", {"action": "retirer"})
self.assertEqual(r.status_code, 200)
self.assertFalse(SiteConfig.load().background_image)
self.assertNotContains(self.client.get("/login/"), url_image)
def test_api_fond_refusee_aux_autres_comptes(self):
self.client.force_login(self.joueur)
r = self.client.post("/api/fond/", {"action": "retirer"})
self.assertEqual(r.status_code, 403)
image = SimpleUploadedFile("fond.png", _png_minuscule(), content_type="image/png")
r = self.client.post("/api/fond/", {"image": image})
self.assertEqual(r.status_code, 403)
self.assertFalse(SiteConfig.load().background_image)
@override_settings(MEDIA_ROOT=_REP_MEDIA_TESTS)
class FragmentImageTests(TestCase):
"""Le gabarit commun de chargement d'image (calque BibliothequAyr) :
présent pour l'avatar et pour le fond, le menu utilisateur identique
sur le rail et l'entête, et les favicons embarqués dans le projet."""
FAVICONS = [
"favicon-16x16.png", "favicon-32x32.png", "favicon-48x48.png",
"favicon-64x64.png", "favicon-128x128.png", "favicon-256x256.png",
"apple-touch-icon.png", "android-chrome-192x192.png",
"android-chrome-512x512.png",
]
@classmethod
def setUpTestData(cls):
cls.admin = User.objects.create_superuser("Ayr", "", "motsdepasse")
cls.joueur = User.objects.create_user("Elvire", password="clef1234")
def test_le_gabarit_est_present_partout(self):
self.client.force_login(self.joueur)
# page du jeu : le gabarit caché de l'avatar
jeu = self.client.get("/")
self.assertContains(jeu, 'template class="tpl-zi"')
self.assertContains(jeu, 'class="zi"')
# pages du site : le gabarit caché + les composants partagés
hist = self.client.get("/historique/")
self.assertEqual(hist.status_code, 200)
self.assertContains(hist, "tpl-zi")
self.assertContains(hist, "menu.css")
self.assertContains(hist, "ui.js")
# Paramètres : le fragment du fond, branché sur /api/fond/
self.client.force_login(self.admin)
param = self.client.get("/parametres/")
self.assertContains(param, "/api/fond/")
self.assertContains(param, "Choisir une image")
def test_menu_utilisateur_identique_rail_et_entete(self):
self.client.force_login(self.admin)
page = self.client.get("/").content.decode("utf-8")
# le même bloc utilisateur est rendu deux fois : rail + entête
self.assertEqual(page.count('class="menu-item menu-utilisateur"'), 2)
# contenu validé : Mon avatar, Paramètres et Admin (admin), Déconnexion
self.assertEqual(page.count("Mon avatar"), 2)
self.assertEqual(page.count(">Déconnexion<"), 2)
self.assertEqual(page.count(">Paramètres<"), 2)
self.assertEqual(page.count(">Admin<"), 2)
# l'ancien bouton Déconnexion nu du rail a disparu
self.assertNotIn('nav-item" type="submit"', page)
def test_sous_menu_du_simple_joueur(self):
self.client.force_login(self.joueur)
page = self.client.get("/").content.decode("utf-8")
self.assertEqual(page.count("Mon avatar"), 2)
self.assertNotIn(">Paramètres<", page)
self.assertNotIn(">Admin<", page)
def test_favicons_embarques_et_declares(self):
rep = Path(__file__).resolve().parent / "static" / "jeu" / "favicons"
for nom in self.FAVICONS:
self.assertTrue((rep / nom).exists(), f"favicon manquant : {nom}")
self.client.force_login(self.joueur)
page = self.client.get("/").content.decode("utf-8")
for nom in self.FAVICONS:
self.assertIn(nom, page)
def test_avatar_dans_la_pastille(self):
from jeu.models import Profil
profil, _ = Profil.objects.get_or_create(user=self.joueur)
profil.avatar.save("avatar-essai.png", ContentFile(_png_minuscule()), save=True)
self.client.force_login(self.joueur)
page = self.client.get("/").content.decode("utf-8")
self.assertIn(profil.avatar.url, page)
class CatalogueMotsTests(TestCase):
"""Le savoir en base : import du catalogue, structure, Historique."""
@classmethod
def setUpTestData(cls):
call_command("importer_mots", verbosity=0)
def test_105_mots_en_base_et_structure_impeccable(self):
nb, erreurs = verifier_base()
self.assertEqual(nb, 105)
self.assertEqual(erreurs, [])
def test_export_identique_au_catalogue(self):
catalogue = json.loads((REPCAT / "mots-complet.json").read_text(encoding="utf-8"))
exporte = [m.vers_donnees(True) for m in Mot.objects.order_by("ordre")]
self.assertEqual(exporte, catalogue)
def test_registre_ternaire_sans_echelle(self):
reponses = set()
for m in Mot.objects.all():
steps = m.pistes["registre"]["steps"]
self.assertEqual(steps[0]["type"], "registre")
self.assertEqual(steps[0]["prompt"], "Dans quel registre s'inscrit le mot ?")
self.assertTrue(steps[0]["pourquoi"])
reponses.add(steps[0]["reponse"])
self.assertEqual(reponses, {"soutenu", "commun", "populaire"})
def test_l_historique_lit_la_base(self):
user = User.objects.create_user("Elvire", password="clef1234")
client = Client()
client.force_login(user)
r = client.get("/historique/")
self.assertEqual(r.status_code, 200)
self.assertContains(r, "Pyjama")
class PageJeuAvecMotsTests(TestCase):
"""La page du jeu reçoit le savoir complet par window.MOTS."""
@classmethod
def setUpTestData(cls):
call_command("importer_mots", verbosity=0)
cls.user = User.objects.create_user("Elvire", password="clef1234")
def test_la_page_du_jeu_recoit_les_105_mots(self):
self.client.force_login(self.user)
r = self.client.get("/")
self.assertEqual(r.status_code, 200)
corps = r.content.decode("utf-8")
self.assertIn("window.MOTS=", corps)
i = corps.index("window.MOTS=") + len("window.MOTS=")
fin = corps.index(";window.ETAT=", i) # les textes des mots contiennent des « ; »
mots = json.loads(corps[i:fin].replace("<\\/", "</"))
self.assertEqual(len(mots), 105)
self.assertEqual(mots[0]["id"], "pyjama")
self.assertIn("pistes", mots[0])
self.assertIn("resolve", mots[0])
class AjouterMotTests(TestCase):
"""Le script d'ajout : création, insertion, refus, mise à jour, export."""
@classmethod
def setUpTestData(cls):
call_command("importer_mots", verbosity=0)
def _mot_essai(self, slug="mot-essai", titre="Mot d'essai"):
source = Mot.objects.get(slug="pyjama").vers_donnees(True)
source["id"] = slug
source["title"] = titre
return source
def _fichier(self, donnees, nom="mot.json"):
tmp = tempfile.TemporaryDirectory()
self.addClassCleanup(tmp.cleanup)
f = Path(tmp.name) / nom
f.write_text(json.dumps(donnees, ensure_ascii=False), encoding="utf-8")
return str(f)
def test_ajout_a_la_suite(self):
call_command("ajouter_mot", self._fichier(self._mot_essai()), verbosity=0)
self.assertEqual(Mot.objects.count(), 106)
self.assertEqual(Mot.objects.order_by("-ordre").first().slug, "mot-essai")
nb, erreurs = verifier_base()
self.assertEqual(erreurs, [])
def test_ajout_avec_glissement_des_suivants(self):
call_command("ajouter_mot", self._fichier(self._mot_essai()), "--ordre", "3", verbosity=0)
self.assertEqual(Mot.objects.get(slug="mot-essai").ordre, 3)
self.assertEqual(Mot.objects.get(slug="pataugeoire").ordre, 4)
nb, erreurs = verifier_base()
self.assertEqual(erreurs, [])
def test_refus_d_un_mot_invalide_rien_n_est_ecrit(self):
mauvais = self._mot_essai()
mauvais["pistes"]["registre"]["steps"][0]["reponse"] = "moyen"
with self.assertRaises(SystemExit):
call_command("ajouter_mot", self._fichier(mauvais), verbosity=0)
self.assertEqual(Mot.objects.count(), 105)
def test_refus_d_une_echelle_slider(self):
vieux = self._mot_essai()
vieux["pistes"]["registre"]["steps"][0] = {
"type": "slider", "left": "soutenu", "right": "familier", "target": 3,
"note": "n", "hint": "h",
}
with self.assertRaises(SystemExit):
call_command("ajouter_mot", self._fichier(vieux), verbosity=0)
self.assertEqual(Mot.objects.count(), 105)
def test_mise_a_jour_d_un_mot_existant(self):
modifie = Mot.objects.get(slug="pyjama").vers_donnees(True)
modifie["teaser"] = "Nouvelle accroche d'essai."
call_command("ajouter_mot", self._fichier(modifie), verbosity=0)
self.assertEqual(Mot.objects.count(), 105)
self.assertEqual(Mot.objects.get(slug="pyjama").accroche, "Nouvelle accroche d'essai.")
def test_export_puis_reimport_sans_perte(self):
tmp = tempfile.TemporaryDirectory()
self.addClassCleanup(tmp.cleanup)
f = str(Path(tmp.name) / "export.json")
call_command("exporter_mots", "--fichier", f, verbosity=0)
avant = [m.vers_donnees(True) for m in Mot.objects.order_by("ordre")]
call_command("importer_mots", "--fichier", f, "--vider", verbosity=0)
apres = [m.vers_donnees(True) for m in Mot.objects.order_by("ordre")]
self.assertEqual(avant, apres)