ChatGPT/FastGPT
1
0
Fork 0
mirror of https://github.com/labring/FastGPT.git synced 2025-07-18 10:03:55 +00:00
Code Issues 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

29
.github/workflows/fastgpt-test.yaml vendored Normal file
View File

@@ -0,0 +1,29 @@
name: 'FastGPT-Test'
on:
pull_request:
workflow_dispatch:
jobs:
test:
runs-on: ubuntu-latest
permissions:
# Required to checkout the code
contents: read
# Required to put a comment into the pull-request
pull-requests: write
steps:
- uses: actions/checkout@v4
- uses: pnpm/action-setup@v4
with:
version: 10
- name: 'Install Deps'
run: pnpm install
- name: 'Test'
run: pnpm run test
- name: 'Report Coverage'
# Set if: always() to also generate the report if tests are failing
# Only works if you set `reportOnFailure: true` in your vite config as specified above
if: always()
uses: davelosert/vitest-coverage-report-action@v2

1
.gitignore vendored
View File

@@ -44,3 +44,4 @@ files/helm/fastgpt/fastgpt-0.1.0.tgz
files/helm/fastgpt/charts/*.tgz
tmp/
coverage

12
package.json
View File

@@ -11,16 +11,22 @@
"initIcon": "node ./scripts/icon/init.js",
"previewIcon": "node ./scripts/icon/index.js",
"api:gen": "tsc ./scripts/openapi/index.ts && node ./scripts/openapi/index.js && npx @redocly/cli build-docs ./scripts/openapi/openapi.json -o ./projects/app/public/openapi/index.html",
"create:i18n": "node ./scripts/i18n/index.js"
"create:i18n": "node ./scripts/i18n/index.js",
"test": "vitest run --exclude './projects/app/src/test/**'",
"test:all": "vitest run",
"test:workflow": "vitest run workflow"
},
"devDependencies": {
"@chakra-ui/cli": "^2.4.1",
"@vitest/coverage-v8": "^3.0.2",
"husky": "^8.0.3",
"lint-staged": "^13.3.0",
"i18next": "23.11.5",
"lint-staged": "^13.3.0",
"next-i18next": "15.3.0",
"react-i18next": "14.1.2",
"prettier": "3.2.4",
"react-i18next": "14.1.2",
"vitest": "^3.0.2",
"vitest-mongodb": "^1.0.1",
"zhlint": "^0.7.4"
},
"lint-staged": {

4
projects/app/src/pages/api/v1/chat/utils.test.ts → packages/service/core/ai/utils.test.ts
View File

@@ -1,5 +1,5 @@
import '@/pages/api/__mocks__/base';
import { parseReasoningStreamContent } from '@fastgpt/service/core/ai/utils';
import { parseReasoningStreamContent } from './utils';
import { expect, test } from 'vitest';
test('Parse reasoning stream content test', async () => {
const partList = [

94
packages/service/test/utils.ts
View File

@@ -1,94 +0,0 @@
import { ERROR_ENUM } from '@fastgpt/global/common/error/errorCode';
export type TestTokenType = {
userId: string;
teamId: string;
tmbId: string;
isRoot: boolean;
};
export type TestRequest = {
headers: {
cookie?: {
token?: TestTokenType;
};
authorization?: string; // testkey
rootkey?: string; // rootkey
};
query: {
[key: string]: string;
};
body: {
[key: string]: string;
};
};
export function getTestRequest<Q = any, B = any>({
query = {},
body = {},
authToken = true,
// authRoot = false,
// authApiKey = false,
user
}: {
query?: Partial<Q>;
body?: Partial<B>;
authToken?: boolean;
authRoot?: boolean;
authApiKey?: boolean;
user?: {
uid: string;
tmbId: string;
teamId: string;
isRoot: boolean;
};
}): [any, any] {
const headers: TestRequest['headers'] = {};
if (authToken) {
headers.cookie = {
token: {
userId: String(user?.uid || ''),
teamId: String(user?.teamId || ''),
tmbId: String(user?.tmbId || ''),
isRoot: user?.isRoot || false
}
};
}
return [
{
headers,
query,
body
},
{}
];
}
export const parseHeaderCertMock = async ({
req,
authToken = true,
authRoot = false,
authApiKey = false
}: {
req: TestRequest;
authToken?: boolean;
authRoot?: boolean;
authApiKey?: boolean;
}): Promise<TestTokenType> => {
if (authToken) {
const token = req.headers?.cookie?.token;
if (!token) {
return Promise.reject(ERROR_ENUM.unAuthorization);
}
return token;
}
// if (authRoot) {
// // TODO: unfinished
// return req.headers.rootkey;
// }
// if (authApiKey) {
// // TODO: unfinished
// return req.headers.authorization;
// }
return {} as any;
};

1267
pnpm-lock.yaml generated
View File

File diff suppressed because it is too large Load Diff

179
projects/app/jest.config.js
View File

@@ -1,179 +0,0 @@
/**
* For a detailed explanation regarding each configuration property, visit:
* https://jestjs.io/docs/configuration
*/
const esModules = ['nanoid'].join('|');
/** @type {import('jest').Config} */
const config = {
// All imported modules in your tests should be mocked automatically
// automock: false,
// Stop running tests after `n` failures
// bail: 0,
// The directory where Jest should store its cached dependency information
// cacheDirectory: "/tmp/jest_rs",
// Automatically clear mock calls, instances, contexts and results before every test
// clearMocks: false,
// Indicates whether the coverage information should be collected while executing the test
collectCoverage: true,
// An array of glob patterns indicating a set of files for which coverage information should be collected
// collectCoverageFrom: undefined,
// The directory where Jest should output its coverage files
coverageDirectory: './tmp/coverage',
// An array of regexp pattern strings used to skip coverage collection
coveragePathIgnorePatterns: ['/node_modules/', '/__mocks__/', '/src/test/'],
// Indicates which provider should be used to instrument code for coverage
// coverageProvider: "babel",
// A list of reporter names that Jest uses when writing coverage reports
coverageReporters: ['json', 'text', 'lcov', 'clover'],
// An object that configures minimum threshold enforcement for coverage results
// coverageThreshold: undefined,
// A path to a custom dependency extractor
// dependencyExtractor: undefined,
// Make calling deprecated APIs throw helpful error messages
// errorOnDeprecated: false,
// The default configuration for fake timers
// fakeTimers: {
// "enableGlobally": false
// },
// Force coverage collection from ignored files using an array of glob patterns
// forceCoverageMatch: [],
// A path to a module which exports an async function that is triggered once before all test suites
// globalSetup: undefined,
// A path to a module which exports an async function that is triggered once after all test suites
// globalTeardown: undefined,
// A set of global variables that need to be available in all test environments
// globals: {},
// The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
// maxWorkers: "50%",
// An array of directory names to be searched recursively up from the requiring module's location
moduleDirectories: ['node_modules', 'src'],
// An array of file extensions your modules use
// moduleFileExtensions: ['js', 'mjs', 'cjs', 'jsx', 'ts', 'tsx', 'json', 'node'],
// A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
moduleNameMapper: {
'@/(.*)': '<rootDir>/src/$1',
'^nanoid(/(.*)|$)': 'nanoid$1'
},
// An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
// modulePathIgnorePatterns: [],
// Activates notifications for test results
// notify: false,
// An enum that specifies notification mode. Requires { notify: true }
// notifyMode: "failure-change",
// A preset that is used as a base for Jest's configuration
preset: 'ts-jest',
// Run tests from one or more projects
// projects: undefined,
// Use this configuration option to add custom reporters to Jest
// reporters: undefined,
// Automatically reset mock state before every test
// resetMocks: false,
// Reset the module registry before running each individual test
// resetModules: false,
// A path to a custom resolver
// resolver: undefined,
// Automatically restore mock state and implementation before every test
// restoreMocks: false,
// The root directory that Jest should scan for tests and modules within
// rootDir: undefined,
// A list of paths to directories that Jest should use to search for files in
// roots: [
// "<rootDir>"
// ],
// Allows you to use a custom runner instead of Jest's default test runner
// runner: "jest-runner",
// The paths to modules that run some code to configure or set up the testing environment before each test
// setupFiles: [],
// A list of paths to modules that run some code to configure or set up the testing framework before each test
// setupFilesAfterEnv: [],
// The number of seconds after which a test is considered as slow and reported as such in the results.
// slowTestThreshold: 5,
// A list of paths to snapshot serializer modules Jest should use for snapshot testing
// snapshotSerializers: [],
// The test environment that will be used for testing
testEnvironment: 'node',
// Options that will be passed to the testEnvironment
// testEnvironmentOptions: {},
// Adds a location field to test results
// testLocationInResults: false,
// The glob patterns Jest uses to detect test files
// testMatch: [
// "**/__tests__/**/*.[jt]s?(x)",
// "**/?(*.)+(spec|test).[tj]s?(x)"
// ],
// An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
// testPathIgnorePatterns: ['/node_modules/'],
// The regexp pattern or array of patterns that Jest uses to detect test files
// testRegex: [],
// This option allows the use of a custom results processor
// testResultsProcessor: undefined,
// This option allows use of a custom test runner
// testRunner: "jest-circus/runner",
// A map from regular expressions to paths to transformers
transform: {},
// An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
transformIgnorePatterns: [`/node_modules/(?!${esModules})`]
// An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
// unmockedModulePathPatterns: undefined,
// Indicates whether each individual test should be reported during the run
// verbose: undefined,
// An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
// watchPathIgnorePatterns: [],
// Whether to use watchman for file crawling
// watchman: true,
};
module.exports = config;

