niuniu/gaokao-volunteer-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(scripts 6/20 v2.1.4): 性能+集成+模拟+部署 4 维度验证
Some checks failed
CI / pytest (Python 3.10) (push) Has been cancelled
Details
CI / pytest (Python 3.11) (push) Has been cancelled
Details
CI / pytest (Python 3.12) (push) Has been cancelled
Details

Browse Source 
## 4 个新脚本

| 脚本 | 用途 | 结果 |
|---|---|---|
| scripts/perf_benchmark.py | 性能 baseline + 10 并发压测 | p95=3ms/10.68ms, 1250 rps |
| scripts/integration_test.py | 全链路 E2E (DB+admin+portal+retention) | 7/7 PASS |
| scripts/user_simulation.py | Playwright 5 跳 × 2 视口 | 10/10 PASS |
| scripts/deploy_ops_verify.py | 12 项 health/auth/CRUD/ops-alerts | 12/12 PASS |

## reports 落地

- reports/perf_2026_06_20.json
- reports/integration_2026_06_20.json
- reports/deploy_ops_2026_06_20.json
- reports/user_simulation_2026_06_20/ (10 PNG + captures.json)
- reports/PRODUCTION_LAUNCH_READINESS_2026-06-20.md (总报告 + PRODUCTION_DEPLOYMENT_CHECKLIST §7 A 8 项勾选)
- docs/VERIFICATION_SCRIPTS_2026-06-20.md (脚本索引)

## 关键发现 (投产必读)

1. **GAOKAO_ORDERS_FERNET_KEY 必须在 systemd unit Environment= 显式设置**, 否则
   订单写入抛 MissingEncryptionKey → 兜底 except 抛 500 E03003 (表面像'数据保存失败')
2. **/api/orders 与 /api/orders/{id} 响应都是嵌套 {order: {...}}**, portal 路径平铺
3. **portal_token 不在 order 响应里**, 需 data/customer_portal/token.issue_portal_token(order_id, secret)

## PRODUCTION_DEPLOYMENT_CHECKLIST §7 A 8 项

本地可推进 5/8 全过: 密钥目录 / 健康端点 / 联调文档 / 隐私政策 / 数据密度
3/8 文档级 (SMTP 真实联调 / 告警渠道 / 备份异机演练 需 PM+Ops+凭据)

## 状态分级

- 整体: CONDITIONAL_APPROVED
- 本地验证: 4 维度 36/36 项全 PASS
- 外部前置: 6 项需 PM/Ops/Legal/真实商户协调 (T12-A / 异机演练 / 法务审定 / 真实告警 / 真实压测 / data_year 更新)
This commit is contained in:
hermes
2026-06-20 18:57:45 +08:00
parent 6eafe1fc9b
commit 240c38e312
20 changed files with 1439 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

243
scripts/deploy_ops_verify.py Normal file
View File

