Merge pull request 'Kanbante 0.47.0 : connexions personnelles' (#97) from connexions-personnelles-0-47-0 into main
CI / test (push) Failing after 2m52s

This commit was merged in pull request #97.
This commit is contained in:
2026-11-18 10:26:52 -05:00
7 changed files with 583 additions and 12 deletions
+11
View File
@@ -1,3 +1,14 @@
## 0.47.0 — 2026-11-18 — Connexions personnelles : chaque utilisateur connecte SA forge
Demande de Bruno : l'authentification de la suite est centralisée et multi-utilisateurs, mais dans Kanbante tout le monde agissait avec le même accès Gitea (la connexion globale de l'instance). Désormais, chacun connecte son propre gestionnaire de sources et agit avec son propre accès.
- **Filtrage par utilisateur** (`_connection_visible_to`, `_visible_connection_ids`) : dans toutes les vues interactives (tableau de bord, projets de l'espace, boards, archives, Mes issues, En vol…), un membre ordinaire ne voit et n'utilise **que ses connexions personnelles** ; les connexions globales (sans propriétaire, dont la connexion héritée n° 1) sont réservées aux administrateurs. Le repli historique de résolution des boards ne sert plus le client hérité à un membre qui n'y a pas droit : le projet lui est **introuvable (404)**. Les rituels d'arrière-plan (briefing, digest, MCP, instantanés) ne passent pas par ce filtre — ils relèvent du service, inchangés.
- **Panneau personnel simplifié** : une connexion créée depuis le profil est **attachée automatiquement à l'espace courant** (avant : « ajoute-la à un espace ou demande à un admin ») ; les connexions personnelles créées avant la 0.47.0 sont rattachées toutes seules à l'espace courant de leur propriétaire. La section « Mes connexions personnelles » du profil donne les liens directs de création de jeton (Gitea de la suite, GitHub, portée « repo »).
- **Aide à la première connexion** : un membre sans aucune connexion personnelle active est accueilli par un écran dédié plutôt que par un tableau de bord vide — explication en 3 étapes, boutons d'ouverture de la page des jetons de chaque forge (Gitea pré-rempli sur l'instance de la suite, GitHub), et formulaire de première connexion : le jeton est **testé contre la forge avant tout enregistrement** (en cas d'échec, rien n'est créé et l'erreur s'affiche) ; en cas de succès, le compte détecté est renseigné, la connexion est attachée et l'utilisateur arrive sur ses dépôts avec un message de bienvenue.
- **Incident de parcours corrigé** : la sonde de test de l'onboarding omettait le `slug` qu'exige `build_client` — 500 en conditions réelles, invisible des tests qui patchent le constructeur. Corrigé, avec un test de régression qui exerce le vrai `build_client`.
- **Tests** : `tests/test_connexions_personnelles.py` (7) — onboarding du membre neuf, admin inchangé, première connexion testée/attachée/affichée, mauvais jeton refusé sans rien enregistrer, isolation complète entre deux membres (vues, profil, board en 404), attache automatique depuis le profil, sonde compatible avec le vrai constructeur. Suite complète comparée à l'arbre vierge : aucun échec nouveau (les 4 échecs barre/mobile sont préexistants sur main).
- **Vérification réelle** (compte Gitea de test « kbtest », supprimé après coup) : écran d'aide à l'arrivée, connexion avec son vrai jeton → tableau de bord ne montrant que `kbtest/projet-de-kbtest` et sa tâche ; aucun dépôt de Bruno ; board d'un dépôt privé d'autrui introuvable. (`Projets/kanbante` étant public, son board reste lisible avec le jeton de kbtest — c'est la permission de la forge, comme sur le site Gitea lui-même.)
## 0.46.11 — 2026-11-16 — SSO : plus aucune sortie nue, « aucun » seulement si décidé, pont inerte signalé
Ronde 2 du cas réel (dev de Bruno) : la 0.46.10 déployée, le bouton SSO ramenait toujours le compte « bruno » au formulaire **nu** — URL `/login` sans paramètre, aucun message — alors que son cookie draco était valide (lu par ShaarIt et TikTak dans le même navigateur). Énumération complète des sorties de la chaîne d'entrée draco (pont, middleware de cohérence #150, entrée automatique 0.46.8, registre des rôles, révocations, rattachement/conflit, re-liaison) et reproduction en pile fidèle de chaque état candidat : la seule variante qui reproduit le symptôme à l'identique est **`DRACO_SESSION_SECRET` absent du conteneur Kanbante** — draco inerte, `claims_for` toujours None, le pont prenait la sortie « jeton absent » vers `/login` nu, pendant que le bouton SSO continuait d'être rendu. Les autres candidates sont signalées ou servent un compte (rôle explicite → 403 lu ; conflit → message dans la page finale ; jeton révoqué → `draco=invalide` ; session du clone « bruno-2 » → le clone est servi). La cause racine est donc un état du conteneur, mais le code taisait l'échec : c'est ce silence qui est corrigé ici, pour que le prochain écart de configuration se lise à l'écran au lieu de se deviner.
+1 -1
View File
@@ -1 +1 @@
0.46.11
0.47.0
+231 -10
View File
@@ -30,7 +30,7 @@ from pathlib import Path
from urllib.parse import quote
import httpx
from fastapi import FastAPI, File, Form, Request, UploadFile
from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile
from fastapi.responses import (
HTMLResponse,
JSONResponse,
@@ -1418,7 +1418,7 @@ async def _archive_target(request: Request, conn_id: int, repo_full_name: str):
parts = _split_full_name(repo_full_name)
if workspace is None or parts is None:
return None
if conn_id not in models.workspace_connection_ids(workspace["id"]):
if conn_id not in _visible_connection_ids(request, workspace["id"]):
return None
client = _forge_client(conn_id)
return client, workspace, parts[0], parts[1]
@@ -1469,7 +1469,7 @@ async def archives_local_bulk(request: Request, csrf_token: str = Form("")):
cid = int(cid_raw)
except ValueError:
continue
if cid not in models.workspace_connection_ids(workspace["id"]):
if cid not in _visible_connection_ids(request, workspace["id"]):
continue
models.set_local_archived(workspace["id"], cid, full_name, True)
count += 1
@@ -1669,6 +1669,105 @@ def _current_workspace(request: Request):
return workspaces[0], None
# ── Connexions personnelles (0.47.0) ─────────────────────
# Demande de Bruno (2026-11-18) : chaque utilisateur connecte
# SON gestionnaire de sources (Gitea, GitHub) et agit avec SON
# accès — plus question que tous les comptes partagent la
# connexion Gitea historique de l'instance.
def _connection_visible_to(row: dict | None, user: dict | None) -> bool:
"""Cette connexion est-elle utilisable par cet utilisateur
dans les vues interactives ?
- opérateur d'environnement (aucun compte en base) : tout,
comme avant ;
- connexion personnelle (owner_user_id) : son seul
propriétaire ;
- connexion globale (sans propriétaire, ex. la connexion
héritée n° 1) : les administrateurs seulement — un membre
ordinaire ne doit plus voir ni manipuler les dépôts d'un
autre accès forge. Les rituels d'arrière-plan (briefing,
digest, MCP, instantanés) ne passent pas par ce filtre :
ils relèvent du service, pas d'un utilisateur.
"""
if row is None:
return False
if user is None or user.get("id") is None:
return True
owner = row.get("owner_user_id")
if owner is not None:
return owner == user["id"]
return user.get("role") == "admin"
def _visible_connection_ids(request: Request, workspace_id: int) -> list[int]:
"""Connexions de l'espace que l'utilisateur courant peut
réellement utiliser (voir _connection_visible_to)."""
user = _current_user(request)
return [
cid
for cid in models.workspace_connection_ids(workspace_id)
if _connection_visible_to(models.get_connection(cid), user)
]
def _personal_connections(user: dict | None) -> list[dict]:
if user is None or user.get("id") is None:
return []
return [
row
for row in models.list_connections()
if row.get("owner_user_id") == user["id"]
]
def _needs_connection_onboarding(request: Request) -> bool:
"""Vrai pour un membre ordinaire sans aucune connexion
personnelle active : ses vues seraient vides, l'écran
d'aide à la connexion doit le prendre en charge."""
user = _current_user(request)
if user is None or user.get("id") is None:
return False
if user.get("role") == "admin":
return False
return not any(
row.get("enabled") for row in _personal_connections(user)
)
def _attach_connection_for_user(
request: Request, conn_id: int
) -> None:
"""Attache une connexion personnelle à l'espace courant de
son propriétaire : elle devient utilisable immédiatement,
sans passage par l'administration des espaces."""
workspace, _role = _current_workspace(request)
if workspace is None:
return
ids = models.workspace_connection_ids(workspace["id"])
if conn_id not in ids:
models.set_workspace_connections(
workspace["id"], ids + [conn_id]
)
def _ensure_personal_attached(request: Request, workspace: dict) -> None:
"""Auto-réparation : les connexions personnelles créées
avant la 0.47.0 n'étaient attachées à aucun espace — on les
rattache à l'espace courant de leur propriétaire."""
user = _current_user(request)
mine = [
row["id"] for row in _personal_connections(user) if row.get("enabled")
]
if not mine:
return
ids = models.workspace_connection_ids(workspace["id"])
missing = [cid for cid in mine if cid not in ids]
if missing:
models.set_workspace_connections(workspace["id"], ids + missing)
@app.post("/workspace/switch")
async def workspace_switch(
request: Request,
@@ -2709,6 +2808,7 @@ def _render_profile(request: Request, user: dict, msg: str = "", err: str = "",
return render(
request, "profile.html",
profile_user=user,
gitea_base=get_settings().gitea_url,
memberships=(
models.user_workspaces(user["id"])
if user.get("id") is not None
@@ -2863,7 +2963,7 @@ async def profile_create_connection(
slug = _unique_slug(
_slugify(f"{user['username']}-{name}"), "connections"
)
models.create_connection(
conn_id = models.create_connection(
slug=slug,
kind="github" if kind == "github" else "gitea",
name=name,
@@ -2871,6 +2971,7 @@ async def profile_create_connection(
token_encrypted=forge_crypto.encrypt_token(token) if token else "",
owner_user_id=user["id"],
)
_attach_connection_for_user(request, conn_id)
models.log_admin(user["id"], "connection.personal.create", slug)
return RedirectResponse(
"/profile?msg=Connexion+personnelle+ajout%C3%A9e", status_code=303
@@ -2913,6 +3014,107 @@ async def profile_test_connection(
return RedirectResponse(f"/profile?{key}={_q(message)}", status_code=303)
# ── Aide à la première connexion (0.47.0) ────────────────
def _render_onboarding(
request: Request, msg: str = "", err: str = "", form: dict | None = None
):
"""Écran d'accueil d'un membre sans connexion personnelle :
il explique, donne les liens directs de création de jeton
et propose le formulaire de première connexion."""
settings = get_settings()
return render(
request, "onboarding.html",
gitea_base=settings.gitea_url,
form=form or {},
msg=msg, err=err,
)
@app.post("/onboarding/connect")
async def onboarding_connect(
request: Request,
kind: str = Form("gitea"),
name: str = Form(""),
base_url: str = Form(""),
token: str = Form(""),
csrf_token: str = Form(""),
):
"""Première connexion d'un utilisateur : le jeton est
TESTÉ contre la forge avant tout enregistrement — en cas
d'échec, rien n'est créé et l'écran d'aide se réaffiche
avec l'erreur. En cas de succès, la connexion personnelle
est créée (compte détecté renseigné) et attachée à
l'espace courant : l'utilisateur voit ses dépôts tout de
suite."""
user = _current_user(request)
if user is None or user.get("id") is None:
return RedirectResponse("/", status_code=303)
if not _csrf_valid(request, csrf_token):
return _csrf_error()
from app import forge_crypto
kind = "github" if kind == "github" else "gitea"
name = name.strip() or ("Mon GitHub" if kind == "github" else "Mon Gitea")
base_url = base_url.strip().rstrip("/")
token = token.strip()
form = {"kind": kind, "name": name, "base_url": base_url}
if not base_url or not token:
return _render_onboarding(
request, err="URL de la forge et jeton d'accès requis",
form=form,
)
# Ligne synthétique complète : build_client lit aussi le
# slug (une première version sans slug donnait un 500 en
# conditions réelles — les tests patchaient build_client).
probe = {
"id": 0,
"slug": "sonde",
"kind": kind,
"base_url": base_url,
"token_encrypted": forge_crypto.encrypt_token(token),
"account_login": "",
}
client = connections_service.build_client(probe)
try:
forge_user = await client.get_user()
login = (
forge_user.get("login") or forge_user.get("username") or ""
)
except Exception as exc:
return _render_onboarding(
request,
err=(
"Connexion impossible avec ce jeton : "
f"{exc} — vérifie l'URL, le jeton et ses portées."
),
form=form,
)
finally:
await client.aclose()
slug = _unique_slug(
_slugify(f"{user['username']}-{name}"), "connections"
)
conn_id = models.create_connection(
slug=slug,
kind=kind,
name=name,
base_url=base_url,
token_encrypted=probe["token_encrypted"],
account_login=login,
owner_user_id=user["id"],
)
_attach_connection_for_user(request, conn_id)
models.log_admin(user["id"], "connection.personal.create", slug)
from urllib.parse import quote as _q
return RedirectResponse(
f"/?msg={_q(f'Connexion établie : {login or name} — bienvenue !')}",
status_code=303,
)
# ── Live updates (SSE hub) ─────────────────────────────────
class LiveHub:
@@ -3347,7 +3549,7 @@ async def _resolve_board_scope(request: Request, owner: str, repo: str):
ws_id = workspace["id"] if workspace else 1
full_name = f"{owner}/{repo}"
if workspace:
conn_ids = models.workspace_connection_ids(ws_id)
conn_ids = _visible_connection_ids(request, ws_id)
if len(conn_ids) == 1:
cid = conn_ids[0]
return _forge_client(cid), cid, ws_id
@@ -3361,7 +3563,17 @@ async def _resolve_board_scope(request: Request, owner: str, repo: str):
continue
if full_name in names:
return client, cid, ws_id
return gitea, registry.default_id, ws_id
# Repli historique : le client hérité n'est servi qu'aux
# utilisateurs autorisés sur la connexion par défaut —
# jamais à un membre qui n'a pas accès à cette forge.
if _connection_visible_to(
models.get_connection(registry.default_id), _current_user(request)
):
return gitea, registry.default_id, ws_id
raise HTTPException(
status_code=404,
detail="Projet introuvable pour vos connexions",
)
async def _workspace_repos(
@@ -3377,6 +3589,7 @@ async def _workspace_repos(
workspace, _role = _current_workspace(request)
if workspace is None:
return [], None
_ensure_personal_attached(request, workspace)
ws_id = workspace["id"]
selection = set(models.workspace_project_selection(ws_id))
locally_archived = {
@@ -3384,7 +3597,7 @@ async def _workspace_repos(
for r in models.list_local_archived(ws_id)
}
repos: list[dict] = []
conn_ids = models.workspace_connection_ids(ws_id)
conn_ids = _visible_connection_ids(request, ws_id)
for cid in conn_ids:
client = _forge_client(cid)
row = models.get_connection(cid)
@@ -3503,19 +3716,26 @@ def _health_dot(health: dict) -> dict:
@app.get("/", response_class=HTMLResponse)
async def dashboard(request: Request):
async def dashboard(request: Request, msg: str = "", err: str = ""):
"""Main dashboard — all projects at a glance.
Since 0.24.0 the projects are those of the CURRENT
WORKSPACE (its connections, its selection, its local
archives excluded); each card carries its connection badge.
"""
# 0.47.0 : un membre sans connexion personnelle est pris
# en charge par l'écran d'aide à la connexion plutôt que
# par un tableau de bord vide (ou pire, alimenté par
# l'accès forge d'un autre).
if _needs_connection_onboarding(request):
return _render_onboarding(request, msg=msg, err=err)
repos, workspace = await _workspace_repos(request)
active, inactive, archived = classify_repos(repos)
ws_id = workspace["id"] if workspace else 1
visible_ids = _visible_connection_ids(request, ws_id)
starred_keys: set[tuple[int, str]] = set()
if workspace:
for cid in models.workspace_connection_ids(ws_id):
for cid in visible_ids:
try:
client = _forge_client(cid)
for r in await client.list_starred():
@@ -3591,7 +3811,8 @@ async def dashboard(request: Request):
column_keys=bcols.keys(ws_id),
active_window_days=get_settings().active_window_days,
metrics=get_metrics(window_days=30),
multi_conn=len(models.workspace_connection_ids(ws_id)) > 1,
multi_conn=len(visible_ids) > 1,
msg=msg, err=err,
)
+2
View File
@@ -45,6 +45,8 @@
}
</script>
<main x-data="dashState()">
{% if msg %}<p class="chip-ok">{{ msg }}</p>{% endif %}
{% if err %}<p class="chip-warn">{{ err }}</p>{% endif %}
<!-- Barre d'outils unique (0.20.0) : onglets segmentés,
filtre, tri/regroupement (#21) et vue (#22) alignés.
Onglets : "actif" = fenêtre glissante ; "archivé" =
+77
View File
@@ -0,0 +1,77 @@
<!DOCTYPE html>
<html lang="fr" data-theme="dark">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="csrf-token" content="{{ csrf_token }}">
<title>Connecter ton gestionnaire de sources — Kanbante</title>
<link rel="stylesheet" href="/static/css/style.css?v={{ version }}">
</head>
<body>
{% include "_header.html" %}
<main class="focus-main">
<div class="page-head">
<h1>Bienvenue dans Kanbante</h1>
<p class="page-sub">Kanbante affiche les tableaux Kanban des dépôts de <strong>ton</strong> gestionnaire de sources. Aucune connexion n'est encore configurée pour ton compte : connecte la tienne pour commencer — elle ne servira qu'à toi.</p>
</div>
{% if msg %}<p class="chip-ok">{{ msg }}</p>{% endif %}
{% if err %}<p class="chip-warn">{{ err }}</p>{% endif %}
<section class="briefing-card">
<h2>Comment ça marche</h2>
<ol>
<li><strong>Choisis ta forge</strong> : Gitea (par exemple l'instance de la suite, <code>{{ gitea_base }}</code>) ou GitHub.</li>
<li><strong>Crée un jeton d'accès</strong> dans ta forge, avec la portée « repo » (lecture et écriture des dépôts et des issues). Les boutons ci-dessous ouvrent directement la bonne page.</li>
<li><strong>Colle le jeton ici</strong> : on teste la connexion avant de l'enregistrer. Le jeton est chiffré au repos et ne sera jamais réaffiché ; tu pourras le remplacer ou supprimer la connexion depuis ton profil.</li>
</ol>
<p>
<a class="btn-mini" href="{{ gitea_base }}/user/settings/applications" target="_blank" rel="noopener">Créer un jeton Gitea</a>
<a class="btn-mini" href="https://github.com/settings/tokens/new?scopes=repo&amp;description=Kanbante" target="_blank" rel="noopener">Créer un jeton GitHub</a>
</p>
</section>
<section class="briefing-card">
<h2>Ta première connexion</h2>
<form method="post" action="/onboarding/connect" class="admin-form">
<input type="hidden" name="csrf_token" value="{{ csrf_token }}">
<label>Type
<select name="kind" id="ob-kind">
<option value="gitea" {% if form.get('kind') != 'github' %}selected{% endif %}>Gitea</option>
<option value="github" {% if form.get('kind') == 'github' %}selected{% endif %}>GitHub</option>
</select>
</label>
<label>Nom <input type="text" name="name" id="ob-name" value="{{ form.get('name', '') }}" placeholder="Mon Gitea"></label>
<label>URL de base <input type="text" name="base_url" id="ob-url" required value="{{ form.get('base_url', '') }}" placeholder="{{ gitea_base }}"></label>
<label>Jeton d'accès <input type="password" name="token" required autocomplete="off"></label>
<button type="submit" class="btn-save btn-inline">Tester et connecter</button>
</form>
<p class="muted">Après la connexion, tes dépôts apparaîtront ici même. Tu pourras ajouter d'autres forges depuis ton profil (« Mes connexions personnelles »).</p>
</section>
</main>
<script>
// Pré-remplissage selon la forge choisie : l'instance
// Gitea de la suite, ou l'API publique GitHub.
(function () {
var kind = document.getElementById("ob-kind");
var url = document.getElementById("ob-url");
var name = document.getElementById("ob-name");
var gitea = "{{ gitea_base }}";
function sync() {
if (!url.value) {
url.value = kind.value === "github" ? "https://api.github.com" : gitea;
}
if (!name.value) {
name.value = kind.value === "github" ? "Mon GitHub" : "Mon Gitea";
}
}
kind.addEventListener("change", function () {
url.value = "";
name.value = "";
sync();
});
sync();
})();
</script>
</body>
</html>
+1 -1
View File
@@ -98,7 +98,7 @@
<section class="briefing-card">
<h2>Mes connexions personnelles</h2>
<p class="muted">Visibles de toi seul. Pour les utiliser, ajoute-les à un de tes espaces (ou demande à un admin d'espace).</p>
<p class="muted">Visibles de toi seul : chacune est attachée automatiquement à ton espace courant et Kanbante agit avec TON accès à la forge. Besoin d'un jeton ? <a href="{{ gitea_base }}/user/settings/applications" target="_blank" rel="noopener">Créer un jeton Gitea</a> · <a href="https://github.com/settings/tokens/new?scopes=repo&amp;description=Kanbante" target="_blank" rel="noopener">Créer un jeton GitHub</a> (portée « repo » dans les deux cas).</p>
{% for c in my_connections %}
<p>
{% if c.kind == 'github' %}GitHub{% else %}Gitea{% endif %} <strong>{{ c.name }}</strong>
+260
View File
@@ -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:"