10
projects/app/package.json
View File

@@ -6,8 +6,7 @@
"dev": "next dev",
"build": "next build",
"start": "next start",
"lint": "next lint",
"test": "jest"
"lint": "next lint"
},
"dependencies": {
"@chakra-ui/anatomy": "2.2.1",
@@ -26,7 +25,6 @@
"@fortaine/fetch-event-source": "^3.0.6",
"@node-rs/jieba": "1.10.0",
"@tanstack/react-query": "^4.24.10",
"@types/jest": "^29.5.2",
"@types/nprogress": "^0.2.0",
"ahooks": "^3.7.11",
"axios": "^1.8.2",
@@ -39,7 +37,6 @@
"hyperdown": "^2.4.29",
"i18next": "23.11.5",
"immer": "^9.0.19",
"jest": "^29.5.0",
"js-yaml": "^4.1.0",
"json5": "^2.2.3",
"jsondiffpatch": "^0.6.0",
@@ -69,13 +66,10 @@
"remark-math": "^6.0.0",
"request-ip": "^3.3.0",
"sass": "^1.58.3",
"ts-jest": "^29.1.0",
"use-context-selector": "^1.4.4",
"zustand": "^4.3.5"
},
"devDependencies": {
"@faker-js/faker": "^9.0.3",
"@shelf/jest-mongodb": "^4.3.2",
"@svgr/webpack": "^6.5.1",
"@types/formidable": "^2.0.5",
"@types/js-yaml": "^4.0.9",
@@ -89,8 +83,6 @@
"@types/request-ip": "^0.0.37",
"eslint": "8.56.0",
"eslint-config-next": "14.2.3",
"mockingoose": "^2.16.2",
"mongodb-memory-server": "^10.0.0",
"nextjs-node-loader": "^1.1.5",
"typescript": "^5.1.3"
}

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);
});

