334 lines
21 KiB
JavaScript
334 lines
21 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'
|
|
import { requireOrderProgress } from '../utils/orderProgress.ts'
|
|
|
|
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', receivingWarehouseAddress: behavior.receivingWarehouseAddress, destinationCountryCode: 'US' }, cargoes: [] }
|
|
}
|
|
if (behavior.failWrite || (behavior.failSubmit && config.url.endsWith('/submit'))) throw new Error('响应丢失')
|
|
if (config.url.endsWith('/submit') && behavior.failSubmitRead) behavior.failRead = true
|
|
if (config.method === 'POST' && config.url === '/merchant/v1/orders/first-leg') return 'one'
|
|
} } })
|
|
const module = compile('./firstLegOrders.ts', {
|
|
vue, pinia,
|
|
'@/modules/first-leg/api/firstLeg': api,
|
|
'@/modules/first-leg/api/unifiedOrders': {
|
|
getMerchantUnifiedOrder: async () => ({ progress: { orderId: 'one', stage: 'none', partial: false }, summary: { orderId: 'one', mainStatus: null }, order: { order: { id: 'one', status: behavior.status, version: behavior.version, receivingWarehouseId: 'warehouse', receivingWarehouseAddress: behavior.receivingWarehouseAddress } }, timeline: [] }),
|
|
},
|
|
'@/modules/first-leg/utils/firstLegOrder': { canClientEditFirstLegOrder: status => status === 'DRAFT', getFirstLegStatusLabel: value => value },
|
|
'@/modules/first-leg/utils/warehousePagination': {},
|
|
'@/modules/first-leg/utils/orderProgress': { requireOrderProgress },
|
|
})
|
|
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 }
|
|
}
|
|
|
|
function displayedWarehouseAddress(order) {
|
|
const view = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8')
|
|
const expressions = [...view.matchAll(/\{\{ (detailOrder\.receivingWarehouseSnapshot\.(?:province|city|address)) \}\}/g)]
|
|
assert.equal(expressions.length, 3)
|
|
return expressions.map(([, expression]) => new Function('detailOrder', `return ${expression}`)(order)).join('')
|
|
}
|
|
|
|
test('complete address is identical for cold unified, warm unified, raw detail and remark-only save', async t => {
|
|
const h = harness(t)
|
|
const fullAddress = 'CN 浙江省 义乌市 仓库路 8 号 322000'
|
|
h.behavior.receivingWarehouseAddress = fullAddress
|
|
h.store.warehouses = []
|
|
const cold = await h.store.loadDetail('one')
|
|
assert.equal(displayedWarehouseAddress(cold), fullAddress)
|
|
h.store.warehouses = [{ id: 'warehouse', name: '国内仓', warehouseType: 'DOMESTIC', province: '浙江省', city: '义乌市', address: '主档已更新的地址' }]
|
|
h.store.orders = []
|
|
const warm = await h.store.loadDetail('one')
|
|
const raw = await h.store.loadDraftDetail('one')
|
|
for (const detail of [warm, raw]) {
|
|
assert.equal(displayedWarehouseAddress(detail), fullAddress)
|
|
assert.equal(detail.receivingWarehouseSnapshot.province, '')
|
|
assert.equal(detail.receivingWarehouseSnapshot.city, '')
|
|
}
|
|
const session = h.store.beginDraftEdit(raw)
|
|
h.draft.customerRemark = '仅修改备注'
|
|
const saved = await h.store.saveDraft(h.draft, '客户', 'one', session)
|
|
assert.equal(displayedWarehouseAddress(saved), fullAddress)
|
|
const write = h.calls.find(call => call.method === 'PUT')
|
|
assert.equal(write.data.draft.customerRemark, '仅修改备注')
|
|
assert.equal(Object.hasOwn(write.data.draft, 'receivingWarehouseAddress'), false)
|
|
assert.equal(h.behavior.receivingWarehouseAddress, fullAddress)
|
|
assert.equal(h.store.warehouses[0].province, '浙江省')
|
|
assert.equal(h.store.warehouses[0].address, '主档已更新的地址')
|
|
})
|
|
|
|
test('structured master address stays structured when no order address snapshot exists', async t => {
|
|
const h = harness(t)
|
|
h.store.warehouses = [{ id: 'warehouse', name: '国内仓', province: '浙江省', city: '义乌市', address: '仓库路 8 号', warehouseType: 'DOMESTIC' }]
|
|
const detail = await h.store.loadDetail('one')
|
|
assert.equal(detail.receivingWarehouseSnapshot.province, '浙江省')
|
|
assert.equal(detail.receivingWarehouseSnapshot.city, '义乌市')
|
|
assert.equal(detail.receivingWarehouseSnapshot.address, '仓库路 8 号')
|
|
assert.equal(displayedWarehouseAddress(detail), '浙江省义乌市仓库路 8 号')
|
|
})
|
|
|
|
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('fresh direct draft detail preserves raw DRAFT with null unified summary and opens an edit session', async t => {
|
|
const h = harness(t)
|
|
assert.equal(h.store.orders.length, 0)
|
|
const direct = await h.store.loadDetail('one')
|
|
assert.equal(direct.status, 'DRAFT')
|
|
assert.equal(h.store.beginDraftEdit(direct).expectedVersion, 9)
|
|
h.store.orders = []
|
|
const refreshed = await h.store.loadDetail('one')
|
|
assert.equal(refreshed.status, 'DRAFT')
|
|
h.store.orders = []
|
|
h.behavior.status = 'APPROVED'
|
|
const unknown = await h.store.loadDetail('one')
|
|
assert.notEqual(unknown.status, 'DRAFT')
|
|
assert.notEqual(unknown.status, 'CANCELLED')
|
|
assert.throws(() => h.store.beginDraftEdit(unknown), /重新打开/)
|
|
})
|
|
|
|
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 preserves the detail version but generates a fresh command after failure', async t => {
|
|
const h = harness(t), session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
|
|
h.store.orders = [{ id: 'one', version: 0 }]; h.behavior.failWrite = true
|
|
await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session), /响应丢失/)
|
|
h.behavior.failWrite = false; h.draft.customerRemark = '已修改'
|
|
await h.store.saveDraft(h.draft, '客户', 'one', session)
|
|
const writes = h.calls.filter(call => call.method === 'PUT')
|
|
assert.equal(writes[0].data.expectedVersion, 9); assert.equal(writes[1].data.draft.customerRemark, '已修改')
|
|
assert.notEqual(writes[0].headers['Idempotency-Key'], writes[1].headers['Idempotency-Key'])
|
|
})
|
|
test('missing edit session is invalid while changed inputs after failure are accepted', async t => {
|
|
const h = harness(t); await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one'), /重新打开/)
|
|
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 = '不同内容'; h.behavior.failWrite = false
|
|
await h.store.saveDraft(h.draft, '客户', 'one', session)
|
|
assert.equal(h.calls.filter(call => call.method === 'PUT').length, 2)
|
|
})
|
|
test('read failure after edit does not retain a frozen request', 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.notEqual(writes[0].headers['Idempotency-Key'], writes[1].headers['Idempotency-Key'])
|
|
})
|
|
|
|
test('cancel submits the current version and reason after a previous failure', async t => {
|
|
const h = harness(t); h.behavior.status = 'SUBMITTED'; h.behavior.failWrite = true
|
|
await assert.rejects(h.store.cancelOrder('one', 12, '客户要求取消'), /响应丢失/)
|
|
h.behavior.failWrite = false; await h.store.cancelOrder('one', 13, '其他原因')
|
|
const writes = h.calls.filter(call => call.method === 'POST')
|
|
assert.equal(writes.length, 2); assert.deepEqual(writes[1].data, { expectedVersion: 13, reason: '其他原因' })
|
|
assert.notEqual(writes[0].headers['Idempotency-Key'], writes[1].headers['Idempotency-Key'])
|
|
})
|
|
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,
|
|
loadOrderPage: async () => calls.push(['load']),
|
|
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 releases failure and asks for a current cancellation decision on the next click', async () => {
|
|
const h = cancellationViewHarness(), order = { id: 'one', status: 'DRAFT' }
|
|
h.behavior.error = new Error('网络无响应'); await h.handler(order)
|
|
h.behavior.error = null; await h.handler(order)
|
|
assert.equal(h.prompts.length, 2); assert.equal(h.calls.filter(call => call[0] === 'prepare').length, 2)
|
|
assert.equal(h.calls.filter(call => call[0] === 'cancel').length, 2)
|
|
})
|
|
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(?:ForSubmission)?\(cloneDraft\(form\), tenantStore\.company\.companyName, editingId\.value, editingSession\.value\)/g) ?? []).length, 2)
|
|
})
|
|
|
|
test('submit uses the current raw version and a fresh key after timeout', async t => {
|
|
const h = harness(t); h.store.orders = [{id:'one',status:'DRAFT',version:0}]; h.behavior.failSubmit = true
|
|
await assert.rejects(h.store.submitSaved('one', 'ACTIVE'), /响应丢失/)
|
|
h.behavior.version = 10; h.behavior.failSubmit = false; await h.store.submitSaved('one', 'ACTIVE')
|
|
const writes = h.calls.filter(call => call.url.endsWith('/submit'))
|
|
assert.deepEqual(writes.map(call => call.data.expectedVersion), [9,10]); assert.notEqual(writes[0].headers['Idempotency-Key'],writes[1].headers['Idempotency-Key'])
|
|
})
|
|
test('submit validates current status and releases failure after readback', async t => {
|
|
const h = harness(t)
|
|
for (const version of [undefined, -1, 1.5]) {
|
|
h.behavior.version = version
|
|
await assert.rejects(h.store.submitSaved('one'), /版本缺失/)
|
|
}
|
|
h.behavior.version = 0; h.behavior.status = 'SUBMITTED'
|
|
await assert.rejects(h.store.submitSaved('one'), /不是草稿/)
|
|
assert.ok(h.calls.every(call => call.method === 'GET'))
|
|
h.behavior.status = 'DRAFT'; h.behavior.failSubmitRead = true
|
|
await assert.rejects(h.store.submitSaved('one'), /读取失败/)
|
|
h.behavior.failRead = false; h.behavior.failSubmitRead = false
|
|
await h.store.submitSaved('one')
|
|
const posts = h.calls.filter(call => call.method === 'POST')
|
|
assert.notEqual(posts[0].headers['Idempotency-Key'], posts[1].headers['Idempotency-Key'])
|
|
assert.deepEqual(posts[0].data, { expectedVersion: 0 }, 'raw detail zero is valid')
|
|
})
|
|
|
|
test('failed submit leaves the draft editable for a fresh save and submission', async t => {
|
|
const h = harness(t), session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
|
|
await h.store.saveDraft(h.draft, '客户', 'one', session); h.behavior.failSubmit = true
|
|
await assert.rejects(h.store.submitSaved('one')); h.draft.customerRemark = '新内容'
|
|
await h.store.saveDraft(h.draft, '客户', 'one', session); h.behavior.failSubmit = false
|
|
await h.store.submitSaved('one'); assert.equal(h.calls.filter(call => call.method === 'PUT').length, 2)
|
|
})
|
|
test('failed initial submit read releases the submission guard for the next click', async t => {
|
|
const h = harness(t); h.behavior.failRead = true; await assert.rejects(h.store.submitSaved('one'))
|
|
h.behavior.failRead = false; await h.store.submitSaved('one')
|
|
assert.equal(h.calls.filter(call => call.url.endsWith('/submit')).length, 1)
|
|
})
|
|
async function submissionViewHarness(t) {
|
|
const h = harness(t)
|
|
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) && ['submitOrder', 'confirmSubmissionEdit', 'submitSelectedDraftOrders'].includes(node.name?.text)).map(node => node.getText(ast)).join('\n')
|
|
const code = ts.transpileModule(functions, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
|
|
const messages = [], confirmations = []
|
|
const globals = {
|
|
store: h.store, saving: vue.ref(false), form: h.draft, cloneDraft: draft => structuredClone(draft),
|
|
editingId: vue.ref('one'), editingSession: vue.shallowRef(h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))),
|
|
companySubmissionBlocked: vue.ref(false), companyAuditLoaded: vue.ref(true), tenantStore: { company: { companyName: '客户', auditStatus: 'ACTIVE' } },
|
|
validateEditorForm: async () => true, markEditorClean: () => {}, editorOpen: vue.ref(true), isCreatePage: vue.ref(false), loadPageData: async () => {},
|
|
batchSubmitting: vue.ref(false), selectedDraftOrders: vue.ref([{ id: 'one', version: 0 }]), pendingBatchSubmissionIds: vue.ref([]),
|
|
searchOrders: async () => { globals.selectedDraftOrders.value = [] }, appliedFilters: vue.ref({}),
|
|
ElMessageBox: { confirm: async message => { confirmations.push(message); if (h.behavior.cancelConfirm) throw 'cancel' } },
|
|
ElMessage: { error: message => messages.push(message), warning: message => messages.push(message), success: message => messages.push(message) },
|
|
}
|
|
const handlers = new Function(...Object.keys(globals), code + '\nreturn {submitOrder, submitSelectedDraftOrders}')(...Object.values(globals))
|
|
return { ...h, ...handlers, globals, messages, confirmations }
|
|
}
|
|
|
|
test('real editor releases failure and saves current edited input on another click', async t => {
|
|
const h = await submissionViewHarness(t); h.behavior.failSubmit = true
|
|
await h.submitOrder(); assert.equal(h.globals.saving.value, false)
|
|
h.draft.customerRemark = '修改后的决定'; h.behavior.failSubmit = false; await h.submitOrder()
|
|
const writes = h.calls.filter(call => call.method === 'PUT'), posts = h.calls.filter(call => call.url.endsWith('/submit'))
|
|
assert.equal(writes.length, 2); assert.equal(writes[1].data.draft.customerRemark, '修改后的决定')
|
|
assert.notEqual(posts[0].headers['Idempotency-Key'], posts[1].headers['Idempotency-Key']); assert.equal(h.globals.saving.value, false)
|
|
})
|
|
test('real batch handler uses only current selection after a failed batch', async t => {
|
|
const h = await submissionViewHarness(t); h.behavior.failSubmit = true
|
|
await h.submitSelectedDraftOrders(); assert.equal(h.globals.batchSubmitting.value, false)
|
|
h.behavior.failSubmit = false; await h.submitSelectedDraftOrders()
|
|
assert.equal(h.calls.filter(call => call.url.endsWith('/submit')).length, 1)
|
|
h.globals.selectedDraftOrders.value = [{id:'one',version:9}]; await h.submitSelectedDraftOrders()
|
|
const posts = h.calls.filter(call => call.url.endsWith('/submit'))
|
|
assert.equal(posts.length, 2); assert.notEqual(posts[0].headers['Idempotency-Key'], posts[1].headers['Idempotency-Key'])
|
|
})
|
|
test('real new-order handler retains the created order and saves current edits after submit failure', async t => {
|
|
const h = await submissionViewHarness(t); h.globals.editingId.value = undefined; h.globals.editingSession.value = undefined
|
|
h.behavior.version = 0; h.behavior.failSubmit = true; await h.submitOrder()
|
|
assert.equal(h.globals.editingId.value, 'one'); h.behavior.failSubmit = false; h.draft.customerRemark = '修改'
|
|
await h.submitOrder()
|
|
assert.equal(h.calls.filter(call => call.method === 'POST' && call.url === '/merchant/v1/orders/first-leg').length, 1)
|
|
assert.equal(h.calls.filter(call => call.method === 'PUT').length, 1)
|
|
assert.equal(h.calls.filter(call => call.url.endsWith('/submit')).length, 2)
|
|
}) |