mirror of
https://github.com/shumaiOne/shumai.git
synced 2026-11-22 09:26:53 +00:00
* 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.
408 lines
12 KiB
TypeScript
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',
|
|
})
|
|
})
|
|
})
|