feat: améliorations UX roadmap votes #94

- Votes cappés à VOTES_PER_WEEK (pas d'accumulation) pour valoriser
  les connexions régulières
- Solde de votes affiché dans la liste (input inéditable) à la place
  du bandeau Alert, avec date de prochain rechargement
- Compteur de votes par feature affiché comme input inéditable en
  fin de ligne (avant le bouton "+")
- Animation FLIP JS (roadmap_flip.js) : seules les lignes qui changent
  de position sont animées après un vote
- Renommage votes_credited_until → votes_last_credited_at (migration 0005)
- Constantes du module utilisées dans les assertions de tests

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

tests/conftest.py

@@ -49,6 +49,9 @@ os.environ["DATA_SCHEMA_CACHE"] = str(_SCHEMA_FIXTURE)
 os.environ.pop("DATA_SCHEMA_PATH", None)
 
 
+_DB_BACKUP = _DB_PATH.with_suffix(".duckdb.pytest-backup")
+
+
 def _cleanup_db_artifacts() -> None:
     for artifact in (
         _DB_PATH,
@@ -59,19 +62,30 @@ def _cleanup_db_artifacts() -> None:
             artifact.unlink()
 
 
+def _backup_db() -> None:
+    if _DB_PATH.exists():
+        _DB_PATH.rename(_DB_BACKUP)
+
+
+def _restore_db() -> None:
+    _cleanup_db_artifacts()
+    if _DB_BACKUP.exists():
+        _DB_BACKUP.rename(_DB_PATH)
+
+
 # Runs at conftest import, before test modules import src.db (which builds the
 # DuckDB at import time). Guarantees the test parquet exists and the stale DB
 # from a previous `python run.py` is wiped so src.db rebuilds from test data.
 pl.DataFrame(_TEST_DATA).write_parquet(_PARQUET_PATH)
+_backup_db()
 _cleanup_db_artifacts()
 
 
 @pytest.fixture(scope="session", autouse=True)
 def test_data():
     yield str(_PARQUET_PATH)
-    # Teardown: remove the test DuckDB so the next `python run.py` rebuilds
-    # from decp_prod.parquet.
-    _cleanup_db_artifacts()
+    # Teardown: restore the original DuckDB so the next `python run.py` finds it.
+    _restore_db()
 
 
 def pytest_setup_options():

tests/roadmap/conftest.py

@@ -1,10 +1,14 @@
 import pytest
 
-# Dash minimal pour que register_page() fonctionne dans les tests de pages de ce
-# répertoire (CONFIG peuplé). Instancié une seule fois, ici, avant tout import de page.
-from dash import Dash as _Dash
-
-_Dash(__name__, use_pages=True, pages_folder="", assets_folder="assets")
+# Importer l'app complète à la collecte : sa découverte use_pages enregistre
+# chaque page (et ses @callback) exactement une fois, en contexte propre. Un Dash
+# minimal ad hoc suivi d'imports de pages dans les tests provoque un double
+# enregistrement des @callback (Dash ré-exécute chaque page via exec_module
+# pendant la découverte de src.app), d'où "Duplicate callback outputs" qui casse
+# le rendu de toutes les pages dans la suite Selenium. En important src.app ici,
+# la découverte tourne en premier et les imports ultérieurs de pages sont mis en
+# cache. Voir aussi tests/subscriptions/conftest.py.
+from src.app import app  # noqa: F401, E402
 
 
 @pytest.fixture

tests/roadmap/test_ui.py

@@ -3,11 +3,6 @@ from dash import dcc, html
 from src.roadmap import ui
 
 
-def test_balance_text_singular_plural():
-    assert ui.balance_text(1) == "Il te reste 1 vote."
-    assert ui.balance_text(3) == "Il te reste 3 votes."
-
-
 def test_vote_items_sorted_by_count_desc():
     au_vote = [
         {"number": 1, "title": "A", "html_url": "u1"},
@@ -22,8 +17,8 @@ def test_vote_items_sorted_by_count_desc():
 
 def test_vote_items_buttons_only_when_editable():
     au_vote = [{"number": 1, "title": "A", "html_url": "u1"}]
-    assert "Voter" in str(ui.vote_items(au_vote, {1: 0}, editable=True))
-    assert "Voter" not in str(ui.vote_items(au_vote, {1: 0}, editable=False))
+    assert "roadmap-vote" in str(ui.vote_items(au_vote, {1: 0}, editable=True))
+    assert "roadmap-vote" not in str(ui.vote_items(au_vote, {1: 0}, editable=False))
 
 
 def test_changelog_markdown_returns_component():
@@ -47,4 +42,5 @@ def test_roadmap_content_renders(monkeypatch):
     assert isinstance(content, html.Div)
     assert "En cours X" in s
     assert "Au vote Y" in s
-    assert "Il te reste 2 votes." in s
+    assert "Votes restants" in s
+    assert "value='2'" in s

tests/subscriptions/conftest.py

@@ -2,13 +2,17 @@ import json as _json
 
 import pytest
 
-# Initialise un Dash minimal pour que register_page() fonctionne dans les tests
-# unitaires de pages (pas besoin du serveur complet — juste que CONFIG soit peuplé).
-from dash import Dash as _Dash
-
-_Dash(__name__, use_pages=True, pages_folder="", assets_folder="assets")
-
-from src.pages import compte_abonnement  # noqa: F401, E402  # doit venir après Dash()
+# Importer l'app complète à la collecte : sa découverte use_pages enregistre
+# chaque page (et ses @callback) exactement une fois, en contexte propre.
+#
+# Ne PAS créer un Dash minimal ad hoc puis importer la page séparément : Dash
+# ré-exécute chaque module de page via exec_module pendant la découverte (sans
+# vérifier sys.modules). Si la page a déjà été importée (donc ses @callback déjà
+# enregistrés), elle est ré-enregistrée → "Duplicate callback outputs"
+# (salaire-modal, resiliation-modal) qui casse le rendu de TOUTES les pages dans
+# la suite Selenium complète. En important src.app ici, la découverte tourne en
+# premier et les imports ultérieurs de compte_abonnement sont mis en cache.
+from src.app import app  # noqa: F401, E402
 
 
 class FakeResponse:
@@ -67,11 +71,11 @@ def sub_app(users_db_path, monkeypatch):
     monkeypatch.setenv("FRISBII_PLAN_SIMPLE", "plan_simple")
     monkeypatch.setenv("FRISBII_PLAN_SOUTIEN", "plan_soutien")
     monkeypatch.setenv("FRISBII_WEBHOOK_SECRET", "s3cr3t")
-    app = Flask(__name__)
-    app.config["WTF_CSRF_ENABLED"] = False
-    init_auth(app)
-    init_subscriptions(app)
-    return app
+    flask_app = Flask(__name__)
+    flask_app.config["WTF_CSRF_ENABLED"] = False
+    init_auth(flask_app)
+    init_subscriptions(flask_app)
+    return flask_app
 
 
 @pytest.fixture

tests/subscriptions/test_db.py

@@ -20,7 +20,7 @@ def _make_user(email="u@ex.fr"):
 def _activate(uid, cursor_iso=None):
     """Met l'abonnement en statut actif avec un curseur d'accumulation donné."""
     db.get_conn().execute(
-        "UPDATE subscriptions SET status = 'active', votes_credited_until = ? "
+        "UPDATE subscriptions SET status = 'active', votes_last_credited_at = ? "
         "WHERE user_id = ?",
         (cursor_iso, uid),
     )
@@ -135,7 +135,7 @@ def test_init_schema_creates_votes_columns(users_db_path):
     db.create_pending(uid, "decpinfo-1", "simple")
     row = db.get_by_user(uid)
     assert row["votes_balance"] == 0
-    assert row["votes_credited_until"] is None
+    assert row["votes_last_credited_at"] is None
 
 
 def test_credit_pending_grants_initial_two_on_first_active(users_db_path):
@@ -144,8 +144,8 @@ def test_credit_pending_grants_initial_two_on_first_active(users_db_path):
     db.create_pending(uid, "decpinfo-1", "simple")
     _activate(uid, cursor_iso=None)
     balance = db.credit_pending(uid)
-    assert balance == 2
-    assert db.get_by_user(uid)["votes_credited_until"] is not None
+    assert balance == db.INITIAL_VOTES
+    assert db.get_by_user(uid)["votes_last_credited_at"] is not None
 
 
 def test_credit_pending_is_idempotent_same_day(users_db_path):
@@ -154,17 +154,17 @@ def test_credit_pending_is_idempotent_same_day(users_db_path):
     db.create_pending(uid, "decpinfo-1", "simple")
     _activate(uid, cursor_iso=None)
     db.credit_pending(uid)
-    assert db.credit_pending(uid) == 2  # aucun crédit supplémentaire
+    assert db.credit_pending(uid) == db.INITIAL_VOTES  # aucun crédit supplémentaire
 
 
-def test_credit_pending_adds_one_vote_per_full_week(users_db_path):
+def test_credit_pending_capped_at_votes_per_week(users_db_path):
     db.init_schema()
     uid = _make_user()
     db.create_pending(uid, "decpinfo-1", "simple")
     fifteen_days_ago = (datetime.now(timezone.utc) - timedelta(days=15)).isoformat()
     _activate(uid, cursor_iso=fifteen_days_ago)
-    # 15 jours = 2 semaines pleines
-    assert db.credit_pending(uid) == 2
+    # 15 jours = 2 semaines pleines, mais le solde est cappé à VOTES_PER_WEEK
+    assert db.credit_pending(uid) == db.VOTES_PER_WEEK
 
 
 def test_credit_pending_no_credit_when_not_active(users_db_path):
@@ -179,9 +179,9 @@ def test_spend_vote_decrements_when_balance_positive(users_db_path):
     uid = _make_user()
     db.create_pending(uid, "decpinfo-1", "simple")
     _activate(uid, cursor_iso=None)
-    db.credit_pending(uid)  # solde = 2
+    db.credit_pending(uid)  # solde = INITIAL_VOTES
     assert db.spend_vote(uid) is True
-    assert db.get_by_user(uid)["votes_balance"] == 1
+    assert db.get_by_user(uid)["votes_balance"] == db.INITIAL_VOTES - 1
 
 
 def test_spend_vote_refused_when_balance_zero(users_db_path):
@@ -198,21 +198,21 @@ def test_reactivation_resets_cursor_without_regranting(users_db_path):
     uid = _make_user()
     db.create_pending(uid, "decpinfo-1", "simple")
     _activate(uid, cursor_iso=None)
-    db.credit_pending(uid)  # +2, curseur posé
+    db.credit_pending(uid)  # +3, curseur posé
     # désabonnement
     db.update_from_webhook("decpinfo-1", "sub_1", "cancelled", _future())
     # période sans abonnement simulée : on recule artificiellement le curseur
     old_cursor = (datetime.now(timezone.utc) - timedelta(days=30)).isoformat()
     db.get_conn().execute(
-        "UPDATE subscriptions SET votes_credited_until = ? WHERE user_id = ?",
+        "UPDATE subscriptions SET votes_last_credited_at = ? WHERE user_id = ?",
         (old_cursor, uid),
     )
     # réabonnement
     db.update_from_webhook("decpinfo-1", "sub_1", "active", _future())
     row = db.get_by_user(uid)
-    assert row["votes_balance"] == 2  # pas de re-crédit des +2
+    assert row["votes_balance"] == db.INITIAL_VOTES  # pas de re-crédit des +3
     # le curseur a été remis ~à maintenant → pas de crédit du gap de 30 jours
-    assert db.credit_pending(uid) == 2
+    assert db.credit_pending(uid) == db.INITIAL_VOTES
 
 
 def test_trial_to_active_does_not_reset_then_grants_two(users_db_path):
@@ -221,5 +221,5 @@ def test_trial_to_active_does_not_reset_then_grants_two(users_db_path):
     db.create_pending(uid, "decpinfo-1", "simple")
     db.update_from_webhook("decpinfo-1", "sub_1", "trial", _future())
     db.update_from_webhook("decpinfo-1", "sub_1", "active", _future())
-    # fin d'essai : credit_pending accorde les +2 initiaux
-    assert db.credit_pending(uid) == 2
+    # fin d'essai : credit_pending accorde les +INITIAL_VOTES initiaux
+    assert db.credit_pending(uid) == db.INITIAL_VOTES

tests/test_csrf_architecture.py

@@ -35,10 +35,18 @@ def test_fill_csrf_inputs_allows_initial_call():
     initiale (_pages_location → _generate_csrf_token → csrf-token → _fill_csrf_inputs),
     laissant le champ csrf_token vide → erreur 400 au premier chargement de /connexion.
     """
-    import src.app  # noqa: F401 — enregistre les callbacks
+    from src.app import app  # enregistre les callbacks et expose callback_map
 
+    # Tant que l'app n'a pas été servie, les callbacks vivent dans
+    # dash._callback.GLOBAL_CALLBACK_MAP. Dès la première requête (qu'un test
+    # précédent a pu déclencher), Dash les déplace dans app.callback_map et vide
+    # le registre global. On inspecte donc les deux pour ne pas dépendre de
+    # l'ordre des tests.
     found = False
-    for cb_info in dash._callback.GLOBAL_CALLBACK_MAP.values():
+    registries = list(dash._callback.GLOBAL_CALLBACK_MAP.values()) + list(
+        app.callback_map.values()
+    )
+    for cb_info in registries:
         inputs = getattr(cb_info, "inputs", None) or cb_info.get("inputs", [])
         for inp in inputs:
             if hasattr(inp, "component_id"):

tests/test_main.py

@@ -45,7 +45,7 @@ def test_002_filter_persistence(dash_duo: DashComposite):
     def open_page_and_check_filter_input():
         dash_duo.wait_for_page(f"{dash_duo.server_url}/{page}")
         filter_input_selector = (
-            '.marches_table th[data-dash-column="uid"] input[type="text"]'
+            '.marches_table th[data-dash-column="dateNotification"] input[type="text"]'
         )
         dash_duo.wait_for_element(filter_input_selector, timeout=2)
         _filter_input: WebElement = dash_duo.find_element(filter_input_selector)
@@ -53,17 +53,17 @@ def test_002_filter_persistence(dash_duo: DashComposite):
 
     for page in ["tableau", "acheteurs/123", "titulaires/345"]:
         filter_input = open_page_and_check_filter_input()
-        filter_input.send_keys("11")  # a UID that doesn't exist
+        filter_input.send_keys("11")  # valeur quelconque, on teste la persistance
         filter_input.send_keys(Keys.ENTER)
         filter_input = open_page_and_check_filter_input()
         assert filter_input.get_attribute("value") == "11"
 
 
 def test_003_tableau_download(dash_duo: DashComposite):
-    from pages.acheteur import download_acheteur_data
-    from pages.tableau import download_data
-    from pages.titulaire import download_titulaire_data
     from src.app import app
+    from src.pages.acheteur import download_acheteur_data
+    from src.pages.tableau import download_data
+    from src.pages.titulaire import download_titulaire_data
 
     # Juste pour instancier l'app
     print(app.server.name)
@@ -340,5 +340,6 @@ def test_015_tableau_filter_date(dash_duo: DashComposite):
         _filter_input: WebElement = dash_duo.find_element(filter_input)
         _filter_input.send_keys("3333")  # a dateNotification that doesn't exist
         _filter_input.send_keys(Keys.ENTER)
-        _filter_result: list[WebElement] = dash_duo.find_elements(filter_cell_result)
-        assert len(_filter_result) == 0, f"Page : {page}"
+        # Le filtrage est asynchrone : attendre la mise à jour du tableau plutôt
+        # que de lire les lignes immédiatement (sinon on lit l'état pré-filtre).
+        dash_duo.wait_for_no_elements(filter_cell_result, timeout=4)