671 lines
28 KiB
JavaScript
671 lines
28 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
/**
|
|
* Client phase-two test-environment acceptance flow.
|
|
*
|
|
* The platform account is used only to discover deterministic inbound fixtures.
|
|
* All phase-two product assertions are executed with the Client account.
|
|
*
|
|
* Run directly and enter credentials when prompted:
|
|
* node scripts/client-phase2-test-env-acceptance.mjs
|
|
*/
|
|
|
|
import { mkdir, writeFile } from 'node:fs/promises'
|
|
import { randomUUID } from 'node:crypto'
|
|
import { resolve } from 'node:path'
|
|
import { createInterface } from 'node:readline/promises'
|
|
|
|
const args = parseArgs(process.argv.slice(2))
|
|
const gateway = trimSlash(args.gateway ?? process.env.CLIENT_PHASE2_TEST_GATEWAY
|
|
?? 'http://8.163.30.128:9000')
|
|
const clientUsername = args['client-username'] ?? process.env.CLIENT_PHASE2_USERNAME
|
|
?? await promptText('二期客户端账号', 'merchant_admin')
|
|
const clientPassword = args['client-password'] ?? process.env.CLIENT_PHASE2_PASSWORD
|
|
?? await promptSecret('二期客户端密码')
|
|
const platformUsername = args['platform-username'] ?? process.env.PLATFORM_USERNAME
|
|
?? await promptText('平台夹具查询账号', 'platform_admin')
|
|
const platformPassword = args['platform-password'] ?? process.env.PLATFORM_PASSWORD
|
|
?? await promptSecret('平台夹具查询密码')
|
|
const forcedOrderId = args['order-id'] ?? process.env.CLIENT_PHASE2_ORDER_ID ?? null
|
|
const reportDir = resolve(args['report-dir'] ?? process.env.CLIENT_PHASE2_REPORT_DIR ?? 'reports')
|
|
const timeoutMs = Number(args['timeout-ms'] ?? process.env.CLIENT_PHASE2_TIMEOUT_MS ?? 30_000)
|
|
|
|
if (!clientPassword || !platformPassword) {
|
|
console.error('Client and platform passwords are required')
|
|
process.exit(2)
|
|
}
|
|
if (!Number.isFinite(timeoutMs) || timeoutMs < 1_000) {
|
|
console.error('--timeout-ms must be at least 1000')
|
|
process.exit(2)
|
|
}
|
|
|
|
const now = new Date()
|
|
const marker = `${compactTimestamp(now)}-${randomUUID().slice(0, 8)}`
|
|
const reportPath = resolve(reportDir, `client-phase2-test-env-${marker}.json`)
|
|
const report = {
|
|
marker,
|
|
gateway,
|
|
generatedAt: now.toISOString(),
|
|
completedAt: null,
|
|
success: false,
|
|
fatal: null,
|
|
testAccount: { username: clientUsername },
|
|
expectedTerminalState: {
|
|
processStatus: 'WAIT_SPLIT',
|
|
measureReviewStatus: 'APPROVED',
|
|
feeStatus: 'CONFIRMED',
|
|
},
|
|
resources: {
|
|
tenantId: null,
|
|
terminalInboundId: null,
|
|
terminalOrderId: null,
|
|
terminalInboundCode: null,
|
|
pendingOrderId: null,
|
|
foreignOrderId: null,
|
|
measurementImageFileIds: [],
|
|
weightImageFileIds: [],
|
|
},
|
|
steps: [],
|
|
}
|
|
|
|
let clientToken
|
|
let platformToken
|
|
let terminalFixture
|
|
let pendingFixture
|
|
let foreignFixture
|
|
let platformTerminalDetail
|
|
let merchantBilling
|
|
|
|
try {
|
|
await sessionModule()
|
|
await fixtureDiscoveryModule()
|
|
await unpublishedVisibilityModule()
|
|
await terminalBillingModule()
|
|
await unifiedOrderModule()
|
|
await isolationModule()
|
|
report.success = report.steps.every((step) => step.passed)
|
|
} catch (error) {
|
|
report.fatal = sanitizeError(error)
|
|
report.success = false
|
|
} finally {
|
|
report.completedAt = new Date().toISOString()
|
|
await mkdir(reportDir, { recursive: true })
|
|
await writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8')
|
|
printSummary()
|
|
}
|
|
|
|
process.exitCode = report.success ? 0 : 1
|
|
|
|
async function sessionModule() {
|
|
const clientLogin = await apiStep('phase2-session', 'client login', {
|
|
method: 'POST', path: '/api/auth/login',
|
|
body: { username: clientUsername, password: clientPassword },
|
|
}, ({ json }) => {
|
|
requireSuccess(json)
|
|
assertPresent(json.data?.accessToken, 'client accessToken')
|
|
}, () => ({ username: clientUsername }))
|
|
clientToken = clientLogin.json.data.accessToken
|
|
|
|
const profile = await apiStep('phase2-session', 'load current enterprise profile', {
|
|
method: 'GET', path: '/api/merchant/v1/iam/tenant/profile', token: clientToken,
|
|
}, ({ json }) => {
|
|
requireSuccess(json)
|
|
assertPresent(json.data?.id, 'enterprise id')
|
|
assertEqual(json.data?.status, 'ACTIVE', 'enterprise status')
|
|
}, ({ json }) => ({ tenantId: json.data.id, tenantName: json.data.tenantName, status: json.data.status }))
|
|
report.resources.tenantId = String(profile.json.data.id)
|
|
|
|
await apiStep('phase2-session', 'client has order view permission', {
|
|
method: 'GET', path: '/api/merchant/v1/iam/authorization/permissions', token: clientToken,
|
|
}, ({ json }) => {
|
|
requireSuccess(json)
|
|
assertTrue(arrayData(json.data).includes('merchant:order:view'), 'merchant:order:view permission is required')
|
|
}, ({ json }) => ({ permissionCount: arrayData(json.data).length }))
|
|
|
|
const platformLogin = await apiStep('phase2-fixture', 'platform fixture account login', {
|
|
method: 'POST', path: '/api/auth/login',
|
|
body: { username: platformUsername, password: platformPassword },
|
|
}, ({ json }) => {
|
|
requireSuccess(json)
|
|
assertPresent(json.data?.accessToken, 'platform accessToken')
|
|
}, () => ({ username: platformUsername }))
|
|
platformToken = platformLogin.json.data.accessToken
|
|
}
|
|
|
|
async function fixtureDiscoveryModule() {
|
|
const ownInbounds = await apiStep('phase2-fixture', 'discover current enterprise inbound fixtures', {
|
|
method: 'GET',
|
|
path: `/api/platform/inbounds?tenantId=${report.resources.tenantId}&page=1&size=200`,
|
|
token: platformToken,
|
|
}, ({ json }) => {
|
|
requireSuccess(json)
|
|
assertTrue(Array.isArray(json.data?.records), 'inbound records must be an array')
|
|
}, ({ json }) => ({ total: json.data?.total, statusCounts: statusCounts(json.data?.records) }))
|
|
|
|
const ownRows = pageRecords(ownInbounds.json.data)
|
|
terminalFixture = forcedOrderId
|
|
? ownRows.find((row) => String(row.orderId) === String(forcedOrderId))
|
|
: ownRows.find(isTerminalFixture)
|
|
if (!terminalFixture) {
|
|
throw new Error(forcedOrderId
|
|
? `Configured orderId=${forcedOrderId} is not visible in tenant ${report.resources.tenantId}`
|
|
: `Tenant ${report.resources.tenantId} has no WAIT_SPLIT + APPROVED + CONFIRMED fixture`)
|
|
}
|
|
assertTerminalFixture(terminalFixture)
|
|
report.resources.terminalInboundId = String(terminalFixture.id)
|
|
report.resources.terminalOrderId = String(terminalFixture.orderId)
|
|
report.resources.terminalInboundCode = terminalFixture.inboundCode
|
|
|
|
pendingFixture = ownRows.find((row) => String(row.orderId) !== report.resources.terminalOrderId
|
|
&& !isTerminalFixture(row))
|
|
report.resources.pendingOrderId = pendingFixture == null ? null : String(pendingFixture.orderId)
|
|
|
|
await softApiStep('phase2-fixture', 'terminal state filters find selected inbound', {
|
|
method: 'GET',
|
|
path: `/api/platform/inbounds?tenantId=${report.resources.tenantId}`
|
|
+ '&processStatus=WAIT_SPLIT&measureReviewStatus=APPROVED&feeStatus=CONFIRMED&page=1&size=200',
|
|
token: platformToken,
|
|
}, ({ json }) => {
|
|
requireSuccess(json)
|
|
const row = pageRecords(json.data)
|
|
.find((item) => String(item.id) === report.resources.terminalInboundId)
|
|
assertPresent(row, 'terminal inbound filter row')
|
|
assertTerminalFixture(row)
|
|
}, ({ json }) => ({ total: json.data?.total, inboundId: report.resources.terminalInboundId }))
|
|
const detail = await apiStep('phase2-fixture', 'load platform terminal inbound reference detail', {
|
|
method: 'GET',
|
|
path: `/api/platform/inbounds/${report.resources.terminalInboundId}?tenantId=${report.resources.tenantId}`,
|
|
token: platformToken,
|
|
}, ({ json }) => {
|
|
requireSuccess(json)
|
|
assertEqual(String(json.data?.summary?.id), report.resources.terminalInboundId, 'inbound id')
|
|
assertEqual(String(json.data?.summary?.orderId), report.resources.terminalOrderId, 'order id')
|
|
assertTerminalFixture(json.data?.summary)
|
|
}, ({ json }) => ({
|
|
inboundId: json.data.summary.id,
|
|
orderId: json.data.summary.orderId,
|
|
processStatus: json.data.summary.processStatus,
|
|
measureReviewStatus: json.data.summary.measureReviewStatus,
|
|
feeStatus: json.data.summary.feeStatus,
|
|
}))
|
|
platformTerminalDetail = detail.json.data
|
|
|
|
const allTerminal = await apiStep('phase2-fixture', 'discover foreign terminal fixture for isolation', {
|
|
method: 'GET',
|
|
path: '/api/platform/inbounds?page=1&size=200',
|
|
token: platformToken,
|
|
}, ({ json }) => {
|
|
requireSuccess(json)
|
|
assertTrue(Array.isArray(json.data?.records), 'terminal fixture records must be an array')
|
|
}, ({ json }) => ({ total: json.data?.total }))
|
|
foreignFixture = pageRecords(allTerminal.json.data)
|
|
.find((row) => isTerminalFixture(row) && String(row.tenantId) !== report.resources.tenantId)
|
|
report.resources.foreignOrderId = foreignFixture == null ? null : String(foreignFixture.orderId)
|
|
}
|
|
|
|
async function unpublishedVisibilityModule() {
|
|
if (!pendingFixture) {
|
|
recordSkipped('phase2-client-visibility', 'unfinished inbound billing remains unavailable',
|
|
'Current enterprise has no non-terminal inbound fixture')
|
|
return
|
|
}
|
|
await apiStep('phase2-client-visibility', 'unfinished inbound billing remains unavailable', {
|
|
method: 'GET',
|
|
path: `/api/merchant/v1/first-leg/orders/${pendingFixture.orderId}/inbound-billing`,
|
|
token: clientToken,
|
|
}, ({ json, status }) => {
|
|
assertEqual(status, 200, 'HTTP status')
|
|
assertEqual(String(json?.code), 'A0404', 'business code')
|
|
}, ({ json }) => ({
|
|
orderId: pendingFixture.orderId,
|
|
processStatus: pendingFixture.processStatus,
|
|
feeStatus: pendingFixture.feeStatus,
|
|
rejectionCode: json?.code,
|
|
}))
|
|
|
|
await apiStep('phase2-client-visibility', 'unknown order inbound billing is rejected', {
|
|
method: 'GET', path: '/api/merchant/v1/first-leg/orders/1/inbound-billing', token: clientToken,
|
|
}, ({ json, status }) => {
|
|
assertEqual(status, 200, 'HTTP status')
|
|
assertEqual(String(json?.code), 'A0404', 'business code')
|
|
}, ({ json }) => ({ orderId: 1, rejectionCode: json?.code }))
|
|
}
|
|
|
|
async function terminalBillingModule() {
|
|
const response = await softApiStep('phase2-client-billing',
|
|
'terminal inbound billing is visible to client', {
|
|
method: 'GET',
|
|
path: `/api/merchant/v1/first-leg/orders/${report.resources.terminalOrderId}/inbound-billing`,
|
|
token: clientToken,
|
|
}, ({ json }) => {
|
|
requireSuccess(json)
|
|
assertPresent(json.data?.inbound?.summary, 'merchant inbound summary')
|
|
assertPresent(json.data?.latestFee, 'merchant latest fee')
|
|
assertEqual(String(json.data.inbound.summary.id), report.resources.terminalInboundId, 'inbound id')
|
|
assertEqual(String(json.data.inbound.summary.orderId), report.resources.terminalOrderId, 'order id')
|
|
assertTerminalFixture(json.data.inbound.summary)
|
|
assertEqual(json.data.latestFee.feeStatus, 'CONFIRMED', 'latest fee status')
|
|
}, ({ json }) => ({
|
|
inboundId: json?.data?.inbound?.summary?.id,
|
|
orderId: json?.data?.inbound?.summary?.orderId,
|
|
processStatus: json?.data?.inbound?.summary?.processStatus,
|
|
measureReviewStatus: json?.data?.inbound?.summary?.measureReviewStatus,
|
|
feeStatus: json?.data?.latestFee?.feeStatus,
|
|
rejectionCode: json?.code,
|
|
}))
|
|
if (!response) {
|
|
recordSkipped('phase2-client-billing', 'terminal billing aggregate contract',
|
|
'Terminal billing endpoint did not return a visible aggregate')
|
|
recordSkipped('phase2-client-images', 'published measurement and weight image access',
|
|
'Terminal billing endpoint did not return image references')
|
|
return
|
|
}
|
|
merchantBilling = response.json.data
|
|
|
|
await localStep('phase2-client-billing', 'terminal billing aggregate contract', () => {
|
|
const summary = merchantBilling.inbound.summary
|
|
const fee = merchantBilling.latestFee
|
|
assertStringId(summary.id, 'inbound summary id')
|
|
assertStringId(summary.orderId, 'inbound order id')
|
|
assertStringId(fee.feeId, 'fee id')
|
|
assertStringId(fee.inboundId, 'fee inbound id')
|
|
assertEqual(String(fee.inboundId), String(summary.id), 'fee inbound relation')
|
|
assertEqual(fee.inboundCode, summary.inboundCode, 'fee inbound code')
|
|
assertEqual(fee.customerId == null ? null : String(fee.customerId), report.resources.tenantId,
|
|
'fee customer isolation')
|
|
assertTrue(Number(fee.actualWeightKg) > 0, 'actual weight must be positive')
|
|
assertTrue(Number(fee.actualVolumeCbm) > 0, 'actual volume must be positive')
|
|
assertTrue(Number(fee.chargeableQuantity) > 0, 'chargeable quantity must be positive')
|
|
assertTrue(Number(fee.unitPrice) >= 0, 'unit price must not be negative')
|
|
assertMoneyEqual(Number(fee.subtotalAmount) + Number(fee.additionalAmount),
|
|
Number(fee.totalAmount), 'fee amount composition')
|
|
assertEqual(fee.chargeUnit, fee.chargeMode, 'fee charge unit')
|
|
assertTrue(['KG', 'CBM'].includes(fee.chargeMode), 'charge mode must be KG or CBM')
|
|
}, {
|
|
inboundId: report.resources.terminalInboundId,
|
|
feeId: merchantBilling.latestFee.feeId,
|
|
feeNo: merchantBilling.latestFee.feeNo,
|
|
chargeMode: merchantBilling.latestFee.chargeMode,
|
|
chargeableQuantity: merchantBilling.latestFee.chargeableQuantity,
|
|
totalAmount: merchantBilling.latestFee.totalAmount,
|
|
currency: merchantBilling.latestFee.currency,
|
|
})
|
|
|
|
await localStep('phase2-client-billing', 'client aggregate excludes platform internal collections', () => {
|
|
assertEqual(arrayData(merchantBilling.inbound.internalNotes).length, 0, 'merchant internal note count')
|
|
assertEqual(arrayData(merchantBilling.inbound.statusHistory).length, 0, 'merchant status history count')
|
|
for (const file of arrayData(merchantBilling.inbound.files)) {
|
|
assertTrue(['PUBLIC', 'MERCHANT'].includes(file.visibility),
|
|
`merchant file visibility must be PUBLIC or MERCHANT, actual=${file.visibility}`)
|
|
}
|
|
assertEqual(merchantBilling.inbound.publicRemark ?? null,
|
|
platformTerminalDetail.publicRemark ?? null, 'public remark')
|
|
}, {
|
|
internalNoteCount: arrayData(merchantBilling.inbound.internalNotes).length,
|
|
statusHistoryCount: arrayData(merchantBilling.inbound.statusHistory).length,
|
|
visibleFileCount: arrayData(merchantBilling.inbound.files).length,
|
|
})
|
|
|
|
await localStep('phase2-client-billing', 'measurement and billing basis are internally consistent', () => {
|
|
const summary = merchantBilling.measurementSummary
|
|
const basis = merchantBilling.billingBasis
|
|
const fee = merchantBilling.latestFee
|
|
assertPresent(summary?.measurementId, 'measurement id')
|
|
assertEqual(summary.measurementStatus, 'SUBMITTED', 'measurement status')
|
|
assertTrue(Number(summary.actualPackageCount) > 0, 'actual package count must be positive')
|
|
assertTrue(Number(summary.actualGrossWeightKg) > 0, 'measurement gross weight must be positive')
|
|
assertTrue(Number(summary.actualVolumeCbm) > 0, 'measurement volume must be positive')
|
|
assertNumberEqual(basis.actualWeightKg, fee.actualWeightKg, 'billing actual weight')
|
|
assertNumberEqual(basis.actualVolumeCbm, fee.actualVolumeCbm, 'billing actual volume')
|
|
assertNumberEqual(basis.convertedQuantity, fee.convertedQuantity, 'billing converted quantity')
|
|
assertNumberEqual(basis.chargeableQuantity, fee.chargeableQuantity, 'billing chargeable quantity')
|
|
}, {
|
|
measurementId: merchantBilling.measurementSummary?.measurementId,
|
|
measurementStatus: merchantBilling.measurementSummary?.measurementStatus,
|
|
measurementItemCount: arrayData(merchantBilling.measurementItems).length,
|
|
weightResultCount: arrayData(merchantBilling.weightResults).length,
|
|
chargeableBasis: merchantBilling.billingBasis?.chargeableBasis,
|
|
})
|
|
|
|
const measurementImages = arrayData(merchantBilling.measurementImages)
|
|
const weightImages = arrayData(merchantBilling.weightImages)
|
|
report.resources.measurementImageFileIds = measurementImages.map((item) => String(item.fileId))
|
|
report.resources.weightImageFileIds = weightImages.map((item) => String(item.fileId))
|
|
const images = [...measurementImages, ...weightImages]
|
|
if (images.length === 0) {
|
|
recordSkipped('phase2-client-images', 'published measurement and weight image access',
|
|
'Terminal billing aggregate contains no image references')
|
|
} else {
|
|
for (const image of images.slice(0, 4)) {
|
|
await apiStep('phase2-client-images', `download ${image.imageType} image ${image.fileId}`, {
|
|
method: 'GET', path: apiPath(image.previewUrl), token: clientToken, responseType: 'bytes',
|
|
}, ({ status, bytes, headers }) => {
|
|
assertEqual(status, 200, 'HTTP status')
|
|
assertTrue(bytes?.length > 0, 'downloaded image must not be empty')
|
|
assertTrue((headers.get('content-type') ?? '').startsWith('image/'),
|
|
'download content type must be an image')
|
|
}, ({ bytes, headers }) => ({
|
|
fileId: image.fileId,
|
|
imageType: image.imageType,
|
|
sizeBytes: bytes.length,
|
|
contentType: headers.get('content-type'),
|
|
}))
|
|
}
|
|
}
|
|
|
|
await apiStep('phase2-client-images', 'unreferenced inbound image is rejected', {
|
|
method: 'GET',
|
|
path: `/api/merchant/v1/first-leg/orders/${report.resources.terminalOrderId}/inbound-billing/images/1`,
|
|
token: clientToken,
|
|
}, ({ json, status }) => {
|
|
assertEqual(status, 200, 'HTTP status')
|
|
assertEqual(String(json?.code), 'A0404', 'business code')
|
|
}, ({ json }) => ({ fileId: 1, rejectionCode: json?.code }))
|
|
}
|
|
|
|
async function unifiedOrderModule() {
|
|
const orderNo = terminalFixture.orderNo
|
|
await apiStep('phase2-unified-orders', 'unified order list exposes phase-two terminal state', {
|
|
method: 'GET',
|
|
path: `/api/merchant/v1/orders?page=1&size=50&orderNo=${encodeURIComponent(orderNo)}`,
|
|
token: clientToken,
|
|
}, ({ json }) => {
|
|
requireSuccess(json)
|
|
const row = pageRecords(json.data)
|
|
.find((item) => String(item.orderId) === report.resources.terminalOrderId)
|
|
assertPresent(row, 'unified terminal order row')
|
|
assertEqual(row.mainStatus, 'INBOUNDED', 'unified main status')
|
|
assertEqual(String(row.inboundId), report.resources.terminalInboundId, 'unified inbound id')
|
|
assertEqual(row.measurement?.reviewStatus, 'APPROVED', 'unified measurement review status')
|
|
assertTrue(Number(row.actualGrossWeightKg) > 0, 'unified actual gross weight must be positive')
|
|
assertTrue(Number(row.actualVolumeCbm) > 0, 'unified actual volume must be positive')
|
|
}, ({ json }) => {
|
|
const row = pageRecords(json.data)
|
|
.find((item) => String(item.orderId) === report.resources.terminalOrderId)
|
|
return { orderId: row?.orderId, mainStatus: row?.mainStatus,
|
|
inboundId: row?.inboundId, measurementReviewStatus: row?.measurement?.reviewStatus,
|
|
actualGrossWeightKg: row?.actualGrossWeightKg, actualVolumeCbm: row?.actualVolumeCbm }
|
|
})
|
|
|
|
await apiStep('phase2-unified-orders', 'unified order detail includes phase-two timeline', {
|
|
method: 'GET', path: `/api/merchant/v1/orders/${report.resources.terminalOrderId}`, token: clientToken,
|
|
}, ({ json }) => {
|
|
requireSuccess(json)
|
|
assertEqual(String(json.data?.summary?.orderId), report.resources.terminalOrderId, 'unified order id')
|
|
assertEqual(json.data?.summary?.mainStatus, 'INBOUNDED', 'unified main status')
|
|
assertTrue(arrayData(json.data?.timeline).some((item) => item.status === 'INBOUNDED'),
|
|
'unified timeline must contain INBOUNDED')
|
|
}, ({ json }) => ({
|
|
orderId: json.data?.summary?.orderId,
|
|
mainStatus: json.data?.summary?.mainStatus,
|
|
timelineCount: arrayData(json.data?.timeline).length,
|
|
}))
|
|
}
|
|
|
|
async function isolationModule() {
|
|
if (!foreignFixture) {
|
|
recordSkipped('phase2-isolation', 'cross-enterprise terminal billing is rejected',
|
|
'No foreign WAIT_SPLIT + APPROVED + CONFIRMED fixture is visible to the platform account')
|
|
return
|
|
}
|
|
await apiStep('phase2-isolation', 'cross-enterprise terminal billing is rejected', {
|
|
method: 'GET',
|
|
path: `/api/merchant/v1/first-leg/orders/${foreignFixture.orderId}/inbound-billing`,
|
|
token: clientToken,
|
|
}, ({ json, status }) => {
|
|
assertEqual(status, 200, 'HTTP status')
|
|
assertTrue(['A0403', 'A0404'].includes(String(json?.code)),
|
|
`expected A0403/A0404, actual=${json?.code}`)
|
|
}, ({ json }) => ({
|
|
orderId: foreignFixture.orderId,
|
|
tenantId: foreignFixture.tenantId,
|
|
rejectionCode: json?.code,
|
|
}))
|
|
}
|
|
|
|
async function apiStep(module, name, request, validate, evidenceBuilder = defaultEvidence) {
|
|
const startedAt = new Date().toISOString()
|
|
const started = Date.now()
|
|
let response
|
|
try {
|
|
response = await httpRequest(request)
|
|
validate(response)
|
|
report.steps.push(makeStep(module, name, true, startedAt, started, response, evidenceBuilder(response)))
|
|
console.log(`PASS [${module}] ${name}`)
|
|
return response
|
|
} catch (error) {
|
|
let evidence = null
|
|
if (response) {
|
|
try { evidence = evidenceBuilder(response) } catch { evidence = defaultEvidence(response) }
|
|
}
|
|
const step = makeStep(module, name, false, startedAt, started, response, evidence)
|
|
step.error = sanitizeError(error)
|
|
report.steps.push(step)
|
|
console.error(`FAIL [${module}] ${name}: ${error.message}`)
|
|
throw error
|
|
}
|
|
}
|
|
|
|
async function softApiStep(module, name, request, validate, evidenceBuilder = defaultEvidence) {
|
|
try { return await apiStep(module, name, request, validate, evidenceBuilder) } catch { return null }
|
|
}
|
|
|
|
async function localStep(module, name, validate, evidence = null) {
|
|
const startedAt = new Date().toISOString()
|
|
const started = Date.now()
|
|
try {
|
|
validate()
|
|
report.steps.push(makeStep(module, name, true, startedAt, started, null, evidence))
|
|
console.log(`PASS [${module}] ${name}`)
|
|
} catch (error) {
|
|
const step = makeStep(module, name, false, startedAt, started, null, evidence)
|
|
step.error = sanitizeError(error)
|
|
report.steps.push(step)
|
|
console.error(`FAIL [${module}] ${name}: ${error.message}`)
|
|
throw error
|
|
}
|
|
}
|
|
|
|
async function httpRequest({ method = 'GET', path, token, headers = {}, body, responseType = 'json' }) {
|
|
const requestHeaders = { Accept: 'application/json', 'X-Request-Id': `client-phase2-${randomUUID()}`, ...headers }
|
|
if (token) requestHeaders.Authorization = `Bearer ${token}`
|
|
let requestBody = body
|
|
if (body != null && !(body instanceof FormData)) {
|
|
requestHeaders['Content-Type'] = 'application/json'
|
|
requestBody = JSON.stringify(body)
|
|
}
|
|
const response = await fetch(`${gateway}${path}`, {
|
|
method, headers: requestHeaders, body: requestBody, signal: AbortSignal.timeout(timeoutMs),
|
|
})
|
|
const result = { status: response.status, headers: response.headers, json: null, bytes: null, text: null }
|
|
if (responseType === 'bytes') {
|
|
result.bytes = new Uint8Array(await response.arrayBuffer())
|
|
return result
|
|
}
|
|
const text = await response.text()
|
|
result.text = text
|
|
if (text) {
|
|
try { result.json = JSON.parse(text) }
|
|
catch { throw new Error(`Expected JSON but received ${text.slice(0, 200)}`) }
|
|
}
|
|
return result
|
|
}
|
|
|
|
function makeStep(module, name, passed, startedAt, started, response, evidence) {
|
|
return {
|
|
module, name, passed, skipped: false, startedAt, durationMs: Date.now() - started,
|
|
http: response?.status ?? null,
|
|
code: response?.json?.code == null ? null : String(response.json.code),
|
|
message: response?.json?.message ?? null,
|
|
requestId: headerOrBody(response, 'x-request-id', 'requestId'),
|
|
traceId: headerOrBody(response, 'x-trace-id', 'traceId'),
|
|
evidence,
|
|
}
|
|
}
|
|
|
|
function recordSkipped(module, name, reason) {
|
|
report.steps.push({
|
|
module, name, passed: true, skipped: true, startedAt: new Date().toISOString(), durationMs: 0,
|
|
http: null, code: null, message: reason, requestId: null, traceId: null, evidence: null,
|
|
})
|
|
console.log(`SKIP [${module}] ${name}: ${reason}`)
|
|
}
|
|
|
|
function requireSuccess(json) {
|
|
assertPresent(json, 'response body')
|
|
assertEqual(String(json.code), '200', 'business code')
|
|
}
|
|
|
|
function isTerminalFixture(row) {
|
|
return row?.processStatus === 'WAIT_SPLIT'
|
|
&& row?.measureReviewStatus === 'APPROVED'
|
|
&& row?.feeStatus === 'CONFIRMED'
|
|
}
|
|
|
|
function assertTerminalFixture(row) {
|
|
assertPresent(row, 'terminal inbound fixture')
|
|
assertEqual(row.processStatus, 'WAIT_SPLIT', 'process status')
|
|
assertEqual(row.measureReviewStatus, 'APPROVED', 'measurement review status')
|
|
assertEqual(row.feeStatus, 'CONFIRMED', 'fee status')
|
|
}
|
|
|
|
function statusCounts(values) {
|
|
const counts = {}
|
|
for (const row of arrayData(values)) {
|
|
const key = `${row.processStatus ?? 'UNKNOWN'}|${row.measureReviewStatus ?? 'NONE'}|${row.feeStatus ?? 'NONE'}`
|
|
counts[key] = (counts[key] ?? 0) + 1
|
|
}
|
|
return counts
|
|
}
|
|
|
|
function assertStringId(value, label) {
|
|
assertPresent(value, label)
|
|
assertEqual(typeof value, 'string', `${label} type`)
|
|
assertTrue(/^\d+$/.test(value), `${label} must contain only digits`)
|
|
}
|
|
|
|
function assertNumberEqual(actual, expected, label) {
|
|
assertEqual(Number(actual), Number(expected), label)
|
|
}
|
|
|
|
function assertMoneyEqual(actual, expected, label) {
|
|
assertEqual(Math.round(Number(actual) * 100), Math.round(Number(expected) * 100), label)
|
|
}
|
|
|
|
function defaultEvidence({ json }) {
|
|
if (!json || json.data == null) return null
|
|
if (typeof json.data !== 'object') return { data: json.data }
|
|
return null
|
|
}
|
|
|
|
function pageRecords(data) {
|
|
if (Array.isArray(data)) return data
|
|
return arrayData(data?.records ?? data?.items ?? data?.content)
|
|
}
|
|
|
|
function arrayData(value) { return Array.isArray(value) ? value : [] }
|
|
|
|
function headerOrBody(response, headerName, bodyName) {
|
|
return response?.headers?.get(headerName)
|
|
?? response?.json?.[bodyName]
|
|
?? response?.json?.data?.[bodyName]
|
|
?? null
|
|
}
|
|
|
|
function assertEqual(actual, expected, label) {
|
|
if (actual !== expected) throw new Error(`${label}: expected=${format(expected)} actual=${format(actual)}`)
|
|
}
|
|
|
|
function assertPresent(value, label) {
|
|
if (value == null || value === '') throw new Error(`${label} is required`)
|
|
}
|
|
|
|
function assertTrue(value, message) {
|
|
if (!value) throw new Error(message)
|
|
}
|
|
|
|
function apiPath(value) {
|
|
const url = new URL(String(value), `${gateway}/`)
|
|
return `${url.pathname}${url.search}`
|
|
}
|
|
|
|
function printSummary() {
|
|
const failed = report.steps.filter((step) => !step.passed)
|
|
const skipped = report.steps.filter((step) => step.skipped)
|
|
console.log(JSON.stringify({
|
|
success: report.success,
|
|
marker,
|
|
passed: report.steps.filter((step) => step.passed && !step.skipped).length,
|
|
failed: failed.length,
|
|
skipped: skipped.length,
|
|
reportPath,
|
|
}, null, 2))
|
|
}
|
|
|
|
function parseArgs(values) {
|
|
const parsed = {}
|
|
for (let index = 0; index < values.length; index += 1) {
|
|
const value = values[index]
|
|
if (!value.startsWith('--')) continue
|
|
const [rawKey, inlineValue] = value.slice(2).split('=', 2)
|
|
parsed[rawKey] = inlineValue ?? values[index + 1]
|
|
if (inlineValue == null) index += 1
|
|
}
|
|
return parsed
|
|
}
|
|
|
|
function compactTimestamp(value) {
|
|
return value.toISOString().replace(/[-:TZ.]/g, '').slice(0, 14)
|
|
}
|
|
|
|
function trimSlash(value) { return String(value).replace(/\/+$/, '') }
|
|
|
|
function format(value) { return typeof value === 'string' ? JSON.stringify(value) : String(value) }
|
|
|
|
function sanitizeError(error) {
|
|
return { name: error?.name ?? 'Error', message: error?.message ?? String(error) }
|
|
}
|
|
|
|
async function promptText(label, defaultValue = '') {
|
|
if (!process.stdin.isTTY || !process.stdout.isTTY) return defaultValue
|
|
const reader = createInterface({ input: process.stdin, output: process.stdout })
|
|
try {
|
|
const suffix = defaultValue ? ` [${defaultValue}]` : ''
|
|
const value = await reader.question(`${label}${suffix}: `)
|
|
return value.trim() || defaultValue
|
|
} finally {
|
|
reader.close()
|
|
}
|
|
}
|
|
|
|
async function promptSecret(label) {
|
|
if (!process.stdin.isTTY || !process.stdout.isTTY) return undefined
|
|
const input = process.stdin
|
|
const output = process.stdout
|
|
output.write(`${label}: `)
|
|
input.setRawMode(true)
|
|
input.resume()
|
|
input.setEncoding('utf8')
|
|
let value = ''
|
|
try {
|
|
for await (const chunk of input) {
|
|
for (const character of chunk) {
|
|
if (character === '\r' || character === '\n') {
|
|
output.write('\n')
|
|
return value
|
|
}
|
|
if (character === '\u0003') throw new Error('Input cancelled')
|
|
if (character === '\u007f' || character === '\b') {
|
|
if (value.length > 0) value = value.slice(0, -1)
|
|
continue
|
|
}
|
|
value += character
|
|
}
|
|
}
|
|
return value
|
|
} finally {
|
|
input.setRawMode(false)
|
|
input.pause()
|
|
}
|
|
}
|