Files
shumai/packages/api/src/provider.test.ts
T
Yiling-J a236cd3a97 feat(provider): add provider and model sync feature with vendored generator (#378)
* feat(provider): vendor and adapt pi model generator

- Vendor generate-models.ts, model-data.ts, and models-dev-reasoning-options.ts from @earendil-works/pi tag v0.82.1
- Adapt imports to use @earendil-works/pi-ai and expose generateModels programmatic function
- Add compare.test.ts to verify vendored generator against original built-in catalog
- Add packages/core/src/provider/generator to eslint ignores

* feat(provider): add provider and model sync api and ui

* feat(webui): add checkbox for existing providers and clean dialog description

* feat(webui): add expand all and collapse all to sync providers dialog

* refactor(provider): remove compare.test.ts and cli overhead from generate-models

* fix(provider): add 30s timeout and strict error handling to sync catalog fetching

* fix(e2e): eliminate drag-and-drop race condition on webkit

Allow requestAnimationFrame collision updates to settle in dragCard helper before releasing pointer, and scope fileCard locator via data-testid to avoid matching sidebar tree items.
2026-09-03 21:01:14 +08:00

408 lines
12 KiB
TypeScript

import { describe, expect, it, vi, beforeEach } from 'vitest'
import { Hono, type Context, type Next } from 'hono'
import providerRoute from './provider'
import { providerService } from '@shumai/core/src/provider/provider'
import { authzService, Permission, ResourceType } from '@shumai/core/src/authz/authz'
import { auditLogService } from '@shumai/core/src/auditLog/auditLog'
vi.mock('./middleware/auth', () => ({
authMiddleware: async (
c: Context<{ Variables: { user: { id: string; name: string } } }>,
next: Next,
) => {
c.set('user', { id: 'user1', name: 'Test User' })
await next()
},
}))
vi.mock('@shumai/core/src/authz/authz')
vi.mock('@shumai/core/src/provider/provider')
vi.mock('@shumai/core/src/auditLog/auditLog', () => ({
auditLogService: {
logAction: vi.fn().mockResolvedValue({}),
},
}))
describe('provider api', () => {
const app = new Hono<{ Variables: { user: { id: string; name: string } } }>()
.use('*', async (c, next) => {
c.set('user', { id: 'user1', name: 'Test User' })
await next()
})
.route('/', providerRoute)
beforeEach(() => {
vi.restoreAllMocks()
vi.mocked(authzService.hasPermission).mockResolvedValue(undefined)
})
it('GET /teams/:teamId/providers returns providers', async () => {
vi.mocked(providerService.listByTeam).mockResolvedValue([
{ id: 'p1', name: 'openai', config: { api: 'openai' } },
] as unknown as Awaited<ReturnType<typeof providerService.listByTeam>>)
const res = await app.request('/teams/t1/providers')
expect(res.status).toBe(200)
const data = await res.json()
expect(data).toHaveLength(1)
expect(data[0].id).toBe('p1')
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: expect.anything(),
permission: Permission.Admin,
type: ResourceType.Team,
id: 't1',
})
})
it('GET /providers/:id/models returns models', async () => {
vi.mocked(providerService.getById).mockResolvedValue({
id: 'p1',
teamId: 't1',
} as unknown as Awaited<ReturnType<typeof providerService.getById>>)
vi.mocked(providerService.listModelsByProvider).mockResolvedValue([
{ modelId: 'm1', name: 'model1' },
] as unknown as Awaited<ReturnType<typeof providerService.listModelsByProvider>>)
const res = await app.request('/providers/p1/models')
expect(res.status).toBe(200)
const data = await res.json()
expect(data).toHaveLength(1)
expect(data[0].modelId).toBe('m1')
expect(providerService.listModelsByProvider).toHaveBeenCalledWith('t1', 'p1')
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: expect.anything(),
permission: Permission.Admin,
type: ResourceType.Provider,
id: 'p1',
})
})
it('POST /teams/:teamId/providers creates provider', async () => {
const config = {
baseUrl: 'https://api.openai.com/v1',
api: 'openai-completions',
}
const models = [
{
modelId: 'gpt-4',
name: 'GPT-4',
config: {
api: 'openai-completions',
reasoning: false,
input: ['text' as const],
contextWindow: 128000,
maxTokens: 4096,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
},
},
]
vi.mocked(providerService.create).mockResolvedValue({
id: 'p1',
name: 'openai',
config,
models,
} as unknown as Awaited<ReturnType<typeof providerService.create>>)
const res = await app.request('/teams/t1/providers', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ name: 'openai', config, models }),
})
expect(res.status).toBe(200)
const data = await res.json()
expect(data.name).toBe('openai')
expect(providerService.create).toHaveBeenCalledWith('t1', 'openai', config, models)
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: expect.anything(),
permission: Permission.Admin,
type: ResourceType.Team,
id: 't1',
})
expect(auditLogService.logAction).toHaveBeenCalledWith({
action: 'provider_create',
teamId: 't1',
userId: 'user1',
itemId: 'p1',
})
})
it('PUT /providers/:id updates provider', async () => {
const config = {
baseUrl: 'https://new-url.com',
api: 'openai-completions',
}
const models = [
{
modelId: 'gpt-4',
name: 'GPT-4',
config: {
api: 'openai-completions',
reasoning: false,
input: ['text' as const],
contextWindow: 128000,
maxTokens: 4096,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
},
},
]
vi.mocked(providerService.getById).mockResolvedValue({
id: 'p1',
teamId: 't1',
} as unknown as Awaited<ReturnType<typeof providerService.getById>>)
vi.mocked(providerService.update).mockResolvedValue({
id: 'p1',
name: 'openai',
config,
models,
} as unknown as Awaited<ReturnType<typeof providerService.update>>)
const res = await app.request('/providers/p1', {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ name: 'new-name', config, models }),
})
expect(res.status).toBe(200)
const data = await res.json()
expect(data.config.baseUrl).toBe('https://new-url.com')
expect(providerService.update).toHaveBeenCalledWith('t1', 'p1', config, models, 'new-name')
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: expect.anything(),
permission: Permission.Admin,
type: ResourceType.Provider,
id: 'p1',
})
expect(auditLogService.logAction).toHaveBeenCalledWith({
action: 'provider_update',
teamId: 't1',
userId: 'user1',
itemId: 'p1',
})
})
it('POST /providers/:id/models creates a model', async () => {
vi.mocked(providerService.getById).mockResolvedValue({
id: 'p1',
teamId: 't1',
} as unknown as Awaited<ReturnType<typeof providerService.getById>>)
const modelData = {
modelId: 'm1',
name: 'Model 1',
config: {
reasoning: true,
input: ['text' as const],
contextWindow: 128000,
maxTokens: 4096,
cost: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 },
},
}
vi.mocked(providerService.createModel).mockResolvedValue({
id: 'm-db-1',
providerId: 'p1',
modelId: 'm1',
name: 'Model 1',
config: modelData.config,
createdAt: new Date(),
updatedAt: new Date(),
})
const res = await app.request('/providers/p1/models', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(modelData),
})
expect(res.status).toBe(201)
const data = await res.json()
expect(data.id).toBe('m-db-1')
expect(providerService.createModel).toHaveBeenCalledWith('t1', 'p1', modelData)
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: expect.anything(),
permission: Permission.Admin,
type: ResourceType.Provider,
id: 'p1',
})
expect(auditLogService.logAction).toHaveBeenCalledWith({
action: 'provider_update',
teamId: 't1',
userId: 'user1',
itemId: 'p1',
})
})
it('PUT /providers/:id/models/:modelDbId updates a model', async () => {
vi.mocked(providerService.getById).mockResolvedValue({
id: 'p1',
teamId: 't1',
} as unknown as Awaited<ReturnType<typeof providerService.getById>>)
const updateData = {
name: 'Updated Model',
}
vi.mocked(providerService.updateModel).mockResolvedValue({
id: 'm-db-1',
providerId: 'p1',
modelId: 'm1',
name: 'Updated Model',
config: {
reasoning: false,
input: ['text'],
contextWindow: 128000,
maxTokens: 4096,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
},
createdAt: new Date(),
updatedAt: new Date(),
})
const res = await app.request('/providers/p1/models/m-db-1', {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(updateData),
})
expect(res.status).toBe(200)
const data = await res.json()
expect(data.name).toBe('Updated Model')
expect(providerService.updateModel).toHaveBeenCalledWith('t1', 'p1', 'm-db-1', updateData)
})
it('DELETE /providers/:id/models/:modelDbId deletes a model', async () => {
vi.mocked(providerService.getById).mockResolvedValue({
id: 'p1',
teamId: 't1',
} as unknown as Awaited<ReturnType<typeof providerService.getById>>)
vi.mocked(providerService.deleteModel).mockResolvedValue({
id: 'm-db-1',
} as unknown as Awaited<ReturnType<typeof providerService.deleteModel>>)
const res = await app.request('/providers/p1/models/m-db-1', {
method: 'DELETE',
})
expect(res.status).toBe(200)
const data = await res.json()
expect(data.success).toBe(true)
expect(providerService.deleteModel).toHaveBeenCalledWith('t1', 'p1', 'm-db-1')
})
it('DELETE /providers/:id deletes provider', async () => {
vi.mocked(providerService.getById).mockResolvedValue({
id: 'p1',
teamId: 't1',
} as unknown as Awaited<ReturnType<typeof providerService.getById>>)
vi.mocked(providerService.delete).mockResolvedValue({
id: 'p1',
} as unknown as Awaited<ReturnType<typeof providerService.delete>>)
const res = await app.request('/providers/p1', {
method: 'DELETE',
})
expect(res.status).toBe(200)
const data = await res.json()
expect(data.success).toBe(true)
expect(providerService.delete).toHaveBeenCalledWith('t1', 'p1')
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: expect.anything(),
permission: Permission.Admin,
type: ResourceType.Provider,
id: 'p1',
})
expect(auditLogService.logAction).toHaveBeenCalledWith({
action: 'provider_delete',
teamId: 't1',
userId: 'user1',
itemId: 'p1',
})
})
it('POST /teams/:teamId/providers/sync-check checks for updates', async () => {
vi.mocked(providerService.checkUpdates).mockResolvedValue({
providers: [
{
name: 'deepseek',
isNewProvider: true,
config: { api: 'openai-responses', apiKey: 'DEEPSEEK_API_KEY' },
models: [],
},
],
totalNewProviders: 1,
totalNewModels: 0,
})
const res = await app.request('/teams/t1/providers/sync-check', {
method: 'POST',
})
expect(res.status).toBe(200)
const data = await res.json()
expect(data.totalNewProviders).toBe(1)
expect(data.providers).toHaveLength(1)
expect(providerService.checkUpdates).toHaveBeenCalledWith('t1')
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: expect.anything(),
permission: Permission.Admin,
type: ResourceType.Team,
id: 't1',
})
})
it('POST /teams/:teamId/providers/sync-apply applies sync selection', async () => {
vi.mocked(providerService.applySync).mockResolvedValue({
addedProviders: 1,
addedModels: 3,
})
const payload = {
providers: [
{
name: 'deepseek',
isNewProvider: true,
config: { api: 'openai-responses', apiKey: 'KEY' },
models: [
{
modelId: 'deepseek-v4-flash',
name: 'DeepSeek V4 Flash',
config: {
api: 'openai-responses',
reasoning: true,
input: ['text'],
contextWindow: 128000,
maxTokens: 4096,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
},
},
],
},
],
}
const res = await app.request('/teams/t1/providers/sync-apply', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
})
expect(res.status).toBe(200)
const data = await res.json()
expect(data.addedProviders).toBe(1)
expect(data.addedModels).toBe(3)
expect(providerService.applySync).toHaveBeenCalledWith('t1', payload)
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: expect.anything(),
permission: Permission.Admin,
type: ResourceType.Team,
id: 't1',
})
expect(auditLogService.logAction).toHaveBeenCalledWith({
action: 'provider_update',
teamId: 't1',
userId: 'user1',
})
})
})