Séparation du moteur dans la partie métier (instance 03, spec M1-M6, option B) : - jeu/static/jeu/moteur.js : le moteur du jeu — règles (pistes, registres, grades), progression, persistance (fusion anti-recul, sauvegarde /api/etat/) et verdicts purs des mini-jeux (verdictChoix, verdictChaine, partagés par les pistes et la résolution) — décide sans jamais toucher au DOM, testable hors navigateur ; - index.html garde le dessin : écrans, style, polices incrustées, câblage des clics ; les handlers lisent les verdicts puis rendent ; - mode « fichier unique hors ligne » retiré (jamais un objectif) : le jeu n'existe que sur le site, branché sur l'injection Django (window.MOTS, window.ETAT) et sur ui.js ; - cache-busteur aligné ?v=0.04 sur ui.css, ui.js et moteur.js ; - 33e test : la page sert le moteur séparé, sans accès au DOM ; - README ajusté (rôles moteur/page, « Ce que le site apporte au jeu », 33 tests) ; docstring de la vue mise au ton. Comportement de jeu inchangé : 33 tests OK, moteur exécuté hors navigateur (harnais node), parcours complet vérifié dans un navigateur réel (pistes, résolution, thème, remise à zéro).
396 lines
17 KiB
Python
Executable file
396 lines
17 KiB
Python
Executable file
"""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])
|
||
|
||
|
||
def test_la_page_charge_le_moteur_separe(self):
|
||
self.client.force_login(self.user)
|
||
r = self.client.get("/")
|
||
self.assertContains(r, "/static/jeu/moteur.js?v=0.04")
|
||
# le moteur est bien séparé : il décide, il ne dessine pas
|
||
source = (Path(__file__).resolve().parent / "static" / "jeu" / "moteur.js").read_text(encoding="utf-8")
|
||
self.assertIn("function verdictChaine", source)
|
||
self.assertIn("function verdictChoix", source)
|
||
self.assertNotIn("document.", source)
|
||
self.assertNotIn("innerHTML", source)
|
||
|
||
|
||
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)
|