- acces/ : conteneur (bibliothèque standard) qui répond à l'outil get_customer_access de LibreDesk. L'e-mail du contact (X-Libredesk-Contact-Email, ajouté par LibreDesk, jamais par le LLM) est traduit en compte auth0|… par l'export d'Auth0 (utilisateurs.json), puis en projets par les UserGroup de la base du dashboard (database.db, lecture seule) : project, serial, role. Jeton Bearer obligatoire ; fichier ou base illisible → 502, jamais une liste vide. - exporter_utilisateurs.py : l'export Auth0, lancé avec le .env du dashboard. - Données et secrets hors de git (acces/.env, database.db, utilisateurs.json), .env interdit à Claude. - Production : en service provisoire sur le PC de Maxime (point 14), vérifié sur un vrai « Generate reply » (1 projet renvoyé). Architecture draw.io : la partie accès. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
120 lines
5.9 KiB
Python
120 lines
5.9 KiB
Python
"""Le service d'accès (acces/service.py) et l'index de l'export Auth0, contre une base SQLite et un utilisateurs.json."""
|
|
import json
|
|
import sqlite3
|
|
import sys
|
|
import tempfile
|
|
import threading
|
|
import unittest
|
|
import urllib.error
|
|
import urllib.request
|
|
from pathlib import Path
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "acces"))
|
|
from exporter_utilisateurs import index_par_email # noqa: E402
|
|
from service import ROUTE, creer_serveur # noqa: E402
|
|
|
|
JETON = "j" * 40
|
|
UTILISATEURS = {"alice@client.ch": ["auth0|a1", "auth0|a2"], "bob@client.ch": ["auth0|b"]}
|
|
|
|
|
|
def creer_base(chemin: Path):
|
|
with sqlite3.connect(chemin) as c:
|
|
c.executescript("""
|
|
CREATE TABLE Device (id INTEGER PRIMARY KEY, serial_number VARCHAR, name VARCHAR UNIQUE);
|
|
CREATE TABLE UserGroup (id INTEGER PRIMARY KEY, device_id INTEGER, role VARCHAR);
|
|
CREATE TABLE UserGroupEntry (id INTEGER PRIMARY KEY, group_id INTEGER, user_id VARCHAR);
|
|
CREATE TABLE UserAccess (id INTEGER PRIMARY KEY, device_id INTEGER, user_id VARCHAR, access_type TEXT);
|
|
INSERT INTO Device VALUES (1, 'PONT', 'Voie Lac'), (2, 'PONT', 'Voie Jura'), (3, 'NORDEND', 'Nordend'),
|
|
(4, 'ALASKA', 'Alaska');
|
|
INSERT INTO UserGroup VALUES (10, 1, 'user'), (11, 2, 'dev_admin'), (12, 4, 'user'), (13, 99, 'user');
|
|
INSERT INTO UserGroupEntry (group_id, user_id) VALUES
|
|
(10, 'auth0|a1'), (11, 'auth0|a2'), (10, 'auth0|a2'), (13, 'auth0|a1'), (12, 'auth0|b');
|
|
-- l'ancienne table, ignorée comme par le dashboard
|
|
INSERT INTO UserAccess (device_id, user_id, access_type) VALUES (3, 'auth0|a1', 'read');
|
|
""")
|
|
c.close() # « with » valide la transaction mais ne ferme pas
|
|
|
|
|
|
class TestServiceAcces(unittest.TestCase):
|
|
def setUp(self):
|
|
dossier = tempfile.TemporaryDirectory()
|
|
self.addCleanup(dossier.cleanup)
|
|
self.base = Path(dossier.name) / "database.db"
|
|
self.utilisateurs = Path(dossier.name) / "utilisateurs.json"
|
|
creer_base(self.base)
|
|
self.utilisateurs.write_text(json.dumps(UTILISATEURS))
|
|
self.serveur = creer_serveur(("127.0.0.1", 0), JETON, str(self.base), str(self.utilisateurs))
|
|
self.serveur.RequestHandlerClass.log_message = lambda *a: None
|
|
threading.Thread(target=self.serveur.serve_forever, daemon=True).start()
|
|
self.addCleanup(self.serveur.server_close)
|
|
self.addCleanup(self.serveur.shutdown)
|
|
|
|
def demander(self, entetes: dict, route=ROUTE) -> tuple[int, dict]:
|
|
url = f"http://127.0.0.1:{self.serveur.server_address[1]}{route}"
|
|
try:
|
|
with urllib.request.urlopen(urllib.request.Request(url, headers=entetes), timeout=5) as r:
|
|
return r.status, json.load(r)
|
|
except urllib.error.HTTPError as e:
|
|
with e:
|
|
return e.code, json.load(e)
|
|
|
|
def client(self, email=None) -> tuple[int, dict]:
|
|
entetes = {"Authorization": f"Bearer {JETON}"}
|
|
if email is not None:
|
|
entetes["X-Libredesk-Contact-Email"] = email
|
|
return self.demander(entetes)
|
|
|
|
def test_sans_jeton_ou_mauvais_jeton_401(self):
|
|
for entetes in ({}, {"Authorization": "Bearer faux"}, {"Authorization": JETON}):
|
|
self.assertEqual(self.demander({**entetes, "X-Libredesk-Contact-Email": "alice@client.ch"})[0], 401)
|
|
|
|
def test_projets_avec_role_sans_useraccess_ni_device_supprime(self):
|
|
# a1 et a2 sont tous deux dans le groupe « user » de Voie Lac : une seule ligne ; a2 administre Voie Jura
|
|
self.assertEqual(self.client(" Alice@Client.CH "), (200, {"projects": [
|
|
{"project": "Voie Jura", "serial": "PONT", "role": "dev_admin"},
|
|
{"project": "Voie Lac", "serial": "PONT", "role": "user"}]}))
|
|
|
|
def test_dev_admin_l_emporte_sur_user_dans_le_meme_projet(self):
|
|
self.utilisateurs.write_text(json.dumps({"dan@client.ch": ["auth0|a2"]}))
|
|
with sqlite3.connect(self.base) as c:
|
|
c.execute("INSERT INTO UserGroup VALUES (14, 1, 'dev_admin')")
|
|
c.execute("INSERT INTO UserGroupEntry (group_id, user_id) VALUES (14, 'auth0|a2')")
|
|
c.close()
|
|
self.assertIn({"project": "Voie Lac", "serial": "PONT", "role": "dev_admin"}, self.client("dan@client.ch")[1]["projects"])
|
|
|
|
def test_inconnu_ou_sans_e_mail_liste_vide(self):
|
|
self.assertEqual(self.client("inconnu@ailleurs.ch"), (200, {"projects": []}))
|
|
self.assertEqual(self.client(), (200, {"projects": []}))
|
|
|
|
def test_nouvel_export_lu_sans_redemarrer(self):
|
|
self.utilisateurs.write_text(json.dumps({"carol@client.ch": ["auth0|b"]}))
|
|
self.assertEqual(self.client("carol@client.ch")[1],
|
|
{"projects": [{"project": "Alaska", "serial": "ALASKA", "role": "user"}]})
|
|
|
|
def test_fichier_ou_base_illisible_502_jamais_liste_vide(self):
|
|
self.utilisateurs.write_text("pas du json")
|
|
self.assertEqual(self.client("alice@client.ch"), (502, {"error": "access lookup unavailable"}))
|
|
self.utilisateurs.write_text(json.dumps(UTILISATEURS))
|
|
self.base.unlink()
|
|
self.assertEqual(self.client("alice@client.ch")[0], 502)
|
|
|
|
def test_autre_route_404(self):
|
|
self.assertEqual(self.demander({"Authorization": f"Bearer {JETON}"}, "/")[0], 404)
|
|
|
|
def test_base_jamais_modifiee(self):
|
|
avant = self.base.read_bytes()
|
|
self.client("alice@client.ch")
|
|
self.assertEqual(self.base.read_bytes(), avant)
|
|
|
|
|
|
class TestIndexParEmail(unittest.TestCase):
|
|
def test_minuscules_plusieurs_comptes_sans_e_mail_ignore(self):
|
|
self.assertEqual(index_par_email([
|
|
{"user_id": "auth0|2", "email": "Alice@Client.ch "}, {"user_id": "auth0|1", "email": "alice@client.ch"},
|
|
{"user_id": "auth0|3"}, {"user_id": "auth0|4", "email": None}]),
|
|
{"alice@client.ch": ["auth0|1", "auth0|2"]})
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|