358
projects/app/src/test/workflow/loopTest.json Normal file
View File

@@ -0,0 +1,358 @@
{
"nodes": [
{
"nodeId": "userGuide",
"name": "common:core.module.template.system_config",
"intro": "common:core.module.template.system_config_info",
"avatar": "core/workflow/template/systemConfig",
"flowNodeType": "userGuide",
"position": {
"x": 220.4077028616387,
"y": -429.3158723159836
},
"version": "481",
"inputs": [
{
"key": "welcomeText",
"renderTypeList": [
"hidden"
],
"valueType": "string",
"label": "core.app.Welcome Text",
"value": ""
},
{
"key": "variables",
"renderTypeList": [
"hidden"
],
"valueType": "any",
"label": "core.app.Chat Variable",
"value": []
},
{
"key": "questionGuide",
"valueType": "any",
"renderTypeList": [
"hidden"
],
"label": "core.app.Question Guide",
"value": {
"open": false
}
},
{
"key": "tts",
"renderTypeList": [
"hidden"
],
"valueType": "any",
"label": "",
"value": {
"type": "web"
}
},
{
"key": "whisper",
"renderTypeList": [
"hidden"
],
"valueType": "any",
"label": "",
"value": {
"open": false,
"autoSend": false,
"autoTTSResponse": false
}
},
{
"key": "scheduleTrigger",
"renderTypeList": [
"hidden"
],
"valueType": "any",
"label": "",
"value": null
}
],
"outputs": []
},
{
"nodeId": "448745",
"name": "common:core.module.template.work_start",
"intro": "",
"avatar": "core/workflow/template/workflowStart",
"flowNodeType": "workflowStart",
"position": {
"x": 773.4174945178407,
"y": -331.3158723159836
},
"version": "481",
"inputs": [
{
"key": "userChatInput",
"renderTypeList": [
"reference",
"textarea"
],
"valueType": "string",
"label": "common:core.module.input.label.user question",
"required": true,
"toolDescription": "用户问题",
"debugLabel": ""
}
],
"outputs": [
{
"id": "userChatInput",
"key": "userChatInput",
"label": "common:core.module.input.label.user question",
"type": "static",
"valueType": "string",
"description": ""
}
]
},
{
"nodeId": "nlv8iMRsvgkA",
"name": "批量执行",
"intro": "输入一个数组，遍历数组并将每一个数组元素作为输入元素，执行工作流。",
"avatar": "core/workflow/template/loop",
"flowNodeType": "loop",
"showStatus": true,
"position": {
"x": 1236,
"y": -593
},
"version": "4811",
"inputs": [
{
"key": "loopInputArray",
"renderTypeList": [
"reference"
],
"valueType": "arrayNumber",
"required": true,
"label": "数组",
"value": [
[
"VARIABLE_NODE_ID",
"list"
]
],
"valueDesc": "",
"description": "",
"debugLabel": "",
"toolDescription": ""
},
{
"key": "childrenNodeIdList",
"renderTypeList": [
"hidden"
],
"valueType": "arrayString",
"label": "",
"value": [
"tRxC7faEoGuE",
"cGnptXbKAyMN"
]
},
{
"key": "nodeWidth",
"renderTypeList": [
"hidden"
],
"valueType": "number",
"label": "",
"value": 1246.6404923618281
},
{
"key": "nodeHeight",
"renderTypeList": [
"hidden"
],
"valueType": "number",
"label": "",
"value": 642.1566957382456
},
{
"key": "loopNodeInputHeight",
"renderTypeList": [
"hidden"
],
"valueType": "number",
"label": "",
"value": 83,
"valueDesc": "",
"description": "",
"debugLabel": "",
"toolDescription": ""
}
],
"outputs": [
{
"id": "loopArray",
"key": "loopArray",
"label": "数组执行结果",
"type": "static",
"valueType": "arrayAny",
"valueDesc": "",
"description": ""
}
]
},
{
"nodeId": "tRxC7faEoGuE",
"parentNodeId": "nlv8iMRsvgkA",
"name": "开始",
"avatar": "core/workflow/template/loopStart",
"flowNodeType": "loopStart",
"showStatus": false,
"position": {
"x": 1305.782937883576,
"y": -270.30845154767246
},
"version": "4811",
"inputs": [
{
"key": "loopStartInput",
"renderTypeList": [
"hidden"
],
"valueType": "any",
"label": "",
"required": true,
"value": ""
},
{
"key": "loopStartIndex",
"renderTypeList": [
"hidden"
],
"valueType": "number",
"label": "workflow:Array_element_index"
}
],
"outputs": [
{
"id": "loopStartIndex",
"key": "loopStartIndex",
"label": "workflow:Array_element_index",
"type": "static",
"valueType": "number"
},
{
"id": "loopStartInput",
"key": "loopStartInput",
"label": "数组元素",
"type": "static",
"valueType": "number"
}
]
},
{
"nodeId": "cGnptXbKAyMN",
"parentNodeId": "nlv8iMRsvgkA",
"name": "结束",
"avatar": "core/workflow/template/loopEnd",
"flowNodeType": "loopEnd",
"showStatus": false,
"position": {
"x": 1929.4234302454042,
"y": 135.8482441905731
},
"version": "4811",
"inputs": [
{
"key": "loopEndInput",
"renderTypeList": [
"reference"
],
"valueType": "any",
"label": "",
"required": true,
"value": []
}
],
"outputs": []
},
{
"nodeId": "zpOBWBxfyUap",
"parentNodeId": "nlv8iMRsvgkA",
"name": "指定回复",
"intro": "该模块可以直接回复一段指定的内容。常用于引导、提示。非字符串内容传入时，会转成字符串进行输出。",
"avatar": "core/workflow/template/reply",
"flowNodeType": "answerNode",
"position": {
"x": 1806.423430245404,
"y": -217.4185397094268
},
"version": "481",
"inputs": [
{
"key": "text",
"renderTypeList": [
"textarea",
"reference"
],
"valueType": "any",
"required": true,
"label": "回复的内容",
"description": "可以使用 \\n 来实现连续换行。\n可以通过外部模块输入实现回复，外部模块输入时会覆盖当前填写的内容。\n如传入非字符串类型数据将会自动转成字符串",
"placeholder": "common:core.module.input.description.Response content",
"value": "{{$tRxC7faEoGuE.loopStartInput$}}",
"valueDesc": "",
"debugLabel": "",
"toolDescription": ""
}
],
"outputs": []
}
],
"edges": [
{
"source": "448745",
"target": "nlv8iMRsvgkA",
"sourceHandle": "448745-source-right",
"targetHandle": "nlv8iMRsvgkA-target-left"
},
{
"source": "tRxC7faEoGuE",
"target": "zpOBWBxfyUap",
"sourceHandle": "tRxC7faEoGuE-source-right",
"targetHandle": "zpOBWBxfyUap-target-left"
}
],
"chatConfig": {
"variables": [
{
"id": "04sm7m",
"key": "list",
"label": "list",
"type": "custom",
"description": "",
"required": false,
"valueType": "arrayNumber",
"list": [
{
"value": "",
"label": ""
}
],
"defaultValue": "[1,2,3]",
"enums": [
{
"value": "",
"label": ""
}
]
}
],
"_id": "67a8d281b54c01f7bd95c995",
"scheduledTriggerConfig": {
"cronString": "",
"timezone": "Asia/Shanghai",
"defaultPrompt": ""
}
}
}

