diff --git a/admin-frontend-vue/src/pages/account/UserSecretsPage.vue b/admin-frontend-vue/src/pages/account/UserSecretsPage.vue
index 5a259d443..70e52ca33 100644
--- a/admin-frontend-vue/src/pages/account/UserSecretsPage.vue
+++ b/admin-frontend-vue/src/pages/account/UserSecretsPage.vue
@@ -16,8 +16,11 @@ import {
import {
PROXY_MODULE_KEY,
llmSourceLabel,
+ moduleStatusBand,
proxyDisplayText,
proxySourceLabel,
+ rowDetailLines,
+ rowStatusBand,
} from './user-secret-model.ts'
import { useAdminSessionStore } from '@/stores/admin-session'
import { useCompanyTabStore } from '@/stores/company-tab'
@@ -55,48 +58,20 @@ const STATUS_OPTIONS = [
{ value: 'passed', label: '检测通过' },
{ value: 'failed', label: '检测失败' },
{ value: 'incomplete', label: '未配齐' },
- { value: 'error', label: '无法判定' },
+ // 后端的行级值仍是 error:这一档现在既可能是「问不出结论」,也可能是「通道还没释放、等一会再点」,
+ // 界面按码把后者补成「可重试」(见 user-secret-model.ts 的档位表),筛选项就得把两档都点名。
+ { value: 'error', label: '无法判定/可重试' },
{ value: 'unknown', label: '未检测' },
]
-/** 行级状态药丸:三类都检测通过才显示「检测通过」。 */
-function rowStatusMeta(status: string) {
- switch (status) {
- case 'passed':
- return { label: '检测通过', tone: 'is-allowed' }
- case 'failed':
- return { label: '检测失败', tone: 'is-blocked' }
- case 'incomplete':
- return { label: '未配齐', tone: 'is-warn' }
- case 'error':
- return { label: '无法判定', tone: 'is-warn' }
- default:
- return { label: '未检测', tone: 'is-unknown' }
- }
-}
-
-/** 单格状态药丸:未配置时统一灰色;欠费单独标识。 */
-function moduleStatusMeta(module: AdminUserSecretModule | undefined) {
- if (!module || !module.exists) {
- return { label: '未配置', tone: 'is-unknown' }
- }
- switch (module.checkStatus) {
- case 'passed':
- return { label: '通过', tone: 'is-allowed' }
- case 'failed':
- if (module.checkCode === 'insufficient_balance') {
- return { label: '欠费', tone: 'is-warn' }
- }
- return { label: '失败', tone: 'is-blocked' }
- case 'error':
- return { label: '无法判定', tone: 'is-warn' }
- default:
- return { label: '未检测', tone: 'is-unknown' }
- }
-}
+/* 状态药丸的档位表在 `user-secret-model.ts`(唯一出处,页面不带第二张表):
+ 行级传整行而不是 `row.status`——后端把 failed/incomplete 都判掉之后就只剩一个「error」,
+ 这一行到底是「查不出」还是「等青果释放」只有逐格的 `check_code` 说得清。 */
/**
- * 单格悬停详情:后端下发的**脱敏值** + 锁定说明 + 检测消息 + 检测时间 + 耗时。
+ * 单格悬停详情:后端下发的**脱敏值** + 锁定说明 + **检测结果原文 `check_message`** + 检测时间 + 耗时。
+ * 运维要判「是欠费还是被自己的采集占着」,靠的就是这句后端原文——档名只是扫一眼用的短词,
+ * 前端一律不按码自己拼句子。
* ⚠ 只读 `masked`:`full` 在后台侧恒空(2026-11-02 `SecretMasking.maskProxy` 收口),
* 这里不做任何「masked 空就回落原文」的兜底,也不给复制整条链接的旁路。
*/
@@ -108,7 +83,9 @@ function moduleTooltip(module: AdminUserSecretModule | undefined) {
parts.push(isProxyModule(module) ? `代理地址(已脱敏,不含 key/pwd):${display}` : `密钥:${display}`)
}
if (module.locked) parts.push('已由后台代填并锁定:客户端不可修改或清空,改代理需重新填写账密')
- if (module.checkMessage) parts.push(module.checkMessage)
+ // 后端的这句话就是给人看的结论,原样透出(不动一个字、不按码另拼一句)
+ const message = String(module.checkMessage || '').trim()
+ if (message) parts.push(message)
if (module.checkedAt) parts.push(`检测时间:${formatDateTime(module.checkedAt)}`)
if (module.checkLatencyMs != null) parts.push(`耗时:${module.checkLatencyMs}ms`)
return parts.join(';') || '暂无检测记录'
@@ -126,9 +103,15 @@ function groupTextOf(row: AdminUserSecretRow) {
return '—'
}
+/**
+ * 行级悬停详情:后端的行级摘要 + 逐格的 `check_message` 原文 + 更新时间。
+ * 行级状态一旦补成「可重试」,管理员得能立刻看出是哪一格在等、后端原话怎么说;
+ * 逐格那句一律取后端下发文本(`rowDetailLines` 只搬运、不改写、不另拼一句)。
+ */
function rowStatusTooltip(row: AdminUserSecretRow) {
const parts: string[] = []
if (row.statusMessage) parts.push(row.statusMessage)
+ parts.push(...rowDetailLines(row))
if (row.updatedAt) parts.push(`最近更新:${formatDateTime(row.updatedAt)}`)
return parts.join(';') || '暂无检测记录'
}
@@ -185,7 +168,9 @@ async function check(row: AdminUserSecretRow) {
if (failed.length) {
ElMessage.warning(failed[0].checkMessage || '存在检测失败项')
} else if (errors.length) {
- ElMessage.warning('部分配置本次无法判定')
+ // 后端这句话会区分「通道被你自己占着,等约 3 分钟」与「真的问不出结论」;
+ // 硬写「无法判定」等于把可重试那一族又抹回一坨(现网 uid=1 就是这个形状)。
+ ElMessage.warning(errors[0].checkMessage || '部分配置本次无法判定')
} else {
ElMessage.success('检测通过')
}
@@ -329,8 +314,8 @@ onMounted(load)
{{ llmSourceLabel(row.similarAsin.channel) }}
-
- {{ moduleStatusMeta(row.similarAsin).label }}
+
+ {{ moduleStatusBand(row.similarAsin).label }}
@@ -341,8 +326,8 @@ onMounted(load)
{{ llmSourceLabel(row.appearancePatent.channel) }}
-
- {{ moduleStatusMeta(row.appearancePatent).label }}
+
+ {{ moduleStatusBand(row.appearancePatent).label }}
@@ -354,8 +339,8 @@ onMounted(load)
{{ proxySourceLabel(row.proxy.channel) }}
-
- {{ moduleStatusMeta(row.proxy).label }}
+
+ {{ moduleStatusBand(row.proxy).label }}
-
- {{ rowStatusMeta(row.status).label }}
+
+ {{ rowStatusBand(row).label }}
|
{{ formatDateTime(row.createdAt) }} |
@@ -672,6 +657,13 @@ h3 {
border-color: #f0dfae;
color: #8f6d1e;
}
+/* 「等一会再点」这一族(通道待释放/限流/超时/网络/上游):既不红(密钥没坏)
+ 也不黄(不是欠费)更不是灰(不是查不出),独立一档青色——三种处置一眼分开。 */
+.wh-pill.is-retry {
+ background: #e6f2f7;
+ border-color: #b6d8e6;
+ color: #2b6b86;
+}
.wh-pill.is-unknown {
background: #f0f3f6;
border-color: #d6dee6;
diff --git a/admin-frontend-vue/src/pages/account/user-secret-model.ts b/admin-frontend-vue/src/pages/account/user-secret-model.ts
index 8f5dbf9b2..046f9ca9d 100644
--- a/admin-frontend-vue/src/pages/account/user-secret-model.ts
+++ b/admin-frontend-vue/src/pages/account/user-secret-model.ts
@@ -1,7 +1,7 @@
/**
- * 密钥管理页的纯逻辑模型(货源标签 + 代理重填)。
+ * 密钥管理页的纯逻辑模型(货源标签 + 代理重填 + 检测结果档位)。
*
- * 两条收口都在这个文件里,页模板只调这里导出的函数,不各写各的字典:
+ * 三条收口都在这个文件里,页模板只调这里导出的函数,不各写各的字典:
*
* 1. **货源标签按模块分字典**(2026-11-02 修):原先 `UserSecretsPage.vue` 里是一整张
* `sourceLabel()`,把 LLM 渠道(longtaitou/t8star)与代理供应商(qingguo/jikip)混在同一个
@@ -17,6 +17,11 @@
* 由 `composeQingguoLink` 现拼;极客按其产品口径填自家提取链接。
* ⚠ 拼出来的链接是一次性写请求的载荷,**不得**回显、回填、进 tooltip、进剪贴板。
*
+ * 3. **检测结果按 `check_code` 分档渲染**(2026-11-02 加,见下方档位表):状态列原先只看
+ * `check_status`,把后端新分出来的一族「等一会再点就行」的码(`channel_busy` 等)一律显示成
+ * 「无法判定」,管理员分不清「被自己占着」「密钥坏了」「欠费」三种完全不同的处置。
+ * 码表只在这一份文件里(页面不再自带第二张表),句子一律用后端的 `check_message` 原文。
+ *
* 零 `@/` 别名依赖:本文件被 `node --test` 直测(那颗 runner 不认 Vite 别名)。
*/
import { composeQingguoLink } from '../../shared/utils/qingguo-link.ts'
@@ -27,6 +32,164 @@ export type ProxyProviderKey = 'qingguo' | 'jikip'
/** 代理模块 key(与后端 `UserSecretModule.PROXY.key()` 同值):写请求的路径段与「这一格是代理」的判据。 */
export const PROXY_MODULE_KEY = 'proxy'
+/* ------------------------------------------------------------------ *
+ * 检测结果的渲染档位(2026-11-02 加,起因是现网 uid=1 的 proxy 行)
+ *
+ * 后端 `UserApiSecretCheckService` 把青果检测从「无条件假通过」改成真提取后**按供应商返回码分档**,
+ * 于是 `check_code` 成了这一格到底怎么了的最细信号;而界面当时只认 `check_status` 三档
+ * (passed/failed/error),`error` 一律写成「无法判定」——`channel_busy`(青果通道被自己的采集
+ * 占着,等约 3 分钟就能重试)因此被显示成「查不出」,管理员既看不出「等一会就行」,
+ * 也分不清它和「密钥坏了」「欠费」是三种完全不同的处置。
+ *
+ * 所以现在**按码建表、按状态兜底**:
+ * - 认得的码 ⇒ 各有自己的档位(可重试这一族另给独立配色,既不红也不黄);
+ * - 「无法判定」只留给真正没有结论的情况(空码/这表里没有的码 + `check_status=error`);
+ * - `check_status=unknown`(后端 upsert 后的初值,等于「从没检测过」)仍是「未检测」,
+ * 不许冒充「无法判定」——那是两件事,前者点一次检测就有答案,后者点了也还是没答案。
+ *
+ * ⚠ 措辞的权威在后端:给人看的那句中文在 `check_message` 里,界面只出**档名**(一个词),
+ * 绝不按码自己拼句子;句子通过 `moduleTooltip`/行级 tooltip 原样透出。
+ * ------------------------------------------------------------------ */
+
+/** 药丸配色档位,对应 `UserSecretsPage.vue` 里 `.wh-pill.is-*` 那套样式类。 */
+export type StatusTone = 'is-allowed' | 'is-blocked' | 'is-warn' | 'is-retry' | 'is-unknown'
+
+/** 一个渲染档位:档名 + 配色。档名是给管理员扫一眼用的短词,不是解释句。 */
+export interface StatusBand {
+ label: string
+ tone: StatusTone
+}
+
+/** 单格「没配」与「没检测」是两档,但都用灰色:都不代表密钥本身有问题。 */
+export const NOT_CONFIGURED_BAND: StatusBand = { label: '未配置', tone: 'is-unknown' }
+export const NOT_CHECKED_BAND: StatusBand = { label: '未检测', tone: 'is-unknown' }
+/** 真的问不出结论(空码/未知码 + `check_status=error`)才落到这一档。 */
+export const INDETERMINATE_BAND: StatusBand = { label: '无法判定', tone: 'is-warn' }
+/** 后端 `STATUS_PASSED`(或码 `ok`):唯一可以当成「这项配好了」的一档。 */
+export const PASSED_BAND: StatusBand = { label: '通过', tone: 'is-allowed' }
+/** 后端新增了一档、前端还没登记码名时的兜底:按状态给个不撒谎的词,不当场判死。 */
+const GENERIC_FAILED_BAND: StatusBand = { label: '失败', tone: 'is-blocked' }
+
+/** 后端 `UserApiSecretCheckService` 的 `CODE_*` 全集(2026-11-02 逐条对着源码登记)。 */
+const CHECK_CODE_BANDS: Record = {
+ ok: PASSED_BAND,
+ /** 通道被自己的采集占着:等释放后重点一次,密钥没坏——这一档就是本次要修的错渲染。 */
+ channel_busy: { label: '待释放', tone: 'is-retry' },
+ rate_limited: { label: '限流重试', tone: 'is-retry' },
+ timeout: { label: '超时重试', tone: 'is-retry' },
+ /** 传输层失败:后端两个分支都给这个码(提取接口不可达=failed、探测异常=error),都可重试。 */
+ network_error: { label: '网络重试', tone: 'is-retry' },
+ server_error: { label: '上游重试', tone: 'is-retry' },
+ /** 欠费(现网 21 行):修之前就只有 `check_status=failed` 这一条路径认得它,改后按码认、不再吊在状态上。 */
+ insufficient_balance: { label: '欠费', tone: 'is-warn' },
+ /** 提取成功但链接里组不出可验连的地址(没带 key/pwd):要用户重填,不是「查不出」。 */
+ tunnel_unverified: { label: '链接缺账密', tone: 'is-warn' },
+ invalid_key: { label: '密钥失效', tone: 'is-blocked' },
+ forbidden: { label: '鉴权被拒', tone: 'is-blocked' },
+ bad_request: { label: '参数被拒', tone: 'is-blocked' },
+ provider_error: { label: '供应商报错', tone: 'is-blocked' },
+}
+
+/** 行级档位:后端 `UserApiSecretService` 按 failed > incomplete > passed > error > unknown 聚合,界面不重排这个优先级。 */
+const ROW_STATUS_BANDS: Record = {
+ passed: { label: '检测通过', tone: 'is-allowed' },
+ failed: { label: '检测失败', tone: 'is-blocked' },
+ incomplete: { label: '未配齐', tone: 'is-warn' },
+ error: INDETERMINATE_BAND,
+}
+/** 行级「可重试」:仅当整行的问题**只**出在可重试那一族码上时替换掉「无法判定」(后端给不了这一档,前端按格子的码补)。 */
+const ROW_RETRY_BAND: StatusBand = { label: '可重试', tone: 'is-retry' }
+
+/** 单模块的可比较形状(不引 `@/api/*`:本文件要能被零别名的 `node --test` 直测)。 */
+interface CheckModuleLike {
+ exists?: boolean | null
+ moduleLabel?: string | null
+ checkStatus?: string | null
+ checkCode?: string | null
+ checkMessage?: string | null
+}
+
+/** 一行的可比较形状:只用到行状态 + 三个格子。 */
+interface SecretRowLike {
+ status?: string | null
+ similarAsin?: CheckModuleLike | null
+ appearancePatent?: CheckModuleLike | null
+ proxy?: CheckModuleLike | null
+}
+
+/** 按归一后的键查档位表:空键与表里没有的键都返回 null(调用方兜底,绝不硬认一档)。 */
+function bandOf(table: Record, raw: unknown): StatusBand | null {
+ const key = normalizeKey(raw)
+ if (!key || !Object.prototype.hasOwnProperty.call(table, key)) return null
+ return table[key] ?? null
+}
+
+/** 码 → 档位;空码或这表里没有的码返回 null(由调用方按状态兜底,不硬认一档)。 */
+export function checkCodeBand(code: string | null | undefined): StatusBand | null {
+ return bandOf(CHECK_CODE_BANDS, code)
+}
+
+/** 这一档是不是「等一等再点」那一族(可重试):配色与行级补档都读这一个判据,不散落码名。 */
+export function isRetryBand(band: StatusBand | null | undefined): boolean {
+ return band?.tone === 'is-retry'
+}
+
+/**
+ * 单格状态药丸:先看是否已配置,再看 `check_status=passed`,然后**按 `check_code` 分档**,
+ * 都不认才按状态兜底。
+ */
+export function moduleStatusBand(module: CheckModuleLike | null | undefined): StatusBand {
+ if (!module || !module.exists) return NOT_CONFIGURED_BAND
+ const status = normalizeKey(module.checkStatus)
+ if (status === 'passed') return PASSED_BAND
+ const band = checkCodeBand(module.checkCode)
+ if (band) return band
+ if (status === 'error') return INDETERMINATE_BAND
+ if (status === 'failed') return GENERIC_FAILED_BAND
+ // ''/unknown/后端下一版新增的状态值:宁可说「未检测」,也不替后端编造一个结论
+ return NOT_CHECKED_BAND
+}
+
+/** 行级状态药丸:后端聚合成 `error` 时,若这一行**没有结论的格子全是可重试那一族**,补成「可重试」。 */
+export function rowStatusBand(row: SecretRowLike | null | undefined): StatusBand {
+ const status = normalizeKey(row?.status)
+ if (status === 'error' && awaitsRetryOnly(row)) return ROW_RETRY_BAND
+ // 行级 `unknown`=后端还没问过(不是「问了问不出」),留「未检测」这一档,与筛选项里那一行同词
+ return bandOf(ROW_STATUS_BANDS, status) ?? NOT_CHECKED_BAND
+}
+
+/**
+ * 这一行是不是「点一次就有答案」:后端把 error 之上的 failed/incomplete 都判掉了才轮到 error,
+ * 所以这里只需再确认剩下那些没通过的格子都落在可重试档——混进一格「链接缺账密」就不算可重试,
+ * 那一格不会自己好,把整行说成「可重试」等于让管理员一直等。
+ */
+function awaitsRetryOnly(row: SecretRowLike | null | undefined): boolean {
+ const pending = modulesOf(row).filter(
+ (module) => Boolean(module?.exists) && normalizeKey(module?.checkStatus) !== 'passed',
+ )
+ return pending.length > 0 && pending.every((module) => isRetryBand(moduleStatusBand(module)))
+}
+
+/**
+ * 行级 tooltip 的明细:逐格把**后端原文** `check_message` 抄出来(运维判「是欠费还是被自己占着」就靠这句)。
+ * 前端不拼句子、不改一个字;没检测过的格子没有这句话,自然不出现。
+ */
+export function rowDetailLines(row: SecretRowLike | null | undefined): string[] {
+ return modulesOf(row)
+ .filter((module) => Boolean(module?.exists))
+ .map((module) => {
+ const message = String(module?.checkMessage ?? '').trim()
+ if (!message) return ''
+ const label = String(module?.moduleLabel ?? '').trim()
+ return label ? `${label}:${message}` : message
+ })
+ .filter(Boolean)
+}
+
+function modulesOf(row: SecretRowLike | null | undefined): CheckModuleLike[] {
+ return [row?.similarAsin, row?.appearancePatent, row?.proxy].filter(Boolean) as CheckModuleLike[]
+}
+
/** 后端 `ProxyProvider.DEFAULT`=极客:新建默认极客,青果手动切(2026-10-30 拍板)。 */
export const DEFAULT_PROXY_PROVIDER: ProxyProviderKey = 'jikip'
diff --git a/admin-frontend-vue/tests/baselines/source-pin-ledger.json b/admin-frontend-vue/tests/baselines/source-pin-ledger.json
index 10466d467..82d272284 100644
--- a/admin-frontend-vue/tests/baselines/source-pin-ledger.json
+++ b/admin-frontend-vue/tests/baselines/source-pin-ledger.json
@@ -1,10 +1,10 @@
{
"note": "readSource 钉子逐文件基线。两把尺子:pins=落在用例体内的读盘,reads=全文读点总数(含模块级夹具与 helper)。都只许减;pins 下降而 reads 没同步下降=把读盘挪出体内,不算改进。由 tests/source-pin-ratchet.test.ts 生成。",
"totals": {
- "files": 252,
- "cases": 1753,
- "pins": 456,
- "reads": 651
+ "files": 253,
+ "cases": 1772,
+ "pins": 457,
+ "reads": 652
},
"files": {
"admin-scaffold.test.ts": {
@@ -1266,6 +1266,11 @@
"cases": 4,
"pins": 0,
"reads": 1
+ },
+ "密钥货源标签与代理脱敏.test.ts": {
+ "cases": 19,
+ "pins": 1,
+ "reads": 1
}
}
}
\ No newline at end of file
diff --git a/admin-frontend-vue/tests/mount/user-secret-status-band.mount.test.ts b/admin-frontend-vue/tests/mount/user-secret-status-band.mount.test.ts
new file mode 100644
index 000000000..2b46916c2
--- /dev/null
+++ b/admin-frontend-vue/tests/mount/user-secret-status-band.mount.test.ts
@@ -0,0 +1,262 @@
+/**
+ * 密钥管理列表页「检测结果分档」的界面侧判据(2026-11-02)。
+ *
+ * 现网证据:库里 uid=1 的 proxy 行是 `check_status=error / check_code=channel_busy`,
+ * 数据是对的、界面不认识这个码,于是渲染成「无法判定」——管理员分不清
+ * 「被自己的采集占着(等 3 分钟再点)」「密钥坏了」「欠费」这三种完全不同的处置。
+ *
+ * 这一支跑真组件+真 pinia store,API 用假数据顶掉,逐档核对:
+ * ① 药丸文字与配色类名(`is-retry` 是新档,既不红也不黄);
+ * ② 悬停详情里能看到后端 `check_message` 原文(措辞权威在后端,界面只搬运);
+ * ③ 一格上的两颗药丸分别取 `channel`(货源)与 `check_status`/`check_code`(状态)——
+ * 把状态当渠道渲染(或反过来)会在这里红。
+ *
+ * 夹具里的凭据一律假值(fakekey/fakepwd/sk-fake),本仓有尺子按长度+高熵认凭据。
+ *
+ * 跑法:`npx vitest run tests/mount/user-secret-status-band.mount.test.ts`
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { flushPromises, mount, type VueWrapper } from '@vue/test-utils'
+import { createPinia, setActivePinia, type Pinia } from 'pinia'
+
+import UserSecretsPage from '@/pages/account/UserSecretsPage.vue'
+import { useAdminSessionStore } from '@/stores/admin-session'
+import { useCompanyTabStore } from '@/stores/company-tab'
+
+const secretsApi = vi.hoisted(() => ({
+ fetchUserSecretList: vi.fn(),
+ checkUserSecret: vi.fn(),
+ deleteUserSecret: vi.fn(),
+ saveUserSecretModule: vi.fn(),
+ clearUserSecretModule: vi.fn(),
+}))
+
+vi.mock('@/api/user-secrets', () => secretsApi)
+
+/** 后端那句人话(CHANNEL_BUSY_MESSAGE 的形状):措辞权威在后端,界面只原样透出。 */
+const BUSY_MESSAGE = '通道正被你自己的采集占着,等约 3 分钟释放后再点检测'
+const BALANCE_MESSAGE = '代理服务商余额不足,请充值后重试'
+const MASKED_PROXY = 'https://overseas.proxy.qg.net'
+
+function moduleCell(moduleKey: string, over: Record = {}) {
+ return {
+ moduleKey,
+ moduleLabel: moduleKey,
+ channel: null,
+ masked: 'sk-f****9BgQ',
+ full: '',
+ exists: true,
+ locked: false,
+ checkStatus: 'passed',
+ checkCode: 'ok',
+ checkMessage: '连通正常',
+ checkLatencyMs: 12,
+ checkedAt: '2026-11-02T15:51:07',
+ updatedAt: '2026-11-02T15:51:07',
+ ...over,
+ }
+}
+
+function row(over: Record = {}) {
+ return {
+ userId: 7,
+ username: 'alice',
+ groups: [],
+ leaderUsername: '',
+ similarAsin: moduleCell('similar-asin', { moduleLabel: '货源查询密钥', channel: 'longtaitou' }),
+ appearancePatent: moduleCell('appearance-patent', { moduleLabel: '外观专利密钥', channel: 't8star' }),
+ proxy: moduleCell('proxy', { moduleLabel: '代理设置', channel: 'qingguo', masked: MASKED_PROXY }),
+ status: 'passed',
+ statusMessage: '三项均检测通过',
+ createdAt: '2026-11-01T09:00:00',
+ updatedAt: '2026-11-02T15:51:07',
+ ...over,
+ }
+}
+
+/** 表头文字定位列(不靠列序数:加列就会全体错位),返回该格里的药丸。 */
+function pills(wrapper: VueWrapper, header: string) {
+ const headers = wrapper.findAll('thead th').map((th) => th.text().trim())
+ const index = headers.findIndex((label) => label.includes(header))
+ expect(index, `表头里找不到「${header}」`).toBeGreaterThanOrEqual(0)
+ return wrapper.findAll('tbody tr')[0].findAll('td')[index].findAll('.wh-pill').map((pill) => ({
+ text: pill.text().trim(),
+ classes: pill.classes(),
+ title: pill.attributes('title') ?? '',
+ }))
+}
+
+function cellText(wrapper: VueWrapper, header: string): string {
+ const headers = wrapper.findAll('thead th').map((th) => th.text().trim())
+ const index = headers.findIndex((label) => label.includes(header))
+ return wrapper.findAll('tbody tr')[0].findAll('td')[index].text()
+}
+
+describe('密钥管理页:检测结果按 check_code 分档渲染', () => {
+ let pinia: Pinia
+
+ beforeEach(() => {
+ vi.clearAllMocks()
+ pinia = createPinia()
+ setActivePinia(pinia)
+ useAdminSessionStore().user = { id: 1, username: 'root', role: 'super_admin' }
+ useCompanyTabStore().setActiveId(1)
+ })
+
+ async function mountWith(rowValue: Record) {
+ secretsApi.fetchUserSecretList.mockResolvedValue({ items: [rowValue], total: 1, page: 1, pageSize: 15, groupOptions: [] })
+ const wrapper = mount(UserSecretsPage, { global: { plugins: [pinia] } })
+ await flushPromises()
+ return wrapper
+ }
+
+ /** 现网 uid=1 那一行的形状:error + channel_busy。 */
+ function busyRow() {
+ return row({
+ status: 'error',
+ statusMessage: '存在无法判定的检测结果',
+ proxy: moduleCell('proxy', {
+ moduleLabel: '代理设置',
+ channel: 'qingguo',
+ masked: MASKED_PROXY,
+ checkStatus: 'error',
+ checkCode: 'channel_busy',
+ checkMessage: BUSY_MESSAGE,
+ }),
+ })
+ }
+
+ it('channel_busy 渲染成「待释放」+独立配色,不再掉进「无法判定」', async () => {
+ const wrapper = await mountWith(busyRow())
+ const proxyPills = pills(wrapper, '代理设置')
+ const statusPill = proxyPills[proxyPills.length - 1]
+ expect(statusPill.text).toBe('待释放')
+ expect(statusPill.classes).toContain('is-retry')
+ expect(cellText(wrapper, '代理设置')).not.toContain('无法判定')
+ // 供应商那颗药丸还在原位:改的是状态档,不是把货源档挤掉
+ expect(proxyPills[0].text).toBe('青果')
+ expect(proxyPills[0].classes).toContain('is-source')
+ })
+
+ it('整行只剩「等一等」那一族时,行级状态列补成「可重试」', async () => {
+ const wrapper = await mountWith(busyRow())
+ const rowPill = pills(wrapper, '状态')[0]
+ expect(rowPill.text).toBe('可重试')
+ expect(rowPill.classes).toContain('is-retry')
+ expect(rowPill.text).not.toBe('无法判定')
+ })
+
+ it('混进一格「不会自己好」的问题时,行级不许谎报可重试', async () => {
+ const wrapper = await mountWith({
+ ...busyRow(),
+ appearancePatent: moduleCell('appearance-patent', {
+ moduleLabel: '外观专利密钥',
+ channel: 't8star',
+ checkStatus: 'error',
+ checkCode: 'tunnel_unverified',
+ checkMessage: '这条链接里没有可用于隧道验连的账密,请重新填写',
+ }),
+ })
+ expect(pills(wrapper, '状态')[0].text).toBe('无法判定')
+ expect(pills(wrapper, '外观专利密钥').at(-1)!.text).toBe('链接缺账密')
+ })
+
+ it('悬停能看到后端 check_message 原文:单格与行级 tooltip 都带上', async () => {
+ const wrapper = await mountWith(busyRow())
+ const proxyStatusTitle = pills(wrapper, '代理设置').at(-1)!.title
+ expect(proxyStatusTitle).toContain(BUSY_MESSAGE)
+ expect(proxyStatusTitle).toContain(MASKED_PROXY, '脱敏值仍然在同一条 tooltip 里')
+ const rowTitle = pills(wrapper, '状态')[0].title
+ expect(rowTitle).toContain('存在无法判定的检测结果', '后端行级摘要不动')
+ expect(rowTitle).toContain(`代理设置:${BUSY_MESSAGE}`, '运维判「是欠费还是被自己占着」就靠这句')
+ })
+
+ it('欠费(现网 21 行)保留自己那一档,不被新码表挤去「无法判定」', async () => {
+ const wrapper = await mountWith(row({
+ status: 'failed',
+ statusMessage: '存在检测失败的配置',
+ proxy: moduleCell('proxy', {
+ moduleLabel: '代理设置',
+ channel: 'qingguo',
+ masked: MASKED_PROXY,
+ checkStatus: 'failed',
+ checkCode: 'insufficient_balance',
+ checkMessage: BALANCE_MESSAGE,
+ }),
+ }))
+ const balancePill = pills(wrapper, '代理设置').at(-1)!
+ expect(balancePill.text).toBe('欠费')
+ expect(balancePill.classes).toContain('is-warn')
+ expect(pills(wrapper, '状态')[0].text).toBe('检测失败', '行级优先级是后端的:failed 永远压过 error')
+ expect(pills(wrapper, '代理设置').at(-1)!.title).toContain(BALANCE_MESSAGE)
+ })
+
+ it('密钥坏了与查不出是两档:invalid_key 红、空码/未知码才是「无法判定」', async () => {
+ const wrapper = await mountWith(row({
+ status: 'error',
+ similarAsin: moduleCell('similar-asin', { moduleLabel: '货源查询密钥', channel: 'longtaitou', checkStatus: 'failed', checkCode: 'invalid_key', checkMessage: '密钥无效(401)' }),
+ appearancePatent: moduleCell('appearance-patent', { moduleLabel: '外观专利密钥', channel: 't8star', checkStatus: 'error', checkCode: '', checkMessage: '' }),
+ proxy: moduleCell('proxy', { moduleLabel: '代理设置', channel: 'qingguo', masked: MASKED_PROXY, checkStatus: 'error', checkCode: 'a_code_not_registered', checkMessage: '' }),
+ }))
+ expect(pills(wrapper, '货源查询密钥').at(-1)!.text).toBe('密钥失效')
+ expect(pills(wrapper, '货源查询密钥').at(-1)!.classes).toContain('is-blocked')
+ expect(pills(wrapper, '外观专利密钥').at(-1)!.text).toBe('无法判定')
+ expect(pills(wrapper, '代理设置').at(-1)!.text).toBe('无法判定')
+ })
+
+ it('没配与没检测不许冒充「无法判定」', async () => {
+ const wrapper = await mountWith(row({
+ status: 'unknown',
+ statusMessage: '存在尚未检测的配置',
+ similarAsin: moduleCell('similar-asin', { moduleLabel: '货源查询密钥', exists: false, checkStatus: 'unknown', checkCode: '', checkMessage: '' }),
+ appearancePatent: moduleCell('appearance-patent', { moduleLabel: '外观专利密钥', channel: 't8star', checkStatus: 'unknown', checkCode: '', checkMessage: '' }),
+ }))
+ expect(pills(wrapper, '货源查询密钥').at(-1)!.text).toBe('未配置')
+ expect(cellText(wrapper, '货源查询密钥')).toContain('未配置')
+ expect(pills(wrapper, '外观专利密钥').at(-1)!.text).toBe('未检测')
+ expect(pills(wrapper, '状态')[0].text).toBe('未检测')
+ })
+
+ it('一格上的两颗药丸不同源:货源取 channel、状态取 check_status/check_code', async () => {
+ // 把代理供应商值塞进 LLM 行的 channel:货源那颗药丸必须认不出(走「—」),
+ // 状态那颗仍按 check_code 出「鉴权被拒」——两值互不串门,才是「不同源」的正证。
+ const wrapper = await mountWith(row({
+ status: 'failed',
+ similarAsin: moduleCell('similar-asin', { moduleLabel: '货源查询密钥', channel: 'qingguo', checkStatus: 'failed', checkCode: 'forbidden', checkMessage: '密钥被拒绝(403)' }),
+ appearancePatent: moduleCell('appearance-patent', { moduleLabel: '外观专利密钥', channel: 't8star', checkStatus: 'passed', checkCode: 'ok' }),
+ }))
+ const similarPills = pills(wrapper, '货源查询密钥')
+ expect(similarPills[0].text).toBe('—')
+ expect(similarPills[1].text).toBe('鉴权被拒')
+ // 反向:把状态词塞进渠道位也不会被认成货源
+ const llmPills = pills(wrapper, '外观专利密钥')
+ expect(llmPills[0].text).toBe('贞贞')
+ expect(llmPills[1].text).toBe('通过')
+ expect(llmPills[0].classes).toContain('is-source')
+ expect(llmPills[1].classes).toContain('is-allowed')
+ })
+
+ it('筛选项把 error 这一档的两个可能读法都点名(选了要能筛到待释放的行)', async () => {
+ const wrapper = await mountWith(busyRow())
+ const options = wrapper.findAll('.secrets-filter-row select')[0].findAll('option').map((option) => option.text().trim())
+ expect(options).toContain('无法判定/可重试')
+ expect(options).not.toContain('无法判定')
+ })
+
+ it('立即检测的 toast 用后端那句原文,不再硬写「无法判定」', async () => {
+ secretsApi.fetchUserSecretList.mockResolvedValue({ items: [busyRow()], total: 1, page: 1, pageSize: 15, groupOptions: [] })
+ secretsApi.checkUserSecret.mockResolvedValue([
+ { moduleKey: 'proxy', checkStatus: 'error', checkCode: 'channel_busy', checkMessage: BUSY_MESSAGE, checkLatencyMs: 30, checkedAt: '2026-11-02T15:51:07', viaProxy: false },
+ ])
+ const wrapper = mount(UserSecretsPage, { global: { plugins: [pinia] } })
+ await flushPromises()
+ const checkButton = wrapper.findAll('button').find((button) => button.text().trim() === '立即检测')
+ expect(checkButton, '行内应有「立即检测」入口').toBeDefined()
+ await checkButton!.trigger('click')
+ await flushPromises()
+ // ElMessage 真渲染进 body:读的是那一句后端原文,不是界面自己拼的「部分配置本次无法判定」
+ const shown = document.body.textContent ?? ''
+ expect(shown).toContain(BUSY_MESSAGE)
+ expect(shown).not.toContain('部分配置本次无法判定')
+ })
+})
diff --git a/admin-frontend-vue/tests/密钥货源标签与代理脱敏.test.ts b/admin-frontend-vue/tests/密钥货源标签与代理脱敏.test.ts
index 103eca860..e63a2c6a9 100644
--- a/admin-frontend-vue/tests/密钥货源标签与代理脱敏.test.ts
+++ b/admin-frontend-vue/tests/密钥货源标签与代理脱敏.test.ts
@@ -1,20 +1,31 @@
import test from 'node:test'
import assert from 'node:assert/strict'
+import { readSource } from './helpers.ts'
import {
DEFAULT_PROXY_PROVIDER,
+ INDETERMINATE_BAND,
+ NOT_CHECKED_BAND,
+ PASSED_BAND,
UNKNOWN_SOURCE_LABEL,
buildProxyEntryPayload,
+ checkCodeBand,
emptyProxyEntryDraft,
+ isRetryBand,
llmSourceLabel,
+ moduleStatusBand,
proxyDisplayText,
proxySourceLabel,
+ rowDetailLines,
+ rowStatusBand,
validateProxyEntry,
} from '../src/pages/account/user-secret-model.ts'
import { QINGGUO_EXTRACT_URL, composeQingguoLink } from '../src/shared/utils/qingguo-link.ts'
-// 密钥管理页(后管)两条收口的判据(2026-11-02):
+// 密钥管理页(后管)三条收口的判据(2026-11-02):
// ① 货源标签按模块分字典——代理列只认供应商,LLM 渠道名不许出现在代理行上;
-// ② 代理列只显示后端脱敏值(masked),界面既不回落原文、也没有可预填的整条链接。
+// ② 代理列只显示后端脱敏值(masked),界面既不回落原文、也没有可预填的整条链接;
+// ③ 检测结果按 `check_code` 分档——后端今天把青果检测分成一族供应商码,界面只认
+// `check_status` 三档就会把「通道被自己占着」和「密钥坏了」「欠费」挤成同一句「无法判定」。
// 夹具里的 key/pwd 全是假值(fakekey/fakepwd),本仓有尺子按长度+高熵认凭据。
test('代理列只认供应商:LLM 渠道值在代理列认不出', () => {
@@ -100,3 +111,168 @@ test('载荷带上这一单的供应商:channel 缺失会被后端按域名识
assert.equal(buildProxyEntryPayload({ provider: 'qingguo', authkey: 'fakekey', authpwd: 'fakepwd', link: '' })?.channel, 'qingguo')
assert.equal(buildProxyEntryPayload({ provider: 'jikip', authkey: '', authpwd: '', link: 'https://api.example.test/ip-get' })?.channel, 'jikip')
})
+
+/* ------------------------------------------------------------------ *
+ * ③ 检测结果按 check_code 分档(2026-11-02)
+ *
+ * 码集与状态取自后端 `UserApiSecretCheckService` 的 `CODE_*`/`STATUS_*`(逐条对着源码抄):
+ * `channel_busy`、`tunnel_unverified`、`rate_limited`、`timeout`、`network_error`、`server_error`
+ * 落 `error`;`insufficient_balance`、`invalid_key`、`forbidden`、`bad_request`、`provider_error`、
+ * `network_error`(提取接口不可达那一支)落 `failed`;`ok` 落 `passed`。
+ * 界面只看 `check_status` 的话,前一半全被挤成「无法判定」——现网 uid=1 的 proxy 行就是这么花的。
+ * ------------------------------------------------------------------ */
+
+/** 后端 2026-11-02 那一版实际会下发的码全集(新增码时这张清单要一起长)。 */
+const BACKEND_CHECK_CODES = [
+ 'ok',
+ 'channel_busy',
+ 'invalid_key',
+ 'forbidden',
+ 'bad_request',
+ 'rate_limited',
+ 'server_error',
+ 'network_error',
+ 'timeout',
+ 'provider_error',
+ 'insufficient_balance',
+ 'tunnel_unverified',
+]
+
+/** 已配置的一格(默认 error + 空码:那是「问了问不出」的形状,不是任何一档码)。 */
+function checkedModule(over: Record = {}) {
+ return { exists: true, moduleLabel: '代理设置', checkStatus: 'error', checkCode: '', checkMessage: '', ...over }
+}
+
+test('后端分出的每一档码都不许掉进「无法判定」(逐码扫全集)', () => {
+ const offenders: string[] = []
+ for (const code of BACKEND_CHECK_CODES) {
+ // 同一个码在 error/failed 两个状态下都扫一遍:`network_error` 后端就两支都用
+ for (const status of ['error', 'failed']) {
+ const band = moduleStatusBand(checkedModule({ checkCode: code, checkStatus: status }))
+ if (band.label === INDETERMINATE_BAND.label) offenders.push(`${status}/${code}`)
+ }
+ }
+ assert.deepEqual(offenders, [], '这些码又被当成「无法判定」渲染:' + offenders.join(', '))
+})
+
+test('逐码档位表:档名与配色都登记在案(可重试那一族既不正红也不黄)', () => {
+ const table: Array<[string, string, string]> = [
+ ['ok', '通过', 'is-allowed'],
+ ['channel_busy', '待释放', 'is-retry'],
+ ['rate_limited', '限流重试', 'is-retry'],
+ ['timeout', '超时重试', 'is-retry'],
+ ['network_error', '网络重试', 'is-retry'],
+ ['server_error', '上游重试', 'is-retry'],
+ ['insufficient_balance', '欠费', 'is-warn'],
+ ['tunnel_unverified', '链接缺账密', 'is-warn'],
+ ['invalid_key', '密钥失效', 'is-blocked'],
+ ['forbidden', '鉴权被拒', 'is-blocked'],
+ ['bad_request', '参数被拒', 'is-blocked'],
+ ['provider_error', '供应商报错', 'is-blocked'],
+ ]
+ assert.deepEqual(table.map((row) => row[0]).sort(), [...BACKEND_CHECK_CODES].sort(), '这张表与码集不同步:漏档就红')
+ for (const [code, label, tone] of table) {
+ const band = moduleStatusBand(checkedModule({ checkCode: code }))
+ assert.equal(band.label, label, `码 ${code} 的档名变了`)
+ assert.equal(band.tone, tone, `码 ${code} 的配色变了`)
+ assert.ok(band.label.length <= 5, `档名「${band.label}」超过 5 字:状态列 130px 会把药丸裁掉`)
+ }
+})
+
+test('变异钉子:把 channel_busy 改回「不认识」立刻红', () => {
+ const busy = moduleStatusBand(checkedModule({ checkCode: 'channel_busy' }))
+ const blank = moduleStatusBand(checkedModule({ checkCode: '' }))
+ // 这一条就是今天的线上形状:认不出码 ⇒ 与空码同档 ⇒ 显示「无法判定」
+ assert.notDeepEqual(busy, blank, 'channel_busy 与空码同档=又回到「error 一律无法判定」')
+ assert.ok(isRetryBand(busy), 'channel_busy 必须落在可重试那一族')
+ assert.equal(busy.tone, 'is-retry')
+ assert.notEqual(busy.tone, INDETERMINATE_BAND.tone, '可重试与查不出必须是两种配色')
+})
+
+test('欠费(现网 21 行)有自己的一档,且不再吊在 check_status=failed 上', () => {
+ const broke = checkedModule({ checkCode: 'insufficient_balance' })
+ assert.deepEqual(moduleStatusBand(broke), { label: '欠费', tone: 'is-warn' })
+ // 后端哪天把欠费落成 error,界面仍然说欠费(按码判档,不看状态脸色)
+ assert.deepEqual(moduleStatusBand({ ...broke, checkStatus: 'error' }), { label: '欠费', tone: 'is-warn' })
+ assert.notEqual(moduleStatusBand(broke).label, INDETERMINATE_BAND.label)
+})
+
+test('「无法判定」只留给真没结论:空码与未知码才落这一档', () => {
+ assert.deepEqual(moduleStatusBand(checkedModule({ checkCode: '' })), INDETERMINATE_BAND)
+ assert.deepEqual(moduleStatusBand(checkedModule({ checkCode: ' ' })), INDETERMINATE_BAND)
+ assert.deepEqual(moduleStatusBand(checkedModule({ checkCode: 'a_code_backend_has_not_invented_yet' })), INDETERMINATE_BAND)
+ // 没问过的格子不是「问不出」:后端 upsert 后 check_status=unknown,这里留「未检测」
+ assert.deepEqual(moduleStatusBand(checkedModule({ checkStatus: 'unknown' })), NOT_CHECKED_BAND)
+ assert.deepEqual(moduleStatusBand(checkedModule({ checkStatus: '' })), NOT_CHECKED_BAND)
+ assert.notDeepEqual(NOT_CHECKED_BAND, INDETERMINATE_BAND, '「未检测」与「无法判定」是两件事,不许并档')
+ // 未配置优先于一切状态
+ assert.deepEqual(moduleStatusBand(checkedModule({ exists: false, checkCode: 'channel_busy' })), { label: '未配置', tone: 'is-unknown' })
+ assert.deepEqual(moduleStatusBand(undefined), { label: '未配置', tone: 'is-unknown' })
+ // 后端新增一档状态而前端没登记:failed 兜底成「失败」,不把坏说成查不出
+ assert.equal(moduleStatusBand(checkedModule({ checkStatus: 'failed', checkCode: 'brand_new_code' })).tone, 'is-blocked')
+})
+
+test('passed 状态一律「通过」:码位上留着旧值也不许翻档', () => {
+ assert.deepEqual(moduleStatusBand(checkedModule({ checkStatus: 'passed', checkCode: 'ok' })), PASSED_BAND)
+ // 后端 applyCheckOutcome 状态与码是同一条 UPDATE,留旧码属异常;此时以状态为准,不给管理员一个假红灯
+ assert.deepEqual(moduleStatusBand(checkedModule({ checkStatus: 'passed', checkCode: 'timeout' })), PASSED_BAND)
+})
+
+test('码名归一:大小写与首尾空格不改变档位', () => {
+ assert.deepEqual(checkCodeBand(' CHANNEL_BUSY '), checkCodeBand('channel_busy'))
+ assert.deepEqual(checkCodeBand('Insufficient_Balance')?.label, '欠费')
+ assert.equal(checkCodeBand(null), null)
+ assert.equal(checkCodeBand(undefined), null)
+ assert.equal(checkCodeBand(''), null)
+})
+
+test('行级状态:整行只剩可重试那一族时补成「可重试」,混进别的就还「无法判定」', () => {
+ const busyRow = {
+ status: 'error',
+ similarAsin: checkedModule({ moduleLabel: '货源查询密钥', checkStatus: 'passed', checkCode: 'ok' }),
+ appearancePatent: checkedModule({ moduleLabel: '外观专利密钥', checkStatus: 'passed', checkCode: 'ok' }),
+ proxy: checkedModule({ checkStatus: 'error', checkCode: 'channel_busy' }),
+ }
+ assert.deepEqual(rowStatusBand(busyRow), { label: '可重试', tone: 'is-retry' })
+ // 另一格是「链接缺账密」:那一格不会自己好,把整行说成可重试等于让管理员一直等
+ assert.deepEqual(rowStatusBand({ ...busyRow, appearancePatent: checkedModule({ checkCode: 'tunnel_unverified' }) }), INDETERMINATE_BAND)
+ // 后端行级聚合的其余取值原样保留(优先级是后端的,界面不重排)
+ assert.deepEqual(rowStatusBand({ status: 'passed' }), { label: '检测通过', tone: 'is-allowed' })
+ assert.deepEqual(rowStatusBand({ status: 'failed' }), { label: '检测失败', tone: 'is-blocked' })
+ assert.deepEqual(rowStatusBand({ status: 'incomplete' }), { label: '未配齐', tone: 'is-warn' })
+ assert.deepEqual(rowStatusBand({ status: 'unknown' }), NOT_CHECKED_BAND)
+ assert.deepEqual(rowStatusBand({ status: 'error' }), INDETERMINATE_BAND, '行级 error 但一格码都认不出时仍是「无法判定」')
+ assert.deepEqual(rowStatusBand(null), NOT_CHECKED_BAND)
+})
+
+test('行级明细逐字搬后端 check_message:前端不改写、不另拼句子', () => {
+ const busyMessage = '后端原话:通道被占,等约 3 分钟再点'
+ const lines = rowDetailLines({
+ status: 'error',
+ similarAsin: checkedModule({ moduleLabel: '货源查询密钥', checkStatus: 'passed', checkCode: 'ok', checkMessage: '连通正常' }),
+ appearancePatent: checkedModule({ moduleLabel: '外观专利密钥', exists: false, checkMessage: '' }),
+ proxy: checkedModule({ checkStatus: 'error', checkCode: 'channel_busy', checkMessage: busyMessage }),
+ })
+ assert.deepEqual(lines, ['货源查询密钥:连通正常', `代理设置:${busyMessage}`])
+ assert.ok(lines[1].endsWith(busyMessage), `后端那句被改写了:${lines[1]}`)
+ // 没有 message 的格子不占位(否则 tooltip 里一串空段,运维读不到重点)
+ assert.deepEqual(rowDetailLines({ proxy: checkedModule({ checkMessage: ' ' }) }), [])
+})
+
+test('页面只有一张码表:不留旧 switch、tooltip 取后端 checkMessage、is-retry 真有条配色', () => {
+ const page = readSource('src/pages/account/UserSecretsPage.vue')
+ // ① 页面不得自带第二张表:两处各判各的,后端加分档时界面只会漏(今天漏的就是 channel_busy)
+ for (const code of BACKEND_CHECK_CODES) {
+ // 'ok' 这种两字母串当子串查必然误报(token/lock 里就有),它也不是会漏进旧 switch 的那族
+ if (code.length < 4) continue
+ assert.ok(!page.includes(code), `页面里又写了一遍码名 ${code}`)
+ }
+ assert.ok(!/case 'error':/.test(page), "页面里还留着按状态硬分档的旧 switch('error' 一律「无法判定」)")
+ assert.match(page, /moduleStatusBand\(/, '单格药丸必须走模型那一档')
+ assert.match(page, /rowStatusBand\(row\)/, '行级药丸必须吃整行:后端只剩一个 error,逐格码才说得清')
+ // ② 悬停那句必须是后端原文,且不许开回 `full` 那条旁路
+ assert.match(page, /module\.checkMessage/, 'tooltip 要的是后端那句人话(运维判欠费还是被自己占着就靠它)')
+ assert.ok(!/module\.full/.test(page), '不得读 full:后台侧恒空,读它等于把脱敏前的行为留在界面里')
+ // ③ 新档位得真有条样式,否则 is-retry 渲染出来是无框无底的裸文本
+ assert.match(page, /\.wh-pill\.is-retry\s*\{[^}]*background/, '页面没有 .is-retry 这一档配色')
+})