Files
ssw-mvp/docs/e2e/lib/dsl.mjs
T
admin 35edaaa702 chore: dag-panel 重组子目录 + web 头部用户修复 + 清理临时文件
- docs/e2e: 将 DAG 演示面板(dag-panel.mjs/html/data.mjs/sh/DAG演示.command)用 git mv 归入 dag-panel/ 子目录;修正相对依赖 ../lib、../results/dag-runs;清理 _diag_*.mjs 等临时诊断脚本(git rm 已跟踪项,rm 未跟踪项)
- web: 修复头部用户名称切账号不变(新增 utils/user.ts 响应式 userName,登录/挂载/路由切换时拉取 /oauth/CurrentUser)
- .gitignore: 新增 __pycache__/*.pyc 忽略规则(排除 demo 构建产物)
- demo: 多个演示脚本与算子集市用例更新
- .workbuddy/memory: 补充本次工作记录

注意:docs/e2e/sswflow 与 **/__pycache__/*.pyc 按要求排除,未纳入。
2026-08-11 15:31:41 +08:00

981 lines
42 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import fs from 'node:fs'
import path from 'node:path'
import { ACCOUNT, ACTION_TIMEOUT, BE_BASE, FE_BASE, PASSWORD, SHOTS_DIR, TOKEN_KEY } from './config.mjs'
import { encryptPassword } from './cipher.mjs'
import { humanClick, humanFill, humanHover, humanPress, humanScrollTo, humanViewportFlicker, jitter } from './human.mjs'
/**
* 用例 DSL —— 344 条脚本共用的动作与断言。
*
* 页面这边有个很大的便利:TDS/TDC 绝大多数管理页都由 web/src/components/ssw/common/CrudPage.vue
* 渲染,DOM 是统一的(新建按钮 / 抽屉表单 / 行内链接按钮 / prompt 弹窗 / 关键字搜索)。
* 所以这里的选择器按那份组件的结构来写,一次写对,全站通用。
*
* 注意:项目没有给 ant-design-vue 配中文 locale,Modal/Popconfirm 的确认按钮文案是
* 组件库默认英文(OK/Cancel)。因此凡是组件库自带的按钮一律按 .ant-btn-primary 类名点,
* 不去赌文案;只有业务自己写死的中文(新建/保存/查询/删除…)才按文本定位。
*
* 所有浏览器操作(click/fill/hover/scroll)默认走「人类行为模拟」(lib/human.mjs):
* 鼠标移动走贝塞尔曲线 + 悬停停顿 + 字符级键入 + 操作间随机抖动;
* 只有 URL 跳转、addInitScript 注入、网络 API 调用保持程序式(这些必须程序化)。
*/
export class SkipError extends Error {
constructor(msg) {
super(msg)
this.name = 'SkipError'
this.isSkip = true
}
}
export class ManualError extends Error {
constructor(msg) {
super(msg)
this.name = 'ManualError'
this.isManual = true
}
}
export class AssertError extends Error {
constructor(msg) {
super(msg)
this.name = 'AssertError'
}
}
/**
* 按钮文案匹配 —— Ant Design 会给「恰好两个汉字」的按钮中间插一个空格
* (`新建` 实际渲染成 `新 建`),但 type="link" / "text" 的按钮又不插
* (所以 `编辑`/`删除` 保持原样)。两种都要能点中,统一按「忽略空白」匹配。
*/
export function btnName(label) {
const body = [...label].map((ch) => ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('\\s*')
return new RegExp(`^\\s*${body}\\s*$`)
}
/**
* 后端统一返回 `{ code, msg, data }`。脚本里两种写法都常见:
* - 读信封:`r.code` / `r.msg` / `r.data`
* - 直接读数据:`r.id` / `r.account` / `r.userId`(把 `r` 当成 data 本体)
* 这里用 Proxy 让两者都成立:顶层字段优先走信封,查不到时回落到 `data` 上的字段。
* 这样历史脚本「忘了写 .data」的写法也能跑,不必逐条改;真正的产品缺陷(data 里也没有该字段)仍会如实报 undefined。
*/
export function wrapEnvelope(json) {
if (json == null || typeof json !== 'object') return json
const data = json.data
const isObj = data != null && typeof data === 'object'
return new Proxy(json, {
get(target, prop, receiver) {
if (prop === 'toJSON') return () => target
if (typeof prop === 'symbol') return Reflect.get(target, prop, receiver)
if (prop in target) return target[prop]
if (isObj && prop in data) return data[prop]
return undefined
},
has(target, prop) {
if (prop in target) return true
if (isObj && prop in data) return true
return false
},
ownKeys(target) {
const base = Reflect.ownKeys(target)
const extra = isObj ? Reflect.ownKeys(data).filter((k) => !(k in target)) : []
return [...new Set([...base, ...extra])]
},
getOwnPropertyDescriptor(target, prop) {
if (prop in target) return Reflect.getOwnPropertyDescriptor(target, prop)
if (isObj && prop in data) return Reflect.getOwnPropertyDescriptor(data, prop)
return undefined
}
})
}
let tokenCache = { token: null, at: 0 }
/** 直接调后端拿 token —— 加密算法与前端 cipher.ts 等价 */
export async function apiLogin(account = ACCOUNT, password = PASSWORD, force = false) {
if (!force && tokenCache.token && Date.now() - tokenCache.at < 30 * 60 * 1000) return tokenCache.token
const body = new URLSearchParams({
account,
password: encryptPassword(password),
grant_type: 'password'
})
const res = await fetch(`${BE_BASE}/api/oauth/Login`, {
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'App-Code': 'sswflow',
'Jnpf-Origin': 'pc',
'Vue-Version': '3'
},
body
})
const json = await res.json().catch(() => ({}))
if (json.code !== 200 || !json.data?.token) {
throw new Error(`登录失败:code=${json.code} msg=${json.msg || res.status}`)
}
const token = json.data.token.startsWith('bearer ') ? json.data.token : `bearer ${json.data.token}`
if (account === ACCOUNT) tokenCache = { token, at: Date.now() }
return token
}
export function resetTokenCache() {
tokenCache = { token: null, at: 0 }
}
/**
* 一条用例的执行上下文。脚本里拿到的 `t` 就是它。
*/
export class TestCtx {
constructor({ page, context, meta, runId, log }) {
this.page = page
this.context = context
this.meta = meta
this.runId = runId
this._log = log
this.shots = []
this.consoleErrors = []
this.token = null
this.steps = []
page.on('console', (m) => {
if (m.type() === 'error') {
const txt = m.text()
// 资源 404 / favicon 之类噪声不算前端异常
if (!/favicon|net::ERR_|Failed to load resource/i.test(txt)) this.consoleErrors.push(txt)
}
})
page.on('pageerror', (e) => this.consoleErrors.push(`pageerror: ${e.message}`))
}
log(msg) {
this._log(msg)
}
/** 带日志的步骤分组,失败时能一眼看出卡在第几步 */
async step(name, fn) {
const t0 = Date.now()
this.log(`▸ ${name}`)
try {
const r = await fn()
this.steps.push({ name, ok: true, ms: Date.now() - t0 })
return r
} catch (e) {
this.steps.push({ name, ok: false, ms: Date.now() - t0, err: e.message })
throw e
}
}
assert(cond, msg) {
if (!cond) throw new AssertError(msg)
this.log(` ✓ ${msg}`)
return true
}
skip(reason) {
throw new SkipError(reason)
}
/** 无法用浏览器自动化的用例(扫描器、断电、纸质文档核对…),标记为人工核对并给出指引 */
manual(reason) {
throw new ManualError(reason)
}
/** 生成本轮唯一的业务标识,避免反复跑用例把库里塞满同名数据 */
uid(prefix = 'E2E') {
return `${prefix}-${this.runId}`
}
// ---------- 登录 / 导航 ----------
/** 快速登录:后端换 token 后直接注入 localStorage,省掉每条用例重复走登录页 */
async login(account = ACCOUNT, password = PASSWORD) {
const token = await apiLogin(account, password)
this.token = token
await this.context.addInitScript(
([k, v]) => {
localStorage.setItem(k, v)
localStorage.setItem(`${k}_expire`, String(Date.now() + 7200 * 1000))
},
[TOKEN_KEY, token]
)
// 已经打开过页面的话,当前页也补一份,免得还停留在未登录态
if (!this.page.url().startsWith('about:')) {
await this.page.evaluate(
([k, v]) => {
localStorage.setItem(k, v)
localStorage.setItem(`${k}_expire`, String(Date.now() + 7200 * 1000))
},
[TOKEN_KEY, token]
)
}
this.log(` 已登录 ${account}`)
return token
}
/**
* 清登录态:localStorage + sessionStorage + cookies 全部清空。
* 切用户场景专用:单 context 单 window 模式下,每个节点切 lane 前调用一次。
* 然后调用 login(newAccount) 即可登入新账号。
*/
async clearLogin() {
try {
await this.page.evaluate(() => {
try { localStorage.clear() } catch {}
try { sessionStorage.clear() } catch {}
})
} catch {}
try {
await this.context.clearCookies()
} catch {}
}
/** 走真实登录页(身份认证类用例要的就是这条链路) */
async loginUI(account = ACCOUNT, password = PASSWORD) {
await this.page.goto(`${FE_BASE}/login`, { waitUntil: 'domcontentloaded' })
await humanViewportFlicker(this.page)
// 用户名:先清空再字符级键入
await humanFill(this.page, this.page.locator('.login-card input').first(), account)
// 密码:tab 切到下一字段 → 字符级键入
await humanPress(this.page, 'Tab')
await humanFill(this.page, this.page.locator('.login-card input[type="password"]'), password)
// 登录按钮
await humanClick(this.page, this.page.getByRole('button', { name: btnName('登录') }))
}
async logout() {
// 页面还没导航(about:blank)时 localStorage 访问会抛 SecurityError,
// 而全新 context 本就没有 token,直接跳过即可。
if (!this.page.url().startsWith('about:')) {
await this.page.evaluate((k) => {
localStorage.removeItem(k)
localStorage.removeItem(`${k}_expire`)
}, TOKEN_KEY)
}
}
async goto(route, { waitTable = true } = {}) {
const url = route.startsWith('http') ? route : `${FE_BASE}${route}`
await this.page.goto(url, { waitUntil: 'domcontentloaded' })
// 导航后的短暂停顿(真人等待页面响应)
await this.page.waitForTimeout(jitter(200, 400))
if (waitTable) {
// 表格页等首屏加载完;不是表格页就算了,不阻塞
await this.page
.locator('.ant-table, .crud-page, .ant-card, .ant-tabs')
.first()
.waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
.catch(() => {})
await this.waitIdle()
}
// 页面打开后视口自然微动("看屏幕")
await humanViewportFlicker(this.page, { intensity: 'low' })
this.log(` 已打开 ${route}`)
}
async waitIdle(ms = 600) {
await this.page.waitForLoadState('networkidle', { timeout: 15_000 }).catch(() => {})
await this.page.waitForTimeout(jitter(ms, ms + 200))
// 偶尔触发视口微动(模拟"查看结果")
if (Math.random() < 0.25) await humanViewportFlicker(this.page, { intensity: 'low' })
}
/** 页面标题(CrudPage 的 .page-title) */
async pageTitle() {
const el = this.page.locator('.page-title').first()
return (await el.count()) ? (await el.innerText()).trim() : (await this.page.title()).trim()
}
async expectTitle(text) {
const got = await this.pageTitle()
this.assert(got.includes(text), `页面标题包含「${text}」(实际「${got}」)`)
}
async expectVisible(selectorOrText, desc) {
// 既支持「选择器」也支持「文本」:
// - 以 . # [ 开头 → 选择器
// - 以标签名(button/a/div…)开头且含 : > 空格(后代/伪类)→ 选择器
// - 否则当作页面文本匹配
const isSelector =
selectorOrText.startsWith('.') ||
selectorOrText.startsWith('#') ||
selectorOrText.startsWith('[') ||
/^[a-zA-Z][\w-]*[ :>]/.test(selectorOrText)
const loc = isSelector
? this.page.locator(selectorOrText)
: this.page.getByText(selectorOrText, { exact: false })
await loc.first().waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
this.assert(true, desc || `可见:${selectorOrText}`)
}
// ---------- 表格 ----------
table() {
return this.page.locator('.ant-table').first()
}
rows() {
return this.page.locator('.ant-table-tbody tr.ant-table-row')
}
async rowCount() {
await this.page.waitForTimeout(200)
return await this.rows().count()
}
row(text) {
return this.page.locator(`.ant-table-tbody tr.ant-table-row:has-text(${JSON.stringify(text)})`).first()
}
async expectRow(text) {
await this.row(text).waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
this.assert(true, `列表中存在「${text}」`)
}
async expectNoRow(text) {
const n = await this.page.locator(`.ant-table-tbody tr.ant-table-row:has-text(${JSON.stringify(text)})`).count()
this.assert(n === 0, `列表中不存在「${text}」`)
}
/** 读整表为二维数组,用于「列表与详情一致」这类断言 */
async readTable() {
return await this.page.$$eval('.ant-table-tbody tr.ant-table-row', (trs) =>
trs.map((tr) => [...tr.querySelectorAll('td')].map((td) => td.innerText.trim()))
)
}
async search(keyword) {
const input = this.page.getByPlaceholder('关键字搜索')
await humanFill(this.page, input, keyword)
await humanClick(this.page, this.page.getByRole('button', { name: btnName('查询') }))
await this.waitIdle()
this.log(` 已按关键字「${keyword}」查询`)
}
async resetQuery() {
await humanClick(this.page, this.page.getByRole('button', { name: btnName('重置') }))
await this.waitIdle()
}
async refresh() {
await humanClick(this.page, this.page.getByRole('button', { name: btnName('刷新') }))
await this.waitIdle()
}
/** 顶部筛选下拉(CrudPage filters) */
async selectFilter(label, optionText) {
const item = this.page.locator(`.filter-bar .ant-form-item:has(label:text-is(${JSON.stringify(label)}))`).first()
await humanClick(this.page, item.locator('.ant-select'))
await this.page.locator('.ant-select-dropdown:visible .ant-select-item-option').filter({ hasText: optionText }).first().waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
await humanClick(this.page, this.page.locator('.ant-select-dropdown:visible .ant-select-item-option').filter({ hasText: optionText }).first())
await this.waitIdle()
this.log(` 筛选 ${label} = ${optionText}`)
}
// ---------- 新建 / 编辑抽屉 ----------
/**
* 选顶部的「所属空间」(SpacePicker,placeholder=全部空间)。
* TDS 大部分业务对象都挂在空间下,不选空间直接新建会被后端挡回
* 「所属空间不能为空」——所以正向用例开头基本都要先来一发。
* 返回选中的空间显示名。
*/
async pickSpace(name) {
// SpacePicker 渲染在 CrudPage 的 head-extra 插槽里,就是页头里的第一个下拉。
// 不按 placeholder 找:antd 的 placeholder 是独立的 span,选中后就没了。
const picker = this.page.locator('.page-head .ant-select').first()
if (!(await picker.count())) {
this.log(' 本页没有空间选择器,跳过选空间')
return null
}
// 组件在只有一个空间时会自动选中,已经有值就不用再点。
// 注意:未选中态下 .ant-select-selection-item 不存在,Playwright 默认 strict 模式会等 30s 才返回,
// 之前用 .catch(()=>'') 兜底但 innerText() 内部仍会卡 20s。必须先 count() 探测。
const selItem = picker.locator('.ant-select-selection-item')
const hasSel = await selItem.count()
if (hasSel > 0) {
const current = (await selItem.innerText()).trim()
if (current && !name) {
this.log(` 所属空间已选中「${current}」`)
return current
}
}
await humanClick(this.page, picker)
const dd = this.page.locator('.ant-select-dropdown:visible .ant-select-item-option')
await dd.first().waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
const opt = name ? dd.filter({ hasText: name }).first() : dd.first()
const label = (await opt.innerText()).trim()
await humanClick(this.page, opt)
await this.waitIdle()
this.log(` 已选择所属空间「${label}」`)
return label
}
/**
* 选空间并返回真实 spaceId。
*
* SpacePicker 的 option `label` 是 `名称(编码)`、`value` 才是 id,但 DOM 里只看得到 label。
* 用例如果直接读 `.page-head .ant-select-selection-item` 的文案当 spaceId 去 POST 建数据,
* 后端 beforeSave 只校验非空所以会建成功,可数据实际挂在一个**不存在的空间**上,
* 页面按当前空间过滤时就再也查不到自己刚建的那条,表现为「查询超时找不到行」。
* 需要真实 id 的用例一律用这个方法,别自己从 DOM 抠。
*/
async pickSpaceRef(name) {
const label = await this.pickSpace(name)
if (!label) return null
const spaces = await this.apiList('/api/ssw/tds/Space', { pageSize: 200 })
const hit =
spaces.find((s) => `${s.name}(${s.spaceCode})` === label) ||
spaces.find((s) => s.spaceCode && label.includes(s.spaceCode)) ||
spaces.find((s) => s.name && label.includes(s.name))
if (!hit) {
this.log(` ⚠ 空间「${label}」在接口列表里找不到对应记录,无法解析 spaceId`)
return null
}
return { id: hit.id, name: hit.name, spaceCode: hit.spaceCode, label }
}
async openCreate() {
await humanClick(this.page, this.page.getByRole('button', { name: btnName('新建') }))
await this.page.locator('.ant-drawer-content').waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
await this.page.waitForTimeout(jitter(250, 400))
}
async openEdit(rowText) {
await humanClick(this.page, this.row(rowText).getByRole('button', { name: btnName('编辑') }))
await this.page.locator('.ant-drawer-content').waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
await this.page.waitForTimeout(jitter(250, 400))
}
drawer() {
return this.page.locator('.ant-drawer-content').last()
}
/**
* 打开某个表单项的下拉,返回它专属的选项 locator。
*
* 不能用 `.ant-select-dropdown:visible` —— 表单里有多个 select 时,
* 上一个下拉的关闭是带淡出动画的,新下拉打开的瞬间会同时匹配到两个,
* `.first()` 极可能落在正在消失的那个上,于是「element is not visible」死等超时。
* ant-design-vue 会给每个 select 的 combobox 输入框挂 aria-controls 指向自己的
* 选项列表 id,按它精确定位才稳。
*/
async openSelect(item) {
const select = item.locator('.ant-select').first()
await humanClick(this.page, select)
const listId = await item.locator('input[role="combobox"]').first().getAttribute('aria-controls').catch(() => null)
const dd = listId
? this.page.locator(`.ant-select-dropdown:has(#${listId})`)
: this.page.locator('.ant-select-dropdown:visible')
const opts = dd.locator('.ant-select-item-option')
await opts.first().waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
// 下拉用的是 rc-virtual-list,首帧渲染完还会按实际高度重排一次,
// 紧接着点会撞上「element was detached from the DOM」,等它稳一下。
await this.page.waitForTimeout(jitter(150, 250))
return opts
}
/** 点下拉项。虚拟列表重排会让节点瞬间 detach,撞上就重试一次 */
async clickOption(opt) {
try {
await humanClick(this.page, opt, { hoverMs: [80, 220] })
} catch (e) {
await this.page.waitForTimeout(jitter(250, 400))
await humanClick(this.page, opt, { hoverMs: [80, 220] })
}
}
/**
* 按索引选下拉项,返回选中的文案。
* 用于「必须选到两个不同的引用对象」这类场景(如合约的提供方/使用方连接器)——
* 用例事先并不知道下拉里到底会有哪些选项,按名字猜不如按位置取。
*/
async pickOption(label, index = 0) {
const item = this.drawer().locator(`.ant-form-item:has(label:text-is(${JSON.stringify(label)}))`).first()
await item.waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
const opts = await this.openSelect(item)
const total = await opts.count()
if (index >= total) throw new Error(`「${label}」下拉只有 ${total} 个选项,取不到第 ${index + 1} 个`)
const opt = opts.nth(index)
const text = (await opt.innerText()).trim()
await this.clickOption(opt)
await item.locator('.ant-form-item-label, .ant-select').first().click().catch(() => {})
this.log(` 「${label}」选中「${text}」`)
return text
}
/** 按表单项标签定位控件,自动识别 input / textarea / number / select */
async fillField(label, value) {
const item = this.drawer().locator(`.ant-form-item:has(label:text-is(${JSON.stringify(label)}))`).first()
await item.waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
if (await item.locator('.ant-select').count()) {
const opts = await this.openSelect(item)
const hit = opts.filter({ hasText: String(value) })
if (await hit.count()) await this.clickOption(hit.first())
else await this.clickOption(opts.first())
// 不直接按 Escape:ant-design-vue Drawer 默认也会监听 Escape 关闭抽屉。
// 点选项本身会关闭下拉,再点一下表单项容器让焦点安全转移即可。
await item.locator('.ant-form-item-label, .ant-select').first().click().catch(() => {})
return
}
if (await item.locator('.ant-input-number-input').count()) {
await humanFill(this.page, item.locator('.ant-input-number-input'), String(value))
return
}
if (await item.locator('textarea').count()) {
await humanFill(this.page, item.locator('textarea'), String(value))
return
}
await humanFill(this.page, item.locator('input').first(), String(value))
}
async fillForm(obj) {
for (const [label, value] of Object.entries(obj)) {
if (value === undefined || value === null) continue
await this.fillField(label, value)
}
}
async clearField(label) {
const item = this.drawer().locator(`.ant-form-item:has(label:text-is(${JSON.stringify(label)}))`).first()
const box = item.locator('input, textarea').first()
if (await box.count()) await humanFill(this.page, box, '')
}
async save() {
await humanClick(this.page, this.drawer().getByRole('button', { name: btnName('保存') }))
await this.page.waitForTimeout(jitter(400, 600))
}
async cancelDrawer() {
await humanClick(this.page, this.drawer().getByRole('button', { name: btnName('取消') }))
await this.page.locator('.ant-drawer-content').waitFor({ state: 'hidden', timeout: ACTION_TIMEOUT }).catch(() => {})
}
/** 新建一条并断言成功(正向用例主力) */
async create(fields, { expectToast = '新增成功' } = {}) {
await this.openCreate()
await this.fillForm(fields)
await this.save()
if (expectToast) await this.expectToast(expectToast)
await this.waitIdle()
}
// ---------- 行内动作 ----------
/** 点某行的链接按钮(提供方签署 / 上链存证 / 终止 …) */
async rowAction(rowText, actionLabel) {
const row = this.row(rowText)
await row.waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
const btn = row.getByRole('button', { name: btnName(actionLabel) }).first()
await btn.waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
await humanClick(this.page, btn)
// 等待 modal/popover/drawer 出现的初始动画(避免 promptOk / 后续逻辑等不到)
await this.page.waitForTimeout(jitter(400, 700))
}
async hasRowAction(rowText, actionLabel) {
return (await this.row(rowText).getByRole('button', { name: btnName(actionLabel) }).count()) > 0
}
/** 锁定当前页可见的「弹窗 / 抽屉 / 浮层」容器。
* ant-design-vue 不同版本渲染差异大:v3 标准 a-modal 是 .ant-modal-wrap > .ant-modal,
* 但 jweb 用的版本把 modal 内部用 ant-tabs 组件包了一层,根容器变成 .ant-tabs-root;
* 抽屉(Drawer)又是 .ant-drawer。这里统一收口。
* 返回的 locator 直接当 modal 容器用:locator('.ant-btn-primary') / locator('textarea') 等。
*/
_visibleDialog() {
// 优先级:标准 modal > ant-tabs-root(jweb modal) > drawer > 自定义 .ant-popover
const sels = [
'.ant-modal-wrap:visible .ant-modal:not(.ant-modal-confirm)',
'.ant-modal-wrap:visible .ant-tabs-root',
'.ant-drawer-content-wrapper:visible .ant-drawer-body',
'.ant-popover:visible .ant-popover-inner'
]
for (const s of sels) {
const n = this.page.locator(s)
if (n.length) return n.last()
}
return this.page.locator('body')
}
/** prompt 弹窗填值并确认;组件库自带按钮按 class 点,避开中英文文案差异
* value 用法:
* - null / undefined / '':保留 modal 默认值(不点 select、不填 textarea),直接确认
* - 'xxx':先在 select 里匹配(同时按文本与 value 属性匹配,兼容中英文),再把同一值填到 textarea(若有)
* - { select: 'SANDBOX', textarea: '留言...' }:分别指定 select 选项 + textarea 文案
*/
async promptOk(value) {
const dialog = this._visibleDialog()
await dialog.waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
// 解析 value:支持对象 / 单值
const opts = (value && typeof value === 'object')
? value
: { select: value, textarea: value }
// 处理顺序:先填 select(如果有 + 显式指定),再填 textarea(如果有)
const wantSelect = opts.select !== null && opts.select !== undefined && opts.select !== ''
if (wantSelect && await dialog.locator('.ant-select').count()) {
await humanClick(this.page, dialog.locator('.ant-select').first())
// antd 渲染时 option 的 label 是 label 文本,value 落在 li[data-value] / .ant-select-item-option-value 上
const dropdown = this.page.locator('.ant-select-dropdown:visible').last()
await dropdown.waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
const want = String(opts.select)
// 先按 li title / 文本匹配(中文 label),再回退按 data-value 匹配(英文 value)
let opt = dropdown.locator('.ant-select-item-option').filter({ hasText: want }).first()
if (!(await opt.count())) {
opt = dropdown.locator(`.ant-select-item-option[data-value="${want.replace(/"/g, '\\"')}"]`).first()
}
await opt.waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
await humanClick(this.page, opt)
// antd select 选中后自动收起 dropdown,等其稳一下再 fill textarea(避免遮盖)
await this.page.waitForTimeout(jitter(150, 280))
}
const wantText = opts.textarea
if (wantText !== undefined && wantText !== null && wantText !== '' && await dialog.locator('textarea').count()) {
await humanFill(this.page, dialog.locator('textarea').first(), String(wantText))
}
await humanClick(this.page, dialog.locator('.ant-btn-primary').last())
await this.page.waitForTimeout(jitter(400, 600))
}
async promptCancel() {
const dialog = this._visibleDialog()
await humanClick(this.page, dialog.locator('.ant-btn:not(.ant-btn-primary)').first())
await this.page.waitForTimeout(jitter(200, 350))
}
async promptIsOpen() {
// 兼容 jweb 的 ant-tabs-root modal + 标准 ant-modal + drawer
return (await this.page.locator('.ant-modal-wrap:visible, .ant-drawer-content-wrapper:visible').count()) > 0
}
/** 行内动作 + prompt 一步到位 */
async doAction(rowText, actionLabel, promptValue) {
await this.rowAction(rowText, actionLabel)
if (await this.promptIsOpen()) await this.promptOk(promptValue)
await this.waitIdle()
}
async remove(rowText) {
await humanClick(this.page, this.row(rowText).getByRole('button', { name: btnName('删除') }))
const confirm = this.page.locator('.ant-popconfirm:visible').last()
await confirm.waitFor({ state: 'visible', timeout: ACTION_TIMEOUT })
await humanClick(this.page, confirm.locator('.ant-btn-primary'))
await this.waitIdle()
}
// ---------- 提示 ----------
/** ant-design-vue 的全局提示 3 秒自动消失,这里轮询抓取,别用固定等待 */
async toastText(timeout = 6000) {
const t0 = Date.now()
while (Date.now() - t0 < timeout) {
const n = this.page.locator('.ant-message-notice-content')
if (await n.count()) {
const txt = (await n.last().innerText()).trim()
if (txt) return txt
}
await this.page.waitForTimeout(120)
}
return ''
}
async expectToast(expect, { type } = {}) {
const txt = await this.toastText()
this.assert(txt.includes(expect), `出现提示「${expect}」(实际「${txt || '无提示'}」)`)
if (type) {
const cls = await this.page.locator('.ant-message-notice-content').last().innerHTML()
this.assert(cls.includes(`anticon-${type}`) || cls.includes(type), `提示类型为 ${type}`)
}
return txt
}
/** 反向用例:期望出现拒绝/校验类提示,且不是成功提示 */
async expectReject(keyword) {
const txt = await this.toastText()
this.assert(!!txt, `系统给出了提示(实际「${txt}」)`)
this.assert(!/成功/.test(txt), `未出现成功提示,操作被拒绝(实际「${txt}」)`)
if (keyword) this.assert(txt.includes(keyword), `提示包含「${keyword}」`)
return txt
}
async expectNoToast(ms = 1500) {
await this.page.waitForTimeout(ms)
const n = await this.page.locator('.ant-message-notice-content').count()
this.assert(n === 0, '没有出现任何提示')
}
// ---------- 后端接口 ----------
/** 直接打后端,用于「界面之外还要落库/落链」这类断言 */
async api(method, url, body, { raw = false, token } = {}) {
const t = token ?? this.token ?? (await this.login())
const full = url.startsWith('http') ? url : `${BE_BASE}${url.startsWith('/api') ? '' : '/api'}${url}`
// GET / HEAD 不允许 body;脚本可能误传,DSL 兜底不让整批崩
const upper = method.toUpperCase()
const safeBody = (upper === 'GET' || upper === 'HEAD') ? undefined : body
const res = await fetch(full, {
method: upper,
headers: {
Authorization: t,
'App-Code': 'sswflow',
'Jnpf-Origin': 'pc',
'Vue-Version': '3',
...(safeBody ? { 'Content-Type': 'application/json' } : {})
},
...(safeBody ? { body: JSON.stringify(safeBody) } : {})
})
const json = await res.json().catch(() => ({}))
if (raw) return { status: res.status, json }
return wrapEnvelope(json)
}
/** 分页列表接口的通用取数 */
async apiList(url, query = {}) {
const qs = new URLSearchParams({ currentPage: 1, pageSize: 20, ...query }).toString()
const r = await this.api('GET', `${url}?${qs}`)
const d = r?.data ?? r
return d?.list ?? d?.records ?? (Array.isArray(d) ? d : [])
}
/** 自举:创建一条全新的 SANDBOX 交付任务(status/runStatus=PENDING_DELIVER,无程序)
* 用于 DELIVERY/USAGE 用例在无「干净可上传」共享任务时可独立跑通。
* 探针已验证:POST 后 status=runStatus=PENDING_DELIVER、programUri=null,UploadProgram 返回 200。
* 返回 { id, contractCode, productName } 或 null(失败/无前置数据时)。 */
async createSandboxTask() {
try {
const contracts = (await this.apiList('/api/ssw/tds/Contract', { pageSize: 50 })).filter((c) => c.status === '02')
const prods = await this.apiList('/api/ssw/tds/DataProduct', { pageSize: 50 })
if (!contracts.length || !prods.length) return null
const c = contracts[0]
const p = prods[0]
// 自带唯一 taskNo(beforeSave 仅在缺省时生成 DT+时间戳;自带则沿用,且需全局唯一)
const taskNo = 'DT-E2E-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6)
const r = await this.api('POST', '/api/ssw/tdc/DeliveryTask', {
taskNo,
contractId: c.id,
contractCode: c.contractCode,
productId: p.id,
productName: p.name || p.productName,
deliveryType: 'SANDBOX',
// beforeSave 仅在缺省时设 status=PENDING,这里自带 PENDING_DELIVER 让用例 filter 命中;
// runStatus 也自带(beforeSave 不设),否则 UploadProgram 会因 runStatus!=PENDING_DELIVER 被拒
status: 'PENDING_DELIVER',
runStatus: 'PENDING_DELIVER',
triggerType: 'MANUAL'
})
if (r.code !== 200 || !r.data) return null
const id = typeof r.data === 'string' ? r.data : r.data?.id
if (!id) return null
return { id, taskNo, contractCode: c.contractCode, productName: p.name || p.productName }
} catch (e) {
return null
}
}
// ---------- 证据 ----------
async shot(name) {
fs.mkdirSync(SHOTS_DIR, { recursive: true })
// 关键动作截图统一命名 <用例号>-<序号>.jpg,如 TC-FLOW-001-001.jpg
const file = `${this.meta.tc}-${String(this.shots.length + 1).padStart(3, '0')}.jpg`
const full = path.join(SHOTS_DIR, file)
try {
// 视口变更 / 异常跳转让 page 可能已关:拿不到也别让用例崩
if (this.page.isClosed()) throw new Error('page closed')
await this.page.screenshot({ path: full, type: 'jpeg', quality: 82, fullPage: false, timeout: 5000 })
this.shots.push(file)
this.log(` 📸 ${file}${name ? ' · ' + name : ''}`)
return file
} catch (e) {
this.log(` 📸(${name} 截图失败:${e.message.slice(0, 60)})`)
return null
}
}
/** 无前端报错 —— 可靠性/易用性类用例的通用断言 */
expectConsoleClean() {
this.assert(
this.consoleErrors.length === 0,
`无前端控制台错误(实际 ${this.consoleErrors.length} 条${this.consoleErrors[0] ? ':' + this.consoleErrors[0].slice(0, 120) : ''})`
)
}
// ====================================================================
// 真实链路 / 真实计算引擎标记断言(TC-FLOW-001~005 共用)
// --------------------------------------------------------------------
// 把"沙箱执行/隐私计算是不是真的走了 Nax→K8s→TEE 还是退到本地模拟"
// 以及"FISCO 上链区块号、TEE 远程证明、KBS 密文路径"这些**真实物理证据**
// 解析成结构化断言,而不是只验一个宽泛的正则。
// ====================================================================
/**
* 解析 runLog 中的引擎回退链标记:[K8S] / [NAX] / [模拟] 出现位置 + 顺序。
* 返回 { k8s, nax, simulator, chain } —— chain 是按时间顺序的命中列表(去重保序)。
* 引擎先后顺序:真 K8s > Nax > 本地模拟;都未命中视为「无引擎标记」(用例应警觉)。
*/
parseEngineChain(runLog) {
const s = String(runLog || '')
const re = /\[(K8S(?:[^\]]*)?|NAX(?:[^\]]*)?|模拟[^\]]*?)\]/g
const chain = []
let m
while ((m = re.exec(s)) !== null) {
const tag = m[1]
if (!chain.includes(tag)) chain.push(tag)
}
const k8s = chain.find((t) => /^K8S/.test(t)) || null
const nax = chain.find((t) => /^NAX/.test(t)) || null
const simulator = chain.find((t) => /^模拟/.test(t)) || null
return { k8s, nax, simulator, chain }
}
/**
* 断言 runLog 命中「真引擎」至少一次(K8S 或 NAX,**不接受纯模拟**)。
* 如果走 NAX 也能算「真实计算」—— Nax 真起 Python 子进程跑 pandas/numpy。
* 用例如果强制要求真 K8s,可传 { requireK8s: true }。
*/
assertRealEngineEngaged(runLog, opts = {}) {
const { requireK8s = false, allowSimulator = true, label = '本次执行' } = opts
const parsed = this.parseEngineChain(runLog)
const summary = `引擎回退链=[${parsed.chain.join(' → ') || '无标记'}]`
if (requireK8s) {
this.assert(!!parsed.k8s, `${label}走真 K8S 引擎(${summary})`)
} else if (parsed.k8s || parsed.nax) {
this.assert(true, `${label}命中真实计算引擎(${summary})`)
} else if (parsed.simulator && allowSimulator) {
this.assert(true, `${label}走本地模拟回退(${summary})—— 接受为有效执行`)
} else {
this.assert(false, `${label}未命中任何引擎标记(${summary}),结果不可信`)
}
return parsed
}
/**
* 解析 runLog 中的 FISCO 存证区块号。格式:「上链 block=#N tx=0x...」或类似。
* 真上链:blockHeight > 0;fallback LOCAL/PENDING/FAIL:blockHeight=0 或缺失。
* 返回 { blockHeight, txHash, status, raw }。
*/
parseChainEvidence(runLog) {
const s = String(runLog || '')
const m = s.match(/block=#(\d+)|block[=#:]+\s*(\d+)|区块[=#:]*\s*(\d+)/i)
const tx = s.match(/tx[=#:]*\s*(0x[0-9a-fA-F]{64})/)
const status = s.match(/存证\s*([A-Z]{2,})/) || s.match(/on-chain\s*([A-Z]{2,})/i)
return {
blockHeight: m ? Number(m[1] || m[2] || m[3]) : 0,
txHash: tx ? tx[1] : null,
status: status ? status[1] : null,
raw: m ? m[0] : null
}
}
/**
* 断言 FISCO 真上链:返回 blockHeight > 0;fallback 状态(LOCAL/PENDING/FAIL)单独识别。
* - { requireOnChain: true }:必须是真链(blockHeight > 0)—— 适合「上链存证」步骤
* - 默认允许 fallback:本地缓存 + 异步上链,结果落 LOCAL/PENDING/FAIL 都不阻断主流程
*/
assertChainEvidence(runLog, opts = {}) {
const { requireOnChain = false, label = '本次存证' } = opts
const ev = this.parseChainEvidence(runLog)
if (requireOnChain) {
this.assert(ev.blockHeight > 0 || !!ev.txHash, `${label}已上链(blockHeight=${ev.blockHeight} tx=${(ev.txHash || '').slice(0, 12)}...)`)
} else {
const ok = ev.blockHeight > 0 || ['LOCAL', 'PENDING'].includes(ev.status || '')
this.assert(ok, `${label}落账(blockHeight=${ev.blockHeight} status=${ev.status || '未知'})`)
}
return ev
}
/**
* 读 TEE 结构化证据(解析 runLog 中的 [TEE_EVIDENCE_JSON] 块或调后端 /TeeEvidence)。
* 后端路径二选一:runLog 自带(K8sSandboxClient.appendTeeEvidence 写入)→ 直接解析;
* 否则调 /api/ssw/tdc/{Sandbox,Privacy}/{id}/TeeEvidence。
* 返回 { teeType, attestationGated, resultSealed, kbc, guestKernel,
* measurementSha256, signatureNonZeroBytes, runtimeClass, kbsEngaged, fatal }。
*/
async fetchTeeEvidence(taskId, runLog) {
// 先试 runLog 内嵌
if (runLog && runLog.includes('[TEE_EVIDENCE_JSON]')) {
const i = runLog.indexOf('[TEE_EVIDENCE_JSON]')
const json = runLog.substring(i + '[TEE_EVIDENCE_JSON]'.length()).trim()
try {
return JSON.parse(json)
} catch {
/* fall through to API */
}
}
// 落不到 runLog 就调后端(Sandbox 与 Privacy 各试一次)
for (const path of [`/api/ssw/tdc/Sandbox/${taskId}/TeeEvidence`, `/api/ssw/tdc/Privacy/${taskId}/TeeEvidence`]) {
const r = await this.api('GET', path)
if (r.code === 200 && r.data) return r.data
}
return null
}
/**
* 断言 TEE 执行证据:远程证明门控 + 结果加密 + measurement 真存在。
* 默认要求 attestationGated=true 且 resultSealed=true(链路必须密态门控)。
* 如果是真 TEE,应还有 measurementSha256(64 hex);fallback 到本地模拟也允许通过。
*/
async assertTeeEvidence(taskId, runLog, opts = {}) {
const { requireGated = true, requireSealed = true, requireMeasurement = false, label = '本次 TEE 执行' } = opts
const ev = await this.fetchTeeEvidence(taskId, runLog)
if (!ev) {
this.assert(false, `${label}未产出 TEE 证据块(runLog 无 [TEE_EVIDENCE_JSON]、/TeeEvidence 不可读)`)
return null
}
const teeType = ev.teeType || ev.tee || 'unknown'
this.assert(true, `${label}证据结构化:teeType=${teeType} attestationGated=${ev.attestationGated} resultSealed=${ev.resultSealed} kbc=${ev.kbc || 'n/a'} guestKernel=${ev.guestKernel || 'n/a'}`)
if (requireGated) this.assert(ev.attestationGated === true, `${label}远程证明门控开启(attestationGated=true)`)
if (requireSealed) this.assert(ev.resultSealed === true, `${label}结果密文封装(resultSealed=true,AES-256-GCM)`)
if (requireMeasurement) {
const m = ev.measurementSha256
this.assert(typeof m === 'string' && m.length === 64, `${label}有真实 measurement(SHA-256 64位 hex,实际=${(m || '').slice(0, 16)}...)`)
}
if (ev.fatal) {
this.assert(false, `${label}TEE 失败 fatal=${ev.fatal}——fail-closed 起作用但任务不应仍报 SUCCESS`)
}
return ev
}
/**
* 计算一段字符串的真实 SHA-256(hex, 64 字符)。
* 用于把合约摘要、算法代码摘要、销毁前的产物摘要等业务对象的"指纹"算出来,
* 而不是用随机 fakeHash 假装存证;后者过不了「链上数据必须可重现」的反向审计。
*/
sha256Hex(text) {
// 同步实现;不引 crypto 依赖;用 Node 内置
// 通过动态 import 替代 require(ESM 环境)
return import('node:crypto').then(({ createHash }) => createHash('sha256').update(String(text), 'utf8').digest('hex'))
}
/**
* 把"执行耗时(ms)"切成可断言的档位,验证沙箱/隐私计算走的是真实路径不是秒回。
* - missing/undefined:实体若不携带 costMs 字段(如 DeliveryTask),只 log 不阻断(接口尚无此指标)
* - tooFast(< minMs):< 50ms 几乎确定是 stub/缓存(除非仅静态校验)
* - tooSlow(> maxMs):> maxMs 视为超时嫌疑(结合 runStatus 一起判断)
*/
assertExecCost(costMs, opts = {}) {
const { minMs = 50, maxMs = 600000, label = '本次执行', required = false } = opts
const n = Number(costMs)
if (!Number.isFinite(n) || n < 0 || costMs === undefined || costMs === null) {
if (required) {
this.assert(false, `${label}必须带 costMs(实际 ${costMs})`)
} else {
this.log(` (${label}无 costMs 字段(实际 ${costMs}),该实体尚未记录执行耗时,跳过区间校验)`)
}
return n || 0
}
if (n > 0 && n < minMs) {
this.log(` ⚠ ${label}耗时仅 ${n}ms(< ${minMs}ms),疑似本地 stub`)
} else if (n > maxMs) {
this.log(` ⚠ ${label}耗时 ${n}ms(> ${maxMs}ms),需关注是否触发超时回退`)
} else if (n === 0) {
this.log(` (${label}costMs=0,可能尚未记录耗时)`)
} else {
this.assert(true, `${label}耗时 ${n}ms 在合理区间 [${minMs}, ${maxMs}]`)
}
return n
}
}