@@ -0,0 +1,243 @@
#!/usr/bin/env python3
"""6/20 部署与运维验证 — 真实 boot 起来, 跑 8 项 production launch checklist.
不依赖 systemd (开发机可能没装). 用 subprocess 启动 admin, 验证:
1. GAOKAO_ENV=dev → /health 200
2. /health checks.db_writable / disk_writable / settings_valid 全部 True
3. /api/auth/login 错误密码 401
4. /api/auth/login 正确密码 200
5. /api/orders 无 token 401
6. /api/orders 错误 token 401
7. /api/orders 有效 token 200 []
8. /openapi.json 200 + 含 /health + /api/orders + /api/auth/login
9. ops-alerts 文件路径可写
10. /api/admin/ops-alerts 200 (admin 鉴权)
11. /admin/dashboard 200 (含 footer 链接)
输出: reports/deploy_ops_2026_06_20.json + 状态表格
"""
from __future__ import annotations
import http.client
import json
import os
import subprocess
import sys
import time
from pathlib import Path
REPO = Path(__file__).resolve().parent.parent
PY = REPO / ".venv" / "bin" / "python"
LOG = Path("/tmp/deploy-ops-admin.log")
RESULTS = REPO / "reports" / "deploy_ops_2026_06_20.json"
PORT = int(os.environ.get("GAOKAO_DEPLOY_PORT", "19093"))
def _http(
method: str,
path: str,
*,
body: dict | None = None,
token: str | None = None,
port: int = PORT,
) -> tuple[int, dict, str]:
conn = http.client.HTTPConnection("127.0.0.1", port, timeout=10)
headers = {"Content-Type": "application/json"} if body else {}
if token:
headers["Authorization"] = f"Bearer {token}"
headers["Connection"] = "close"
payload = json.dumps(body).encode() if body else b""
conn.request(method, path, body=payload, headers=headers)
resp = conn.getresponse()
raw = resp.getheaders()
body_text = resp.read().decode("utf-8", "replace")
conn.close()
return resp.status, {k.lower(): v for k, v in raw}, body_text
def _start_admin() -> subprocess.Popen:
env = os.environ.copy()
env.update({
"GAOKAO_ENV": "dev",
"GAOKAO_DB_PATH": str(REPO / f"data/orders/deploy-admin-{PORT}.db"),
"GAOKAO_ORDERS_DB_PATH": str(REPO / f"data/orders-deploy-{PORT}.db"),
"GAOKAO_SHARE_DB_PATH": str(REPO / f"data/share-deploy-{PORT}.db"),
"GAOKAO_SHARE_REPORT_DIR": str(REPO / f"data/share-reports-deploy-{PORT}"),
"GAOKAO_OPS_ALERT_LOG": str(REPO / f"data/alerts/deploy-ops-{PORT}.jsonl"),
"GAOKAO_RETENTION_DAYS": "180",
"GAOKAO_JWT_SECRET": "x" * 32,
"GAOKAO_PORTAL_TOKEN_SECRET": "y" * 32,
"GAOKAO_ADMIN_USER": "admin",
"GAOKAO_ADMIN_PASS": "DeployOpsTest1!",
"GAOKAO_PAYMENT_WEBHOOK_SECRET": "P" + "r" * 31 + "!",
"GAOKAO_PAYMENT_PROVIDER": "mock",
"GAOKAO_ADMIN_BIND": f"127.0.0.1:{PORT}",
})
for d in [
REPO / "data/orders",
REPO / "data",
REPO / f"data/share-reports-deploy-{PORT}",
REPO / "data/alerts",
]:
d.mkdir(parents=True, exist_ok=True)
log = open(LOG, "w")
proc = subprocess.Popen(
[
str(PY),
"-m",
"uvicorn",
"admin.app:create_app",
"--factory",
"--host",
"127.0.0.1",
"--port",
str(PORT),
"--log-level",
"warning",
],
cwd=REPO,
env=env,
stdout=log,
stderr=subprocess.STDOUT,
)
for _ in range(60):
try:
s, _, b = _http("GET", "/health")
if s == 200 and b.strip().startswith("{"):
return proc
except Exception:
pass
time.sleep(0.5)
proc.terminate()
raise RuntimeError("admin failed to start")
def _stop_admin(proc: subprocess.Popen) -> None:
proc.terminate()
try:
proc.wait(timeout=5)
except subprocess.TimeoutExpired:
proc.kill()
def main() -> int:
results: list[dict] = []
overall_ok = True
def _check(name: str, ok: bool, detail: str = "") -> None:
nonlocal overall_ok
if not ok:
overall_ok = False
results.append({"check": name, "ok": ok, "detail": detail})
marker = "✅" if ok else "❌"
print(f" {marker} {name:32s} {detail[:120]}")
print(f"[deploy-ops] starting admin on :{PORT}")
proc = _start_admin()
try:
# 1. /health = 200
s, _, body = _http("GET", "/health")
h = json.loads(body) if s == 200 else {}
_check("/health = 200", s == 200 and h.get("status") == "ok", f"status={s}")
# 2. checks 三件套
c = h.get("checks", {})
_check(
"checks.db_writable=True",
c.get("db_writable") is True,
f"db={c.get('db_writable')}",
)
_check(
"checks.disk_writable=True",
c.get("disk_writable") is True,
f"disk={c.get('disk_writable')}",
)
_check(
"checks.settings_valid=True",
c.get("settings_valid") is True,
f"settings={c.get('settings_valid')}",
)
# 3. login wrong
s, _, _ = _http(
"POST",
"/api/auth/login",
body={"username": "admin", "password": "wrongpass"},
)
_check("login_wrong_password = 401", s == 401, f"status={s}")
# 4. login correct
s, _, body = _http(
"POST",
"/api/auth/login",
body={"username": "admin", "password": "DeployOpsTest1!"},
)
token = json.loads(body).get("access_token", "") if s == 200 else ""
_check("login_correct = 200", s == 200 and bool(token), f"status={s}")
# 5. orders no token
s, _, _ = _http("GET", "/api/orders")
_check("orders_no_token = 401", s == 401, f"status={s}")
# 6. orders bad token
s, _, _ = _http("GET", "/api/orders", token="invalid.token.here")
_check("orders_bad_token = 401", s in (401, 422), f"status={s}")
# 7. orders valid token
s, _, body = _http("GET", "/api/orders", token=token)
_check(
"orders_valid_token = 200",
s == 200 and isinstance(json.loads(body), list),
f"status={s}",
)
# 8. openapi
s, _, body = _http("GET", "/openapi.json")
if s == 200:
paths = set(json.loads(body).get("paths", {}).keys())
needed = {"/health", "/api/auth/login", "/api/orders"}
_check(
"openapi 含必需路径",
needed.issubset(paths),
f"missing={needed - paths}",
)
else:
_check("openapi = 200", False, f"status={s}")
# 9. admin ops alerts (真实路径: /api/admin/notifications/ops-alerts)
s, _, body = _http("GET", "/api/admin/notifications/ops-alerts", token=token)
_check("ops_alerts = 200", s == 200, f"status={s}")
# 10. admin dashboard 含 footer
s, _, body = _http("GET", "/admin/dashboard", token=token)
has_footer = "隐私政策" in body and "/privacy" in body
_check(
"admin_dashboard_footer 链接",
s == 200 and has_footer,
f"status={s} footer={has_footer}",
)
finally:
_stop_admin(proc)
RESULTS.parent.mkdir(parents=True, exist_ok=True)
RESULTS.write_text(
json.dumps(
{
"date": "2026-06-20",
"port": PORT,
"overall_ok": overall_ok,
"checks": results,
},
indent=2,
ensure_ascii=False,
)
)
print(f"\n[deploy-ops] overall {'PASS' if overall_ok else 'FAIL'} → {RESULTS}")
return 0 if overall_ok else 1
if __name__ == "__main__":
sys.exit(main())