319
projects/app/src/test/workflow/simple.json Normal file
View File

@@ -0,0 +1,319 @@
{
"nodes": [
{
"nodeId": "userGuide",
"name": "系统配置",
"intro": "",
"avatar": "core/workflow/template/systemConfig",
"flowNodeType": "userGuide",
"position": {
"x": 531.2422736065552,
"y": -486.7611729549753
},
"version": "481",
"inputs": [],
"outputs": []
},
{
"nodeId": "workflowStartNodeId",
"name": "流程开始",
"intro": "",
"avatar": "core/workflow/template/workflowStart",
"flowNodeType": "workflowStart",
"position": {
"x": 531.2422736065552,
"y": 244.69591764653183
},
"version": "481",
"inputs": [
{
"key": "userChatInput",
"renderTypeList": [
"reference",
"textarea"
],
"valueType": "string",
"label": "workflow:user_question",
"toolDescription": "用户问题",
"required": true,
"debugLabel": ""
}
],
"outputs": [
{
"id": "userChatInput",
"key": "userChatInput",
"label": "common:core.module.input.label.user question",
"type": "static",
"valueType": "string",
"description": ""
},
{
"id": "userFiles",
"key": "userFiles",
"label": "app:workflow.user_file_input",
"description": "app:workflow.user_file_input_desc",
"type": "static",
"valueType": "arrayString"
}
]
},
{
"nodeId": "7BdojPlukIQw",
"name": "AI 对话",
"intro": "AI 大模型对话",
"avatar": "core/workflow/template/aiChat",
"flowNodeType": "chatNode",
"showStatus": true,
"position": {
"x": 1106.3238387960757,
"y": -350.6030674683474
},
"version": "4813",
"inputs": [
{
"key": "model",
"renderTypeList": [
"settingLLMModel",
"reference"
],
"label": "",
"valueType": "string",
"value": "deepseek-reasoner",
"debugLabel": "",
"toolDescription": ""
},
{
"key": "temperature",
"renderTypeList": [
"hidden"
],
"label": "",
"value": 0,
"valueType": "number",
"min": 0,
"max": 10,
"step": 1,
"debugLabel": "",
"toolDescription": ""
},
{
"key": "maxToken",
"renderTypeList": [
"hidden"
],
"label": "",
"value": 8000,
"valueType": "number",
"min": 100,
"max": 4000,
"step": 50,
"debugLabel": "",
"toolDescription": ""
},
{
"key": "isResponseAnswerText",
"renderTypeList": [
"hidden"
],
"label": "",
"value": true,
"valueType": "boolean",
"debugLabel": "",
"toolDescription": ""
},
{
"key": "aiChatQuoteRole",
"renderTypeList": [
"hidden"
],
"label": "",
"valueType": "string",
"value": "system",
"debugLabel": "",
"toolDescription": ""
},
{
"key": "quoteTemplate",
"renderTypeList": [
"hidden"
],
"label": "",
"valueType": "string",
"debugLabel": "",
"toolDescription": ""
},
{
"key": "quotePrompt",
"renderTypeList": [
"hidden"
],
"label": "",
"valueType": "string",
"debugLabel": "",
"toolDescription": ""
},
{
"key": "aiChatVision",
"renderTypeList": [
"hidden"
],
"label": "",
"valueType": "boolean",
"value": true,
"debugLabel": "",
"toolDescription": ""
},
{
"key": "aiChatReasoning",
"renderTypeList": [
"hidden"
],
"label": "",
"valueType": "boolean",
"value": true,
"debugLabel": "",
"toolDescription": ""
},
{
"key": "systemPrompt",
"renderTypeList": [
"textarea",
"reference"
],
"max": 3000,
"valueType": "string",
"label": "core.ai.Prompt",
"description": "core.app.tip.systemPromptTip",
"placeholder": "core.app.tip.chatNodeSystemPromptTip",
"value": "",
"debugLabel": "",
"toolDescription": ""
},
{
"key": "history",
"renderTypeList": [
"numberInput",
"reference"
],
"valueType": "chatHistory",
"label": "core.module.input.label.chat history",
"required": true,
"min": 0,
"max": 50,
"value": 6,
"description": "workflow:max_dialog_rounds",
"debugLabel": "",
"toolDescription": ""
},
{
"key": "quoteQA",
"renderTypeList": [
"settingDatasetQuotePrompt"
],
"label": "",
"debugLabel": "知识库引用",
"description": "",
"valueType": "datasetQuote",
"toolDescription": ""
},
{
"key": "fileUrlList",
"renderTypeList": [
"reference",
"input"
],
"label": "app:file_quote_link",
"debugLabel": "文件链接",
"valueType": "arrayString",
"value": [
[
"workflowStartNodeId",
"userFiles"
]
],
"toolDescription": ""
},
{
"key": "userChatInput",
"renderTypeList": [
"reference",
"textarea"
],
"valueType": "string",
"label": "common:core.module.input.label.user question",
"required": true,
"toolDescription": "用户问题",
"value": [
"workflowStartNodeId",
"userChatInput"
],
"debugLabel": ""
}
],
"outputs": [
{
"id": "history",
"key": "history",
"required": true,
"label": "common:core.module.output.label.New context",
"description": "将本次回复内容拼接上历史记录，作为新的上下文返回",
"valueType": "chatHistory",
"valueDesc": "{\n obj: System | Human | AI;\n value: string;\n}[]",
"type": "static"
},
{
"id": "answerText",
"key": "answerText",
"required": true,
"label": "common:core.module.output.label.Ai response content",
"description": "将在 stream 回复完毕后触发",
"valueType": "string",
"type": "static"
}
]
}
],
"edges": [
{
"source": "workflowStartNodeId",
"target": "7BdojPlukIQw",
"sourceHandle": "workflowStartNodeId-source-right",
"targetHandle": "7BdojPlukIQw-target-left"
}
],
"chatConfig": {
"questionGuide": false,
"ttsConfig": {
"type": "web"
},
"whisperConfig": {
"open": false,
"autoSend": false,
"autoTTSResponse": false
},
"scheduledTriggerConfig": {
"cronString": "",
"timezone": "Asia/Shanghai",
"defaultPrompt": ""
},
"chatInputGuide": {
"open": false,
"textList": [],
"customUrl": ""
},
"instruction": "",
"autoExecute": {
"open": false,
"defaultPrompt": ""
},
"welcomeText": "",
"variables": [],
"fileSelectConfig": {
"canSelectFile": false,
"canSelectImg": false,
"maxFiles": 10
},
"_id": "66f4c2f5e9e4e93a95141004"
}
}

