197 lines
9.3 KiB
JavaScript
197 lines
9.3 KiB
JavaScript
import assert from 'node:assert/strict'
|
|
import test from 'node:test'
|
|
import { AcceptanceRun, parseArguments, buildAcceptanceSummary, finalizeAcceptanceReport } from './admin-test-env-acceptance.mjs'
|
|
import { mkdtemp, writeFile, unlink, rmdir } from 'node:fs/promises'
|
|
import { tmpdir } from 'node:os'
|
|
import { join } from 'node:path'
|
|
|
|
test('登录失败且未执行业务模块不能报告全量覆盖', async () => {
|
|
const run = new AcceptanceRun({ environment: 'test', fixedCustomerId: '123', quiet: true,
|
|
modules: ['dashboard'], requestedModules: ['dashboard'] })
|
|
run.request = async () => ({ http: 200, body: { code: 'A0401' } })
|
|
const report = await run.run()
|
|
assert.equal(report.success, false)
|
|
assert.equal(report.fullCoverage, false)
|
|
assert.equal(report.coverageStatus, 'FAILED')
|
|
assert.deepEqual(report.executionScope.unexecutedModules, ['dashboard'])
|
|
})
|
|
|
|
function completeReport() {
|
|
return { fatal: null, executionScope: { plannedModules: ['orders', 'finance'], defaultModules: ['orders', 'finance'] },
|
|
steps: [{ module: 'orders', passed: true }, { module: 'finance', passed: true }],
|
|
modules: ['orders', 'finance'].map(name => ({ name, success: true, passed: 1, failed: 0 })),
|
|
coverageGaps: [], deploymentBlockers: [] }
|
|
}
|
|
|
|
test('全量覆盖要求计划全部实际完成；定向成功单独保留通过结果', () => {
|
|
const full = finalizeAcceptanceReport(completeReport())
|
|
assert.equal(full.success, true)
|
|
assert.equal(full.fullCoverage, true)
|
|
assert.equal(full.coverageStatus, 'FULL')
|
|
const focused = completeReport()
|
|
focused.executionScope.plannedModules = ['orders']
|
|
focused.modules.pop(); focused.steps.pop()
|
|
finalizeAcceptanceReport(focused)
|
|
assert.equal(focused.success, true)
|
|
assert.equal(focused.fullCoverage, false)
|
|
assert.equal(focused.executionScope.planCompleted, true)
|
|
assert.equal(focused.coverageStatus, 'PARTIAL')
|
|
})
|
|
|
|
for (const [label, mutate, failed] of [
|
|
['模块未执行', report => { report.modules.pop() }, true],
|
|
['模块没有断言', report => { report.modules[1].passed = 0 }, true],
|
|
['模块失败但没有失败步骤', report => { report.modules[1].success = false }, true],
|
|
['中止', report => { report.executionScope.stoppedByRequest = true }, true],
|
|
['阻断覆盖缺口', report => { report.coverageGaps.push({ blocking: true }) }, true],
|
|
['外部部署阻断', report => { report.deploymentBlockers.push({ module: 'orders' }) }, true],
|
|
['跳过模块', report => { Object.assign(report.modules[1], { skipped: true, success: false, passed: 0 }) }, false],
|
|
['只读生命周期缺口', report => { report.coverageGaps.push({ blocking: false }) }, false],
|
|
['仅准备数据', report => { report.executionScope.preparationOnly = true }, false],
|
|
['退货仅主链', report => { report.executionScope.returnMainChainOnly = true }, false],
|
|
['显式局部验收', report => { report.fullAcceptance = false }, false],
|
|
]) test(`${label}不允许标记全量覆盖`, () => {
|
|
const report = completeReport(); mutate(report); finalizeAcceptanceReport(report)
|
|
assert.equal(report.success, !failed)
|
|
assert.equal(report.fullCoverage, false)
|
|
})
|
|
|
|
test('清理失败后重新计算报告，不能保留先前的成功与覆盖率', () => {
|
|
const report = finalizeAcceptanceReport(completeReport())
|
|
report.steps.push({ module: 'cleanup', passed: false })
|
|
finalizeAcceptanceReport(report)
|
|
assert.equal(report.success, false)
|
|
assert.equal(report.fullCoverage, false)
|
|
assert.equal(report.summary.failed, 1)
|
|
})
|
|
|
|
test('混柜专项隔离上下文与报告资源，失败仍保留本轮独立证据', async () => {
|
|
const run = new AcceptanceRun({ environment: 'test', fixedCustomerId: '123', quiet: true })
|
|
run.context.orderDestinationType = 'FBA'
|
|
run.createdResources.orders = { orderNo: 'MAIN-ORDER' }
|
|
const marker = run.marker
|
|
await assert.rejects(run.runIsolatedModule('mixed-container-receiving', async child => {
|
|
assert.equal(child.fixedPdaLeases, run.fixedPdaLeases)
|
|
child.context.orderDestinationType = 'PRIVATE'
|
|
child.options.prepareDropshipManualCount = true
|
|
child.createdResources.orders = { orderNo: 'ISOLATED-ORDER' }
|
|
child.token = 'rotated-session'
|
|
child.refreshToken = 'rotated-refresh'
|
|
child.expiresAt = 123
|
|
child.marker = 'CHANGED'
|
|
throw Error('fixture failure')
|
|
}), /fixture failure/)
|
|
assert.equal(run.marker, marker)
|
|
assert.equal(run.context.orderDestinationType, 'FBA')
|
|
assert.equal(run.options.prepareDropshipManualCount, undefined)
|
|
assert.equal(run.token, 'rotated-session')
|
|
assert.equal(run.refreshToken, 'rotated-refresh')
|
|
assert.equal(run.expiresAt, 123)
|
|
assert.equal(run.createdResources.orders.orderNo, 'MAIN-ORDER')
|
|
assert.equal(run.createdResources.isolatedModules['mixed-container-receiving'].orders.orderNo, 'ISOLATED-ORDER')
|
|
})
|
|
|
|
test('真实总入口调度混柜模块必须经过隔离处理器', async () => {
|
|
const run = new AcceptanceRun({ environment: 'test', fixedCustomerId: '123', quiet: true,
|
|
modules: ['mixed-container-receiving'], requestedModules: ['mixed-container-receiving'] })
|
|
run.request = async (method, path) => {
|
|
assert.equal(method, 'POST'); assert.equal(path, '/api/auth/login')
|
|
return { http: 200, body: { code: '200', data: { accessToken: 'mock-session', refreshToken: 'mock-refresh' } } }
|
|
}
|
|
let isolated = false
|
|
run.runIsolatedModule = async (name, handler) => {
|
|
assert.equal(name, 'mixed-container-receiving')
|
|
assert.equal(typeof handler, 'function')
|
|
isolated = true
|
|
run.addStep(name, 'offline isolated workflow', null, true)
|
|
}
|
|
const report = await run.run()
|
|
assert.equal(isolated, true)
|
|
assert.equal(report.success, true)
|
|
assert.equal(report.fullCoverage, false)
|
|
assert.deepEqual(report.executionScope.completedModules, ['mixed-container-receiving'])
|
|
})
|
|
|
|
test('explicit stop file waits for a module boundary and records an interrupted failure once', async () => {
|
|
const directory = await mkdtemp(join(tmpdir(), 'acceptance-stop-'))
|
|
const stopFile = join(directory, 'stop')
|
|
const run = new AcceptanceRun({ stopFile, quiet: true, modules: [] })
|
|
try {
|
|
assert.equal(parseArguments(['--stop-file', stopFile]).stopFile, stopFile)
|
|
assert.equal(await run.stopAtBoundary(), false)
|
|
await writeFile(stopFile, 'stop')
|
|
assert.equal(await run.stopAtBoundary(), true)
|
|
assert.equal(await run.stopAtBoundary(), true)
|
|
assert.match(run.fatal, /中止结果/)
|
|
assert.equal(run.steps.length, 1)
|
|
assert.equal(run.steps[0].passed, false)
|
|
assert.equal(buildAcceptanceSummary(run.steps, [], []).failed, 1)
|
|
assert.deepEqual(run.createdResources, {})
|
|
} finally { await unlink(stopFile).catch(error => { if (error.code !== 'ENOENT') throw error }); await rmdir(directory) }
|
|
})
|
|
|
|
test('report summary separates assertion, module-run and unique-request metrics', () => {
|
|
const sharedResponse = {
|
|
method: 'GET', path: '/api/platform/v1/orders?page=1', requestId: 'request-1',
|
|
}
|
|
const steps = [
|
|
{ module: 'orders', name: '订单列表成功', passed: true,
|
|
request: { method: sharedResponse.method, path: sharedResponse.path }, requestId: sharedResponse.requestId },
|
|
{ module: 'orders', name: '订单列表数据结构正确', passed: true,
|
|
request: { method: sharedResponse.method, path: sharedResponse.path }, requestId: sharedResponse.requestId },
|
|
{ module: 'orders', name: '订单列表成功', passed: false,
|
|
request: { method: 'GET', path: '/api/platform/v1/orders?page=2' }, requestId: 'request-2' },
|
|
{ module: 'report-security', name: '报告敏感信息扫描', passed: true, request: null, requestId: null },
|
|
]
|
|
const modules = [
|
|
{ name: 'orders' },
|
|
{ name: 'orders' },
|
|
{ name: 'finance', skipped: 'owned by finance full chain' },
|
|
]
|
|
|
|
const summary = buildAcceptanceSummary(steps, modules, [])
|
|
|
|
assert.deepEqual(summary, {
|
|
total: 4,
|
|
passed: 3,
|
|
failed: 1,
|
|
moduleRuns: 2,
|
|
uniqueModules: 1,
|
|
uniqueRequests: 2,
|
|
uniqueStepNames: 3,
|
|
skippedModules: 1,
|
|
coverageGaps: { total: 0, blocking: 0, nonBlocking: 0, byCategory: {} },
|
|
})
|
|
})
|
|
|
|
test('request evidence without requestId is deduplicated by method and path', () => {
|
|
const summary = buildAcceptanceSummary([
|
|
{ name: 'CSV 状态', passed: true, request: { method: 'GET', path: '/api/export' }, requestId: null },
|
|
{ name: 'CSV 表头', passed: true, request: { method: 'GET', path: '/api/export' }, requestId: null },
|
|
{ name: 'CSV POST', passed: true, request: { method: 'POST', path: '/api/export' }, requestId: null },
|
|
])
|
|
|
|
assert.equal(summary.uniqueRequests, 2)
|
|
})
|
|
|
|
test('coverage gaps are counted by category and blocking status without copying details', () => {
|
|
const summary = buildAcceptanceSummary([], [], [
|
|
{ category: 'device', blocking: false, reason: 'camera', secretEvidence: 'must-not-copy' },
|
|
{ category: 'device', blocking: true, reason: 'scanner' },
|
|
{ category: 'external-third-party', blocking: false, reason: 'captcha' },
|
|
{ blocking: true, reason: 'fixture' },
|
|
])
|
|
|
|
assert.deepEqual(summary.coverageGaps, {
|
|
total: 4,
|
|
blocking: 2,
|
|
nonBlocking: 2,
|
|
byCategory: {
|
|
device: { total: 2, blocking: 1, nonBlocking: 1 },
|
|
'external-third-party': { total: 1, blocking: 0, nonBlocking: 1 },
|
|
uncategorized: { total: 1, blocking: 1, nonBlocking: 0 },
|
|
},
|
|
})
|
|
assert.equal(JSON.stringify(summary).includes('must-not-copy'), false)
|
|
})
|