Files
cms-website/scripts/smoke-real-wxr.mjs
T

358 lines
15 KiB
JavaScript
Raw Normal View History

#!/usr/bin/env node
// 真实 WXR 冒烟(Plan 2 · Task 8,阶段 2 验收):
// 对 hesupipe 真实导出(只读)跑 wxr:probe 同链路(runWxrAdapterReport),计数对照
// Plan 1 基线 docs/evidence/real-wxr-baseline.md,内存按计划钉死口径采样——
// setInterval(100ms) 采 process.memoryUsage() 的 heapUsed/rss 双 max。
//
// 运行方式(仓库根):
// pnpm exec tsx scripts/smoke-real-wxr.mjs [--wxr <path>] [--out <dir>]
// 与 scripts/sf.ts 同机制:@sf/adapter-wp 经根 tsconfig paths 直连 TS 源码(需 tsx,
// 纯 node 无法解析 workspace TS 包——证据文档须记实际执行命令原文)。
//
// 断言语义(任一不一致 → verdict FAIL + exitCode 1,如实报告不凑解释):
// - totals 与基线逐项一致(rows/terms/unsupported/failed 与 item 总数);
// - unsupported 按 sourceType(`wp:<post_type>`)细分计数一致;
// - heapUsed max < 100MB(流式验收线);fatalError 必须为 null。
// nicename 锚点核对(Task 4 冻结点)为证据采集而非 pass/fail 断言:不一致逐条列出,
// 供阶段 3 taxonomyRefs 映射策略决策。
//
// 计时口径(Task 6 移交,报告须注明):parseMs 是 parser.next() await 窗口累计,
// 含流式 IO 等待(磁盘读/backpressure),非纯 CPU 解析耗时;totalMs 覆盖整个消费循环。
//
// 输出:stdout 纯 JSON(机器可消费);人类可读进度走 stderr。产物落
// artifacts/probe/<runId>/{report.json,report.html,smoke.json}(与 wxr:probe CLI 同布局)。
import { createHash } from 'node:crypto'
import { createReadStream } from 'node:fs'
import { mkdir, stat, writeFile } from 'node:fs/promises'
import { dirname, join, resolve } from 'node:path'
import { fileURLToPath } from 'node:url'
import { parseWxrStream, renderReportHtml, runWxrAdapterReport } from '@sf/adapter-wp'
import { makeRunId } from '../apps/api/src/modules/source/register.service.js'
const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
/** 冒烟对象(缺省):hesupipe 真实导出,绝对只读 */
const DEFAULT_WXR = 'D:/project/cms/storage/wxr/fd04d6ba8a1316b6.xml'
/** 流式验收线:heapUsed max < 100MB(计划钉死) */
const HEAP_LIMIT_BYTES = 100 * 1024 * 1024
/** 内存采样周期(计划钉死口径:setInterval(100ms) 双 max) */
const SAMPLE_INTERVAL_MS = 100
/** nicename 锚点抽检条数:文档序前 N 个含 domain="category" 引用的 item */
const NICENAME_SAMPLE_ITEMS = 10
/** Plan 1 基线(docs/evidence/real-wxr-baseline.md,对照用冻结值) */
const BASELINE = {
fileBytes: 5_490_399,
sha256: 'f9bc5d4497a1792af37abff78e0096268bda975cb367a956da42bcf9552b9f62',
itemsTotal: 1122,
rowsTotal: 1047, // 855 attachment + 129 post + 48 product + 15 page
terms: 451,
unsupportedTotal: 75,
failedTotal: 0,
/** 产 row 的四类(created+skipped+failed 之和对照) */
rowsByType: { 'wp:attachment': 855, 'wp:post': 129, 'wp:product': 48, 'wp:page': 15 },
/** unsupported 细分(`wp:<post_type>` 归桶) */
unsupportedByType: {
'wp:nav_menu_item': 68,
'wp:wpcf7_contact_form': 3,
'wp:elementor_library': 2,
'wp:wp_navigation': 2,
},
}
/** 期望出现的 counts 键全集 = rowsByType ∪ unsupportedByType(多一个少一个都算不一致) */
const EXPECTED_COUNTS_KEYS = [...Object.keys(BASELINE.rowsByType), ...Object.keys(BASELINE.unsupportedByType)].sort()
/** 断言登记(顺序即证据表行序) */
function makeChecks() {
const checks = []
const check = (name, expected, actual, pass) => checks.push({ name, expected, actual, pass })
const checkEq = (name, expected, actual) => check(name, expected, actual, Object.is(expected, actual))
return { checks, check, checkEq }
}
/** 流式 sha256(64KB 块,与 register 服务的哈希口径同型) */
async function sha256File(path) {
const hash = createHash('sha256')
for await (const chunk of createReadStream(path, { highWaterMark: 64 * 1024 })) {
hash.update(chunk)
}
return hash.digest('hex')
}
/** --wxr <path> / --wxr=<path> / --out <dir> / --out=<dir>(缺省 DEFAULT_WXR 与 artifacts/probe) */
function parseArgs(argv) {
const out = { wxr: DEFAULT_WXR, outDir: join(REPO_ROOT, 'artifacts', 'probe') }
for (let i = 0; i < argv.length; i++) {
const arg = argv[i]
if (arg === '--wxr' || arg === '--out') {
const value = argv[++i]
if (value === undefined) throw new Error(`${arg} 缺少值参数`)
if (arg === '--wxr') out.wxr = value
else out.outDir = value
} else if (arg !== undefined && arg.startsWith('--wxr=')) out.wxr = arg.slice(6)
else if (arg !== undefined && arg.startsWith('--out=')) out.outDir = arg.slice(6)
else throw new Error(`未知参数:${arg}(支持 --wxr <path> 与 --out <dir>)`)
}
return out
}
/** 单域 unresolved nicename 明细固化上限(防 post_tag 这类大域使 smoke.json 失去上界) */
const UNRESOLVED_LIST_CAP = 50
/**
* nicename 锚点核对(Task 4 冻结点:sourceTermId 以 item 内 @nicename 为锚)。
* 单遍流式(与 probe 独立的第二遍读,采样器已停):全量收集 wp:term 的
* (taxonomy → Set(slug)) 与 item 引用 (domain → Map(nicename → 计数))、
* 文档序前 10 个含 category 域引用的 item 明细——流结束后统一比对
* (不依赖 wp:term 与 item 的文档先后顺序)。
*
* 证据分两层(阶段 3 taxonomyRefs 映射策略的决策依据):
* - 任务要求的 10 条抽检:item 的 category 域 nicename ∈ wp:term(category) 的 slug 集;
* - 全量分层核对(每个 domain):区分「taxonomy 未出现在 wp:term 表」(导出缺该
* taxonomy,锚点无从对拍)与「taxonomy 在表但 nicename 无对应 slug」(真正的
* nicename≠slug 不一致)。前者是本 WXR 的实际形态(category/post_tag 未导出
* term 表),如实记录而非记为锚点失败。
*/
async function nicenameAudit(wxrPath) {
const termSlugsByTaxonomy = new Map()
const domainCounts = new Map()
const nicenameCountsByDomain = new Map()
const sampledItems = []
let itemsSeen = 0
let itemsWithCategoryRef = 0
for await (const ev of parseWxrStream(createReadStream(wxrPath))) {
if (ev.kind === 'term') {
const { taxonomy, slug } = ev.term
let set = termSlugsByTaxonomy.get(taxonomy)
if (set === undefined) {
set = new Set()
termSlugsByTaxonomy.set(taxonomy, set)
}
set.add(slug)
continue
}
itemsSeen++
const categoryRefs = ev.item.categories.filter((c) => c.domain === 'category')
for (const ref of ev.item.categories) {
domainCounts.set(ref.domain, (domainCounts.get(ref.domain) ?? 0) + 1)
let byNicename = nicenameCountsByDomain.get(ref.domain)
if (byNicename === undefined) {
byNicename = new Map()
nicenameCountsByDomain.set(ref.domain, byNicename)
}
byNicename.set(ref.nicename, (byNicename.get(ref.nicename) ?? 0) + 1)
}
if (categoryRefs.length === 0) continue
itemsWithCategoryRef++
if (sampledItems.length < NICENAME_SAMPLE_ITEMS) {
sampledItems.push({
rawLocation: ev.item.rawLocation,
postId: ev.item.postId,
postType: ev.item.postType,
refs: categoryRefs.map((ref) => ({ nicename: ref.nicename, value: ref.value })),
})
}
}
const categorySlugs = termSlugsByTaxonomy.get('category') ?? new Set()
// 抽检 10 条:明细级比对(nicename ∈ category 域 wp:term 的 term_slug 集)
let sampleMatched = 0
let sampleTotal = 0
const sampleMismatches = []
for (const item of sampledItems) {
for (const ref of item.refs) {
sampleTotal++
const resolved = categorySlugs.has(ref.nicename)
if (resolved) sampleMatched++
else sampleMismatches.push({ rawLocation: item.rawLocation, postId: item.postId, ...ref })
}
}
// 全量分层核对(每个 domain 一行):taxonomy 在表与否 × nicename 可解析与否
const perDomain = [...nicenameCountsByDomain.entries()]
.sort(([a], [b]) => a.localeCompare(b))
.map(([domain, byNicename]) => {
const slugs = termSlugsByTaxonomy.get(domain)
let refs = 0
let matched = 0
let distinctUnresolved = 0
const unresolved = []
for (const [nicename, count] of byNicename) {
refs += count
if (slugs !== undefined && slugs.has(nicename)) {
matched += count
} else {
distinctUnresolved++
if (unresolved.length < UNRESOLVED_LIST_CAP) unresolved.push({ nicename, refCount: count })
}
}
return {
domain,
refs,
matched,
rate: refs === 0 ? null : matched / refs,
taxonomyInTermTable: slugs !== undefined,
distinctUnresolved,
unresolvedCapped: unresolved.length < distinctUnresolved,
unresolved,
}
})
const conclusion = {
/** taxonomy 在 wp:term 表中的域的引用数(这些引用可严格对拍 nicename vs slug) */
refsAgainstExistingTaxonomy: 0,
matchedAgainstExistingTaxonomy: 0,
/** taxonomy 不在 wp:term 表的域的引用数(锚点无从对拍——导出缺表,非锚点不一致) */
refsOfAbsentTaxonomy: 0,
/** taxonomy 在表但 nicename 无对应 slug 的引用数(真正的 nicename≠slug 违例) */
nicenameEqualsSlugViolations: 0,
}
for (const row of perDomain) {
if (row.taxonomyInTermTable) {
conclusion.refsAgainstExistingTaxonomy += row.refs
conclusion.matchedAgainstExistingTaxonomy += row.matched
conclusion.nicenameEqualsSlugViolations += row.refs - row.matched
} else {
conclusion.refsOfAbsentTaxonomy += row.refs
}
}
return {
sampleRule: `文档序前 ${NICENAME_SAMPLE_ITEMS} 个含 domain="category" 引用的 item(共 ${itemsWithCategoryRef} 个 item 含 category 域引用,items 总数 ${itemsSeen})`,
sampledItems: sampledItems.map((item) => ({
...item,
refs: item.refs.map((ref) => ({ ...ref, resolvedToTermSlug: categorySlugs.has(ref.nicename) })),
})),
sampleMatched,
sampleTotal,
sampleRate: sampleTotal === 0 ? null : sampleMatched / sampleTotal,
sampleMismatches,
perDomain,
conclusion,
domainCounts: Object.fromEntries([...domainCounts.entries()].sort(([a], [b]) => a.localeCompare(b))),
termTaxonomies: Object.fromEntries(
[...termSlugsByTaxonomy.entries()]
.sort(([a], [b]) => a.localeCompare(b))
.map(([taxonomy, set]) => [taxonomy, set.size]),
),
}
}
async function main() {
const args = parseArgs(process.argv.slice(2))
const wxrPath = resolve(args.wxr)
const { checks, check, checkEq } = makeChecks()
process.stderr.write(`[smoke] 输入:${wxrPath}\n`)
const fileStat = await stat(wxrPath)
const sha256 = await sha256File(wxrPath)
checkEq('input.bytes', BASELINE.fileBytes, fileStat.size)
checkEq('input.sha256', BASELINE.sha256, sha256)
// —— probe + 内存采样(计划钉死口径)——
process.stderr.write('[smoke] 运行 probe(parse→map→sanitize 全链)+ setInterval(100ms) 内存采样…\n')
let maxHeapUsed = 0
let maxRss = 0
let samples = 0
const sample = () => {
const mu = process.memoryUsage()
if (mu.heapUsed > maxHeapUsed) maxHeapUsed = mu.heapUsed
if (mu.rss > maxRss) maxRss = mu.rss
samples++
}
const sampler = setInterval(sample, SAMPLE_INTERVAL_MS)
const report = await runWxrAdapterReport(createReadStream(wxrPath))
clearInterval(sampler)
sample() // 终末补采一次,覆盖收尾段(报告对象组装等)
// —— 计数对照(基线逐项)——
const t = report.totals
checkEq('totals.rows', BASELINE.rowsTotal, t.rows)
checkEq('totals.terms', BASELINE.terms, t.terms)
checkEq('totals.unsupported', BASELINE.unsupportedTotal, t.unsupported)
checkEq('totals.failed', BASELINE.failedTotal, t.failed)
checkEq('items.total(rows+unsupported+failed)', BASELINE.itemsTotal, t.rows + t.unsupported + t.failed)
for (const [type, expected] of Object.entries(BASELINE.rowsByType)) {
const c = report.counts[type]
checkEq(`rows.${type}(created+skipped+failed)`, expected, c === undefined ? 0 : c.created + c.skipped + c.failed)
}
for (const [type, expected] of Object.entries(BASELINE.unsupportedByType)) {
const c = report.counts[type]
checkEq(`unsupported.${type}`, expected, c === undefined ? 0 : c.unsupported)
}
checkEq(
'counts.keys(无多余/缺失桶)',
EXPECTED_COUNTS_KEYS.join(','),
Object.keys(report.counts).sort().join(','),
)
checkEq('probe.fatalError', null, report.fatalError)
check('memory.heapUsedMax<100MB', `< ${HEAP_LIMIT_BYTES}`, maxHeapUsed, maxHeapUsed < HEAP_LIMIT_BYTES)
// —— nicename 锚点核对(证据采集,非 pass/fail 断言)——
process.stderr.write('[smoke] nicename 锚点核对(第二遍流式)…\n')
const nicename = await nicenameAudit(wxrPath)
const verdict = checks.every((c) => c.pass) ? 'PASS' : 'FAIL'
// —— 产物(与 wxr:probe CLI 同布局 + smoke.json)——
const runId = makeRunId()
const dir = join(resolve(args.outDir), runId)
await mkdir(dir, { recursive: true })
await writeFile(join(dir, 'report.json'), `${JSON.stringify(report, null, 2)}\n`, 'utf8')
await writeFile(join(dir, 'report.html'), `${renderReportHtml(report)}\n`, 'utf8')
const smoke = {
runId,
generatedAt: new Date().toISOString(),
nodeVersion: process.version,
input: { path: wxrPath, bytes: fileStat.size, sha256 },
probe: {
totals: report.totals,
counts: report.counts,
sanitize: report.sanitize,
timing: report.timing,
rowErrors: { recorded: report.rowErrors.length, truncated: report.rowErrorsTruncated },
fatalError: report.fatalError,
},
memory: {
intervalMs: SAMPLE_INTERVAL_MS,
samples,
maxHeapUsedBytes: maxHeapUsed,
maxRssBytes: maxRss,
heapLimitBytes: HEAP_LIMIT_BYTES,
heapUnderLimit: maxHeapUsed < HEAP_LIMIT_BYTES,
},
nicenameAudit: nicename,
checks,
verdict,
artifacts: { dir, report: join(dir, 'report.json'), smoke: join(dir, 'smoke.json') },
}
await writeFile(join(dir, 'smoke.json'), `${JSON.stringify(smoke, null, 2)}\n`, 'utf8')
for (const c of checks) {
process.stderr.write(` [${c.pass ? 'ok' : 'FAIL'}] ${c.name}: expected=${JSON.stringify(c.expected)} actual=${JSON.stringify(c.actual)}\n`)
}
const nc = nicename.conclusion
process.stderr.write(
`[smoke] verdict=${verdict}(nicename 抽检 ${nicename.sampleMatched}/${nicename.sampleTotal};` +
`在表 taxonomy 对拍 ${nc.matchedAgainstExistingTaxonomy}/${nc.refsAgainstExistingTaxonomy},` +
`nicename≠slug 违例 ${nc.nicenameEqualsSlugViolations},缺表 taxonomy 引用 ${nc.refsOfAbsentTaxonomy})\n`,
)
process.stderr.write(`[smoke] 产物:${join(dir, 'smoke.json')}\n`)
process.stdout.write(`${JSON.stringify(smoke, null, 2)}\n`)
process.exitCode = verdict === 'PASS' ? 0 : 1
}
main().catch((err) => {
process.stderr.write(`[smoke] 未预期异常:${err instanceof Error ? err.stack : String(err)}\n`)
process.exitCode = 1
})