212 lines
9.3 KiB
Python
212 lines
9.3 KiB
Python
import unittest
|
|
from pathlib import Path
|
|
|
|
from support_diagnostic.diagnostic import Resultat
|
|
from support_diagnostic.libredesk import Garde
|
|
from support_diagnostic.run import ETIQUETTES, Config, eligible, fil, note, traiter
|
|
|
|
ENTETE = "<p><strong>🤖 BROUILLON IA — à relire, ne pas envoyer tel quel</strong></p>"
|
|
MOI = 4
|
|
ENV = {"LIBREDESK_URL": "http://ld", "LIBREDESK_API_KEY": "k", "LIBREDESK_API_SECRET": "s"}
|
|
|
|
|
|
def msg(type_, texte, private=False, sender=10, quand="2026-11-09T08:00:00Z", pieces=()):
|
|
return {"uuid": f"m-{texte[:8]}", "type": type_, "private": private, "sender_id": sender, "created_at": quand,
|
|
"author": {"first_name": "Client" if type_ == "incoming" else "Marc"}, "meta": {},
|
|
"text_content": texte, "content": f"<p>{texte}</p>", "attachments": list(pieces)}
|
|
|
|
|
|
class FauxLD:
|
|
"""Le client LibreDesk en mémoire : mêmes méthodes, ecrire comme le vrai."""
|
|
def __init__(self, conversations: dict[str, list[str]], ecrire=True, note_leve=None):
|
|
self.tags = {u: list(t) for u, t in conversations.items()}
|
|
self.msgs = {u: [msg("incoming", f"Mes courbes {u} ?")] for u in conversations}
|
|
self.ecrire, self.note_leve = ecrire, note_leve
|
|
self.notes: list[tuple[str, str]] = []
|
|
self.lus: list[str] = []
|
|
|
|
def moi(self):
|
|
return MOI
|
|
|
|
def ids_etiquettes(self):
|
|
return {t: i for i, t in enumerate(ETIQUETTES)}
|
|
|
|
def conversations(self, avec):
|
|
return [{"uuid": u} for u, t in self.tags.items() if "tri:diagnostic" in t]
|
|
|
|
def etiquettes(self, uuid):
|
|
return list(self.tags[uuid])
|
|
|
|
def messages(self, uuid):
|
|
self.lus.append(uuid)
|
|
return self.msgs[uuid]
|
|
|
|
def piece(self, url):
|
|
return b"x" * 20_000
|
|
|
|
def etiqueter(self, uuid, ajouter=(), retirer=()):
|
|
if self.ecrire:
|
|
self.tags[uuid] = [t for t in self.tags[uuid] if t not in retirer] + [t for t in ajouter if t not in self.tags[uuid]]
|
|
|
|
def note_privee(self, uuid, html):
|
|
if self.note_leve:
|
|
raise self.note_leve
|
|
if self.ecrire:
|
|
self.notes.append((uuid, html))
|
|
|
|
|
|
def cfg(**plus):
|
|
return Config.depuis_env({**ENV, "DRY_RUN": "false", "ALLOWED_CONVERSATION_IDS": "*", **plus})
|
|
|
|
|
|
def diag_fait(mail, images, contexte, donnees, cases):
|
|
return Resultat("fait", "Bonjour,\n\nTout va bien.", [], 1.5, Path("/tmp"))
|
|
|
|
|
|
class TestConfig(unittest.TestCase):
|
|
def test_dry_run_par_defaut(self):
|
|
self.assertFalse(Config.depuis_env(ENV).ecrire)
|
|
for v in ("False", "0", "no", "true", ""):
|
|
self.assertFalse(Config.depuis_env({**ENV, "DRY_RUN": v}).ecrire, v)
|
|
self.assertTrue(cfg().ecrire)
|
|
|
|
def test_ecrire_exige_liste_blanche(self):
|
|
with self.assertRaises(ValueError):
|
|
Config.depuis_env({**ENV, "DRY_RUN": "false"})
|
|
self.assertIsNone(cfg().autorisees)
|
|
self.assertEqual(cfg(ALLOWED_CONVERSATION_IDS="c1, c2").autorisees, {"c1", "c2"})
|
|
|
|
def test_liste_blanche_mal_formee(self):
|
|
for v in (",", " , ", ",,"):
|
|
with self.assertRaises(ValueError, msg=v):
|
|
cfg(ALLOWED_CONVERSATION_IDS=v)
|
|
|
|
def test_kill_switch(self):
|
|
self.assertIsNone(Config.depuis_env({**ENV, "KILL_SWITCH": "1"}))
|
|
for v in ("false", "0", ""):
|
|
self.assertIsNotNone(Config.depuis_env({**ENV, "KILL_SWITCH": v}), v)
|
|
|
|
def test_plafond_par_defaut(self):
|
|
self.assertEqual(Config.depuis_env(ENV).plafond, 3)
|
|
|
|
|
|
class TestCycle(unittest.TestCase):
|
|
def test_eligible(self):
|
|
self.assertTrue(eligible(["tri:diagnostic"]))
|
|
self.assertFalse(eligible(["tri:diagnostic", "diag:fait"]))
|
|
self.assertTrue(eligible(["tri:diagnostic", "diag:fait", "diag:relancer"]))
|
|
self.assertFalse(eligible([]))
|
|
self.assertFalse(eligible(["diag:relancer"]))
|
|
self.assertFalse(eligible(["tri:diagnostic", "diag:fait", "diag:relancer", "diag:en-cours"]))
|
|
|
|
def test_plafond_et_liste_blanche(self):
|
|
ld = FauxLD({f"c{i}": ["tri:diagnostic"] for i in range(1, 6)})
|
|
self.assertEqual(len(traiter(ld, cfg(), diag_fait)), 3)
|
|
ld = FauxLD({f"c{i}": ["tri:diagnostic"] for i in range(1, 6)})
|
|
self.assertEqual(traiter(ld, cfg(ALLOWED_CONVERSATION_IDS="c2"), diag_fait), {"c2": "fait"})
|
|
|
|
def test_conversation_unique(self):
|
|
ld = FauxLD({"c1": ["tri:diagnostic"], "c2": ["tri:diagnostic"]})
|
|
self.assertEqual(traiter(ld, cfg(CONVERSATION="c2"), diag_fait), {"c2": "fait"})
|
|
|
|
def test_conversation_forcee_sans_etiquette(self):
|
|
ld = FauxLD({"c1": [], "c2": ["tri:diagnostic", "diag:fait"]})
|
|
self.assertEqual(traiter(ld, cfg(CONVERSATION="c1"), diag_fait), {"c1": "fait"})
|
|
self.assertEqual(traiter(ld, cfg(CONVERSATION="c2"), diag_fait), {"c2": "fait"})
|
|
ld = FauxLD({"c1": []})
|
|
self.assertEqual(traiter(ld, cfg(CONVERSATION="c1", ALLOWED_CONVERSATION_IDS="c9"), diag_fait), {})
|
|
|
|
def test_cycle_fait(self):
|
|
ld = FauxLD({"c1": ["tri:diagnostic", "urgent", "diag:fait", "diag:relancer"]})
|
|
self.assertEqual(traiter(ld, cfg(), diag_fait), {"c1": "fait"})
|
|
self.assertEqual(sorted(ld.tags["c1"]), ["diag:fait", "tri:diagnostic", "urgent"])
|
|
(uuid, html), = ld.notes
|
|
self.assertTrue(html.startswith(ENTETE))
|
|
self.assertIn("Tout va bien.", html)
|
|
|
|
def test_simulation_n_ecrit_rien(self):
|
|
ld = FauxLD({"c1": ["tri:diagnostic"]}, ecrire=False)
|
|
traiter(ld, Config.depuis_env(ENV), diag_fait)
|
|
self.assertEqual((ld.notes, ld.tags["c1"]), ([], ["tri:diagnostic"]))
|
|
|
|
def test_mail_vide_ignore(self):
|
|
ld = FauxLD({"c1": ["tri:diagnostic"]})
|
|
ld.msgs["c1"] = [msg("incoming", " ")]
|
|
appels = []
|
|
self.assertEqual(traiter(ld, cfg(), lambda *a: appels.append(a)), {"c1": "ignore"})
|
|
self.assertEqual(appels, [])
|
|
self.assertIn("diag:ignore", ld.tags["c1"])
|
|
self.assertIn("ne contient pas de texte", ld.notes[0][1])
|
|
|
|
def test_erreur_passe_a_la_suivante(self):
|
|
ld = FauxLD({"c1": ["tri:diagnostic"], "c2": ["tri:diagnostic"]})
|
|
|
|
def diag(mail, *a):
|
|
if "c1" in mail:
|
|
raise RuntimeError("agents en panne")
|
|
return diag_fait(mail, *a)
|
|
self.assertEqual(traiter(ld, cfg(), diag), {"c1": "erreur", "c2": "fait"})
|
|
self.assertEqual(sorted(ld.tags["c1"]), ["diag:erreur", "tri:diagnostic"])
|
|
self.assertIn("RuntimeError", ld.notes[0][1])
|
|
|
|
def test_relance_en_echec_n_est_plus_eligible(self):
|
|
ld = FauxLD({"c1": ["tri:diagnostic", "diag:fait", "diag:relancer"]})
|
|
|
|
def panne(*a):
|
|
raise RuntimeError("agents en panne")
|
|
traiter(ld, cfg(), panne)
|
|
self.assertFalse(eligible(ld.tags["c1"]), ld.tags["c1"])
|
|
ld = FauxLD({"c1": ["tri:diagnostic", "diag:fait", "diag:relancer"]}, note_leve=Garde("pas privée"))
|
|
with self.assertRaises(Garde):
|
|
traiter(ld, cfg(), diag_fait)
|
|
self.assertFalse(eligible(ld.tags["c1"]), ld.tags["c1"])
|
|
|
|
def test_etiquettes_manquantes_arrete_avant_ecriture(self):
|
|
ld = FauxLD({"c1": ["tri:diagnostic"]})
|
|
ld.ids_etiquettes = lambda: {"tri:diagnostic": 1, "diag:en-cours": 2}
|
|
with self.assertRaises(RuntimeError):
|
|
traiter(ld, cfg(CONVERSATION="c1"), diag_fait)
|
|
self.assertEqual((ld.notes, ld.tags["c1"], ld.lus), ([], ["tri:diagnostic"], []))
|
|
|
|
def test_garde_arrete_tout(self):
|
|
ld = FauxLD({"c1": ["tri:diagnostic"], "c2": ["tri:diagnostic"]}, note_leve=Garde("pas privée"))
|
|
with self.assertRaises(Garde):
|
|
traiter(ld, cfg(), diag_fait)
|
|
self.assertEqual(ld.lus, ["c1"])
|
|
self.assertIn("diag:erreur", ld.tags["c1"])
|
|
|
|
def test_relance_ecarte_nos_notes(self):
|
|
mail, contexte = fil([
|
|
msg("incoming", "Mes courbes ?", quand="2026-11-09T08:00:00Z"),
|
|
msg("outgoing", "BROUILLON IA ancien", private=True, sender=MOI, quand="2026-11-09T09:00:00Z"),
|
|
msg("outgoing", "C'est Crissier, station LENZSPITZE", private=True, sender=7, quand="2026-11-09T10:00:00Z"),
|
|
msg("activity", "Marc a posé diag:relancer", private=True, sender=7, quand="2026-11-09T10:01:00Z"),
|
|
], MOI)
|
|
self.assertIn("Mes courbes ?", mail)
|
|
self.assertNotIn("BROUILLON", mail + contexte)
|
|
self.assertNotIn("LENZSPITZE", mail)
|
|
self.assertIn("LENZSPITZE", contexte)
|
|
self.assertNotIn("relancer", mail + contexte)
|
|
|
|
def test_images_des_messages_entrants(self):
|
|
ld = FauxLD({"c1": ["tri:diagnostic"]})
|
|
ld.msgs["c1"][0]["attachments"] = [
|
|
{"content_type": "image/png", "size": 20_000, "url": "/u/1", "name": "capture.png"},
|
|
{"content_type": "image/png", "size": 500, "url": "/u/2", "name": "logo.png"},
|
|
{"content_type": "application/pdf", "size": 90_000, "url": "/u/3", "name": "a.pdf"}]
|
|
vus = []
|
|
traiter(ld, cfg(), lambda mail, images, *a: vus.append(images) or diag_fait(mail, images, *a))
|
|
self.assertEqual([t for t, _ in vus[0]], ["image/png"])
|
|
|
|
def test_note_echappe_le_html(self):
|
|
html = note(Resultat("fait", "<script>x</script>", [Path("/d/figure-1.png")], 1.234, None), "local · abc1234")
|
|
self.assertIn("<script>", html)
|
|
self.assertNotIn("<script>", html)
|
|
self.assertIn("figure-1.png", html)
|
|
self.assertIn("claude-opus-5-5", html)
|
|
self.assertIn("1.23 $", html)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|