diff --git a/support_diagnostic/__init__.py b/support_diagnostic/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/support_diagnostic/libredesk.py b/support_diagnostic/libredesk.py new file mode 100644 index 0000000..38d841d --- /dev/null +++ b/support_diagnostic/libredesk.py @@ -0,0 +1,87 @@ +"""Le client LibreDesk restreint : le seul code du dépôt qui parle à LibreDesk. + +Lire des conversations et des messages ; écrire seulement une note privée et des étiquettes (spec §7.2, §7.3). +Pas de requête générique : une écriture qui n'est pas ici n'existe pas. `ecrire=False` (simulation) : rien n'est envoyé. +""" +import json +import urllib.error +import urllib.parse +import urllib.request + + +class Garde(Exception): + """Anomalie du garde-fou d'envoi : l'appelant arrête toute l'exécution (spec §7.3).""" + + +class LibreDesk: + def __init__(self, url: str, cle: str, secret: str, ecrire: bool): + self.url, self.ecrire = url.rstrip("/"), ecrire + self._auth = f"token {cle}:{secret}" + + def _requete(self, methode: str, chemin: str, corps: dict | None = None) -> bytes: + r = urllib.request.Request(urllib.parse.urljoin(self.url + "/", chemin.lstrip("/")), method=methode, + data=json.dumps(corps).encode() if corps is not None else None, + headers={"Content-Type": "application/json"}) + r.add_unredirected_header("Authorization", self._auth) # pas vers S3 si une pièce redirige + with urllib.request.urlopen(r, timeout=30) as rep: + return rep.read() + + def _data(self, methode: str, chemin: str, corps: dict | None = None): + return json.loads(self._requete(methode, chemin, corps) or b"{}").get("data") + + # --- lectures + + def moi(self) -> int: + return self._data("GET", "/api/v1/agents/me")["id"] + + def ids_etiquettes(self) -> dict[str, int]: + return {t["name"]: t["id"] for t in self._data("GET", "/api/v1/tags") or []} + + def conversations(self, avec: int) -> list[dict]: + """Toutes les conversations qui portent l'étiquette d'id `avec`.""" + filtre = json.dumps([{"model": "conversations", "field": "tags", "operator": "contains", "value": f"[{avec}]"}]) + tout, page = [], 1 + while True: + d = self._data("GET", f"/api/v1/conversations/all?page_size=50&page={page}" + f"&order_by=conversations.last_message_at&order=asc&filters={urllib.parse.quote(filtre)}") + tout += d.get("results") or [] + if page >= (d.get("total_pages") or 1): + return tout + page += 1 + + def etiquettes(self, uuid: str) -> list[str]: + return self._data("GET", f"/api/v1/conversations/{uuid}").get("tags") or [] + + def messages(self, uuid: str) -> list[dict]: + return self._data("GET", f"/api/v1/conversations/{uuid}/messages?page_size=500").get("results") or [] + + def piece(self, url: str) -> bytes: + return self._requete("GET", url) + + # --- écritures + + def etiqueter(self, uuid: str, ajouter: list[str] = (), retirer: list[str] = ()) -> None: + """Toujours add_tags / remove_tags : sans action, LibreDesk remplacerait toutes les étiquettes.""" + if not self.ecrire: + print(f"[simulation] {uuid} : + {list(ajouter)} − {list(retirer)}") + return + for action, noms in (("add_tags", ajouter), ("remove_tags", retirer)): + if noms: + self._data("POST", f"/api/v1/conversations/{uuid}/tags", {"tags": list(noms), "action": action}) + if ajouter and (manque := set(ajouter) - set(self.etiquettes(uuid))): + raise RuntimeError(f"étiquettes absentes de LibreDesk (ignorées en silence) : {sorted(manque)}") + + def note_privee(self, uuid: str, html: str) -> dict | None: + """La seule écriture de message : private en dur, ni to, ni cc, ni bcc. Toute réponse qui n'est pas une note + privée lève Garde.""" + if not self.ecrire: + print(f"[simulation] note pour {uuid} :\n{html}") + return None + try: + m = self._data("POST", f"/api/v1/conversations/{uuid}/messages", + {"message": html, "private": True, "sender_type": "agent"}) + except urllib.error.HTTPError as e: + raise Garde(f"note privée refusée ({e.code}) sur {uuid}") from e + if not isinstance(m, dict) or m.get("private") is not True: + raise Garde(f"la réponse de LibreDesk n'est pas une note privée ({uuid}) : {str(m)[:200]}") + return m diff --git a/tests/faux_libredesk.py b/tests/faux_libredesk.py new file mode 100644 index 0000000..7508901 --- /dev/null +++ b/tests/faux_libredesk.py @@ -0,0 +1,47 @@ +"""Un faux LibreDesk (http.server) : enregistre chaque requête, rend les réponses qu'on lui donne.""" +import json +import threading +import urllib.parse +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer + + +class FauxLibreDesk: + def __init__(self): + self.requetes: list[tuple[str, str, dict | None]] = [] # (méthode, chemin avec la requête, corps JSON) + self.entetes: list[dict] = [] + self.reponses: dict[tuple[str, str], object] = {} # (méthode, chemin sans requête) → data, ou un code d'erreur + faux = self + + class Gestion(BaseHTTPRequestHandler): + def _repondre(self): + n = int(self.headers.get("Content-Length") or 0) + corps = json.loads(self.rfile.read(n)) if n else None + faux.requetes.append((self.command, self.path, corps)) + faux.entetes.append(dict(self.headers)) + cle = (self.command, urllib.parse.urlsplit(self.path).path) + r = faux.reponses.get(cle, {}) + if callable(r): + r = r(self.path) + code = r if isinstance(r, int) else 200 + texte = json.dumps({"message": "erreur"} if isinstance(r, int) else {"data": r}).encode() + self.send_response(code) + self.send_header("Content-Type", "application/json") + self.send_header("Content-Length", str(len(texte))) + self.end_headers() + self.wfile.write(texte) + + do_GET = do_POST = do_PUT = do_DELETE = _repondre + + def log_message(self, *_): + pass + + self._serveur = ThreadingHTTPServer(("127.0.0.1", 0), Gestion) + self.url = f"http://127.0.0.1:{self._serveur.server_address[1]}" + threading.Thread(target=self._serveur.serve_forever, daemon=True).start() + + def ecritures(self) -> list[tuple[str, str, dict | None]]: + return [r for r in self.requetes if r[0] != "GET"] + + def arreter(self): + self._serveur.shutdown() + self._serveur.server_close() diff --git a/tests/test_garde_fou.py b/tests/test_garde_fou.py new file mode 100644 index 0000000..a557b03 --- /dev/null +++ b/tests/test_garde_fou.py @@ -0,0 +1,34 @@ +"""Spec §7.10 : le seul envoi vers …/messages est la note privée, private en dur, sans destinataires.""" +import ast +import unittest +from pathlib import Path + +PAQUET = Path(__file__).resolve().parents[1] / "support_diagnostic" + + +class TestGardeFou(unittest.TestCase): + def sources(self): + return {f.name: f.read_text() for f in PAQUET.glob("*.py")} + + def test_un_seul_post_de_messages(self): + sources = self.sources() + for nom, texte in sources.items(): + if nom != "libredesk.py": + self.assertNotIn("/messages", texte, nom) + arbre = ast.parse(sources["libredesk.py"]) + fonctions = {f.name for f in ast.walk(arbre) if isinstance(f, ast.FunctionDef) + and "/messages" in ast.get_source_segment(sources["libredesk.py"], f)} + self.assertEqual(fonctions, {"note_privee", "messages"}) + messages = next(f for f in ast.walk(arbre) if isinstance(f, ast.FunctionDef) and f.name == "messages") + self.assertNotIn("POST", ast.get_source_segment(sources["libredesk.py"], messages)) + + def test_private_en_dur(self): + sources = self.sources() + self.assertIn('"private": True', sources["libredesk.py"]) + for nom, texte in sources.items(): + for interdit in ('"to"', '"cc"', '"bcc"', "set_tags"): + self.assertNotIn(interdit, texte, f"{interdit} dans {nom}") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_libredesk.py b/tests/test_libredesk.py new file mode 100644 index 0000000..fbe8098 --- /dev/null +++ b/tests/test_libredesk.py @@ -0,0 +1,82 @@ +import json +import unittest +import urllib.parse + +from faux_libredesk import FauxLibreDesk +from support_diagnostic.libredesk import Garde, LibreDesk + +NOTE = ("POST", "/api/v1/conversations/c1/messages") +TAGS = ("POST", "/api/v1/conversations/c1/tags") + + +class TestLibreDesk(unittest.TestCase): + def setUp(self): + self.faux = FauxLibreDesk() + self.addCleanup(self.faux.arreter) + + def ld(self, ecrire=True): + return LibreDesk(self.faux.url, "k", "s", ecrire=ecrire) + + def test_note_privee_envoie_exactement_le_corps_fige(self): + self.faux.reponses[NOTE] = {"uuid": "m1", "private": True} + self.ld().note_privee("c1", "
x
") + m, chemin, corps = self.faux.requetes[-1] + self.assertEqual((m, chemin), NOTE) + self.assertEqual(corps, {"message": "x
", "private": True, "sender_type": "agent"}) + + def test_note_non_privee_leve_garde(self): + for reponse in ({"uuid": "m1", "private": False}, {}, None): + self.faux.reponses[NOTE] = reponse + with self.assertRaises(Garde): + self.ld().note_privee("c1", "x
") + + def test_note_refusee_leve_garde(self): + self.faux.reponses[NOTE] = 403 + with self.assertRaises(Garde): + self.ld().note_privee("c1", "x
") + + def test_simulation_n_ecrit_rien(self): + ld = self.ld(ecrire=False) + self.assertIsNone(ld.note_privee("c1", "x
")) + ld.etiqueter("c1", ["diag:fait"], ["diag:en-cours"]) + self.assertEqual(self.faux.ecritures(), []) + + def test_etiqueter_n_envoie_jamais_set(self): + self.faux.reponses[("GET", "/api/v1/conversations/c1")] = {"tags": ["urgent", "diag:fait"]} + self.ld().etiqueter("c1", ["diag:fait"], ["diag:en-cours"]) + self.assertEqual(self.faux.ecritures(), [ + ("POST", "/api/v1/conversations/c1/tags", {"tags": ["diag:fait"], "action": "add_tags"}), + ("POST", "/api/v1/conversations/c1/tags", {"tags": ["diag:en-cours"], "action": "remove_tags"})]) + + def test_etiquette_inconnue_leve(self): + self.faux.reponses[("GET", "/api/v1/conversations/c1")] = {"tags": ["tri:diagnostic"]} + with self.assertRaises(RuntimeError): + self.ld().etiqueter("c1", ["diag:fait"]) + + def test_authentification(self): + self.faux.reponses[("GET", "/api/v1/agents/me")] = {"id": 4} + self.ld().moi() + self.assertEqual(self.faux.entetes[-1]["Authorization"], "token k:s") + + def test_conversations_pagine_et_filtre(self): + def page(chemin): + p = int(urllib.parse.parse_qs(urllib.parse.urlsplit(chemin).query)["page"][0]) + return {"results": [{"uuid": f"c{p}"}], "total_pages": 2, "page": p} + self.faux.reponses[("GET", "/api/v1/conversations/all")] = page + self.assertEqual([c["uuid"] for c in self.ld().conversations(7)], ["c1", "c2"]) + q = urllib.parse.parse_qs(urllib.parse.urlsplit(self.faux.requetes[0][1]).query) + self.assertEqual(json.loads(q["filters"][0]), + [{"model": "conversations", "field": "tags", "operator": "contains", "value": "[7]"}]) + + def test_lectures(self): + self.faux.reponses[("GET", "/api/v1/agents/me")] = {"id": 4} + self.faux.reponses[("GET", "/api/v1/tags")] = [{"id": 7, "name": "tri:diagnostic"}] + self.faux.reponses[("GET", "/api/v1/conversations/c1/messages")] = {"results": [{"uuid": "m1"}]} + ld = self.ld(ecrire=False) + self.assertEqual(ld.moi(), 4) + self.assertEqual(ld.ids_etiquettes(), {"tri:diagnostic": 7}) + self.assertEqual(ld.messages("c1"), [{"uuid": "m1"}]) + + +if __name__ == "__main__": + unittest.main()