473 lines
19 KiB
Python
473 lines
19 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
test_series_studio.py
|
|
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)
|
|
|
|
EXEMPLE_SERIE06_PATH = os.path.join(os.path.dirname(__file__), "..", "exemples", "serie06.json")
|
|
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():
|
|
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()
|
|
assert data.get("valid") is False
|
|
assert "errors" in data
|
|
assert any("cartouche" in err.get("path", "") for err in data["errors"])
|
|
|
|
def test_pdf_deux_pages():
|
|
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():
|
|
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))
|
|
doc_xml = z.read("word/document.xml").decode("utf-8")
|
|
assert doc_xml.count("$") == 0
|
|
|
|
def test_omml_natif():
|
|
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")
|
|
omath_count = len(re.findall(r"<m:oMath[ >]", doc_xml))
|
|
assert omath_count == 84
|
|
|
|
def test_cartouche_identique():
|
|
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
|
|
assert champ in docx_xml
|
|
|
|
def test_auteur_enseignant():
|
|
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")
|
|
m = re.search(r"<dc:creator>([^<]*)</dc:creator>", core_xml)
|
|
assert m is not None
|
|
author = m.group(1).strip().lower()
|
|
assert author != "python-docx"
|
|
assert author == expected_author
|
|
|
|
def test_theme_inconnu_refuse():
|
|
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():
|
|
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
|
|
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():
|
|
import figures
|
|
out_png = os.path.join(JOBS_DIR, "test_fig_decl.png")
|
|
spec = {
|
|
"figsize": [4.0, 4.0],
|
|
"xlim": [-2, 2],
|
|
"ylim": [-2, 2],
|
|
"aspect": "equal",
|
|
"grid": {"x_step": 1.0, "y_step": 1.0},
|
|
"axes": True,
|
|
"elements": [
|
|
{"kind": "circle", "center": [0, 0], "radius": 1.0, "stroke": "#1e3a8a", "lw": 1.8},
|
|
{"kind": "point", "x": 1.0, "y": 0, "color": "#b91c1c", "label": "$A$"}
|
|
]
|
|
}
|
|
rendered_path = figures.render_declarative_figure(spec, out_png)
|
|
assert os.path.exists(rendered_path)
|
|
assert os.path.getsize(rendered_path) > 1000
|
|
|
|
def test_aucun_secret():
|
|
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):
|
|
if "ref" in root or "jobs" in root or ".git" in root:
|
|
continue
|
|
for fname in files:
|
|
if fname.endswith((".py", ".json", ".md")):
|
|
fpath = os.path.join(root, fname)
|
|
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
|