jurix-api / tests /test_api /test_law_files_distant.py
rahim237cm's picture
Claude Opus 5 (1M context)
feat: deployment on free tiers, object-storage documents, and email
6429ad3
Raw History Blame Contribute Delete
6.59 kB
"""
Les endpoints de fichiers, en mode magasin distant.
CE QUE CE FICHIER PROTEGE. `test_law_files.py` fixe le contrat des routes quand
le PDF est sur le disque local. Ce fichier-ci prouve que le MEME contrat tient
quand le fichier vient d'un magasin HTTPS — parce que c'est ainsi que tournera
toute instance hebergee sur un disque ephemere, et qu'une regression n'y serait
visible qu'en production.
Le test decisif est `test_le_nom_reste_construit_sur_le_titre` : la tentation,
en mode distant, est de rediriger le navigateur vers l'URL publique. Ce serait
gratuit en bande passante, et ce serait un piege — le magasin ne controle pas
`Content-Disposition`, donc l'utilisateur enregistrerait un fichier nomme
`abc123def456.pdf` au lieu du titre de la loi. `_download_filename` a ete ecrite
exactement contre ce defaut.
Le second est `test_magasin_en_panne_donne_503_et_non_404` : un 404 ferait
disparaitre le document de l'interface au lieu de signaler une panne passagere.
AUCUN RESEAU REEL : `respx` intercepte httpx et compte les appels.
Usage:
pytest tests/test_api/test_law_files_distant.py -v
"""
import hashlib
import io
from urllib.parse import unquote
import httpx
import pytest
import respx
from pypdf import PdfWriter
from app.core.config import settings
from app.models.law import Law
from app.services import document_storage
BASE = "https://magasin.test/documents"
FILE_ID = "distant0001abcdef"
URL_PDF = f"{BASE}/{FILE_ID}.pdf"
def _pdf_valide() -> bytes:
"""PDF reellement valide : /pdf-info l'ouvre avec PdfReader."""
writer = PdfWriter()
writer.add_blank_page(width=612, height=792)
tampon = io.BytesIO()
writer.write(tampon)
return tampon.getvalue()
PDF = _pdf_valide()
@pytest.fixture
def magasin(monkeypatch, tmp_path):
monkeypatch.setattr(settings, "DOCUMENTS_BASE_URL", BASE)
monkeypatch.setattr(settings, "DOCUMENTS_CACHE_DIR", str(tmp_path / "cache"))
document_storage._verrous.clear()
return tmp_path / "cache"
@pytest.fixture
async def loi_distante(db_session):
"""Une loi dont le fichier n'existe QUE dans le magasin distant."""
law = Law(
reference="PRC-TEST-DISTANT",
title="Décret de test avec fichier",
content="Article 1. Contenu de test.",
type="décret",
language="fr",
status="published",
file_id=FILE_ID,
original_filename="decret-original.pdf",
)
db_session.add(law)
await db_session.commit()
await db_session.refresh(law)
return law
class TestTelechargement:
@pytest.mark.asyncio
@respx.mock
async def test_sert_les_octets_de_l_amont(self, client, magasin, loi_distante):
respx.get(URL_PDF).mock(return_value=httpx.Response(200, content=PDF))
r = await client.get(f"/api/v1/laws/{loi_distante.id}/download")
assert r.status_code == 200
assert hashlib.sha256(r.content).hexdigest() == hashlib.sha256(PDF).hexdigest()
@pytest.mark.asyncio
@respx.mock
async def test_le_nom_reste_construit_sur_le_titre(self, client, magasin, loi_distante):
"""
LE TEST QUI INTERDIT LA REDIRECTION. Voir le docstring du module : une
302 vers le magasin perdrait le nom construit sur le titre.
"""
respx.get(URL_PDF).mock(return_value=httpx.Response(200, content=PDF))
r = await client.get(f"/api/v1/laws/{loi_distante.id}/download")
disposition = unquote(r.headers["content-disposition"])
assert disposition.startswith("attachment")
assert "Décret de test avec fichier.pdf" in disposition
assert "decret-original.pdf" not in disposition
assert FILE_ID not in disposition, "l'identifiant interne a fuite dans le nom"
@pytest.mark.asyncio
@respx.mock
async def test_deux_appels_ne_tirent_le_document_qu_une_fois(
self, client, magasin, loi_distante
):
route = respx.get(URL_PDF).mock(return_value=httpx.Response(200, content=PDF))
await client.get(f"/api/v1/laws/{loi_distante.id}/download")
await client.get(f"/api/v1/laws/{loi_distante.id}/download")
assert route.call_count == 1, "le cache ne sert a rien"
class TestInformationsPdf:
@pytest.mark.asyncio
@respx.mock
async def test_compte_les_pages_depuis_l_amont(self, client, magasin, loi_distante):
respx.get(URL_PDF).mock(return_value=httpx.Response(200, content=PDF))
r = await client.get(f"/api/v1/laws/{loi_distante.id}/pdf-info")
assert r.status_code == 200
assert r.json()["page_count"] == 1
class TestPannesEtRefus:
@pytest.mark.asyncio
@respx.mock
async def test_magasin_en_panne_donne_503_et_non_404(self, client, magasin, loi_distante):
"""Un 404 accuserait l'utilisateur d'un defaut qui est le notre."""
respx.get(URL_PDF).mock(return_value=httpx.Response(502))
r = await client.get(f"/api/v1/laws/{loi_distante.id}/download")
assert r.status_code == 503
assert r.headers.get("Retry-After") == "30"
@pytest.mark.asyncio
@respx.mock
async def test_document_absent_du_magasin_donne_404(self, client, magasin, loi_distante):
respx.get(url__startswith=BASE).mock(return_value=httpx.Response(404))
r = await client.get(f"/api/v1/laws/{loi_distante.id}/download")
assert r.status_code == 404
@pytest.mark.parametrize("file_id", ["../../../etc/passwd", "sous/dossier/fichier", "a@evil"])
@pytest.mark.asyncio
@respx.mock
async def test_file_id_douteux_donne_404_sans_aucune_requete(
self, client, db_session, magasin, file_id
):
"""
Le pendant, au niveau HTTP, de la garde SSRF de document_storage.
L'assertion qui compte n'est pas le 404 — c'est `call_count == 0`. Une
garde placee trop tard rendrait le meme 404 apres avoir deja contacte
l'hote arbitraire.
"""
route = respx.get(url__startswith="http").mock(return_value=httpx.Response(200))
law = Law(
reference=f"PRC-TEST-{abs(hash(file_id))}",
title="Loi au file_id douteux",
content="Article 1.",
type="loi",
language="fr",
status="published",
file_id=file_id,
)
db_session.add(law)
await db_session.commit()
await db_session.refresh(law)
r = await client.get(f"/api/v1/laws/{law.id}/download")
assert r.status_code == 404
assert route.call_count == 0, "une requete est partie vers un hote arbitraire"