chore: vitest support (#4026)

* chore: vitest

* chore: move test files

* chore: support vitest

* fix: exclude test files

* chore(ci): add test workflow

* feat: remove read env

test/datas/users.ts

@@ -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
+  };
+}

test/mocks/index.ts

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

test/mocks/request.ts

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

test/setup.ts

@@ -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();
+});

test/setupModels.ts

@@ -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
+    }
+  };
+}

test/test.ts

@@ -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');
+});

test/utils/request.ts

@@ -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;
+  }>;
+}