gitea/FastGPT
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: vitest support (#4026)

Browse Source 
* chore: vitest

* chore: move test files

* chore: support vitest

* fix: exclude test files

* chore(ci): add test workflow

* feat: remove read env
This commit is contained in:
Finley Ge
2025-03-12 19:27:53 +08:00
committed by GitHub
parent 139e934345
commit bb30ca4859
32 changed files with 2393 additions and 892 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
projects/app/src/pages/api/__mocks__/base.ts
View File

@@ -1,130 +0,0 @@
import { MongoMemoryReplSet } from 'mongodb-memory-server';
import mongoose from 'mongoose';
import { parseHeaderCertMock } from '@fastgpt/service/test/utils';
import { initMockData, root } from './db/init';
import { faker } from '@faker-js/faker/locale/zh_CN';
jest.mock('nanoid', () => {
return {
nanoid: () => {}
};
});
jest.mock('@fastgpt/global/common/string/tools', () => {
return {
hashStr(str: string) {
return str;
},
getNanoid() {
return faker.string.alphanumeric(12);
}
};
});
jest.mock('@fastgpt/service/common/system/log', () => ({
addLog: {
log: jest.fn(),
warn: jest.fn((...prop) => {
console.warn(prop);
}),
error: jest.fn((...prop) => {
console.error(prop);
}),
info: jest.fn(),
debug: jest.fn()
}
}));
jest.setMock(
'@fastgpt/service/support/permission/controller',
(() => {
const origin = jest.requireActual<
typeof import('@fastgpt/service/support/permission/controller')
>('@fastgpt/service/support/permission/controller');
return {
...origin,
parseHeaderCert: parseHeaderCertMock
};
})()
);
jest.mock('@/service/middleware/entry', () => {
return {
NextAPI: (...args: any) => {
return async function api(req: any, res: any) {
try {
let response = null;
for (const handler of args) {
response = await handler(req, res);
}
return {
code: 200,
data: response
};
} catch (error) {
return {
code: 500,
error
};
}
};
}
};
});
beforeAll(async () => {
// 新建一个内存数据库，然后让 mongoose 连接这个数据库
if (!global.mongod || !global.mongodb) {
const replSet = new MongoMemoryReplSet({
instanceOpts: [
{
storageEngine: 'wiredTiger'
},
{
storageEngine: 'wiredTiger'
}
]
});
replSet.start();
await replSet.waitUntilRunning();
const uri = replSet.getUri();
// const mongod = await MongoMemoryServer.create({
// instance: {
// replSet: 'testset'
// }
// });
// global.mongod = mongod;
global.replSet = replSet;
global.mongodb = mongoose;
await global.mongodb.connect(uri, {
dbName: 'fastgpt_test',
bufferCommands: true,
maxConnecting: 50,
maxPoolSize: 50,
minPoolSize: 20,
connectTimeoutMS: 60000,
waitQueueTimeoutMS: 60000,
socketTimeoutMS: 60000,
maxIdleTimeMS: 300000,
retryWrites: true,
retryReads: true
});
await initMockData();
console.log(root);
}
});
afterAll(async () => {
if (global.mongodb) {
await global.mongodb.disconnect();
}
if (global.replSet) {
await global.replSet.stop();
}
if (global.mongod) {
await global.mongod.stop();
}
});

56
projects/app/src/pages/api/__mocks__/db/init.ts
View File

@@ -1,56 +0,0 @@
import { DefaultGroupName } from '@fastgpt/global/support/user/team/group/constant';
import { MongoApp } from '@fastgpt/service/core/app/schema';
import { MongoMemberGroupModel } from '@fastgpt/service/support/permission/memberGroup/memberGroupSchema';
import { MongoUser } from '@fastgpt/service/support/user/schema';
import { MongoTeamMember } from '@fastgpt/service/support/user/team/teamMemberSchema';
import { MongoTeam } from '@fastgpt/service/support/user/team/teamSchema';
export const root = {
uid: '',
tmbId: '',
teamId: '',
isRoot: true,
appId: ''
};
export const initMockData = async () => {
const [rootUser] = await MongoUser.create([
{
username: 'root',
password: '123456'
}
]);
root.uid = String(rootUser._id);
const [rootTeam] = await MongoTeam.create([
{
name: 'root Team'
}
]);
root.teamId = String(rootTeam._id);
const [rootTmb] = await MongoTeamMember.create([
{
teamId: rootTeam._id,
name: 'owner',
role: 'owner',
userId: rootUser._id,
status: 'active'
}
]);
root.tmbId = String(rootTmb._id);
await MongoMemberGroupModel.create([
{
name: DefaultGroupName,
teamId: rootTeam._id
}
]);
const [rootApp] = await MongoApp.create([
{
name: 'root Test App',
teamId: rootTeam._id,
tmbId: rootTmb._id
}
]);
root.appId = String(rootApp._id);
};

61
projects/app/src/pages/api/__mocks__/demo/demo.test.ts
View File

@@ -1,61 +0,0 @@
import '@/pages/api/__mocks__/base';
import { root } from '@/pages/api/__mocks__/db/init';
import { getTestRequest } from '@fastgpt/service/test/utils';
import { AppErrEnum } from '@fastgpt/global/common/error/code/app';
import handler from './demo';
// Import the schema
import { MongoOutLink } from '@fastgpt/service/support/outLink/schema';
beforeAll(async () => {
// await MongoOutLink.create({
// shareId: 'aaa',
// appId: root.appId,
// tmbId: root.tmbId,
// teamId: root.teamId,
// type: 'share',
// name: 'aaa'
// })
});
test('Should return a list of outLink', async () => {
// Mock request
const res = (await handler(
...getTestRequest({
query: {
appId: root.appId,
type: 'share'
},
user: root
})
)) as any;
expect(res.code).toBe(200);
expect(res.data.length).toBe(2);
});
test('appId is required', async () => {
const res = (await handler(
...getTestRequest({
query: {
type: 'share'
},
user: root
})
)) as any;
expect(res.code).toBe(500);
expect(res.error).toBe(AppErrEnum.unExist);
});
test('if type is not provided, return nothing', async () => {
const res = (await handler(
...getTestRequest({
query: {
appId: root.appId
},
user: root
})
)) as any;
expect(res.code).toBe(200);
expect(res.data.length).toBe(0);
});

17
projects/app/src/pages/api/__mocks__/demo/demo.ts
View File

@@ -1,17 +0,0 @@
import type { ApiRequestProps, ApiResponseType } from '@fastgpt/service/type/next';
import { NextAPI } from '@/service/middleware/entry';
export type demoQuery = {};
export type demoBody = {};
export type demoResponse = {};
async function handler(
req: ApiRequestProps<demoBody, demoQuery>,
res: ApiResponseType<any>
): Promise<demoResponse> {
return {};
}
export default NextAPI(handler);

11
projects/app/src/pages/api/__mocks__/type.d.ts vendored
View File

@@ -1,11 +0,0 @@
import type { MongoMemoryReplSet, MongoMemoryServer } from 'mongodb-memory-server';
declare global {
var mongod: MongoMemoryServer | undefined;
var replSet: MongoMemoryReplSet | undefined;
}
export type RequestResponse<T = any> = {
code: number;
error?: string;
data?: T;
};

55
projects/app/src/pages/api/core/app/version/latest.test.ts
View File

@@ -1,55 +0,0 @@
import '@/pages/api/__mocks__/base';
import { root } from '@/pages/api/__mocks__/db/init';
import { getTestRequest } from '@fastgpt/service/test/utils';
import handler, { getLatestVersionQuery, getLatestVersionResponse } from './latest';
import { MongoAppVersion } from '@fastgpt/service/core/app/version/schema';
beforeAll(async () => {
// 创建3个测试数据，其中2个是已发布的
await MongoAppVersion.create([
{
appId: root.appId,
nodes: [1],
edges: [],
chatConfig: {},
isPublish: false,
versionName: 'v1',
tmbId: root.tmbId,
time: new Date('2023-01-01')
},
{
appId: root.appId,
nodes: [2],
edges: [],
chatConfig: {},
isPublish: true,
versionName: 'v2',
tmbId: root.tmbId,
time: new Date('2023-01-02')
},
{
appId: root.appId,
nodes: [3],
edges: [],
chatConfig: {},
isPublish: false,
versionName: 'v3',
tmbId: root.tmbId,
time: new Date('2023-01-03')
}
]);
});
test('获取最新版本并检查', async () => {
const _res = (await handler(
...getTestRequest<{}, getLatestVersionQuery>({
query: {
appId: root.appId
},
user: root
})
)) as any;
const res = _res.data as getLatestVersionResponse;
expect(res.nodes[0]).toEqual(2);
});

69
projects/app/src/pages/api/core/app/version/lis.test.ts
View File

@@ -1,69 +0,0 @@
import '@/pages/api/__mocks__/base';
import { root } from '@/pages/api/__mocks__/db/init';
import { getTestRequest } from '@fastgpt/service/test/utils';
import handler, { versionListBody, versionListResponse } from './list';
// Import the schema
import { MongoAppVersion } from '@fastgpt/service/core/app/version/schema';
const total = 22;
beforeAll(async () => {
const arr = new Array(total).fill(0);
await MongoAppVersion.insertMany(
arr.map((_, index) => ({
appId: root.appId,
nodes: [],
edges: [],
chatConfig: {},
isPublish: index % 2 === 0,
versionName: `v` + index,
tmbId: root.tmbId,
time: new Date(index * 1000)
}))
);
});
test('Get version list and check', async () => {
const offset = 0;
const pageSize = 10;
const _res = (await handler(
...getTestRequest<{}, versionListBody>({
body: {
offset,
pageSize,
appId: root.appId
},
user: root
})
)) as any;
const res = _res.data as versionListResponse;
expect(res.total).toBe(total);
expect(res.list.length).toBe(pageSize);
expect(res.list[0].versionName).toBe('v21');
expect(res.list[9].versionName).toBe('v12');
});
test('Get version list with offset 20', async () => {
const offset = 20;
const pageSize = 10;
const _res = (await handler(
...getTestRequest<{}, versionListBody>({
body: {
offset,
pageSize,
appId: root.appId
},
user: root
})
)) as any;
const res = _res.data as versionListResponse;
expect(res.total).toBe(total);
expect(res.list.length).toBe(2);
expect(res.list[0].versionName).toBe('v1');
expect(res.list[1].versionName).toBe('v0');
});

35
projects/app/src/pages/api/core/app/version/list.test.ts Normal file
View File

@@ -0,0 +1,35 @@
import { MongoApp } from '@fastgpt/service/core/app/schema';
import { MongoAppVersion } from '@fastgpt/service/core/app/version/schema';
import { getRootUser } from '@test/datas/users';
import { Call } from '@test/utils/request';
import { describe, expect, it } from 'vitest';
import handler, { type versionListBody, type versionListResponse } from './list';
describe('app version list test', () => {
it('should return app version list', async () => {
const root = await getRootUser();
const app = await MongoApp.create({
name: 'test',
tmbId: root.tmbId,
teamId: root.teamId
});
await MongoAppVersion.create(
[...Array(10).keys()].map((i) => ({
tmbId: root.tmbId,
appId: app._id,
versionName: `v${i}`
}))
);
const res = await Call<versionListBody, {}, versionListResponse>(handler, {
auth: root,
body: {
pageSize: 10,
offset: 0,
appId: app._id
}
});
expect(res.code).toBe(200);
expect(res.data.total).toBe(10);
expect(res.data.list.length).toBe(10);
});
});

36
projects/app/src/pages/api/core/app/version/publish.test.ts
View File

@@ -1,36 +0,0 @@
import '@/pages/api/__mocks__/base';
import { root } from '@/pages/api/__mocks__/db/init';
import { getTestRequest } from '@fastgpt/service/test/utils';
import handler from './publish';
import { MongoAppVersion } from '@fastgpt/service/core/app/version/schema';
import { PostPublishAppProps } from '@/global/core/app/api';
import { AppTypeEnum } from '@fastgpt/global/core/app/constants';
describe('发布应用版本测试', () => {
test('发布一个未发布的版本', async () => {
const publishData: PostPublishAppProps = {
nodes: [],
edges: [],
chatConfig: {},
isPublish: false,
versionName: '1'
};
await handler(
...getTestRequest<{ appId: string }, PostPublishAppProps>({
body: publishData,
query: { appId: root.appId },
user: root
})
);
// 检查数据库是否插入成功
const insertedVersion = await MongoAppVersion.countDocuments();
console.log(insertedVersion, '==-');
// expect(insertedVersion).toBeTruthy();
// expect(insertedVersion?.isPublish).toBe(false);
// expect(insertedVersion?.versionName).toBe('1');
});
});

67
projects/app/src/pages/api/support/outLink/list.test.ts
View File

@@ -1,67 +0,0 @@
import '../../__mocks__/base';
import { root } from '../../__mocks__/db/init';
import { getTestRequest } from '@fastgpt/service/test/utils';
import type { OutLinkListQuery } from './list';
import { AppErrEnum } from '@fastgpt/global/common/error/code/app';
import handler from './list';
import { MongoOutLink } from '@fastgpt/service/support/outLink/schema';
beforeAll(async () => {
await MongoOutLink.create({
shareId: 'aaa',
appId: root.appId,
tmbId: root.tmbId,
teamId: root.teamId,
type: 'share',
name: 'aaa'
});
await MongoOutLink.create({
shareId: 'bbb',
appId: root.appId,
tmbId: root.tmbId,
teamId: root.teamId,
type: 'share',
name: 'bbb'
});
});
test('Should return a list of outLink', async () => {
const res = (await handler(
...getTestRequest<OutLinkListQuery>({
query: {
appId: root.appId,
type: 'share'
},
user: root
})
)) as any;
expect(res.code).toBe(200);
expect(res.data.length).toBe(2);
});
test('appId is required', async () => {
const res = (await handler(
...getTestRequest<OutLinkListQuery>({
query: {
type: 'share'
},
user: root
})
)) as any;
expect(res.code).toBe(500);
expect(res.error).toBe(AppErrEnum.unExist);
});
test('if type is not provided, return nothing', async () => {
const res = (await handler(
...getTestRequest<OutLinkListQuery>({
query: {
appId: root.appId
},
user: root
})
)) as any;
expect(res.code).toBe(200);
expect(res.data.length).toBe(0);
});

54
projects/app/src/pages/api/support/outLink/update.test.ts
View File

@@ -1,54 +0,0 @@
import '../../__mocks__/base';
import { getTestRequest } from '@fastgpt/service/test/utils';
import handler, { OutLinkUpdateBody, OutLinkUpdateQuery } from './update';
import { MongoOutLink } from '@fastgpt/service/support/outLink/schema';
import { CommonErrEnum } from '@fastgpt/global/common/error/code/common';
import { root } from '../../__mocks__/db/init';
beforeAll(async () => {
await MongoOutLink.create({
shareId: 'aaa',
appId: root.appId,
tmbId: root.tmbId,
teamId: root.teamId,
type: 'share',
name: 'aaa'
});
});
test('Update Outlink', async () => {
const outlink = await MongoOutLink.findOne({ name: 'aaa' }).lean();
if (!outlink) {
throw new Error('Outlink not found');
}
const res = (await handler(
...getTestRequest<OutLinkUpdateQuery, OutLinkUpdateBody>({
body: {
_id: outlink._id,
name: 'changed'
},
user: root
})
)) as any;
console.log(res);
expect(res.code).toBe(200);
const link = await MongoOutLink.findById(outlink._id).lean();
expect(link?.name).toBe('changed');
});
test('Did not post _id', async () => {
const res = (await handler(
...getTestRequest<OutLinkUpdateQuery, OutLinkUpdateBody>({
body: {
name: 'changed'
},
user: root
})
)) as any;
expect(res.code).toBe(500);
expect(res.error).toBe(CommonErrEnum.missingParams);
});

145
projects/app/src/pages/api/v1/chat/utils.test.ts
View File

@@ -1,145 +0,0 @@
import '@/pages/api/__mocks__/base';
import { parseReasoningStreamContent } from '@fastgpt/service/core/ai/utils';
test('Parse reasoning stream content test', async () => {
const partList = [
{
data: [{ content: '你好1' }, { content: '你好2' }, { content: '你好3' }],
correct: { answer: '你好1你好2你好3', reasoning: '' }
},
{
data: [
{ reasoning_content: '这是' },
{ reasoning_content: '思考' },
{ reasoning_content: '过程' },
{ content: '你好1' },
{ content: '你好2' },
{ content: '你好3' }
],
correct: { answer: '你好1你好2你好3', reasoning: '这是思考过程' }
},
{
data: [
{ content: '<t' },
{ content: 'hink>' },
{ content: '这是' },
{ content: '思考' },
{ content: '过程' },
{ content: '</think>' },
{ content: '你好1' },
{ content: '你好2' },
{ content: '你好3' }
],
correct: { answer: '你好1你好2你好3', reasoning: '这是思考过程' }
},
{
data: [
{ content: '<think>' },
{ content: '这是' },
{ content: '思考' },
{ content: '过程' },
{ content: '</think>' },
{ content: '你好1' },
{ content: '你好2' },
{ content: '你好3' }
],
correct: { answer: '你好1你好2你好3', reasoning: '这是思考过程' }
},
{
data: [
{ content: '<think>这是' },
{ content: '思考' },
{ content: '过程' },
{ content: '</think>' },
{ content: '你好1' },
{ content: '你好2' },
{ content: '你好3' }
],
correct: { answer: '你好1你好2你好3', reasoning: '这是思考过程' }
},
{
data: [
{ content: '<think>这是' },
{ content: '思考' },
{ content: '过程</' },
{ content: 'think>' },
{ content: '你好1' },
{ content: '你好2' },
{ content: '你好3' }
],
correct: { answer: '你好1你好2你好3', reasoning: '这是思考过程' }
},
{
data: [
{ content: '<think>这是' },
{ content: '思考' },
{ content: '过程</think>' },
{ content: '你好1' },
{ content: '你好2' },
{ content: '你好3' }
],
correct: { answer: '你好1你好2你好3', reasoning: '这是思考过程' }
},
{
data: [
{ content: '<think>这是' },
{ content: '思考' },
{ content: '过程</think>你好1' },
{ content: '你好2' },
{ content: '你好3' }
],
correct: { answer: '你好1你好2你好3', reasoning: '这是思考过程' }
},
{
data: [
{ content: '<think>这是' },
{ content: '思考' },
{ content: '过程</th' },
{ content: '假的' },
{ content: '你好2' },
{ content: '你好3' },
{ content: '过程</think>你好1' },
{ content: '你好2' },
{ content: '你好3' }
],
correct: { answer: '你好1你好2你好3', reasoning: '这是思考过程</th假的你好2你好3过程' }
},
{
data: [
{ content: '<think>这是' },
{ content: '思考' },
{ content: '过程</th' },
{ content: '假的' },
{ content: '你好2' },
{ content: '你好3' }
],
correct: { answer: '', reasoning: '这是思考过程</th假的你好2你好3' }
}
];
partList.forEach((part) => {
const { parsePart } = parseReasoningStreamContent();
let answer = '';
let reasoning = '';
part.data.forEach((item) => {
const formatPart = {
choices: [
{
delta: {
role: 'assistant',
content: item.content,
reasoning_content: item.reasoning_content
}
}
]
};
const [reasoningContent, content] = parsePart(formatPart, true);
answer += content;
reasoning += reasoningContent;
});
expect(answer).toBe(part.correct.answer);
expect(reasoning).toBe(part.correct.reasoning);
});
});