316 lines
11 KiB
TypeScript
316 lines
11 KiB
TypeScript
import { execSync } from 'child_process';
|
||
import { TestResult } from './test-reporter';
|
||
|
||
const ONES_CLI = '/Users/woan/local/bin/ones';
|
||
|
||
export interface OnesPlanCase {
|
||
key: string;
|
||
caseUUID: string;
|
||
caseName: string;
|
||
caseNumber: number;
|
||
currentResult: string;
|
||
executor?: string;
|
||
}
|
||
|
||
export interface OnesStepResult {
|
||
uuid: string;
|
||
// 执行结果填到 execute_result（step.result 是预期文本，属定义不可覆盖）。
|
||
// 未执行的 step 只列 uuid、不带 execute_result。
|
||
execute_result?: 'passed' | 'failed' | 'skipped';
|
||
actual_result?: string;
|
||
}
|
||
|
||
export interface OnesUpdatePayload {
|
||
uuid: string;
|
||
executor: string;
|
||
note: string;
|
||
result: 'passed' | 'failed' | 'skipped' | 'to_do';
|
||
steps: OnesStepResult[];
|
||
}
|
||
|
||
// 测试名锚点：[ONES:15974] 或 [ONES:15974#<stepUuid>]（控制为 step 级）
|
||
const ONES_ANCHOR = /\[ONES:(\d+)(?:#([A-Za-z0-9_-]+))?\]/;
|
||
|
||
type SyncStatus = 'passed' | 'failed' | 'skipped';
|
||
|
||
function toStatus(s: TestResult['status']): SyncStatus {
|
||
return s === 'PASS' ? 'passed' : s === 'FAIL' ? 'failed' : 'skipped';
|
||
}
|
||
|
||
// 聚合多个 step 结果为 case 结果：fail > skip > pass
|
||
function mergeStatus(a: SyncStatus | undefined, b: SyncStatus): SyncStatus {
|
||
const rank = (s?: SyncStatus) => (s === 'failed' ? 2 : s === 'skipped' ? 1 : 0);
|
||
return !a || rank(b) > rank(a) ? b : a;
|
||
}
|
||
|
||
function runOnesGraphQL(query: string): any {
|
||
const cmd = `${ONES_CLI} graphql '${query.replace(/'/g, "'\\''")}'`;
|
||
const output = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
|
||
return JSON.parse(output);
|
||
}
|
||
|
||
/**
|
||
* 从 ONES 测试计划读取所有用例
|
||
*/
|
||
export function fetchPlanCases(planUUID: string): OnesPlanCase[] {
|
||
const results: OnesPlanCase[] = [];
|
||
let offset = 0;
|
||
const limit = 100;
|
||
|
||
while (true) {
|
||
const query = `{ testcasePlanCases(filter: { testcasePlan: { uuid_in: ["${planUUID}"] } }, limit: ${limit}, offset: ${offset}) { key result executor { uuid } testcaseCase { uuid name number } } }`;
|
||
const resp = runOnesGraphQL(query);
|
||
const cases = resp?.data?.testcasePlanCases || [];
|
||
if (cases.length === 0) break;
|
||
|
||
for (const c of cases) {
|
||
results.push({
|
||
key: c.key,
|
||
caseUUID: c.testcaseCase.uuid,
|
||
caseName: c.testcaseCase.name,
|
||
caseNumber: c.testcaseCase.number,
|
||
currentResult: c.result || 'to_do',
|
||
executor: c.executor?.uuid,
|
||
});
|
||
}
|
||
|
||
if (cases.length < limit) break;
|
||
offset += limit;
|
||
}
|
||
|
||
return results;
|
||
}
|
||
|
||
/**
|
||
* 将自动化测试结果映射到 ONES 用例 (按用例名称模糊匹配)
|
||
*/
|
||
export function matchResults(
|
||
planCases: OnesPlanCase[],
|
||
testResults: TestResult[]
|
||
): Map<string, { caseUUID: string; result: 'passed' | 'failed' | 'skipped' }> {
|
||
const matched = new Map<string, { caseUUID: string; result: 'passed' | 'failed' | 'skipped' }>();
|
||
|
||
for (const tr of testResults) {
|
||
const result = tr.status === 'PASS' ? 'passed' : tr.status === 'FAIL' ? 'failed' : 'skipped';
|
||
|
||
// 精确匹配: 用例名完全包含在 ONES 用例名中，或反之
|
||
let bestMatch: OnesPlanCase | null = null;
|
||
let bestScore = 0;
|
||
|
||
for (const pc of planCases) {
|
||
const score = similarityScore(tr.name, pc.caseName);
|
||
if (score > bestScore && score >= 0.5) {
|
||
bestScore = score;
|
||
bestMatch = pc;
|
||
}
|
||
}
|
||
|
||
if (bestMatch) {
|
||
matched.set(bestMatch.caseUUID, { caseUUID: bestMatch.caseUUID, result });
|
||
}
|
||
}
|
||
|
||
return matched;
|
||
}
|
||
|
||
/**
|
||
* 计算两个字符串的相似度 (0~1)
|
||
* 基于最长公共子序列
|
||
*/
|
||
function similarityScore(a: string, b: string): number {
|
||
const aNorm = a.replace(/[\s\-_]/g, '').toLowerCase();
|
||
const bNorm = b.replace(/[\s\-_]/g, '').toLowerCase();
|
||
|
||
if (aNorm === bNorm) return 1;
|
||
if (aNorm.includes(bNorm) || bNorm.includes(aNorm)) return 0.9;
|
||
|
||
// LCS ratio
|
||
const lcsLen = lcs(aNorm, bNorm);
|
||
return (2 * lcsLen) / (aNorm.length + bNorm.length);
|
||
}
|
||
|
||
function lcs(a: string, b: string): number {
|
||
const m = a.length, n = b.length;
|
||
if (m === 0 || n === 0) return 0;
|
||
const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
|
||
for (let i = 1; i <= m; i++) {
|
||
for (let j = 1; j <= n; j++) {
|
||
dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
|
||
}
|
||
}
|
||
return dp[m][n];
|
||
}
|
||
|
||
/**
|
||
* 按测试名锚点构建回写 payload（支持 case 级与 step 级）。
|
||
* - [ONES:<num>] → case 级结果
|
||
* - [ONES:<num>#<stepUuid>] → step 级结果
|
||
* 无锚点的结果不在此处理（交由 matchResults LCS 兜底）。
|
||
*
|
||
* 只写「跑过的」step（不读取/不列出原有 step，提高效率）。
|
||
* opts.totalStepsByNumber: 用例号 → 该用例步骤总数（来自本地参数文件）。
|
||
* 提供时：跑过的 step 数 < 总数 → case 保持 to_do（部分执行）；全跑完才聚合 passed/failed。
|
||
* 不提供时：按已有结果聚合。
|
||
*/
|
||
export function buildAnchoredPayloads(
|
||
planCases: OnesPlanCase[],
|
||
testResults: TestResult[],
|
||
executor: string,
|
||
opts: { totalStepsByNumber?: Map<number, number> } = {}
|
||
): { payloads: OnesUpdatePayload[]; unanchored: TestResult[] } {
|
||
const byNumber = new Map<number, OnesPlanCase>();
|
||
for (const pc of planCases) byNumber.set(pc.caseNumber, pc);
|
||
|
||
const caseLevel = new Map<string, SyncStatus>(); // caseUUID -> result (add/feature)
|
||
const runSteps = new Map<string, Map<string, OnesStepResult>>(); // caseUUID -> stepUuid -> result
|
||
const numberByUUID = new Map<string, number>();
|
||
const unanchored: TestResult[] = [];
|
||
|
||
for (const tr of testResults) {
|
||
const m = ONES_ANCHOR.exec(tr.name);
|
||
if (!m) {
|
||
unanchored.push(tr);
|
||
continue;
|
||
}
|
||
const pc = byNumber.get(parseInt(m[1], 10));
|
||
if (!pc) continue; // 锚点用例不在本计划内
|
||
numberByUUID.set(pc.caseUUID, pc.caseNumber);
|
||
const status = toStatus(tr.status);
|
||
if (m[2]) {
|
||
if (!runSteps.has(pc.caseUUID)) runSteps.set(pc.caseUUID, new Map());
|
||
runSteps.get(pc.caseUUID)!.set(m[2], {
|
||
uuid: m[2],
|
||
execute_result: status,
|
||
actual_result: (tr.detail || '').slice(0, 500),
|
||
});
|
||
} else {
|
||
caseLevel.set(pc.caseUUID, mergeStatus(caseLevel.get(pc.caseUUID), status));
|
||
}
|
||
}
|
||
|
||
const payloads: OnesUpdatePayload[] = [];
|
||
|
||
// step 级用例：只写跑过的 step；全跑完才聚合 case 结果，否则 to_do
|
||
for (const [caseUUID, stepMap] of runSteps) {
|
||
const num = numberByUUID.get(caseUUID)!;
|
||
const steps = Array.from(stepMap.values());
|
||
const total = opts.totalStepsByNumber?.get(num);
|
||
const allRun = total != null ? stepMap.size >= total : true;
|
||
let agg: SyncStatus | undefined;
|
||
for (const s of stepMap.values()) if (s.execute_result) agg = mergeStatus(agg, s.execute_result);
|
||
const result: OnesUpdatePayload['result'] = allRun ? agg ?? 'to_do' : 'to_do';
|
||
payloads.push({ uuid: caseUUID, executor, note: '', result, steps });
|
||
}
|
||
|
||
// case 级用例（添加/功能，无 step 结果）
|
||
for (const [caseUUID, result] of caseLevel) {
|
||
if (runSteps.has(caseUUID)) continue;
|
||
payloads.push({ uuid: caseUUID, executor, note: '', result, steps: [] });
|
||
}
|
||
|
||
return { payloads, unanchored };
|
||
}
|
||
|
||
/**
|
||
* 分批 POST 回写 payload 到 ONES 测试计划。
|
||
*/
|
||
/**
|
||
* 执行一个 GraphQL mutation（经 ones CLI，复用登录认证）。失败抛错。
|
||
*/
|
||
function runOnesMutation(body: string): void {
|
||
const resp = runOnesGraphQL(`mutation { ${body} }`);
|
||
if (!resp || !resp.data) {
|
||
throw new Error(JSON.stringify(resp?.detail || resp || {}).slice(0, 300));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 回写 payload 到 ONES 测试计划，走 GraphQL mutation（updateTestcasePlanCase /
|
||
* updateTestcasePlanCaseStep），用 ones CLI 的登录认证，无需 token/PAT。
|
||
*
|
||
* key 规则：
|
||
* case: testcase_plan_case-<planUUID>-<caseUUID>
|
||
* step: testcase_plan_case_step-<planUUID>-<caseUUID>-<stepUuid>
|
||
*/
|
||
export function postPayloads(
|
||
planUUID: string,
|
||
payload: OnesUpdatePayload[]
|
||
): { success: number; failed: number } {
|
||
let success = 0;
|
||
let failed = 0;
|
||
let stepsWritten = 0;
|
||
|
||
for (const p of payload) {
|
||
try {
|
||
// 先写 step（仅跑过的）
|
||
for (const s of p.steps) {
|
||
if (!s.execute_result) continue;
|
||
const sk = `testcase_plan_case_step-${planUUID}-${p.uuid}-${s.uuid}`;
|
||
const ar = s.actual_result ? `, actual_result: ${JSON.stringify(s.actual_result)}` : '';
|
||
runOnesMutation(
|
||
`updateTestcasePlanCaseStep(key: ${JSON.stringify(sk)}, step_result: ${JSON.stringify(s.execute_result)}${ar}) { key }`
|
||
);
|
||
stepsWritten++;
|
||
}
|
||
// 再写 case 级结果
|
||
const ck = `testcase_plan_case-${planUUID}-${p.uuid}`;
|
||
runOnesMutation(
|
||
`updateTestcasePlanCase(key: ${JSON.stringify(ck)}, result: ${JSON.stringify(p.result)}) { key }`
|
||
);
|
||
success++;
|
||
} catch (e: any) {
|
||
console.error(`[ONES] 用例 ${p.uuid} 回写失败: ${e.message}`);
|
||
failed++;
|
||
}
|
||
}
|
||
|
||
if (stepsWritten) console.log(`[ONES] 写入 ${stepsWritten} 个 step 结果`);
|
||
return { success, failed };
|
||
}
|
||
|
||
/**
|
||
* 反写结果到 ONES 测试计划（case 级）。步骤级请用带 steps 的 payload 走 postPayloads。
|
||
*/
|
||
export function syncResultsToOnes(
|
||
planUUID: string,
|
||
results: Map<string, { caseUUID: string; result: 'passed' | 'failed' | 'skipped' }>,
|
||
executorUUID: string
|
||
): { success: number; failed: number } {
|
||
const payload: OnesUpdatePayload[] = [];
|
||
for (const [, { caseUUID, result }] of results) {
|
||
payload.push({ uuid: caseUUID, executor: executorUUID, note: '', result, steps: [] });
|
||
}
|
||
return postPayloads(planUUID, payload);
|
||
}
|
||
|
||
/**
|
||
* 一键同步: 读取计划用例 → 匹配自动化结果 → 反写
|
||
*/
|
||
export function fullSync(
|
||
planUUID: string,
|
||
testResults: TestResult[],
|
||
executorUUID?: string
|
||
): { total: number; matched: number; synced: number; failed: number } {
|
||
const configStr = execSync(`${ONES_CLI} config show`, { encoding: 'utf-8' });
|
||
const config = JSON.parse(configStr);
|
||
const executor = executorUUID || config.user_id;
|
||
|
||
console.log(`[ONES Sync] 读取测试计划 ${planUUID} ...`);
|
||
const planCases = fetchPlanCases(planUUID);
|
||
console.log(`[ONES Sync] 计划共 ${planCases.length} 条用例`);
|
||
|
||
console.log(`[ONES Sync] 匹配自动化结果 (${testResults.length} 条) ...`);
|
||
const matched = matchResults(planCases, testResults);
|
||
console.log(`[ONES Sync] 匹配成功 ${matched.size} 条`);
|
||
|
||
if (matched.size === 0) {
|
||
return { total: planCases.length, matched: 0, synced: 0, failed: 0 };
|
||
}
|
||
|
||
console.log(`[ONES Sync] 反写结果到 ONES ...`);
|
||
const { success, failed } = syncResultsToOnes(planUUID, matched, executor);
|
||
console.log(`[ONES Sync] 完成: ${success} 成功, ${failed} 失败`);
|
||
|
||
return { total: planCases.length, matched: matched.size, synced: success, failed };
|
||
}
|