82
projects/app/src/test/workflow/workflow.test.ts Normal file
View File

@@ -0,0 +1,82 @@
import { readFileSync } from 'fs';
import { resolve } from 'path';
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { dispatchWorkFlow } from '@fastgpt/service/core/workflow/dispatch';
import {
getWorkflowEntryNodeIds,
storeNodes2RuntimeNodes
} from '@fastgpt/global/core/workflow/runtime/utils';
import { ChatItemValueTypeEnum } from '@fastgpt/global/core/chat/constants';
vi.mock(import('@fastgpt/service/common/string/tiktoken'), async (importOriginal) => {
const mod = await importOriginal();
return {
...mod,
countGptMessagesTokens: async () => {
return 1;
}
};
});
vi.mock(import('@fastgpt/service/support/wallet/usage/utils'), async (importOriginal) => {
const mod = await importOriginal();
return {
...mod,
formatModelChars2Points: () => ({
modelName: 'test',
totalPoints: 1
})
};
});
const testWorkflow = async (path: string) => {
const workflowStr = readFileSync(resolve(path), 'utf-8');
const workflow = JSON.parse(workflowStr);
const { nodes, edges, chatConfig } = workflow;
let runtimeNodes = storeNodes2RuntimeNodes(nodes, getWorkflowEntryNodeIds(nodes));
const variables = {};
const { assistantResponses, flowResponses } = await dispatchWorkFlow({
mode: 'test',
runningAppInfo: {
id: 'test',
teamId: 'test',
tmbId: 'test'
},
runningUserInfo: {
tmbId: 'test',
teamId: 'test'
},
timezone: 'Asia/Shanghai',
externalProvider: {},
uid: 'test',
runtimeNodes,
runtimeEdges: edges,
variables,
query: [
{
type: ChatItemValueTypeEnum.text,
text: {
content: '你是谁'
}
}
],
chatConfig,
histories: [],
stream: false,
maxRunTimes: 5
});
expect(assistantResponses).toBeDefined();
expect(assistantResponses[0].text?.content).toBeDefined();
return {
assistantResponses,
flowResponses
};
};
it('Workflow test: simple workflow', async () => {
// create a simple app
await testWorkflow('projects/app/src/test/workflow/simple.json');
});
it('Workflow test: output test', async () => {
console.log(await testWorkflow('projects/app/src/test/workflow/loopTest.json'));
});

