Files
treblo-mcp/tests/test_envoi_paroles.py
T

289 lines
11 KiB
Python
Executable File

# -*- coding: utf-8 -*-
import os
import sys
import json
import pytest
import datetime
import subprocess
from zoneinfo import ZoneInfo
from unittest.mock import MagicMock, patch
from cap_check import TUNIS_TZ
from main import (
compute_empreinte,
validate_titre,
nettoyer_titre_fichier,
titre_vers_nom_fichier,
echapper_html,
preparer_messages_paroles,
generer,
valider,
send_telegram_preview_mp3,
get_journal_path,
get_validations_path,
get_envois_path,
get_titres_path,
current_sphere_var
)
@pytest.fixture(autouse=True)
def clean_test_env(monkeypatch, tmp_path):
j_file = str(tmp_path / "journal.jsonl")
v_file = str(tmp_path / "validations.json")
e_file = str(tmp_path / "envois.jsonl")
t_file = str(tmp_path / "titres.json")
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)
monkeypatch.setattr("main.get_titres_path", lambda: t_file)
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")
# Mocks de sécurité : interdire tout envoi réel
monkeypatch.setattr("main.send_telegram_validation_request", lambda *args, **kwargs: None)
def test_validation_id_autre_contenu_refuse(monkeypatch, tmp_path):
"""T0. Quand un validation_id est fourni mais ne correspond pas au contenu (tags/prompt/paroles),
refus clair sans débit, et l'approbation reste intacte (statut APPROVED)."""
v_file = str(tmp_path / "validations.json")
now_tunis = datetime.datetime.now(TUNIS_TZ)
exp = (now_tunis + datetime.timedelta(minutes=15)).isoformat()
# Approbation pour des tags 'blues'
emp_blues = compute_empreinte("nyora", ["blues"], "", "")
init_data = {
"validations": [
{
"id": "val_blues_ok",
"sphere": "nyora",
"empreinte": emp_blues,
"code": "654321",
"status": "APPROVED",
"attempts": 0,
"created_at": now_tunis.isoformat(),
"expires_at": exp,
"details": {"tags": ["blues"], "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:
balance_called = {"count": 0}
def fake_balance(sp):
balance_called["count"] += 1
return {"sphere": sp, "total": 9200, "num_credits": 0, "num_credits_payg": 9200}
monkeypatch.setattr("main.treblo_balance", fake_balance)
# Appel avec d'autres tags ("ambient") et le validation_id "val_blues_ok"
with pytest.raises(ValueError) as exc:
generer(sphere="nyora", titre="Test Ambient", tags=["ambient"], validation_id="val_blues_ok")
err = str(exc.value).lower()
assert "refus" in err or "approbation" in err or "empreinte" in err
# L'approbation doit rester intacte (APPROVED)
with open(v_file, "r", encoding="utf-8") as f:
v_check = json.load(f)
assert v_check["validations"][0]["status"] == "APPROVED"
assert "used_at" not in v_check["validations"][0]
# Aucun appel Treblo balance pour générer
assert balance_called["count"] == 0
# 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_nom_fichier_depuis_titre():
"""T2. Nettoyage du nom de fichier : accents conservés, espaces multiples réduits, extension .mp3."""
assert titre_vers_nom_fichier("Brume de Nuit") == "Brume de Nuit.mp3"
assert titre_vers_nom_fichier("Blues sous la Pluie") == "Blues sous la Pluie.mp3"
assert titre_vers_nom_fichier("Éphémère été à Paris") == "Éphémère été à Paris.mp3"
assert titre_vers_nom_fichier(" Chanson avec espaces ") == "Chanson avec espaces.mp3"
def test_nom_fichier_caracteres_interdits():
"""T2. Remplacement des caractères interdits / \\ : * ? \" < > | et caractères de contrôle par un tiret, limite 80 car."""
raw = 'Rock / Pop : Live * 2026 ? "Great" <Old> | New \\ Best\x07'
res = titre_vers_nom_fichier(raw)
assert res == 'Rock - Pop - Live - 2026 - -Great- -Old- - New - Best-.mp3'
for c in '/\\:*?"<>|\x07':
assert c not in res
# Troncation à 80 caractères au plus (hors extension)
long_titre = "Z" * 120
res_long = titre_vers_nom_fichier(long_titre)
assert res_long == ("Z" * 80) + ".mp3"
def test_titre_obligatoire(monkeypatch, tmp_path):
"""T1. Le paramètre titre est obligatoire, 1-60 caractères, sans nom d'artiste ni formule 'comme X'."""
token_cv = current_sphere_var.set("nyora")
try:
# Titre vide
with pytest.raises(ValueError) as exc1:
generer(sphere="nyora", titre="")
assert "titre" in str(exc1.value).lower()
# Titre avec espaces seuls
with pytest.raises(ValueError) as exc1b:
generer(sphere="nyora", titre=" ")
assert "titre" in str(exc1b.value).lower()
# Titre > 60 caractères
with pytest.raises(ValueError) as exc2:
generer(sphere="nyora", titre="A" * 61, tags=["ambient"])
assert "60" in str(exc2.value)
# Formule 'comme X' interdite
with pytest.raises(ValueError) as exc3:
generer(sphere="nyora", titre="Blues comme BB King", tags=["blues"])
assert "comme" in str(exc3.value).lower()
# Formule 'like X'
with pytest.raises(ValueError) as exc3b:
generer(sphere="nyora", titre="Track like Miles Davis", tags=["jazz"])
assert "titre" in str(exc3b.value).lower() or "comme" in str(exc3b.value).lower()
# Titre valide accepté par la validation
assert validate_titre("Brume de Nuit") == "Brume de Nuit"
finally:
current_sphere_var.reset(token_cv)
def test_paroles_mise_en_forme():
"""T3. Paroles : titre en gras avec 🎵, étiquettes en italique, séparateur, paroles en blockquote avec strophes."""
paroles = "Late at night when the city is still\nI hear the blues rolling down the hill\n\nOld acoustic guitar crying in the rain\nWhispering secrets of sorrow and pain"
msgs = preparer_messages_paroles(
titre="Blues sous la Pluie",
tags=["southern soul", "blues", "soulful"],
paroles=paroles
)
assert len(msgs) == 1
m = msgs[0]
assert "<b>🎵 Blues sous la Pluie</b>" in m
assert "<i>southern soul, blues, soulful</i>" in m
assert "---" in m
assert "<blockquote>" in m and "</blockquote>" in m
# Vérification que le saut de ligne entre strophes (\n\n) est bien conservé
assert "Late at night when the city is still\nI hear the blues rolling down the hill\n\nOld acoustic guitar crying in the rain\nWhispering secrets of sorrow and pain" in m
def test_paroles_echappement_html():
"""T3. Tout le texte est échappé (&, <, >) avant mise en forme."""
msgs = preparer_messages_paroles(
titre="Rock & Roll <Live>",
tags=["r&b", "<metal>"],
paroles="Strophe 1 & 2 <test>\nFin > début"
)
assert len(msgs) == 1
m = msgs[0]
assert "Rock &amp; Roll &lt;Live&gt;" in m
assert "r&amp;b, &lt;metal&gt;" in m
assert "Strophe 1 &amp; 2 &lt;test&gt;\nFin &gt; début" in m
assert "<Live>" not in m
assert "<metal>" not in m
assert "<test>" not in m
def test_paroles_decoupage_4096():
"""T3. Au-delà de 4096 caractères, découpage aux frontières de strophe en plusieurs messages <= 4096 car."""
strophe_txt = "Ligne de chanson répétée pour tester la longueur du message.\n" * 8
# 12 strophes pour dépasser largement 4096 caractères
strophes = [f"Strophe {i+1} :\n" + strophe_txt for i in range(12)]
paroles = "\n\n".join(strophes)
assert len(paroles) > 5000
msgs = preparer_messages_paroles(
titre="Épopée Longue",
tags=["epic", "ambient"],
paroles=paroles
)
assert len(msgs) >= 2
for idx, m in enumerate(msgs):
assert len(m) <= 4096
assert m.endswith("</blockquote>")
if idx == 0:
assert "<b>🎵 Épopée Longue</b>" in m
assert "<i>epic, ambient</i>" in m
assert "---" in m
assert "<blockquote>" in m
else:
assert "<blockquote>" in m
# Vérifier que toutes les strophes sont présentes dans l'ensemble des messages
corpus = "".join(msgs)
for i in range(12):
assert f"Strophe {i+1} :" in corpus
def test_instrumental_message_dedie():
"""T3. Chanson instrumentale sans paroles : court message Instrumental avec titre et étiquettes."""
msgs = preparer_messages_paroles(
titre="Brume de Nuit",
tags=["ambient", "piano", "chill"],
paroles=""
)
assert len(msgs) == 1
m = msgs[0]
assert "<b>🎵 Brume de Nuit</b>" in m
assert "<i>ambient, piano, chill</i>" in m
assert "Instrumental" in m
assert "<blockquote>" not in m
def test_envoi_cli_claude(monkeypatch, tmp_path):
"""T4. Script /app/envoyer_apercu.py avec --aide mentionnant task_id et --titre, et exécution conforme."""
# Test aide
script_path = "/app/envoyer_apercu.py"
if not os.path.exists(script_path):
script_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "envoyer_apercu.py")
proc = subprocess.run([sys.executable, script_path, "--aide"], capture_output=True, text=True)
assert proc.returncode == 0
assert "task_id" in proc.stdout
assert "--titre" in proc.stdout
# Test fonctionnel CLI avec simulateur Telegram
musique_dir = tmp_path / "musique" / "perso"
musique_dir.mkdir(parents=True, exist_ok=True)
mp3_file = musique_dir / "task_cli_test_123.mp3"
mp3_file.write_bytes(b"FAKE_AUDIO_DATA")
json_file = musique_dir / "task_cli_test_123.json"
json_file.write_text(json.dumps({"tags": ["blues"], "paroles": "Lyrics"}), encoding="utf-8")
calls = []
def fake_send(sphere, mp3_path, task_id, titre=None, tags=None, paroles=None):
calls.append({"sphere": sphere, "task_id": task_id, "titre": titre, "tags": tags, "paroles": paroles})
return {"message_id": 1234, "texte_message_id": 5678}
import envoyer_apercu
monkeypatch.setattr(envoyer_apercu, "send_telegram_preview_mp3", fake_send)
monkeypatch.setattr(envoyer_apercu, "get_titre_for_task", lambda tid: "Blues sous la Pluie")
monkeypatch.setattr(envoyer_apercu, "get_musique_dir", lambda sp: str(tmp_path / "musique" / sp))
test_argv = ["envoyer_apercu.py", "task_cli_test_123", "--sphere", "perso", "--titre", "Blues sous la Pluie"]
monkeypatch.setattr(sys, "argv", test_argv)
envoyer_apercu.main()
assert len(calls) == 1
assert calls[0]["task_id"] == "task_cli_test_123"
assert calls[0]["sphere"] == "perso"
assert calls[0]["titre"] == "Blues sous la Pluie"