168 lines
8.8 KiB
JavaScript
168 lines
8.8 KiB
JavaScript
const assert = require('node:assert/strict')
|
|
const fs = require('node:fs')
|
|
const path = require('node:path')
|
|
const test = require('node:test')
|
|
const ts = require('typescript')
|
|
const vue = require('vue')
|
|
const { parse, compileScript, compileTemplate } = require('@vue/compiler-sfc')
|
|
|
|
const selected = [
|
|
'patchUsageVisible', 'patchUsageSaving', 'patchUsageFormRef', 'patchUsageForm',
|
|
'patchUsageRules', 'openPatchUsageDialog', 'resetPatchUsageForm', 'submitPatchUsage'
|
|
]
|
|
|
|
for (const page of ['components/PrescriptionOrderDetailDrawer.vue', 'order_list_h5.vue']) {
|
|
const filename = path.join(__dirname, '../src/views/consumer/prescription', page)
|
|
const { descriptor, errors } = parse(fs.readFileSync(filename, 'utf8'), { filename })
|
|
assert.deepEqual(errors, [])
|
|
const script = compileScript(descriptor, { id: page })
|
|
const template = compileTemplate({
|
|
source: descriptor.template.content, filename, id: page,
|
|
compilerOptions: { bindingMetadata: script.bindings }
|
|
})
|
|
assert.deepEqual(template.errors, [])
|
|
|
|
// Run the real handlers; replace the network and the rest of the order page.
|
|
const ast = ts.createSourceFile(filename + '.ts', descriptor.scriptSetup.content, ts.ScriptTarget.Latest, true)
|
|
const declarations = new Map()
|
|
for (const node of ast.statements) {
|
|
if (ts.isFunctionDeclaration(node) && node.name) declarations.set(node.name.text, node.getText(ast))
|
|
if (ts.isVariableStatement(node)) {
|
|
for (const declaration of node.declarationList.declarations) {
|
|
declarations.set(declaration.name.getText(ast), `const ${declaration.getText(ast)}`)
|
|
}
|
|
}
|
|
}
|
|
const executed = page.startsWith('components/') ? [...selected, 'refresh'] : selected
|
|
for (const name of executed) assert.ok(declarations.has(name), `${page}: missing ${name}`)
|
|
const compiled = ts.transpileModule(executed.map(name => declarations.get(name)).join('\n'), {
|
|
compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS }
|
|
}).outputText
|
|
|
|
function instance({ hasAux = true, prescriptionType = '浓缩水丸', bagCount = 2, mainBagCount = 2, status = 2, fail = false } = {}) {
|
|
const calls = []
|
|
const events = []
|
|
const aux = { times_per_day: 3, usage_days: 10, dosage_bag_count: bagCount }
|
|
const detailPrescription = vue.ref({ prescription_type: prescriptionType, times_per_day: 3, usage_days: 10, dosage_bag_count: mainBagCount })
|
|
const detailAuxUsage = vue.ref(hasAux ? aux : null)
|
|
const detailData = vue.ref({
|
|
id: 42, prescription_id: 17, medication_days: 10, fulfillment_status: status,
|
|
gancao_reciperl_order_no: 'TEST-SUBMITTED', ej_pharmacy_order_no: 'TEST-EJ-SUBMITTED'
|
|
})
|
|
const refresh = async () => {
|
|
if (calls[0]?.dosage_bag_count) detailPrescription.value.dosage_bag_count = calls[0].dosage_bag_count
|
|
if (calls[0]?.aux_dosage_bag_count) detailAuxUsage.value.dosage_bag_count = calls[0].aux_dosage_bag_count
|
|
events.push('refresh')
|
|
return { ...detailData.value }
|
|
}
|
|
const globals = {
|
|
ref: vue.ref, reactive: vue.reactive, computed: vue.computed, nextTick: vue.nextTick,
|
|
detailPrescription, detailAuxUsage, detailData, detailHasAuxHerbs: vue.ref(hasAux),
|
|
feedback: { msgWarning() {}, msgSuccess() {} },
|
|
prescriptionOrderPatchPrescriptionUsage: async payload => {
|
|
calls.push(payload)
|
|
if (fail) throw new Error('Save failed')
|
|
},
|
|
requestDetail: refresh, refreshCurrentPrescriptionOrderDetail: refresh,
|
|
props: { loadRelatedData: true },
|
|
emit: event => events.push(event),
|
|
fetchLogs: async () => {
|
|
events.push('logs:start')
|
|
await Promise.resolve()
|
|
events.push('logs:done')
|
|
},
|
|
getLists: () => events.push('lists')
|
|
}
|
|
const state = new Function(...Object.keys(globals), `${compiled}\nreturn { ${selected.join(', ')} }`)(...Object.values(globals))
|
|
state.patchUsageFormRef.value = { validate: async () => {}, clearValidate() {} }
|
|
return { state, calls, events, detailAuxUsage, detailPrescription }
|
|
}
|
|
|
|
test(`${page}: edits auxiliary bags and refreshes the persisted value without changing usage`, async () => {
|
|
const { state, calls, events, detailAuxUsage } = instance()
|
|
state.openPatchUsageDialog()
|
|
assert.equal(state.patchUsageForm.aux_dosage_bag_count, 2)
|
|
state.patchUsageForm.aux_dosage_bag_count = 4
|
|
await state.submitPatchUsage()
|
|
assert.deepEqual(calls, [{
|
|
id: 42, times_per_day: 3, usage_days: 10, medication_days: 10,
|
|
dosage_bag_count: 2,
|
|
aux_times_per_day: 3, aux_usage_days: 10, aux_dosage_bag_count: 4
|
|
}])
|
|
assert.equal(state.patchUsageVisible.value, false)
|
|
assert.equal(detailAuxUsage.value.dosage_bag_count, 4)
|
|
assert.ok(events.includes('refresh'))
|
|
assert.ok(events.indexOf('logs:done') > events.indexOf('refresh'))
|
|
const completedEvent = page.startsWith('components/') ? 'detail-changed' : 'lists'
|
|
assert.ok(events.indexOf(completedEvent) > events.indexOf('logs:done'))
|
|
state.openPatchUsageDialog()
|
|
assert.equal(state.patchUsageForm.aux_dosage_bag_count, 4)
|
|
})
|
|
|
|
test(`${page}: missing historical bag count defaults to one and resets on close`, () => {
|
|
const { state } = instance({ bagCount: null, mainBagCount: null })
|
|
state.openPatchUsageDialog()
|
|
assert.equal(state.patchUsageForm.aux_dosage_bag_count, 1)
|
|
assert.equal(state.patchUsageForm.dosage_bag_count, 1)
|
|
state.patchUsageForm.dosage_bag_count = 4
|
|
state.patchUsageForm.aux_dosage_bag_count = 5
|
|
state.resetPatchUsageForm()
|
|
assert.equal(state.patchUsageForm.aux_dosage_bag_count, 1)
|
|
assert.equal(state.patchUsageForm.dosage_bag_count, 1)
|
|
})
|
|
|
|
test(`${page}: only water pills with an auxiliary formula submit or require auxiliary bags`, async () => {
|
|
for (const options of [{ hasAux: false }, { prescriptionType: '饮片' }, { prescriptionType: '颗粒' }]) {
|
|
const { state, calls } = instance(options)
|
|
state.openPatchUsageDialog()
|
|
state.patchUsageForm.aux_dosage_bag_count = 5
|
|
assert.equal(state.patchUsageRules.value.aux_dosage_bag_count, undefined)
|
|
await state.submitPatchUsage()
|
|
assert.ok(!Object.hasOwn(calls[0], 'aux_dosage_bag_count'))
|
|
assert.equal(Object.hasOwn(calls[0], 'dosage_bag_count'), !options.prescriptionType)
|
|
}
|
|
const { state } = instance()
|
|
assert.equal(state.patchUsageRules.value.aux_dosage_bag_count[0].required, true)
|
|
assert.equal(state.patchUsageRules.value.dosage_bag_count[0].required, true)
|
|
})
|
|
|
|
test(`${page}: main and auxiliary bags can be edited independently in every submitted order status`, async () => {
|
|
for (let status = 1; status <= 12; status++) {
|
|
const { state, calls, detailPrescription, detailAuxUsage } = instance({ status })
|
|
state.openPatchUsageDialog()
|
|
assert.equal(state.patchUsageForm.dosage_bag_count, 2)
|
|
state.patchUsageForm.dosage_bag_count = 5
|
|
state.patchUsageForm.aux_dosage_bag_count = 1
|
|
await state.submitPatchUsage()
|
|
assert.equal(calls.length, 1, `status ${status}`)
|
|
assert.equal(calls[0].dosage_bag_count, 5)
|
|
assert.equal(calls[0].aux_dosage_bag_count, 1)
|
|
assert.equal(detailPrescription.value.dosage_bag_count, 5)
|
|
assert.equal(detailAuxUsage.value.dosage_bag_count, 1)
|
|
}
|
|
const { state, calls } = instance({ hasAux: false })
|
|
state.openPatchUsageDialog()
|
|
state.patchUsageForm.dosage_bag_count = 4
|
|
await state.submitPatchUsage()
|
|
assert.equal(calls[0].dosage_bag_count, 4)
|
|
assert.ok(!Object.hasOwn(calls[0], 'aux_dosage_bag_count'))
|
|
})
|
|
|
|
test(`${page}: validation blocks requests and a rejected save retains the selected bags`, async () => {
|
|
const { state, calls, events } = instance({ fail: true })
|
|
state.openPatchUsageDialog()
|
|
state.patchUsageForm.aux_dosage_bag_count = 3
|
|
state.patchUsageForm.dosage_bag_count = 4
|
|
state.patchUsageFormRef.value.validate = async () => { throw new Error('Required') }
|
|
await state.submitPatchUsage()
|
|
assert.equal(calls.length, 0)
|
|
state.patchUsageFormRef.value.validate = async () => {}
|
|
await state.submitPatchUsage()
|
|
assert.equal(state.patchUsageForm.aux_dosage_bag_count, 3)
|
|
assert.equal(state.patchUsageForm.dosage_bag_count, 4)
|
|
assert.equal(state.patchUsageVisible.value, true)
|
|
assert.equal(state.patchUsageSaving.value, false)
|
|
assert.deepEqual(events, [])
|
|
})
|
|
}
|