6
projects/app/tsconfig.json
View File

@@ -3,8 +3,10 @@
"compilerOptions": {
"baseUrl": ".",
"paths": {
"@/*": ["./src/*"]
"@/*": ["./src/*"],
"@test/*": ["../../test/*"]
}
},
"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", "**/*.d.ts", "../../packages/**/*.d.ts"]
"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", "**/*.d.ts", "../../packages/**/*.d.ts"],
"exclude": ["**/*.test.ts"]
}

34
test/datas/users.ts Normal file
View File

@@ -0,0 +1,34 @@
import { AuthUserTypeEnum } from '@fastgpt/global/support/permission/constant';
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';
import { parseHeaderCertRet } from 'test/mocks/request';
export async function getRootUser(): Promise<parseHeaderCertRet> {
const rootUser = await MongoUser.create({
username: 'root',
password: '123456'
});
const team = await MongoTeam.create({
name: 'test team',
ownerId: rootUser._id
});
const tmb = await MongoTeamMember.create({
teamId: team._id,
userId: rootUser._id,
status: 'active'
});
return {
userId: rootUser._id,
apikey: '',
appId: '',
authType: AuthUserTypeEnum.token,
isRoot: true,
sourceName: undefined,
teamId: tmb?.teamId,
tmbId: tmb?._id
};
}

