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 这一档配色') +})