319 lines
21 KiB
JavaScript
319 lines
21 KiB
JavaScript
import assert from 'node:assert/strict'
|
|
import test from 'node:test'
|
|
import { readFileSync } from 'node:fs'
|
|
import { createRequire } from 'node:module'
|
|
import { runInNewContext } from 'node:vm'
|
|
import ts from 'typescript'
|
|
import * as vue from 'vue'
|
|
import { parse, compileScript } from 'vue/compiler-sfc'
|
|
|
|
const { default: Schema } = createRequire(import.meta.resolve('element-plus'))('async-validator')
|
|
|
|
let nextKey = 0
|
|
const crypto = { randomUUID: () => `test-key-${++nextKey}` }
|
|
function moduleFrom(source, require = () => { throw new Error('unexpected import') }) {
|
|
const context = { exports: {}, require, URL, Error, crypto }
|
|
const code = ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS } }).outputText
|
|
runInNewContext(code, context)
|
|
return context.exports
|
|
}
|
|
const presentation = moduleFrom(readFileSync(new URL('./procurementPresentation.ts', import.meta.url), 'utf8'))
|
|
const submission = moduleFrom(readFileSync(new URL('./procurementSubmission.ts', import.meta.url), 'utf8'), name => {
|
|
if (name === './procurementPresentation') return presentation
|
|
throw new Error(`unexpected import ${name}`)
|
|
})
|
|
const normalized = value => JSON.parse(JSON.stringify(value))
|
|
const draft = () => ({ ...presentation.emptyProcurementDraft(), purchaseCategory: 'Sample', productName: 'Test product', productSpecification: 'A',
|
|
productUrl: 'https://example.com/product', purchaseQuantity: '3', budgetUnitPrice: '0.29', receivingAddress: '测试省测试市测试街 1 号', contactName: '测试收件人', contactPhone: '13800000000' })
|
|
const fee = (purpose, walletStatus, amount) => ({ purpose, walletStatus, amount, currency: 'CNY' })
|
|
|
|
test('budget distinguishes unknown from zero, preserves cents, and requires a real telephone/address', () => {
|
|
assert.equal(presentation.draftBudgetTotal(draft()), '0.87')
|
|
const valid = presentation.buildProcurementCreate(draft(), 'Authenticated Company', 'same-key')
|
|
assert.equal(valid.customerName, 'Authenticated Company')
|
|
assert.equal(valid.budgetUnitPrice, 0.29)
|
|
for (const value of ['', '-1', '1.001', '90071992547409.91']) assert.throws(() => presentation.buildProcurementCreate({ ...draft(), budgetUnitPrice: value }, 'Company', 'key'), /预算/)
|
|
assert.equal(presentation.buildProcurementCreate({ ...draft(), budgetUnitPrice: '0' }, 'Company', 'key').budgetUnitPrice, 0)
|
|
for (const patch of [{ contactPhone: 'wechat-name' }, { contactPhone: 'a@test.invalid' }, { receivingAddress: '' }, { purchaseQuantity: '1.5' }]) {
|
|
assert.throws(() => presentation.buildProcurementCreate({ ...draft(), ...patch }, 'Company', 'key'))
|
|
}
|
|
assert.equal(presentation.measurement(20, 2), '20.00')
|
|
assert.equal(presentation.measurement('5.125', 3), '5.125')
|
|
assert.equal(presentation.measurement('1.234', 2), '待核对')
|
|
assert.equal(presentation.money(null), '—')
|
|
assert.equal(presentation.money(0), 'CNY 0.00')
|
|
assert.equal(presentation.productHref('javascript:alert(1)'), undefined)
|
|
assert.equal(presentation.productHref('https://example.com/item'), 'https://example.com/item')
|
|
})
|
|
|
|
test('successful net debit excludes the original estimate and counts only successful refunds and differences', () => {
|
|
const result = presentation.feeTotals([fee('INTERNATIONAL_ESTIMATE', 'SETTLED', '100'), fee('INTERNATIONAL_FREIGHT', 'SETTLED', '100'),
|
|
fee('ADJUSTMENT', 'SETTLED', '20'), fee('ADJUSTMENT', 'SETTLED', '10'), fee('REFUND', 'REFUNDED', '20'), fee('REFUND', 'REFUND_PENDING', '5')])
|
|
assert.deepEqual(normalized(result), { paid: '130.00', refunded: '20.00', net: '110.00', estimatedHold: '0.00' })
|
|
assert.equal(presentation.feeTotals([fee('INTERNATIONAL_ESTIMATE', 'RELEASE_PENDING', '100')]).estimatedHold, '100.00')
|
|
assert.equal(presentation.feeTotals([fee('DUTY', 'SETTLED', 'unknown')]), null)
|
|
assert.equal(presentation.feeStatus(fee('INTERNATIONAL_ESTIMATE', 'FROZEN', 100)), '已冻结，未扣款')
|
|
assert.equal(presentation.feeStatus(fee('INTERNATIONAL_ESTIMATE', 'SETTLED', 100)), '原预估已结清')
|
|
assert.equal(presentation.feeStatus(fee('DUTY', null, 100)), '待核定')
|
|
})
|
|
|
|
test('new requests get unique keys without restoring stored submissions', () => {
|
|
assert.notEqual(submission.procurementRequestKey(crypto), submission.procurementRequestKey(crypto))
|
|
})
|
|
|
|
class ApiError extends Error { constructor(message, code, status) { super(message); this.code = code; this.status = status } }
|
|
const flush = async () => { await vue.nextTick(); await new Promise(resolve => setImmediate(resolve)); await vue.nextTick() }
|
|
function viewHarness({ createPage = false, detailPage = false, api = {}, storage = new Map() } = {}) {
|
|
const props = vue.reactive({ createPage, detailPage })
|
|
const route = vue.reactive({ params: { orderNo: detailPage ? 'PO-1' : '' } })
|
|
const auth = vue.reactive({ token: 'identity-A', user: { tenantName: 'Company' }, profile: { tenantName: 'Company' }, hasPermission: () => true })
|
|
const pushes = [], dispose = []
|
|
const defaults = { getProcurementWorkflow: async orderNo => ({ orderNo, version: 1, status: 'WAIT_CUSTOMER_CONFIRM', receipts: [], outbounds: [] }), confirmProcurement: async () => ({ orderNo: 'PO-1', version: 2, status: 'CONFIRMED' }), listProcurements: async () => ({ records: [], total: 0 }), getProcurement: async orderNo => ({ order: { orderNo } }), createProcurement: async () => ({ order: { orderNo: 'PO-CREATED' } }) }
|
|
const { descriptor } = parse(readFileSync(new URL('./views/ProcurementView.vue', import.meta.url), 'utf8'))
|
|
const source = compileScript(descriptor, { id: 'procurement-test' }).content
|
|
const context = { exports: {}, Error, crypto, sessionStorage: { getItem: key => storage.get(key) || null, setItem: (key, value) => storage.set(key, value), removeItem: key => storage.delete(key) },
|
|
require(name) {
|
|
if (name === 'vue') return { ...vue, onBeforeUnmount: callback => dispose.push(callback), watch: (...args) => { const stop = vue.watch(...args); dispose.push(stop); return stop } }
|
|
if (name === 'vue-router') return { useRoute: () => route, useRouter: () => ({ push: async target => pushes.push(target) }) }
|
|
if (name === 'element-plus') return { ElMessage: { success: () => {} }, ElMessageBox: { confirm: async () => {}, prompt: async (...args) => { const value = api.rejectionReason ?? '照片不清晰'; const valid = args[2].inputValidator(value); if (valid !== true) throw new Error(valid); return { value } } } }
|
|
if (name === '@/api/types') return { ApiError }
|
|
if (name === '@/api/session') return { accessTokenIdentity: token => token }
|
|
if (name === '@/modules/auth/public') return { useAuthStore: () => auth }
|
|
if (name === '../api/orderBudgets') return { requireOrderBudget: api.requireOrderBudget || (async () => {}) }
|
|
if (name === '../api/procurement') return { ...defaults, ...api }
|
|
if (name === '../procurementPresentation') return presentation
|
|
if (name === '../procurementSubmission') return submission
|
|
if (name.endsWith('.vue')) return { default: {} }
|
|
throw new Error(`unexpected view import ${name}`)
|
|
},
|
|
}
|
|
runInNewContext(ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS } }).outputText, context)
|
|
const state = context.exports.default.setup(props, { expose: () => {} })
|
|
state.formRef.value = {
|
|
validate: async () => { await new Schema(state.formRules).validate(state.form); return true },
|
|
clearValidate: () => {},
|
|
}
|
|
return { state, props, route, auth, pushes, storage, dispose: () => dispose.forEach(callback => callback()) }
|
|
}
|
|
|
|
test('procurement required fields validate individually and blank submissions never call the API', async () => {
|
|
const calls = []
|
|
const harness = viewHarness({ createPage: true, api: { createProcurement: async payload => { calls.push(payload); return { order: { orderNo: 'PO-VALID' } } } } })
|
|
try {
|
|
const fields = ['procurementDirection', 'productName', 'productUrl', 'purchaseQuantity', 'budgetUnitPrice', 'currency', 'contactName', 'contactPhone', 'receivingAddress']
|
|
const source = readFileSync(new URL('./views/ProcurementView.vue', import.meta.url), 'utf8')
|
|
for (const field of fields) {
|
|
assert.match(source, new RegExp(`<el-form-item[^>]*prop="${field}"`))
|
|
const schema = new Schema({ [field]: harness.state.formRules[field] })
|
|
await assert.rejects(schema.validate({ [field]: '' }), error => Boolean(error.fields[field]))
|
|
}
|
|
await assert.rejects(new Schema(harness.state.formRules).validate({ ...draft(), productName: ' ' }))
|
|
await harness.state.submit()
|
|
assert.equal(calls.length, 0)
|
|
assert.equal(harness.state.submitting.value, false)
|
|
assert.equal(harness.state.submitError.value, '')
|
|
Object.assign(harness.state.form, draft(), { budgetUnitPrice: '0' })
|
|
await harness.state.submit()
|
|
assert.equal(calls.length, 1)
|
|
assert.equal(calls[0].budgetUnitPrice, 0)
|
|
assert.deepEqual(normalized(harness.pushes), [{ name: 'cross-border-procurement' }])
|
|
} finally { harness.dispose() }
|
|
})
|
|
|
|
test('create summary follows the current form, preserves cents and clears with the draft', () => {
|
|
const harness = viewHarness({ createPage: true })
|
|
try {
|
|
assert.equal(harness.state.summaryQuantity.value, '1')
|
|
assert.equal(harness.state.summaryUnitPrice.value, '—')
|
|
assert.equal(harness.state.budgetTotal.value, null)
|
|
assert.equal(harness.state.summaryCurrencyName.value, '美元')
|
|
Object.assign(harness.state.form, draft())
|
|
assert.equal(harness.state.summaryQuantity.value, '3')
|
|
assert.equal(harness.state.summaryUnitPrice.value, '0.29')
|
|
assert.equal(harness.state.budgetTotal.value, '0.87')
|
|
harness.state.form.currency = 'CNY'
|
|
assert.equal(harness.state.summaryCurrencyName.value, '人民币')
|
|
assert.equal(presentation.money(harness.state.budgetTotal.value, harness.state.form.currency), 'CNY 0.87')
|
|
harness.state.form.budgetUnitPrice = '0'
|
|
assert.equal(harness.state.summaryUnitPrice.value, '0.00')
|
|
assert.equal(harness.state.budgetTotal.value, '0.00')
|
|
harness.state.resetForm()
|
|
assert.equal(harness.state.summaryQuantity.value, '1')
|
|
assert.equal(harness.state.summaryUnitPrice.value, '—')
|
|
assert.equal(harness.state.budgetTotal.value, null)
|
|
assert.equal(harness.state.summaryCurrencyName.value, '美元')
|
|
} finally { harness.dispose() }
|
|
})
|
|
|
|
test('create summary never retains a stale budget when quantity or price becomes invalid', () => {
|
|
const harness = viewHarness({ createPage: true })
|
|
try {
|
|
Object.assign(harness.state.form, draft())
|
|
for (const quantity of ['', '0', '-1', '1.5', '9007199254740992']) {
|
|
harness.state.form.purchaseQuantity = quantity
|
|
assert.equal(harness.state.summaryQuantity.value, '—')
|
|
assert.equal(harness.state.budgetTotal.value, null)
|
|
assert.equal(harness.state.form.purchaseQuantity, quantity)
|
|
}
|
|
harness.state.form.purchaseQuantity = '3'
|
|
assert.equal(harness.state.budgetTotal.value, '0.87')
|
|
for (const price of ['', '-1', '1.001', 'invalid']) {
|
|
harness.state.form.budgetUnitPrice = price
|
|
assert.equal(harness.state.summaryUnitPrice.value, '—')
|
|
assert.equal(harness.state.budgetTotal.value, null)
|
|
assert.equal(harness.state.form.budgetUnitPrice, price)
|
|
}
|
|
harness.state.form.budgetUnitPrice = '0.29'
|
|
assert.equal(harness.state.budgetTotal.value, '0.87')
|
|
} finally { harness.dispose() }
|
|
})
|
|
|
|
test('detail has one in-flight request and an older response cannot overwrite another order', async () => {
|
|
const calls = [], pending = new Map()
|
|
const harness = viewHarness({ detailPage: true, api: { getProcurement: orderNo => { calls.push(orderNo); return new Promise(resolve => pending.set(orderNo, resolve)) } } })
|
|
try {
|
|
assert.deepEqual(calls, ['PO-1'])
|
|
await harness.state.loadDetail(); assert.equal(calls.length, 1)
|
|
harness.route.params.orderNo = 'PO-2'; await flush(); assert.deepEqual(calls, ['PO-1', 'PO-2'])
|
|
pending.get('PO-1')({ order: { orderNo: 'PO-1' } }); await flush(); assert.equal(harness.state.detail.value, null)
|
|
pending.get('PO-2')({ order: { orderNo: 'PO-2' } }); await flush(); assert.equal(harness.state.detail.value.order.orderNo, 'PO-2')
|
|
assert.equal(harness.state.loading.value, false)
|
|
} finally { harness.dispose() }
|
|
})
|
|
|
|
test('timeout releases the form and another click submits the edited current values', async () => {
|
|
const calls = []
|
|
const harness = viewHarness({ createPage: true, api: { createProcurement: async payload => { calls.push(normalized(payload)); throw new ApiError('timeout', 'TIMEOUT') } } })
|
|
try {
|
|
Object.assign(harness.state.form, draft()); await harness.state.submit()
|
|
assert.equal(harness.state.submitting.value, false); assert.equal(harness.storage.size, 0)
|
|
harness.state.form.productName = 'changed'; await harness.state.submit()
|
|
assert.equal(calls[1].productName, 'changed'); assert.notEqual(calls[0].idempotencyKey, calls[1].idempotencyKey)
|
|
assert.equal(harness.state.submitting.value, false)
|
|
} finally { harness.dispose() }
|
|
})
|
|
|
|
test('submission double-click sends once and definitive validation rejection permits correction', async () => {
|
|
let reject, calls = 0
|
|
const harness = viewHarness({ createPage: true, api: { createProcurement: () => { calls++; return new Promise((_, failure) => { reject = failure }) } } })
|
|
try {
|
|
Object.assign(harness.state.form, draft()); const first = harness.state.submit(); await harness.state.submit(); await flush(); assert.equal(calls, 1)
|
|
reject(new ApiError('invalid', 'A0422')); await first
|
|
assert.equal(harness.state.submitting.value, false); assert.equal(harness.storage.size, 0)
|
|
} finally { harness.dispose() }
|
|
})
|
|
|
|
test('pagination batches one request and switching account clears old rows before the new response', async () => {
|
|
const calls = []; let resolveSecond
|
|
const harness = viewHarness({ api: { listProcurements: async params => {
|
|
calls.push(normalized(params)); if (calls.length < 3) return { records: [{ orderNo: 'PO-A' }], total: 100 }
|
|
return new Promise(resolve => { resolveSecond = resolve })
|
|
} } })
|
|
try {
|
|
await flush(); assert.equal(calls.length, 1)
|
|
harness.state.query.page = 2; harness.state.query.size = 50; await flush(); assert.equal(calls.length, 2)
|
|
harness.auth.token = 'identity-B'; await vue.nextTick(); assert.equal(harness.state.rows.value.length, 0); assert.equal(harness.state.total.value, 0)
|
|
resolveSecond({ records: [{ orderNo: 'PO-B' }], total: 1 }); await flush(); assert.equal(harness.state.rows.value[0].orderNo, 'PO-B')
|
|
assert.ok(calls.every(params => !('customerId' in params) && !('tenantId' in params)))
|
|
} finally { harness.dispose() }
|
|
})
|
|
|
|
|
|
test('consecutive timeout and permission failures never persist or freeze a submission', async () => {
|
|
let attempt = 0
|
|
const harness = viewHarness({ createPage: true, api: { createProcurement: async () => { throw new ApiError('failed', ++attempt === 1 ? 'TIMEOUT' : 'A0403') } } })
|
|
try {
|
|
Object.assign(harness.state.form, draft()); await harness.state.submit(); await harness.state.submit()
|
|
assert.equal(attempt, 2); assert.equal(harness.state.submitting.value, false); assert.equal(harness.storage.size, 0)
|
|
harness.state.form.productName = 'editable'; assert.equal(harness.state.form.productName, 'editable')
|
|
} finally { harness.dispose() }
|
|
})
|
|
|
|
test('purchase category is optional while its length remains bounded', () => {
|
|
const payload = presentation.buildProcurementCreate({ ...draft(), purchaseCategory: ' ' }, 'Company', 'key')
|
|
assert.equal(payload.purchaseCategory, '')
|
|
assert.throws(() => presentation.buildProcurementCreate({ ...draft(), purchaseCategory: 'x'.repeat(129) }, 'Company', 'key'), /品类/)
|
|
})
|
|
|
|
|
|
test('domestic purchase creates an export order and displays the actual origin and destination regions', () => {
|
|
const payload = presentation.buildProcurementCreate({ ...draft(), procurementDirection: 'DOMESTIC_TO_OVERSEAS', receivingAddress: 'US, CA, Los Angeles, test destination' }, 'Authenticated Company', 'export-key')
|
|
assert.equal(payload.procurementDirection, 'DOMESTIC_TO_OVERSEAS')
|
|
assert.equal(payload.receivingAddress, 'US, CA, Los Angeles, test destination')
|
|
assert.equal(presentation.statusLabel('RECEIVING', payload.procurementDirection), '收货中')
|
|
assert.equal(presentation.statusLabel('DELIVERING', payload.procurementDirection), '派送中')
|
|
assert.equal(presentation.statusLabel('WAIT_CUSTOMER_CONFIRM', payload.procurementDirection), '待客户确认')
|
|
assert.equal(presentation.statusLabel('COMPLETED'), '签收完成')
|
|
assert.throws(() => presentation.buildProcurementCreate({ ...draft(), procurementDirection: 'INVALID' }, 'Company', 'key'), /采购方向/)
|
|
const source = readFileSync(new URL('./views/ProcurementView.vue', import.meta.url), 'utf8')
|
|
assert.match(source, /v-model="form.procurementDirection"/)
|
|
assert.match(source, /regionText\('最终国内收件资料', form.procurementDirection\)/)
|
|
})
|
|
|
|
|
|
test('unchanged create retries reuse the idempotency key', async () => {
|
|
const calls = []
|
|
const harness = viewHarness({ createPage: true, api: { createProcurement: async payload => { calls.push(payload); throw new ApiError('timeout', 'TIMEOUT') } } })
|
|
try {
|
|
Object.assign(harness.state.form, draft()); await harness.state.submit(); await harness.state.submit()
|
|
assert.equal(calls[0].idempotencyKey, calls[1].idempotencyKey)
|
|
assert.equal(harness.pushes.length, 0)
|
|
} finally { harness.dispose() }
|
|
})
|
|
|
|
test('bill-settled manual fees show review results without counting a balance debit', () => {
|
|
const bill = determination => ({ ...fee('OTHER', 'NOT_REQUIRED', '100'), determination })
|
|
assert.equal(presentation.feeStatus(bill('PENDING')), '账单结算 · 待审核')
|
|
assert.equal(presentation.feeStatus(bill('APPROVED')), '账单结算 · 已确认')
|
|
assert.equal(presentation.feeStatus(bill('REJECTED')), '账单结算 · 已拒绝')
|
|
assert.equal(presentation.feeTone(bill('REJECTED')), 'danger')
|
|
assert.equal(presentation.feeTotals([bill('PENDING'), bill('APPROVED'), bill('REJECTED')]).paid, '0.00')
|
|
})
|
|
|
|
|
|
test('procurement creates immediately while funding is asynchronous and exposes funding states', async () => {
|
|
let creates = 0
|
|
const harness = viewHarness({ createPage: true, api: { createProcurement: async () => { creates++; return { order: { orderNo: 'CG-PENDING', status: 'FUNDING_PENDING' } } } } })
|
|
try {
|
|
Object.assign(harness.state.form, draft()); await harness.state.submit()
|
|
assert.equal(creates, 1); assert.equal(harness.state.submitError.value, '')
|
|
assert.equal(harness.state.submittedOrder.value, 'CG-PENDING')
|
|
assert.equal(presentation.statusLabel('FUNDING_PENDING'), '订单受理中')
|
|
assert.equal(presentation.statusLabel('FUNDING_FAILED'), '订单处理失败')
|
|
} finally { harness.dispose() }
|
|
})
|
|
|
|
test('confirmation and rejection are list actions only while waiting for customer confirmation', async () => {
|
|
let status = 'WAIT_CUSTOMER_CONFIRM'
|
|
const harness = viewHarness({ api: { listProcurements: async () => ({ records: [{ orderNo: 'PO-1', status, purchaseQuantity: 10 }], total: 1 }) } })
|
|
try {
|
|
await flush()
|
|
const actions = harness.state.rowActions(harness.state.rows.value[0])
|
|
assert.deepEqual(normalized(actions.map(action => action.key)), ['detail', 'reject', 'confirm'])
|
|
actions[1].run(); assert.equal(harness.state.decision.value, 'reject')
|
|
assert.equal(harness.state.decisionTarget.value.orderNo, 'PO-1')
|
|
status = 'CONFIRMED'; harness.state.decisionChanged(); await flush()
|
|
assert.equal(harness.state.decisionTarget.value, null)
|
|
assert.deepEqual(normalized(harness.state.rowActions(harness.state.rows.value[0]).map(action => action.key)), ['detail'])
|
|
harness.auth.hasPermission = () => false
|
|
assert.equal(harness.state.rowActions({ orderNo: 'PO-1', status: 'WAIT_CUSTOMER_CONFIRM' }).length, 1)
|
|
const source = readFileSync(new URL('./views/ProcurementView.vue', import.meta.url), 'utf8')
|
|
const detailHeader = source.slice(source.indexOf('<header class="procurement-heading">'), source.indexOf('</header>', source.indexOf('<header class="procurement-heading">')))
|
|
assert.doesNotMatch(detailHeader, /确认采购结果|驳回/)
|
|
} finally { harness.dispose() }
|
|
})
|
|
|
|
test('product links must be nonblank and use HTTP or HTTPS before budget reservation', async () => {
|
|
for (const productUrl of ['', ' ', 'javascript:alert(1)', 'invalid', 'https://' ]) {
|
|
assert.throws(() => presentation.buildProcurementCreate({ ...draft(), productUrl }, 'Company', 'key'), /商品链接/)
|
|
}
|
|
let budgets = 0, creates = 0
|
|
const harness = viewHarness({ createPage: true, api: { requireOrderBudget: async () => { budgets++ }, createProcurement: async () => { creates++ } } })
|
|
try {
|
|
for (const productUrl of ['', ' ']) {
|
|
Object.assign(harness.state.form, draft(), { productUrl }); await harness.state.submit()
|
|
}
|
|
assert.equal(budgets, 0); assert.equal(creates, 0); assert.equal(harness.pushes.length, 0)
|
|
} finally { harness.dispose() }
|
|
})
|