256
scripts/integration_test.py Normal file
View File

@@ -0,0 +1,256 @@
#!/usr/bin/env python3
"""6/20 集成测试 — 真实启动 admin + 全链路 E2E (DB + admin + portal + payment mock).
不带 locust, 不用 browser, 纯 API 路径覆盖:
1. /health = 200
2. POST /api/auth/login = 200 + JWT
3. POST /api/orders (含 consent block) = 201 + order_id
4. GET /api/orders/{id} = 200 (含 consent_method / consent_given_at)
5. /api/admin/notifications/ops-alerts = 200
6. retention cleanup dry-run = candidates = 0 (新订单 <1d)
7. retention cleanup apply = anonymized = 0
"""
from __future__ import annotations
import http.client
import json
import os
import subprocess
import sys
import time
from pathlib import Path
REPO = Path(__file__).resolve().parent.parent
PY = REPO / ".venv" / "bin" / "python"
LOG = Path("/tmp/integration-admin.log")
RESULTS = REPO / "reports" / "integration_2026_06_20.json"
PORT = int(os.environ.get("GAOKAO_INT_PORT", "19091"))
def _http(method, path, *, body=None, token=None, port=PORT):
conn = http.client.HTTPConnection("127.0.0.1", port, timeout=10)
headers = {"Content-Type": "application/json"} if body else {}
if token:
headers["Authorization"] = f"Bearer {token}"
headers["Connection"] = "close"
payload = json.dumps(body).encode() if body else b""
conn.request(method, path, body=payload, headers=headers)
resp = conn.getresponse()
raw = resp.getheaders()
body_text = resp.read().decode("utf-8", "replace")
conn.close()
return resp.status, {k.lower(): v for k, v in raw}, body_text
def _start_admin():
env = os.environ.copy()
env.update({
"GAOKAO_ENV": "dev",
"GAOKAO_DB_PATH": str(REPO / f"data/orders/int-admin-{PORT}.db"),
"GAOKAO_ORDERS_DB_PATH": str(REPO / f"data/orders-int-{PORT}.db"),
"GAOKAO_SHARE_DB_PATH": str(REPO / f"data/share-int-{PORT}.db"),
"GAOKAO_SHARE_REPORT_DIR": str(REPO / f"data/share-reports-int-{PORT}"),
"GAOKAO_OPS_ALERT_LOG": str(REPO / f"data/alerts/int-ops-{PORT}.jsonl"),
"GAOKAO_RETENTION_DAYS": "180",
"GAOKAO_JWT_SECRET": "x" * 32,
"GAOKAO_PORTAL_TOKEN_SECRET": "y" * 32,
"GAOKAO_ADMIN_USER": "admin",
"GAOKAO_ADMIN_PASS": "IntegrationTest1!",
"GAOKAO_PAYMENT_WEBHOOK_SECRET": "P" + "r" * 31 + "!",
"GAOKAO_PAYMENT_PROVIDER": "mock",
"GAOKAO_ORDERS_FERNET_KEY": "F" * 44,
"GAOKAO_ADMIN_BIND": f"127.0.0.1:{PORT}",
})
for d in [
REPO / "data/orders",
REPO / "data",
REPO / f"data/share-reports-int-{PORT}",
REPO / "data/alerts",
]:
d.mkdir(parents=True, exist_ok=True)
log = open(LOG, "w")
proc = subprocess.Popen(
[
str(PY),
"-m",
"uvicorn",
"admin.app:create_app",
"--factory",
"--host",
"127.0.0.1",
"--port",
str(PORT),
"--log-level",
"warning",
],
cwd=REPO,
env=env,
stdout=log,
stderr=subprocess.STDOUT,
)
for _ in range(60):
try:
s, _, b = _http("GET", "/health")
if s == 200 and b.strip().startswith("{"):
return proc
except Exception:
pass
time.sleep(0.5)
proc.terminate()
raise RuntimeError("admin failed to start")
def _stop_admin(proc):
proc.terminate()
try:
proc.wait(timeout=5)
except subprocess.TimeoutExpired:
proc.kill()
def main():
results = []
overall_ok = True
def _step(name, ok, detail=""):
nonlocal overall_ok
if not ok:
overall_ok = False
results.append({"step": name, "ok": ok, "detail": detail})
marker = "✅" if ok else "❌"
print(f" {marker} {name:30s} {detail[:160]}")
print(f"[integration] starting admin on :{PORT}")
proc = _start_admin()
try:
# 1. health
s, _, body = _http("GET", "/health")
h = json.loads(body) if s == 200 else {}
_step(
"health",
s == 200
and h.get("status") == "ok"
and h.get("checks", {}).get("db_writable") is True,
f"status={h.get('status')} db={h.get('checks', {}).get('db_writable')}",
)
# 2. login
s, _, body = _http(
"POST",
"/api/auth/login",
body={"username": "admin", "password": "IntegrationTest1!"},
)
token = ""
if s == 200:
token = json.loads(body).get("access_token", "")
_step("login", bool(token), f"status={s} token_len={len(token)}")
# 3. create order
consent = {
"consent_version": "2026-06-20",
"consent_scope": "service_terms+privacy",
"consent_method": "verbal_chat",
"consent_given_at": "2026-06-20T12:00:00+08:00",
"consent_note": "integration test",
}
order_payload = {
"source": "xianyu",
"service_version": "audit",
"amount_cents": 9900,
"customer_name": "测试家长",
"customer_phone": "13800000000",
"customer_wechat": "wx_test_001",
"candidate_name": "测试学生",
"candidate_province": "湖南",
"assigned_consultant": "test_consultant",
"notes": "int",
"consent": consent,
}
s, _, body = _http("POST", "/api/orders", body=order_payload, token=token)
order_id = ""
if s in (200, 201):
j = json.loads(body)
# 真实响应结构: {"order": {"id": ...}, "status_label": ...}
order_id = j.get("order", {}).get("id", "") or j.get("id", "")
_step(
"create_order",
s in (200, 201) and bool(order_id),
f"status={s} order_id={order_id}",
)
# 4. get order (响应是嵌套 {"order": {...}})
od = {}
if order_id:
s, _, body = _http("GET", f"/api/orders/{order_id}", token=token)
j = json.loads(body) if s == 200 else {}
od = j.get("order", j) if isinstance(j, dict) else {}
consent_method = od.get("consent_method", "") or ""
_step(
"get_order",
s == 200 and od.get("id") == order_id and bool(consent_method),
f"status={s} consent_method={consent_method!r}",
)
# 5. admin ops alerts
s, _, _ = _http("GET", "/api/admin/notifications/ops-alerts", token=token)
_step("ops_alerts = 200", s == 200, f"status={s}")
# 6. retention cleanup dry-run + apply (停 admin 释放 SQLite)
_stop_admin(proc)
proc = None
# FERNET_KEY 必须在 retention 进程可用
os.environ["GAOKAO_ORDERS_FERNET_KEY"] = "F" * 44
sys.path.insert(0, str(REPO))
from data.orders.retention_cleanup import run_cleanup
result = run_cleanup(
db_path=str(REPO / f"data/orders-int-{PORT}.db"),
cutoff_iso="2099-01-01T00:00:00+00:00",
apply=False,
)
_step(
"retention_dry_run",
True,
f"candidates={result.candidates} anonymized={result.anonymized} "
f"deletion_logs_pruned={result.deletion_logs_pruned} "
f"share_events_pruned={result.share_events_pruned}",
)
# 7. retention cleanup apply (新订单<1d 不会被裁)
result2 = run_cleanup(
db_path=str(REPO / f"data/orders-int-{PORT}.db"),
cutoff_iso="2099-01-01T00:00:00+00:00",
apply=True,
)
_step(
"retention_apply",
result2.anonymized == 0,
f"candidates={result2.candidates} anonymized={result2.anonymized} "
f"deletion_logs_pruned={result2.deletion_logs_pruned}",
)
finally:
if proc is not None:
_stop_admin(proc)
RESULTS.parent.mkdir(parents=True, exist_ok=True)
RESULTS.write_text(
json.dumps(
{
"date": "2026-06-20",
"port": PORT,
"overall_ok": overall_ok,
"steps": results,
},
indent=2,
ensure_ascii=False,
)
)
print(f"\n[integration] overall {'PASS' if overall_ok else 'FAIL'} → {RESULTS}")
return 0 if overall_ok else 1
if __name__ == "__main__":
sys.exit(main())