1
test/mocks/index.ts Normal file
View File

@@ -0,0 +1 @@
import './request';

89
test/mocks/request.ts Normal file
View File

@@ -0,0 +1,89 @@
import { AuthUserTypeEnum } from '@fastgpt/global/support/permission/constant';
import { vi } from 'vitest';
// vi.mock(import('@/service/middleware/entry'), async () => {
// const NextAPI = vi.fn((handler: any) => handler);
// return {
// NextAPI
// };
// });
vi.mock(import('@fastgpt/service/common/middle/entry'), async (importOriginal) => {
const mod = await importOriginal();
const NextEntry = vi.fn(({ beforeCallback = [] }: { beforeCallback?: Promise<any>[] }) => {
return (...args: any) => {
return async function api(req: any, res: any) {
try {
await Promise.all([...beforeCallback]);
let response = null;
for await (const handler of args) {
response = await handler(req, res);
if (res.writableFinished) {
break;
}
}
return {
code: 200,
data: response
};
} catch (error) {
return {
code: 500,
error,
url: req.url
};
}
};
};
});
return {
...mod,
NextEntry
};
});
export type parseHeaderCertRet = {
userId: string;
teamId: string;
tmbId: string;
appId: string;
authType: AuthUserTypeEnum;
sourceName: string | undefined;
apikey: string;
isRoot: boolean;
};
export type MockReqType<B = any, Q = any> = {
body?: B;
query?: Q;
auth?: parseHeaderCertRet;
[key: string]: any;
};
vi.mock(import('@fastgpt/service/support/permission/controller'), async (importOriginal) => {
const mod = await importOriginal();
const parseHeaderCert = vi.fn(
({
req,
authToken = false,
authRoot = false,
authApiKey = false
}: {
req: MockReqType;
authToken?: boolean;
authRoot?: boolean;
authApiKey?: boolean;
}) => {
const { auth } = req;
if (!auth) {
return Promise.reject(Error('unAuthorization'));
}
return Promise.resolve(auth);
}
);
return {
...mod,
parseHeaderCert
};
});

88
test/setup.ts Normal file
View File

@@ -0,0 +1,88 @@
import { existsSync, readFileSync } from 'fs';
import mongoose from '@fastgpt/service/common/mongo';
import { connectMongo } from '@fastgpt/service/common/mongo/init';
import { initGlobalVariables } from '@/service/common/system';
import { afterAll, beforeAll, vi } from 'vitest';
import { setup, teardown } from 'vitest-mongodb';
import setupModels from './setupModels';
import './mocks';
vi.stubEnv('NODE_ENV', 'test');
vi.mock(import('@fastgpt/service/common/mongo'), async (importOriginal) => {
const mod = await importOriginal();
return {
...mod,
connectionMongo: await (async () => {
if (!global.mongodb) {
global.mongodb = mongoose;
await global.mongodb.connect((globalThis as any).__MONGO_URI__ as string);
}
return global.mongodb;
})()
};
});
vi.mock(import('@/service/common/system'), async (importOriginal) => {
const mod = await importOriginal();
return {
...mod,
getSystemVersion: async () => {
return '0.0.0';
},
readConfigData: async () => {
return readFileSync('@/data/config.json', 'utf-8');
},
initSystemConfig: async () => {
// read env from projects/app/.env
const str = readFileSync('projects/app/.env.local', 'utf-8');
const lines = str.split('\n');
const systemEnv: Record<string, string> = {};
for (const line of lines) {
const [key, value] = line.split('=');
if (key && value) {
systemEnv[key] = value;
}
}
global.systemEnv = systemEnv as any;
return;
}
};
});
beforeAll(async () => {
await setup({
type: 'replSet',
serverOptions: {
replSet: {
count: 4
}
}
});
vi.stubEnv('MONGODB_URI', (globalThis as any).__MONGO_URI__);
initGlobalVariables();
await connectMongo();
// await getInitConfig();
if (existsSync('projects/app/.env.local')) {
const str = readFileSync('projects/app/.env.local', 'utf-8');
const lines = str.split('\n');
const systemEnv: Record<string, string> = {};
for (const line of lines) {
const [key, value] = line.split('=');
if (key && value && !key.startsWith('#')) {
systemEnv[key] = value;
}
}
global.systemEnv = {} as any;
global.systemEnv.oneapiUrl = systemEnv['OPENAI_BASE_URL'];
global.systemEnv.chatApiKey = systemEnv['CHAT_API_KEY'];
await setupModels();
}
});
afterAll(async () => {
await teardown();
});

