romfast/rar-autopass
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(5.20): US-010 badge mediu RAR in liste/preview/detaliu/jurnal + audit + ecou API

Browse Source 
labels.py: ETICHETE_ENV + eticheta_env(env)->(text,css). Productie afisata
"PRODUCȚIE" (majuscule+diacritice) cu badge fill de atentie (--err), Testare
outline discret muted — semnalizare risc L.142 (declaratie reala ireversibila).
Clase .env-badge-prod / .env-badge-test in base.html; eticheta_env expus ca
global Jinja.

Badge de mediu per rand in _submissions, _coada implicit prin view, _preview_rand,
_trimitere_detaliu, _jurnal. Statusbar (_status.html) aliniat la aceeasi conventie
(Productie = atentie, nu verde) — inlocuieste culorile ad-hoc din US-011, toggle
neatins.

rar_env in exportul de audit (AUDIT_COLUMNS + _audit_rows) si ecou in
GET /v1/prezentari(/{id}). _submission_row_view/_detaliu_ctx/fragment_submissions
duc rar_env pana in template.

tests/test_badge_rar_env.py: badge in lista, audit contine rar_env, GET ecou rar_env.
test_statusbar_env: asertie aliniata la eticheta PRODUCȚIE.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Claude Agent
2026-07-02 20:16:08 +00:00
parent d1978e2545
commit 0a1df31126
11 changed files with 319 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

235
tests/test_badge_rar_env.py Normal file
View File