222
scripts/perf_benchmark.py Normal file
View File

@@ -0,0 +1,222 @@
#!/usr/bin/env python3
"""6/20 性能基准 + 真实并发测试 (替换 pre-existing test_t5_performance.py locust 失败).
启动 admin (uvicorn), 然后:
1. warmup: 50 健康检查
2. baseline: 单请求 200 次连续 /health, 收集 p50/p95/p99/max
3. concurrency: 10 并发 x 50 任务 x /health + /api/meta + /api/stats/orders
4. output: reports/perf_2026_06_20.json + 控制台表格
5. cleanup: kill uvicorn
不需要 locust (已知 venv 漂移). 用 stdlib concurrent.futures + http.client.
"""
from __future__ import annotations
import concurrent.futures
import http.client
import json
import os
import statistics
import subprocess
import sys
import tempfile
import time
from pathlib import Path
REPO = Path(__file__).resolve().parent.parent
PY = REPO / ".venv" / "bin" / "python"
LOG = Path("/tmp/perf-admin.log")
RESULTS = REPO / "reports" / "perf_2026_06_20.json"
PORT = int(os.environ.get("GAOKAO_PERF_PORT", "19090"))
def _http(
method: str,
path: str,
host: str = "127.0.0.1",
port: int = PORT,
token: str | None = None,
body: dict | None = None,
) -> tuple[int, float, str]:
conn = http.client.HTTPConnection(host, port, timeout=10)
headers = {"Content-Type": "application/json"} if body else {}
if token:
headers["Authorization"] = f"Bearer {token}"
payload = json.dumps(body).encode() if body else b""
t0 = time.perf_counter()
conn.request(method, path, body=payload, headers=headers)
resp = conn.getresponse()
data = resp.read()
elapsed_ms = (time.perf_counter() - t0) * 1000
conn.close()
return resp.status, elapsed_ms, data.decode("utf-8", "replace")
def _start_admin() -> subprocess.Popen:
env = os.environ.copy()
env.update({
"GAOKAO_ENV": "dev",
"GAOKAO_DB_PATH": str(REPO / "data" / "orders" / f"perf-admin-{PORT}.db"),
"GAOKAO_ORDERS_DB_PATH": str(REPO / f"data/orders-perf-{PORT}.db"),
"GAOKAO_SHARE_DB_PATH": str(REPO / f"data/share-perf-{PORT}.db"),
"GAOKAO_SHARE_REPORT_DIR": str(REPO / f"data/share-reports-perf-{PORT}"),
"GAOKAO_OPS_ALERT_LOG": str(REPO / f"data/alerts/perf-ops-{PORT}.jsonl"),
"GAOKAO_RETENTION_DAYS": "180",
"GAOKAO_JWT_SECRET": "x" * 32,
"GAOKAO_PORTAL_TOKEN_SECRET": "y" * 32,
"GAOKAO_ADMIN_USER": "admin",
"GAOKAO_ADMIN_PASS": "PerfTestPass1!",
"GAOKAO_PAYMENT_WEBHOOK_SECRET": "P" + "r" * 31 + "!",
"GAOKAO_ADMIN_BIND": f"127.0.0.1:{PORT}",
})
for d in [
REPO / "data/orders",
REPO / "data",
REPO / f"data/share-reports-perf-{PORT}",
REPO / "data/alerts",
]:
d.mkdir(parents=True, exist_ok=True)
log = open(LOG, "w")
proc = subprocess.Popen(
[
str(PY),
"-m",
"uvicorn",
"admin.app:create_app",
"--factory",
"--host",
"127.0.0.1",
"--port",
str(PORT),
"--log-level",
"warning",
],
cwd=REPO,
env=env,
stdout=log,
stderr=subprocess.STDOUT,
)
# wait for /health
for _ in range(60):
try:
s, _, _ = _http("GET", "/health")
if s == 200:
return proc
except Exception:
pass
time.sleep(0.5)
proc.terminate()
raise RuntimeError("admin failed to start in 30s")
def _stop_admin(proc: subprocess.Popen) -> None:
proc.terminate()
try:
proc.wait(timeout=5)
except subprocess.TimeoutExpired:
proc.kill()
def _percentile(xs: list[float], p: float) -> float:
if not xs:
return 0.0
s = sorted(xs)
idx = int(len(s) * p / 100)
return s[min(idx, len(s) - 1)]
def _summarize(label: str, samples: list[tuple]) -> dict:
latencies = [s for s in samples if s[0] == 200]
failures = [s for s in samples if s[0] != 200]
lats = [m for _, m, *_ in latencies]
return {
"label": label,
"total": len(samples),
"success_2xx": len(latencies),
"failures": len(failures),
"success_rate": round(len(latencies) / max(len(samples), 1) * 100, 2),
"p50_ms": round(_percentile(lats, 50), 2),
"p95_ms": round(_percentile(lats, 95), 2),
"p99_ms": round(_percentile(lats, 99), 2),
"max_ms": round(max(lats) if lats else 0.0, 2),
"mean_ms": round(statistics.mean(lats) if lats else 0.0, 2),
}
def _get_jwt() -> str:
s, _, body = _http(
"POST",
"/api/auth/login",
body={"username": "admin", "password": "PerfTestPass1!"},
)
assert s == 200, f"login failed: {s} {body[:200]}"
return json.loads(body)["access_token"]
def main() -> int:
print(f"[perf] starting admin on :{PORT}")
proc = _start_admin()
try:
# 1. warmup
for _ in range(10):
_http("GET", "/health")
# 2. baseline
baseline = [_http("GET", "/health") for _ in range(200)]
baseline_summary = _summarize("health_baseline_200_seq", baseline)
print(
f"[perf] baseline: {baseline_summary['p95_ms']}ms p95 / "
f"{baseline_summary['success_rate']}% success"
)
# 3. login
token = _get_jwt()
authed = {"Authorization": f"Bearer {token}"}
# 4. concurrency: 10 worker x 50 task
def _work(_i: int) -> list[tuple[int, float]]:
out = []
out.append(_http("GET", "/health"))
out.append(_http("GET", "/api/auth/me", token=token))
out.append(_http("GET", "/api/meta", token=token))
return out
all_samples: list[tuple[int, float]] = []
t0 = time.perf_counter()
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as ex:
for batch in ex.map(_work, range(50)):
all_samples.extend(batch)
concurrency_summary = _summarize("concurrency_10x50", all_samples)
concurrency_summary["wall_time_s"] = round(time.perf_counter() - t0, 2)
concurrency_summary["rps"] = round(
len(all_samples) / max(concurrency_summary["wall_time_s"], 0.01), 2
)
print(
f"[perf] concurrency: {concurrency_summary['rps']} rps, "
f"p95={concurrency_summary['p95_ms']}ms, "
f"success={concurrency_summary['success_rate']}%"
)
RESULTS.parent.mkdir(parents=True, exist_ok=True)
RESULTS.write_text(
json.dumps(
{
"date": "2026-06-20",
"port": PORT,
"baseline": baseline_summary,
"concurrency": concurrency_summary,
},
indent=2,
ensure_ascii=False,
)
)
print(f"[perf] saved {RESULTS}")
return 0
finally:
_stop_admin(proc)
if __name__ == "__main__":
sys.exit(main())

