294 lines
9.6 KiB
TypeScript
294 lines
9.6 KiB
TypeScript
// @vitest-environment jsdom
|
|
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import { defineComponent, h } from 'vue'
|
|
import { flushPromises, mount } from '@vue/test-utils'
|
|
import ArcoVue from '@arco-design/web-vue'
|
|
|
|
const mockMessage = vi.hoisted(() => ({
|
|
warning: vi.fn(),
|
|
success: vi.fn(),
|
|
error: vi.fn(),
|
|
}))
|
|
|
|
const mockSettingsStore = vi.hoisted(() => ({
|
|
platforms: {} as Record<string, any>,
|
|
fetchSettings: vi.fn(async () => {
|
|
mockSettingsStore.platforms = {
|
|
telegram: { token: 'telegram-token' },
|
|
discord: { token: 'discord-token' },
|
|
slack: { token: 'slack-token' },
|
|
whatsapp: { enabled: true },
|
|
matrix: { token: 'matrix-token' },
|
|
weixin: { token: 'weixin-token' },
|
|
wecom: { extra: { bot_id: 'wecom-bot' } },
|
|
feishu: { extra: { app_id: 'feishu-app' } },
|
|
dingtalk: { extra: { client_id: 'dingtalk-client' } },
|
|
qqbot: { extra: { app_id: 'qq-app', client_secret: 'qq-secret' } },
|
|
}
|
|
}),
|
|
}))
|
|
|
|
const mockJobsStore = vi.hoisted(() => ({
|
|
createJob: vi.fn(),
|
|
updateJob: vi.fn(),
|
|
}))
|
|
|
|
const mockAppStore = vi.hoisted(() => ({
|
|
modelGroups: [
|
|
{ provider: 'openai', label: 'OpenAI', models: ['gpt-4.1', 'gpt-4.1-mini'] },
|
|
{ provider: 'anthropic', label: 'Anthropic', models: ['claude-sonnet-4'] },
|
|
],
|
|
loadModels: vi.fn(async () => undefined),
|
|
displayModelName: vi.fn((model: string) => model),
|
|
}))
|
|
|
|
const mockFetchSkills = vi.hoisted(() => vi.fn(async () => ({
|
|
categories: [
|
|
{
|
|
name: 'local',
|
|
description: '',
|
|
skills: [
|
|
{ name: 'planner', description: 'Plan work' },
|
|
{ name: 'reviewer', description: 'Review work' },
|
|
{ name: 'disabled-skill', description: 'Disabled', enabled: false },
|
|
],
|
|
},
|
|
],
|
|
archived: [],
|
|
})))
|
|
|
|
vi.mock('@/stores/hermes/settings', () => ({
|
|
useSettingsStore: () => mockSettingsStore,
|
|
}))
|
|
|
|
vi.mock('@/stores/hermes/jobs', () => ({
|
|
useJobsStore: () => mockJobsStore,
|
|
}))
|
|
|
|
vi.mock('@/stores/hermes/app', () => ({
|
|
useAppStore: () => mockAppStore,
|
|
}))
|
|
|
|
vi.mock('@/api/hermes/jobs', async () => {
|
|
const actual = await vi.importActual<any>('@/api/hermes/jobs')
|
|
return {
|
|
...actual,
|
|
getJob: vi.fn(),
|
|
}
|
|
})
|
|
|
|
vi.mock('@/api/hermes/skills', () => ({
|
|
fetchSkills: mockFetchSkills,
|
|
}))
|
|
|
|
vi.mock('vue-i18n', () => ({
|
|
useI18n: () => ({
|
|
t: (key: string) => key,
|
|
}),
|
|
}))
|
|
|
|
// Arco's imperative Message API needs a live DOM, so mock the adapter composable.
|
|
vi.mock('@/composables/useMessage', () => ({ useMessage: () => mockMessage }))
|
|
|
|
/**
|
|
* Arco's a-select renders a custom dropdown instead of a native <select>, and
|
|
* a-modal teleports to body in jsdom. Both are stubbed under Arco's *internal*
|
|
* component names (stubs key off those, not the `a-*` template tags, because
|
|
* Arco is registered globally via `app.use(ArcoVue)`).
|
|
*/
|
|
const ASelectStub = defineComponent({
|
|
name: 'Select',
|
|
props: {
|
|
modelValue: { type: [String, Number, Array], default: null },
|
|
options: { type: Array, default: () => [] },
|
|
multiple: { type: Boolean, default: false },
|
|
disabled: { type: Boolean, default: false },
|
|
placeholder: { type: String, default: '' },
|
|
},
|
|
emits: ['update:modelValue', 'change'],
|
|
setup(props, { emit }) {
|
|
return () =>
|
|
h(
|
|
'select',
|
|
{
|
|
class: 'arco-select-stub',
|
|
multiple: props.multiple,
|
|
disabled: props.disabled,
|
|
onChange: (event: Event) => {
|
|
const target = event.target as HTMLSelectElement
|
|
const value = props.multiple
|
|
? Array.from(target.selectedOptions).map(option => option.value)
|
|
: target.value
|
|
emit('update:modelValue', value)
|
|
emit('change', value)
|
|
},
|
|
},
|
|
[
|
|
!props.multiple && h('option', { value: '' }, props.placeholder),
|
|
...(props.options as Array<{ label: string; value: string; disabled?: boolean }>).map(option =>
|
|
h('option', { key: option.value, value: option.value, disabled: option.disabled }, option.label),
|
|
),
|
|
],
|
|
)
|
|
},
|
|
})
|
|
|
|
const AInputNumberStub = defineComponent({
|
|
name: 'InputNumber',
|
|
props: { modelValue: { type: [Number, String], default: undefined } },
|
|
emits: ['update:modelValue', 'change'],
|
|
setup(_props, { emit }) {
|
|
return () =>
|
|
h('input', {
|
|
class: 'arco-input-number-stub',
|
|
type: 'number',
|
|
onChange: (event: Event) => {
|
|
const value = Number((event.target as HTMLInputElement).value)
|
|
emit('update:modelValue', value)
|
|
emit('change', value)
|
|
},
|
|
})
|
|
},
|
|
})
|
|
|
|
const AModalStub = defineComponent({
|
|
name: 'Modal',
|
|
props: ['visible'],
|
|
template: '<div v-if="visible" class="a-modal-stub"><slot /><slot name="footer" /></div>',
|
|
})
|
|
|
|
const arcoGlobal = {
|
|
plugins: [ArcoVue],
|
|
stubs: { Select: ASelectStub, InputNumber: AInputNumberStub, Modal: AModalStub },
|
|
}
|
|
|
|
/**
|
|
* Locate a form control by its Arco form-item label instead of by DOM index, so
|
|
* the assertion keeps targeting the intended field even if field order changes.
|
|
*/
|
|
function fieldByLabel(wrapper: ReturnType<typeof mount>, label: string) {
|
|
const item = wrapper
|
|
.findAll('.arco-form-item')
|
|
.find(node => node.find('.arco-form-item-label').text().trim() === label)
|
|
if (!item) throw new Error(`form item not found: ${label}`)
|
|
return item
|
|
}
|
|
|
|
function selectByLabel(wrapper: ReturnType<typeof mount>, label: string) {
|
|
return fieldByLabel(wrapper, label).get('select.arco-select-stub')
|
|
}
|
|
|
|
function buttonByText(wrapper: ReturnType<typeof mount>, text: string) {
|
|
const button = wrapper.findAll('button').find(node => node.text().trim() === text)
|
|
if (!button) throw new Error(`button not found: ${text}`)
|
|
return button
|
|
}
|
|
|
|
import JobFormModal from '@/components/hermes/jobs/JobFormModal.vue'
|
|
|
|
describe('JobFormModal deliver targets', () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
mockSettingsStore.platforms = {}
|
|
})
|
|
|
|
it('loads platform settings when the store has not been hydrated', async () => {
|
|
mount(JobFormModal, {
|
|
props: { jobId: null },
|
|
global: arcoGlobal,
|
|
})
|
|
|
|
await flushPromises()
|
|
|
|
expect(mockSettingsStore.fetchSettings).toHaveBeenCalledOnce()
|
|
expect(mockAppStore.loadModels).toHaveBeenCalledOnce()
|
|
})
|
|
|
|
it('shows every supported platform channel in deliver target options', async () => {
|
|
mockSettingsStore.platforms = {
|
|
telegram: { token: 'telegram-token' },
|
|
whatsapp: { enabled: false },
|
|
qqbot: { extra: { app_id: 'qq-app', client_secret: 'qq-secret' } },
|
|
}
|
|
const wrapper = mount(JobFormModal, {
|
|
props: { jobId: null },
|
|
global: arcoGlobal,
|
|
})
|
|
|
|
await flushPromises()
|
|
|
|
expect(mockSettingsStore.fetchSettings).not.toHaveBeenCalled()
|
|
const deliverSelect = selectByLabel(wrapper, 'jobs.deliverTarget')
|
|
const labels = deliverSelect.text()
|
|
expect(labels).toContain('Telegram')
|
|
expect(labels).toContain('Discord')
|
|
expect(labels).toContain('Slack')
|
|
expect(labels).toContain('WhatsApp')
|
|
expect(labels).toContain('Matrix')
|
|
expect(labels).toContain('WeChat')
|
|
expect(labels).toContain('WeCom')
|
|
expect(labels).toContain('Feishu')
|
|
expect(labels).toContain('DingTalk')
|
|
expect(labels).toContain('QQBot')
|
|
|
|
const options = deliverSelect.findAll('option')
|
|
const optionByValue = Object.fromEntries(options.map(option => [option.attributes('value'), option]))
|
|
expect(optionByValue.telegram.attributes('disabled')).toBeUndefined()
|
|
expect(optionByValue.qqbot.attributes('disabled')).toBeUndefined()
|
|
expect(optionByValue.discord.attributes('disabled')).toBe('')
|
|
expect(optionByValue.whatsapp.attributes('disabled')).toBe('')
|
|
})
|
|
|
|
it('submits selected skills when creating a job', async () => {
|
|
mockSettingsStore.platforms = { telegram: { token: 'telegram-token' } }
|
|
mockJobsStore.createJob.mockResolvedValue({ id: 'job-1' })
|
|
const wrapper = mount(JobFormModal, {
|
|
props: { jobId: null },
|
|
global: arcoGlobal,
|
|
})
|
|
|
|
await flushPromises()
|
|
await fieldByLabel(wrapper, 'jobs.name').get('input').setValue('Daily research')
|
|
await fieldByLabel(wrapper, 'jobs.schedule').get('input').setValue('0 9 * * *')
|
|
await fieldByLabel(wrapper, 'jobs.prompt').get('textarea').setValue('summarize updates')
|
|
await selectByLabel(wrapper, 'jobs.skills').setValue(['planner', 'reviewer'])
|
|
await buttonByText(wrapper, 'common.create').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(mockJobsStore.createJob).toHaveBeenCalledWith({
|
|
name: 'Daily research',
|
|
schedule: '0 9 * * *',
|
|
prompt: 'summarize updates',
|
|
deliver: 'origin',
|
|
skills: ['planner', 'reviewer'],
|
|
repeat: undefined,
|
|
provider: undefined,
|
|
model: undefined,
|
|
})
|
|
})
|
|
|
|
it('submits selected provider and model when creating a job', async () => {
|
|
mockSettingsStore.platforms = { telegram: { token: 'telegram-token' } }
|
|
mockJobsStore.createJob.mockResolvedValue({ id: 'job-1' })
|
|
const wrapper = mount(JobFormModal, {
|
|
props: { jobId: null },
|
|
global: arcoGlobal,
|
|
})
|
|
|
|
await flushPromises()
|
|
await fieldByLabel(wrapper, 'jobs.name').get('input').setValue('Daily research')
|
|
await fieldByLabel(wrapper, 'jobs.schedule').get('input').setValue('0 9 * * *')
|
|
await fieldByLabel(wrapper, 'jobs.prompt').get('textarea').setValue('summarize updates')
|
|
await selectByLabel(wrapper, 'jobs.provider').setValue('openai')
|
|
await flushPromises()
|
|
await selectByLabel(wrapper, 'jobs.model').setValue('gpt-4.1-mini')
|
|
await buttonByText(wrapper, 'common.create').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(mockJobsStore.createJob).toHaveBeenCalledWith(expect.objectContaining({
|
|
provider: 'openai',
|
|
model: 'gpt-4.1-mini',
|
|
}))
|
|
})
|
|
})
|