Skip to content

赵月辉 / fastgpt-migrated

Go to a project
Commit 19435e58 by Archer Committed by GitHub
Options

test: parallelize Mongo-backed Vitest suites (#6984) 

* test: parallelize mongo-backed vitest suites

* ci: split FastGPT test jobs

* ci: publish one coverage report

* test: fix app suite under retained mongo indexes

* test: keep app vitest config self-contained

* test: preserve root username in fixtures
parent a14f76c3
Showing with 309 additions and 45 deletions
.github/workflows/test-fastgpt.yaml
name: "FastGPT-Test" name: 'FastGPT-Test'
on: on:
pull_request: pull_request:
workflow_dispatch: workflow_dispatch:
# Only one build per PR branch at a time # Only one build per PR branch at a time
concurrency: concurrency:
group: "test-fastgpt-${{ github.event.pull_request.number || github.ref }}" group: 'test-fastgpt-${{ github.event.pull_request.number || github.ref }}'
cancel-in-progress: true cancel-in-progress: true
permissions: permissions:
# Required to checkout the code # Required to checkout the code
contents: read contents: read
# Required to put a comment into the pull-request # Required to put a comment into the pull-request
issues: write
pull-requests: write pull-requests: write
jobs: jobs:
test: test-global:
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v4 - uses: actions/checkout@v4
...@@ -28,45 +29,190 @@ jobs: ...@@ -28,45 +29,190 @@ jobs:
- uses: actions/setup-node@v4 - uses: actions/setup-node@v4
with: with:
node-version: "24" node-version: '24'
cache: "pnpm" cache: 'pnpm'
- name: "Install Deps" - name: 'Install Deps'
run: pnpm install --frozen-lockfile run: pnpm install --frozen-lockfile
- name: "Test Global" - name: 'Test Global'
run: pnpm test:global run: pnpm test:global
- name: "Test Service" - name: 'Upload Coverage (Global)'
run: pnpm test:service
- name: "Test App"
run: pnpm test:app
- name: "Report Coverage (Global)"
# 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() && hashFiles('packages/global/coverage/coverage-summary.json') != if: always() && hashFiles('packages/global/coverage/coverage-summary.json') !=
'' ''
uses: davelosert/vitest-coverage-report-action@v2 uses: actions/upload-artifact@v4
with:
name: coverage-global
path: |
packages/global/coverage/coverage-final.json
packages/global/coverage/coverage-summary.json
test-service:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
ref: ${{ github.event.pull_request.head.ref || github.ref }}
repository: ${{ github.event.pull_request.head.repo.full_name ||
github.repository }}
- uses: pnpm/action-setup@v4
- uses: actions/setup-node@v4
with: with:
name: global node-version: '24'
json-final-path: packages/global/coverage/coverage-final.json cache: 'pnpm'
json-summary-path: packages/global/coverage/coverage-summary.json
- name: 'Install Deps'
run: pnpm install --frozen-lockfile
- name: 'Test Service'
run: pnpm test:service
- name: "Report Coverage (Service)" - name: 'Upload Coverage (Service)'
if: always() && hashFiles('packages/service/coverage/coverage-summary.json') != if: always() && hashFiles('packages/service/coverage/coverage-summary.json') !=
'' ''
uses: davelosert/vitest-coverage-report-action@v2 uses: actions/upload-artifact@v4
with: with:
name: service name: coverage-service
json-final-path: packages/service/coverage/coverage-final.json path: |
json-summary-path: packages/service/coverage/coverage-summary.json packages/service/coverage/coverage-final.json
packages/service/coverage/coverage-summary.json
- name: "Report Coverage (App)" test-app:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
ref: ${{ github.event.pull_request.head.ref || github.ref }}
repository: ${{ github.event.pull_request.head.repo.full_name ||
github.repository }}
- uses: pnpm/action-setup@v4
- uses: actions/setup-node@v4
with:
node-version: '24'
cache: 'pnpm'
- name: 'Install Deps'
run: pnpm install --frozen-lockfile
- name: 'Test App'
run: pnpm test:app
- name: 'Upload Coverage (App)'
if: always() && hashFiles('projects/app/coverage/coverage-summary.json') != '' if: always() && hashFiles('projects/app/coverage/coverage-summary.json') != ''
uses: davelosert/vitest-coverage-report-action@v2 uses: actions/upload-artifact@v4
with:
name: coverage-app
path: |
projects/app/coverage/coverage-final.json
projects/app/coverage/coverage-summary.json
report-coverage:
runs-on: ubuntu-latest
needs: [test-global, test-service, test-app]
if: always()
steps:
- name: 'Download Coverage Artifacts'
uses: actions/download-artifact@v4
with: with:
name: app path: coverage-artifacts
json-final-path: projects/app/coverage/coverage-final.json pattern: coverage-*
json-summary-path: projects/app/coverage/coverage-summary.json
- name: 'Report Coverage'
if: github.event_name == 'pull_request'
uses: actions/github-script@v7
with:
script: |
const fs = require('fs');
const path = require('path');
const marker = '<!-- fastgpt-coverage-report -->';
const packages = [
{ name: 'Global', dir: 'coverage-global' },
{ name: 'Service', dir: 'coverage-service' },
{ name: 'App', dir: 'coverage-app' }
];
const formatPct = (value) => {
if (typeof value !== 'number') return 'N/A';
return `${value.toFixed(2)}%`;
};
const rows = packages.map((pkg) => {
const summaryPath = path.join(
process.cwd(),
'coverage-artifacts',
pkg.dir,
'coverage-summary.json'
);
if (!fs.existsSync(summaryPath)) {
return `| ${pkg.name} | N/A | N/A | N/A | N/A |`;
}
const summary = JSON.parse(fs.readFileSync(summaryPath, 'utf8'));
const total = summary.total || {};
return [
`| ${pkg.name}`,
formatPct(total.statements?.pct),
formatPct(total.branches?.pct),
formatPct(total.functions?.pct),
`${formatPct(total.lines?.pct)} |`
].join(' | ');
});
const body = [
marker,
'## Coverage Report',
'',
'| Package | Statements | Branches | Functions | Lines |',
'| --- | ---: | ---: | ---: | ---: |',
...rows
].join('\n');
await core.summary.addRaw(body).write();
const { owner, repo } = context.repo;
const issue_number = context.payload.pull_request.number;
try {
const comments = await github.rest.issues.listComments({
owner,
repo,
issue_number,
per_page: 100
});
const existing = comments.data.find((comment) =>
comment.body?.includes(marker)
);
if (existing) {
await github.rest.issues.updateComment({
owner,
repo,
comment_id: existing.id,
body
});
} else {
await github.rest.issues.createComment({
owner,
repo,
issue_number,
body
});
}
} catch (error) {
core.warning(`Failed to publish coverage comment: ${error.message}`);
}
- name: 'Check Test Results'
run: |
if [ "${{ needs.test-global.result }}" != "success" ] ||
[ "${{ needs.test-service.result }}" != "success" ] ||
[ "${{ needs.test-app.result }}" != "success" ]; then
exit 1
fi
packages/service/vitest.config.ts
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import { configDefaults, defineConfig } from 'vitest/config'; import { configDefaults, defineConfig } from 'vitest/config';
import { getTestMaxWorkers } from '../../test/vitestWorkers';
export default defineConfig({ export default defineConfig({
resolve: { resolve: {
...@@ -45,7 +46,8 @@ export default defineConfig({ ...@@ -45,7 +46,8 @@ export default defineConfig({
outputFile: 'test-results.json', outputFile: 'test-results.json',
setupFiles: '../../test/setup.ts', setupFiles: '../../test/setup.ts',
globalSetup: '../../test/globalSetup.ts', globalSetup: '../../test/globalSetup.ts',
fileParallelism: false, fileParallelism: true,
maxWorkers: getTestMaxWorkers(),
maxConcurrency: 10, maxConcurrency: 10,
pool: 'threads', pool: 'threads',
testTimeout: 20000, testTimeout: 20000,
......
projects/app/vitest.config.ts
import { resolve } from 'node:path'; import { resolve } from 'node:path';
import { defineConfig } from 'vitest/config'; import { defineConfig } from 'vitest/config';
/**
* Keep this helper local to the app project because the app Docker build context
* does not include the repository root `test/` directory, but Next still
* type-checks this config during image builds.
*/
const getTestMaxWorkers = () => {
const raw = process.env.FASTGPT_TEST_MAX_WORKERS;
if (!raw) return 4;
if (raw.endsWith('%')) return raw as `${number}%`;
const parsed = Number(raw);
return Number.isFinite(parsed) && parsed > 0 ? parsed : 4;
};
export default defineConfig({ export default defineConfig({
resolve: { resolve: {
alias: { alias: {
...@@ -46,7 +60,8 @@ export default defineConfig({ ...@@ -46,7 +60,8 @@ export default defineConfig({
outputFile: 'test-results.json', outputFile: 'test-results.json',
setupFiles: '../../test/setup.ts', setupFiles: '../../test/setup.ts',
globalSetup: '../../test/globalSetup.ts', globalSetup: '../../test/globalSetup.ts',
fileParallelism: false, fileParallelism: true,
maxWorkers: getTestMaxWorkers(),
maxConcurrency: 10, maxConcurrency: 10,
pool: 'threads', pool: 'threads',
testTimeout: 20000, testTimeout: 20000,
......
test/datas/users.ts
...@@ -14,11 +14,33 @@ import { MongoTeam } from '@fastgpt/service/support/user/team/teamSchema'; ...@@ -14,11 +14,33 @@ import { MongoTeam } from '@fastgpt/service/support/user/team/teamSchema';
import { initTeamFreePlan } from '@fastgpt/service/support/wallet/sub/utils'; import { initTeamFreePlan } from '@fastgpt/service/support/wallet/sub/utils';
import type { parseHeaderCertRet } from '@test/mocks/request'; import type { parseHeaderCertRet } from '@test/mocks/request';
/**
* Create an authenticated system root user fixture.
*
* `authSystemAdmin` checks for the literal username `root`, so the fixture must
* keep that stable. Some tests call this helper multiple times before per-test
* Mongo cleanup runs; reuse the existing root document to preserve unique
* indexes while still creating an isolated team/member for each caller.
*/
export async function getRootUser(): Promise<parseHeaderCertRet> { export async function getRootUser(): Promise<parseHeaderCertRet> {
const rootUser = await MongoUser.create({ const rootUser = await (async () => {
username: 'root', const existingRoot = await MongoUser.findOne({ username: 'root' });
password: '123456' if (existingRoot) return existingRoot;
});
try {
return await MongoUser.create({
username: 'root',
password: '123456'
});
} catch (error) {
if ((error as { code?: number }).code === 11000) {
const concurrentRoot = await MongoUser.findOne({ username: 'root' });
if (concurrentRoot) return concurrentRoot;
}
throw error;
}
})();
const team = await MongoTeam.create({ const team = await MongoTeam.create({
name: 'test team', name: 'test team',
......
test/mocks/common/mongo.ts
...@@ -2,18 +2,66 @@ import { vi } from 'vitest'; ...@@ -2,18 +2,66 @@ import { vi } from 'vitest';
import { randomUUID } from 'crypto'; import { randomUUID } from 'crypto';
import type { Mongoose } from '@fastgpt/service/common/mongo'; import type { Mongoose } from '@fastgpt/service/common/mongo';
const fileDbPrefix = `fastgpt_test_${process.env.VITEST_WORKER_ID ?? '0'}_${randomUUID().replaceAll(
'-',
''
)}`;
const dbNames = new WeakMap<Mongoose, string>();
const connectPromises = new WeakMap<Mongoose, Promise<Mongoose>>();
let dbSeq = 0;
const getDbName = (db: Mongoose) => {
const existing = dbNames.get(db);
if (existing) return existing;
const dbName = `${fileDbPrefix}_${dbSeq++}`;
dbNames.set(db, dbName);
return dbName;
};
const connectTestMongo = async (props: { db: Mongoose; url: string; connectedCb?: () => void }) => {
const { db, url, connectedCb } = props;
if (db.connection.readyState !== 0) {
return db;
}
const connecting = connectPromises.get(db);
if (connecting) return connecting;
const promise = (async () => {
await db.connect(url, {
dbName: getDbName(db),
maxPoolSize: 4,
minPoolSize: 0,
retryWrites: false,
serverSelectionTimeoutMS: 10000
});
await db.connection.db?.dropDatabase();
connectedCb?.();
return db;
})();
connectPromises.set(db, promise);
try {
return await promise;
} finally {
connectPromises.delete(db);
}
};
/** /**
* Mock MongoDB connection for testing * Mock MongoDB connection for testing
* Creates a unique database for each test run and drops it on connection * Creates a stable, isolated database for each test file and Mongoose instance.
*/ */
vi.mock(import('@fastgpt/service/common/mongo/init'), async (importOriginal: any) => { vi.mock(import('@fastgpt/service/common/mongo/init'), async (importOriginal: any) => {
const mod = await importOriginal(); const mod = await importOriginal();
return { return {
...mod, ...mod,
connectMongo: async (props: { db: Mongoose; url: string; connectedCb?: () => void }) => { connectMongo: async (props: { db: Mongoose; url: string; connectedCb?: () => void }) => {
const { db, url } = props; return connectTestMongo(props);
await db.connect(url, { dbName: randomUUID(), retryWrites: false });
await db.connection.db?.dropDatabase();
} }
}; };
}); });
......
test/setup.ts
...@@ -8,11 +8,25 @@ import setupModels from './setupModels'; ...@@ -8,11 +8,25 @@ import setupModels from './setupModels';
import { clean } from './datas/users'; import { clean } from './datas/users';
import { connectionLogMongo, connectionMongo } from '@fastgpt/service/common/mongo'; import { connectionLogMongo, connectionMongo } from '@fastgpt/service/common/mongo';
import { loadVectorDBEnv } from './utils/env'; import { loadVectorDBEnv } from './utils/env';
import type { Mongoose } from '@fastgpt/service/common/mongo';
vi.stubEnv('NODE_ENV', 'test'); vi.stubEnv('NODE_ENV', 'test');
loadVectorDBEnv({ envFileNames: ['.env.test.local'] }); loadVectorDBEnv({ envFileNames: ['.env.test.local'] });
/**
* Clears documents while keeping collections and indexes warm inside one test file.
* File-level DB names are already isolated, so per-case cleanup does not need to
* drop the whole database and force MongoDB to rebuild collection metadata.
*/
const clearMongoCollections = async (db: Mongoose | undefined) => {
const database = db?.connection.db;
if (!database) return;
const collections = await database.collections();
await Promise.all(collections.map((collection) => collection.deleteMany({})));
};
beforeAll(async () => { beforeAll(async () => {
vi.stubEnv('MONGODB_URI', inject('MONGODB_URI')); vi.stubEnv('MONGODB_URI', inject('MONGODB_URI'));
await connectMongo({ db: connectionMongo, url: inject('MONGODB_URI') }); await connectMongo({ db: connectionMongo, url: inject('MONGODB_URI') });
...@@ -44,6 +58,8 @@ beforeAll(async () => { ...@@ -44,6 +58,8 @@ beforeAll(async () => {
afterAll(async () => { afterAll(async () => {
await connectionMongo?.connection.db?.dropDatabase(); await connectionMongo?.connection.db?.dropDatabase();
await connectionLogMongo?.connection.db?.dropDatabase(); await connectionLogMongo?.connection.db?.dropDatabase();
await connectionMongo?.disconnect();
await connectionLogMongo?.disconnect();
}); });
beforeEach(async () => { beforeEach(async () => {
...@@ -53,11 +69,10 @@ beforeEach(async () => { ...@@ -53,11 +69,10 @@ beforeEach(async () => {
onTestFinished(async () => { onTestFinished(async () => {
clean(); clean();
// Ensure all sessions are closed before dropping database
try { try {
await Promise.all([ await Promise.all([
connectionMongo?.connection.db?.dropDatabase(), clearMongoCollections(connectionMongo),
connectionLogMongo?.connection.db?.dropDatabase() clearMongoCollections(connectionLogMongo)
]); ]);
} catch (error) { } catch (error) {
// Ignore errors during cleanup // Ignore errors during cleanup
......
test/vitestWorkers.ts 0 → 100644
/**
* Resolve Vitest worker count for Mongo-backed suites.
*
* The default is based on the current Mongo-backed service suite benchmark.
* Override with FASTGPT_TEST_MAX_WORKERS=8 on high-memory machines or when
* repeatedly starting/stopping mongodb-memory-server in local experiments.
*/
export const getTestMaxWorkers = () => {
const raw = process.env.FASTGPT_TEST_MAX_WORKERS;
if (!raw) return 4;
if (raw.endsWith('%')) return raw as `${number}%`;
const parsed = Number(raw);
return Number.isFinite(parsed) && parsed > 0 ? parsed : 4;
};
vitest.config.mts
import { resolve } from 'path'; import { resolve } from 'path';
import { defineConfig } from 'vitest/config'; import { defineConfig } from 'vitest/config';
import { getTestMaxWorkers } from './test/vitestWorkers';
export default defineConfig({ export default defineConfig({
resolve: { resolve: {
...@@ -48,8 +49,8 @@ export default defineConfig({ ...@@ -48,8 +49,8 @@ export default defineConfig({
outputFile: 'test-results.json', outputFile: 'test-results.json',
setupFiles: 'test/setup.ts', setupFiles: 'test/setup.ts',
globalSetup: 'test/globalSetup.ts', globalSetup: 'test/globalSetup.ts',
// File-level execution: serial (one file at a time to avoid MongoDB conflicts) fileParallelism: true,
fileParallelism: false, maxWorkers: getTestMaxWorkers(),
// Test-level execution within a file: parallel (up to 5 concurrent tests) // Test-level execution within a file: parallel (up to 5 concurrent tests)
maxConcurrency: 10, maxConcurrency: 10,
pool: 'threads', pool: 'threads',
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment