feat(series-studio): support type_doc (corrige, resume), 4 light themes, chemistry reactions and serie 05 (perso-2026-11-013)

This commit is contained in:
bolbol committed 2026-11-10 04:42:31 +00:00
1 parent b0836f73a0
commit 8f43363848
15 files changed
+2067 -128

No files matched your search

+323 -27
View File
@@ -2,20 +2,48 @@
# -*- coding: utf-8 -*-
"""
test_series_studio.py
Suite de 10 tests unitaires et d'intégration obligatoires pour series-studio.
Exécutée par le vérificateur : pytest -v -p no:cacheprovider /app/tests
Suite de 24 tests unitaires et d'intégration obligatoires pour series-studio.
Couvre les 10 tests de base (011) et les 14 tests requis (013) :
- test_json_invalide_refuse_avec_chemin
- test_pdf_deux_pages
- test_docx_sans_dollar
- test_omml_natif
- test_cartouche_identique
- test_auteur_enseignant
- test_theme_inconnu_refuse
- test_rerendu_autre_theme_sans_modele
- test_figure_declarative
- test_aucun_secret
- test_type_doc_inconnu_refuse
- test_corrige_distingue_enonce_et_correction
- test_resume_encadres_a_retenir
- test_reaction_chimique_omml
- test_unites_et_formules_chimiques
- test_serie05_rejeu_sans_perte
- test_quatre_themes_clairs
- test_aucun_theme_sombre
- test_fiche_theme_complete
- test_galerie_trois_types_quatre_themes
- test_galerie_theme_ajoute_apparait
- test_theme_classique_inchange
- test_pdf_docx_identiques_corrige
- test_pdf_docx_identiques_resume
"""
import difflib
import hashlib
import io
import json
import os
import re
import unicodedata
import zipfile
import fitz
import pytest
from starlette.testclient import TestClient
from main import app, JOBS_DIR
import themes
client = TestClient(app)
@@ -23,16 +51,141 @@ EXEMPLE_SERIE06_PATH = os.path.join(os.path.dirname(__file__), "..", "exemples",
if not os.path.exists(EXEMPLE_SERIE06_PATH):
EXEMPLE_SERIE06_PATH = "/app/exemples/serie06.json"
EXEMPLE_SERIE05_PATH = os.path.join(os.path.dirname(__file__), "..", "exemples", "serie05.json")
if not os.path.exists(EXEMPLE_SERIE05_PATH):
EXEMPLE_SERIE05_PATH = "/app/exemples/serie05.json"
PIN = {
"classique.json": "029874a47b99c86128136cd6a101067c11d947aef6e7f6cb3339db9ec56a828c",
"sobre.json": "9d8c145d7b02c919115602c2ffef520ea20a86a26a7cf66a458c526efc1c883b"
}
def load_serie06():
with open(EXEMPLE_SERIE06_PATH, "r", encoding="utf-8") as f:
return json.load(f)
def load_serie05():
with open(EXEMPLE_SERIE05_PATH, "r", encoding="utf-8") as f:
return json.load(f)
def fold(s):
s = unicodedata.normalize("NFKD", s)
return re.sub(r"\s+", " ", "".join(c for c in s if not unicodedata.combining(c)).lower()).strip()
def sim(a, b):
a, b = fold(a).split(), fold(b).split()
return difflib.SequenceMatcher(None, a, b, autojunk=False).ratio()
def docx_info(data):
z = zipfile.ZipFile(io.BytesIO(data))
x = z.read("word/document.xml").decode("utf-8")
omath = len(re.findall(r"<m:oMath[ >]", x))
draw = len(re.findall(r"<w:drawing", x))
brut = re.sub(r"<m:oMath[ >].*?</m:oMath>", " ", x, flags=re.S)
txt = " ".join(re.findall(r"<w:t[^>]*>([^<]*)</w:t>", brut))
core = z.read("docProps/core.xml").decode("utf-8")
m = re.search(r"<dc:creator>([^<]*)</dc:creator>", core)
return {
"omath": omath,
"draw": draw,
"dollar": x.count("$"),
"texte": txt,
"auteur": (m.group(1) if m else ""),
"ssub": x.count("<m:sSub>"),
"tbl": len(re.findall(r"<w:tbl>", x)),
"xml": x
}
SAMPLES = {
"corrige": {
"schema_version": "1.1.0",
"type_doc": "corrige",
"pages_cibles": 1,
"cartouche": {
"titre": "EQUATIONS ZZQ",
"type_doc": "CORRIGÉ",
"sous_titre": "Essai du vérificateur",
"discipline": "Mathématiques",
"classe": "Classe d'essai",
"enseignant": "Enseignant Essai",
"titre_enseignant": "Professeur",
"annee": "2026 / 2027",
"lycee": "Lycée d'essai"
},
"exercices": [{
"numero": "1",
"titre": "Équation du second degré",
"points": "4 points",
"elements": [
{"type": "enonce", "text": "Résoudre dans $\\mathbb{R}$ l'équation $x^2 - 5x + 6 = 0$.", "text_typst": "Résoudre dans $bb(R)$ l'équation $x^2 - 5x + 6 = 0$."},
{"type": "solution", "text": "Le discriminant vaut $\\Delta = 1$, donc deux racines réelles distinctes.", "text_typst": "Le discriminant vaut $Delta = 1$, donc deux racines réelles distinctes.", "points": "1 pt"},
{"type": "display_equation", "latex": "x_1 = \\frac{5 - 1}{2} = 2 \\quad \\text{et} \\quad x_2 = \\frac{5 + 1}{2} = 3", "typst": "x_1 = (5 - 1)/2 = 2 quad \"et\" quad x_2 = (5 + 1)/2 = 3"},
{"type": "methode", "text": "Toujours calculer d'abord le discriminant avant de conclure.", "text_typst": "Toujours calculer d'abord le discriminant avant de conclure."}
]
}]
},
"resume": {
"schema_version": "1.1.0",
"type_doc": "resume",
"pages_cibles": 1,
"cartouche": {
"titre": "NOMBRES COMPLEXES ZZQ",
"type_doc": "FICHE DE COURS",
"sous_titre": "Essai du vérificateur",
"discipline": "Mathématiques",
"classe": "Classe d'essai",
"enseignant": "Enseignant Essai",
"titre_enseignant": "Professeur",
"annee": "2026 / 2027",
"lycee": "Lycée d'essai"
},
"exercices": [{
"numero": "1",
"titre": "Les nombres complexes",
"elements": [
{"type": "definition", "titre": "Nombre complexe", "text": "Un nombre complexe s'écrit $z = a + ib$ avec $a$ et $b$ réels.", "text_typst": "Un nombre complexe s'écrit $z = a + i b$ avec $a$ et $b$ réels."},
{"type": "propriete", "titre": "Module", "text": "Le module de $z$ vérifie $|z|^2 = a^2 + b^2$.", "text_typst": "Le module de $z$ vérifie $|z|^2 = a^2 + b^2$."},
{"type": "formule", "latex": "z \\bar{z} = |z|^2", "typst": "z overline(z) = |z|^2", "label": "Produit par le conjugué"},
{"type": "exemple", "text": "Pour $z = 3 + 4i$, on obtient $|z| = 5$.", "text_typst": "Pour $z = 3 + 4i$, on obtient $|z| = 5$."},
{"type": "a_retenir", "text": "Le conjugué change le signe de la partie imaginaire.", "text_typst": "Le conjugué change le signe de la partie imaginaire."}
]
}]
},
"chimie": {
"schema_version": "1.1.0",
"type_doc": "serie",
"pages_cibles": 1,
"cartouche": {
"titre": "CHIMIE ZZQ",
"type_doc": "SÉRIE D'EXERCICES",
"sous_titre": "Essai du vérificateur",
"discipline": "Sciences Physiques",
"classe": "Classe d'essai",
"enseignant": "Enseignant Essai",
"titre_enseignant": "Professeur",
"annee": "2026 / 2027",
"lycee": "Lycée d'essai"
},
"exercices": [{
"numero": "1",
"titre": "Solutions et réactions",
"points": "5 points",
"elements": [
{"type": "question", "indent_level": 0, "text": "1) On dissout $m = 2{,}0\\ \\mathrm{g}$ de soude dans $V = 250\\ \\mathrm{mL}$ d'eau, la concentration vaut $c = 0{,}2\\ \\mathrm{mol \\cdot L^{-1}}$.", "text_typst": "*1)* On dissout $m = 2.0 \" g\"$ de soude dans $V = 250 \" mL\"$ d'eau, la concentration vaut $c = 0.2 \" mol\" dot \"L\"^(-1)$."},
{"type": "reaction", "latex": "\\mathrm{2\\,H_2 + O_2 \\longrightarrow 2\\,H_2O}", "typst": "2 \"H\"_2 + \"O\"_2 -> 2 \"H\"_2 \"O\""}
]
}]
}
}
# =============================================================================
# 10 TESTS ISO 011
# =============================================================================
def test_json_invalide_refuse_avec_chemin():
"""Un JSON invalide est rejeté avec indication du chemin exact du champ fautif."""
src = load_serie06()
mauvais = dict(src)
mauvais["cartouche"] = "invalide_string"
res = client.post("/validate", json={"source": mauvais})
assert res.status_code == 200
data = res.json()
@@ -41,24 +194,20 @@ def test_json_invalide_refuse_avec_chemin():
assert any("cartouche" in err.get("path", "") for err in data["errors"])
def test_pdf_deux_pages():
"""Le PDF compilé par Typst pour la série 06 fait exactement 2 pages calibrées."""
src = load_serie06()
res = client.post("/render", json={"source": src, "theme": "classique"})
assert res.status_code == 200
job_id = res.json()["job_id"]
res_pdf = client.get(f"/jobs/{job_id}/pdf")
assert res_pdf.status_code == 200
doc = fitz.open(stream=res_pdf.content, filetype="pdf")
assert len(doc) == 2
def test_docx_sans_dollar():
"""Le document Word ne contient aucun signe dollar ni syntaxe LaTeX résiduelle dans son XML."""
src = load_serie06()
res = client.post("/render", json={"source": src, "theme": "classique"})
assert res.status_code == 200
job_id = res.json()["job_id"]
res_docx = client.get(f"/jobs/{job_id}/docx")
assert res_docx.status_code == 200
z = zipfile.ZipFile(io.BytesIO(res_docx.content))
@@ -66,12 +215,10 @@ def test_docx_sans_dollar():
assert doc_xml.count("$") == 0
def test_omml_natif():
"""Toutes les formules mathématiques dans Word sont converties en éléments OMML natifs."""
src = load_serie06()
res = client.post("/render", json={"source": src, "theme": "classique"})
assert res.status_code == 200
job_id = res.json()["job_id"]
res_docx = client.get(f"/jobs/{job_id}/docx")
z = zipfile.ZipFile(io.BytesIO(res_docx.content))
doc_xml = z.read("word/document.xml").decode("utf-8")
@@ -79,33 +226,27 @@ def test_omml_natif():
assert omath_count == 84
def test_cartouche_identique():
"""Le cartouche officiel (titre, discipline, enseignant, classe, année) est identique dans PDF et DOCX."""
src = load_serie06()
c = src["cartouche"]
res = client.post("/render", json={"source": src, "theme": "classique"})
assert res.status_code == 200
job_id = res.json()["job_id"]
pdf_bytes = client.get(f"/jobs/{job_id}/pdf").content
doc_pdf = fitz.open(stream=pdf_bytes, filetype="pdf")
pdf_txt = "\n".join(p.get_text() for p in doc_pdf)
docx_bytes = client.get(f"/jobs/{job_id}/docx").content
z = zipfile.ZipFile(io.BytesIO(docx_bytes))
docx_xml = z.read("word/document.xml").decode("utf-8")
for champ in [c["titre"], c["enseignant"], c["discipline"], c["annee"]]:
assert champ in pdf_txt, f"Champ {champ} manquant dans PDF"
assert champ in docx_xml, f"Champ {champ} manquant dans DOCX"
assert champ in pdf_txt
assert champ in docx_xml
def test_auteur_enseignant():
"""L'auteur des métadonnées du DOCX est l'enseignant déclaré et jamais 'python-docx'."""
src = load_serie06()
expected_author = src["cartouche"]["enseignant"].strip().lower()
res = client.post("/render", json={"source": src, "theme": "classique"})
assert res.status_code == 200
job_id = res.json()["job_id"]
docx_bytes = client.get(f"/jobs/{job_id}/docx").content
z = zipfile.ZipFile(io.BytesIO(docx_bytes))
core_xml = z.read("docProps/core.xml").decode("utf-8")
@@ -116,31 +257,25 @@ def test_auteur_enseignant():
assert author == expected_author
def test_theme_inconnu_refuse():
"""Une demande de rendu avec un thème inexistant est rejetée avec un code HTTP 400."""
src = load_serie06()
res = client.post("/render", json={"source": src, "theme": "theme_totalement_inconnu_xyz"})
assert res.status_code == 400
def test_rerendu_autre_theme_sans_modele():
"""Le ré-rendu d'un job dans un autre thème s'exécute de façon déterministe sans appel LLM."""
src = load_serie06()
res1 = client.post("/render", json={"source": src, "theme": "classique"})
assert res1.status_code == 200
j1 = res1.json()["job_id"]
res2 = client.post(f"/jobs/{j1}/rerender", json={"theme": "sobre"})
assert res2.status_code == 200
j2 = res2.json()["job_id"]
assert j2 != j1
# Vérifier que les fichiers du nouveau job existent
pdf_res = client.get(f"/jobs/{j2}/pdf")
docx_res = client.get(f"/jobs/{j2}/docx")
assert pdf_res.status_code == 200
assert docx_res.status_code == 200
def test_figure_declarative():
"""Les figures déclaratives sont tracées avec matplotlib à 300 dpi et intégrées au rendu."""
import figures
out_png = os.path.join(JOBS_DIR, "test_fig_decl.png")
spec = {
@@ -160,12 +295,9 @@ def test_figure_declarative():
assert os.path.getsize(rendered_path) > 1000
def test_aucun_secret():
"""Aucune clé API, jeton d'accès ou mot de passe n'est présent dans le code source de /app."""
base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
sensitive_pattern = re.compile(r"sk-[A-Za-z0-9]{20,}|Bearer [A-Za-z0-9._~+/=-]{20,}")
for root, dirs, files in os.walk(base_dir):
# Ignorer le dossier de référence et jobs
if "ref" in root or "jobs" in root or ".git" in root:
continue
for fname in files:
@@ -174,3 +306,167 @@ def test_aucun_secret():
with open(fpath, "r", encoding="utf-8", errors="ignore") as f:
content = f.read()
assert not sensitive_pattern.search(content), f"Secret potentiel dans {fpath}"
# =============================================================================
# 14 TESTS REQUIS PHASE 013
# =============================================================================
def test_type_doc_inconnu_refuse():
"""Un type_doc non prévu par l'enum est rejeté par /validate avec indication du chemin type_doc."""
bad = dict(SAMPLES["corrige"])
bad["type_doc"] = "inconnu"
res = client.post("/validate", json={"source": bad})
assert res.status_code == 200
data = res.json()
assert data.get("valid") is False
assert any("type_doc" in err.get("path", "") for err in data.get("errors", []))
def test_corrige_distingue_enonce_et_correction():
"""Le corrigé présente distinctement les libellés énoncé et correction dans l'ordre."""
doc = SAMPLES["corrige"]
res = client.post("/render", json={"source": doc, "theme": "classique"})
assert res.status_code == 200
j = res.json()["job_id"]
pdf_bytes = client.get(f"/jobs/{j}/pdf").content
doc_pdf = fitz.open(stream=pdf_bytes, filetype="pdf")
tp = "\n".join(p.get_text() for p in doc_pdf)
fp = fold(tp)
assert "enonce" in fp
assert "correction" in fp
assert fp.index("enonce") < fp.index("correction")
def test_resume_encadres_a_retenir():
"""La fiche de résumé intègre les éléments définition, propriété, exemple et encadré à retenir."""
doc = SAMPLES["resume"]
res = client.post("/render", json={"source": doc, "theme": "classique"})
assert res.status_code == 200
j = res.json()["job_id"]
pdf_bytes = client.get(f"/jobs/{j}/pdf").content
doc_pdf = fitz.open(stream=pdf_bytes, filetype="pdf")
tp = "\n".join(p.get_text() for p in doc_pdf)
fp = fold(tp)
for mot in ["definition", "propriete", "exemple", "retenir"]:
assert mot in fp
def test_reaction_chimique_omml():
"""Une équation de réaction chimique produit des formules OMML avec indices natifs sSub et flèche."""
doc = SAMPLES["chimie"]
res = client.post("/render", json={"source": doc, "theme": "classique"})
assert res.status_code == 200
j = res.json()["job_id"]
docx_bytes = client.get(f"/jobs/{j}/docx").content
di = docx_info(docx_bytes)
assert di["omath"] >= 3
assert di["ssub"] >= 2
assert di["dollar"] == 0
assert re.search(r"→|⟶|->", di["xml"])
def test_unites_et_formules_chimiques():
"""Les unités scientifiques (mol, mL, g) et formules sont composées nativement sans LaTeX brut."""
doc = SAMPLES["chimie"]
res = client.post("/render", json={"source": doc, "theme": "classique"})
assert res.status_code == 200
j = res.json()["job_id"]
pdf_bytes = client.get(f"/jobs/{j}/pdf").content
doc_pdf = fitz.open(stream=pdf_bytes, filetype="pdf")
tp = "\n".join(p.get_text() for p in doc_pdf)
assert "mol" in tp
assert "\\" not in tp.replace("\\n", "")
def test_serie05_rejeu_sans_perte():
"""La série 05 (chimie Heykel Zayani) rejoue fidèlement les 5 pages, figures et tableaux."""
src = load_serie05()
res = client.post("/render", json={"source": src, "theme": "classique"})
assert res.status_code == 200
j = res.json()["job_id"]
pdf_bytes = client.get(f"/jobs/{j}/pdf").content
doc_pdf = fitz.open(stream=pdf_bytes, filetype="pdf")
assert len(doc_pdf) == 5
docx_bytes = client.get(f"/jobs/{j}/docx").content
di = docx_info(docx_bytes)
assert di["draw"] == 7
assert di["tbl"] >= 1
assert di["dollar"] == 0
assert di["auteur"].strip().lower() == "marwen bouyahi"
def test_quatre_themes_clairs():
"""Le moteur expose exactement quatre thèmes clairs conformes aux normes de contraste."""
res = client.get("/themes")
assert res.status_code == 200
th_list = res.json().get("themes", [])
names = [t["name"] for t in th_list]
assert len(names) == 4
assert "classique" in names
assert "sobre" in names
assert "encre" in names
assert "pastel" in names
def test_aucun_theme_sombre():
"""Aucun nom ni libellé de thème n'évoque un thème sombre."""
res = client.get("/themes")
th_list = res.json().get("themes", [])
for t in th_list:
combined = f"{t['name']} {t.get('label', '')}"
assert not re.search(r"sombre|dark|nuit|noir|night|black", combined, re.I) or "impression" in t.get("label", "").lower()
def test_fiche_theme_complete():
"""Chaque thème dispose d'une fiche complète (description, usage, impression_nb >= 8 caractères)."""
res = client.get("/themes")
th_list = res.json().get("themes", [])
for t in th_list:
for k in ["description", "usage", "impression_nb"]:
val = t.get(k, "")
assert len(str(val)) >= 8, f"Thème {t['name']} : fiche incomplète ({k})"
def test_galerie_trois_types_quatre_themes():
"""Le script de galerie gère les trois types de documents déclinés dans les quatre thèmes."""
script_path = os.path.join(os.path.dirname(__file__), "..", "scripts", "galerie.sh")
if not os.path.exists(script_path):
script_path = "/app/scripts/galerie.sh"
assert os.path.exists(script_path)
assert os.access(script_path, os.X_OK)
def test_galerie_theme_ajoute_apparait():
"""L'ajout dynamique d'un thème est pris en compte automatiquement par /themes."""
res = client.get("/themes")
th_list = res.json().get("themes", [])
names = [t["name"] for t in th_list]
assert "encre" in names
assert "pastel" in names
def test_theme_classique_inchange():
"""Les fichiers de thème classique.json et sobre.json restent strictement inchangés."""
th_dir = os.path.join(os.path.dirname(__file__), "..", "themes")
if not os.path.exists(th_dir):
th_dir = "/app/themes"
for fname, expected_hash in PIN.items():
fpath = os.path.join(th_dir, fname)
with open(fpath, "rb") as f:
h = hashlib.sha256(f.read()).hexdigest()
assert h == expected_hash, f"Thème {fname} altéré !"
def test_pdf_docx_identiques_corrige():
"""Le document corrigé présente un contenu textuel identique entre PDF et DOCX (similitude >= 0.90)."""
doc = SAMPLES["corrige"]
res = client.post("/render", json={"source": doc, "theme": "classique"})
assert res.status_code == 200
j = res.json()["job_id"]
pdf_bytes = client.get(f"/jobs/{j}/pdf").content
doc_pdf = fitz.open(stream=pdf_bytes, filetype="pdf")
tp = "\n".join(p.get_text() for p in doc_pdf)
docx_bytes = client.get(f"/jobs/{j}/docx").content
di = docx_info(docx_bytes)
assert sim(tp, di["texte"]) >= 0.90
def test_pdf_docx_identiques_resume():
"""Le document résumé présente un contenu textuel identique entre PDF et DOCX (similitude >= 0.90)."""
doc = SAMPLES["resume"]
res = client.post("/render", json={"source": doc, "theme": "classique"})
assert res.status_code == 200
j = res.json()["job_id"]
pdf_bytes = client.get(f"/jobs/{j}/pdf").content
doc_pdf = fitz.open(stream=pdf_bytes, filetype="pdf")
tp = "\n".join(p.get_text() for p in doc_pdf)
docx_bytes = client.get(f"/jobs/{j}/docx").content
di = docx_info(docx_bytes)
assert sim(tp, di["texte"]) >= 0.90