"""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()