2260 lines
77 KiB
JavaScript
2260 lines
77 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, compileStyle } = require('@vue/compiler-sfc')
|
|
const base = path.join(__dirname, '../src/views/assistant_service')
|
|
const compile = (source) =>
|
|
ts.transpileModule(source, {
|
|
compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS }
|
|
}).outputText
|
|
function evaluate(source, dependencies = require) {
|
|
const module = { exports: {} }
|
|
new Function('require', 'module', 'exports', compile(source))(
|
|
dependencies,
|
|
module,
|
|
module.exports
|
|
)
|
|
return module.exports
|
|
}
|
|
const shared = evaluate(fs.readFileSync(path.join(base, 'shared.ts'), 'utf8'))
|
|
const { createJobTracker } = evaluate(
|
|
fs.readFileSync(path.join(base, 'workbench/jobTracker.ts'), 'utf8'),
|
|
(name) => (name === 'vue' ? vue : shared)
|
|
)
|
|
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()
|
|
}
|
|
const job = (id, diagnosis = 1, status = 'queued', type = 'analysis') => ({
|
|
id,
|
|
subject_admin_id: 8,
|
|
diagnosis_id: diagnosis,
|
|
status,
|
|
type,
|
|
version: 1,
|
|
scenario: 'followup',
|
|
stale: false,
|
|
created_at: 1700000000,
|
|
updated_at: 1700000000,
|
|
error_code: '',
|
|
error_message: '',
|
|
coverage: [],
|
|
sources: [],
|
|
reviews: [],
|
|
result: null
|
|
})
|
|
const analysis = () => ({
|
|
summary: [],
|
|
needs: [],
|
|
unresolved: [],
|
|
tags: [],
|
|
suggested_actions: [],
|
|
quality_checks: []
|
|
})
|
|
const capabilities = {
|
|
enabled: true,
|
|
ready: true,
|
|
schema_ready: true,
|
|
reason: '',
|
|
permissions: [
|
|
'view',
|
|
'analyze',
|
|
'draftReply',
|
|
'record',
|
|
'adoptAction',
|
|
'completeAction',
|
|
'reviewQuality',
|
|
'manageKnowledge'
|
|
],
|
|
scenarios: [{ value: 'followup', label: '随访' }],
|
|
limits: { max_manual_chars: 10000, max_source_chars: 30000 }
|
|
}
|
|
const context = (id, subject = 8) => ({
|
|
subject_admin_id: subject,
|
|
patient: { diagnosis_id: id, patient_id: id, patient_name: `合成患者${id}`, assistant_id: 8 },
|
|
sources: [
|
|
{
|
|
id: `manual:${id}`,
|
|
text: '合成来源',
|
|
channel: 'manual',
|
|
speaker: 'unknown',
|
|
actor_admin_id: 0,
|
|
quality_eligible: false,
|
|
occurred_at: 1700000000
|
|
}
|
|
],
|
|
coverage: [],
|
|
latest_job: null,
|
|
latest_analysis_job: null,
|
|
days: 30
|
|
})
|
|
const page = (rows) => ({ lists: rows, count: rows.length, page_no: 1, page_size: 10 })
|
|
function trackerFixture(read) {
|
|
let time = 0,
|
|
id = 0
|
|
const timers = new Map()
|
|
const tracker = createJobTracker({
|
|
read,
|
|
now: () => time,
|
|
setTimer: (fn) => {
|
|
timers.set(++id, fn)
|
|
return id
|
|
},
|
|
clearTimer: (id) => timers.delete(id)
|
|
})
|
|
return {
|
|
tracker,
|
|
timers,
|
|
advance(ms) {
|
|
time += ms
|
|
const callbacks = [...timers.values()]
|
|
timers.clear()
|
|
callbacks.forEach((fn) => fn())
|
|
}
|
|
}
|
|
}
|
|
function setup(relative, props = {}, api = {}, extra = {}) {
|
|
const hooks = {},
|
|
calls = [],
|
|
events = [],
|
|
scope = vue.effectScope()
|
|
const filename = path.join(base, relative)
|
|
const { descriptor } = parse(fs.readFileSync(filename, 'utf8'), { filename })
|
|
const compiled = compileScript(descriptor, { id: relative })
|
|
const component = evaluate(compiled.content, (name) => {
|
|
if (name === 'vue')
|
|
return {
|
|
...vue,
|
|
useModel: (props, key) => vue.ref(props[key]),
|
|
...Object.fromEntries(
|
|
['onMounted', 'onBeforeUnmount', 'onActivated', 'onDeactivated'].map((hook) => [
|
|
hook,
|
|
(fn) => {
|
|
hooks[hook] = fn
|
|
}
|
|
])
|
|
)
|
|
}
|
|
if (name === '@/api/assistantService') return api
|
|
if (name === '@/stores/modules/user') return { default: () => ({ userInfo: { id: 8 } }) }
|
|
if (name === '@/utils/feedback')
|
|
return {
|
|
default: {
|
|
msgSuccess: (message) => calls.push(['success', message]),
|
|
msgWarning: (message) => calls.push(['warning', message]),
|
|
msgError: (message) => calls.push(['error', message]),
|
|
confirm: async (message) => {
|
|
calls.push(['confirm', message])
|
|
return true
|
|
},
|
|
...extra.feedback
|
|
}
|
|
}
|
|
if (name === 'vue-clipboard3')
|
|
return {
|
|
default: () => ({
|
|
toClipboard: async (text) => {
|
|
calls.push(['copy', text])
|
|
}
|
|
})
|
|
}
|
|
if (name.endsWith('/shared') || name === '../shared') return shared
|
|
if (name === './jobTracker' || name === '../workbench/jobTracker')
|
|
return { createJobTracker: extra.tracker || createJobTracker }
|
|
if (name.endsWith('.vue')) return { default: {} }
|
|
throw new Error(`Unexpected import ${name}`)
|
|
}).default
|
|
const reactiveProps = vue.reactive(props)
|
|
const panel = scope.run(() =>
|
|
component.setup(reactiveProps, { expose() {}, emit: (...args) => events.push(args) })
|
|
)
|
|
return {
|
|
panel,
|
|
props: reactiveProps,
|
|
hooks,
|
|
calls,
|
|
events,
|
|
dispose() {
|
|
hooks.onBeforeUnmount?.()
|
|
scope.stop()
|
|
}
|
|
}
|
|
}
|
|
|
|
test('all module SFC scripts, templates and scoped styles compile', () => {
|
|
const walk = (directory) =>
|
|
fs
|
|
.readdirSync(directory, { withFileTypes: true })
|
|
.flatMap((entry) =>
|
|
entry.isDirectory()
|
|
? walk(path.join(directory, entry.name))
|
|
: [path.join(directory, entry.name)]
|
|
)
|
|
for (const filename of walk(base).filter((name) => name.endsWith('.vue'))) {
|
|
const { descriptor, errors } = parse(fs.readFileSync(filename, 'utf8'), { filename })
|
|
assert.deepEqual(errors, [])
|
|
const script = compileScript(descriptor, { id: filename })
|
|
const template = compileTemplate({
|
|
source: descriptor.template.content,
|
|
filename,
|
|
id: filename,
|
|
compilerOptions: { bindingMetadata: script.bindings }
|
|
})
|
|
assert.deepEqual(template.errors, [], filename)
|
|
for (const style of descriptor.styles)
|
|
assert.deepEqual(
|
|
compileStyle({ source: style.content, filename, id: filename, scoped: true })
|
|
.errors,
|
|
[]
|
|
)
|
|
}
|
|
})
|
|
|
|
test('API retains error reason/code and disables automatic retries and URL cancellation for mutations', async () => {
|
|
const calls = []
|
|
let response = { code: 1, data: job(1) }
|
|
const request = Object.fromEntries(
|
|
['get', 'post'].map((method) => [
|
|
method,
|
|
async (config, options) => {
|
|
calls.push({ method, config, options })
|
|
return response
|
|
}
|
|
])
|
|
)
|
|
const api = evaluate(
|
|
fs.readFileSync(path.join(__dirname, '../src/api/assistantService.ts'), 'utf8'),
|
|
() => ({ default: request })
|
|
)
|
|
await api.assistantAnalyze({ diagnosis_id: 1, days: 30, scenario: 'followup' })
|
|
await api.assistantDraftReply({
|
|
diagnosis_id: 1,
|
|
days: 30,
|
|
scenario: 'followup',
|
|
question: '合成问题'
|
|
})
|
|
for (const call of calls) {
|
|
assert.equal(call.options.isOpenRetry, false)
|
|
assert.equal(call.options.ignoreCancelToken, true)
|
|
assert.equal(call.options.retryCount, 0)
|
|
assert.equal(call.config.timeout, 30000)
|
|
assert.equal(call.config.data.diagnosis_id, 1)
|
|
}
|
|
assert.equal(calls[0].config.url, '/tcm.assistantService/analyze')
|
|
response = {
|
|
code: 0,
|
|
msg: '服务知识版本已被更新，请刷新后重试',
|
|
data: { code: 'version_conflict' }
|
|
}
|
|
await assert.rejects(
|
|
api.assistantSaveKnowledge({
|
|
id: 1,
|
|
version: 1,
|
|
question: '问题',
|
|
answer: '答案',
|
|
category: '',
|
|
source_note: '核对'
|
|
}),
|
|
(error) => error.code === 'version_conflict' && error.message.includes('版本')
|
|
)
|
|
})
|
|
|
|
test('job tracker discards prior patient responses and disposes timers', async () => {
|
|
const old = deferred(),
|
|
f = trackerFixture((id) => (id === 1 ? old.promise : Promise.resolve(job(id, 2, 'ready'))))
|
|
f.tracker.setJob(job(1))
|
|
f.advance(3000)
|
|
await settle()
|
|
f.tracker.setJob(job(2, 2))
|
|
old.resolve(job(1, 1, 'ready'))
|
|
await settle()
|
|
assert.equal(f.tracker.state.job.id, 2)
|
|
f.advance(3000)
|
|
await settle()
|
|
assert.equal(f.tracker.state.job.status, 'ready')
|
|
assert.equal(f.timers.size, 0)
|
|
f.tracker.setJob(job(3))
|
|
assert.equal(f.timers.size, 1)
|
|
f.tracker.dispose()
|
|
assert.equal(f.timers.size, 0)
|
|
assert.equal(f.tracker.state.job, null)
|
|
})
|
|
|
|
test('poll timeout pauses reads; visibility pause and failed authorization hide actionable results', async () => {
|
|
let calls = 0,
|
|
fail = false
|
|
const f = trackerFixture(async (id) => {
|
|
calls++
|
|
if (fail) throw new Error('患者权限已撤销')
|
|
return job(id)
|
|
})
|
|
f.tracker.setJob(job(1))
|
|
f.advance(360000)
|
|
await settle()
|
|
assert.equal(calls, 1)
|
|
assert.equal(f.tracker.state.paused, true)
|
|
assert.match(f.tracker.state.error, /6 分钟/)
|
|
assert.equal(f.timers.size, 0)
|
|
f.tracker.setActive(false)
|
|
f.tracker.setActive(true)
|
|
await settle()
|
|
assert.equal(calls, 2)
|
|
f.tracker.setJob({ ...job(1, 1, 'ready'), result: analysis() })
|
|
fail = true
|
|
await f.tracker.refresh()
|
|
assert.equal(f.tracker.state.job.result, null)
|
|
assert.match(f.tracker.state.error, /权限已撤销/)
|
|
f.tracker.dispose()
|
|
})
|
|
|
|
test('actual case detail preserves stale context/submission protection and duplicate generation guard', async () => {
|
|
const originalDocument = global.document,
|
|
listeners = new Map(),
|
|
old = deferred(),
|
|
submit = deferred(),
|
|
submissions = []
|
|
global.document = {
|
|
visibilityState: 'visible',
|
|
addEventListener: (name, fn) => listeners.set(name, fn),
|
|
removeEventListener: (name) => listeners.delete(name)
|
|
}
|
|
const f = setup(
|
|
'components/CaseDetail.vue',
|
|
{ patient: context(1).patient, assistantId: 8, days: 30, capabilities },
|
|
{
|
|
assistantCapabilities: async () => capabilities,
|
|
assistantContext: async (params) =>
|
|
params.diagnosis_id === 1 ? old.promise : context(params.diagnosis_id),
|
|
assistantJobs: async () => page([]),
|
|
assistantJob: async (id) => job(id, 2, 'ready'),
|
|
assistantAnalyze: async (data) => {
|
|
submissions.push(data)
|
|
return submit.promise
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
f.panel.selectPatient(context(1).patient)
|
|
f.panel.selectPatient(context(2).patient)
|
|
await settle()
|
|
old.resolve(context(1))
|
|
await settle()
|
|
assert.equal(f.panel.context.value.patient.diagnosis_id, 2)
|
|
const first = f.panel.generate('analysis'),
|
|
duplicate = f.panel.generate('analysis')
|
|
await settle()
|
|
assert.equal(submissions.length, 1)
|
|
f.panel.selectPatient(context(3).patient)
|
|
await settle()
|
|
submit.resolve(job(10, 2, 'ready'))
|
|
await Promise.all([first, duplicate])
|
|
assert.equal(f.panel.analysisState.job, null)
|
|
assert.equal(f.panel.selected.value.diagnosis_id, 3)
|
|
} finally {
|
|
f.dispose()
|
|
assert.equal(listeners.size, 0)
|
|
global.document = originalDocument
|
|
}
|
|
})
|
|
|
|
test('actual record dialog requires explicit transcript confirmation and guards double submit', async () => {
|
|
const pending = deferred(),
|
|
calls = []
|
|
const f = setup(
|
|
'components/RecordDialog.vue',
|
|
{ diagnosisId: 2, maxChars: 10000, modelValue: true },
|
|
{
|
|
assistantRecord: async (data) => {
|
|
calls.push(data)
|
|
return pending.promise
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
f.panel.form.record_type = 'verified_transcript'
|
|
f.panel.form.content = '合成转写'
|
|
f.panel.occurredAt.value = new Date(Date.now() - 10000)
|
|
await f.panel.save()
|
|
assert.equal(calls.length, 0)
|
|
assert.match(f.panel.error.value, /确认/)
|
|
f.panel.form.speaker_confirmed = true
|
|
const first = f.panel.save()
|
|
await f.panel.save()
|
|
assert.equal(calls.length, 1)
|
|
assert.equal(calls[0].speaker_confirmed, true)
|
|
pending.resolve({ id: 5 })
|
|
await first
|
|
assert.equal(f.events[0][0], 'saved')
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('actual result component disables stale adoption/copy and locates generation snapshot evidence', async () => {
|
|
const evidence = context(1).sources[0],
|
|
calls = []
|
|
const item = { key: 'call', text: '合成跟进事项', evidence_ids: [evidence.id] }
|
|
const f = setup(
|
|
'components/JobResult.vue',
|
|
{
|
|
job: {
|
|
...job(1, 1, 'ready'),
|
|
sources: [evidence],
|
|
result: { ...analysis(), suggested_actions: [item] }
|
|
},
|
|
permissions: ['adoptAction'],
|
|
checking: false,
|
|
error: '',
|
|
disabled: false
|
|
},
|
|
{
|
|
assistantAdoptAction: async (data) => {
|
|
calls.push(data)
|
|
return { id: 9, todo_id: 10 }
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
f.panel.evidence([evidence.id])
|
|
assert.equal(f.events[0][1][0].text, '合成来源')
|
|
f.panel.openAdopt(item)
|
|
await f.panel.adopt()
|
|
assert.equal(calls.length, 0)
|
|
assert.match(f.panel.mutationError.value, /截止时间/)
|
|
f.panel.dueAt.value = new Date(Date.now() + 60000)
|
|
f.props.job.stale = true
|
|
await f.panel.adopt()
|
|
assert.equal(calls.length, 0)
|
|
f.props.job.stale = false
|
|
await f.panel.adopt()
|
|
assert.equal(calls.length, 1)
|
|
assert.equal(calls[0].version, 1)
|
|
assert.equal(calls[0].action_key, 'call')
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('actual service task component separates notification from completion and enforces owner/terminal notes', async () => {
|
|
const calls = [],
|
|
row = {
|
|
id: 1,
|
|
diagnosis_id: 2,
|
|
content: '合成跟进',
|
|
business_state: 'pending',
|
|
notification_status: 1,
|
|
assignee_id: 8,
|
|
due_at: 1900000000
|
|
}
|
|
const f = setup(
|
|
'components/ServiceActions.vue',
|
|
{ diagnosisId: 2, actorId: 8, canComplete: true, canReview: false, refreshKey: 0 },
|
|
{
|
|
assistantActions: async () => page([row]),
|
|
assistantCompleteAction: async (data) => {
|
|
calls.push(data)
|
|
return { id: 1 }
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
await settle()
|
|
assert.equal(f.panel.notificationLabel(1), '已发送')
|
|
assert.equal(f.panel.canUpdate(row), true)
|
|
assert.equal(f.panel.canUpdate({ ...row, assignee_id: 9 }), false)
|
|
assert.equal(f.panel.canUpdate({ ...row, business_state: 'completed' }), false)
|
|
f.panel.edit(row)
|
|
f.panel.nextState.value = 'completed'
|
|
await f.panel.save()
|
|
assert.equal(calls.length, 0)
|
|
f.panel.note.value = '已电话核对预约流程'
|
|
await f.panel.save()
|
|
assert.equal(calls[0].state, 'completed')
|
|
assert.equal(calls[0].note, '已电话核对预约流程')
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('knowledge conflict preserves local draft and reloads actual server version before publishing', async () => {
|
|
const row = {
|
|
id: 1,
|
|
version: 2,
|
|
question: '合成问题',
|
|
answer: '旧答案',
|
|
category: '测试',
|
|
source_note: '合成说明',
|
|
status: 'published',
|
|
updated_at: 1700000000
|
|
}
|
|
const latest = { ...row, version: 4, answer: '已更新答案', status: 'draft' },
|
|
writes = []
|
|
const f = setup(
|
|
'knowledge/index.vue',
|
|
{},
|
|
{
|
|
assistantCapabilities: async () => capabilities,
|
|
assistantKnowledge: async () => page([latest]),
|
|
assistantSaveKnowledge: async () => {
|
|
throw new Error('服务知识版本已被更新，请刷新后重试')
|
|
},
|
|
assistantPublishKnowledge: async (data) => {
|
|
writes.push(data)
|
|
return { id: 1, version: 5 }
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
await f.hooks.onMounted()
|
|
f.panel.openEditor(row)
|
|
f.panel.form.answer = '本地未保存答案'
|
|
await f.panel.saveDraft()
|
|
assert.equal(f.panel.conflicted.value, true)
|
|
assert.equal(f.panel.form.answer, '本地未保存答案')
|
|
assert.equal(f.panel.form.version, 2)
|
|
await f.panel.publish('published')
|
|
assert.equal(writes.length, 0)
|
|
await f.panel.copyLocal()
|
|
assert.ok(f.calls.some((call) => call[0] === 'copy' && call[1].includes('本地未保存答案')))
|
|
await f.panel.reloadLatest()
|
|
assert.equal(f.panel.form.version, 4)
|
|
assert.equal(f.panel.form.answer, '已更新答案')
|
|
assert.equal(f.panel.conflicted.value, false)
|
|
await f.panel.publish('published')
|
|
assert.deepEqual(writes[0], { id: 1, version: 4, status: 'published' })
|
|
assert.equal(f.panel.form.version, 5)
|
|
assert.ok(f.calls.some((call) => call[0] === 'confirm' && call[1].includes('发布后')))
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('actual reply editor copies edited draft and blocks copy after result becomes stale', async () => {
|
|
const f = setup('components/JobResult.vue', {
|
|
job: {
|
|
...job(7, 1, 'ready', 'reply'),
|
|
result: {
|
|
reply: '合成原始草稿',
|
|
evidence_ids: [],
|
|
knowledge_refs: [{ id: 1, version: 3 }],
|
|
needs_confirmation: true,
|
|
reason: '请核对适用条件'
|
|
}
|
|
},
|
|
permissions: ['view', 'draftReply'],
|
|
checking: false,
|
|
error: '',
|
|
disabled: false
|
|
})
|
|
try {
|
|
assert.equal(f.panel.draft.value, '合成原始草稿')
|
|
f.panel.draft.value = '人工核对后的合成草稿'
|
|
f.props.job = { ...f.props.job, result: { ...f.props.job.result } }
|
|
await settle()
|
|
assert.equal(f.panel.draft.value, '人工核对后的合成草稿')
|
|
await f.panel.copyDraft()
|
|
assert.equal(f.calls.filter((call) => call[0] === 'copy')[0][1], '人工核对后的合成草稿')
|
|
f.props.job.stale = true
|
|
await f.panel.copyDraft()
|
|
assert.equal(f.calls.filter((call) => call[0] === 'copy').length, 1)
|
|
assert.equal(f.events.length, 0)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('actual quality review requires a note and submits the original item key and version', async () => {
|
|
const calls = [],
|
|
item = {
|
|
key: 'needs',
|
|
label: '诉求核实',
|
|
status: 'insufficient',
|
|
reason: '说话人未核实',
|
|
evidence_ids: [],
|
|
actor_admin_id: 0
|
|
}
|
|
const f = setup(
|
|
'components/JobResult.vue',
|
|
{
|
|
job: { ...job(8, 1, 'ready'), result: { ...analysis(), quality_checks: [item] } },
|
|
permissions: ['reviewQuality'],
|
|
checking: false,
|
|
error: '',
|
|
disabled: false
|
|
},
|
|
{
|
|
assistantReviewQuality: async (data) => {
|
|
calls.push(data)
|
|
return { id: 2 }
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
f.panel.openReview(item)
|
|
await f.panel.review()
|
|
assert.equal(calls.length, 0)
|
|
f.panel.reviewNote.value = '经核对材料不足，维持不可评价'
|
|
f.panel.decision.value = 'confirmed'
|
|
f.props.job = { ...f.props.job, result: { ...f.props.job.result } }
|
|
await settle()
|
|
assert.equal(f.panel.reviewOpened.value, true)
|
|
assert.equal(f.panel.reviewNote.value, '经核对材料不足，维持不可评价')
|
|
assert.equal(f.panel.decision.value, 'confirmed')
|
|
await f.panel.review()
|
|
assert.deepEqual(calls[0], {
|
|
job_id: 8,
|
|
version: 1,
|
|
item_key: 'needs',
|
|
decision: 'confirmed',
|
|
note: '经核对材料不足，维持不可评价'
|
|
})
|
|
assert.ok(f.events.some((event) => event[0] === 'refresh'))
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
const staff = (id) => ({ id, name: `合成医助${id}`, is_self: id === 8 })
|
|
const staffCase = (id, subject = 8) => ({
|
|
...context(id, subject).patient,
|
|
im_messages: 3,
|
|
manual_records: 1,
|
|
last_activity_at: 1700000000
|
|
})
|
|
const overview = (id, days = 30) => ({
|
|
staff: staff(id),
|
|
days,
|
|
metrics: {
|
|
assigned_cases: id,
|
|
im_messages: 3,
|
|
manual_records: 1,
|
|
analyzed_cases: 1,
|
|
pending_actions: 2,
|
|
overdue_actions: 1,
|
|
completed_actions: 1
|
|
},
|
|
quality: [],
|
|
coverage_notes: []
|
|
})
|
|
const teamStaff = (id) => ({
|
|
staff: staff(id),
|
|
today_contact: dailyCounts(),
|
|
metrics: overview(id).metrics,
|
|
unreviewed_issues: 1,
|
|
last_analyzed_at: 1700000000,
|
|
analysis_state: 'ready',
|
|
queued_jobs: 0,
|
|
running_jobs: 0,
|
|
attention_jobs: 0
|
|
})
|
|
const teamOverview = (rows = [teamStaff(8), teamStaff(9)]) => ({
|
|
...page(rows),
|
|
page_size: 20,
|
|
days: 30,
|
|
daily: dailyMeta(),
|
|
daily_summary: dailyCounts({
|
|
required: 8,
|
|
contacted: 2,
|
|
pending: 4,
|
|
reported: 2,
|
|
outstanding: 6
|
|
}),
|
|
summary: {
|
|
staff_count: 26,
|
|
active_staff: 19,
|
|
analyzed_cases: 36,
|
|
unreviewed_issues: 5,
|
|
pending_actions: 8,
|
|
overdue_actions: 2,
|
|
queued_jobs: 0,
|
|
running_jobs: 0,
|
|
attention_jobs: 0
|
|
},
|
|
automation: {
|
|
enabled: true,
|
|
state: 'running',
|
|
last_scan_at: 1700000000,
|
|
next_scan_at: 1700000060,
|
|
interval_seconds: 60,
|
|
quiet_seconds: 300,
|
|
days: 30,
|
|
reason: ''
|
|
}
|
|
})
|
|
const dailyCounts = (overrides = {}) => ({
|
|
required: 4,
|
|
contacted: 1,
|
|
pending: 2,
|
|
reported: 1,
|
|
outstanding: 3,
|
|
exempt: 0,
|
|
state: 'pending',
|
|
...overrides
|
|
})
|
|
const dailyMeta = (overrides = {}) => ({
|
|
business_date: '2026-11-10',
|
|
timezone: 'Asia/Shanghai',
|
|
as_of: 1794268800,
|
|
state: 'ready',
|
|
reason: '',
|
|
last_scan_at: 1794268800,
|
|
rule_label: '到期复诊与明确需联系的服务跟进',
|
|
coverage: [{ source: 'im', status: 'available', note: '已归档文字' }],
|
|
...overrides
|
|
})
|
|
const dailyPatient = (id = 3, status = 'pending') => ({
|
|
key: `patient:${id}`,
|
|
patient_id: id,
|
|
patient_name: `合成患者${id}`,
|
|
diagnosis_id: id,
|
|
diagnosis_ids: [id, id + 100],
|
|
status,
|
|
reasons: [{ type: 'revisit', label: '复诊到期', due_at: 1794268800, source_id: id }],
|
|
last_contact_at: 0,
|
|
evidence: [],
|
|
exempt_reason: ''
|
|
})
|
|
const dailyContacts = (id = 9, overrides = {}) => ({
|
|
...page([dailyPatient()]),
|
|
staff: staff(id),
|
|
daily: dailyMeta(),
|
|
summary: dailyCounts(),
|
|
...overrides
|
|
})
|
|
function installTimers() {
|
|
const previousSet = global.setTimeout,
|
|
previousClear = global.clearTimeout,
|
|
timers = new Map()
|
|
let id = 0
|
|
global.setTimeout = (fn) => {
|
|
timers.set(++id, fn)
|
|
return id
|
|
}
|
|
global.clearTimeout = (value) => timers.delete(value)
|
|
const restore = () => {
|
|
global.setTimeout = previousSet
|
|
global.clearTimeout = previousClear
|
|
}
|
|
restore.timers = timers
|
|
return restore
|
|
}
|
|
function workspaceApi(overrides = {}) {
|
|
return {
|
|
assistantCapabilities: async () => capabilities,
|
|
assistantTeamOverview: async () => teamOverview(),
|
|
assistantStaff: async () => page([staff(8), staff(9)]),
|
|
assistantStaffOverview: async ({ assistant_id, days }) => overview(assistant_id, days),
|
|
assistantStaffDailyContacts: async ({ assistant_id }) => dailyContacts(assistant_id),
|
|
assistantStaffCases: async ({ assistant_id }) =>
|
|
page([staffCase(assistant_id, assistant_id)]),
|
|
assistantStaffIssues: async () => page([]),
|
|
assistantJobs: async () => page([]),
|
|
assistantJob: async (id) => ({ ...job(id, id, 'ready'), subject_admin_id: 8 }),
|
|
...overrides
|
|
}
|
|
}
|
|
function installDocument() {
|
|
const previous = global.document,
|
|
listeners = new Set()
|
|
global.document = {
|
|
visibilityState: 'visible',
|
|
addEventListener: (_, fn) => listeners.add(fn),
|
|
removeEventListener: (_, fn) => listeners.delete(fn)
|
|
}
|
|
return () => {
|
|
assert.equal(listeners.size, 0)
|
|
global.document = previous
|
|
}
|
|
}
|
|
|
|
test('staff APIs preserve explicit target scope and existing optional-target compatibility', async () => {
|
|
const calls = []
|
|
const request = Object.fromEntries(
|
|
['get', 'post'].map((method) => [
|
|
method,
|
|
async (config, options) => {
|
|
calls.push({ method, config, options })
|
|
return { code: 1, data: {} }
|
|
}
|
|
])
|
|
)
|
|
const api = evaluate(
|
|
fs.readFileSync(path.join(__dirname, '../src/api/assistantService.ts'), 'utf8'),
|
|
() => ({ default: request })
|
|
)
|
|
const scope = { assistant_id: 9, days: 7 }
|
|
await api.assistantStaff({ keyword: '医助', page_no: 1, page_size: 50 })
|
|
await api.assistantStaffOverview(scope)
|
|
await api.assistantStaffCases({ ...scope, page_no: 1, page_size: 10 })
|
|
await api.assistantStaffIssues({ ...scope, page_no: 1, page_size: 10 })
|
|
await api.assistantAnalyzeStaff({ ...scope, scenario: 'followup', diagnosis_ids: [3, 4] })
|
|
await api.assistantContext({ ...scope, diagnosis_id: 3 })
|
|
await api.assistantJobs({ assistant_id: 9, page_no: 1, page_size: 10 })
|
|
await api.assistantActions({ assistant_id: 9, page_no: 1, page_size: 10 })
|
|
await api.assistantActions({ diagnosis_id: 3, page_no: 1, page_size: 10 })
|
|
assert.deepEqual(
|
|
calls.map((call) => call.config.url.split('/').at(-1)),
|
|
[
|
|
'staff',
|
|
'staffOverview',
|
|
'staffCases',
|
|
'staffIssues',
|
|
'analyzeStaff',
|
|
'context',
|
|
'jobs',
|
|
'actions',
|
|
'actions'
|
|
]
|
|
)
|
|
for (const call of calls.slice(1, 8))
|
|
assert.equal((call.config.params || call.config.data).assistant_id, 9)
|
|
assert.deepEqual(calls[4].config.data.diagnosis_ids, [3, 4])
|
|
assert.equal(calls[4].options.isOpenRetry, false)
|
|
assert.equal(calls[8].config.params.assistant_id, undefined)
|
|
})
|
|
|
|
test('team API is a cancellable read and keeps search, filter and pagination explicit', async () => {
|
|
const calls = [],
|
|
signal = new AbortController().signal
|
|
const api = evaluate(
|
|
fs.readFileSync(path.join(__dirname, '../src/api/assistantService.ts'), 'utf8'),
|
|
() => ({
|
|
default: {
|
|
get: async (config, options) => {
|
|
calls.push({ config, options })
|
|
return { code: 1, data: teamOverview() }
|
|
}
|
|
}
|
|
})
|
|
)
|
|
const result = await api.assistantTeamOverview(
|
|
{ keyword: '医助', filter: 'attention', page_no: 2, page_size: 20 },
|
|
signal
|
|
)
|
|
assert.equal(calls[0].config.url, '/tcm.assistantService/teamOverview')
|
|
assert.equal(calls[0].config.signal, signal)
|
|
assert.equal(calls[0].options.isOpenRetry, false)
|
|
assert.deepEqual(calls[0].config.params, {
|
|
keyword: '医助',
|
|
filter: 'attention',
|
|
page_no: 2,
|
|
page_size: 20
|
|
})
|
|
assert.equal(result.summary.staff_count, 26)
|
|
assert.equal(result.lists.length, 2)
|
|
})
|
|
|
|
test('team overview reads authorized staff without selecting anyone or submitting analysis', async () => {
|
|
const restore = installDocument(),
|
|
requests = [],
|
|
writes = []
|
|
const f = setup(
|
|
'workbench/index.vue',
|
|
{},
|
|
workspaceApi({
|
|
assistantTeamOverview: async (params) => {
|
|
requests.push(params)
|
|
return teamOverview([teamStaff(9)])
|
|
},
|
|
assistantAnalyzeStaff: async (data) => writes.push(data),
|
|
assistantAnalyze: async (data) => writes.push(data)
|
|
})
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
assert.equal(f.panel.surface.value, 'alerts')
|
|
assert.equal(requests.length, 0)
|
|
await f.panel.setSurface('daily')
|
|
await settle()
|
|
assert.equal(f.panel.selectedStaff.value, null)
|
|
assert.equal(f.panel.drawerOpened.value, false)
|
|
assert.equal(f.panel.team.value.lists[0].staff.id, 9)
|
|
assert.deepEqual(requests[0], { keyword: '', filter: 'all', page_no: 1, page_size: 20 })
|
|
assert.equal(writes.length, 0)
|
|
f.panel.openStaff(teamStaff(8))
|
|
assert.equal(f.panel.drawerOpened.value, false)
|
|
f.panel.openStaff(f.panel.team.value.lists[0])
|
|
assert.equal(f.panel.selectedStaff.value.id, 9)
|
|
assert.equal(f.panel.drawerOpened.value, true)
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('team search and filter cancel older reads and never mix a late response into the current scope', async () => {
|
|
const restore = installDocument(),
|
|
old = deferred(),
|
|
signals = [],
|
|
requests = []
|
|
let count = 0
|
|
const f = setup(
|
|
'workbench/index.vue',
|
|
{},
|
|
workspaceApi({
|
|
assistantTeamOverview: async (params, signal) => {
|
|
signals.push(signal)
|
|
requests.push(params)
|
|
if (++count === 1) return old.promise
|
|
return teamOverview([teamStaff(9)])
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
f.panel.setSurface('daily')
|
|
f.panel.keyword.value = '医助九'
|
|
f.panel.search()
|
|
assert.equal(signals[0].aborted, true)
|
|
await settle()
|
|
f.panel.setFilter('issues')
|
|
await settle()
|
|
old.resolve(teamOverview([teamStaff(8)]))
|
|
await settle()
|
|
assert.equal(f.panel.team.value.lists[0].staff.id, 9)
|
|
assert.equal(f.panel.filter.value, 'issues')
|
|
assert.deepEqual(requests.at(-1), {
|
|
keyword: '医助九',
|
|
filter: 'issues',
|
|
page_no: 1,
|
|
page_size: 20
|
|
})
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('automatic refresh preserves search draft, filter, page and drawer, and pauses while hidden', async () => {
|
|
const restore = installDocument(),
|
|
restoreTimers = installTimers(),
|
|
requests = []
|
|
const f = setup(
|
|
'workbench/index.vue',
|
|
{},
|
|
workspaceApi({
|
|
assistantTeamOverview: async (params) => {
|
|
requests.push(params)
|
|
return teamOverview()
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
await f.panel.setSurface('daily')
|
|
await settle()
|
|
f.panel.setFilter('attention')
|
|
await settle()
|
|
f.panel.page.value = 3
|
|
f.panel.keyword.value = '未提交的搜索'
|
|
f.panel.openStaff(f.panel.team.value.lists[0])
|
|
const current = f.panel.selectedStaff.value.id
|
|
await f.panel.refreshResults()
|
|
assert.equal(f.panel.keyword.value, '未提交的搜索')
|
|
assert.equal(f.panel.page.value, 3)
|
|
assert.equal(f.panel.filter.value, 'attention')
|
|
assert.equal(f.panel.selectedStaff.value.id, current)
|
|
assert.equal(f.panel.drawerOpened.value, true)
|
|
assert.equal(requests.at(-1).keyword, '')
|
|
assert.equal(restoreTimers.timers.size, 1)
|
|
global.document.visibilityState = 'hidden'
|
|
f.panel.updateVisibility()
|
|
assert.equal(restoreTimers.timers.size, 0)
|
|
const before = requests.length
|
|
await f.panel.refreshResults()
|
|
assert.equal(requests.length, before)
|
|
global.document.visibilityState = 'visible'
|
|
f.panel.updateVisibility()
|
|
await settle()
|
|
assert.equal(requests.length, before + 1)
|
|
f.panel.drawerOpened.value = false
|
|
f.panel.drawerClosed()
|
|
assert.equal(f.panel.selectedStaff.value, null)
|
|
assert.equal(f.panel.page.value, 3)
|
|
assert.equal(f.panel.filter.value, 'attention')
|
|
} finally {
|
|
f.dispose()
|
|
assert.equal(restoreTimers.timers.size, 0)
|
|
restoreTimers()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('permission revalidation clears team and drawer before its response and denial hides old results', async () => {
|
|
const restore = installDocument(),
|
|
denied = deferred()
|
|
let deny = false
|
|
const f = setup(
|
|
'workbench/index.vue',
|
|
{},
|
|
workspaceApi({
|
|
assistantCapabilities: async () => (deny ? denied.promise : capabilities)
|
|
})
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
await f.panel.setSurface('daily')
|
|
await settle()
|
|
f.panel.openStaff(f.panel.team.value.lists[0])
|
|
deny = true
|
|
const recheck = f.panel.initialize()
|
|
assert.equal(f.panel.team.value, null)
|
|
assert.equal(f.panel.selectedStaff.value, null)
|
|
denied.resolve({ ...capabilities, permissions: [] })
|
|
await recheck
|
|
assert.equal(f.panel.can('view'), false)
|
|
assert.equal(f.panel.team.value, null)
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('staff drawer resets target immediately and discards all previous staff responses', async () => {
|
|
const waits = {},
|
|
signals = []
|
|
const read = (kind, params, signal) => {
|
|
signals.push(signal)
|
|
if (params.assistant_id === 8) {
|
|
waits[kind] = deferred()
|
|
return waits[kind].promise
|
|
}
|
|
if (kind === 'overview') return Promise.resolve(overview(9))
|
|
return Promise.resolve(
|
|
page(kind === 'cases' ? [staffCase(97, 9)] : [{ diagnosis_id: 97, reason: '当前问题' }])
|
|
)
|
|
}
|
|
const f = setup(
|
|
'components/StaffDetail.vue',
|
|
{ staff: staff(8), capabilities, refreshKey: 0 },
|
|
workspaceApi({
|
|
assistantStaffOverview: (params, signal) => read('overview', params, signal),
|
|
assistantStaffCases: (params, signal) => read('cases', params, signal),
|
|
assistantStaffIssues: (params, signal) => read('issues', params, signal)
|
|
})
|
|
)
|
|
try {
|
|
await settle()
|
|
f.panel.detail.value = { patient: context(1).patient }
|
|
f.props.staff = staff(9)
|
|
assert.equal(f.panel.overview.value, null)
|
|
assert.equal(f.panel.detail.value, null)
|
|
assert.equal(signals[0].aborted, true)
|
|
await settle()
|
|
for (const [kind, value] of Object.entries(waits))
|
|
value.resolve(kind === 'overview' ? overview(8) : page([staffCase(8)]))
|
|
await settle()
|
|
assert.equal(f.panel.overview.value.staff.id, 9)
|
|
assert.equal(f.panel.overview.value.days, 30)
|
|
assert.equal(f.panel.cases.value[0].diagnosis_id, 97)
|
|
assert.equal(f.panel.issues.value[0].reason, '当前问题')
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('staff drawer refresh preserves record navigation, search draft and both pagination positions', async () => {
|
|
const requests = []
|
|
const f = setup(
|
|
'components/StaffDetail.vue',
|
|
{ staff: staff(9), capabilities, refreshKey: 0 },
|
|
workspaceApi({
|
|
assistantStaffCases: async (params) => {
|
|
requests.push(params)
|
|
return page([staffCase(9)])
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
await settle()
|
|
f.panel.activeTab.value = 'cases'
|
|
f.panel.casesPage.value = 3
|
|
f.panel.issuesPage.value = 2
|
|
f.panel.caseKeyword.value = '正在编辑'
|
|
f.panel.openIssue({ job_id: 5, diagnosis_id: 9, patient_name: '核查患者' })
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(f.panel.detail.value.jobId, 5)
|
|
assert.equal(f.panel.activeTab.value, 'cases')
|
|
assert.equal(f.panel.casesPage.value, 3)
|
|
assert.equal(f.panel.issuesPage.value, 2)
|
|
assert.equal(f.panel.caseKeyword.value, '正在编辑')
|
|
assert.equal(requests.at(-1).keyword, '')
|
|
assert.equal(requests.at(-1).assistant_id, 9)
|
|
assert.equal(requests.at(-1).days, 30)
|
|
f.panel.closeDetail()
|
|
await settle()
|
|
assert.equal(f.panel.detail.value, null)
|
|
assert.equal(f.panel.casesPage.value, 3)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('staff drawer refuses overview belonging to a different target', async () => {
|
|
const f = setup(
|
|
'components/StaffDetail.vue',
|
|
{ staff: staff(9), capabilities, refreshKey: 0 },
|
|
workspaceApi({
|
|
assistantStaffOverview: async () => overview(8)
|
|
})
|
|
)
|
|
try {
|
|
await settle()
|
|
assert.equal(f.panel.overview.value, null)
|
|
assert.match(f.panel.overviewError.value, /不一致/)
|
|
f.panel.openCase(staffCase(8))
|
|
assert.equal(f.panel.detail.value, null)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('actual staff tasks load across patients by assignee, clear on staff switch, and reject stale lists', async () => {
|
|
const old = deferred(),
|
|
requests = []
|
|
const f = setup(
|
|
'components/ServiceActions.vue',
|
|
{ assistantId: 8, actorId: 8, canComplete: true, canReview: true, refreshKey: 0 },
|
|
{
|
|
assistantActions: async (params) => {
|
|
requests.push(params)
|
|
return params.assistant_id === 8
|
|
? old.promise
|
|
: page([
|
|
{ id: 2, diagnosis_id: 202, patient_name: '合成患者二', assignee_id: 9 }
|
|
])
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
await settle()
|
|
assert.equal(requests[0].assistant_id, 8)
|
|
assert.equal('diagnosis_id' in requests[0], false)
|
|
f.panel.rows.value = [{ id: 1, diagnosis_id: 101 }]
|
|
f.panel.opened.value = true
|
|
f.props.assistantId = 9
|
|
assert.equal(f.panel.rows.value.length, 0)
|
|
assert.equal(f.panel.opened.value, false)
|
|
await settle()
|
|
old.resolve(page([{ id: 1, diagnosis_id: 101 }]))
|
|
await settle()
|
|
assert.equal(f.panel.rows.value[0].diagnosis_id, 202)
|
|
assert.equal(f.panel.rows.value[0].patient_name, '合成患者二')
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('silent action refresh keeps the current page and an unfinished execution note', async () => {
|
|
const requests = []
|
|
const item = {
|
|
id: 1,
|
|
diagnosis_id: 3,
|
|
assignee_id: 8,
|
|
business_state: 'pending',
|
|
content: '待核查'
|
|
}
|
|
const f = setup(
|
|
'components/ServiceActions.vue',
|
|
{ assistantId: 8, actorId: 8, canComplete: true, canReview: true, refreshKey: 0 },
|
|
{
|
|
assistantActions: async (params) => {
|
|
requests.push(params)
|
|
return page([item])
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
await settle()
|
|
f.panel.page.value = 3
|
|
f.panel.edit(item)
|
|
f.panel.note.value = '正在补充执行情况'
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(f.panel.opened.value, true)
|
|
assert.equal(f.panel.note.value, '正在补充执行情况')
|
|
assert.equal(f.panel.page.value, 3)
|
|
assert.equal(requests.at(-1).page_no, 3)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('automatic case mode reads results, keeps active review and inputs, and never submits analysis', async () => {
|
|
const restore = installDocument(),
|
|
writes = [],
|
|
readCalls = []
|
|
let latest = 30
|
|
const f = setup(
|
|
'components/CaseDetail.vue',
|
|
{
|
|
patient: context(3).patient,
|
|
assistantId: 9,
|
|
days: 30,
|
|
capabilities,
|
|
automatic: true,
|
|
initialJobId: 30,
|
|
refreshKey: 0
|
|
},
|
|
{
|
|
assistantContext: async (params) => {
|
|
readCalls.push(params)
|
|
return {
|
|
...context(3, 9),
|
|
latest_job: { ...job(latest, 3, 'ready'), subject_admin_id: 9 },
|
|
latest_analysis_job: { ...job(latest, 3, 'ready'), subject_admin_id: 9 }
|
|
}
|
|
},
|
|
assistantJobs: async () => page([]),
|
|
assistantJob: async (id) => ({ ...job(id, 3, 'ready'), subject_admin_id: 9 }),
|
|
assistantAnalyze: async (data) => {
|
|
writes.push(data)
|
|
return job(30, 3)
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
assert.equal(f.panel.analysisState.job.id, 30)
|
|
await f.panel.generate('analysis')
|
|
assert.equal(writes.length, 0)
|
|
f.panel.question.value = '正在输入的回复问题'
|
|
f.panel.activeTab.value = 'reply'
|
|
f.panel.historyPage.value = 2
|
|
latest = 31
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(f.panel.analysisState.job.id, 30)
|
|
assert.equal(f.panel.newAnalysisAvailable.value, true)
|
|
assert.equal(f.panel.question.value, '正在输入的回复问题')
|
|
assert.equal(f.panel.activeTab.value, 'reply')
|
|
assert.equal(f.panel.historyPage.value, 2)
|
|
assert.equal(readCalls.at(-1).assistant_id, 9)
|
|
assert.equal(readCalls.at(-1).days, 30)
|
|
f.panel.showLatestAnalysis()
|
|
await settle()
|
|
assert.equal(f.panel.analysisState.job.id, 31)
|
|
assert.equal(f.panel.activeTab.value, 'analysis')
|
|
assert.equal(f.panel.newAnalysisAvailable.value, false)
|
|
global.document.visibilityState = 'hidden'
|
|
const before = readCalls.length
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(readCalls.length, before)
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('a newer reply cannot hide an analysis outside the current history page or replace active review', async () => {
|
|
const restore = installDocument(),
|
|
historyReads = [],
|
|
writes = []
|
|
let latestAnalysis = job(30, 3, 'ready'),
|
|
latestReply = null
|
|
const f = setup(
|
|
'components/CaseDetail.vue',
|
|
{
|
|
patient: context(3).patient,
|
|
assistantId: 8,
|
|
days: 30,
|
|
capabilities,
|
|
automatic: true,
|
|
initialJobId: 30,
|
|
refreshKey: 0
|
|
},
|
|
{
|
|
assistantContext: async () => ({
|
|
...context(3),
|
|
latest_job: latestReply || latestAnalysis,
|
|
latest_analysis_job: latestAnalysis
|
|
}),
|
|
assistantJobs: async (params) => {
|
|
historyReads.push(params)
|
|
// 当前页不包含最新分析，第一页也可能只有回复。
|
|
return page(
|
|
params.page_no === 2 ? [job(29, 3, 'ready')] : latestReply ? [latestReply] : []
|
|
)
|
|
},
|
|
assistantJob: async (id) => job(id, 3, 'ready', id === 32 ? 'reply' : 'analysis'),
|
|
assistantDraftReply: async (params) => {
|
|
writes.push(params)
|
|
latestReply = job(32, 3, 'ready', 'reply')
|
|
return latestReply
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
latestAnalysis = job(31, 3, 'ready')
|
|
f.panel.question.value = '准备人工核对的回复问题'
|
|
await f.panel.generate('reply')
|
|
assert.equal(writes.length, 1)
|
|
f.panel.question.value = '生成后仍在编辑的问题'
|
|
f.panel.activeTab.value = 'reply'
|
|
f.panel.historyPage.value = 2
|
|
f.panel.evidenceOpened.value = true
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(f.panel.analysisState.job.id, 30)
|
|
assert.equal(f.panel.replyState.job.id, 32)
|
|
assert.equal(f.panel.newAnalysisAvailable.value, true)
|
|
assert.equal(f.panel.question.value, '生成后仍在编辑的问题')
|
|
assert.equal(f.panel.activeTab.value, 'reply')
|
|
assert.equal(f.panel.evidenceOpened.value, true)
|
|
assert.equal(f.panel.historyPage.value, 2)
|
|
assert.equal(historyReads.at(-1).page_no, 2)
|
|
assert.deepEqual(
|
|
f.panel.history.value.map((item) => item.id),
|
|
[29]
|
|
)
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(f.panel.analysisState.job.id, 30)
|
|
assert.equal(f.panel.newAnalysisAvailable.value, true)
|
|
f.panel.showLatestAnalysis()
|
|
await settle()
|
|
assert.equal(f.panel.analysisState.job.id, 31)
|
|
assert.equal(f.panel.replyState.job.id, 32)
|
|
assert.equal(f.panel.newAnalysisAvailable.value, false)
|
|
assert.equal(f.panel.question.value, '生成后仍在编辑的问题')
|
|
assert.equal(f.panel.activeTab.value, 'analysis')
|
|
assert.deepEqual(
|
|
f.panel.history.value.map((item) => item.id),
|
|
[32]
|
|
)
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('initial case analysis is independent of reply-only history and older history rows', async () => {
|
|
const restore = installDocument(),
|
|
latestAnalysis = job(31, 3, 'ready'),
|
|
replies = Array.from({ length: 10 }, (_, index) => job(50 - index, 3, 'ready', 'reply'))
|
|
let rows = replies
|
|
const f = setup(
|
|
'components/CaseDetail.vue',
|
|
{ patient: context(3).patient, assistantId: 8, days: 30, capabilities, automatic: true },
|
|
{
|
|
assistantContext: async () => ({
|
|
...context(3),
|
|
latest_job: replies[0],
|
|
latest_analysis_job: latestAnalysis
|
|
}),
|
|
assistantJobs: async () => ({ ...page(rows), count: 22 }),
|
|
assistantJob: async (id) => job(id, 3, 'ready', id >= 41 ? 'reply' : 'analysis')
|
|
}
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
assert.equal(f.panel.analysisState.job.id, 31)
|
|
assert.equal(f.panel.replyState.job.id, 50)
|
|
assert.equal(f.panel.newAnalysisAvailable.value, false)
|
|
assert.ok(f.panel.history.value.every((item) => item.type === 'reply'))
|
|
rows = [job(29, 3, 'ready')]
|
|
await f.panel.reloadContext(true)
|
|
await settle()
|
|
assert.equal(f.panel.analysisState.job.id, 31)
|
|
f.panel.openHistory(rows[0])
|
|
await settle()
|
|
assert.equal(f.panel.analysisState.job.id, 29)
|
|
assert.equal(f.panel.newAnalysisAvailable.value, true)
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('case context rejects a latest analysis for another assistant, diagnosis or task type', async () => {
|
|
const restore = installDocument()
|
|
try {
|
|
for (const invalid of [
|
|
{ ...job(31, 3, 'ready'), subject_admin_id: 9 },
|
|
job(31, 4, 'ready'),
|
|
job(31, 3, 'ready', 'reply')
|
|
]) {
|
|
let latest = job(30, 3, 'ready')
|
|
const f = setup(
|
|
'components/CaseDetail.vue',
|
|
{
|
|
patient: context(3).patient,
|
|
assistantId: 8,
|
|
days: 30,
|
|
capabilities,
|
|
automatic: true,
|
|
refreshKey: 0
|
|
},
|
|
{
|
|
assistantContext: async () => ({ ...context(3), latest_analysis_job: latest }),
|
|
assistantJobs: async () => page([]),
|
|
assistantJob: async (id) => job(id, 3, 'ready')
|
|
}
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
latest = invalid
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.match(f.panel.contextError.value, /医助或关联诊单不一致/)
|
|
assert.equal(f.panel.context.value, null)
|
|
assert.equal(f.panel.analysisState.job, null)
|
|
await f.panel.reloadContext()
|
|
assert.match(f.panel.contextError.value, /医助或关联诊单不一致/)
|
|
assert.equal(f.panel.context.value, null)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
}
|
|
} finally {
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('actual case detail sends target and time to context, history, analysis and reply and defaults to service review', async () => {
|
|
const restore = installDocument(),
|
|
calls = [],
|
|
waits = []
|
|
const f = setup(
|
|
'components/CaseDetail.vue',
|
|
{ patient: context(3).patient, assistantId: 9, days: 7, capabilities },
|
|
{
|
|
assistantContext: async (params) => {
|
|
calls.push(['context', params])
|
|
return context(3, params.assistant_id)
|
|
},
|
|
assistantJobs: async (params) => {
|
|
calls.push(['jobs', params])
|
|
return page([])
|
|
},
|
|
assistantAnalyze: async (params) => {
|
|
calls.push(['analysis', params])
|
|
return { ...job(30, 3, 'ready'), subject_admin_id: 9 }
|
|
},
|
|
assistantDraftReply: async (params) => {
|
|
calls.push(['reply', params])
|
|
return { ...job(31, 3, 'ready', 'reply'), subject_admin_id: 9 }
|
|
},
|
|
assistantJob: async (id) => ({ ...job(id, 3, 'ready'), subject_admin_id: 9 })
|
|
}
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
assert.equal(f.panel.activeTab.value, 'analysis')
|
|
await f.panel.generate('analysis')
|
|
f.panel.question.value = '核对预约'
|
|
await f.panel.generate('reply')
|
|
for (const [name, params] of calls) {
|
|
assert.equal(params.assistant_id, 9, name)
|
|
assert.equal(params.diagnosis_id, 3, name)
|
|
if (name !== 'jobs') assert.equal(params.days, 7, name)
|
|
}
|
|
assert.ok(calls.some(([name]) => name === 'reply'))
|
|
assert.equal(f.panel.analysisState.job.subject_admin_id, 9)
|
|
assert.equal(f.panel.replyState.job.subject_admin_id, 9)
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('actual case detail rejects context belonging to another assistant and target changes cancel old sources', async () => {
|
|
const restore = installDocument(),
|
|
old = deferred()
|
|
const f = setup(
|
|
'components/CaseDetail.vue',
|
|
{ patient: context(3).patient, assistantId: 8, days: 30, capabilities },
|
|
{
|
|
assistantContext: async (params) =>
|
|
params.assistant_id === 8 ? old.promise : context(3, 8),
|
|
assistantJobs: async () => page([])
|
|
}
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
f.props.assistantId = 9
|
|
await settle()
|
|
assert.equal(f.panel.context.value, null)
|
|
assert.match(f.panel.contextError.value, /医助/)
|
|
old.resolve(context(3, 8))
|
|
await settle()
|
|
assert.equal(f.panel.context.value, null)
|
|
assert.equal(f.panel.canGenerate.value, false)
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('actual result defaults to service perspective and supervisor adoption requires review authorization for another assistant', async () => {
|
|
const item = { key: 'follow', text: '核对跟进', evidence_ids: [] },
|
|
calls = []
|
|
const f = setup(
|
|
'components/JobResult.vue',
|
|
{
|
|
job: {
|
|
...job(1, 3, 'ready'),
|
|
subject_admin_id: 9,
|
|
result: { ...analysis(), suggested_actions: [item] }
|
|
},
|
|
permissions: ['adoptAction'],
|
|
checking: false,
|
|
error: '',
|
|
disabled: false
|
|
},
|
|
{
|
|
assistantAdoptAction: async (data) => {
|
|
calls.push(data)
|
|
return { id: 1, todo_id: 2 }
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
assert.equal(f.panel.perspective.value, 'service')
|
|
assert.equal(f.panel.canAdopt.value, false)
|
|
f.panel.openAdopt(item)
|
|
f.panel.dueAt.value = new Date(Date.now() + 60000)
|
|
await f.panel.adopt()
|
|
assert.equal(calls.length, 0)
|
|
f.props.permissions = ['adoptAction', 'reviewQuality']
|
|
await f.panel.adopt()
|
|
assert.equal(calls.length, 1)
|
|
assert.equal(calls[0].job_id, 1)
|
|
assert.ok(f.calls.some((call) => call[1] === '已分配给该医助'))
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('daily contacts API is a cancellable read with only the frozen target, status and page parameters', async () => {
|
|
const calls = [],
|
|
signal = new AbortController().signal
|
|
const api = evaluate(
|
|
fs.readFileSync(path.join(__dirname, '../src/api/assistantService.ts'), 'utf8'),
|
|
() => ({
|
|
default: {
|
|
get: async (config, options) => {
|
|
calls.push({ config, options })
|
|
return { code: 1, data: dailyContacts() }
|
|
}
|
|
}
|
|
})
|
|
)
|
|
const result = await api.assistantStaffDailyContacts(
|
|
{ assistant_id: 9, status: 'reported', page_no: 2, page_size: 10 },
|
|
signal
|
|
)
|
|
assert.equal(calls[0].config.url, '/tcm.assistantService/staffDailyContacts')
|
|
assert.equal(calls[0].config.signal, signal)
|
|
assert.equal(calls[0].options.isOpenRetry, false)
|
|
assert.deepEqual(calls[0].config.params, {
|
|
assistant_id: 9,
|
|
status: 'reported',
|
|
page_no: 2,
|
|
page_size: 10
|
|
})
|
|
assert.equal(result.daily.timezone, 'Asia/Shanghai')
|
|
})
|
|
|
|
test('today entry selects pending or reported directly and service review keeps its own entry without model readiness', async () => {
|
|
const restore = installDocument(),
|
|
writes = []
|
|
const f = setup(
|
|
'workbench/index.vue',
|
|
{},
|
|
workspaceApi({
|
|
assistantCapabilities: async () => ({
|
|
...capabilities,
|
|
ready: false,
|
|
reason: '模型未配置'
|
|
}),
|
|
assistantAnalyze: async (...args) => writes.push(args),
|
|
assistantAnalyzeStaff: async (...args) => writes.push(args)
|
|
})
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
await f.panel.setSurface('daily')
|
|
await settle()
|
|
const row = f.panel.team.value.lists[0]
|
|
assert.equal(f.panel.businessDate.value, '2026-11-10')
|
|
assert.equal(f.panel.team.value.daily_summary.pending, 4)
|
|
f.panel.openStaff(row)
|
|
assert.equal(f.panel.initialView.value, 'daily')
|
|
assert.equal(f.panel.initialStatus.value, 'pending')
|
|
const entry = f.panel.entryKey.value
|
|
f.panel.openStaff(row, 'daily', 'reported')
|
|
assert.equal(f.panel.initialStatus.value, 'reported')
|
|
assert.equal(f.panel.entryKey.value, entry + 1)
|
|
f.panel.openStaff(row, 'issues')
|
|
assert.equal(f.panel.initialView.value, 'issues')
|
|
assert.equal(f.panel.selectedStaff.value.id, row.staff.id)
|
|
assert.equal(writes.length, 0)
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('daily list preserves whole-patient summary across status and page reads and opens only authorized diagnosis references', async () => {
|
|
const requests = [],
|
|
writes = []
|
|
const f = setup(
|
|
'components/DailyContacts.vue',
|
|
{ assistantId: 9, businessDate: '2026-11-10', refreshKey: 0, allowed: true },
|
|
workspaceApi({
|
|
assistantStaffDailyContacts: async (params) => {
|
|
requests.push(params)
|
|
return dailyContacts(9, {
|
|
...page([dailyPatient(3, params.status === 'all' ? 'pending' : params.status)]),
|
|
count: 14
|
|
})
|
|
},
|
|
assistantAnalyze: async (...args) => writes.push(args),
|
|
assistantCompleteAction: async (...args) => writes.push(args)
|
|
})
|
|
)
|
|
try {
|
|
await settle()
|
|
assert.equal(f.panel.status.value, 'pending')
|
|
assert.equal(f.panel.data.value.summary.required, 4)
|
|
assert.equal(f.panel.data.value.lists.length, 1)
|
|
assert.equal(f.panel.data.value.count, 14)
|
|
f.panel.setStatus('reported')
|
|
await settle()
|
|
f.panel.page.value = 2
|
|
await f.panel.load()
|
|
assert.equal(requests.at(-1).status, 'reported')
|
|
assert.equal(requests.at(-1).page_no, 2)
|
|
assert.equal(f.panel.data.value.summary.required, 4)
|
|
assert.equal(f.panel.data.value.summary.contacted, 1)
|
|
const patient = f.panel.data.value.lists[0]
|
|
f.panel.openPatient(patient, 999)
|
|
assert.equal(f.events.length, 0)
|
|
f.panel.openPatient(patient, 103)
|
|
assert.equal(f.events[0][0], 'open')
|
|
assert.equal(f.events[0][1].diagnosis_id, 103)
|
|
assert.equal(f.events[0][1].assistant_id, 9)
|
|
assert.equal(writes.length, 0)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('daily list cancels old staff reads, rejects mismatched staff and clears data immediately on permission loss', async () => {
|
|
const old = deferred(),
|
|
signals = []
|
|
let invalid = false
|
|
const f = setup(
|
|
'components/DailyContacts.vue',
|
|
{ assistantId: 8, businessDate: '2026-11-10', refreshKey: 0, allowed: true },
|
|
workspaceApi({
|
|
assistantStaffDailyContacts: async (params, signal) => {
|
|
signals.push(signal)
|
|
return params.assistant_id === 8 ? old.promise : dailyContacts(invalid ? 8 : 9)
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
await settle()
|
|
f.props.assistantId = 9
|
|
assert.equal(signals[0].aborted, true)
|
|
assert.equal(f.panel.data.value, null)
|
|
await settle()
|
|
old.resolve(dailyContacts(8))
|
|
await settle()
|
|
assert.equal(f.panel.data.value.staff.id, 9)
|
|
invalid = true
|
|
await f.panel.load(true)
|
|
assert.equal(f.panel.data.value, null)
|
|
assert.match(f.panel.error.value, /医助或业务日期不一致/)
|
|
assert.ok(f.events.some(([name]) => name === 'unavailable'))
|
|
invalid = false
|
|
await f.panel.load()
|
|
const before = signals.length
|
|
f.props.allowed = false
|
|
assert.equal(f.panel.data.value, null)
|
|
assert.equal(signals.at(-1).aborted, true)
|
|
await f.panel.load()
|
|
assert.equal(signals.length, before)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('daily list distinguishes no tasks, complete, unavailable, partial and read failure without deriving completion from an empty page', async () => {
|
|
let result = dailyContacts(9, {
|
|
...page([]),
|
|
summary: dailyCounts({
|
|
required: 0,
|
|
contacted: 0,
|
|
pending: 0,
|
|
reported: 0,
|
|
outstanding: 0,
|
|
state: 'no_tasks'
|
|
})
|
|
})
|
|
const f = setup(
|
|
'components/DailyContacts.vue',
|
|
{ assistantId: 9, businessDate: '2026-11-10', refreshKey: 0, allowed: true },
|
|
workspaceApi({
|
|
assistantStaffDailyContacts: async () => {
|
|
if (result instanceof Error) throw result
|
|
return result
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
await settle()
|
|
assert.equal(f.panel.emptyDescription.value, '今日暂无应维护患者')
|
|
result = dailyContacts(9, {
|
|
...page([]),
|
|
summary: dailyCounts({
|
|
required: 4,
|
|
contacted: 4,
|
|
pending: 0,
|
|
reported: 0,
|
|
outstanding: 0,
|
|
state: 'done'
|
|
})
|
|
})
|
|
await f.panel.load()
|
|
assert.equal(f.panel.data.value.summary.state, 'done')
|
|
assert.equal(f.panel.emptyDescription.value, '当前筛选暂无患者')
|
|
for (const state of ['waiting', 'partial', 'unavailable']) {
|
|
result = dailyContacts(9, {
|
|
...page([]),
|
|
daily: dailyMeta({ state, reason: '来源待确认' }),
|
|
summary: dailyCounts({
|
|
required: null,
|
|
contacted: null,
|
|
pending: null,
|
|
reported: null,
|
|
outstanding: null,
|
|
exempt: null,
|
|
state: 'unavailable'
|
|
})
|
|
})
|
|
await f.panel.load()
|
|
assert.equal(f.panel.data.value.summary.required, null)
|
|
assert.match(f.panel.emptyDescription.value, /不可确认/)
|
|
}
|
|
result = new Error('权限已变更')
|
|
await f.panel.load(true)
|
|
assert.equal(f.panel.data.value, null)
|
|
assert.equal(f.panel.error.value, '权限已变更')
|
|
assert.match(f.panel.emptyDescription.value, /读取失败/)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('same-day daily refresh keeps status and pagination while updating evidence and summary', async () => {
|
|
const requests = []
|
|
let recorded = false
|
|
const f = setup(
|
|
'components/DailyContacts.vue',
|
|
{
|
|
assistantId: 9,
|
|
businessDate: '2026-11-10',
|
|
refreshKey: 0,
|
|
initialStatus: 'reported',
|
|
entryKey: 1,
|
|
allowed: true
|
|
},
|
|
workspaceApi({
|
|
assistantStaffDailyContacts: async (params) => {
|
|
requests.push(params)
|
|
return dailyContacts(9, {
|
|
...page(recorded ? [] : [dailyPatient(3, 'reported')]),
|
|
summary: dailyCounts({
|
|
contacted: recorded ? 2 : 1,
|
|
reported: recorded ? 0 : 1
|
|
})
|
|
})
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
await settle()
|
|
f.panel.page.value = 3
|
|
recorded = true
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(f.panel.status.value, 'reported')
|
|
assert.equal(f.panel.page.value, 3)
|
|
assert.equal(requests.at(-1).page_no, 3)
|
|
assert.equal(f.panel.data.value.summary.contacted, 2)
|
|
assert.equal(f.panel.data.value.summary.reported, 0)
|
|
f.props.initialStatus = 'pending'
|
|
f.props.entryKey++
|
|
await settle()
|
|
assert.equal(f.panel.status.value, 'pending')
|
|
assert.equal(f.panel.page.value, 1)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('server business-date rollover resets daily page and rejects late old-day responses and wrong timezone', async () => {
|
|
const old = deferred(),
|
|
requests = []
|
|
let count = 0,
|
|
returnedDate = '2026-11-11',
|
|
timezone = 'Asia/Shanghai'
|
|
const f = setup(
|
|
'components/DailyContacts.vue',
|
|
{
|
|
assistantId: 9,
|
|
businessDate: '2026-11-10',
|
|
refreshKey: 0,
|
|
initialStatus: 'reported',
|
|
allowed: true
|
|
},
|
|
workspaceApi({
|
|
assistantStaffDailyContacts: async (params) => {
|
|
requests.push(params)
|
|
if (++count === 1) return old.promise
|
|
return dailyContacts(9, {
|
|
daily: dailyMeta({ business_date: returnedDate, timezone })
|
|
})
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
await settle()
|
|
f.panel.page.value = 3
|
|
f.props.businessDate = '2026-11-11'
|
|
assert.equal(f.panel.data.value, null)
|
|
assert.equal(f.panel.page.value, 1)
|
|
await settle()
|
|
old.resolve(dailyContacts(9))
|
|
await settle()
|
|
assert.equal(f.panel.data.value.daily.business_date, '2026-11-11')
|
|
assert.equal(f.panel.status.value, 'reported')
|
|
assert.equal(requests.at(-1).page_no, 1)
|
|
returnedDate = '2026-11-10'
|
|
await f.panel.load(true)
|
|
assert.equal(f.panel.data.value, null)
|
|
assert.match(f.panel.error.value, /旧业务日期/)
|
|
returnedDate = '2026-11-12'
|
|
await f.panel.load(true)
|
|
assert.equal(f.panel.data.value, null)
|
|
assert.ok(f.events.some(([name, date]) => name === 'date-change' && date === '2026-11-12'))
|
|
timezone = 'UTC'
|
|
await f.panel.load(true)
|
|
assert.match(f.panel.error.value, /业务日期不一致/)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('team refuses a response older than the latest server business date while retaining the open staff and search draft', async () => {
|
|
const restore = installDocument(),
|
|
old = deferred()
|
|
let count = 0,
|
|
date = '2026-11-10'
|
|
const f = setup(
|
|
'workbench/index.vue',
|
|
{},
|
|
workspaceApi({
|
|
assistantTeamOverview: async () => {
|
|
if (++count === 2) return old.promise
|
|
return { ...teamOverview(), daily: dailyMeta({ business_date: date }) }
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
await f.panel.setSurface('daily')
|
|
await settle()
|
|
f.panel.openStaff(f.panel.team.value.lists[0])
|
|
f.panel.keyword.value = '编辑中的搜索'
|
|
const read = f.panel.loadTeam(true)
|
|
date = '2026-11-11'
|
|
f.panel.observeBusinessDate(date)
|
|
await settle()
|
|
old.resolve(teamOverview())
|
|
await read
|
|
await settle()
|
|
assert.equal(f.panel.team.value.daily.business_date, date)
|
|
assert.equal(f.panel.businessDate.value, date)
|
|
assert.equal(f.panel.drawerOpened.value, true)
|
|
assert.equal(f.panel.keyword.value, '编辑中的搜索')
|
|
date = '2026-11-10'
|
|
await f.panel.loadTeam(true)
|
|
assert.equal(f.panel.team.value.daily.business_date, '2026-11-11')
|
|
assert.equal(f.panel.businessDate.value, '2026-11-11')
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
test('daily record navigation survives quality-only errors and refreshes, with independent denial and same-staff view changes', async () => {
|
|
const f = setup(
|
|
'components/StaffDetail.vue',
|
|
{
|
|
staff: staff(9),
|
|
capabilities: { ...capabilities },
|
|
refreshKey: 0,
|
|
businessDate: '2026-11-10',
|
|
initialView: 'daily',
|
|
initialStatus: 'pending',
|
|
entryKey: 1
|
|
},
|
|
workspaceApi({
|
|
assistantStaffOverview: async () => {
|
|
throw new Error('近期质检暂不可用')
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
await settle()
|
|
assert.equal(f.panel.activeTab.value, 'daily')
|
|
assert.match(f.panel.overviewError.value, /暂不可用/)
|
|
f.panel.openDaily({ ...context(3).patient, assistant_id: 9 })
|
|
assert.equal(f.panel.detail.value.patient.diagnosis_id, 3)
|
|
const refresh = f.panel.dailyRefresh.value
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(f.panel.detail.value.daily, true)
|
|
assert.ok(f.panel.dailyRefresh.value > refresh)
|
|
f.panel.closeDetail()
|
|
await settle()
|
|
assert.equal(f.panel.activeTab.value, 'daily')
|
|
f.panel.openDaily({ ...context(3).patient, assistant_id: 9 })
|
|
f.panel.dailyUnavailable()
|
|
assert.equal(f.panel.detail.value, null)
|
|
f.props.initialView = 'issues'
|
|
f.props.entryKey++
|
|
await settle()
|
|
assert.equal(f.panel.activeTab.value, 'issues')
|
|
f.props.capabilities = { ...capabilities, permissions: [] }
|
|
assert.equal(f.panel.detail.value, null)
|
|
assert.equal(f.panel.overview.value, null)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('adopting a suggested action requires explicit contact opt-in and each new adoption starts unchecked', async () => {
|
|
const calls = [],
|
|
item = { key: 'follow', text: '核对随访', evidence_ids: [] }
|
|
const f = setup(
|
|
'components/JobResult.vue',
|
|
{
|
|
job: { ...job(1, 3, 'ready'), result: { ...analysis(), suggested_actions: [item] } },
|
|
permissions: ['adoptAction'],
|
|
checking: false,
|
|
error: '',
|
|
disabled: false
|
|
},
|
|
{
|
|
assistantAdoptAction: async (data) => {
|
|
calls.push(data)
|
|
return { id: 1, todo_id: 2 }
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
f.panel.openAdopt(item)
|
|
assert.equal(f.panel.contactRequired.value, false)
|
|
f.panel.dueAt.value = new Date(Date.now() + 60000)
|
|
await f.panel.adopt()
|
|
assert.equal(calls[0].contact_required, false)
|
|
f.panel.openAdopt(item)
|
|
f.panel.contactRequired.value = true
|
|
f.panel.dueAt.value = new Date(Date.now() + 60000)
|
|
await f.panel.adopt()
|
|
assert.equal(calls[1].contact_required, true)
|
|
f.panel.openAdopt(item)
|
|
assert.equal(f.panel.contactRequired.value, false)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('daily list pauses hidden and inactive reads and discards a response already in flight', async () => {
|
|
const restore = installDocument(),
|
|
old = deferred(),
|
|
requests = []
|
|
let count = 0
|
|
const f = setup(
|
|
'components/DailyContacts.vue',
|
|
{ assistantId: 9, businessDate: '2026-11-10', refreshKey: 0, allowed: true },
|
|
workspaceApi({
|
|
assistantStaffDailyContacts: async (params, signal) => {
|
|
requests.push({ params, signal })
|
|
return ++count === 1 ? old.promise : dailyContacts(9)
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
global.document.visibilityState = 'hidden'
|
|
f.panel.updateVisibility()
|
|
assert.equal(requests[0].signal.aborted, true)
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(requests.length, 1)
|
|
old.resolve(dailyContacts(9))
|
|
await settle()
|
|
assert.equal(f.panel.data.value, null)
|
|
global.document.visibilityState = 'visible'
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(f.panel.data.value.staff.id, 9)
|
|
f.hooks.onDeactivated()
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(requests.length, 2)
|
|
f.hooks.onActivated()
|
|
f.props.refreshKey++
|
|
await settle()
|
|
assert.equal(requests.length, 3)
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|
|
|
|
function alertRow(id = 4, overrides = {}) {
|
|
return {
|
|
id,
|
|
staff: staff(9),
|
|
patient_id: 3,
|
|
patient_name: '合成患者3',
|
|
diagnosis_id: 3,
|
|
channel: 'im',
|
|
rule_code: 'clinical_boundary',
|
|
rule_label: '越界诊疗',
|
|
rule_version: 1,
|
|
severity: 'high',
|
|
snippet: '诊断为糖尿病',
|
|
status: 'open',
|
|
occurred_at: 1794268800,
|
|
review_note: '',
|
|
reviewed_at: 0,
|
|
...overrides
|
|
}
|
|
}
|
|
function alertPage(lists = [alertRow()], emptyReason = '') {
|
|
return {
|
|
...page(lists),
|
|
page_size: 20,
|
|
schema_ready: true,
|
|
summary: { open: lists.length ? 2 : 0, high_open: lists.length ? 1 : 0, im_open: lists.length ? 2 : 0, call_open: 0 },
|
|
scan: { enabled: true, state: 'ready', last_scan_at: 1794268800, reason: '' },
|
|
coverage: [
|
|
{ channel: 'im', status: 'available', note: '员工侧已归档文字' },
|
|
{
|
|
channel: 'call',
|
|
status: emptyReason ? 'no_transcript' : 'not_connected',
|
|
note: emptyReason || '通话转写尚未接入'
|
|
}
|
|
],
|
|
empty_reason: emptyReason
|
|
}
|
|
}
|
|
|
|
test('alert API keeps filters explicit and does not retry a review', async () => {
|
|
const calls = [],
|
|
signal = new AbortController().signal
|
|
const api = evaluate(
|
|
fs.readFileSync(path.join(__dirname, '../src/api/assistantService.ts'), 'utf8'),
|
|
() => ({
|
|
default: {
|
|
get: async (config, options) => {
|
|
calls.push({ config, options })
|
|
return { code: 1, data: alertPage() }
|
|
},
|
|
post: async (config, options) => {
|
|
calls.push({ config, options })
|
|
return { code: 1, data: { id: 4, status: 'confirmed' } }
|
|
}
|
|
}
|
|
})
|
|
)
|
|
const result = await api.assistantAlerts(
|
|
{ keyword: '甲', status: 'open', severity: 'high', page_no: 2, page_size: 20 },
|
|
signal
|
|
)
|
|
await api.assistantReviewAlert({ id: 4, status: 'false_positive', note: '患者原话' })
|
|
assert.equal(calls[0].config.url, '/tcm.assistantService/alerts')
|
|
assert.equal(calls[0].config.signal, signal)
|
|
assert.equal(calls[0].options.isOpenRetry, false)
|
|
assert.deepEqual(calls[0].config.params, {
|
|
keyword: '甲',
|
|
status: 'open',
|
|
severity: 'high',
|
|
page_no: 2,
|
|
page_size: 20
|
|
})
|
|
assert.equal(result.summary.call_open, 0)
|
|
assert.equal(calls[1].config.url, '/tcm.assistantService/reviewAlert')
|
|
assert.equal(calls[1].options.isOpenRetry, false)
|
|
assert.deepEqual(calls[1].config.data, { id: 4, status: 'false_positive', note: '患者原话' })
|
|
})
|
|
|
|
test('alert inbox reviews only with a reason for false positives and keeps the unfiltered summary', async () => {
|
|
const reads = [],
|
|
reviews = []
|
|
const f = setup(
|
|
'components/AlertInbox.vue',
|
|
{ refreshKey: 0, canReview: true },
|
|
workspaceApi({
|
|
assistantAlerts: async (params) => {
|
|
reads.push(params)
|
|
return alertPage()
|
|
},
|
|
assistantReviewAlert: async (data) => {
|
|
reviews.push(data)
|
|
return { id: data.id, status: data.status }
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
await settle()
|
|
assert.equal(f.panel.filter.value, 'open')
|
|
assert.equal(f.panel.data.value.summary.open, 2)
|
|
assert.equal(f.panel.data.value.summary.call_open, 0)
|
|
assert.equal(reads[0].status, 'open')
|
|
assert.equal(reads[0].severity, 'all')
|
|
const row = f.panel.data.value.lists[0]
|
|
f.panel.openStaff(row)
|
|
assert.equal(f.events[0][0], 'open-staff')
|
|
assert.equal(f.events[0][1].id, 9)
|
|
await f.panel.review(row, 'false_positive')
|
|
assert.equal(reviews.length, 0)
|
|
assert.equal(f.panel.noteTarget.value, row.id)
|
|
f.panel.note.value = '患者原话'
|
|
await f.panel.review(row, 'false_positive')
|
|
assert.deepEqual(reviews[0], { id: row.id, status: 'false_positive', note: '患者原话' })
|
|
await f.panel.review(alertRow(5), 'confirmed')
|
|
assert.equal(reviews[1].status, 'confirmed')
|
|
assert.equal(reviews[1].note, '')
|
|
f.panel.setFilter('high')
|
|
await settle()
|
|
assert.equal(reads.at(-1).status, 'open')
|
|
assert.equal(reads.at(-1).severity, 'high')
|
|
f.panel.setRole('doctor')
|
|
await settle()
|
|
assert.equal(reads.at(-1).role, 'doctor')
|
|
assert.equal(f.panel.role.value, 'doctor')
|
|
assert.equal(f.panel.data.value.summary.open, 2)
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('alert inbox explains an empty list when visible assistants have no archived text', async () => {
|
|
const f = setup(
|
|
'components/AlertInbox.vue',
|
|
{ refreshKey: 0, canReview: false },
|
|
workspaceApi({
|
|
assistantAlerts: async () =>
|
|
alertPage(
|
|
[],
|
|
'可见医助账号没有已归档文字。通话 69 通，有时长 0 通，有转写 0 通。医生账号的聊天和转写不进这个列表。'
|
|
)
|
|
})
|
|
)
|
|
try {
|
|
await settle()
|
|
assert.match(f.panel.emptyDescription.value, /没有已归档文字/)
|
|
assert.equal(f.panel.callMetric.value, '无正文')
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('alert inbox ignores review without permission and discards a stale list response', async () => {
|
|
const old = deferred(),
|
|
signals = []
|
|
let count = 0
|
|
const f = setup(
|
|
'components/AlertInbox.vue',
|
|
{ refreshKey: 0, canReview: false },
|
|
workspaceApi({
|
|
assistantAlerts: async (params, signal) => {
|
|
signals.push(signal)
|
|
if (++count === 1) return old.promise
|
|
return alertPage([alertRow(8)])
|
|
},
|
|
assistantReviewAlert: async () => {
|
|
throw new Error('不应复核')
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
await f.panel.review(alertRow(), 'confirmed')
|
|
f.panel.setFilter('all')
|
|
assert.equal(signals[0].aborted, true)
|
|
await settle()
|
|
old.resolve(alertPage([alertRow(4)]))
|
|
await settle()
|
|
assert.equal(f.panel.data.value.lists[0].id, 8)
|
|
assert.equal(f.panel.filter.value, 'all')
|
|
} finally {
|
|
f.dispose()
|
|
}
|
|
})
|
|
|
|
test('workbench refresh on the alert surface does not load the maintenance roster', async () => {
|
|
const restore = installDocument(),
|
|
reads = []
|
|
const f = setup(
|
|
'workbench/index.vue',
|
|
{},
|
|
workspaceApi({
|
|
assistantTeamOverview: async () => {
|
|
reads.push('team')
|
|
return teamOverview()
|
|
}
|
|
})
|
|
)
|
|
try {
|
|
f.hooks.onMounted()
|
|
await settle()
|
|
f.panel.refresh()
|
|
assert.equal(f.panel.alertRefresh.value, 1)
|
|
assert.equal(reads.length, 0)
|
|
f.panel.openAlertStaff(staff(9))
|
|
assert.equal(f.panel.drawerOpened.value, true)
|
|
assert.equal(f.panel.initialView.value, 'issues')
|
|
assert.equal(f.panel.selectedStaff.value.id, 9)
|
|
} finally {
|
|
f.dispose()
|
|
restore()
|
|
}
|
|
})
|