222 lines
12 KiB
JavaScript
222 lines
12 KiB
JavaScript
import assert from 'node:assert/strict'
|
|
import test from 'node:test'
|
|
import { readFileSync } from 'node:fs'
|
|
import ts from 'typescript'
|
|
import * as vue from 'vue'
|
|
import * as pinia from 'pinia'
|
|
|
|
function compile(path, dependencies) {
|
|
const source = readFileSync(new URL(path, import.meta.url), 'utf8')
|
|
const code = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
|
|
const exports = {}
|
|
new Function('require', 'exports', code)(id => { assert.ok(id in dependencies, id); return dependencies[id] }, exports)
|
|
return exports
|
|
}
|
|
function harness(t) {
|
|
const context = pinia.createPinia(); pinia.setActivePinia(context)
|
|
t.after(() => pinia.disposePinia(context))
|
|
const calls = []
|
|
const behavior = { failWrite: false, failRead: false, version: 9, status: 'DRAFT' }
|
|
const api = compile('../api/firstLeg.ts', { '@/api/http': { apiRequest: async config => {
|
|
calls.push(structuredClone(config))
|
|
if (config.method === 'GET') {
|
|
if (behavior.failRead) throw new Error('读取失败')
|
|
return { order: { id: 'one', orderNo: 'FL-ONE', version: behavior.version, status: behavior.status, receivingWarehouseId: 'warehouse', destinationCountryCode: 'US' }, cargoes: [] }
|
|
}
|
|
if (behavior.failWrite) throw new Error('响应丢失')
|
|
} } })
|
|
const module = compile('./firstLegOrders.ts', {
|
|
vue, pinia,
|
|
'@/modules/first-leg/api/firstLeg': api,
|
|
'@/modules/first-leg/api/unifiedOrders': {
|
|
getMerchantUnifiedOrder: async () => ({ summary: { orderId: 'one', mainStatus: null }, order: { order: { id: 'one', status: behavior.status, version: behavior.version, receivingWarehouseId: 'warehouse' } }, timeline: [] }),
|
|
isUnifiedOrderQueryUnavailable: () => false,
|
|
},
|
|
'@/modules/first-leg/utils/firstLegOrder': { canClientEditFirstLegOrder: status => status === 'DRAFT', getFirstLegStatusLabel: value => value },
|
|
'@/modules/first-leg/utils/warehousePagination': {},
|
|
})
|
|
const store = module.useFirstLegOrdersStore()
|
|
store.warehouses = [{ id: 'warehouse', name: '国内仓', warehouseType: 'DOMESTIC' }]
|
|
const draft = { receivingWarehouseId: 'warehouse', destinationType: 'PRIVATE', destinationCountryCode: 'US', items: [], customerRemark: '原草稿' }
|
|
return { store, api, calls, behavior, draft }
|
|
}
|
|
|
|
test('raw and unified cancelled detail remain CANCELLED even when unified mainStatus is null', async t => {
|
|
const h = harness(t)
|
|
h.behavior.status = 'CANCELLED'
|
|
const raw = await h.store.loadDraftDetail('one')
|
|
assert.equal(raw.status, 'CANCELLED')
|
|
const unified = await h.store.loadDetail('one')
|
|
assert.equal(unified.status, 'CANCELLED')
|
|
h.behavior.status = 'APPROVED'
|
|
const unknown = await h.store.loadDetail('one')
|
|
assert.notEqual(unknown.status, 'CANCELLED', 'unknown summary must not be reclassified as cancellation')
|
|
})
|
|
|
|
test('cancelled detail summary has no pending overseas synchronization entries', () => {
|
|
const source = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8')
|
|
const script = source.match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
|
|
const ast = ts.createSourceFile('view.ts', script, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
|
|
const declaration = ast.statements.flatMap(node => ts.isVariableStatement(node) ? [...node.declarationList.declarations] : []).find(node => node.name.getText(ast) === 'progressSummaryItems')
|
|
const code = ts.transpileModule('const progressSummaryItems = ' + declaration.initializer.getText(ast), { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
|
|
const summary = new Function('computed', 'detailOrder', code + '; return progressSummaryItems.value')(vue.computed, { value: { status: 'CANCELLED' } })
|
|
assert.deepEqual(summary, [])
|
|
})
|
|
|
|
test('edit freezes detail version rather than cached list version and replays same key/body after uncertain result', async t => {
|
|
const h = harness(t)
|
|
const original = await h.store.loadDraftDetail('one')
|
|
const session = h.store.beginDraftEdit(original)
|
|
h.store.orders[0].version = 0
|
|
h.behavior.failWrite = true
|
|
await assert.rejects(h.store.saveDraft(h.draft, '测试企业', 'one', session), /响应丢失/)
|
|
const first = h.calls.find(call => call.method === 'PUT')
|
|
assert.equal(first.data.expectedVersion, 9)
|
|
assert.equal(first.data.draft.customerRemark, '原草稿')
|
|
assert.ok(first.headers['Idempotency-Key'])
|
|
assert.deepEqual(h.calls.map(call => call.method), ['GET', 'PUT'], 'no pre-save version refresh')
|
|
h.behavior.failWrite = false; h.behavior.version = 10
|
|
const result = await h.store.saveDraft(h.draft, '测试企业', 'one', session)
|
|
const writes = h.calls.filter(call => call.method === 'PUT')
|
|
assert.deepEqual(writes[1], first)
|
|
assert.deepEqual(h.calls.map(call => call.method), ['GET', 'PUT', 'GET', 'PUT', 'GET'])
|
|
assert.equal(result.version, 10)
|
|
})
|
|
|
|
test('changed retry payload or missing edit session fails closed without issuing a new write', async t => {
|
|
const h = harness(t)
|
|
await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one'), /重新打开/)
|
|
assert.equal(h.calls.length, 0)
|
|
const session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
|
|
h.behavior.failWrite = true
|
|
await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session))
|
|
h.draft.customerRemark = '不同内容'
|
|
await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session), /重试原内容/)
|
|
assert.equal(h.calls.filter(call => call.method === 'PUT').length, 1)
|
|
assert.equal(session.expectedVersion, 9)
|
|
assert.ok(Object.isFrozen(session))
|
|
})
|
|
|
|
test('read failure after successful edit preserves the same command for retry', async t => {
|
|
const h = harness(t)
|
|
const session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
|
|
h.behavior.failRead = true
|
|
await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session), /读取失败/)
|
|
h.behavior.failRead = false
|
|
await h.store.saveDraft(h.draft, '客户', 'one', session)
|
|
const writes = h.calls.filter(call => call.method === 'PUT')
|
|
assert.deepEqual(writes[0], writes[1])
|
|
})
|
|
|
|
test('cancel forwards version and reason without rejecting submitted orders locally; retry keeps key and body', async t => {
|
|
const h = harness(t)
|
|
h.behavior.status = 'SUBMITTED'
|
|
h.store.orders = [{ id: 'one', status: 'PENDING_REVIEW', version: 0 }]
|
|
h.behavior.failWrite = true
|
|
await assert.rejects(h.store.cancelOrder('one', 12, '客户要求取消'), /响应丢失/)
|
|
const first = h.calls[0]
|
|
assert.equal(first.method, 'POST')
|
|
assert.equal(first.url, '/merchant/v1/orders/first-leg/one/cancel')
|
|
assert.deepEqual(first.data, { expectedVersion: 12, reason: '客户要求取消' })
|
|
await assert.rejects(h.store.cancelOrder('one', 13, '其他原因'), /原版本和原因/)
|
|
assert.equal(h.calls.length, 1)
|
|
h.behavior.failWrite = false
|
|
await h.store.cancelOrder('one', 12, '客户要求取消')
|
|
assert.deepEqual(h.calls[2], first)
|
|
assert.equal(h.calls[1].method, 'GET')
|
|
assert.equal(h.store.orders.length, 0)
|
|
})
|
|
|
|
test('cancel requires a detail version and a nonempty reason', async t => {
|
|
const h = harness(t)
|
|
await assert.rejects(h.store.cancelOrder('one', undefined, '理由'))
|
|
await assert.rejects(h.store.cancelOrder('one', 1, ' '))
|
|
assert.equal(h.calls.length, 0)
|
|
})
|
|
|
|
test('cancellation decision reads raw server status and version including SUBMITTED', async t => {
|
|
const h = harness(t)
|
|
for (const status of ['DRAFT', 'SUBMITTED', 'APPROVED', 'ACCEPTED', 'REJECTED']) {
|
|
h.behavior.status = status
|
|
const target = await h.store.prepareCancellation('one')
|
|
assert.equal(target.expectedVersion, 9)
|
|
assert.equal(target.businessNo, 'FL-ONE')
|
|
}
|
|
for (const status of ['PROCESSING', 'COMPLETED', 'CANCELLED']) {
|
|
h.behavior.status = status
|
|
await assert.rejects(h.store.prepareCancellation('one'), /不允许取消/)
|
|
}
|
|
assert.ok(h.calls.every(call => call.method === 'GET'))
|
|
})
|
|
|
|
function cancellationViewHarness() {
|
|
const source = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8').match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
|
|
const ast = ts.createSourceFile('view.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
|
|
const functions = ast.statements.filter(node => ts.isFunctionDeclaration(node) && ['canOfferCancellation', 'cancelOrder'].includes(node.name?.text)).map(node => node.getText(ast)).join('\n')
|
|
const code = ts.transpileModule(functions, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
|
|
const calls = [], messages = [], prompts = []
|
|
const canCancelOrder = vue.ref(true), cancellingOrderId = vue.ref(''), pendingCancellation = vue.shallowRef()
|
|
class ApiError extends Error { constructor() { super('订单版本已变化'); this.code = 'A0409'; this.status = 409 } }
|
|
const behavior = { error: null }
|
|
const store = {
|
|
prepareCancellation: async id => { calls.push(['prepare', id]); return { id, expectedVersion: 12, businessNo: 'FL-ONE', statusLabel: '审核中' } },
|
|
cancelOrder: async (...args) => { calls.push(['cancel', ...args]); if (behavior.error) throw behavior.error },
|
|
load: async query => calls.push(['load', query]),
|
|
}
|
|
const ElMessageBox = {
|
|
prompt: async (message, title, options) => { prompts.push({ message, title, options }); return { value: '客户申请取消' } },
|
|
confirm: async (...args) => calls.push(['confirm', ...args]),
|
|
}
|
|
const ElMessage = { error: message => messages.push(message), warning: message => messages.push(message), success: message => messages.push(message) }
|
|
const globals = { canCancelOrder, cancellingOrderId, pendingCancellation, store, ElMessageBox, ElMessage, ApiError,
|
|
isDetailPage: vue.ref(true), router: { push: async route => calls.push(['route', route]) } }
|
|
const handler = new Function(...Object.keys(globals), code + '\nreturn cancelOrder')(...Object.values(globals))
|
|
return { handler, calls, messages, prompts, canCancelOrder, pendingCancellation, behavior, ApiError }
|
|
}
|
|
|
|
test('cancel UI uses mandatory-reason centered prompt and refreshes after successful submitted-order cancellation', async () => {
|
|
const h = cancellationViewHarness()
|
|
await h.handler({ id: 'one', status: 'PENDING_REVIEW' })
|
|
assert.match(h.prompts[0].message, /FL-ONE.*审核中/)
|
|
const validate = h.prompts[0].options.inputValidator
|
|
assert.notEqual(validate(' '), true)
|
|
assert.notEqual(validate('x'.repeat(501)), true)
|
|
assert.equal(validate('合理原因'), true)
|
|
assert.deepEqual(h.calls.map(call => call[0]), ['prepare', 'cancel', 'load', 'route'])
|
|
assert.deepEqual(h.calls[1], ['cancel', 'one', 12, '客户申请取消'])
|
|
})
|
|
|
|
test('cancel UI keeps an uncertain command for explicit retry, but conflict requires a fresh decision', async () => {
|
|
const h = cancellationViewHarness()
|
|
const order = { id: 'one', status: 'DRAFT' }
|
|
h.behavior.error = new Error('网络无响应')
|
|
await h.handler(order)
|
|
assert.equal(h.pendingCancellation.value.expectedVersion, 12)
|
|
h.behavior.error = null
|
|
await h.handler(order)
|
|
assert.equal(h.prompts.length, 1)
|
|
assert.equal(h.calls.filter(call => call[0] === 'prepare').length, 1)
|
|
assert.equal(h.calls.filter(call => call[0] === 'confirm').length, 1)
|
|
assert.deepEqual(h.calls.filter(call => call[0] === 'cancel')[0], h.calls.filter(call => call[0] === 'cancel')[1])
|
|
h.behavior.error = new h.ApiError()
|
|
await h.handler(order)
|
|
assert.equal(h.pendingCancellation.value, undefined)
|
|
assert.match(h.messages.at(-1), /刷新订单后重新确认/)
|
|
})
|
|
|
|
test('cancel UI blocks unavailable permission and irreversible visible stages before reads or writes', async () => {
|
|
const h = cancellationViewHarness()
|
|
h.canCancelOrder.value = false
|
|
await h.handler({ id: 'one', status: 'DRAFT' })
|
|
h.canCancelOrder.value = true
|
|
await h.handler({ id: 'one', status: 'LOADED' })
|
|
assert.equal(h.calls.length, 0)
|
|
assert.equal(h.prompts.length, 0)
|
|
})
|
|
|
|
test('both editor entry points capture detail sessions and both save paths pass them', () => {
|
|
const view = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8')
|
|
assert.equal((view.match(/editingSession\.value = store\.beginDraftEdit\(detailedOrder\)/g) ?? []).length, 2)
|
|
assert.equal((view.match(/store\.saveDraft\(cloneDraft\(form\), tenantStore\.company\.companyName, editingId\.value, editingSession\.value\)/g) ?? []).length, 2)
|
|
})
|