52
test/setupModels.ts Normal file
View File

@@ -0,0 +1,52 @@
import { ModelTypeEnum } from 'packages/global/core/ai/model';
import { ModelProviderIdType } from 'packages/global/core/ai/provider';
export default async function setupModels() {
global.llmModelMap = new Map<string, any>();
global.llmModelMap.set('gpt-4o-mini', {
type: ModelTypeEnum.llm,
model: 'gpt-4o-mini',
name: 'gpt-4o-mini',
avatar: 'gpt-4o-mini',
isActive: true,
isDefault: true,
isCustom: false,
requestUrl: undefined,
requestAuth: undefined,
customCQPrompt: '',
customExtractPrompt: '',
defaultSystemChatPrompt: undefined,
fieldMap: undefined,
defaultConfig: undefined,
provider: 'OpenAI' as ModelProviderIdType,
functionCall: false,
toolChoice: false,
maxContext: 4096,
maxResponse: 4096,
quoteMaxToken: 2048
});
global.systemDefaultModel = {
llm: {
type: ModelTypeEnum.llm,
model: 'gpt-4o-mini',
name: 'gpt-4o-mini',
avatar: 'gpt-4o-mini',
isActive: true,
isDefault: true,
isCustom: false,
requestUrl: undefined,
requestAuth: undefined,
customCQPrompt: '',
customExtractPrompt: '',
defaultSystemChatPrompt: undefined,
fieldMap: undefined,
defaultConfig: undefined,
provider: 'OpenAI' as ModelProviderIdType,
functionCall: false,
toolChoice: false,
maxContext: 4096,
maxResponse: 4096,
quoteMaxToken: 2048
}
};
}

18
test/test.ts Normal file
View File

@@ -0,0 +1,18 @@
import { MongoUser } from '@fastgpt/service/support/user/schema';
import { it, expect } from 'vitest';
it('should be a test', async () => {
expect(1).toBe(1);
});
it('should be able to connect to mongo', async () => {
expect(global.mongodb).toBeDefined();
expect(global.mongodb?.connection.readyState).toBe(1);
await MongoUser.create({
username: 'test',
password: '123456'
});
const user = await MongoUser.findOne({ username: 'test' });
expect(user).toBeDefined();
expect(user?.username).toBe('test');
});

21
test/utils/request.ts Normal file
View File

@@ -0,0 +1,21 @@
import { NextApiHandler } from '@fastgpt/service/common/middle/entry';
import { MockReqType } from '../mocks/request';
export async function Call<B = any, Q = any, R = any>(
handler: NextApiHandler<R>,
props?: MockReqType<B, Q>
) {
const { body = {}, query = {}, ...rest } = props || {};
return (await handler(
{
body: body,
query: query,
...(rest as any)
},
{} as any
)) as Promise<{
code: number;
data: R;
error?: any;
}>;
}

7
tsconfig.json
View File

@@ -14,7 +14,12 @@
"isolatedModules": true,
"jsx": "preserve",
"incremental": true,
"baseUrl": "."
"baseUrl": ".",
"paths": {
"@/*": ["projects/app/src/*"],
"@fastgpt/*": ["packages/*"],
"@test": ["test/*"]
}
},
"exclude": ["**/node_modules"]
}

23
vitest.config.mts Normal file
View File

@@ -0,0 +1,23 @@
import { resolve } from 'path';
import { defineConfig } from 'vitest/config';
export default defineConfig({
test: {
coverage: {
enabled: true,
reporter: ['html', 'json-summary', 'json'],
all: false,
reportOnFailure: true
},
outputFile: 'test-results.json',
setupFiles: ['./test/setup.ts'],
include: ['./test/test.ts', './projects/app/**/*.test.ts'],
testTimeout: 5000
},
resolve: {
alias: {
'@': resolve('projects/app/src'),
'@fastgpt': resolve('packages'),
'@test': resolve('test')
}
}
});