2031 lines
82 KiB
Python
2031 lines
82 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
"""默认测试套件：合同到期智能预警与续聘辅助。
|
||
|
||
设计原则：
|
||
- 仅用标准库（不依赖 pytest / jinja2），CI 与本地均能直接 `python tests/run_tests.py` 跑
|
||
- 用 sqlite3 ":memory:" 隔离 DB，不污染仓库 data/ 目录
|
||
- 覆盖：util.date_util 纯函数 / util.constants 版本对齐 / repository 新增功能
|
||
（parse_sandbox_card_performance + upsert_performance_record）/ scanner 分级 / task_generator
|
||
规则版 / html_renderer 降级路径
|
||
- 退出码：0 = 全部通过，1 = 有失败
|
||
- -v 开关：详细输出每个用例的状态
|
||
|
||
release.ps1 在打 tag 前会自动跑 `python tests/run_tests.py -v`，任何一个
|
||
test_* 返回 (False, msg) 即 abort 发布。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import json
|
||
import os
|
||
import re
|
||
import shutil
|
||
import sqlite3
|
||
import sys
|
||
import tempfile
|
||
import traceback
|
||
from datetime import date
|
||
from pathlib import Path
|
||
from types import SimpleNamespace
|
||
from typing import Any, Callable
|
||
|
||
# 让 scripts/ 下的模块可导入
|
||
_REPO_ROOT = Path(__file__).resolve().parent.parent
|
||
_SCRIPTS_DIR = _REPO_ROOT / "scripts"
|
||
sys.path.insert(0, str(_SCRIPTS_DIR))
|
||
|
||
|
||
# ---------- 测试基础设施 ----------
|
||
|
||
# 测试结果收集器
|
||
_RESULTS: list[tuple[str, bool, str]] = []
|
||
_VERBOSE = False
|
||
|
||
|
||
def _run(name: str, fn: Callable[[], tuple[bool, str]]) -> None:
|
||
"""运行单个 test_*，记录结果。"""
|
||
try:
|
||
ok, msg = fn()
|
||
except Exception as e: # 测试本身抛异常也算失败
|
||
tb = traceback.format_exc(limit=3)
|
||
ok, msg = False, f"exception: {e}\n{tb}"
|
||
_RESULTS.append((name, ok, msg))
|
||
if _VERBOSE or not ok:
|
||
marker = "PASS" if ok else "FAIL"
|
||
print(f" [{marker}] {name}: {msg}", flush=True)
|
||
|
||
|
||
def _make_conn() -> sqlite3.Connection:
|
||
"""建一张 in-memory DB，应用所有 DDL + 迁移（不加载 seed）。"""
|
||
from db.connection import DDL_STATEMENTS
|
||
from db.migrations import apply_all
|
||
|
||
conn = sqlite3.connect(":memory:")
|
||
conn.row_factory = sqlite3.Row
|
||
conn.execute("PRAGMA foreign_keys = ON;")
|
||
for ddl in DDL_STATEMENTS:
|
||
conn.execute(ddl)
|
||
apply_all(conn)
|
||
conn.commit()
|
||
return conn
|
||
|
||
|
||
class _FakeRow:
|
||
"""Mock 一行 sqlite3.Row：同时支持下标访问 (r["x"]) 和属性访问 (r.x)。
|
||
|
||
production 代码里 task_generator.suggest() 用的是 r["moral_teaching_score"]
|
||
下标语法，所以 fake row 必须也支持。
|
||
"""
|
||
|
||
__slots__ = ("year", "performance_score", "moral_teaching_score",
|
||
"research_score", "teaching_score")
|
||
|
||
def __init__(self, year: int, score: float, moral: float):
|
||
self.year = year
|
||
self.performance_score = score
|
||
self.moral_teaching_score = moral
|
||
self.research_score = score
|
||
self.teaching_score = score
|
||
|
||
def __getitem__(self, key: str) -> Any:
|
||
return getattr(self, key)
|
||
|
||
|
||
def _fake_perf(year: int, score: float, moral: float | None = None) -> _FakeRow:
|
||
"""构造一个 performance_records-like 行（用于纯函数测试，不入 DB）。"""
|
||
m = moral if moral is not None else score
|
||
return _FakeRow(year=year, score=score, moral=m)
|
||
|
||
|
||
def _insert_stub_contract(conn: sqlite3.Connection, contract_id: str) -> None:
|
||
"""插入一份占位合同（performance_records 的 FK 目标）。"""
|
||
conn.execute(
|
||
"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status, last_material_id, renewed_at)
|
||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '可续聘', NULL, NULL)""",
|
||
(contract_id, f"E-{contract_id}", f"占位-{contract_id}", "U-TEST",
|
||
"测试系", "讲师", "正式", "2022-01-01", "2099-12-31", "2022-07-01"),
|
||
)
|
||
conn.commit()
|
||
|
||
|
||
# ---------- util.date_util ----------
|
||
|
||
def test_parse_iso_date() -> tuple[bool, str]:
|
||
from util.date_util import parse_iso_date
|
||
cases = [
|
||
("2024-03-15", date(2024, 3, 15)),
|
||
("2024-03-15T08:30:00", date(2024, 3, 15)),
|
||
(" 2024-03-15 ", date(2024, 3, 15)),
|
||
(date(2024, 3, 15), date(2024, 3, 15)), # 已为 date
|
||
]
|
||
for inp, want in cases:
|
||
got = parse_iso_date(inp)
|
||
if got != want:
|
||
return False, f"parse_iso_date({inp!r}) = {got}, want {want}"
|
||
return True, "4 cases ok"
|
||
|
||
|
||
def test_days_to() -> tuple[bool, str]:
|
||
from util.date_util import days_to
|
||
if days_to(date(2024, 3, 15), today=date(2024, 1, 1)) != 74:
|
||
return False, "days_to 正向计算错"
|
||
if days_to(date(2023, 12, 31), today=date(2024, 1, 1)) != -1:
|
||
return False, "days_to 已过期返回负数错"
|
||
# 默认 today=今天
|
||
if days_to(date(2099, 1, 1)) <= 0:
|
||
return False, "days_to 默认 today 应为今天"
|
||
return True, "正/负/默认 today 三种场景"
|
||
|
||
|
||
def test_classify_alert() -> tuple[bool, str]:
|
||
from util.date_util import classify_alert
|
||
t = (90, 60, 30)
|
||
cases = [
|
||
(100, None), # 超出预警范围
|
||
(91, None), # 边界外
|
||
(90, "yellow"),
|
||
(61, "yellow"),
|
||
(60, "orange"),
|
||
(31, "orange"),
|
||
(30, "red"),
|
||
(1, "red"),
|
||
(0, "red"),
|
||
(-5, "red"), # 已过期仍属 red
|
||
]
|
||
for days, want in cases:
|
||
got = classify_alert(days, t)
|
||
if got != want:
|
||
return False, f"classify_alert({days}) = {got}, want {want}"
|
||
return True, "10 边界 + 越界场景"
|
||
|
||
|
||
def test_month_match() -> tuple[bool, str]:
|
||
from util.date_util import month_match
|
||
d = date(2024, 3, 15)
|
||
if not month_match(d, "2024-03"):
|
||
return False, "同月应命中"
|
||
if month_match(d, "2024-04"):
|
||
return False, "不同月不应命中"
|
||
if not month_match(d, ""):
|
||
return False, "空 month_str 应命中全部"
|
||
if month_match(d, "garbage"):
|
||
return False, "非法 month_str 不应命中"
|
||
return True, "命中 / 未命中 / 空 / 非法 四种"
|
||
|
||
|
||
# ---------- util.constants 版本对齐（POLICY-RELEASE-001） ----------
|
||
|
||
def test_skill_md_version_alignment() -> tuple[bool, str]:
|
||
"""POLICY-RELEASE-001：SKILL.md version == SKILL_VERSION == CHANGELOG 顶部版本"""
|
||
from util.constants import SKILL_VERSION
|
||
|
||
skill_md = (_REPO_ROOT / "SKILL.md").read_text(encoding="utf-8")
|
||
m = re.search(r'(?m)^version:\s*["\']?(\d+\.\d+\.\d+)', skill_md)
|
||
if not m:
|
||
return False, "SKILL.md 缺顶层 version: X.Y.Z"
|
||
md_ver = m.group(1)
|
||
if md_ver != SKILL_VERSION:
|
||
return False, f"SKILL.md={md_ver} != SKILL_VERSION={SKILL_VERSION}"
|
||
|
||
# CHANGELOG 顶部应有 ## X.Y.Z
|
||
cl = (_REPO_ROOT / "CHANGELOG.md").read_text(encoding="utf-8")
|
||
cl_m = re.search(r'(?m)^##\s+(\d+\.\d+\.\d+)', cl)
|
||
if not cl_m:
|
||
return False, "CHANGELOG.md 缺顶层 ## X.Y.Z"
|
||
cl_ver = cl_m.group(1)
|
||
if cl_ver != SKILL_VERSION:
|
||
return False, f"CHANGELOG 顶部={cl_ver} != SKILL_VERSION={SKILL_VERSION}"
|
||
|
||
return True, f"SKILL.md={md_ver} == CHANGELOG={cl_ver} == SKILL_VERSION={SKILL_VERSION}"
|
||
|
||
|
||
def test_skill_md_slug_alignment() -> tuple[bool, str]:
|
||
"""SKILL.md metadata.openclaw.slug == SKILL_SLUG"""
|
||
from util.constants import SKILL_SLUG
|
||
|
||
skill_md = (_REPO_ROOT / "SKILL.md").read_text(encoding="utf-8")
|
||
m = re.search(r'(?m)^\s*slug:\s*["\']?([a-z0-9_-]+)', skill_md)
|
||
if not m:
|
||
return False, "SKILL.md 缺 metadata.openclaw.slug"
|
||
md_slug = m.group(1)
|
||
if md_slug != SKILL_SLUG:
|
||
return False, f"SKILL.md slug={md_slug} != SKILL_SLUG={SKILL_SLUG}"
|
||
return True, f"slug={md_slug}"
|
||
|
||
|
||
def test_data_management_actions() -> tuple[bool, str]:
|
||
"""数据管理动作必须绑定业务表，并映射到实际 CLI 命令。"""
|
||
actions_path = _REPO_ROOT / "assets" / "actions.json"
|
||
actions = json.loads(actions_path.read_text(encoding="utf-8"))["actions"]
|
||
by_id = {action["id"]: action for action in actions}
|
||
|
||
expected = {
|
||
"scan-expiring-contracts": "toolbar",
|
||
"collect-from-platform": "toolbar",
|
||
"generate-renewal-task": "row",
|
||
"dispatch-task-notice": "batch",
|
||
"mark-contract-renewed": "row",
|
||
}
|
||
for action_id, placement in expected.items():
|
||
action = by_id.get(action_id)
|
||
if not action:
|
||
return False, f"缺少数据管理动作 {action_id}"
|
||
if placement not in action.get("placements", []):
|
||
return False, f"{action_id} 缺少 {placement} placement"
|
||
if "合同台账" not in action.get("bind", {}).get("tables", []):
|
||
return False, f"{action_id} 未绑定合同台账"
|
||
if action.get("entrypoint", {}).get("command") != action_id:
|
||
return False, f"{action_id} CLI command 映射错误"
|
||
|
||
# v1.1.18: download-materials 是 async form action，绑定 download_tasks 队列表
|
||
dl = by_id.get("download-materials")
|
||
if not dl:
|
||
return False, "缺少 download-materials 动作"
|
||
if dl.get("executionProfile") != "async":
|
||
return False, f"download-materials 应为 async，实际 {dl.get('executionProfile')}"
|
||
if dl.get("interaction") != "form":
|
||
return False, f"download-materials 应为 form interaction"
|
||
if "download_tasks" not in dl.get("bind", {}).get("tables", []):
|
||
return False, f"download-materials 未绑定 download_tasks"
|
||
schema_props = dl.get("inputSchema", {}).get("properties", {})
|
||
if "itemIds" not in schema_props or "pickCount" not in schema_props:
|
||
return False, f"download-materials inputSchema 缺 itemIds/pickCount: {schema_props}"
|
||
|
||
# v1.1.18: show-config / logs-list 是 sync 运维动作
|
||
for sync_id in ("show-config", "logs-list"):
|
||
a = by_id.get(sync_id)
|
||
if not a:
|
||
return False, f"缺少 {sync_id} 动作"
|
||
if a.get("executionProfile") != "sync":
|
||
return False, f"{sync_id} 应为 sync"
|
||
|
||
return True, "5 个数据管理动作 + download-materials (async form) + show-config/logs-list (sync) 全部就绪"
|
||
|
||
|
||
def test_collect_platform_defaults_to_browser() -> tuple[bool, str]:
|
||
"""平台采集默认显示浏览器；--headless 仅用于已登录自动化。"""
|
||
from cli.app import build_parser
|
||
|
||
parser = build_parser()
|
||
default_args = parser.parse_args(["collect-from-platform"])
|
||
if default_args.headless:
|
||
return False, "collect-from-platform 默认不应使用无头模式"
|
||
headless_args = parser.parse_args(["collect-from-platform", "--headless"])
|
||
if not headless_args.headless:
|
||
return False, "--headless 未启用无头模式"
|
||
legacy_args = parser.parse_args(["collect-from-platform", "--show-browser"])
|
||
if legacy_args.headless:
|
||
return False, "--show-browser 兼容别名未保留浏览器模式"
|
||
return True, "默认浏览器模式，--headless 和 --show-browser 行为正确"
|
||
|
||
|
||
# ---------- db.repository：v1.1.2 新增的 sandbox card 解析 ----------
|
||
|
||
def test_parse_sandbox_card_row_format() -> tuple[bool, str]:
|
||
"""v1.1.2：行格式 '2024\\t称职'"""
|
||
from db import repository as repo
|
||
|
||
conn = _make_conn()
|
||
_insert_stub_contract(conn, "C001")
|
||
card_text = "year\tresult\n2023\t优秀\n2024\t称职\n2025\t基本称职\n"
|
||
n = repo.parse_sandbox_card_performance(conn, "C001", card_text)
|
||
if n != 3:
|
||
return False, f"写入 {n} 条，期望 3"
|
||
|
||
rows = repo.list_performance_by_contract(conn, "C001")
|
||
if len(rows) != 3:
|
||
return False, f"DB 行数 {len(rows)}，期望 3"
|
||
by_year = {r["year"]: r["performance_score"] for r in rows}
|
||
expected = {2023: 90.0, 2024: 75.0, 2025: 60.0}
|
||
for y, want in expected.items():
|
||
if by_year.get(y) != want:
|
||
return False, f"{y} 年分数={by_year.get(y)}，期望 {want}"
|
||
return True, "3 行（优秀/称职/基本称职）解析 + 写入正确"
|
||
|
||
|
||
def test_parse_sandbox_card_narrative_format() -> tuple[bool, str]:
|
||
"""v1.1.2：叙述式 '2024年：等次「称职」'"""
|
||
from db import repository as repo
|
||
|
||
conn = _make_conn()
|
||
_insert_stub_contract(conn, "C002")
|
||
card_text = "考核情况：\n2023年：等次「优秀」。\n2024年：等次「称职」。\n2025年：等次「不称职」。\n"
|
||
n = repo.parse_sandbox_card_performance(conn, "C002", card_text)
|
||
if n != 3:
|
||
return False, f"写入 {n} 条，期望 3"
|
||
|
||
rows = repo.list_performance_by_contract(conn, "C002")
|
||
by_year = {r["year"]: r["performance_score"] for r in rows}
|
||
expected = {2023: 90.0, 2024: 75.0, 2025: 30.0}
|
||
for y, want in expected.items():
|
||
if by_year.get(y) != want:
|
||
return False, f"{y} 年分数={by_year.get(y)}，期望 {want}"
|
||
return True, "3 行（优秀/称职/不称职）叙述式解析正确"
|
||
|
||
|
||
def test_parse_sandbox_card_empty_and_invalid() -> tuple[bool, str]:
|
||
"""空字符串 / 无匹配应返回 0，不报错"""
|
||
from db import repository as repo
|
||
|
||
conn = _make_conn()
|
||
_insert_stub_contract(conn, "C001")
|
||
if repo.parse_sandbox_card_performance(conn, "C001", "") != 0:
|
||
return False, "空字符串应返回 0"
|
||
if repo.parse_sandbox_card_performance(conn, "C001", "没有任何年份/等次信息") != 0:
|
||
return False, "无匹配应返回 0"
|
||
rows = repo.list_performance_by_contract(conn, "C001")
|
||
if rows:
|
||
return False, "无匹配不应写入任何行"
|
||
return True, "空 / 无匹配场景"
|
||
|
||
|
||
def test_parse_sandbox_card_mixed_formats() -> tuple[bool, str]:
|
||
"""同卡片混用两种格式时按行去重（PK = P-<contract>-<year>）"""
|
||
from db import repository as repo
|
||
|
||
conn = _make_conn()
|
||
_insert_stub_contract(conn, "C003")
|
||
card_text = (
|
||
"2024年：等次「称职」。\n" # 叙述式
|
||
"2025\t优秀\n" # 行格式
|
||
"2026年：等次「基本称职」\n"
|
||
)
|
||
n = repo.parse_sandbox_card_performance(conn, "C003", card_text)
|
||
if n != 3:
|
||
return False, f"混合解析写入 {n} 条，期望 3"
|
||
return True, "叙述式 + 行格式混合解析"
|
||
|
||
|
||
def test_upsert_performance_record_grade_mapping() -> tuple[bool, str]:
|
||
"""grade → score 映射 + ON CONFLICT upsert"""
|
||
from db import repository as repo
|
||
|
||
conn = _make_conn()
|
||
_insert_stub_contract(conn, "C001")
|
||
if not repo.upsert_performance_record(conn, "C001", 2024, "优秀"):
|
||
return False, "优秀应返回 True"
|
||
if not repo.upsert_performance_record(conn, "C001", 2024, "优秀"):
|
||
return False, "upsert 已存在应仍返回 True"
|
||
if not repo.upsert_performance_record(conn, "C001", 2025, "称职"):
|
||
return False, "称职应返回 True"
|
||
if not repo.upsert_performance_record(conn, "C001", 2026, "基本称职"):
|
||
return False, "基本称职应返回 True"
|
||
if not repo.upsert_performance_record(conn, "C001", 2027, "不称职"):
|
||
return False, "不称职应返回 True"
|
||
if not repo.upsert_performance_record(conn, "C001", 2028, "不合格"):
|
||
return False, "不合格应返回 True"
|
||
if repo.upsert_performance_record(conn, "C001", 2029, "未知等次"):
|
||
return False, "未知等次应返回 False"
|
||
|
||
rows = repo.list_performance_by_contract(conn, "C001")
|
||
# 期望 5 行：2024/2025/2026/2027/2028
|
||
# 第二次 (2024, 优秀) 是 upsert 覆盖不新增；2029 未知等次不入库
|
||
if len(rows) != 5:
|
||
return False, f"DB 行数 {len(rows)}，期望 5（upsert 同年不新增；未知等次不入库）"
|
||
by_year = {r["year"]: r["performance_score"] for r in rows}
|
||
expected = {2024: 90.0, 2025: 75.0, 2026: 60.0, 2027: 30.0, 2028: 30.0}
|
||
for y, want in expected.items():
|
||
if by_year.get(y) != want:
|
||
return False, f"{y} 年分数={by_year.get(y)}，期望 {want}"
|
||
# 验证 2024 的分数确实被 upsert 覆盖（不是 30/60/75 等其他值）
|
||
if by_year[2024] != 90.0:
|
||
return False, f"upsert 未保持分数：2024={by_year[2024]}，want 90.0"
|
||
return True, "grade 映射 + upsert 幂等 + 未知等次返回 False"
|
||
|
||
|
||
# ---------- service.task_generator.suggest 规则版 ----------
|
||
|
||
def test_suggest_empty_records() -> tuple[bool, str]:
|
||
"""无业绩记录 → observe（数据缺失）"""
|
||
from service.task_generator import suggest
|
||
s, r = suggest([])
|
||
if s != "observe":
|
||
return False, f"suggest([]) = {s}, want observe"
|
||
if "缺失" not in r:
|
||
return False, f"reason 应提示缺失，实际 {r!r}"
|
||
return True, "observe + '缺失'"
|
||
|
||
|
||
def test_suggest_low_moral() -> tuple[bool, str]:
|
||
"""师德 < 60 → non_renew"""
|
||
from service.task_generator import suggest
|
||
rows = [_fake_perf(2024, 85, moral=50)]
|
||
s, r = suggest(rows)
|
||
if s != "non_renew":
|
||
return False, f"suggest(师德 50) = {s}, want non_renew"
|
||
if "师德" not in r:
|
||
return False, f"reason 应含「师德」，实际 {r!r}"
|
||
return True, "non_renew + '师德'"
|
||
|
||
|
||
def test_suggest_fail_year() -> tuple[bool, str]:
|
||
"""任意一年考核 < 60 → observe（复核）"""
|
||
from service.task_generator import suggest
|
||
rows = [
|
||
_fake_perf(2023, 80, moral=85),
|
||
_fake_perf(2024, 50, moral=85), # 不及格
|
||
_fake_perf(2025, 85, moral=85),
|
||
]
|
||
s, r = suggest(rows)
|
||
if s != "observe":
|
||
return False, f"suggest(有不及格年) = {s}, want observe"
|
||
if "复核" not in r and "不合格" not in r:
|
||
return False, f"reason 应提示不合格/复核，实际 {r!r}"
|
||
return True, "observe + '不合格'"
|
||
|
||
|
||
def test_suggest_renew_upward() -> tuple[bool, str]:
|
||
"""全部 >= 80 且逐年上升 → renew"""
|
||
from service.task_generator import suggest
|
||
rows = [
|
||
_fake_perf(2023, 80, moral=85),
|
||
_fake_perf(2024, 85, moral=85),
|
||
_fake_perf(2025, 90, moral=85),
|
||
]
|
||
s, r = suggest(rows)
|
||
if s != "renew":
|
||
return False, f"suggest(全部 80+ 上升) = {s}, want renew"
|
||
return True, "renew + 上升趋势"
|
||
|
||
|
||
def test_suggest_observe_equal_scores_not_renew() -> tuple[bool, str]:
|
||
"""持平不算逐年上升；应回落到 observe"""
|
||
from service.task_generator import suggest
|
||
rows = [
|
||
_fake_perf(2023, 80, moral=85),
|
||
_fake_perf(2024, 80, moral=85),
|
||
_fake_perf(2025, 90, moral=85),
|
||
]
|
||
s, r = suggest(rows)
|
||
if s != "observe":
|
||
return False, f"suggest(80,80,90) = {s}, want observe"
|
||
return True, "观察：持平不等于逐年上升"
|
||
|
||
|
||
def test_suggest_observe_default() -> tuple[bool, str]:
|
||
"""达标但非逐年上升 → observe（常规评审）"""
|
||
from service.task_generator import suggest
|
||
rows = [
|
||
_fake_perf(2023, 85, moral=85),
|
||
_fake_perf(2024, 80, moral=85), # 回落
|
||
_fake_perf(2025, 85, moral=85),
|
||
]
|
||
s, r = suggest(rows)
|
||
if s != "observe":
|
||
return False, f"suggest(回落) = {s}, want observe"
|
||
return True, "observe（常规评审）"
|
||
|
||
|
||
# ---------- service.scanner 端到端 ----------
|
||
|
||
def test_scanner_no_alerts() -> tuple[bool, str]:
|
||
"""所有合同都在 90 天外 → 0 预警"""
|
||
from service import scanner
|
||
|
||
conn = _make_conn()
|
||
conn.executemany(
|
||
"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status, last_material_id, renewed_at)
|
||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '可续聘', NULL, NULL)""",
|
||
[
|
||
("C-FAR-1", "T001", "张三", "U1", "数学系", "教授", "正式",
|
||
"2022-01-01", "2099-12-31", "2022-07-01"),
|
||
],
|
||
)
|
||
conn.commit()
|
||
result = scanner.scan(conn, today=date(2024, 1, 15))
|
||
if result["scanned_count"] != 1:
|
||
return False, f"scanned={result['scanned_count']}, want 1"
|
||
if result["yellow_count"] + result["orange_count"] + result["red_count"] != 0:
|
||
return False, f"应无预警，实测 yellow={result['yellow_count']} orange={result['orange_count']} red={result['red_count']}"
|
||
return True, "1 合同全在 90 天外 → 0 预警"
|
||
|
||
|
||
def test_scanner_three_levels() -> tuple[bool, str]:
|
||
"""3 份合同分别命中黄/橙/红"""
|
||
from service import scanner
|
||
|
||
conn = _make_conn()
|
||
conn.executemany(
|
||
"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status, last_material_id, renewed_at)
|
||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '可续聘', NULL, NULL)""",
|
||
[
|
||
("C-YEL", "T001", "黄老师", "U1", "数学系", "教授", "正式",
|
||
"2022-01-01", "2024-05-15", "2022-07-01"), # 距 2024-02-15 = 90 天 → yellow
|
||
("C-ORA", "T002", "橙老师", "U1", "物理系", "讲师", "正式",
|
||
"2022-01-01", "2024-04-15", "2022-07-01"), # 距 2024-02-15 = 60 天 → orange
|
||
("C-RED", "T003", "红老师", "U1", "化学系", "副教授", "正式",
|
||
"2022-01-01", "2024-03-15", "2022-07-01"), # 距 2024-02-15 = 29 天 → red
|
||
],
|
||
)
|
||
conn.commit()
|
||
result = scanner.scan(conn, today=date(2024, 2, 15))
|
||
if result["scanned_count"] != 3:
|
||
return False, f"scanned={result['scanned_count']}, want 3"
|
||
if result["yellow_count"] != 1 or result["orange_count"] != 1 or result["red_count"] != 1:
|
||
return False, (f"分级数 yellow={result['yellow_count']} "
|
||
f"orange={result['orange_count']} red={result['red_count']}, "
|
||
f"want 1/1/1")
|
||
|
||
# 验证 alerts 表实际写入
|
||
alerts = conn.execute("SELECT contract_id, alert_level FROM alerts").fetchall()
|
||
by_cid = {a["contract_id"]: a["alert_level"] for a in alerts}
|
||
if by_cid.get("C-YEL") != "yellow":
|
||
return False, f"C-YEL 写入等级 {by_cid.get('C-YEL')}, want yellow"
|
||
if by_cid.get("C-ORA") != "orange":
|
||
return False, f"C-ORA 写入等级 {by_cid.get('C-ORA')}, want orange"
|
||
if by_cid.get("C-RED") != "red":
|
||
return False, f"C-RED 写入等级 {by_cid.get('C-RED')}, want red"
|
||
return True, "3 合同 → 1 黄 + 1 橙 + 1 红，alerts 表写入正确"
|
||
|
||
|
||
def test_scanner_skips_non_active_contracts() -> tuple[bool, str]:
|
||
"""status != '可续聘' 的合同不应被扫描"""
|
||
from service import scanner
|
||
|
||
conn = _make_conn()
|
||
conn.execute(
|
||
"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status, last_material_id, renewed_at)
|
||
VALUES ('C-DONE', 'T001', '已续签老师', 'U1', '数学系', '教授', '正式',
|
||
'2022-01-01', '2024-03-15', '2022-07-01', '已续签', NULL, NULL)"""
|
||
)
|
||
conn.commit()
|
||
result = scanner.scan(conn, today=date(2024, 2, 15))
|
||
if result["scanned_count"] != 0:
|
||
return False, f"已续签合同不应被扫描，scanned={result['scanned_count']}"
|
||
alerts = conn.execute("SELECT COUNT(*) AS n FROM alerts").fetchone()["n"]
|
||
if alerts != 0:
|
||
return False, f"应无 alerts 写入，实测 {alerts}"
|
||
return True, "已续签合同被跳过"
|
||
|
||
|
||
# ---------- service.html_renderer 降级路径 ----------
|
||
|
||
def test_html_render_basic() -> tuple[bool, str]:
|
||
"""HTML 渲染（无 jinja2 走 str.replace 降级路径）"""
|
||
from service import html_renderer
|
||
|
||
tmpdir = Path(tempfile.mkdtemp(prefix="alert-hr-test-"))
|
||
saved = os.environ.get("HTML_OUTPUT_DIR")
|
||
os.environ["HTML_OUTPUT_DIR"] = str(tmpdir)
|
||
try:
|
||
conn = _make_conn()
|
||
conn.execute(
|
||
"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status, last_material_id, renewed_at)
|
||
VALUES ('C-HTML', 'T100', '渲染测试', 'U9', '测试系', '教授', '正式',
|
||
'2022-01-01', '2024-06-30', '2022-07-01', '可续聘', NULL, NULL)"""
|
||
)
|
||
conn.execute(
|
||
"""INSERT INTO alerts
|
||
VALUES ('A-HTML', 'C-HTML', 'orange', 60, 'test',
|
||
'2024-04-01T00:00:00', 'open')"""
|
||
)
|
||
conn.execute(
|
||
"""INSERT INTO renewal_tasks
|
||
VALUES ('T-HTML', 'C-HTML', 'A-HTML', 'renew', '近 3 年考核良好',
|
||
'业绩良好', '["材料 A", "材料 B"]',
|
||
'2024-04-01T00:00:00', 'pending',
|
||
'rules', '')"""
|
||
)
|
||
conn.commit()
|
||
|
||
path = html_renderer.render_task_html(conn, "T-HTML")
|
||
if not path.exists():
|
||
return False, f"输出文件不存在 {path}"
|
||
|
||
text = path.read_text(encoding="utf-8")
|
||
if "渲染测试" not in text:
|
||
return False, "HTML 应含教师姓名"
|
||
if "续聘准备任务书" not in text:
|
||
return False, "HTML 应含 TITLE"
|
||
if "橙色" not in text:
|
||
return False, "HTML 应含「橙色」预警等级标签"
|
||
if "建议续聘" not in text:
|
||
return False, "HTML 应含「建议续聘」建议标签"
|
||
return True, f"HTML 渲染 OK → {path.name}"
|
||
finally:
|
||
if saved is None:
|
||
os.environ.pop("HTML_OUTPUT_DIR", None)
|
||
else:
|
||
os.environ["HTML_OUTPUT_DIR"] = saved
|
||
shutil.rmtree(tmpdir, ignore_errors=True)
|
||
|
||
|
||
def test_html_render_unknown_task_raises() -> tuple[bool, str]:
|
||
"""渲染不存在的 task_id 应抛 ValueError"""
|
||
from service import html_renderer
|
||
|
||
conn = _make_conn()
|
||
try:
|
||
html_renderer.render_task_html(conn, "T-NONEXISTENT")
|
||
except ValueError as e:
|
||
return True, f"ValueError OK: {e}"
|
||
return False, "应抛 ValueError，实际未抛"
|
||
|
||
|
||
# ---------- v1.1.6：service.platform_collector 纯函数 ----------
|
||
|
||
def test_gen_contract_id_emp_id() -> tuple[bool, str]:
|
||
"""_gen_contract_id 工号派生（v1.1.1 起用工号作主键）"""
|
||
from service import platform_collector as pc
|
||
|
||
cases = [
|
||
(("T20190033", "2026-04-15"), "RPA-T20190033-20260415"),
|
||
(("T20200055", "2026-06-30"), "RPA-T20200055-20260630"),
|
||
(("T20180021", "2026-08-31"), "RPA-T20180021-20260831"),
|
||
]
|
||
for (emp_id, end_date), expected in cases:
|
||
got = pc._gen_contract_id(emp_id, end_date)
|
||
if got != expected:
|
||
return False, f"({emp_id!r}, {end_date!r}) → {got!r}，want {expected!r}"
|
||
return True, f"3 工号派生正确"
|
||
|
||
|
||
def test_gen_contract_id_special_chars() -> tuple[bool, str]:
|
||
"""_gen_contract_id 工号含特殊字符时正确清洗（保留前 10 字符）"""
|
||
from service import platform_collector as pc
|
||
|
||
# 工号含非 \w 字符 → 清洗；超过 10 字符截断
|
||
got = pc._gen_contract_id("T-2019.0033", "2026-04-15")
|
||
# 清洗后保留 \w，"T-2019.0033" → "T20190033"（8 字符，未截断）
|
||
if "RPA-" not in got or "20260415" not in got:
|
||
return False, f"清洗后格式错：{got!r}"
|
||
# 长工号 → 截断到 10 字符
|
||
got2 = pc._gen_contract_id("ABCDEFGHIJKLMNO", "2026-01-01")
|
||
# "ABCDEFGHIJ"（10 字符）
|
||
if not got2.startswith("RPA-ABCDEFGHIJ-"):
|
||
return False, f"长工号未截断到 10 字符：{got2!r}"
|
||
return True, "清洗 + 截断 OK"
|
||
|
||
|
||
def test_normalize_date_iso() -> tuple[bool, str]:
|
||
"""_normalize_date ISO 日期直通"""
|
||
from service import platform_collector as pc
|
||
|
||
cases = [
|
||
("2026-04-15", "2026-04-15"),
|
||
("2024-01-01", "2024-01-01"),
|
||
]
|
||
for inp, want in cases:
|
||
got = pc._normalize_date(inp)
|
||
if got != want:
|
||
return False, f"{inp!r} → {got!r}，want {want!r}"
|
||
return True, "ISO 日期直通"
|
||
|
||
|
||
def test_normalize_date_fallback() -> tuple[bool, str]:
|
||
"""_normalize_date 非标准格式截前 10 字符"""
|
||
from service import platform_collector as pc
|
||
|
||
# 非标准但带 ISO 前缀
|
||
got = pc._normalize_date("2026-04-15T00:00:00")
|
||
if got != "2026-04-15":
|
||
return False, f"ISO 前缀应保留前 10 字符 → {got!r}"
|
||
# 完全非日期 → 截前 10 字符
|
||
got2 = pc._normalize_date("20260415X")
|
||
if got2 != "20260415X": # 10 字符
|
||
return False, f"非日期应截前 10 字符 → {got2!r}"
|
||
# 带空白
|
||
got3 = pc._normalize_date(" 2026-04-15 ")
|
||
if got3 != "2026-04-15":
|
||
return False, f"带空白应去除 → {got3!r}"
|
||
return True, "非标准格式 fallback OK"
|
||
|
||
|
||
def test_parse_days_positive() -> tuple[bool, str]:
|
||
"""_parse_days 正天数"""
|
||
from service import platform_collector as pc
|
||
|
||
cases = [
|
||
("30", 30),
|
||
("90", 90),
|
||
("还剩 45 天", 45),
|
||
("0", 0),
|
||
]
|
||
for inp, want in cases:
|
||
got = pc._parse_days(inp)
|
||
if got != want:
|
||
return False, f"{inp!r} → {got!r}，want {want!r}"
|
||
return True, "正天数解析 OK"
|
||
|
||
|
||
def test_parse_days_negative() -> tuple[bool, str]:
|
||
"""_parse_days 负数 / 兜底"""
|
||
from service import platform_collector as pc
|
||
|
||
# 含负号
|
||
if pc._parse_days("-15") != -15:
|
||
return False, "负天数未解析"
|
||
# 已过期（带 "已过期" 文本）
|
||
if pc._parse_days("已过期 7 天") != 7:
|
||
return False, "已过期文本未解析数字部分"
|
||
# 无法解析
|
||
if pc._parse_days("") is not None:
|
||
return False, "空字符串应返回 None"
|
||
if pc._parse_days("无数字") is not None:
|
||
return False, "纯文本应返回 None"
|
||
return True, "负数 + 兜底 OK"
|
||
|
||
|
||
def test_parse_alert_red_orange_yellow_unknown() -> tuple[bool, str]:
|
||
"""_parse_alert 红/橙/黄/未知四级映射"""
|
||
from service import platform_collector as pc
|
||
|
||
cases = [
|
||
("红色预警", "red"),
|
||
("红牌", "red"),
|
||
("橙色预警", "orange"),
|
||
("黄灯", "yellow"),
|
||
("黄色预警", "yellow"),
|
||
("无", "unknown"),
|
||
("", "unknown"),
|
||
("blue", "unknown"),
|
||
]
|
||
for inp, want in cases:
|
||
got = pc._parse_alert(inp)
|
||
if got != want:
|
||
return False, f"{inp!r} → {got!r}，want {want!r}"
|
||
return True, "四级映射 OK"
|
||
|
||
|
||
# ---------- v1.1.18：日志 / 路径 / 输入目录 / 队列 / 配置 / 日志查看 ----------
|
||
|
||
|
||
def test_logging_rotating_file_handler() -> tuple[bool, str]:
|
||
"""LOG_FILE 已设时，setup_skill_logging 应追加 RotatingFileHandler。"""
|
||
import importlib
|
||
from util.runtime_paths import get_logs_dir
|
||
|
||
log_path = get_logs_dir() / "test-rotate.log"
|
||
|
||
os.environ["LOG_FILE"] = str(log_path)
|
||
os.environ.pop("LOG_MAX_BYTES", None)
|
||
os.environ.pop("LOG_BACKUP_COUNT", None)
|
||
os.environ.pop("LOG_LEVEL", None)
|
||
import util.logging_setup as ls
|
||
importlib.reload(ls)
|
||
ls.reset_for_tests()
|
||
|
||
logger = ls.setup_skill_logging()
|
||
logger.info("hello rotating")
|
||
|
||
found = [h for h in logger.handlers if h.__class__.__name__ == "RotatingFileHandler"]
|
||
if not found:
|
||
ls.reset_for_tests()
|
||
os.environ.pop("LOG_FILE", None)
|
||
return False, "未发现 RotatingFileHandler"
|
||
if not log_path.exists():
|
||
ls.reset_for_tests()
|
||
os.environ.pop("LOG_FILE", None)
|
||
return False, f"日志文件未生成: {log_path}"
|
||
content = log_path.read_text(encoding="utf-8")
|
||
if "hello rotating" not in content:
|
||
ls.reset_for_tests()
|
||
os.environ.pop("LOG_FILE", None)
|
||
return False, f"日志内容缺 'hello rotating': {content[:200]}"
|
||
|
||
ls.reset_for_tests()
|
||
os.environ.pop("LOG_FILE", None)
|
||
importlib.reload(ls)
|
||
return True, "RotatingFileHandler 写入成功"
|
||
|
||
|
||
def test_logging_fallback_when_log_file_unset() -> tuple[bool, str]:
|
||
"""LOG_FILE 未设时，logger 只有 StreamHandler（行为等价 v1.1.17）。"""
|
||
import importlib
|
||
|
||
os.environ.pop("LOG_FILE", None)
|
||
os.environ.pop("LOG_LEVEL", None)
|
||
import util.logging_setup as ls
|
||
importlib.reload(ls)
|
||
ls.reset_for_tests()
|
||
|
||
logger = ls.setup_skill_logging()
|
||
file_handlers = [h for h in logger.handlers if "File" in h.__class__.__name__]
|
||
if file_handlers:
|
||
ls.reset_for_tests()
|
||
return False, f"应有 0 个 FileHandler，实际 {len(file_handlers)}"
|
||
|
||
ls.reset_for_tests()
|
||
return True, "无 LOG_FILE 时无 FileHandler（兼容 v1.1.17）"
|
||
|
||
|
||
def test_logging_level_env() -> tuple[bool, str]:
|
||
"""LOG_LEVEL=DEBUG 应让 logger.level == logging.DEBUG。"""
|
||
import importlib
|
||
import logging
|
||
|
||
os.environ["LOG_LEVEL"] = "DEBUG"
|
||
os.environ.pop("LOG_FILE", None)
|
||
import util.logging_setup as ls
|
||
importlib.reload(ls)
|
||
ls.reset_for_tests()
|
||
|
||
logger = ls.setup_skill_logging()
|
||
got = logger.level
|
||
if got != logging.DEBUG:
|
||
ls.reset_for_tests()
|
||
os.environ.pop("LOG_LEVEL", None)
|
||
return False, f"logger.level={got} (want {logging.DEBUG})"
|
||
|
||
ls.reset_for_tests()
|
||
os.environ.pop("LOG_LEVEL", None)
|
||
return True, "LOG_LEVEL=DEBUG 生效"
|
||
|
||
|
||
def test_logs_dir_default_under_data() -> tuple[bool, str]:
|
||
"""JIANGCHANG_LOGS_DIR 未设时，get_logs_dir() = get_data_dir() / 'logs'。"""
|
||
os.environ.pop("JIANGCHANG_LOGS_DIR", None)
|
||
os.environ.pop("LOG_FILE", None)
|
||
import util.logging_setup as ls # 触发 runtime_paths 副作用
|
||
ls.reset_for_tests()
|
||
|
||
from util.runtime_paths import get_logs_dir, get_data_dir
|
||
expected = get_data_dir() / "logs"
|
||
if get_logs_dir() != expected:
|
||
return False, f"get_logs_dir()={get_logs_dir()} != {expected}"
|
||
if not expected.exists():
|
||
return False, f"ensure_dirs 没创建 {expected}"
|
||
return True, f"get_logs_dir={expected}"
|
||
|
||
|
||
def _isolated_input_dirs(monkeypatch_env: dict[str, str | None]) -> tuple[Path, Path]:
|
||
"""把 INPUT_DIR 重定向到 tmpdir，返回 (input_root, materials_target) 的 Path。
|
||
|
||
不会污染仓库 data/input/。
|
||
"""
|
||
import tempfile
|
||
tmp = Path(tempfile.mkdtemp(prefix="alert-hr-importer-test-"))
|
||
input_root = tmp / "input"
|
||
(input_root / "contracts").mkdir(parents=True)
|
||
(input_root / "materials").mkdir(parents=True)
|
||
monkeypatch_env["INPUT_DIR"] = str(input_root)
|
||
os.environ["INPUT_DIR"] = str(input_root) # 关键：进程 env 也得设，否则 runtime_paths 读不到
|
||
return input_root, tmp
|
||
|
||
|
||
def _restore_input_env(saved: dict[str, str | None]) -> None:
|
||
for k, v in saved.items():
|
||
if v is None:
|
||
os.environ.pop(k, None)
|
||
else:
|
||
os.environ[k] = v
|
||
|
||
|
||
def test_importer_contracts_csv_upsert() -> tuple[bool, str]:
|
||
"""input/contracts/*.csv → contracts 表 upsert。"""
|
||
saved = {k: os.environ.get(k) for k in ("INPUT_DIR",)}
|
||
try:
|
||
input_root, tmp = _isolated_input_dirs(saved)
|
||
contracts_dir = input_root / "contracts"
|
||
csv_path = contracts_dir / "batch1.csv"
|
||
csv_path.write_text(
|
||
"contract_id,teacher_name,unit_name,contract_end,employee_id\n"
|
||
"C001,张三,物理学院,2026-04-15,T001\n"
|
||
"C002,李四,计算机学院,2026-08-31,T002\n",
|
||
encoding="utf-8",
|
||
)
|
||
|
||
conn = _make_conn()
|
||
try:
|
||
from service.importer import import_input_dir
|
||
result = import_input_dir(conn)
|
||
|
||
if result["contracts_added"] != 2:
|
||
return False, f"contracts_added={result['contracts_added']} (want 2)"
|
||
if result["errors"]:
|
||
return False, f"errors={result['errors']}"
|
||
|
||
rows = conn.execute(
|
||
"SELECT contract_id, teacher_name, unit_name, contract_end "
|
||
"FROM contracts ORDER BY contract_id"
|
||
).fetchall()
|
||
if len(rows) != 2:
|
||
return False, f"DB 中合同数={len(rows)} (want 2)"
|
||
if rows[0]["teacher_name"] != "张三":
|
||
return False, f"row[0].teacher_name={rows[0]['teacher_name']}"
|
||
return True, f"contracts_added={result['contracts_added']}"
|
||
finally:
|
||
conn.close()
|
||
shutil.rmtree(tmp, ignore_errors=True)
|
||
finally:
|
||
_restore_input_env(saved)
|
||
|
||
|
||
def test_importer_materials_pdf_enqueue() -> tuple[bool, str]:
|
||
"""input/materials/{cid}__{f}.pdf → materials_content (parse_method='pending')。"""
|
||
saved = {k: os.environ.get(k) for k in ("INPUT_DIR",)}
|
||
try:
|
||
input_root, tmp = _isolated_input_dirs(saved)
|
||
materials_dir = input_root / "materials"
|
||
pdf_path = materials_dir / "RPA-C001__考核表.pdf"
|
||
pdf_path.write_bytes(b"%PDF-1.4 fake test file")
|
||
|
||
conn = _make_conn()
|
||
try:
|
||
# 先插入 contract（materials_content FK 到 contracts.contract_id）
|
||
conn.execute(
|
||
"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status)
|
||
VALUES ('RPA-C001', 'T001', '张三', 'U001', '物理学院',
|
||
'教授', '固定期限', '2024-01-01', '2026-04-15',
|
||
'2024-04-15', '可续聘')"""
|
||
)
|
||
conn.commit()
|
||
|
||
from service.importer import import_input_dir
|
||
result = import_input_dir(conn)
|
||
|
||
if result["materials_added"] != 1:
|
||
return False, f"materials_added={result['materials_added']} (want 1) errors={result['errors']}"
|
||
|
||
row = conn.execute(
|
||
"SELECT contract_id, parse_method FROM materials_content "
|
||
"WHERE contract_id = 'RPA-C001'"
|
||
).fetchone()
|
||
if not row:
|
||
return False, "materials_content 未写入"
|
||
if row["parse_method"] != "pending":
|
||
return False, f"parse_method={row['parse_method']} (want pending)"
|
||
return True, "PDF 入库 parse_method=pending"
|
||
finally:
|
||
conn.close()
|
||
shutil.rmtree(tmp, ignore_errors=True)
|
||
finally:
|
||
_restore_input_env(saved)
|
||
|
||
|
||
def test_importer_idempotent() -> tuple[bool, str]:
|
||
"""同一 CSV 跑两次，第二次 contracts_added=0（upsert 幂等）。"""
|
||
saved = {k: os.environ.get(k) for k in ("INPUT_DIR",)}
|
||
try:
|
||
input_root, tmp = _isolated_input_dirs(saved)
|
||
(input_root / "contracts" / "x.csv").write_text(
|
||
"contract_id,teacher_name\nC100,重复测试\n", encoding="utf-8"
|
||
)
|
||
|
||
conn = _make_conn()
|
||
try:
|
||
from service.importer import import_input_dir
|
||
r1 = import_input_dir(conn)
|
||
r2 = import_input_dir(conn)
|
||
if r1["contracts_added"] != 1:
|
||
return False, f"first={r1['contracts_added']} (want 1)"
|
||
if r2["contracts_added"] != 1:
|
||
# 注意：CSV 仍按行 upsert，第 2 次相当于 1 次 UPDATE，contracts_added 仍计数
|
||
return False, f"second={r2['contracts_added']} (want 1)"
|
||
n = conn.execute("SELECT COUNT(*) AS n FROM contracts").fetchone()["n"]
|
||
if n != 1:
|
||
return False, f"DB count={n} (want 1，幂等)"
|
||
return True, "幂等 OK：DB count=1"
|
||
finally:
|
||
conn.close()
|
||
shutil.rmtree(tmp, ignore_errors=True)
|
||
finally:
|
||
_restore_input_env(saved)
|
||
|
||
|
||
def test_importer_empty_input_dir() -> tuple[bool, str]:
|
||
"""空 input 目录 → no-op，返回全 0。"""
|
||
saved = {k: os.environ.get(k) for k in ("INPUT_DIR",)}
|
||
try:
|
||
input_root, tmp = _isolated_input_dirs(saved)
|
||
|
||
conn = _make_conn()
|
||
try:
|
||
from service.importer import import_input_dir
|
||
result = import_input_dir(conn)
|
||
if result["contracts_added"] or result["materials_added"]:
|
||
return False, f"空目录应返回全 0，实际 {result}"
|
||
if result["files_scanned"] != 0:
|
||
return False, f"files_scanned={result['files_scanned']} (want 0)"
|
||
return True, "空目录 no-op"
|
||
finally:
|
||
conn.close()
|
||
shutil.rmtree(tmp, ignore_errors=True)
|
||
finally:
|
||
_restore_input_env(saved)
|
||
|
||
|
||
def test_download_tasks_enqueue_idempotent() -> tuple[bool, str]:
|
||
"""enqueue 同一合同两次：第 2 次返回已有 task_id，DB 仅 1 行。"""
|
||
from db import repository as repo
|
||
|
||
conn = _make_conn()
|
||
try:
|
||
conn.execute(
|
||
"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status)
|
||
VALUES ('C100', 'T100', 'X', 'U1', 'Y', '', '', '2024-01-01',
|
||
'2026-04-15', '2024-04-15', '可续聘')"""
|
||
)
|
||
conn.commit()
|
||
|
||
t1 = repo.enqueue_download_task(conn, "C100", "platform_button")
|
||
t2 = repo.enqueue_download_task(conn, "C100", "platform_button")
|
||
if t1 != t2:
|
||
return False, f"t1={t1} t2={t2} (应相同)"
|
||
n = conn.execute(
|
||
"SELECT COUNT(*) AS n FROM download_tasks WHERE contract_id = 'C100'"
|
||
).fetchone()["n"]
|
||
if n != 1:
|
||
return False, f"DB count={n} (want 1)"
|
||
return True, f"idempotent: task_id={t1}"
|
||
finally:
|
||
conn.close()
|
||
|
||
|
||
def test_download_tasks_claim_atomic() -> tuple[bool, str]:
|
||
"""claim_pending_tasks：第一次拿 N 个，第二次拿 0 个（被抢光）。"""
|
||
from db import repository as repo
|
||
|
||
conn = _make_conn()
|
||
try:
|
||
# 准备 5 份合同
|
||
for i in range(5):
|
||
conn.execute(
|
||
f"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status)
|
||
VALUES ('C{i}', 'T{i}', 'X', 'U{i}', 'Y', '', '',
|
||
'2024-01-01', '2026-04-15', '2024-04-15', '可续聘')"""
|
||
)
|
||
conn.commit()
|
||
for i in range(5):
|
||
repo.enqueue_download_task(conn, f"C{i}", "platform_button")
|
||
conn.commit()
|
||
|
||
first = repo.claim_pending_tasks(conn, limit=5)
|
||
if len(first) != 5:
|
||
return False, f"第一次领到 {len(first)} (want 5)"
|
||
# claim 返回的 Row 是查询时刻的快照（UPDATE 在 fetchall 之后才发）；
|
||
# 重新查 DB 验证 status 已变 running
|
||
for t in first:
|
||
cur = conn.execute(
|
||
"SELECT status FROM download_tasks WHERE task_id = ?",
|
||
(t["task_id"],),
|
||
).fetchone()
|
||
if cur["status"] != "running":
|
||
return False, f"task {t['task_id']} DB status={cur['status']} (want running)"
|
||
|
||
second = repo.claim_pending_tasks(conn, limit=5)
|
||
if len(second) != 0:
|
||
return False, f"第二次领到 {len(second)} (want 0)"
|
||
return True, "claim 原子：5+0"
|
||
finally:
|
||
conn.close()
|
||
|
||
|
||
def test_download_tasks_mark_success_and_failed() -> tuple[bool, str]:
|
||
"""mark_success: status=success + result_path; mark_failed 计数 + 重试状态切换。"""
|
||
from db import repository as repo
|
||
|
||
conn = _make_conn()
|
||
try:
|
||
conn.execute(
|
||
"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status)
|
||
VALUES ('C200', 'T200', 'X', 'U1', 'Y', '', '', '2024-01-01',
|
||
'2026-04-15', '2024-04-15', '可续聘')"""
|
||
)
|
||
conn.commit()
|
||
t = repo.enqueue_download_task(conn, "C200", "platform_button")
|
||
|
||
# 1. 标记 success
|
||
repo.mark_task_success(conn, t, "sandbox://hr/contracts/C200")
|
||
conn.commit()
|
||
row = conn.execute(
|
||
"SELECT status, result_path FROM download_tasks WHERE task_id = ?", (t,)
|
||
).fetchone()
|
||
if row["status"] != "success":
|
||
return False, f"success 后 status={row['status']}"
|
||
if row["result_path"] != "sandbox://hr/contracts/C200":
|
||
return False, f"result_path={row['result_path']}"
|
||
|
||
# 2. 失败 ≤ max_attempts：status 回退 pending
|
||
t2 = repo.enqueue_download_task(conn, "C200", "platform_button_v2")
|
||
repo.mark_task_failed(conn, t2, "first attempt failed")
|
||
conn.commit()
|
||
row2 = conn.execute(
|
||
"SELECT status, attempts FROM download_tasks WHERE task_id = ?", (t2,)
|
||
).fetchone()
|
||
if row2["status"] != "pending":
|
||
return False, f"第 1 次失败应 pending，实际 {row2['status']}"
|
||
if row2["attempts"] != 1:
|
||
return False, f"attempts={row2['attempts']} (want 1)"
|
||
|
||
# 3. 失败 ≥ max_attempts：status=failed
|
||
repo.mark_task_failed(conn, t2, "second attempt failed")
|
||
repo.mark_task_failed(conn, t2, "third attempt failed")
|
||
conn.commit()
|
||
row3 = conn.execute(
|
||
"SELECT status, attempts FROM download_tasks WHERE task_id = ?", (t2,)
|
||
).fetchone()
|
||
if row3["status"] != "failed":
|
||
return False, f"第 3 次失败应 failed，实际 {row3['status']}"
|
||
return True, "mark_success/mark_failed 全 OK"
|
||
finally:
|
||
conn.close()
|
||
|
||
|
||
def test_download_tasks_count_by_status() -> tuple[bool, str]:
|
||
"""count_tasks_by_status 返回 {pending: N, success: M, ...}。"""
|
||
from db import repository as repo
|
||
|
||
conn = _make_conn()
|
||
try:
|
||
for i in range(3):
|
||
conn.execute(
|
||
f"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status)
|
||
VALUES ('CT{i}', 'T{i}', 'X', 'U{i}', 'Y', '', '',
|
||
'2024-01-01', '2026-04-15', '2024-04-15', '可续聘')"""
|
||
)
|
||
conn.commit()
|
||
|
||
t0 = repo.enqueue_download_task(conn, "CT0", "platform_button")
|
||
t1 = repo.enqueue_download_task(conn, "CT1", "platform_button")
|
||
repo.enqueue_download_task(conn, "CT2", "platform_button")
|
||
conn.commit()
|
||
|
||
repo.mark_task_success(conn, t0, "x")
|
||
repo.mark_task_failed(conn, t1, "err")
|
||
# 再失败 2 次让 t1 进 failed
|
||
repo.mark_task_failed(conn, t1, "err")
|
||
repo.mark_task_failed(conn, t1, "err")
|
||
conn.commit()
|
||
|
||
counts = repo.count_tasks_by_status(conn)
|
||
if counts.get("success", 0) < 1:
|
||
return False, f"success 计数 < 1: {counts}"
|
||
if counts.get("failed", 0) < 1:
|
||
return False, f"failed 计数 < 1: {counts}"
|
||
if counts.get("pending", 0) < 1:
|
||
return False, f"pending 计数 < 1: {counts}"
|
||
return True, f"counts={counts}"
|
||
finally:
|
||
conn.close()
|
||
|
||
|
||
def test_enqueue_download_tasks_safe_basic() -> tuple[bool, str]:
|
||
"""_enqueue_download_tasks_safe: 全部成功入队。"""
|
||
from service.platform_collector import _enqueue_download_tasks_safe
|
||
|
||
# 准备 3 个合同（in-memory DB，函数不会关闭）
|
||
conn = _make_conn()
|
||
for i in range(3):
|
||
conn.execute(
|
||
f"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status)
|
||
VALUES ('ENQ-{i}', 'T{i}', 'X', 'U{i}', 'Y', '', '',
|
||
'2024-01-01', '2026-04-15', '2024-04-15', '可续聘')"""
|
||
)
|
||
conn.commit()
|
||
|
||
summary = _enqueue_download_tasks_safe(["ENQ-0", "ENQ-1", "ENQ-2"], conn=conn)
|
||
if summary["enqueued"] != 3:
|
||
return False, f"enqueued={summary['enqueued']} (want 3) - {summary}"
|
||
if summary["failed"] != 0:
|
||
return False, f"failed={summary['failed']} - {summary}"
|
||
if summary["errors"]:
|
||
return False, f"errors={summary['errors']}"
|
||
return True, f"3 个合同全部入队: {summary}"
|
||
|
||
|
||
def test_enqueue_download_tasks_safe_idempotent() -> tuple[bool, str]:
|
||
"""_enqueue_download_tasks_safe: 同 contract_id 第二次调用 → skipped。"""
|
||
from service.platform_collector import _enqueue_download_tasks_safe
|
||
|
||
conn = _make_conn()
|
||
conn.execute(
|
||
f"""INSERT INTO contracts
|
||
(contract_id, employee_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start, contract_end,
|
||
trial_period_end, status)
|
||
VALUES ('ENQ-IDM', 'T1', 'X', 'U1', 'Y', '', '',
|
||
'2024-01-01', '2026-04-15', '2024-04-15', '可续聘')"""
|
||
)
|
||
conn.commit()
|
||
|
||
s1 = _enqueue_download_tasks_safe(["ENQ-IDM"], conn=conn)
|
||
s2 = _enqueue_download_tasks_safe(["ENQ-IDM"], conn=conn)
|
||
if s1["enqueued"] != 1:
|
||
return False, f"第一次 enqueued={s1['enqueued']} (want 1) - {s1}"
|
||
if s2["skipped"] != 1:
|
||
return False, f"第二次 skipped={s2['skipped']} (want 1) - {s2}"
|
||
if s2["enqueued"] != 0:
|
||
return False, f"第二次不应新增 enqueued={s2['enqueued']} - {s2}"
|
||
return True, f"幂等 OK: 第一次 {s1}, 第二次 {s2}"
|
||
|
||
|
||
def test_enqueue_download_tasks_safe_fk_failure() -> tuple[bool, str]:
|
||
"""_enqueue_download_tasks_safe: contract_id 不存在 → 计入 failed，不抛异常。"""
|
||
from service.platform_collector import _enqueue_download_tasks_safe
|
||
|
||
# 不插入合同，直接入队 → FK 失败（in-memory DB，函数不关闭）
|
||
conn = _make_conn()
|
||
summary = _enqueue_download_tasks_safe(["DOES-NOT-EXIST"], conn=conn)
|
||
if summary["failed"] != 1:
|
||
return False, f"failed={summary['failed']} (want 1) - {summary}"
|
||
if not summary["errors"]:
|
||
return False, f"errors 应非空: {summary}"
|
||
if "FOREIGN KEY" not in summary["errors"][0] and "foreign key" not in summary["errors"][0].lower():
|
||
return False, f"错误信息应提及 FOREIGN KEY: {summary['errors'][0]}"
|
||
return True, f"FK 失败被吞掉: failed=1, errors[0]={summary['errors'][0][:80]}"
|
||
|
||
|
||
def test_enqueue_download_tasks_safe_empty_list() -> tuple[bool, str]:
|
||
"""_enqueue_download_tasks_safe: 空列表 → no-op，不开 DB 连接。"""
|
||
from service.platform_collector import _enqueue_download_tasks_safe
|
||
|
||
summary = _enqueue_download_tasks_safe([])
|
||
if summary != {"enqueued": 0, "skipped": 0, "failed": 0, "errors": []}:
|
||
return False, f"空列表返回值异常: {summary}"
|
||
return True, "空列表 no-op OK"
|
||
|
||
|
||
def test_enqueue_download_tasks_safe_auto_create_table_v1_29() -> tuple[bool, str]:
|
||
"""v1.1.29：用户没跑 init-db 时，首次调用 `_enqueue_download_tasks_safe`
|
||
不传 conn（owns_conn=True），函数内部 idempotent 创建 download_tasks 表
|
||
而非抛 "no such table"。
|
||
"""
|
||
import os
|
||
import sqlite3
|
||
import tempfile
|
||
from pathlib import Path
|
||
|
||
from service.platform_collector import _enqueue_download_tasks_safe
|
||
|
||
# 1. 临时文件 DB，**只建 contracts 表**（模拟老 DB 没 download_tasks）
|
||
with tempfile.TemporaryDirectory() as tmp:
|
||
tmp_db = Path(tmp) / "old.db"
|
||
# 重定向 JIANGCHANG_DATA_ROOT 或 get_db_path 用临时路径
|
||
# 这里用 monkeypatch get_db_path + get_connection
|
||
from util import runtime_paths as rp
|
||
from db import connection as dbconn
|
||
|
||
orig_rp_db_path = rp.get_db_path
|
||
orig_dbconn_db_path = dbconn.get_db_path
|
||
rp.get_db_path = lambda: tmp_db # type: ignore[assignment]
|
||
dbconn.get_db_path = lambda: tmp_db # type: ignore[assignment]
|
||
try:
|
||
# 模拟老 DB：只有 contracts 表（v1.1.17 之前 init 过）
|
||
_tmp_conn = sqlite3.connect(str(tmp_db))
|
||
try:
|
||
_tmp_conn.executescript(
|
||
"""
|
||
CREATE TABLE contracts (
|
||
contract_id TEXT PRIMARY KEY,
|
||
teacher_name TEXT, unit_id TEXT, unit_name TEXT,
|
||
position TEXT, contract_type TEXT, contract_start TEXT,
|
||
contract_end TEXT, trial_period_end TEXT,
|
||
status TEXT DEFAULT '可续聘',
|
||
last_material_id TEXT, renewed_at TEXT
|
||
);
|
||
INSERT INTO contracts
|
||
(contract_id, teacher_name, unit_id, unit_name,
|
||
position, contract_type, contract_start,
|
||
contract_end, trial_period_end)
|
||
VALUES ('ENQ-CREATE-1', '测试', 'U1', '物理学院',
|
||
'实验师', '专任教师聘用合同',
|
||
'2024-01-01', '2026-12-31', '2024-04-01');
|
||
"""
|
||
)
|
||
_tmp_conn.commit()
|
||
finally:
|
||
_tmp_conn.close()
|
||
|
||
# 2. 不传 conn 调用（owns_conn=True，会走 get_connection → 触发 ensure 建表）
|
||
summary = _enqueue_download_tasks_safe(["ENQ-CREATE-1"])
|
||
if summary.get("failed", 0) > 0:
|
||
return False, f"应自动建表后入队成功，但 failed={summary}"
|
||
|
||
# 3. 验证表确实被自动创建了
|
||
conn = sqlite3.connect(str(tmp_db))
|
||
try:
|
||
count = conn.execute(
|
||
"SELECT COUNT(*) FROM download_tasks"
|
||
).fetchone()[0]
|
||
finally:
|
||
conn.close()
|
||
|
||
if count != 1:
|
||
return False, f"download_tasks 应有 1 行，实际 {count}"
|
||
|
||
return True, f"ensure 建表 + 入队 OK（enqueued={summary.get('enqueued')}）"
|
||
finally:
|
||
rp.get_db_path = orig_rp_db_path # type: ignore[assignment]
|
||
dbconn.get_db_path = orig_dbconn_db_path # type: ignore[assignment]
|
||
|
||
|
||
# ---------- v1.1.19: _wait_for_url_stable + login flow ----------
|
||
|
||
|
||
class _FakePage:
|
||
"""v1.1.19 login flow 测试用的简易 page mock。
|
||
|
||
- .url: 字符串
|
||
- 支持外部修改 .url 模拟用户登录跳转
|
||
- v1.1.24：新增 .locator() 返回 _FakeLocatorNoOp，让
|
||
_wait_for_login_inputs_filled 的 selector 探测不抛 AttributeError
|
||
"""
|
||
|
||
def __init__(self, initial_url: str = "about:blank") -> None:
|
||
self.url = initial_url
|
||
self.goto_calls: list[str] = []
|
||
self.reload_calls: int = 0
|
||
self.click_calls: int = 0
|
||
|
||
def locator(self, selector: str): # noqa: ARG002
|
||
"""v1.1.24 扩展：测试 _wait_for_login_inputs_filled 用，返回空 locator。"""
|
||
return _FakeLocator(count=0)
|
||
|
||
|
||
def test_wait_for_url_stable_immediate_match() -> tuple[bool, str]:
|
||
"""_wait_for_url_stable: URL 已含目标 + 稳定 → 立即返回 True。"""
|
||
from service.platform_collector import _wait_for_url_stable
|
||
|
||
page = _FakePage("https://example.com/app/contracts")
|
||
if not _wait_for_url_stable(page, "/app/", max_wait_sec=5):
|
||
return False, "URL 已含 /app/ 应立即返回 True"
|
||
if page.goto_calls or page.reload_calls:
|
||
return False, f"不应触发 goto/reload: {page.goto_calls}/{page.reload_calls}"
|
||
return True, "URL 已含 /app/ 立即返回 OK"
|
||
|
||
|
||
def test_wait_for_url_stable_transition() -> tuple[bool, str]:
|
||
"""_wait_for_url_stable: URL 经历 login → /app/ 过渡，等稳定后返回 True。"""
|
||
import threading
|
||
import time as _time
|
||
|
||
from service.platform_collector import _wait_for_url_stable
|
||
|
||
page = _FakePage("https://example.com/login")
|
||
|
||
def flip_to_app():
|
||
_time.sleep(0.6)
|
||
page.url = "https://example.com/app/home"
|
||
|
||
threading.Thread(target=flip_to_app, daemon=True).start()
|
||
if not _wait_for_url_stable(page, "/app/", max_wait_sec=5):
|
||
return False, f"应等 URL 稳定到 /app/，但超时（最终 URL={page.url}）"
|
||
return True, f"URL 过渡后稳定 OK（最终 URL={page.url}）"
|
||
|
||
|
||
def test_wait_for_url_stable_timeout() -> tuple[bool, str]:
|
||
"""_wait_for_url_stable: URL 始终未跳到目标 → 超时返回 False。"""
|
||
from service.platform_collector import _wait_for_url_stable
|
||
|
||
page = _FakePage("https://example.com/login")
|
||
if _wait_for_url_stable(page, "/app/", max_wait_sec=2):
|
||
return False, "URL 永远含 login，应超时返回 False"
|
||
return True, "超时返回 False OK"
|
||
|
||
|
||
def test_wait_for_manual_login_no_goto() -> tuple[bool, str]:
|
||
"""_wait_for_manual_login: 等待期间 **不应** 触发 goto / reload / click。"""
|
||
import threading
|
||
import time as _time
|
||
|
||
from service import platform_collector as pc
|
||
|
||
# platform_collector 在 import 时已经把常量复制到模块 globals；
|
||
# 直接覆盖模块属性最稳。缩短 HUMAN_POLL_INTERVAL 和 URL_STABLE_REQUIRED_S，
|
||
# 让 fake_user 0.8s 翻 URL + 0.3s 稳定窗口能凑进 wait_sec=5。
|
||
orig_poll = pc.HUMAN_POLL_INTERVAL
|
||
orig_stable = pc.URL_STABLE_REQUIRED_S
|
||
pc.HUMAN_POLL_INTERVAL = 0.3
|
||
pc.URL_STABLE_REQUIRED_S = 0.3
|
||
try:
|
||
page = _FakePage("https://example.com/login")
|
||
|
||
def fake_user_login():
|
||
_time.sleep(0.8)
|
||
page.url = "https://example.com/app/home"
|
||
|
||
threading.Thread(target=fake_user_login, daemon=True).start()
|
||
try:
|
||
pc._wait_for_manual_login(page, wait_sec=5)
|
||
except Exception as e:
|
||
return False, f"应等用户登录成功，但抛异常: {e}"
|
||
|
||
if page.goto_calls:
|
||
return False, f"等待期间不应 goto: {page.goto_calls}"
|
||
if page.reload_calls:
|
||
return False, f"等待期间不应 reload: {page.reload_calls}"
|
||
return True, "等用户登录期间无打断 OK"
|
||
finally:
|
||
pc.HUMAN_POLL_INTERVAL = orig_poll
|
||
pc.URL_STABLE_REQUIRED_S = orig_stable
|
||
|
||
|
||
# ---------- v1.1.24: _try_auto_sign_in SPA 二级登录页（中文「登录」按钮）----------
|
||
|
||
|
||
class _FakeLocator:
|
||
"""v1.1.24 _try_auto_sign_in 测试用的简易 Playwright Locator mock。
|
||
|
||
支持的 API：
|
||
- .count() -> int
|
||
- .input_value() -> str
|
||
- .click() -> None
|
||
- .first -> 自身
|
||
"""
|
||
|
||
def __init__(
|
||
self,
|
||
count: int = 0,
|
||
value: str = "",
|
||
click_log: list | None = None,
|
||
) -> None:
|
||
self._count = count
|
||
self._value = value
|
||
self._click_log = click_log if click_log is not None else []
|
||
|
||
@property
|
||
def first(self) -> "_FakeLocator":
|
||
return self
|
||
|
||
def count(self) -> int:
|
||
return self._count
|
||
|
||
def input_value(self) -> str:
|
||
return self._value
|
||
|
||
def click(self) -> None:
|
||
self._click_log.append(self._value or "clicked")
|
||
|
||
def fill(self, value: str) -> None:
|
||
"""v1.1.27：fill 后 value 立即更新。"""
|
||
self._value = value
|
||
|
||
|
||
class _FakeLocatorRouter:
|
||
"""根据 selector 返回对应 _FakeLocator 的路由器。
|
||
|
||
selectors: dict[selector_str, _FakeLocator]
|
||
"""
|
||
|
||
def __init__(self, selectors: dict[str, _FakeLocator], page) -> None:
|
||
self._selectors = selectors
|
||
self._page = page
|
||
|
||
def __call__(self, sel: str):
|
||
"""page.locator(sel) 形式调用。"""
|
||
if sel in self._selectors:
|
||
return self._selectors[sel]
|
||
return _FakeLocator(count=0)
|
||
|
||
def __getattr__(self, sel: str):
|
||
# loc.page 已存在则按 selector 路由
|
||
if sel in self._selectors:
|
||
return self._selectors[sel]
|
||
# fallback：未注册的 selector 都返回空 locator
|
||
return _FakeLocator(count=0)
|
||
|
||
|
||
class _FakePlaywrightPage:
|
||
"""v1.1.24 _try_auto_sign_in 测试用的 page mock。
|
||
|
||
usage:
|
||
page = _FakePlaywrightPage(
|
||
url="https://sandbox.jc2009.com/industries/campus/smartcampus/login",
|
||
selectors={
|
||
"input[type='tel']": _FakeLocator(count=1, value="18677308191"),
|
||
"input[type='password']": _FakeLocator(count=1, value="***"),
|
||
"button:has-text('登录')": _FakeLocator(count=1, click_log=click_log),
|
||
},
|
||
wait_for_selector_log=wait_log,
|
||
)
|
||
"""
|
||
|
||
def __init__(
|
||
self,
|
||
url: str = "about:blank",
|
||
selectors: dict[str, _FakeLocator] | None = None,
|
||
wait_for_selector_log: list | None = None,
|
||
wait_selector_should_raise: bool = False,
|
||
) -> None:
|
||
self.url = url
|
||
self._selectors = selectors or {}
|
||
self._wait_log = wait_for_selector_log if wait_for_selector_log is not None else []
|
||
self._wait_should_raise = wait_selector_should_raise
|
||
|
||
def wait_for_selector(self, selector: str, timeout: int = 0) -> None:
|
||
self._wait_log.append(selector)
|
||
if self._wait_should_raise:
|
||
raise Exception("fake: timeout")
|
||
|
||
@property
|
||
def locator(self):
|
||
return _FakeLocatorRouter(self._selectors, self)
|
||
|
||
|
||
def test_try_auto_sign_in_spa_login_chinese_button() -> tuple[bool, str]:
|
||
"""v1.1.24：SPA 二级登录页（/industries/campus/smartcampus/login），
|
||
input 用 `input[type='tel']` / `input[type='password']`，
|
||
按钮中文「登录」。预填有值 → 自动点登录。
|
||
"""
|
||
from service.platform_collector import _try_auto_sign_in
|
||
|
||
click_log: list[str] = []
|
||
page = _FakePlaywrightPage(
|
||
url="https://sandbox.jc2009.com/industries/campus/smartcampus/login",
|
||
selectors={
|
||
"input[type='tel']": _FakeLocator(count=1, value="18677308191"),
|
||
"input[type='password']": _FakeLocator(count=1, value="dummy"),
|
||
"button:has-text('登录')": _FakeLocator(count=1, click_log=click_log),
|
||
},
|
||
)
|
||
if not _try_auto_sign_in(page, wait_input_sec=2):
|
||
return False, "SPA 二级登录页预填应自动点 登录"
|
||
if not click_log:
|
||
return False, f"未触发点击: {click_log}"
|
||
return True, f"SPA 二级登录页中文按钮自动点 OK（click_log={click_log}）"
|
||
|
||
|
||
def test_try_auto_sign_in_root_sign_in_english_button() -> tuple[bool, str]:
|
||
"""v1.1.24（向后兼容）：根域登录页（https://sandbox.jc2009.com/），
|
||
input 用 `#jc-user` / `#jc-pass`，按钮英文「Sign in」。预填有值 → 自动点。
|
||
"""
|
||
from service.platform_collector import _try_auto_sign_in
|
||
|
||
click_log: list[str] = []
|
||
page = _FakePlaywrightPage(
|
||
url="https://sandbox.jc2009.com/",
|
||
selectors={
|
||
"#jc-user": _FakeLocator(count=1, value="demo"),
|
||
"#jc-pass": _FakeLocator(count=1, value="123456"),
|
||
"button:has-text('Sign in')": _FakeLocator(count=1, click_log=click_log),
|
||
},
|
||
)
|
||
if not _try_auto_sign_in(page, wait_input_sec=2):
|
||
return False, "根域登录页预填应自动点 Sign in"
|
||
if not click_log:
|
||
return False, f"未触发点击: {click_log}"
|
||
return True, f"根域登录页 Sign in 自动点 OK（click_log={click_log}）"
|
||
|
||
|
||
def test_try_auto_sign_in_no_input_returns_false() -> tuple[bool, str]:
|
||
"""v1.1.24：input 为空（用户还没输入）→ 返回 False，不点按钮。"""
|
||
from service.platform_collector import _try_auto_sign_in
|
||
|
||
click_log: list[str] = []
|
||
page = _FakePlaywrightPage(
|
||
url="https://sandbox.jc2009.com/industries/campus/smartcampus/login",
|
||
selectors={
|
||
"input[type='tel']": _FakeLocator(count=1, value=""), # 空
|
||
"input[type='password']": _FakeLocator(count=1, value="123"),
|
||
"button:has-text('登录')": _FakeLocator(count=1, click_log=click_log),
|
||
},
|
||
)
|
||
if _try_auto_sign_in(page, wait_input_sec=2):
|
||
return False, "user 空时不应自动点"
|
||
if click_log:
|
||
return False, f"未填完不应点击: {click_log}"
|
||
return True, "input 空返回 False 不点 OK"
|
||
|
||
|
||
def test_try_auto_sign_in_selector_timeout_returns_false() -> tuple[bool, str]:
|
||
"""v1.1.24：等 input 超时（如 URL 已是 SPA home，无登录 input）→ 返回 False。"""
|
||
from service.platform_collector import _try_auto_sign_in
|
||
|
||
click_log: list[str] = []
|
||
page = _FakePlaywrightPage(
|
||
url="https://sandbox.jc2009.com/industries/campus/smartcampus/app/home",
|
||
selectors={}, # 没有任何 input
|
||
wait_selector_should_raise=True,
|
||
)
|
||
if _try_auto_sign_in(page, wait_input_sec=1):
|
||
return False, "无登录 input 应返回 False"
|
||
if click_log:
|
||
return False, f"无 input 不应点击: {click_log}"
|
||
return True, "无登录 input 超时返回 False OK"
|
||
|
||
|
||
def test_wait_for_login_inputs_filled_auto_click_v1_26() -> tuple[bool, str]:
|
||
"""v1.1.26：`_wait_for_login_inputs_filled` **自动点登录按钮**——
|
||
按用户最新要求：「到了 /industries/campus/smartcampus/login 整个页面，
|
||
有账号和密码可用直接点登录跳转」。
|
||
|
||
input 有值时点击 `button:has-text('登录')` 或 `Sign in`（多按钮文本优先级）。
|
||
"""
|
||
from service import platform_collector as pc
|
||
|
||
orig_poll = pc.HUMAN_POLL_INTERVAL
|
||
orig_prompt = pc.HUMAN_PROMPT_INTERVAL
|
||
pc.HUMAN_POLL_INTERVAL = 0.2
|
||
pc.HUMAN_PROMPT_INTERVAL = 0.2
|
||
try:
|
||
click_log: list[str] = []
|
||
page = _FakePlaywrightPage(
|
||
url="https://sandbox.jc2009.com/industries/campus/smartcampus/login",
|
||
selectors={
|
||
"input[type='tel']": _FakeLocator(count=1, value="18677308191"),
|
||
"input[type='password']": _FakeLocator(count=1, value="dummy"),
|
||
"button:has-text('登录')": _FakeLocator(count=1, click_log=click_log),
|
||
},
|
||
)
|
||
|
||
result = pc._wait_for_login_inputs_filled(page, wait_sec=5)
|
||
if not result:
|
||
return False, "input 有值应自动点登录 → return True"
|
||
|
||
if not click_log:
|
||
return False, f"v1.1.26 应自动点登录按钮，但 click_log={click_log}"
|
||
return True, f"v1.1.26 自动点登录按钮 OK（click_log={click_log}）"
|
||
finally:
|
||
pc.HUMAN_POLL_INTERVAL = orig_poll
|
||
pc.HUMAN_PROMPT_INTERVAL = orig_prompt
|
||
|
||
|
||
def test_fill_demo_on_spa_login_basic_v1_27() -> tuple[bool, str]:
|
||
"""v1.1.27：`_fill_demo_on_spa_login` ——SPA 二级登录页 input 默认不预填，
|
||
必须主动 fill demo/123456 再点登录按钮。
|
||
"""
|
||
click_log: list[str] = []
|
||
page = _FakePlaywrightPage(
|
||
url="https://sandbox.jc2009.com/industries/campus/smartcampus/login",
|
||
selectors={
|
||
"#jc-user": _FakeLocator(count=1, value=""), # 空 → 要 fill
|
||
"#jc-pass": _FakeLocator(count=1, value=""),
|
||
"button:has-text('Sign in')": _FakeLocator(count=1, click_log=click_log),
|
||
},
|
||
)
|
||
from service.platform_collector import _fill_demo_on_spa_login
|
||
|
||
if not _fill_demo_on_spa_login(page):
|
||
return False, "SPA login fill demo 应成功"
|
||
if not click_log:
|
||
return False, f"应点 Sign in，但 click_log={click_log}"
|
||
return True, f"SPA 二级登录页 demo/123456 自动 fill+点 OK（click_log={click_log}）"
|
||
|
||
|
||
def test_fill_demo_on_spa_login_chinese_button_v1_27() -> tuple[bool, str]:
|
||
"""v1.1.27：中文「登录」按钮（用户截图版本）也能 fill demo/123456 并点。"""
|
||
click_log: list[str] = []
|
||
page = _FakePlaywrightPage(
|
||
url="https://sandbox.jc2009.com/industries/campus/smartcampus/login",
|
||
selectors={
|
||
"input[type='tel']": _FakeLocator(count=1, value=""),
|
||
"input[type='password']": _FakeLocator(count=1, value=""),
|
||
"button:has-text('登录')": _FakeLocator(count=1, click_log=click_log),
|
||
},
|
||
)
|
||
from service.platform_collector import _fill_demo_on_spa_login
|
||
|
||
if not _fill_demo_on_spa_login(page):
|
||
return False, "SPA login 中文按钮 fill demo 应成功"
|
||
if not click_log:
|
||
return False, f"应点 登录，但 click_log={click_log}"
|
||
return True, f"SPA 二级登录页中文「登录」按钮 OK（click_log={click_log}）"
|
||
|
||
|
||
def test_fill_demo_on_spa_login_no_input_returns_false_v1_27() -> tuple[bool, str]:
|
||
"""v1.1.27：找不到 user input（页面不是 login 页）→ 返回 False。"""
|
||
page = _FakePlaywrightPage(
|
||
url="https://sandbox.jc2009.com/industries/campus/smartcampus/app/home",
|
||
selectors={},
|
||
)
|
||
from service.platform_collector import _fill_demo_on_spa_login
|
||
|
||
if _fill_demo_on_spa_login(page):
|
||
return False, "无 login input 应返回 False"
|
||
return True, "无 login input 返回 False OK"
|
||
|
||
|
||
# ---------- v1.1.18: show-config / logs-list ----------
|
||
|
||
|
||
def _isolated_env_file(tmp_env_path: Path) -> None:
|
||
"""把 .env 路径重定向到 tmpdir；不影响其他 env。"""
|
||
import util.runtime_paths as rp
|
||
|
||
# runtime_paths.get_env_path() 总是返回 get_skill_root() / ".env"
|
||
# 这里通过 monkey-patch 函数对象实现隔离
|
||
rp.get_env_path = lambda: tmp_env_path # type: ignore[assignment]
|
||
|
||
|
||
def test_show_config_masks_tokens() -> tuple[bool, str]:
|
||
"""含 TOKEN 的 key 自动脱敏。"""
|
||
import tempfile
|
||
from pathlib import Path
|
||
tmp = Path(tempfile.mkdtemp(prefix="alert-hr-config-"))
|
||
env_path = tmp / ".env"
|
||
env_path.write_text(
|
||
"WECOM_API_TOKEN=abc123def456\n"
|
||
"HR_API_TOKEN=xx\n"
|
||
"LOG_LEVEL=INFO\n",
|
||
encoding="utf-8",
|
||
)
|
||
|
||
import service.config_viewer as cv
|
||
orig_get_env_path = cv.get_env_path
|
||
cv.get_env_path = lambda: env_path # type: ignore[assignment]
|
||
try:
|
||
result = cv.read_env_config()
|
||
cfg = result["config"]
|
||
if cfg.get("WECOM_API_TOKEN") != "ab***56":
|
||
return False, f"WECOM_API_TOKEN={cfg.get('WECOM_API_TOKEN')} (want ab***56)"
|
||
if cfg.get("HR_API_TOKEN") != "***":
|
||
return False, f"HR_API_TOKEN={cfg.get('HR_API_TOKEN')} (want *** for ≤4 chars)"
|
||
if cfg.get("LOG_LEVEL") != "INFO":
|
||
return False, f"LOG_LEVEL={cfg.get('LOG_LEVEL')} (want INFO)"
|
||
return True, "tokens masked OK"
|
||
finally:
|
||
cv.get_env_path = orig_get_env_path # type: ignore[assignment]
|
||
shutil.rmtree(tmp, ignore_errors=True)
|
||
|
||
|
||
def test_show_config_skips_empty() -> tuple[bool, str]:
|
||
""".env 中空 value 的 key 不出现在 config 中。"""
|
||
import tempfile
|
||
from pathlib import Path
|
||
tmp = Path(tempfile.mkdtemp(prefix="alert-hr-config-"))
|
||
env_path = tmp / ".env"
|
||
env_path.write_text(
|
||
"DB_PATH=\nLOG_LEVEL=INFO\n", encoding="utf-8",
|
||
)
|
||
|
||
import service.config_viewer as cv
|
||
orig = cv.get_env_path
|
||
cv.get_env_path = lambda: env_path # type: ignore[assignment]
|
||
try:
|
||
cfg = cv.read_env_config()["config"]
|
||
if "DB_PATH" in cfg:
|
||
return False, f"DB_PATH 应该跳过，仍在 cfg: {cfg}"
|
||
if cfg.get("LOG_LEVEL") != "INFO":
|
||
return False, f"LOG_LEVEL={cfg.get('LOG_LEVEL')}"
|
||
return True, "空 value 跳过 OK"
|
||
finally:
|
||
cv.get_env_path = orig # type: ignore[assignment]
|
||
shutil.rmtree(tmp, ignore_errors=True)
|
||
|
||
|
||
def test_show_config_skips_comments() -> tuple[bool, str]:
|
||
"""# 注释行不计入 config。"""
|
||
import tempfile
|
||
from pathlib import Path
|
||
tmp = Path(tempfile.mkdtemp(prefix="alert-hr-config-"))
|
||
env_path = tmp / ".env"
|
||
env_path.write_text(
|
||
"# 这是注释\n"
|
||
" # 也是注释\n"
|
||
"LOG_LEVEL=INFO\n",
|
||
encoding="utf-8",
|
||
)
|
||
|
||
import service.config_viewer as cv
|
||
orig = cv.get_env_path
|
||
cv.get_env_path = lambda: env_path # type: ignore[assignment]
|
||
try:
|
||
cfg = cv.read_env_config()["config"]
|
||
if len(cfg) != 1 or "LOG_LEVEL" not in cfg:
|
||
return False, f"应仅 1 项 LOG_LEVEL，实际 {list(cfg.keys())}"
|
||
return True, "注释跳过 OK"
|
||
finally:
|
||
cv.get_env_path = orig # type: ignore[assignment]
|
||
shutil.rmtree(tmp, ignore_errors=True)
|
||
|
||
|
||
def test_show_config_handles_quotes() -> tuple[bool, str]:
|
||
""".env 中带双引号/单引号的值自动去引号。"""
|
||
import tempfile
|
||
from pathlib import Path
|
||
tmp = Path(tempfile.mkdtemp(prefix="alert-hr-config-"))
|
||
env_path = tmp / ".env"
|
||
env_path.write_text(
|
||
'HR_API_BASE_URL="https://hr.example.edu/api/v1"\n'
|
||
"GREETING='hello world'\n"
|
||
"NOTE=no_quotes\n",
|
||
encoding="utf-8",
|
||
)
|
||
|
||
import service.config_viewer as cv
|
||
orig = cv.get_env_path
|
||
cv.get_env_path = lambda: env_path # type: ignore[assignment]
|
||
try:
|
||
cfg = cv.read_env_config()["config"]
|
||
if cfg.get("HR_API_BASE_URL") != "https://hr.example.edu/api/v1":
|
||
return False, f"双引号未去: {cfg.get('HR_API_BASE_URL')}"
|
||
if cfg.get("GREETING") != "hello world":
|
||
return False, f"单引号未去: {cfg.get('GREETING')}"
|
||
if cfg.get("NOTE") != "no_quotes":
|
||
return False, f"无引号: {cfg.get('NOTE')}"
|
||
return True, "引号处理 OK"
|
||
finally:
|
||
cv.get_env_path = orig # type: ignore[assignment]
|
||
shutil.rmtree(tmp, ignore_errors=True)
|
||
|
||
|
||
def test_logs_viewer_nonexistent_file() -> tuple[bool, str]:
|
||
"""日志文件不存在时，返回 exists=False，lines=[]。"""
|
||
import tempfile
|
||
from pathlib import Path
|
||
tmp = Path(tempfile.mkdtemp(prefix="alert-hr-logs-"))
|
||
fake_log = tmp / "no-such-file.log"
|
||
|
||
os.environ["LOG_FILE"] = str(fake_log)
|
||
try:
|
||
from service.logs_viewer import tail_log_file
|
||
result = tail_log_file(tail=50)
|
||
if result["exists"]:
|
||
return False, "exists 应为 False"
|
||
if result["lines"]:
|
||
return False, f"lines 应为空: {result['lines']}"
|
||
if result["returned_lines"] != 0:
|
||
return False, f"returned_lines={result['returned_lines']}"
|
||
return True, "non-existent file OK"
|
||
finally:
|
||
os.environ.pop("LOG_FILE", None)
|
||
shutil.rmtree(tmp, ignore_errors=True)
|
||
|
||
|
||
def test_logs_viewer_tail_and_filter() -> tuple[bool, str]:
|
||
"""tail + level 过滤：INFO 默认只显示 INFO/WARNING/ERROR。"""
|
||
import tempfile
|
||
from pathlib import Path
|
||
tmp = Path(tempfile.mkdtemp(prefix="alert-hr-logs-"))
|
||
log_path = tmp / "tail-test.log"
|
||
lines: list[str] = []
|
||
for i in range(300):
|
||
if i % 3 == 0:
|
||
lines.append(f"2026-09-15 12:34:5{i%10} [alert-contract-expiring-hr] INFO 第{i}条")
|
||
elif i % 3 == 1:
|
||
lines.append(f"2026-09-15 12:34:5{i%10} [alert-contract-expiring-hr] WARNING 第{i}条")
|
||
else:
|
||
lines.append(f"2026-09-15 12:34:5{i%10} [alert-contract-expiring-hr] DEBUG 第{i}条")
|
||
log_path.write_text("\n".join(lines), encoding="utf-8")
|
||
|
||
os.environ["LOG_FILE"] = str(log_path)
|
||
try:
|
||
from service.logs_viewer import tail_log_file
|
||
# INFO+：最后 50 行中含 INFO + WARNING，去掉 DEBUG
|
||
# 300 行每 3 行一循环：i%3==0 INFO, i%3==1 WARN, i%3==2 DEBUG
|
||
# 最后 50 行是 i=250..299：第 250=INFO 251=WARN 252=DEBUG ... 共 50 行
|
||
# 分布：i%3==0 → 17 (250, 253, ..., 299 但 299%3=0)... 实际 250..299 中 i%3==0 有 17 个
|
||
result_info = tail_log_file(tail=50, min_level="INFO")
|
||
if result_info["returned_lines"] != 33:
|
||
return False, f"INFO+ returned_lines={result_info['returned_lines']} (want 33)"
|
||
if any(" DEBUG " in ln for ln in result_info["lines"]):
|
||
return False, "INFO 过滤应排除 DEBUG 行"
|
||
|
||
# WARNING+：仅 WARNING
|
||
result_warn = tail_log_file(tail=50, min_level="WARNING")
|
||
if result_warn["returned_lines"] != 17:
|
||
return False, f"WARNING+ returned_lines={result_warn['returned_lines']} (want 17)"
|
||
if not all(" WARNING " in ln for ln in result_warn["lines"]):
|
||
return False, "WARNING 过滤应只剩 WARNING 行"
|
||
|
||
# DEBUG：全部 50 行都返回
|
||
result_debug = tail_log_file(tail=50, min_level="DEBUG")
|
||
if result_debug["returned_lines"] != 50:
|
||
return False, f"DEBUG returned_lines={result_debug['returned_lines']} (want 50)"
|
||
return True, f"tail+filter OK: DEBUG+={result_debug['returned_lines']}, INFO+={result_info['returned_lines']}, WARN+={result_warn['returned_lines']}"
|
||
finally:
|
||
os.environ.pop("LOG_FILE", None)
|
||
shutil.rmtree(tmp, ignore_errors=True)
|
||
|
||
|
||
def test_logs_viewer_resolves_relative_path() -> tuple[bool, str]:
|
||
"""LOG_FILE 设相对路径时，解析到 get_logs_dir() 下。"""
|
||
from util.runtime_paths import get_logs_dir
|
||
os.environ["LOG_FILE"] = "relative-test.log"
|
||
os.environ.pop("JIANGCHANG_LOGS_DIR", None)
|
||
try:
|
||
from service.logs_viewer import _resolve_log_path
|
||
got = _resolve_log_path()
|
||
expected = get_logs_dir() / "relative-test.log"
|
||
if got != expected:
|
||
return False, f"_resolve_log_path={got} (want {expected})"
|
||
return True, f"resolved to {got}"
|
||
finally:
|
||
os.environ.pop("LOG_FILE", None)
|
||
|
||
|
||
# ---------- 入口 ----------
|
||
|
||
def main() -> int:
|
||
parser = argparse.ArgumentParser(description="默认 release 测试套件")
|
||
parser.add_argument("-v", "--verbose", action="store_true",
|
||
help="详细输出每个用例结果")
|
||
args = parser.parse_args()
|
||
|
||
global _VERBOSE
|
||
_VERBOSE = args.verbose
|
||
|
||
print("=== alert-contract-expiring-hr release tests ===", flush=True)
|
||
|
||
_run("util/parse_iso_date", test_parse_iso_date)
|
||
_run("util/days_to", test_days_to)
|
||
_run("util/classify_alert", test_classify_alert)
|
||
_run("util/month_match", test_month_match)
|
||
_run("constants/skill_md_version_alignment", test_skill_md_version_alignment)
|
||
_run("constants/skill_md_slug_alignment", test_skill_md_slug_alignment)
|
||
_run("assets/data_management_actions", test_data_management_actions)
|
||
_run("cli/collect_platform_browser_default", test_collect_platform_defaults_to_browser)
|
||
_run("db/parse_sandbox_card_row", test_parse_sandbox_card_row_format)
|
||
_run("db/parse_sandbox_card_narrative", test_parse_sandbox_card_narrative_format)
|
||
_run("db/parse_sandbox_card_empty_invalid", test_parse_sandbox_card_empty_and_invalid)
|
||
_run("db/parse_sandbox_card_mixed", test_parse_sandbox_card_mixed_formats)
|
||
_run("db/upsert_performance_record", test_upsert_performance_record_grade_mapping)
|
||
_run("task_generator/suggest_empty", test_suggest_empty_records)
|
||
_run("task_generator/suggest_low_moral", test_suggest_low_moral)
|
||
_run("task_generator/suggest_fail_year", test_suggest_fail_year)
|
||
_run("task_generator/suggest_renew", test_suggest_renew_upward)
|
||
_run("task_generator/suggest_equal_scores", test_suggest_observe_equal_scores_not_renew)
|
||
_run("task_generator/suggest_observe", test_suggest_observe_default)
|
||
_run("scanner/no_alerts", test_scanner_no_alerts)
|
||
_run("scanner/three_levels", test_scanner_three_levels)
|
||
_run("scanner/skips_non_active", test_scanner_skips_non_active_contracts)
|
||
_run("html_renderer/basic", test_html_render_basic)
|
||
_run("html_renderer/unknown_task_raises", test_html_render_unknown_task_raises)
|
||
_run("platform_collector/gen_contract_id_emp_id", test_gen_contract_id_emp_id)
|
||
_run("platform_collector/gen_contract_id_special", test_gen_contract_id_special_chars)
|
||
_run("platform_collector/normalize_date_iso", test_normalize_date_iso)
|
||
_run("platform_collector/normalize_date_fallback", test_normalize_date_fallback)
|
||
_run("platform_collector/parse_days_positive", test_parse_days_positive)
|
||
_run("platform_collector/parse_days_negative", test_parse_days_negative)
|
||
_run("platform_collector/parse_alert_levels", test_parse_alert_red_orange_yellow_unknown)
|
||
_run("logging/rotating_file_handler", test_logging_rotating_file_handler)
|
||
_run("logging/fallback_when_log_file_unset", test_logging_fallback_when_log_file_unset)
|
||
_run("logging/level_env", test_logging_level_env)
|
||
_run("logging/logs_dir_default", test_logs_dir_default_under_data)
|
||
_run("importer/contracts_csv_upsert", test_importer_contracts_csv_upsert)
|
||
_run("importer/materials_pdf_enqueue", test_importer_materials_pdf_enqueue)
|
||
_run("importer/idempotent", test_importer_idempotent)
|
||
_run("importer/empty_input_dir", test_importer_empty_input_dir)
|
||
_run("download_tasks/enqueue_idempotent", test_download_tasks_enqueue_idempotent)
|
||
_run("download_tasks/claim_atomic", test_download_tasks_claim_atomic)
|
||
_run("download_tasks/mark_success_and_failed", test_download_tasks_mark_success_and_failed)
|
||
_run("download_tasks/count_by_status", test_download_tasks_count_by_status)
|
||
_run("download_tasks/enqueue_safe_basic", test_enqueue_download_tasks_safe_basic)
|
||
_run("download_tasks/enqueue_safe_idempotent", test_enqueue_download_tasks_safe_idempotent)
|
||
_run("download_tasks/enqueue_safe_fk_failure", test_enqueue_download_tasks_safe_fk_failure)
|
||
_run("download_tasks/enqueue_safe_empty_list", test_enqueue_download_tasks_safe_empty_list)
|
||
_run("download_tasks/enqueue_safe_auto_create_table_v1_29", test_enqueue_download_tasks_safe_auto_create_table_v1_29)
|
||
_run("login_flow/wait_url_stable_immediate", test_wait_for_url_stable_immediate_match)
|
||
_run("login_flow/wait_url_stable_transition", test_wait_for_url_stable_transition)
|
||
_run("login_flow/wait_url_stable_timeout", test_wait_for_url_stable_timeout)
|
||
_run("login_flow/wait_manual_login_no_goto", test_wait_for_manual_login_no_goto)
|
||
_run("login_flow/auto_sign_in_spa_chinese_button", test_try_auto_sign_in_spa_login_chinese_button)
|
||
_run("login_flow/auto_sign_in_root_english_button", test_try_auto_sign_in_root_sign_in_english_button)
|
||
_run("login_flow/auto_sign_in_no_input_returns_false", test_try_auto_sign_in_no_input_returns_false)
|
||
_run("login_flow/auto_sign_in_selector_timeout_returns_false", test_try_auto_sign_in_selector_timeout_returns_false)
|
||
_run("login_flow/wait_login_inputs_filled_auto_click_v1_26", test_wait_for_login_inputs_filled_auto_click_v1_26)
|
||
_run("login_flow/fill_demo_on_spa_login_basic_v1_27", test_fill_demo_on_spa_login_basic_v1_27)
|
||
_run("login_flow/fill_demo_on_spa_login_chinese_button_v1_27", test_fill_demo_on_spa_login_chinese_button_v1_27)
|
||
_run("login_flow/fill_demo_on_spa_login_no_input_returns_false_v1_27", test_fill_demo_on_spa_login_no_input_returns_false_v1_27)
|
||
_run("show_config/masks_tokens", test_show_config_masks_tokens)
|
||
_run("show_config/skips_empty", test_show_config_skips_empty)
|
||
_run("show_config/skips_comments", test_show_config_skips_comments)
|
||
_run("show_config/handles_quotes", test_show_config_handles_quotes)
|
||
_run("logs_viewer/nonexistent_file", test_logs_viewer_nonexistent_file)
|
||
_run("logs_viewer/tail_and_filter", test_logs_viewer_tail_and_filter)
|
||
_run("logs_viewer/resolves_relative_path", test_logs_viewer_resolves_relative_path)
|
||
|
||
total = len(_RESULTS)
|
||
passed = sum(1 for _, ok, _ in _RESULTS if ok)
|
||
failed = total - passed
|
||
|
||
print()
|
||
print(f"=== Summary: {passed}/{total} passed, {failed} failed ===", flush=True)
|
||
if failed:
|
||
print("\nFailures:")
|
||
for name, ok, msg in _RESULTS:
|
||
if not ok:
|
||
print(f" - {name}: {msg}")
|
||
return 1
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|