diff --git a/tests/test_connexions_personnelles.py b/tests/test_connexions_personnelles.py new file mode 100644 index 0000000..29b09ce --- /dev/null +++ b/tests/test_connexions_personnelles.py @@ -0,0 +1,260 @@ +"""Connexions personnelles et multi-utilisateurs (0.47.0). + +Demande de Bruno (2026-11-18) : tous les utilisateurs étaient +connectés au même accès Gitea (la connexion globale de +l'instance). Désormais : + +- un membre ordinaire ne voit et n'utilise QUE ses connexions + personnelles ; les connexions globales sont réservées aux + administrateurs dans les vues interactives ; +- un membre sans connexion personnelle est accueilli par + l'écran d'aide à la connexion (onboarding) au lieu d'un + tableau de bord vide ou alimenté par l'accès d'un autre ; +- la première connexion est testée contre la forge avant + d'être enregistrée, puis attachée à l'espace courant. +""" +import uuid + +import pytest +from fastapi.testclient import TestClient + +import app.connections as connections_module +import app.main as main +from app import accounts, models + + +@pytest.fixture() +def forge_factice(monkeypatch, fake_gitea): + """Les clients des connexions créées pendant le test sont + le FakeGitea (le vrai build_client ferait des appels HTTP + réels vers l'URL fournie).""" + + def faux_build(row): + fake_gitea.connection_id = row["id"] + fake_gitea.connection_slug = row.get("slug", "test") + fake_gitea.key_prefix = f"c{row['id']}:" + return fake_gitea + + monkeypatch.setattr(connections_module, "build_client", faux_build) + return fake_gitea + + +class _ClientRefusant: + async def get_user(self): + raise RuntimeError("401 Unauthorized") + + async def aclose(self): + pass + + +@pytest.fixture() +def membre(monkeypatch, fake_gitea): + """Un membre ordinaire connecté (session forgée, patron + test_coherence_identite), nettoyé au teardown.""" + monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno") + monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse") + nom = f"membre-{uuid.uuid4().hex[:8]}" + uid = models.create_user( + nom, accounts.hash_password("motdepasse"), role="member" + ) + creees: list[int] = [] + with TestClient(main.app) as client: + client.cookies.set("kanbante_session", main._make_session(nom)) + yield client, models.get_user(uid), creees + for cid in creees: + models.delete_connection(cid) + with models.get_db() as conn: + conn.execute("DELETE FROM users WHERE id = ?", (uid,)) + + +def _csrf(client) -> str: + return client.cookies.get("kanbante_csrf") or "" + + +def test_membre_sans_connexion_voit_l_aide_pas_les_depots_d_autrui(membre): + client, _user, _creees = membre + r = client.get("/") + assert r.status_code == 200 + assert "gestionnaire de sources" in r.text + assert "Connecter ton gestionnaire de sources" in r.text + # Surtout pas les dépôts servis par la connexion globale. + assert "Projets/demo" not in r.text + + +def test_admin_voit_toujours_la_connexion_globale(monkeypatch, fake_gitea): + monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno") + monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse") + nom = f"admin-{uuid.uuid4().hex[:8]}" + uid = models.create_user( + nom, accounts.hash_password("motdepasse"), role="admin" + ) + try: + with TestClient(main.app) as client: + client.cookies.set( + "kanbante_session", main._make_session(nom) + ) + r = client.get("/") + assert r.status_code == 200 + assert "Projets/demo" in r.text + assert "Connecter ton gestionnaire" not in r.text + finally: + with models.get_db() as conn: + conn.execute("DELETE FROM users WHERE id = ?", (uid,)) + + +def test_premiere_connexion_testee_puis_affichee(membre, forge_factice): + client, user, creees = membre + client.get("/") # pose le cookie CSRF via l'écran d'aide + r = client.post( + "/onboarding/connect", + data={ + "kind": "gitea", + "name": "Mon Gitea", + "base_url": "https://git.exemple.invalid", + "token": "jeton" + "-factice", + "csrf_token": _csrf(client), + }, + follow_redirects=False, + ) + assert r.status_code == 303 + assert r.headers["location"].startswith("/?msg=") + miennes = [ + row for row in models.list_connections() + if row.get("owner_user_id") == user["id"] + ] + assert len(miennes) == 1 + conn = miennes[0] + creees.append(conn["id"]) + # Le compte détecté pendant le test est renseigné (le + # FakeGitea répond « bruno »). + assert conn["account_login"] == "bruno" + # Attachée à l'espace courant : utilisable immédiatement. + principal = models.list_workspaces()[0] + assert conn["id"] in models.workspace_connection_ids(principal["id"]) + # Le tableau de bord montre désormais SES dépôts. + r = client.get("/") + assert r.status_code == 200 + assert "Projets/demo" in r.text + assert "Connecter ton gestionnaire" not in r.text + + +def test_premiere_connexion_mauvais_jeton_refusee(membre, monkeypatch): + monkeypatch.setattr( + connections_module, "build_client", lambda row: _ClientRefusant() + ) + client, user, _creees = membre + client.get("/") + r = client.post( + "/onboarding/connect", + data={ + "kind": "gitea", + "name": "Mon Gitea", + "base_url": "https://git.exemple.invalid", + "token": "jeton" + "-invalide", + "csrf_token": _csrf(client), + }, + ) + assert r.status_code == 200 + assert "Connexion impossible" in r.text + # Rien n'a été enregistré. + assert [ + row for row in models.list_connections() + if row.get("owner_user_id") == user["id"] + ] == [] + + +def test_isolation_entre_deux_membres(membre, forge_factice): + client_a, user_a, creees = membre + client_a.get("/") + client_a.post( + "/onboarding/connect", + data={ + "kind": "gitea", + "name": "Gitea de A", + "base_url": "https://git.exemple.invalid", + "token": "jeton" + "-de-a", + "csrf_token": _csrf(client_a), + }, + follow_redirects=False, + ) + miennes_a = [ + row for row in models.list_connections() + if row.get("owner_user_id") == user_a["id"] + ] + assert len(miennes_a) == 1 + creees.append(miennes_a[0]["id"]) + + # Un second membre, neuf : toujours l'écran d'aide, et la + # connexion de A n'apparaît nulle part chez lui. + nom_b = f"membre-{uuid.uuid4().hex[:8]}" + uid_b = models.create_user( + nom_b, accounts.hash_password("motdepasse"), role="member" + ) + try: + with TestClient(main.app) as client_b: + client_b.cookies.set( + "kanbante_session", main._make_session(nom_b) + ) + r = client_b.get("/") + assert "Connecter ton gestionnaire" in r.text + assert "Projets/demo" not in r.text + r = client_b.get("/profile") + assert miennes_a[0]["slug"] not in r.text + # Le tableau d'un projet de la forge globale lui + # est introuvable (pas de repli sur l'accès d'un + # autre). + r = client_b.get("/board/Projets/demo") + assert r.status_code == 404 + finally: + with models.get_db() as conn: + conn.execute("DELETE FROM users WHERE id = ?", (uid_b,)) + + +def test_creation_depuis_le_profil_attache_a_l_espace(membre, forge_factice): + client, user, creees = membre + client.get("/profile") + r = client.post( + "/profile/connections", + data={ + "kind": "github", + "name": "Mon GitHub", + "base_url": "https://api.github.com", + "token": "jeton" + "-gh", + "csrf_token": _csrf(client), + }, + follow_redirects=False, + ) + assert r.status_code == 303 + miennes = [ + row for row in models.list_connections() + if row.get("owner_user_id") == user["id"] + ] + assert len(miennes) == 1 + creees.append(miennes[0]["id"]) + principal = models.list_workspaces()[0] + assert miennes[0]["id"] in models.workspace_connection_ids( + principal["id"] + ) + # Et le tableau de bord sort de l'écran d'aide. + r = client.get("/") + assert "Connecter ton gestionnaire" not in r.text + + +def test_sonde_onboarding_compatible_avec_le_vrai_build_client(): + """Régression du 500 réel (2026-11-18) : la ligne sonde de + l'onboarding doit nourrir le VRAI build_client, qui lit le + slug — les autres tests le patchent et ne l'ont pas vu.""" + from app import connections as connections_module + from app import forge_crypto + + probe = { + "id": 0, + "slug": "sonde", + "kind": "gitea", + "base_url": "https://git.exemple.invalid", + "token_encrypted": forge_crypto.encrypt_token("jeton" + "-sonde"), + "account_login": "", + } + client = connections_module.build_client(probe) + assert client.connection_id == 0 + assert client.key_prefix == "c0:"