更新
This commit is contained in:
Your Name
@@ -0,0 +1,146 @@
|
||||
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 { renderToString } = require('@vue/server-renderer')
|
||||
const { parse, compileScript, compileTemplate } = require('@vue/compiler-sfc')
|
||||
|
||||
const src = path.join(__dirname, '../src')
|
||||
function moduleFrom(source, mockRequire = require, browserWindow = {}) {
|
||||
const code = ts.transpileModule(source.replaceAll('import.meta.env.DEV', 'false'), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 }
|
||||
}).outputText
|
||||
const module = { exports: {} }
|
||||
new Function('require', 'module', 'exports', 'window', code)(mockRequire, module, module.exports, browserWindow)
|
||||
return module.exports
|
||||
}
|
||||
const read = (file) => fs.readFileSync(path.join(src, file), 'utf8')
|
||||
const types = moduleFrom(read('utils/appointment-type.ts'))
|
||||
const { descriptor } = parse(read('components/chat-dialog/index.vue'))
|
||||
const script = compileScript(descriptor, { id: 'appointment-call-mode' })
|
||||
const template = compileTemplate({ source: descriptor.template.content, filename: 'chat-dialog.vue', id: 'appointment-call-mode', compilerOptions: { bindingMetadata: script.bindings } })
|
||||
assert.deepEqual(template.errors, [])
|
||||
const render = moduleFrom(template.code).render
|
||||
const passthrough = { setup: (_, { slots }) => () => vue.h('div', [slots.default?.(), slots.headerToolbar?.()]) }
|
||||
const picker = text => ({ setup: () => () => vue.h('button', text) })
|
||||
|
||||
function chat(policy = {}) {
|
||||
const requests = [], warnings = [], sdkCalls = []
|
||||
const guard = moduleFrom(read('utils/appointment-call-guard.ts'))
|
||||
const server = Object.fromEntries(['calls', 'call', 'groupCall'].map(name => [name, async params => { sdkCalls.push({ name, params }) }]))
|
||||
const api = { getCallSignature: async params => { requests.push(params); return policy } }
|
||||
const result = moduleFrom(script.content, name => {
|
||||
if (name === 'vue') return { ...vue, onMounted() {}, onUnmounted() {} }
|
||||
if (name === '@/utils/appointment-type') return types
|
||||
if (name === '@/utils/appointment-call-guard') return guard
|
||||
if (name === '@/utils/im-chat-archive-trigger') return moduleFrom(read('utils/im-chat-archive-trigger.ts'))
|
||||
if (name === '@/api/tcm') return api
|
||||
if (name === '@/utils/feedback') return { default: { msgWarning: text => warnings.push(text) } }
|
||||
if (name === '@/stores/modules/user') return { default: () => ({ userInfo: {} }) }
|
||||
if (name === '@/utils/call-local-recorder') return { CallLocalRecorder: class {} }
|
||||
if (name === '@tencentcloud/chat-uikit-vue3') return {
|
||||
useLoginState: () => ({}), useConversationListState: () => ({ activeConversation: vue.ref(null) }),
|
||||
Chat: passthrough, UIKitProvider: passthrough, MessageInput: passthrough, MessageList: passthrough,
|
||||
EmojiPicker: picker('表情'), ImagePicker: picker('图片'), FilePicker: picker('文件'),
|
||||
AudioCallPicker: picker('语音拨打'), VideoCallPicker: picker('视频拨打')
|
||||
}
|
||||
if (name === '@tencentcloud/call-uikit-vue') return { TUICallKitServer: server, TUICallType: { VIDEO_CALL: 2 }, TUIStore: {}, StoreName: {}, NAME: {} }
|
||||
return {}
|
||||
}).default.setup({}, { expose() {} })
|
||||
result.visible.value = true
|
||||
result.isReady.value = true
|
||||
result.isCallReady.value = true
|
||||
result.patientId.value = 50
|
||||
result.diagnosisId.value = 70
|
||||
result.appointmentId.value = 90
|
||||
result.syncAppointmentCallPolicy(policy)
|
||||
guard.registerAppointmentCallGuard(result.prepareAppointmentCall)
|
||||
return { state: result, guard, server, requests, warnings, sdkCalls, api }
|
||||
}
|
||||
const policy = type => ({ appointment_id: 90, appointment_type: type, appointment_type_desc: types.appointmentTypeDescription(type), can_video_call: type === 'video', can_audio_call: type === 'video' || type === 'phone', call_disabled_reason: type === 'text' ? '图文问诊不支持音视频通话' : '当前挂号不支持该通话方式' })
|
||||
|
||||
test('type labels and video capability preserve legacy video while rejecting text and unknown', () => {
|
||||
for (const value of ['text', 'phone', 'unknown']) assert.equal(types.canAppointmentVideoCall(value), false)
|
||||
for (const value of ['video', '', ' ', null, undefined]) assert.equal(types.canAppointmentVideoCall(value), true)
|
||||
assert.equal(types.appointmentTypeDescription('text'), '图文问诊')
|
||||
})
|
||||
|
||||
test('rendered real chat template keeps text tools while excluding call controls in text mode', async () => {
|
||||
async function markup(type) {
|
||||
const { state } = chat(policy(type))
|
||||
const app = vue.createSSRApp({ render: () => render({}, [], {}, vue.proxyRefs(state)) })
|
||||
app.config.warnHandler = () => {}
|
||||
for (const name of ['el-tag', 'el-button', 'el-tooltip', 'el-icon', 'el-alert']) app.component(name, passthrough)
|
||||
const context = {}
|
||||
await renderToString(app, context)
|
||||
return context.teleports.body
|
||||
}
|
||||
const text = await markup('text')
|
||||
assert.match(text, /图文问诊/)
|
||||
for (const tool of ['表情', '图片', '文件']) assert.match(text, new RegExp(tool))
|
||||
assert.doesNotMatch(text, /视频拨打|语音拨打|群视频/)
|
||||
const video = await markup('video')
|
||||
assert.match(video, /视频问诊/)
|
||||
assert.match(video, /视频拨打/)
|
||||
assert.match(video, /群视频/)
|
||||
})
|
||||
|
||||
test('text mode hides all live call entries and refuses direct group invocation', async () => {
|
||||
const { state, requests, sdkCalls } = chat(policy('text'))
|
||||
assert.equal(state.appointmentTypeLabel.value, '图文问诊')
|
||||
assert.equal(state.canVideoCall.value, false)
|
||||
assert.equal(state.canAudioCall.value, false)
|
||||
await state.startGroupVideoCall()
|
||||
await assert.rejects(state.prepareAppointmentCall(2), /图文问诊/)
|
||||
assert.deepEqual(requests, [])
|
||||
assert.deepEqual(sdkCalls, [])
|
||||
assert.match(descriptor.template.content, /<VideoCallPicker v-if="isCallReady && canVideoCall"/)
|
||||
assert.match(descriptor.template.content, /<AudioCallPicker v-if="isCallReady && canAudioCall"/)
|
||||
})
|
||||
|
||||
test('all SDK outgoing paths stop before touching SDK when current appointment is text', async () => {
|
||||
const { state, server, sdkCalls } = chat(policy('text'))
|
||||
state.installTUICallKitRoomHooks()
|
||||
for (const method of ['call', 'calls', 'groupCall']) await assert.rejects(server[method]({ type: 2 }), /图文问诊/)
|
||||
assert.deepEqual(sdkCalls, [])
|
||||
})
|
||||
|
||||
test('video preflight uses actual appointment and prevents a server-side change to text', async () => {
|
||||
const { state, requests, api } = chat(policy('video'))
|
||||
assert.equal(state.canVideoCall.value, true)
|
||||
await state.prepareAppointmentCall(2)
|
||||
assert.deepEqual(requests, [{ patient_id: 50, diagnosis_id: 70, appointment_id: 90 }])
|
||||
api.getCallSignature = async () => policy('text')
|
||||
await assert.rejects(state.prepareAppointmentCall(2), /图文问诊/)
|
||||
assert.equal(state.canVideoCall.value, false)
|
||||
assert.equal(state.appointmentTypeLabel.value, '图文问诊')
|
||||
})
|
||||
|
||||
test('historical phone is audio-only; missing server confirmation never enables video', async () => {
|
||||
const { state } = chat(policy('phone'))
|
||||
assert.equal(state.canAudioCall.value, true)
|
||||
assert.equal(state.canVideoCall.value, false)
|
||||
await state.prepareAppointmentCall(1)
|
||||
await assert.rejects(state.prepareAppointmentCall(2))
|
||||
state.syncAppointmentCallPolicy({ appointment_type: 'video' })
|
||||
assert.equal(state.canVideoCall.value, false)
|
||||
state.syncAppointmentCallPolicy({ appointment_type: null, appointment_type_desc: '未挂号', can_video_call: false, can_audio_call: false })
|
||||
assert.equal(state.appointmentTypeLabel.value, '未挂号')
|
||||
assert.equal(state.canVideoCall.value, false)
|
||||
})
|
||||
|
||||
test('singleton call guard switches to current chat and cancels a pending old context', async () => {
|
||||
const guard = moduleFrom(read('utils/appointment-call-guard.ts'))
|
||||
let resolveOld
|
||||
const releaseOld = guard.registerAppointmentCallGuard(() => new Promise(resolve => { resolveOld = resolve }))
|
||||
const pending = guard.checkAppointmentOutgoingCall({ type: 2 })
|
||||
const releaseNew = guard.registerAppointmentCallGuard(async () => { throw new Error('图文问诊') })
|
||||
releaseOld()
|
||||
await assert.rejects(guard.checkAppointmentOutgoingCall({ type: 2 }), /图文问诊/)
|
||||
resolveOld()
|
||||
await assert.rejects(pending, /问诊已切换/)
|
||||
releaseNew()
|
||||
await assert.rejects(guard.checkAppointmentOutgoingCall({ type: 2 }), /先打开/)
|
||||
})
|
||||
@@ -0,0 +1,125 @@
|
||||
const assert = require('node:assert/strict')
|
||||
const fs = require('node:fs')
|
||||
const path = require('node:path')
|
||||
const test = require('node:test')
|
||||
const { execFileSync } = require('node:child_process')
|
||||
const { DatabaseSync } = require('node:sqlite')
|
||||
const ts = require('typescript')
|
||||
const vue = require('vue')
|
||||
const { parse, compileScript, compileTemplate } = require('@vue/compiler-sfc')
|
||||
|
||||
const root = path.resolve(__dirname, '../..')
|
||||
const sql = JSON.parse(execFileSync(process.env.PHP_BINARY || 'php', [path.join(root, 'server/tests/AppointmentTypeFilterSqlFixture.php')], { encoding: 'utf8' }))
|
||||
const db = new DatabaseSync(':memory:')
|
||||
db.exec(`
|
||||
CREATE TABLE doctor_appointment (id INTEGER, patient_id INTEGER, doctor_id INTEGER, assistant_id INTEGER, appointment_type TEXT, status INTEGER, appointment_date TEXT, appointment_time TEXT);
|
||||
CREATE TABLE tcm_diagnosis (id INTEGER, patient_id INTEGER, patient_name TEXT, phone TEXT, gender INTEGER, age INTEGER, weight INTEGER, height INTEGER, assistant_id INTEGER, delete_time INTEGER);
|
||||
CREATE TABLE admin (id INTEGER, name TEXT);
|
||||
INSERT INTO tcm_diagnosis VALUES (100, 1000, '患者甲', '', 1, 30, 60, 170, 301, NULL), (101, 1001, '患者乙', '', 1, 31, 61, 171, 302, NULL), (102, 1002, '已删除', '', 1, 30, 60, 170, 301, 1);
|
||||
INSERT INTO admin VALUES (201, '医生甲'), (202, '医生乙'), (301, '医助甲'), (302, '医助乙');
|
||||
`)
|
||||
const add = db.prepare('INSERT INTO doctor_appointment VALUES (?, ?, ?, 301, ?, ?, ?, ?)')
|
||||
const fixtures = [
|
||||
[1, 100, 201, 'video', 1],
|
||||
[2, 100, 201, null, 1],
|
||||
[3, 100, 201, '', 2],
|
||||
[4, 101, 202, ' ', 3],
|
||||
[5, 101, 202, '\t\r\n\v ', 4],
|
||||
[6, 100, 201, 'text', 1],
|
||||
[7, 101, 202, 'text', 3],
|
||||
[8, 100, 201, 'phone', 1],
|
||||
[9, 100, 201, 'unknown', 1],
|
||||
[10, 100, 201, 'Video', 1],
|
||||
[11, 100, 201, 'video ', 1],
|
||||
[12, 102, 201, null, 1],
|
||||
[13, 102, 201, 'text', 1]
|
||||
]
|
||||
for (const [id, patient, doctor, type, status] of fixtures) add.run(id, patient, doctor, type, status, '2026-09-09', `${String(id).padStart(2, '0')}:00:00`)
|
||||
|
||||
// SQLite's explicit BINARY collation has the same exact text comparison semantics used here.
|
||||
// The remaining statements are the SQL emitted by the real ThinkPHP list/count/tab paths.
|
||||
const execute = statement => db.prepare(statement.replace(/BINARY a\.appointment_type/g, 'a.appointment_type COLLATE BINARY')).all()
|
||||
const result = name => ({
|
||||
ids: execute(sql[name].lists).map(row => row.id),
|
||||
count: execute(sql[name].count)[0].think_count,
|
||||
tabs: Object.fromEntries(execute(sql[name].tabs).map(row => [row.status, row.cnt]))
|
||||
})
|
||||
|
||||
test('video query includes legacy blanks and keeps list, total and status counts aligned', () => {
|
||||
assert.deepEqual(result('video'), { ids: [1, 2, 3, 4, 5], count: 5, tabs: { 1: 2, 2: 1, 3: 1, 4: 1 } })
|
||||
})
|
||||
|
||||
test('text query excludes video, unknown and historical phone records', () => {
|
||||
assert.deepEqual(result('text'), { ids: [6, 7], count: 2, tabs: { 1: 1, 3: 1 } })
|
||||
})
|
||||
|
||||
test('all and omitted filters retain historical types without admitting deleted diagnoses', () => {
|
||||
for (const name of ['omitted', 'all', 'null']) {
|
||||
const actual = result(name)
|
||||
assert.equal(actual.count, 11)
|
||||
assert.deepEqual(actual.ids.toSorted((a, b) => a - b), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
|
||||
assert.equal(Object.values(actual.tabs).reduce((sum, count) => sum + count, 0), 11)
|
||||
}
|
||||
})
|
||||
|
||||
test('type filter composes with status, doctor and patient filters without OR leakage', () => {
|
||||
assert.deepEqual(result('video_status_1'), { ids: [1, 2], count: 2, tabs: { 1: 2, 2: 1, 3: 1, 4: 1 } })
|
||||
assert.deepEqual(result('text_doctor'), { ids: [6], count: 1, tabs: { 1: 1 } })
|
||||
assert.deepEqual(result('video_patient'), { ids: [4, 5], count: 2, tabs: { 3: 1, 4: 1 } })
|
||||
})
|
||||
|
||||
test('pagination limits only visible rows while count and tabs retain the full filtered set', () => {
|
||||
assert.deepEqual(result('video_page'), { ids: [2, 3], count: 5, tabs: { 1: 2, 2: 1, 3: 1, 4: 1 } })
|
||||
})
|
||||
|
||||
test('unsupported filter values return no rows or counts instead of being converted to video', () => {
|
||||
for (const name of Object.keys(sql).filter(name => name.startsWith('invalid_'))) {
|
||||
assert.deepEqual(result(name), { ids: [], count: 0, tabs: {} }, name)
|
||||
}
|
||||
})
|
||||
|
||||
function moduleFrom(source, dependencies = require, globals = {}) {
|
||||
const compiled = ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS } }).outputText
|
||||
const module = { exports: {} }
|
||||
new Function('require', 'module', 'exports', ...Object.keys(globals), compiled)(dependencies, module, module.exports, ...Object.values(globals))
|
||||
return module.exports
|
||||
}
|
||||
|
||||
const pageFile = path.join(root, 'admin/src/views/consumer/prescription/guahao.vue')
|
||||
const { descriptor, errors } = parse(fs.readFileSync(pageFile, 'utf8'), { filename: pageFile })
|
||||
assert.deepEqual(errors, [])
|
||||
const script = compileScript(descriptor, { id: 'appointment-type-filter' })
|
||||
|
||||
test('actual page and paging hook send type on query and clear it together with all fields on reset', async () => {
|
||||
const calls = []
|
||||
const paging = moduleFrom(fs.readFileSync(path.join(root, 'admin/src/hooks/usePaging.ts'), 'utf8'))
|
||||
const component = moduleFrom(script.content, name => {
|
||||
if (name === 'vue') return vue
|
||||
if (name === '@/hooks/usePaging') return paging
|
||||
if (name === '@/api/doctor') return { appointmentLists: async params => { calls.push({ ...params }); return { lists: [], count: 0 } } }
|
||||
if (name === '@/utils/appointment-type') return { appointmentTypeDescription: value => value }
|
||||
return {}
|
||||
}, { reactive: vue.reactive, ref: vue.ref, computed: vue.computed, onMounted() {}, onActivated() {} })
|
||||
const page = component.default.setup({}, { expose() {} })
|
||||
assert.equal(calls[0].appointment_type, '')
|
||||
page.pager.page = 4
|
||||
page.queryParams.appointment_type = 'text'
|
||||
page.queryParams.patient_name = '张'
|
||||
page.resetPage()
|
||||
assert.equal(calls.at(-1).page_no, 1)
|
||||
assert.equal(calls.at(-1).appointment_type, 'text')
|
||||
assert.equal(calls.at(-1).patient_name, '张')
|
||||
page.pager.page = 3
|
||||
page.queryParams.appointment_type = 'video'
|
||||
page.resetPage()
|
||||
assert.equal(calls.at(-1).appointment_type, 'video')
|
||||
page.resetFilter()
|
||||
assert.equal(calls.at(-1).appointment_type, '')
|
||||
assert.equal(calls.at(-1).patient_name, '')
|
||||
assert.equal(calls.at(-1).page_no, 1)
|
||||
await Promise.resolve()
|
||||
})
|
||||
|
||||
test('updated filter template compiles with existing page bindings', () => {
|
||||
assert.deepEqual(compileTemplate({ source: descriptor.template.content, filename: pageFile, id: 'appointment-type-filter', compilerOptions: { bindingMetadata: script.bindings } }).errors, [])
|
||||
})
|
||||
@@ -0,0 +1,89 @@
|
||||
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 source = fs.readFileSync(path.join(__dirname, '../src/utils/im-chat-archive-trigger.ts'), 'utf8')
|
||||
const compiled = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS } }).outputText
|
||||
const mod = { exports: {} }
|
||||
new Function('module', 'exports', compiled)(mod, mod.exports)
|
||||
const { createImChatArchiveTrigger } = mod.exports
|
||||
const deferred = () => {
|
||||
let resolve, reject
|
||||
const promise = new Promise((a, b) => { resolve = a; reject = b })
|
||||
return { promise, resolve, reject }
|
||||
}
|
||||
|
||||
test('all pages use server-owned current-doctor scope and carry the continuation token', async () => {
|
||||
const calls = []
|
||||
const sync = createImChatArchiveTrigger(async params => {
|
||||
calls.push(params)
|
||||
return { completed: calls.length === 3, sync_token: 'next-page' }
|
||||
})
|
||||
await sync(12116)
|
||||
assert.deepEqual(calls, [
|
||||
{ diagnosis_id: 12116, scope: 'current', sync_token: undefined },
|
||||
{ diagnosis_id: 12116, scope: 'current', sync_token: 'next-page' },
|
||||
{ diagnosis_id: 12116, scope: 'current', sync_token: 'next-page' }
|
||||
])
|
||||
})
|
||||
|
||||
test('many events while syncing coalesce, then perform one catch-up scan for new messages', async () => {
|
||||
const page = deferred()
|
||||
let calls = 0
|
||||
const sync = createImChatArchiveTrigger(() => {
|
||||
calls++
|
||||
return calls === 1 ? page.promise : Promise.resolve({ completed: true })
|
||||
})
|
||||
const first = sync(10)
|
||||
assert.equal(sync(10), first)
|
||||
assert.equal(sync(10), first)
|
||||
assert.equal(calls, 1)
|
||||
page.resolve({ completed: true })
|
||||
await first
|
||||
assert.equal(calls, 2)
|
||||
await sync(10)
|
||||
assert.equal(calls, 3)
|
||||
})
|
||||
|
||||
test('switching patients keeps in-flight requests bound to their original diagnosis', async () => {
|
||||
const old = deferred(), calls = []
|
||||
const sync = createImChatArchiveTrigger(params => {
|
||||
calls.push(params)
|
||||
if (params.diagnosis_id === 10 && !params.sync_token) return old.promise
|
||||
return Promise.resolve({ completed: true })
|
||||
})
|
||||
const first = sync(10)
|
||||
await sync(20)
|
||||
old.resolve({ completed: false, sync_token: 'old-patient' })
|
||||
await first
|
||||
assert.deepEqual(calls.map(p => [p.diagnosis_id, p.sync_token]), [[10, undefined], [20, undefined], [10, 'old-patient']])
|
||||
})
|
||||
|
||||
test('partial failure and network failure are reported and do not poison later retries', async () => {
|
||||
const warnings = []
|
||||
let count = 0
|
||||
const sync = createImChatArchiveTrigger(async () => {
|
||||
count++
|
||||
if (count === 1) return { completed: true, errors: ['cloud unavailable'] }
|
||||
if (count === 2) throw new Error('request timeout')
|
||||
return { completed: true }
|
||||
}, error => warnings.push(error.message))
|
||||
await sync(10)
|
||||
await sync(10)
|
||||
await sync(10)
|
||||
assert.deepEqual(warnings, ['cloud unavailable', 'request timeout'])
|
||||
assert.equal(count, 3)
|
||||
})
|
||||
|
||||
test('invalid IDs never request and missing progress stops a malformed response loop', async () => {
|
||||
const warnings = []
|
||||
let count = 0
|
||||
const sync = createImChatArchiveTrigger(async () => { count++; return { completed: false } }, error => warnings.push(error.message))
|
||||
for (const id of [0, -1, NaN, 1.5]) await sync(id)
|
||||
assert.equal(count, 0)
|
||||
await sync(10)
|
||||
assert.equal(count, 1)
|
||||
assert.match(warnings[0], /未返回进度/)
|
||||
})
|
||||
@@ -0,0 +1,392 @@
|
||||
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 { parse, compileScript, compileTemplate, compileStyle } = require('@vue/compiler-sfc')
|
||||
|
||||
function loadTs(filename, dependencies = require) {
|
||||
const source = fs.readFileSync(filename, 'utf8')
|
||||
const compiled = ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS } }).outputText
|
||||
const module = { exports: {} }
|
||||
new Function('require', 'module', 'exports', compiled)(dependencies, module, module.exports)
|
||||
return module.exports
|
||||
}
|
||||
|
||||
const { createImChatHistory } = loadTs(path.join(__dirname, '../src/utils/im-chat-history.ts'))
|
||||
const archive = (id, text = '已归档消息') => ({ lists: [{ msg_id: id, text }], patient_im_id: `patient_${id}`, patient_name: `患者${id}` })
|
||||
const progress = (completed, extra = {}) => ({ completed, sync_token: 'session-token', inserted: 2, processed_peers: 1, total_peers: 2, ...extra })
|
||||
const deferred = () => {
|
||||
let resolve, reject
|
||||
const promise = new Promise((yes, no) => { resolve = yes; reject = no })
|
||||
return { promise, resolve, reject }
|
||||
}
|
||||
const settle = async () => { for (let i = 0; i < 50; i++) await Promise.resolve() }
|
||||
|
||||
function fixture(overrides = {}) {
|
||||
let time = 100000, nextTimer = 0
|
||||
const timers = new Map(), calls = [], notices = []
|
||||
const controller = createImChatHistory({
|
||||
load: async (id) => { calls.push(['load', id]); return overrides.load ? overrides.load(id) : archive(id) },
|
||||
sync: async (id, token) => { calls.push(['sync', id, token]); return overrides.sync ? overrides.sync(id, token) : progress(true) },
|
||||
notify: (kind, message) => notices.push({ kind, message }),
|
||||
now: () => time,
|
||||
setTimer: (callback, delay) => { const id = ++nextTimer; timers.set(id, { callback, at: time + delay }); return id },
|
||||
clearTimer: (id) => timers.delete(id),
|
||||
visible: overrides.visible
|
||||
})
|
||||
return {
|
||||
controller, state: controller.state, calls, notices, timers,
|
||||
setTime(value) { time = value },
|
||||
advance(ms) {
|
||||
time += ms
|
||||
for (const [id, timer] of [...timers]) {
|
||||
if (timer.at <= time) { timers.delete(id); timer.callback() }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
test('archive appears immediately while automatic cloud sync is pending, then refreshes on completion', async () => {
|
||||
const pending = deferred()
|
||||
let reads = 0
|
||||
const f = fixture({ load: async () => archive(++reads), sync: () => pending.promise })
|
||||
f.controller.setDiagnosis(10)
|
||||
await settle()
|
||||
assert.equal(f.state.rows[0].msg_id, 1)
|
||||
assert.equal(f.state.syncing, true)
|
||||
assert.equal(f.state.loading, false)
|
||||
assert.equal(f.timers.size, 0)
|
||||
pending.resolve(progress(true))
|
||||
await settle()
|
||||
assert.equal(f.state.rows[0].msg_id, 2)
|
||||
assert.equal(f.state.syncing, false)
|
||||
assert.equal(f.timers.size, 1)
|
||||
assert.deepEqual(f.notices, [])
|
||||
f.controller.dispose()
|
||||
})
|
||||
|
||||
test('account verification progress and skipped staff are displayed separately from sync failures', async () => {
|
||||
const checked = deferred(), finished = deferred()
|
||||
let step = 0
|
||||
const f = fixture({ sync: async () => {
|
||||
step++
|
||||
if (step === 1) return progress(false, { phase: 'checking_accounts', checked_accounts: 100, candidate_accounts: 185, skipped_accounts: 98 })
|
||||
if (step === 2) return checked.promise
|
||||
return finished.promise
|
||||
} })
|
||||
f.controller.setDiagnosis(1)
|
||||
await settle()
|
||||
assert.equal(f.state.phase, 'checking_accounts')
|
||||
assert.equal(f.state.checkedAccounts, 100)
|
||||
assert.equal(f.state.candidateAccounts, 185)
|
||||
assert.deepEqual(f.state.partialErrors, [])
|
||||
checked.resolve(progress(false, { phase: 'syncing', checked_accounts: 185, candidate_accounts: 185, skipped_accounts: 183, total_peers: 1 }))
|
||||
await settle()
|
||||
assert.equal(f.state.totalPeers, 1)
|
||||
assert.equal(f.state.skippedAccounts, 183)
|
||||
finished.resolve(progress(true, { phase: 'completed', skipped_accounts: 183, total_peers: 1 }))
|
||||
await settle()
|
||||
assert.equal(f.state.syncError, '')
|
||||
assert.deepEqual(f.state.partialErrors, [])
|
||||
f.controller.setDiagnosis(2)
|
||||
assert.equal(f.state.skippedAccounts, 0)
|
||||
f.controller.dispose()
|
||||
})
|
||||
|
||||
test('completion waits for initial archive read and starts a fresh read after it', async () => {
|
||||
const initial = deferred()
|
||||
let reads = 0
|
||||
const f = fixture({ load: () => ++reads === 1 ? initial.promise : Promise.resolve(archive(2)) })
|
||||
f.controller.setDiagnosis(10)
|
||||
await settle()
|
||||
assert.equal(reads, 1)
|
||||
initial.resolve(archive(1))
|
||||
await settle()
|
||||
assert.equal(reads, 2)
|
||||
assert.equal(f.state.rows[0].msg_id, 2)
|
||||
assert.equal(f.timers.size, 1)
|
||||
f.controller.dispose()
|
||||
})
|
||||
|
||||
test('sync tokens continue across pages and archive refreshes every three pages and on completion', async () => {
|
||||
const lastPage = deferred()
|
||||
let pages = 0, reads = 0
|
||||
const f = fixture({
|
||||
load: async () => archive(++reads),
|
||||
sync: async () => ++pages < 4 ? progress(false, { sync_token: `token-${pages}`, inserted: pages }) : lastPage.promise
|
||||
})
|
||||
f.controller.setDiagnosis(10)
|
||||
await settle()
|
||||
assert.equal(pages, 4)
|
||||
assert.equal(reads, 2)
|
||||
assert.deepEqual(f.calls.filter(call => call[0] === 'sync').map(call => call[2]), [undefined, 'token-1', 'token-2', 'token-3'])
|
||||
assert.equal(f.state.inserted, 3)
|
||||
lastPage.resolve(progress(true, { inserted: 4, processed_peers: 2 }))
|
||||
await settle()
|
||||
assert.equal(reads, 3)
|
||||
assert.equal(f.state.inserted, 4)
|
||||
f.controller.dispose()
|
||||
})
|
||||
|
||||
test('a slow page refreshes archive after two seconds even before three pages', async () => {
|
||||
const lastPage = deferred()
|
||||
let pages = 0, reads = 0
|
||||
const f = fixture({
|
||||
load: async () => archive(++reads),
|
||||
sync: async () => {
|
||||
if (++pages === 1) { f.setTime(102100); return progress(false) }
|
||||
return lastPage.promise
|
||||
}
|
||||
})
|
||||
f.controller.setDiagnosis(10)
|
||||
await settle()
|
||||
assert.equal(reads, 2)
|
||||
assert.equal(f.state.syncing, true)
|
||||
f.controller.dispose()
|
||||
lastPage.resolve(progress(true))
|
||||
await settle()
|
||||
})
|
||||
|
||||
test('switching diagnosis ignores old archive, old sync errors, and old completion timers', async () => {
|
||||
const oldRead = deferred(), oldSync = deferred()
|
||||
const f = fixture({ load: (id) => id === 1 ? oldRead.promise : Promise.resolve(archive(id)), sync: (id) => id === 1 ? oldSync.promise : Promise.resolve(progress(true)) })
|
||||
f.controller.setDiagnosis(1)
|
||||
await settle()
|
||||
f.controller.setDiagnosis(2)
|
||||
await settle()
|
||||
oldRead.resolve(archive(1))
|
||||
oldSync.reject(new Error('旧患者同步失败'))
|
||||
await settle()
|
||||
assert.equal(f.state.patientName, '患者2')
|
||||
assert.equal(f.state.rows[0].msg_id, 2)
|
||||
assert.equal(f.state.syncError, '')
|
||||
assert.equal(f.timers.size, 1)
|
||||
assert.equal(f.calls.filter(call => call[0] === 'load' && call[1] === 1).length, 1)
|
||||
f.controller.dispose()
|
||||
})
|
||||
|
||||
test('dispose invalidates in-flight requests and never refreshes or schedules after completion', async () => {
|
||||
const pending = deferred()
|
||||
const f = fixture({ sync: () => pending.promise })
|
||||
f.controller.setDiagnosis(1)
|
||||
await settle()
|
||||
const before = f.calls.length
|
||||
f.controller.dispose()
|
||||
pending.resolve(progress(true))
|
||||
await settle()
|
||||
assert.equal(f.calls.length, before)
|
||||
assert.equal(f.timers.size, 0)
|
||||
assert.equal(f.state.syncing, false)
|
||||
f.controller.setVisible(true)
|
||||
f.controller.setDiagnosis(2)
|
||||
assert.equal(f.calls.length, before)
|
||||
})
|
||||
|
||||
test('read and sync failures preserve existing rows and expose the original errors', async () => {
|
||||
let readFails = false, syncFails = false
|
||||
const f = fixture({
|
||||
load: async () => { if (readFails) throw { response: { data: { msg: '归档服务读取失败' } } }; return archive(1) },
|
||||
sync: async () => { if (syncFails) throw new Error('腾讯云凭证无效'); return progress(true) }
|
||||
})
|
||||
f.controller.setDiagnosis(1)
|
||||
await settle()
|
||||
readFails = true
|
||||
await f.controller.reload()
|
||||
assert.equal(f.state.rows[0].msg_id, 1)
|
||||
assert.equal(f.state.readError, '归档服务读取失败')
|
||||
syncFails = true
|
||||
await f.controller.sync()
|
||||
assert.equal(f.state.rows[0].msg_id, 1)
|
||||
assert.equal(f.state.syncError, '腾讯云凭证无效')
|
||||
assert.deepEqual(f.notices, [{ kind: 'error', message: '腾讯云凭证无效' }])
|
||||
assert.equal(f.timers.size, 1)
|
||||
f.controller.dispose()
|
||||
})
|
||||
|
||||
test('only a manual completed sync emits success; concurrent clicks share the in-flight run', async () => {
|
||||
let pending
|
||||
const f = fixture({ sync: () => pending ? pending.promise : Promise.resolve(progress(true)) })
|
||||
f.controller.setDiagnosis(1)
|
||||
await settle()
|
||||
assert.deepEqual(f.notices, [])
|
||||
pending = deferred()
|
||||
const manual = f.controller.sync()
|
||||
const duplicate = f.controller.sync()
|
||||
await settle()
|
||||
assert.equal(f.calls.filter(call => call[0] === 'sync').length, 2)
|
||||
assert.deepEqual(f.notices, [])
|
||||
pending.resolve(progress(true, { inserted: 7 }))
|
||||
await Promise.all([manual, duplicate])
|
||||
assert.deepEqual(f.notices, [{ kind: 'success', message: '聊天记录已更新，本次新增 7 条' }])
|
||||
assert.equal(f.timers.size, 1)
|
||||
f.controller.dispose()
|
||||
})
|
||||
|
||||
test('completed partial failure refreshes rows, ends the loop, and never reports full success', async () => {
|
||||
let partial = false, reads = 0
|
||||
const f = fixture({ load: async () => archive(++reads), sync: async () => progress(true, partial ? { error: '医生账号失败', errors: ['医生账号失败', '医助账号失败'] } : {}) })
|
||||
f.controller.setDiagnosis(1)
|
||||
await settle()
|
||||
partial = true
|
||||
await f.controller.sync()
|
||||
assert.deepEqual([...f.state.partialErrors], ['医生账号失败', '医助账号失败'])
|
||||
assert.equal(f.state.rows[0].msg_id, 3)
|
||||
assert.equal(f.state.syncing, false)
|
||||
assert.equal(f.notices.length, 1)
|
||||
assert.equal(f.notices[0].kind, 'warning')
|
||||
assert.match(f.notices[0].message, /医生账号失败；医助账号失败/)
|
||||
f.controller.dispose()
|
||||
})
|
||||
|
||||
test('missing token and missing completed state stop safely without claiming success', async () => {
|
||||
for (const response of [{ completed: false }, { inserted: 0 }]) {
|
||||
const f = fixture({ sync: async () => response })
|
||||
f.controller.setDiagnosis(1)
|
||||
await settle()
|
||||
assert.equal(f.calls.filter(call => call[0] === 'sync').length, 1)
|
||||
assert.match(f.state.syncError, /同步接口未返回/)
|
||||
assert.equal(f.state.rows[0].msg_id, 1)
|
||||
assert.equal(f.notices.length, 0)
|
||||
f.controller.dispose()
|
||||
}
|
||||
})
|
||||
|
||||
test('one 30-second timer starts only after completion and never overlaps a pending run', async () => {
|
||||
let pending
|
||||
const f = fixture({ sync: () => pending ? pending.promise : Promise.resolve(progress(true)) })
|
||||
f.controller.setDiagnosis(1)
|
||||
await settle()
|
||||
f.advance(29999)
|
||||
await settle()
|
||||
assert.equal(f.calls.filter(call => call[0] === 'sync').length, 1)
|
||||
pending = deferred()
|
||||
f.advance(1)
|
||||
await settle()
|
||||
assert.equal(f.calls.filter(call => call[0] === 'sync').length, 2)
|
||||
assert.equal(f.timers.size, 0)
|
||||
f.advance(90000)
|
||||
await settle()
|
||||
assert.equal(f.calls.filter(call => call[0] === 'sync').length, 2)
|
||||
pending.resolve(progress(true))
|
||||
await settle()
|
||||
assert.equal(f.timers.size, 1)
|
||||
f.controller.dispose()
|
||||
assert.equal(f.timers.size, 0)
|
||||
})
|
||||
|
||||
test('hidden or deactivated panels stop scheduling and resume with existing rows retained', async () => {
|
||||
const f = fixture({ visible: false })
|
||||
f.controller.setDiagnosis(1)
|
||||
await settle()
|
||||
assert.deepEqual(f.calls, [])
|
||||
f.controller.setVisible(true)
|
||||
await settle()
|
||||
assert.equal(f.state.rows[0].msg_id, 1)
|
||||
f.controller.setVisible(false)
|
||||
assert.equal(f.timers.size, 0)
|
||||
const before = f.calls.length
|
||||
f.advance(60000)
|
||||
await settle()
|
||||
assert.equal(f.calls.length, before)
|
||||
f.controller.setVisible(true)
|
||||
assert.equal(f.state.rows[0].msg_id, 1)
|
||||
await settle()
|
||||
assert.equal(f.timers.size, 1)
|
||||
f.controller.dispose()
|
||||
})
|
||||
|
||||
test('IM API functions retain raw backend reasons, send progress tokens, and disable retries', async () => {
|
||||
const calls = []
|
||||
let reply = { code: 1, data: progress(true), msg: '不应自动显示的成功提示', show: 1 }
|
||||
const request = {}
|
||||
for (const method of ['get', 'post']) request[method] = async (config, options) => { calls.push({ method, config, options }); return reply }
|
||||
const api = loadTs(path.join(__dirname, '../src/api/tcm.ts'), (name) => {
|
||||
if (name === '@/utils/request') return { default: request }
|
||||
throw new Error(`Unexpected import: ${name}`)
|
||||
})
|
||||
assert.equal((await api.triggerImChatSync({ diagnosis_id: 2, sync_token: 'resume' })).completed, true)
|
||||
reply = { code: 1, data: archive(2) }
|
||||
assert.equal((await api.getImChatMessages({ diagnosis_id: 2, only_archived: 1 })).lists[0].msg_id, 2)
|
||||
assert.deepEqual(calls[0].config.data, { diagnosis_id: 2, sync_token: 'resume' })
|
||||
for (const call of calls) {
|
||||
assert.equal(call.config.timeout, 30000)
|
||||
assert.deepEqual(call.options, { isTransformResponse: false, ignoreCancelToken: true, isOpenRetry: false, retryCount: 0 })
|
||||
}
|
||||
reply = { code: 0, data: [], msg: '腾讯云错误：签名校验失败' }
|
||||
await assert.rejects(api.triggerImChatSync({ diagnosis_id: 2 }), /腾讯云错误：签名校验失败/)
|
||||
})
|
||||
|
||||
test('chat panel script, template, and scoped styles compile', () => {
|
||||
const filename = path.join(__dirname, '../src/views/tcm/diagnosis/components/ImChatRecordPanel.vue')
|
||||
const { descriptor, errors } = parse(fs.readFileSync(filename, 'utf8'), { filename })
|
||||
assert.deepEqual(errors, [])
|
||||
const script = compileScript(descriptor, { id: 'im-chat-history' })
|
||||
assert.deepEqual(compileTemplate({ source: descriptor.template.content, filename, id: 'im-chat-history', compilerOptions: { bindingMetadata: script.bindings } }).errors, [])
|
||||
assert.deepEqual(compileStyle({ source: descriptor.styles[0].content, filename, id: 'im-chat-history', scoped: true, preprocessLang: 'scss' }).errors, [])
|
||||
})
|
||||
|
||||
test('actual panel setup wires archived reads, continued sync, patient switches, and lifecycle cleanup', async () => {
|
||||
const vue = require('vue')
|
||||
const hooks = {}, listeners = new Map(), timers = new Map(), apiCalls = []
|
||||
const pending = deferred()
|
||||
let timerId = 0
|
||||
const originalDocument = global.document
|
||||
global.document = {
|
||||
visibilityState: 'visible',
|
||||
addEventListener: (name, callback) => listeners.set(name, callback),
|
||||
removeEventListener: (name) => listeners.delete(name)
|
||||
}
|
||||
const scope = vue.effectScope()
|
||||
try {
|
||||
const filename = path.join(__dirname, '../src/views/tcm/diagnosis/components/ImChatRecordPanel.vue')
|
||||
const { descriptor } = parse(fs.readFileSync(filename, 'utf8'), { filename })
|
||||
const script = compileScript(descriptor, { id: 'im-chat-panel-setup' })
|
||||
const compiled = ts.transpileModule(script.content, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
|
||||
const module = { exports: {} }
|
||||
new Function('require', 'module', 'exports', compiled)((name) => {
|
||||
if (name === 'vue') return { ...vue, ...Object.fromEntries(['onMounted', 'onBeforeUnmount', 'onActivated', 'onDeactivated'].map(hook => [hook, callback => { hooks[hook] = callback }])) }
|
||||
if (name === 'dayjs') return { default: require('dayjs') }
|
||||
if (name === '@element-plus/icons-vue') return {}
|
||||
if (name === 'element-plus') return { ElMessage: { success() {}, warning() {}, error() {} } }
|
||||
if (name === '@/utils/im-business-message-parse') return { parseImBusinessPayload: () => null }
|
||||
if (name === '@/utils/im-chat-history') return { createImChatHistory: (deps) => createImChatHistory({ ...deps, setTimer: callback => { const id = ++timerId; timers.set(id, callback); return id }, clearTimer: id => timers.delete(id) }) }
|
||||
if (name === '@/api/tcm') return {
|
||||
getImChatMessages: async params => { apiCalls.push(['read', params]); return archive(params.diagnosis_id) },
|
||||
triggerImChatSync: async params => { apiCalls.push(['sync', params]); return params.diagnosis_id === 1 ? pending.promise : progress(true) }
|
||||
}
|
||||
throw new Error(`Unexpected panel import: ${name}`)
|
||||
}, module, module.exports)
|
||||
const props = vue.reactive({ diagnosisId: 1 })
|
||||
const panel = scope.run(() => module.exports.default.setup(props, { expose() {} }))
|
||||
hooks.onMounted()
|
||||
await settle()
|
||||
assert.equal(panel.rows.value[0].raw.msg_id, 1)
|
||||
assert.deepEqual(apiCalls[0], ['read', { diagnosis_id: 1, only_archived: 1 }])
|
||||
assert.deepEqual(apiCalls[1], ['sync', { diagnosis_id: 1 }])
|
||||
props.diagnosisId = 2
|
||||
await settle()
|
||||
assert.equal(panel.rows.value[0].raw.msg_id, 2)
|
||||
pending.resolve(progress(true))
|
||||
await settle()
|
||||
assert.equal(panel.rows.value[0].raw.msg_id, 2)
|
||||
assert.equal(timers.size, 1)
|
||||
panel.history.rows = [{
|
||||
msg_id: 'multi-part', msg_type: 'composite', from_account: 'doctor_20', to_account: 'patient_2', time: 1700000000,
|
||||
parts: [{ msg_type: 'text', text: '第一段' }, { msg_type: 'image', image_url: 'https://example.invalid/chat.png' }, { msg_type: 'text', text: '第三段' }]
|
||||
}]
|
||||
assert.deepEqual(panel.rows.value.map(item => [item.raw.msg_id, item.raw.msg_type]), [
|
||||
['multi-part:0', 'text'], ['multi-part:1', 'image'], ['multi-part:2', 'text']
|
||||
])
|
||||
assert.equal(panel.rows.value[2].raw.text, '第三段')
|
||||
assert.ok(panel.rows.value.every(item => item.raw.to_account === 'patient_2'))
|
||||
global.document.visibilityState = 'hidden'
|
||||
listeners.get('visibilitychange')()
|
||||
assert.equal(timers.size, 0)
|
||||
hooks.onBeforeUnmount()
|
||||
assert.equal(listeners.size, 0)
|
||||
} finally {
|
||||
scope.stop()
|
||||
global.document = originalDocument
|
||||
}
|
||||
})
|
||||
Reference in New Issue
Block a user