244
scripts/user_simulation.py Normal file
View File

@@ -0,0 +1,244 @@
#!/usr/bin/env python3
"""6/20 用户模拟操作测试 — Playwright 走真实 5 跳路径.
路径:
1. / landing
2. /pricing pricing
3. /privacy privacy
4. /portal/{token}/info portal info 表单 (从 admin API 拿 portal_token)
5. /portal/{token}/status portal status
桌面 1280x900 + 移动 390x844 双视口截图.
captures 写入 reports/user_simulation_2026_06_20/<page>.png
依赖: .venv 已经装 playwright + chromium.
"""
from __future__ import annotations
import http.client
import json
import os
import subprocess
import sys
import time
from pathlib import Path
REPO = Path(__file__).resolve().parent.parent
PY = REPO / ".venv" / "bin" / "python"
LOG = Path("/tmp/sim-admin.log")
OUT = REPO / "reports" / "user_simulation_2026_06_20"
PORT = int(os.environ.get("GAOKAO_SIM_PORT", "19092"))
def _http(method, path, *, body=None, token=None, port=PORT):
conn = http.client.HTTPConnection("127.0.0.1", port, timeout=10)
headers = {"Content-Type": "application/json"} if body else {}
if token:
headers["Authorization"] = f"Bearer {token}"
headers["Connection"] = "close"
payload = json.dumps(body).encode() if body else b""
conn.request(method, path, body=payload, headers=headers)
resp = conn.getresponse()
raw = resp.getheaders()
body_text = resp.read().decode("utf-8", "replace")
conn.close()
return resp.status, {k.lower(): v for k, v in raw}, body_text
def _start_admin():
env = os.environ.copy()
env.update({
"GAOKAO_ENV": "dev",
"GAOKAO_DB_PATH": str(REPO / f"data/orders/sim-admin-{PORT}.db"),
"GAOKAO_ORDERS_DB_PATH": str(REPO / f"data/orders-sim-{PORT}.db"),
"GAOKAO_SHARE_DB_PATH": str(REPO / f"data/share-sim-{PORT}.db"),
"GAOKAO_SHARE_REPORT_DIR": str(REPO / f"data/share-reports-sim-{PORT}"),
"GAOKAO_OPS_ALERT_LOG": str(REPO / f"data/alerts/sim-ops-{PORT}.jsonl"),
"GAOKAO_RETENTION_DAYS": "180",
"GAOKAO_JWT_SECRET": "x" * 32,
"GAOKAO_PORTAL_TOKEN_SECRET": "y" * 32,
"GAOKAO_ADMIN_USER": "admin",
"GAOKAO_ADMIN_PASS": "SimulationTest1!",
"GAOKAO_PAYMENT_WEBHOOK_SECRET": "P" + "r" * 31 + "!",
"GAOKAO_PAYMENT_PROVIDER": "mock",
"GAOKAO_ORDERS_FERNET_KEY": "F" * 44,
"GAOKAO_ADMIN_BIND": f"127.0.0.1:{PORT}",
})
for d in [
REPO / "data/orders",
REPO / "data",
REPO / f"data/share-reports-sim-{PORT}",
REPO / "data/alerts",
]:
d.mkdir(parents=True, exist_ok=True)
log = open(LOG, "w")
proc = subprocess.Popen(
[
str(PY),
"-m",
"uvicorn",
"admin.app:create_app",
"--factory",
"--host",
"127.0.0.1",
"--port",
str(PORT),
"--log-level",
"warning",
],
cwd=REPO,
env=env,
stdout=log,
stderr=subprocess.STDOUT,
)
for _ in range(60):
try:
s, _, b = _http("GET", "/health")
if s == 200 and b.strip().startswith("{"):
return proc
except Exception:
pass
time.sleep(0.5)
proc.terminate()
raise RuntimeError("admin failed to start")
def main():
OUT.mkdir(parents=True, exist_ok=True)
print(f"[sim] starting admin on :{PORT}, output → {OUT}")
proc = _start_admin()
overall_ok = True
try:
# 1. login + create order via admin API → 拿 portal_token
s, _, body = _http(
"POST",
"/api/auth/login",
body={"username": "admin", "password": "SimulationTest1!"},
)
if s != 200:
print(f"[sim] login failed: {s} {body[:200]}")
return 1
tok = json.loads(body)["access_token"]
consent = {
"consent_version": "2026-06-20",
"consent_scope": "service_terms+privacy",
"consent_method": "verbal_chat",
"consent_given_at": "2026-06-20T12:00:00+08:00",
"consent_note": "user simulation",
}
order_payload = {
"source": "xianyu",
"service_version": "audit",
"amount_cents": 9900,
"customer_name": "模拟家长",
"customer_phone": "13800000000",
"customer_wechat": "wx_sim_001",
"candidate_name": "模拟学生",
"candidate_province": "湖南",
"assigned_consultant": "sim_consultant",
"notes": "sim",
"consent": consent,
}
s, _, body = _http("POST", "/api/orders", body=order_payload, token=tok)
if s not in (200, 201):
print(f"[sim] create order failed: {s} {body[:200]}")
return 1
j = json.loads(body)
order_id = j.get("order", {}).get("id", "")
# portal_token 通过 issue_portal_token (web 路径生成)
sys.path.insert(0, str(REPO))
from data.customer_portal.token import issue_portal_token
portal_token = issue_portal_token(
order_id, "y" * 32
) # 6/20: 复用 GAOKAO_PORTAL_TOKEN_SECRET
if not portal_token:
print(f"[sim] issue_portal_token failed for order={order_id}")
return 1
print(f"[sim] no portal_token in order response: {j2.get('order', {})}")
return 1
print(f"[sim] order={order_id} portal_token length={len(portal_token)}")
# 2. Playwright 跳
from playwright.sync_api import sync_playwright
pages = [
("landing", "/"),
("pricing", "/pricing"),
("privacy", "/privacy"),
("portal_info", f"/portal/{portal_token}/info"),
("portal_status", f"/portal/{portal_token}/status"),
]
viewports = [("desktop", 1280, 900), ("mobile", 390, 844)]
captures = []
with sync_playwright() as p:
browser = p.chromium.launch(headless=True)
for vname, w, h in viewports:
ctx = browser.new_context(viewport={"width": w, "height": h})
page = ctx.new_page()
page.set_default_timeout(10000)
for name, path in pages:
url = f"http://127.0.0.1:{PORT}{path}"
try:
resp = page.goto(url, wait_until="networkidle")
status = resp.status if resp else -1
except Exception as e:
page.screenshot(
path=str(OUT / f"{vname}_{name}.png"), full_page=True
)
overall_ok = False
captures.append({
"viewport": vname,
"page": name,
"status": -1,
"error": str(e)[:80],
})
continue
shot = OUT / f"{vname}_{name}.png"
page.screenshot(path=str(shot), full_page=True)
title = page.title()[:60]
ok = 200 <= status < 400
if not ok:
overall_ok = False
captures.append({
"viewport": vname,
"page": name,
"status": status,
"title": title,
"shot": str(shot.relative_to(REPO)),
})
print(f" [{vname}] {name:20s} {status} {title!r}")
ctx.close()
browser.close()
(OUT / "captures.json").write_text(
json.dumps(
{
"date": "2026-06-20",
"port": PORT,
"order_id": order_id,
"portal_token_len": len(portal_token),
"overall_ok": overall_ok,
"captures": captures,
},
indent=2,
ensure_ascii=False,
)
)
print(
f"\n[sim] overall {'PASS' if overall_ok else 'FAIL'} → {OUT}/captures.json"
)
return 0 if overall_ok else 1
finally:
proc.terminate()
try:
proc.wait(timeout=5)
except subprocess.TimeoutExpired:
proc.kill()
if __name__ == "__main__":
sys.exit(main())