@@ -0,0 +1,235 @@
"""Teste US-010 (PRD 5.20): badge mediu RAR in liste/detaliu/audit/ecou API.
Teste:
test_badge_in_lista -- /_fragments/submissions afiseaza PRODUCȚIE / Testare per rand
test_audit_contine_rar_env -- GET /v1/audit/export (CSV) contine coloana rar_env cu valoarea
test_get_ecou_rar_env -- GET /v1/prezentari si /v1/prezentari/{id} includ campul rar_env
"""
from __future__ import annotations
import csv
import io
import os
import re
import tempfile
import pytest
from cryptography.fernet import Fernet
from starlette.testclient import TestClient
# ---------------------------------------------------------------------------
# Fixture client izolat (DB temp + cheie Fernet; fara autentificare API-key)
# ---------------------------------------------------------------------------
@pytest.fixture()
def client(monkeypatch):
"""Client izolat cu DB temporara + cheie Fernet. AUTOPASS_REQUIRE_API_KEY=false."""
tmp = tempfile.mkdtemp()
monkeypatch.setenv("AUTOPASS_DB_PATH", os.path.join(tmp, "t_badge.db"))
monkeypatch.setenv("AUTOPASS_CREDS_KEY", Fernet.generate_key().decode())
monkeypatch.setenv("AUTOPASS_REQUIRE_API_KEY", "false")
monkeypatch.setenv("AUTOPASS_WEB_AUTH_REQUIRED", "true")
from app.config import get_settings
from app import crypto
get_settings.cache_clear()
crypto.reset_cache()
from app.main import app
with TestClient(app, follow_redirects=False) as c:
yield c
get_settings.cache_clear()
crypto.reset_cache()
# ---------------------------------------------------------------------------
# Helpere — preluate din test_cont_medii.py (acelasi pattern izolat)
# ---------------------------------------------------------------------------
def _create_account_user(
name: str = "Service Badge SRL",
email: str = "badge@test.com",
password: str = "parolasecreta10",
):
"""Creeaza cont + user. Returneaza (acct_id, user_id)."""
from app.accounts import create_account
from app.users import create_user
from app.db import get_connection
conn = get_connection()
try:
acct_id = create_account(conn, name, active=True)
user_id = create_user(conn, acct_id, email, password)
return acct_id, user_id
finally:
conn.close()
def _login(client, email: str, password: str) -> None:
"""Login real prin HTTP — seteaza cookie sesiune pe client."""
resp = client.get("/login")
assert resp.status_code == 200
m = re.search(r'name="csrf_token"\s+value="([^"]+)"', resp.text)
if not m:
m = re.search(r'value="([^"]+)"\s+name="csrf_token"', resp.text)
assert m, "csrf_token negasit pe /login"
csrf = m.group(1)
resp = client.post(
"/login",
data={"email": email, "parola": password, "csrf_token": csrf},
)
assert resp.status_code == 303, f"Login esuat: {resp.status_code} {resp.text[:200]}"
def _insert_submission(acct_id: int, rar_env: str, vin: str = "WVWZZZ1KZAW000123") -> int:
"""Insereaza un submission direct in DB cu rar_env dat. Returneaza id-ul randului."""
import json
from app.db import get_connection
from app.idempotency import build_key
payload = {
"vin": vin,
"nr_inmatriculare": "B999TST",
"data_prestatie": "2026-06-15",
"odometru_final": "123456",
"prestatii": [{"cod_prestatie": "OE-1", "denumire": "Revizie"}],
}
ikey = build_key(acct_id, payload)
conn = get_connection()
try:
cur = conn.execute(
"INSERT INTO submissions "
"(idempotency_key, account_id, status, payload_json, rar_env) "
"VALUES (?, ?, 'queued', ?, ?)",
(ikey, acct_id, json.dumps(payload), rar_env),
)
row_id = cur.lastrowid
conn.commit()
return row_id
finally:
conn.close()
# ---------------------------------------------------------------------------
# Teste
# ---------------------------------------------------------------------------
def test_badge_in_lista(client):
"""/_fragments/submissions afiseaza PRODUCȚIE pentru rar_env='prod' si Testare pt 'test'."""
acct_id, _ = _create_account_user("Firma Badge 1", "b1@test.com")
_login(client, "b1@test.com", "parolasecreta10")
# Submission cu mediu Productie
_insert_submission(acct_id, rar_env="prod", vin="WVWZZZ1KZAW000001")
# Submission cu mediu Testare
_insert_submission(acct_id, rar_env="test", vin="WVWZZZ1KZAW000002")
resp = client.get("/_fragments/submissions")
assert resp.status_code == 200, f"/_fragments/submissions: {resp.status_code}"
html = resp.text
assert "PRODUC" in html.upper(), \
f"Badge 'PRODUCȚIE' lipsa in lista submissions: {html[:800]}"
assert "testare" in html.lower(), \
f"Badge 'Testare' lipsa in lista submissions: {html[:800]}"
def test_audit_contine_rar_env(client):
"""GET /v1/audit/export?status=all (CSV) contine coloana rar_env cu valoarea corecta."""
acct_id, _ = _create_account_user("Firma Badge 2", "b2@test.com")
# Insereaza un submission cu rar_env='prod' si altul cu 'test'
_insert_submission(acct_id, rar_env="prod", vin="WVWZZZ1KZAW000003")
_insert_submission(acct_id, rar_env="test", vin="WVWZZZ1KZAW000004")
# Exportul de audit functioneaza cu AUTOPASS_REQUIRE_API_KEY=false (cont id=1 implicit)
# Contul creat e acct_id; cont default e 1 (creat de schema).
# Inseram pe cont 1 explicit ca sa testam exportul fara cheie.
from app.db import get_connection
import json
conn = get_connection()
try:
payload = {
"vin": "WVWZZZ1KZAW000099",
"nr_inmatriculare": "B001AUD",
"data_prestatie": "2026-06-15",
"odometru_final": "10000",
"prestatii": [{"cod_prestatie": "OE-1", "denumire": "Revizie"}],
}
conn.execute(
"INSERT INTO submissions "
"(idempotency_key, account_id, status, payload_json, rar_env) "
"VALUES ('audit-test-key', 1, 'sent', ?, 'prod')",
(json.dumps(payload),),
)
conn.commit()
finally:
conn.close()
resp = client.get("/v1/audit/export?status=all")
assert resp.status_code == 200, f"audit/export: {resp.status_code} {resp.text[:200]}"
reader = csv.DictReader(io.StringIO(resp.text))
assert "rar_env" in (reader.fieldnames or []), \
f"Coloana 'rar_env' lipseste din CSV audit. Coloane: {reader.fieldnames}"
rows = list(reader)
assert rows, "Exportul CSV este gol — nicio trimitere?"
# Cel putin un rand are rar_env setat
env_values = {r["rar_env"] for r in rows if r.get("rar_env")}
assert env_values, f"Toate randurile au rar_env gol: {rows}"
assert "prod" in env_values, f"'prod' asteptat in valorile rar_env, gasit: {env_values}"
def test_get_ecou_rar_env(client):
"""GET /v1/prezentari si /v1/prezentari/{id} includ campul rar_env in JSON."""
# Insereaza direct pe cont 1 (default fara cheie cu AUTOPASS_REQUIRE_API_KEY=false)
import json
from app.db import get_connection
conn = get_connection()
try:
payload = {
"vin": "WVWZZZ1KZAW000077",
"nr_inmatriculare": "B002ECO",
"data_prestatie": "2026-06-20",
"odometru_final": "55000",
"prestatii": [{"cod_prestatie": "OE-1", "denumire": "Revizie"}],
}
cur = conn.execute(
"INSERT INTO submissions "
"(idempotency_key, account_id, status, payload_json, rar_env) "
"VALUES ('ecou-test-key-prod', 1, 'queued', ?, 'prod')",
(json.dumps(payload),),
)
sub_id = cur.lastrowid
conn.commit()
finally:
conn.close()
# GET /v1/prezentari (lista)
resp_lista = client.get("/v1/prezentari")
assert resp_lista.status_code == 200, f"GET /v1/prezentari: {resp_lista.status_code}"
lista = resp_lista.json().get("submissions", [])
assert lista, "Lista de submission-uri este goala"
# Fiecare rand din lista trebuie sa aiba campul rar_env
sub = next((s for s in lista if s.get("id") == sub_id), None)
assert sub is not None, f"Submission {sub_id} negasit in lista"
assert "rar_env" in sub, f"Campul 'rar_env' lipseste din raspunsul listei: {sub}"
assert sub["rar_env"] == "prod", f"rar_env asteptat 'prod', gasit {sub['rar_env']!r}"
# GET /v1/prezentari/{id} (detaliu)
resp_det = client.get(f"/v1/prezentari/{sub_id}")
assert resp_det.status_code == 200, f"GET /v1/prezentari/{sub_id}: {resp_det.status_code}"
det = resp_det.json()
assert "rar_env" in det, f"Campul 'rar_env' lipseste din detaliul submission-ului: {det}"
assert det["rar_env"] == "prod", f"rar_env asteptat 'prod', gasit {det['rar_env']!r}"