Files
estimator/tests/unit/web/test_ui.py
T
2026-11-09 08:43:30 +03:00

860 lines
39 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import re
import time
from pathlib import Path
import pytest
from fastapi.testclient import TestClient
from estimator.api.app import create_app
from estimator.config.settings import Settings
from estimator.domain.enums import Role
from estimator.passwords import hash_password
from tests.fakes import AutoGateway
from tests.unit.agent.conftest import (
DOC_WBS,
clarify_out,
decompose_out,
estimate_out,
q,
)
PW = {"alex": "alex-password-1", "bob": "bob-password-22"}
TOKEN_RE = re.compile(r'name="csrf_token" value="([^"]+)"')
SECRET = "s" * 48
ROOT = Path(__file__).resolve().parents[3]
def users_env() -> str:
return ",".join(f"{u}:{hash_password(p, iterations=1000)}" for u, p in PW.items())
def make_ui(monkeypatch, dsn, gateway=None, **env):
base = {
"EST_DATABASE__DSN": dsn,
"EST_LLM__ANTHROPIC__API_KEY": "sk-test",
"EST_API__KEYS": "bot:botkey",
"EST_WEB__ENABLED": "true",
"EST_WEB__SESSION_SECRET": SECRET,
"EST_WEB__USERS": users_env(),
}
base.update(env)
for k, v in base.items():
monkeypatch.setenv(k, v)
# Secure cookies are only sent back over https, so that test client talks https
base = "https://testserver" if env.get("EST_WEB__COOKIE_SECURE") == "true" else "http://testserver"
return TestClient(
create_app(Settings(), gateway=gateway or AutoGateway()), base_url=base, follow_redirects=False
)
def token(client, path="/ui/login") -> str:
r = client.get(path)
found = TOKEN_RE.search(r.text)
assert found, f"no csrf token on {path}: {r.status_code}"
return found.group(1)
def login(client, user="alex", next_="/ui/estimates/new"):
t = token(client)
r = client.post("/ui/login", data={"username": user, "password": PW[user], "csrf_token": t, "next": next_})
assert r.status_code == 303, r.text
return r
def page_token(client, path="/ui/estimates/new") -> str:
return token(client, path)
def create_via_ui(client, text="Бот для Telegram с ИИ", **extra):
t = page_token(client)
r = client.post("/ui/estimates", data={"requirements": text, "csrf_token": t, **extra})
assert r.status_code == 303, r.text
return r.headers["location"].rsplit("/", 1)[-1].split("?")[0]
def wait_done(client, eid, timeout=8.0, until=("done", "failed", "needs_input")):
deadline = time.time() + timeout
while time.time() < deadline:
html = client.get(f"/ui/estimates/{eid}/panel").text
for s in until:
if 'class="badge' in html and _status_label(s) in html.split("</div>")[0]:
return html
time.sleep(0.03)
raise AssertionError("timeout waiting for the panel")
def _status_label(status):
return {"done": "Готово", "failed": "Ошибка", "needs_input": "Нужны ответы", "running": "Считается", "pending": "В очереди"}[status]
@pytest.fixture
def ui(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c:
login(c)
yield c
# ================================================================== authentication
def test_anonymous_is_sent_to_login_with_a_safe_next(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c:
r = c.get("/ui/estimates?status=done")
assert r.status_code == 303
assert r.headers["location"] == "/ui/login?next=%2Fui%2Festimates%3Fstatus%3Ddone"
assert c.get("/ui/estimates/new").status_code == 303
assert c.get("/ui/").status_code == 303 and "/login" in c.get("/ui/").headers["location"]
def test_htmx_request_without_session_gets_hx_redirect_not_a_fragment(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c:
r = c.get("/ui/estimates/x/panel", headers={"HX-Request": "true"})
assert r.status_code == 200 and r.headers["HX-Redirect"].startswith("/ui/login")
assert r.text == ""
def test_login_page_is_public_and_has_no_nav(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c:
r = c.get("/ui/login")
assert r.status_code == 200 and "Пароль" in r.text and "Новая оценка" not in r.text
def test_login_requires_csrf(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c:
r = c.post("/ui/login", data={"username": "alex", "password": PW["alex"]})
assert r.status_code == 403
c.get("/ui/login") # session now has a token, but the form did not send it
assert c.post("/ui/login", data={"username": "alex", "password": PW["alex"], "csrf_token": "forged"}).status_code == 403
def test_successful_login_sets_a_hardened_cookie(monkeypatch, dsn):
with make_ui(monkeypatch, dsn, EST_WEB__COOKIE_SECURE="true") as c:
t = token(c)
r = c.post("/ui/login", data={"username": "alex", "password": PW["alex"], "csrf_token": t})
assert r.status_code == 303 and r.headers["location"] == "/ui/estimates/new"
cookie = r.headers["set-cookie"].lower()
assert "est_session=" in cookie and "httponly" in cookie and "samesite=lax" in cookie and "secure" in cookie
assert "max-age=28800" in cookie
def test_login_follows_safe_next_and_ignores_evil_next(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c:
r = login(c, next_="/ui/market")
assert r.headers["location"] == "/ui/market"
with make_ui(monkeypatch, dsn) as c:
r = login(c, next_="https://evil.example/")
assert r.headers["location"] == "/ui/estimates/new"
def test_wrong_password_and_unknown_user_look_the_same(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c:
t = token(c)
a = c.post("/ui/login", data={"username": "alex", "password": "nope", "csrf_token": t})
b = c.post("/ui/login", data={"username": "ghost", "password": "nope", "csrf_token": t})
assert a.status_code == b.status_code == 401
assert "Неверное имя пользователя или пароль" in a.text and "Неверное имя пользователя или пароль" in b.text
assert "est_session" not in (a.headers.get("set-cookie", "").replace("est_session=;", "")) or "user" not in a.text
def test_brute_force_is_throttled(monkeypatch, dsn):
with make_ui(monkeypatch, dsn, EST_WEB__LOGIN_MAX_ATTEMPTS="3") as c:
t = token(c)
for _ in range(3):
assert c.post("/ui/login", data={"username": "alex", "password": "bad", "csrf_token": t}).status_code == 401
r = c.post("/ui/login", data={"username": "alex", "password": PW["alex"], "csrf_token": t})
assert r.status_code == 429 and int(r.headers["Retry-After"]) > 0
assert "Слишком много попыток" in r.text # even the right password is refused while blocked
def test_logout_ends_the_session(ui):
t = page_token(ui)
assert ui.get("/ui/estimates/new").status_code == 200
assert ui.post("/ui/logout", data={}).status_code == 403 # needs CSRF too
assert ui.post("/ui/logout", data={"csrf_token": t}).status_code == 303
assert ui.get("/ui/estimates/new").status_code == 303
def test_login_page_redirects_when_already_signed_in(ui):
assert ui.get("/ui/login").status_code == 303
def test_tampered_cookie_is_anonymous(ui):
ui.cookies.set("est_session", "garbage.value.here", domain="testserver.local")
ui.cookies.clear()
assert ui.get("/ui/estimates/new").status_code == 303
def test_removed_user_loses_access_even_with_a_valid_cookie(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c1:
login(c1)
cookie = c1.cookies.get("est_session")
only_bob = f"bob:{hash_password(PW['bob'], iterations=1000)}"
with make_ui(monkeypatch, dsn, EST_WEB__USERS=only_bob) as c2:
c2.cookies.set("est_session", cookie)
assert c2.get("/ui/estimates/new").status_code == 303
# ================================================================== CSRF everywhere
@pytest.mark.parametrize(
"path",
[
"/ui/estimates",
"/ui/estimates/abc/answers",
"/ui/estimates/abc/recalculate",
"/ui/estimates/abc/tasks/t1",
"/ui/logout",
],
)
def test_state_changing_routes_reject_missing_or_wrong_csrf(ui, path):
assert ui.post(path, data={"requirements": "x"}).status_code == 403
assert ui.post(path, data={"requirements": "x", "csrf_token": "wrong"}).status_code == 403
assert ui.post(path, headers={"X-CSRF-Token": "wrong"}).status_code == 403
def test_csrf_error_for_htmx_is_an_alert_in_the_flash_area(ui):
r = ui.post("/ui/estimates/abc/recalculate", headers={"HX-Request": "true"})
assert r.status_code == 403 and r.headers["HX-Retarget"] == "#flash"
assert "Обновите страницу" in r.text
# ================================================================== the main flow
def test_new_page_and_create_redirects_to_the_detail_page(ui):
page = ui.get("/ui/estimates/new")
assert page.status_code == 200 and "Описание задачи" in page.text and "Новая оценка" in page.text
eid = create_via_ui(ui)
assert len(eid) == 32
def test_result_page_shows_the_numbers_from_the_doc_example(ui):
eid = create_via_ui(ui, "Бот Telegram, MAX и VK с ИИ и amoCRM")
html = wait_done(ui, eid)
assert "370\u202f000\u00a0₽" in html # the fixed price, reserve included
assert "336\u202f000\u00a0₽" in html # without the reserve
assert "397\u202f000" not in html # the old double-counted figure
assert "144,7\u00a0ч" in html and "16,7%" in html # hours and the margin implied by a 20% markup
assert "минимальный резерв" in html and "Фиксированная цена" in html
assert "В границах рынка" in html and "badge ok" in html
assert html.count('<tr id="task-t') == 8 and "Интеграция amoCRM" in html
assert "Backend" in html and "Аналитик" in html
assert "Мультиканальный ИИ-агент" in html
assert "<html" not in html # the panel is a fragment, not a page
def test_detail_page_is_a_full_document_with_the_panel(ui):
eid = create_via_ui(ui)
wait_done(ui, eid)
page = ui.get(f"/ui/estimates/{eid}")
assert page.status_code == 200 and "<html" in page.text and 'id="panel"' in page.text
assert "hx-headers" in page.text # CSRF header for htmx requests
def test_polling_runs_while_calculating_and_stops_when_done(monkeypatch, dsn):
gw = AutoGateway()
gate = gw.block()
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c)
running = c.get(f"/ui/estimates/{eid}/panel").text
assert f'hx-get="/ui/estimates/{eid}/panel"' in running and 'hx-trigger="every 2s"' in running
assert "progress" in running
gate.set()
done = wait_done(c, eid)
assert "hx-trigger" not in done.split("<table")[0] # the root element stops polling
def test_poll_interval_comes_from_settings(monkeypatch, dsn):
gw = AutoGateway()
gw.block()
with make_ui(monkeypatch, dsn, gw, EST_WEB__POLL_INTERVAL_S="5") as c:
login(c)
eid = create_via_ui(c)
assert 'hx-trigger="every 5s"' in c.get(f"/ui/estimates/{eid}/panel").text
def test_double_submit_with_the_same_form_makes_one_estimate(monkeypatch, dsn):
gw = AutoGateway()
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
t = page_token(c)
body = {"requirements": "бот", "csrf_token": t, "request_id": "same-form-1"}
a = c.post("/ui/estimates", data=body)
b = c.post("/ui/estimates", data=body)
assert a.headers["location"] == b.headers["location"]
wait_done(c, a.headers["location"].rsplit("/", 1)[-1])
assert gw.steps().count("clarify") == 1
def test_region_choice_changes_currency_and_price(ui):
eid = create_via_ui(ui, "бот", region="eu")
html = wait_done(ui, eid)
assert "18\u202f000\u00a0€" in html and "ЕС" in html
def test_validation_error_keeps_what_the_user_typed(ui):
t = page_token(ui)
r = ui.post("/ui/estimates", data={"requirements": " ", "csrf_token": t})
assert r.status_code == 422 and "Опишите задачу" in r.text
r2 = ui.post("/ui/estimates", data={"requirements": "x" * 25000, "csrf_token": t})
assert r2.status_code == 422 and "слишком длинное" in r2.text and "x" * 100 in r2.text
# ================================================================== questions
def test_blocking_questions_are_shown_and_answers_complete_the_estimate(monkeypatch, dsn):
gw = AutoGateway(clarify=[clarify_out([q("crm", "Какая CRM?", blocking=True)]), clarify_out([])])
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c)
html = wait_done(c, eid, until=("needs_input",))
assert "Какая CRM?" in html and "нужно для оценки" in html and 'name="a_crm"' in html
t = page_token(c, f"/ui/estimates/{eid}")
empty = c.post(f"/ui/estimates/{eid}/answers", data={"csrf_token": t})
assert empty.status_code == 422 and "Ответьте хотя бы на один вопрос" in empty.text
ok = c.post(f"/ui/estimates/{eid}/answers", data={"csrf_token": t, "a_crm": "amoCRM"})
assert ok.status_code == 303
assert "Готово" in wait_done(c, eid)
assert "<q>Какая CRM?</q><a>amoCRM</a>" in gw.calls[1]["user"]
# the earlier version is still there and still asks the question
old = c.get(f"/ui/estimates/{eid}?version=1").text
assert "версия 1" in old and "Открыть последнюю" in old and 'name="a_crm"' not in old
def test_proceed_without_answers_continues_on_assumptions(monkeypatch, dsn):
gw = AutoGateway(clarify=[clarify_out([q("crm", "Какая CRM?", blocking=True)])] * 2)
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c)
wait_done(c, eid, until=("needs_input",))
t = page_token(c, f"/ui/estimates/{eid}")
assert c.post(f"/ui/estimates/{eid}/answers", data={"csrf_token": t, "proceed": "1"}).status_code == 303
html = wait_done(c, eid)
assert "Не уточнено: Какая CRM?" in html
# ================================================================== recalculation and editing
def test_recalculate_with_changed_requirements_makes_version_2(monkeypatch, dsn):
gw = AutoGateway()
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c, "Первое описание")
wait_done(c, eid)
t = page_token(c, f"/ui/estimates/{eid}")
r = c.post(f"/ui/estimates/{eid}/recalculate", data={"csrf_token": t, "requirements": "Второе описание"})
assert r.status_code == 303
html = wait_done(c, eid)
assert "версия 2" in html and "пересчёт" in html and "Второе описание" in html
assert f'href="/ui/estimates/{eid}?version=1"' in html
assert "Второе описание" in gw.calls[4]["user"]
def test_recalculate_with_unchanged_text_sends_no_requirements(monkeypatch, dsn):
gw = AutoGateway()
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c, "Описание")
wait_done(c, eid)
t = page_token(c, f"/ui/estimates/{eid}")
assert c.post(f"/ui/estimates/{eid}/recalculate", data={"csrf_token": t, "requirements": "Описание"}).status_code == 303
wait_done(c, eid)
assert c.get(f"/ui/estimates/{eid}").text.count("версия 2") >= 1
def test_recalculate_while_running_shows_a_russian_error(monkeypatch, dsn):
gw = AutoGateway()
gate = gw.block()
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c)
t = page_token(c, f"/ui/estimates/{eid}")
r = c.post(f"/ui/estimates/{eid}/recalculate", data={"csrf_token": t}, headers={"HX-Request": "true"})
assert r.status_code == 409 and r.headers["HX-Retarget"] == "#flash"
assert "ещё считается" in r.text
plain = c.post(f"/ui/estimates/{eid}/recalculate", data={"csrf_token": t})
assert plain.status_code == 409 and "<html" in plain.text and "ещё считается" in plain.text
gate.set()
wait_done(c, eid)
def test_inline_task_edit_flow(ui):
eid = create_via_ui(ui)
wait_done(ui, eid)
base = f"/ui/estimates/{eid}/tasks/t4"
row = ui.get(base).text
assert row.lstrip().startswith("<tr") and "Интеграция amoCRM" in row and "Изменить" in row
edit = ui.get(base + "/edit").text
assert 'name="likely" value="16"' in edit and "Сохранить" in edit and "Отмена" in edit
t = page_token(ui, f"/ui/estimates/{eid}")
hx = {"HX-Request": "true", "X-CSRF-Token": t}
saved = ui.post(base, data={"optimistic": "16", "likely": "32,5", "pessimistic": "64"}, headers=hx)
assert saved.status_code == 200 and saved.headers["HX-Redirect"] == f"/ui/estimates/{eid}"
html = wait_done(ui, eid)
assert "версия 2" in html and "ручная правка" in html and "32,5" in html
assert "Скорректировано вручную" in html
assert "370\u202f000\u00a0₽" not in html # repriced
# without htmx the same form is a plain post with a redirect
plain = ui.post(base, data={"optimistic": "1", "likely": "2", "pessimistic": "3", "csrf_token": t})
assert plain.status_code == 303
@pytest.mark.parametrize(
"fields,message",
[
({"optimistic": "abc", "likely": "2", "pessimistic": "3"}, "введите число"),
({"optimistic": "-1", "likely": "2", "pessimistic": "3"}, "неотрицательным"),
({"optimistic": "5", "likely": "2", "pessimistic": "3"}, "оптимистично ≤ вероятно ≤ пессимистично"),
({"optimistic": "1", "likely": "2", "pessimistic": "99999"}, "допустимого предела"),
],
)
def test_bad_task_edit_shows_a_message_and_changes_nothing(ui, fields, message):
eid = create_via_ui(ui)
wait_done(ui, eid)
t = page_token(ui, f"/ui/estimates/{eid}")
r = ui.post(f"/ui/estimates/{eid}/tasks/t1", data=fields, headers={"HX-Request": "true", "X-CSRF-Token": t})
assert r.status_code == 422 and message in r.text and r.headers["HX-Retarget"] == "#flash"
assert "версия 2" not in ui.get(f"/ui/estimates/{eid}/panel").text
def test_unknown_task_is_404(ui):
eid = create_via_ui(ui)
wait_done(ui, eid)
assert ui.get(f"/ui/estimates/{eid}/tasks/t99").status_code == 404
assert ui.get(f"/ui/estimates/{eid}/tasks/t99/edit").status_code == 404
# ================================================================== failures
def test_failed_estimate_shows_the_reason_and_a_retry_button(monkeypatch, dsn):
from estimator.domain.errors import LlmTransientError
gw = AutoGateway(estimate=[LlmTransientError("down")])
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c)
html = wait_done(c, eid, until=("failed",))
assert "временно недоступен" in html and "llm_unavailable" in html and "Повторить расчёт" in html
t = page_token(c, f"/ui/estimates/{eid}")
assert c.post(f"/ui/estimates/{eid}/recalculate", data={"csrf_token": t, "requirements": ""}).status_code == 303
assert "Готово" in wait_done(c, eid)
def test_api_5xx_is_not_leaked_to_the_browser(ui, monkeypatch):
from estimator.web.client import ApiError, EstimatorApi
async def boom(self, *a, **k):
raise ApiError(500, "Traceback: secret internals")
monkeypatch.setattr(EstimatorApi, "list", boom)
r = ui.get("/ui/estimates")
assert r.status_code == 502 and "Сервис временно недоступен" in r.text and "secret internals" not in r.text
def test_unknown_estimate_is_a_404_page(ui):
r = ui.get("/ui/estimates/does-not-exist")
assert r.status_code == 404 and "Не найдено" in r.text and "<html" in r.text
hx = ui.get("/ui/estimates/does-not-exist/panel", headers={"HX-Request": "true"})
assert hx.status_code == 404 and hx.headers["HX-Retarget"] == "#flash"
assert ui.get("/ui/estimates/x?version=0").status_code in (404, 422)
# ================================================================== XSS and injection
EVIL = '<script>alert("xss")</script>'
EVIL2 = '"><img src=x onerror=alert(1)>'
def test_untrusted_text_is_escaped_everywhere(monkeypatch, dsn):
rows = [(f"{EVIL} Аналитика", Role.ANALYST, 8, 12, 20), *DOC_WBS[1:]]
est = estimate_out(rows)
est.tasks[0].assumptions = [EVIL2]
est.tasks[0].risks = ["<b>risk</b>"]
gw = AutoGateway(
clarify=[clarify_out(summary=f"Сводка {EVIL}")],
decompose=[decompose_out(rows)],
estimate=[est],
)
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c, f"Требования </textarea>{EVIL}")
html = wait_done(c, eid)
page = c.get(f"/ui/estimates/{eid}").text
for doc in (html, page):
assert EVIL not in doc and EVIL2 not in doc and "<b>risk</b>" not in doc
assert "&lt;script&gt;" in doc
assert "&lt;/textarea&gt;" in page # the requirements cannot close their own textarea
history = c.get("/ui/estimates").text
assert EVIL not in history and "<script>alert" not in history
def test_questions_from_the_model_are_escaped(monkeypatch, dsn):
gw = AutoGateway(clarify=[clarify_out([q("x", f"Вопрос {EVIL}", blocking=True)])])
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c)
html = wait_done(c, eid, until=("needs_input",))
assert EVIL not in html and "&lt;script&gt;" in html
def test_error_messages_are_escaped_in_alerts(ui):
t = page_token(ui)
r = ui.post(
f"/ui/estimates/{EVIL}/answers", data={"csrf_token": t, "a_x": "y"}, headers={"HX-Request": "true"}
)
assert EVIL not in r.text
def test_security_headers(ui):
for path in ("/ui/estimates/new", "/ui/login", "/ui/market", "/ui/estimates/nope"):
r = ui.get(path)
csp = r.headers["content-security-policy"]
assert "script-src 'self'" in csp and "frame-ancestors 'none'" in csp and "default-src 'none'" in csp
assert "unsafe-inline" not in csp and "unsafe-eval" not in csp
assert r.headers["x-content-type-options"] == "nosniff"
assert r.headers["cache-control"] == "no-store"
assert "content-security-policy" not in ui.get("/health").headers
def test_pages_have_no_inline_scripts_or_styles(ui):
eid = create_via_ui(ui)
wait_done(ui, eid)
for path in ("/ui/estimates/new", f"/ui/estimates/{eid}", "/ui/estimates", "/ui/market"):
html = ui.get(path).text
assert not re.search(r"<script(?![^>]*\bsrc=)", html), path
assert " style=" not in html and "<style" not in html and "javascript:" not in html
def test_templates_load_nothing_from_other_hosts():
for f in (ROOT / "src/estimator/web/templates").rglob("*.html"):
assert not re.search(r"https?://", f.read_text()), f
css = (ROOT / "src/estimator/web/static/app.css").read_text()
assert "http" not in css and "@import" not in css
def test_static_files_are_served_and_cacheable(ui):
js = ui.get("/ui/static/htmx.min.js")
assert js.status_code == 200 and "htmx" in js.text[:200] and js.headers.get("cache-control") != "no-store"
assert ui.get("/ui/static/app.css").status_code == 200
assert ui.get("/ui/static/../../config/default.toml").status_code in (404, 400)
# ================================================================== isolation and secrets
def test_ui_and_api_clients_do_not_see_each_other(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c:
login(c)
ui_id = create_via_ui(c)
wait_done(c, ui_id)
bot = c.post("/api/estimates", json={"requirements": "бот от клиента API"}, headers={"X-API-Key": "botkey"}).json()
# the API client sees none of the UI's estimates and the reverse
assert c.get("/api/estimates", headers={"X-API-Key": "botkey"}).json()["items"][0]["id"] == bot["id"]
assert c.get(f"/api/estimates/{ui_id}", headers={"X-API-Key": "botkey"}).status_code == 404
assert c.get(f"/ui/estimates/{bot['id']}").status_code == 404
assert bot["id"][:8] not in c.get("/ui/estimates").text
def test_shared_workspace_lets_users_see_each_others_estimates(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as alex, make_ui(monkeypatch, dsn) as bob:
login(alex, "alex")
login(bob, "bob")
eid = create_via_ui(alex)
wait_done(alex, eid)
assert bob.get(f"/ui/estimates/{eid}").status_code == 200
assert eid[:8] in bob.get("/ui/estimates").text
def test_per_user_workspace_separates_users(monkeypatch, dsn):
with make_ui(monkeypatch, dsn, EST_WEB__WORKSPACE="per_user") as alex:
login(alex, "alex")
eid = create_via_ui(alex)
wait_done(alex, eid)
bob_app = make_ui(monkeypatch, dsn, EST_WEB__WORKSPACE="per_user")
with bob_app as bob:
login(bob, "bob")
assert bob.get(f"/ui/estimates/{eid}").status_code == 404
assert eid[:8] not in bob.get("/ui/estimates").text
assert alex.get(f"/ui/estimates/{eid}").status_code == 200
def test_internal_api_tokens_never_reach_the_browser(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c:
login(c)
eid = create_via_ui(c)
bodies = [c.get(p) for p in ("/ui/estimates/new", f"/ui/estimates/{eid}", "/ui/estimates", "/ui/market")]
tokens = list(c.app.state.ui_tokens.values())
assert tokens and all(len(t) >= 32 for t in tokens)
blob = " ".join(r.text + str(r.headers) for r in bodies) + str(c.cookies)
assert not any(t in blob for t in tokens)
# and the API does not accept a guessed or empty key
assert c.get("/api/estimates", headers={"X-API-Key": "ui"}).status_code == 401
def test_session_cookie_does_not_contain_the_password_or_hash(ui):
cookie = ui.cookies.get("est_session")
assert PW["alex"] not in cookie and "pbkdf2" not in cookie
# ================================================================== history and market
def test_history_lists_filters_and_pages(monkeypatch, dsn):
with make_ui(monkeypatch, dsn, EST_WEB__PAGE_SIZE="2") as c:
login(c)
ids = []
for i in range(3):
ids.append(create_via_ui(c, f"бот {i}"))
for eid in ids:
wait_done(c, eid)
page = c.get("/ui/estimates")
assert page.status_code == 200 and "370\u202f000\u00a0₽" in page.text
assert ids[2][:8] in page.text and ids[1][:8] in page.text and ids[0][:8] not in page.text
more = re.search(r'hx-get="(/ui/estimates\?cursor=[^"]+)"', page.text)
assert more and "Показать ещё" in page.text
rows = c.get(more.group(1).replace("&amp;", "&"), headers={"HX-Request": "true"})
assert ids[0][:8] in rows.text and "<html" not in rows.text and "Показать ещё" not in rows.text
assert "Оценок пока нет" in c.get("/ui/estimates?status=failed").text
assert "Оценок пока нет" not in c.get("/ui/estimates?status=weird").text # unknown filter is ignored
def test_empty_history_invites_to_create(ui):
assert "Оценок пока нет" in ui.get("/ui/estimates").text
def test_market_page_shows_rates_and_benchmarks(ui):
html = ui.get("/ui/market").text
assert "2026Q4" in html and "1\u202f800\u00a0₽" in html and "85\u00a0€" in html
assert "400\u202f000\u00a0₽" in html and "Мультиканальный ИИ-агент" in html
assert "стартовые" in html.lower() or "Starting priors" in html
def test_timezone_setting_is_applied(monkeypatch, dsn):
with make_ui(monkeypatch, dsn, EST_WEB__TIMEZONE="Pacific/Kiritimati") as c: # UTC+14, no DST
login(c)
eid = create_via_ui(c)
html = wait_done(c, eid)
created = re.search(r"создана (\d\d)\.(\d\d)\.(\d{4}) (\d\d):(\d\d)", html)
assert created
from datetime import UTC, datetime, timedelta
shown = datetime(int(created[3]), int(created[2]), int(created[1]), int(created[4]), int(created[5]))
assert abs((shown - (datetime.now(UTC).replace(tzinfo=None) + timedelta(hours=14))).total_seconds()) < 300
def test_ui_is_absent_when_disabled(monkeypatch, dsn):
for k, v in {"EST_DATABASE__DSN": dsn, "EST_LLM__ANTHROPIC__API_KEY": "sk-test"}.items():
monkeypatch.setenv(k, v)
with TestClient(create_app(Settings(), gateway=AutoGateway())) as c:
assert c.get("/ui/login").status_code == 404 and c.get("/ui/static/app.css").status_code == 404
assert c.get("/health").status_code == 200
# ================================================================== engagement model in the UI
def test_new_form_offers_the_engagement_choice_with_the_configured_default(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c:
login(c)
html = c.get("/ui/estimates/new").text
assert 'name="engagement"' in html and "Time &amp; Materials" in html
assert re.search(r'value="fixed_price"\s+selected', html)
with make_ui(monkeypatch, dsn, EST_PRICING__DEFAULT_ENGAGEMENT="time_and_materials") as c:
login(c)
assert re.search(r'value="time_and_materials"\s+selected', c.get("/ui/estimates/new").text)
def test_time_and_materials_is_shown_with_a_ceiling_and_client_rates(ui):
eid = create_via_ui(ui, "бот", engagement="time_and_materials")
html = wait_done(ui, eid)
assert "Time &amp; Materials" in html
assert "336\u202f000\u00a0₽" in html and "Потолок бюджета" in html and "370\u202f000\u00a0₽" in html
assert "закрепить в договоре" in html # the advice to cap the budget
assert "2\u202f484\u00a0₽" in html # the backend's client rate: 1800 x 1.15 x 1.20
assert "Показать как фиксированную цену" in html
def test_engagement_can_be_switched_in_the_ui_without_a_new_calculation(monkeypatch, dsn):
gw = AutoGateway()
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c)
wait_done(c, eid)
calls = len(gw.calls)
assert "Показать как Time &amp; Materials" in c.get(f"/ui/estimates/{eid}").text
t = page_token(c, f"/ui/estimates/{eid}")
r = c.post(f"/ui/estimates/{eid}/engagement", data={"csrf_token": t, "engagement": "time_and_materials"})
assert r.status_code == 303
html = c.get(f"/ui/estimates/{eid}").text
assert "версия 2" in html and "смена модели оплаты" in html and "Потолок бюджета" in html
assert len(gw.calls) == calls
assert "Показать как фиксированную цену" in html
assert "Фиксированная цена" in c.get(f"/ui/estimates/{eid}?version=1").text
# an unknown value is a message, not an error page
bad = c.post(f"/ui/estimates/{eid}/engagement", data={"csrf_token": t, "engagement": "hourly"}, headers={"HX-Request": "true"})
assert bad.status_code == 422 and bad.headers["HX-Retarget"] == "#flash"
def test_engagement_switch_requires_csrf(ui):
eid = create_via_ui(ui)
wait_done(ui, eid)
assert ui.post(f"/ui/estimates/{eid}/engagement", data={"engagement": "time_and_materials"}).status_code == 403
def test_history_shows_the_model_next_to_the_amount(ui):
fp = create_via_ui(ui, "один")
tm = create_via_ui(ui, "два", engagement="time_and_materials")
wait_done(ui, fp)
wait_done(ui, tm)
html = ui.get("/ui/estimates").text
assert "370\u202f000\u00a0₽" in html and "336\u202f000\u00a0₽" in html
assert "Фиксированная цена" in html and "Time &amp; Materials" in html
# ================================================================== VAT in the UI
def test_result_shows_the_price_without_vat_and_the_amount_to_pay_with_it(ui):
html = wait_done(ui, create_via_ui(ui))
assert "370\u202f000\u00a0₽" in html and "цена для клиента без НДС" in html
assert "К оплате с НДС 22%: 451\u202f400\u00a0₽" in html and "НДС 81\u202f400\u00a0₽" in html
def test_eu_client_shows_no_vat(ui):
html = wait_done(ui, create_via_ui(ui, "бот", region="eu"))
assert "НДС не применяется" in html and "К оплате с НДС" not in html
def test_new_form_lists_the_vat_choices_from_the_config(ui):
html = ui.get("/ui/estimates/new").text
assert 'name="vat"' in html and "По региону клиента (РФ 22%, ЕС без НДС)" in html
assert 'value="0"' in html and "Без НДС" in html
for rate in ("22%", "10%", "7%", "5%"):
assert f"{rate} сверху" in html
def test_vat_can_be_chosen_when_creating_and_switched_later(monkeypatch, dsn):
gw = AutoGateway()
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c, "бот", vat="0")
html = wait_done(c, eid)
assert "НДС не применяется" in html
calls = len(gw.calls)
t = page_token(c, f"/ui/estimates/{eid}")
assert c.post(f"/ui/estimates/{eid}/vat", data={"csrf_token": t, "vat": "0.22"}).status_code == 303
page = c.get(f"/ui/estimates/{eid}").text
assert "версия 2" in page and "смена модели оплаты" in page
assert "К оплате с НДС 22%: 451\u202f400\u00a0₽" in page
assert re.search(r'<option value="0\.22"\s+selected', page)
assert len(gw.calls) == calls # no new calculation
assert "НДС не применяется" in c.get(f"/ui/estimates/{eid}?version=1").text
def test_bad_vat_values_are_messages_not_crashes(ui):
eid = create_via_ui(ui)
wait_done(ui, eid)
t = page_token(ui, f"/ui/estimates/{eid}")
hx = {"HX-Request": "true"}
for bad in ("", "abc", "0.2", "5"):
r = ui.post(f"/ui/estimates/{eid}/vat", data={"csrf_token": t, "vat": bad}, headers=hx)
assert r.status_code == 422 and r.headers["HX-Retarget"] == "#flash", bad
page = ui.post("/ui/estimates", data={"requirements": "бот", "vat": "0.2", "csrf_token": page_token(ui)})
assert page.status_code == 422 and "Ставка НДС 20% не разрешена" in page.text and "22%" in page.text
assert "not allowed" not in page.text # the message is shown in Russian
def test_vat_switch_requires_csrf(ui):
eid = create_via_ui(ui)
wait_done(ui, eid)
assert ui.post(f"/ui/estimates/{eid}/vat", data={"vat": "0"}).status_code == 403
def test_time_and_materials_shows_vat_on_the_amount_and_the_ceiling(ui):
html = wait_done(ui, create_via_ui(ui, "бот", engagement="time_and_materials"))
assert "С НДС 22%: ожидаемо 409\u202f920\u00a0₽, потолок 451\u202f400\u00a0₽" in html
def test_market_check_card_says_what_it_compares(ui):
html = wait_done(ui, create_via_ui(ui))
assert "ценой с резервом без НДС" in html and "(без НДС)" in html
# ================================================================== audit trail, preliminary, references
def test_the_page_and_the_history_show_who_did_what(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as alex, make_ui(monkeypatch, dsn) as bob:
login(alex, "alex")
login(bob, "bob")
eid = create_via_ui(alex)
wait_done(alex, eid)
t = page_token(bob, f"/ui/estimates/{eid}")
assert bob.post(f"/ui/estimates/{eid}/engagement", data={"csrf_token": t, "engagement": "time_and_materials"}).status_code == 303
page = bob.get(f"/ui/estimates/{eid}").text
assert re.search(r"создана [\d.: ]+, alex", page) and "версия 2: смена модели оплаты, bob" in page
assert "версия 1: расчёт агента, alex" in bob.get(f"/ui/estimates/{eid}?version=1").text
history = bob.get("/ui/estimates").text
assert "<th>Автор</th>" in history and "<td>alex</td>" in history # the creator of the estimate, not the editor
def test_each_ui_user_has_their_own_internal_identity(monkeypatch, dsn):
with make_ui(monkeypatch, dsn) as c:
tokens = c.app.state.ui_tokens
assert set(tokens) == {"alex", "bob"} and len(set(tokens.values())) == 2
principals = {p.user: p.client for p in c.app.state.internal_keys.values()}
assert principals == {"alex": "ui", "bob": "ui"} # one shared workspace, two people
with make_ui(monkeypatch, dsn, EST_WEB__WORKSPACE="per_user") as c:
assert {p.user: p.client for p in c.app.state.internal_keys.values()} == {"alex": "ui:alex", "bob": "ui:bob"}
def test_an_estimate_on_assumptions_is_marked_preliminary_in_the_page_and_the_history(monkeypatch, dsn):
gw = AutoGateway(clarify=[clarify_out([q("crm", "Какая CRM?", blocking=True)])])
with make_ui(monkeypatch, dsn, gw) as c:
login(c)
eid = create_via_ui(c, "бот", proceed="1")
html = wait_done(c, eid)
assert "Предварительная оценка." in html and "Не уточнено: Какая CRM?" in html
assert "предварительная" in c.get("/ui/estimates").text
with make_ui(monkeypatch, dsn) as c:
login(c)
done = wait_done(c, create_via_ui(c)) # a complete estimate in the same database
assert "Предварительная оценка." not in done
assert c.get("/ui/estimates").text.count("предварительная") == 1 # only the first estimate carries the badge
def test_references_are_shown_under_the_task_and_are_escaped(monkeypatch, backend_dsn):
from tests.rag_helpers import RAG_ENV, load_corpus
evil = "<script>alert('ref')</script>"
load_corpus(backend_dsn, [
{"project": "P1", "title": "Интеграция с amoCRM", "role": "backend", "hours": "21", "hours_kind": "actual"},
{"project": f"P2 {evil}", "title": f"Интеграция amoCRM {evil}", "role": "backend", "hours": "9", "hours_kind": "estimate"},
]) # fmt: skip
with make_ui(monkeypatch, backend_dsn, **RAG_ENV) as c:
login(c)
html = wait_done(c, create_via_ui(c))
assert "Аналоги из истории" in html
assert "Интеграция с amoCRM: 21\u00a0ч, факт, P1, сходство" in html
assert ", оценка, " in html # an estimate is labelled differently from a measured value
page = c.get(f"/ui/estimates/{html.split('/ui/estimates/')[1].split(chr(34))[0].split('/')[0]}").text if False else html
assert evil not in page and "&lt;script&gt;alert(&#39;ref&#39;)&lt;/script&gt;" in page
assert "<script>alert" not in page
def test_no_references_block_when_retrieval_is_off(ui):
html = wait_done(ui, create_via_ui(ui))
assert "Аналоги из истории" not in html