Files
treblo-mcp/tests/test_validation_durcie.py
T

317 lines
12 KiB
Python
Executable File

# -*- coding: utf-8 -*-
import os
import json
import pytest
import datetime
from zoneinfo import ZoneInfo
from unittest.mock import MagicMock, patch
from cap_check import TUNIS_TZ, get_tunis_date, count_today
from main import (
compute_empreinte,
valider,
generer,
check_daily_cap,
update_journal_task,
get_journal_path,
get_validations_path,
current_sphere_var
)
@pytest.fixture(autouse=True)
def clean_env(monkeypatch, tmp_path):
# Fichiers temporaires pour isoler chaque test
j_file = str(tmp_path / "journal.jsonl")
v_file = str(tmp_path / "validations.json")
e_file = str(tmp_path / "envois.jsonl")
monkeypatch.setattr("main.get_journal_path", lambda: j_file)
monkeypatch.setattr("main.get_validations_path", lambda: v_file)
monkeypatch.setattr("main.get_envois_path", lambda: e_file)
# Variables d'environnement factices
monkeypatch.setenv("TREBLO_MCP_TOKEN_NYORA", "test_nyora_token_123456789012345678901234567890123456")
monkeypatch.setenv("TREBLO_MCP_TOKEN_PERSO", "test_perso_token_123456789012345678901234567890123456")
monkeypatch.setenv("TREBLO_KEY_NYORA", "test_nyora_key")
monkeypatch.setenv("TREBLO_KEY_PERSO", "test_perso_key")
monkeypatch.setenv("TELEGRAM_BOT_TOKEN_NYORA", "fake_bot_token")
monkeypatch.setenv("TELEGRAM_CHAT_ID", "2084513684")
# Neutraliser l'envoi réel de requêtes Telegram
monkeypatch.setattr("main.send_telegram_validation_request", lambda *args, **kwargs: None)
monkeypatch.setattr("main.send_telegram_preview_mp3", lambda *args, **kwargs: None)
def test_approbation_usage_unique(monkeypatch, tmp_path):
"""(a) Une approbation est à usage unique, consommée par la génération qu'elle autorise (statut USED), jamais réutilisable."""
v_file = str(tmp_path / "validations.json")
now_tunis = datetime.datetime.now(TUNIS_TZ)
exp = (now_tunis + datetime.timedelta(minutes=15)).isoformat()
emp = compute_empreinte("nyora", ["ambient"], "", "")
# Demande initiale approuvée
init_data = {
"validations": [
{
"id": "val_unique",
"sphere": "nyora",
"empreinte": emp,
"code": "123456",
"status": "APPROVED",
"attempts": 0,
"created_at": now_tunis.isoformat(),
"expires_at": exp,
"details": {"tags": ["ambient"], "prompt": "", "paroles": ""}
}
]
}
with open(v_file, "w", encoding="utf-8") as f:
json.dump(init_data, f)
token_cv = current_sphere_var.set("nyora")
try:
# Mock solde Treblo et appel API Treblo génération
monkeypatch.setattr("main.treblo_balance", lambda sp: {"sphere": sp, "total": 9200, "num_credits": 0, "num_credits_payg": 9200})
mock_resp = MagicMock()
mock_resp.read.return_value = json.dumps({"task_id": "task_unique_1", "status": "PENDING"}).encode("utf-8")
mock_resp.__enter__.return_value = mock_resp
monkeypatch.setattr("urllib.request.urlopen", lambda *args, **kwargs: mock_resp)
# 1er appel à generer : doit réussir et consommer l'approbation
res = generer(sphere="nyora", titre="Chanson Test", tags=["ambient"])
assert res.get("task_id") == "task_unique_1"
# Vérifier que le statut est passé à USED
with open(v_file, "r", encoding="utf-8") as f:
v_check = json.load(f)
assert v_check["validations"][0]["status"] == "USED"
# 2ème appel avec les mêmes paramètres : doit refuser car l'approbation est déjà consommée
with pytest.raises(ValueError) as exc:
generer(sphere="nyora", titre="Chanson Test", tags=["ambient"])
assert "validation humaine requise" in str(exc.value)
finally:
current_sphere_var.reset(token_cv)
def test_empreinte_inclut_tags():
"""(b) Empreinte = SHA-256 de (sphère, tags triés, prompt, paroles)."""
# Deux ensembles de tags différents donnent deux empreintes distinctes (même sans prompt ni paroles)
e1 = compute_empreinte("nyora", ["ambient"], "", "")
e2 = compute_empreinte("nyora", ["piano"], "", "")
assert e1 != e2
# L'ordre des tags ne change pas l'empreinte (tri canonique)
e_order1 = compute_empreinte("nyora", ["piano", "ambient"], "", "")
e_order2 = compute_empreinte("nyora", ["ambient", "piano"], "", "")
assert e_order1 == e_order2
# La sphère influence l'empreinte
e_perso = compute_empreinte("perso", ["ambient"], "", "")
assert e_perso != e1
# Prompt ou paroles modifient l'empreinte
e_prompt = compute_empreinte("nyora", ["ambient"], "un prompt jazz", "")
assert e_prompt != e1
def test_valider_code_incorrect_refuse(tmp_path):
"""(c) valider refuse si le code à 6 chiffres est incorrect."""
v_file = str(tmp_path / "validations.json")
now_tunis = datetime.datetime.now(TUNIS_TZ)
exp = (now_tunis + datetime.timedelta(minutes=15)).isoformat()
init_data = {
"validations": [
{
"id": "val_bad_code",
"sphere": "nyora",
"empreinte": "dummy_emp",
"code": "555666",
"status": "PENDING",
"attempts": 0,
"created_at": now_tunis.isoformat(),
"expires_at": exp,
"details": {}
}
]
}
with open(v_file, "w", encoding="utf-8") as f:
json.dump(init_data, f)
# Tentative avec un mauvais code
with pytest.raises(ValueError) as exc:
valider("val_bad_code", "000000")
assert "Code incorrect" in str(exc.value)
# Statut toujours PENDING, 1 essai comptabilisé
with open(v_file, "r", encoding="utf-8") as f:
data = json.load(f)
v = data["validations"][0]
assert v["status"] == "PENDING"
assert v["attempts"] == 1
def test_valider_code_limite_essais(tmp_path):
"""(d) Trois essais au plus par demande, puis la demande est annulée."""
v_file = str(tmp_path / "validations.json")
now_tunis = datetime.datetime.now(TUNIS_TZ)
exp = (now_tunis + datetime.timedelta(minutes=15)).isoformat()
init_data = {
"validations": [
{
"id": "val_3attempts",
"sphere": "nyora",
"empreinte": "dummy_emp",
"code": "789123",
"status": "PENDING",
"attempts": 0,
"created_at": now_tunis.isoformat(),
"expires_at": exp,
"details": {}
}
]
}
with open(v_file, "w", encoding="utf-8") as f:
json.dump(init_data, f)
# 1er échec
with pytest.raises(ValueError):
valider("val_3attempts", "111111")
# 2ème échec
with pytest.raises(ValueError):
valider("val_3attempts", "222222")
# 3ème échec -> déclenche l'annulation
with pytest.raises(ValueError) as exc3:
valider("val_3attempts", "333333")
assert "annulée" in str(exc3.value).lower()
# Vérification que le statut est CANCELLED
with open(v_file, "r", encoding="utf-8") as f:
data = json.load(f)
assert data["validations"][0]["status"] == "CANCELLED"
# Même avec le code exact, la demande annulée est refusée
with pytest.raises(ValueError) as exc_after:
valider("val_3attempts", "789123")
assert "annulée" in str(exc_after.value).lower()
def test_valider_expiration(tmp_path):
"""(e) Une demande de validation expirée (15 minutes) ne peut pas être validée."""
v_file = str(tmp_path / "validations.json")
now_tunis = datetime.datetime.now(TUNIS_TZ)
# Expirée il y a 5 minutes
exp = (now_tunis - datetime.timedelta(minutes=5)).isoformat()
init_data = {
"validations": [
{
"id": "val_expired",
"sphere": "nyora",
"empreinte": "dummy_emp",
"code": "123456",
"status": "PENDING",
"attempts": 0,
"created_at": (now_tunis - datetime.timedelta(minutes=20)).isoformat(),
"expires_at": exp,
"details": {}
}
]
}
with open(v_file, "w", encoding="utf-8") as f:
json.dump(init_data, f)
with pytest.raises(ValueError) as exc:
valider("val_expired", "123456")
assert "expirée" in str(exc.value).lower()
with open(v_file, "r", encoding="utf-8") as f:
data = json.load(f)
assert data["validations"][0]["status"] == "EXPIRED"
def test_generer_sans_validation_sans_debit(monkeypatch, tmp_path):
"""(f) Un appel generer sans validation préalable refuse la génération sans aucun débit."""
token_cv = current_sphere_var.set("nyora")
try:
# Mock solde Treblo
balance_called = {"val": False}
def fake_balance(sp):
balance_called["val"] = True
return {"sphere": sp, "total": 9200, "num_credits": 0, "num_credits_payg": 9200}
monkeypatch.setattr("main.treblo_balance", fake_balance)
# Aucune validation dans validations.json
with pytest.raises(ValueError) as exc:
generer(sphere="nyora", titre="Chanson Test", tags=["ambient", "chill"])
err_msg = str(exc.value)
assert "validation humaine requise" in err_msg.lower()
# Le message de refus envoyé à l'agent ne doit JAMAIS contenir le code à 6 chiffres
with open(str(tmp_path / "validations.json"), "r", encoding="utf-8") as f:
v_data = json.load(f)
assert len(v_data["validations"]) == 1
created_val = v_data["validations"][0]
code = created_val["code"]
assert len(code) == 6
assert code not in err_msg
# Aucun journal écrit
j_path = str(tmp_path / "journal.jsonl")
assert not os.path.exists(j_path) or os.path.getsize(j_path) == 0
finally:
current_sphere_var.reset(token_cv)
def test_plafond_jour_tunis(monkeypatch, tmp_path):
"""(g) Plafond journalier calculé en jour civil de Tunis."""
j_file = str(tmp_path / "journal.jsonl")
now_tunis = datetime.datetime.now(TUNIS_TZ)
today_tunis = now_tunis.strftime("%Y-%m-%d")
# Écrire 5 entrées horodatées aujourd'hui en heure de Tunis
entries = [
{"date": f"{today_tunis}T08:00:00+01:00", "sphere": "nyora", "statut": "SUCCESS"},
{"date": f"{today_tunis}T09:00:00+01:00", "sphere": "nyora", "statut": "SUCCESS"},
{"date": f"{today_tunis}T10:00:00+01:00", "sphere": "nyora", "statut": "SUCCESS"},
{"date": f"{today_tunis}T11:00:00+01:00", "sphere": "nyora", "statut": "SUCCESS"},
{"date": f"{today_tunis}T12:00:00+01:00", "sphere": "nyora", "statut": "SUCCESS"},
# Une entrée d'hier à Tunis (ne doit pas être comptée)
{"date": "2026-10-30T10:00:00+01:00", "sphere": "nyora", "statut": "SUCCESS"},
]
with open(j_file, "w", encoding="utf-8") as f:
for e in entries:
f.write(json.dumps(e) + "\n")
monkeypatch.setenv("TREBLO_DAILY_CAP", "5")
# Pour nyora : 5 aujourd'hui -> CAP_REFUSED
with pytest.raises(ValueError) as exc:
check_daily_cap("nyora")
assert "CAP_REFUSED" in str(exc.value)
# Pour perso : 0 aujourd'hui -> OK
check_daily_cap("perso")
def test_credits_apres_reel(tmp_path):
"""(h) Le journal consigne credits_apres avec le solde réel de l'API Treblo après exécution."""
j_file = str(tmp_path / "journal.jsonl")
task_id = "test_task_solde"
init_entry = {
"date": "2026-11-02T10:00:00Z",
"sphere": "nyora",
"task_id": task_id,
"statut": "PENDING",
"credits_avant": 9300,
"credits_apres": 9300
}
with open(j_file, "w", encoding="utf-8") as f:
f.write(json.dumps(init_entry) + "\n")
# Mise à jour avec le solde réel constaté après génération (débit de 100 crédits -> 9200)
update_journal_task(task_id, "SUCCESS", credits_apres=9200)
with open(j_file, "r", encoding="utf-8") as f:
line = f.readline().strip()
data = json.loads(line)
assert data["statut"] == "SUCCESS"
assert data["credits_apres"] == 9200