大海
568 lines
24 KiB
JavaScript
568 lines
24 KiB
JavaScript
/**
|
|
* Backend Builder Agent Test — SF-04
|
|
*/
|
|
|
|
import { describe, it, before } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { resolve } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
import { existsSync, rmSync, readFileSync } from "node:fs";
|
|
|
|
const __dirname = resolve(fileURLToPath(new URL(".", import.meta.url)));
|
|
const WORKSPACE = resolve(__dirname, "..");
|
|
|
|
let buildBackend, loadJSON, writeBackend;
|
|
|
|
before(async () => {
|
|
const mod = await import("../scripts/backend-builder-agent.mjs");
|
|
buildBackend = mod.buildBackend;
|
|
loadJSON = mod.loadJSON;
|
|
writeBackend = mod.writeBackend;
|
|
});
|
|
|
|
function loadPRD(name) {
|
|
return JSON.parse(readFileSync(resolve(WORKSPACE, `test/fixtures/architecture-agent/${name}-prd.json`), "utf-8"));
|
|
}
|
|
function loadArch() {
|
|
return JSON.parse(readFileSync(resolve(WORKSPACE, "architecture-example.json"), "utf-8"));
|
|
}
|
|
|
|
// Demo RequirementPackage that exercises all generators
|
|
const DEMO_PRD = {
|
|
projectName: "PetCare",
|
|
chineseName: "宠物管理",
|
|
domain: "pet",
|
|
summary: "一款宠物健康管理应用",
|
|
features: [
|
|
{ name: "宠物档案", priority: "P0" },
|
|
{ name: "健康日程", priority: "P0" },
|
|
{ name: "日常记录", priority: "P1" },
|
|
{ name: "附近医院", priority: "P1" },
|
|
],
|
|
userStories: [
|
|
{ id: "US-001", as: "宠物主人", want: "记录宠物信息", soThat: "管理宠物档案", priority: "P0" },
|
|
],
|
|
personas: [{ name: "宠物主人" }],
|
|
};
|
|
|
|
const DEMO_ARCH = {
|
|
projectName: "PetCare",
|
|
databaseSchema: [
|
|
{
|
|
table: "pets",
|
|
description: "宠物档案表",
|
|
fields: [
|
|
{ name: "id", type: "TEXT", constraints: "PK" },
|
|
{ name: "owner_id", type: "TEXT", constraints: "NOT NULL, FK → users.id" },
|
|
{ name: "name", type: "TEXT", constraints: "NOT NULL" },
|
|
{ name: "species", type: "TEXT" },
|
|
{ name: "breed", type: "TEXT" },
|
|
{ name: "birth_date", type: "TEXT" },
|
|
{ name: "weight_kg", type: "REAL" },
|
|
{ name: "avatar_url", type: "TEXT" },
|
|
{ name: "created_at", type: "TEXT", constraints: "NOT NULL, DEFAULT (datetime('now'))" },
|
|
{ name: "updated_at", type: "TEXT", constraints: "NOT NULL, DEFAULT (datetime('now'))" },
|
|
],
|
|
indexes: ["CREATE INDEX IF NOT EXISTS idx_pets_owner ON pets(owner_id)"],
|
|
},
|
|
{
|
|
table: "schedules",
|
|
description: "健康日程表",
|
|
fields: [
|
|
{ name: "id", type: "TEXT", constraints: "PK" },
|
|
{ name: "pet_id", type: "TEXT", constraints: "NOT NULL, FK → pets.id" },
|
|
{ name: "type", type: "TEXT", constraints: "NOT NULL" },
|
|
{ name: "title", type: "TEXT", constraints: "NOT NULL" },
|
|
{ name: "scheduled_at", type: "TEXT", constraints: "NOT NULL" },
|
|
{ name: "completed", type: "INTEGER", constraints: "DEFAULT 0" },
|
|
{ name: "created_at", type: "TEXT", constraints: "NOT NULL, DEFAULT (datetime('now'))" },
|
|
],
|
|
},
|
|
{
|
|
table: "daily_logs",
|
|
description: "日常记录表",
|
|
fields: [
|
|
{ name: "id", type: "TEXT", constraints: "PK" },
|
|
{ name: "pet_id", type: "TEXT", constraints: "NOT NULL, FK → pets.id" },
|
|
{ name: "category", type: "TEXT", constraints: "NOT NULL" },
|
|
{ name: "value", type: "TEXT", constraints: "NOT NULL" },
|
|
{ name: "logged_at", type: "TEXT", constraints: "NOT NULL, DEFAULT (datetime('now'))" },
|
|
],
|
|
},
|
|
],
|
|
apiDesign: [
|
|
{
|
|
resource: "pets",
|
|
basePath: "/api/pets",
|
|
endpoints: [
|
|
{ method: "GET", path: "/api/pets", description: "获取宠物列表" },
|
|
{ method: "GET", path: "/api/pets/:id", description: "获取宠物详情" },
|
|
{ method: "POST", path: "/api/pets", description: "创建宠物" },
|
|
{ method: "PUT", path: "/api/pets/:id", description: "更新宠物" },
|
|
{ method: "DELETE", path: "/api/pets/:id", description: "删除宠物" },
|
|
],
|
|
},
|
|
{
|
|
resource: "schedules",
|
|
basePath: "/api/schedules",
|
|
endpoints: [
|
|
{ method: "GET", path: "/api/schedules", description: "获取日程列表" },
|
|
{ method: "POST", path: "/api/schedules", description: "创建日程" },
|
|
],
|
|
},
|
|
{
|
|
resource: "daily-logs",
|
|
basePath: "/api/daily-logs",
|
|
endpoints: [
|
|
{ method: "POST", path: "/api/daily-logs", description: "记录日常" },
|
|
{ method: "GET", path: "/api/daily-logs", description: "查询日常记录" },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("1 — 目录结构完整性", () => {
|
|
it("生成完整后端项目目录", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(!result.error, `Unexpected error: ${result.error}`);
|
|
assert.ok(result.stats.totalFiles >= 15, `Expected >= 15 files, got ${result.stats.totalFiles}`);
|
|
});
|
|
|
|
it("生成 package.json", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.files["package.json"], "Missing package.json");
|
|
const pkg = JSON.parse(result.files["package.json"]);
|
|
assert.ok(pkg.dependencies.fastify, "fastify dependency missing");
|
|
assert.ok(pkg.dependencies["sql.js"], "sql.js dependency missing");
|
|
assert.ok(pkg.dependencies["@fastify/jwt"], "@fastify/jwt dependency missing");
|
|
assert.ok(pkg.dependencies.bcrypt, "bcrypt dependency missing");
|
|
assert.ok(pkg.devDependencies.typescript, "typescript devDependency missing");
|
|
assert.ok(pkg.scripts.build, "build script missing");
|
|
assert.ok(pkg.scripts.test, "test script missing");
|
|
assert.ok(pkg.scripts.dev, "dev script missing");
|
|
});
|
|
|
|
it("生成 tsconfig.json", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.files["tsconfig.json"], "Missing tsconfig.json");
|
|
const cfg = JSON.parse(result.files["tsconfig.json"]);
|
|
assert.equal(cfg.compilerOptions.strict, true);
|
|
assert.equal(cfg.compilerOptions.module, "ESNext");
|
|
assert.ok(cfg.compilerOptions.outDir);
|
|
});
|
|
|
|
it("生成 .env.example", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.files[".env.example"]);
|
|
const env = result.files[".env.example"];
|
|
assert.ok(env.includes("JWT_SECRET"));
|
|
assert.ok(env.includes("DATABASE_URL"));
|
|
assert.ok(env.includes("PORT"));
|
|
});
|
|
|
|
it("生成 README.md", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.files["README.md"]);
|
|
const readme = result.files["README.md"];
|
|
assert.ok(readme.includes("Fastify"));
|
|
assert.ok(readme.includes("SQLite"));
|
|
assert.ok(readme.includes("npm install"));
|
|
assert.ok(readme.includes("## API Endpoints"));
|
|
});
|
|
|
|
it("生成 .gitignore", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.files[".gitignore"]);
|
|
assert.ok(result.files[".gitignore"].includes("node_modules"));
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("2 — src/index.ts（服务入口）", () => {
|
|
it("生成 src/index.ts", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.files["src/index.ts"]);
|
|
const content = result.files["src/index.ts"];
|
|
assert.ok(content.includes("Fastify"), "Missing Fastify import");
|
|
assert.ok(content.includes("buildApp"), "Missing buildApp function");
|
|
assert.ok(content.includes("@fastify/jwt"), "Missing JWT plugin");
|
|
assert.ok(content.includes("@fastify/cors"), "Missing CORS plugin");
|
|
assert.ok(content.includes("authRoutes"), "Missing auth routes");
|
|
assert.ok(content.includes("petsRoutes") || content.includes("/api/pets"), "Missing pets routes");
|
|
assert.ok(content.includes("/api/health"), "Missing health check");
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("3 — src/db/（数据库层）", () => {
|
|
it("生成 src/db/schema.ts", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.files["src/db/schema.ts"]);
|
|
const content = result.files["src/db/schema.ts"];
|
|
assert.ok(content.includes("CREATE TABLE"), "Missing CREATE TABLE");
|
|
assert.ok(content.includes("users"), "Missing users table");
|
|
assert.ok(content.includes("pets"), "Missing pets table");
|
|
assert.ok(content.includes("schedules"), "Missing schedules table");
|
|
assert.ok(content.includes("daily_logs"), "Missing daily_logs table");
|
|
});
|
|
|
|
it("生成 src/db/client.ts", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.files["src/db/client.ts"]);
|
|
const content = result.files["src/db/client.ts"];
|
|
assert.ok(content.includes("sql.js"), "Missing sql.js import");
|
|
assert.ok(content.includes("getDb"), "Missing getDb function");
|
|
assert.ok(content.includes("queryAll"), "Missing queryAll helper");
|
|
assert.ok(content.includes("queryOne"), "Missing queryOne helper");
|
|
assert.ok(content.includes("execute"), "Missing execute helper");
|
|
assert.ok(content.includes("initDb"), "Missing initDb function");
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("4 — src/routes/（路由层）", () => {
|
|
it("生成 CRUD 路由文件", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.stats.routes >= 3, `Expected >= 3 routes, got ${result.stats.routes}`);
|
|
assert.ok(result.files["src/routes/pets.ts"], "Missing pets routes");
|
|
assert.ok(result.files["src/routes/schedules.ts"], "Missing schedules routes");
|
|
assert.ok(result.files["src/routes/daily_logs.ts"], "Missing daily_logs routes");
|
|
});
|
|
|
|
it("生成 auth 路由", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.files["src/routes/auth.ts"]);
|
|
const content = result.files["src/routes/auth.ts"];
|
|
assert.ok(content.includes("register"), "Missing register route");
|
|
assert.ok(content.includes("login"), "Missing login route");
|
|
assert.ok(content.includes("/me"), "Missing /me route");
|
|
assert.ok(content.includes("bcrypt"), "Missing bcrypt import");
|
|
assert.ok(content.includes("jwt.sign"), "Missing JWT sign");
|
|
});
|
|
|
|
it("路由文件包含 CRUD 方法", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const petsRoute = result.files["src/routes/pets.ts"];
|
|
assert.ok(petsRoute.includes("authenticate"), "Missing auth middleware");
|
|
assert.ok(petsRoute.includes("app.get"), "Missing GET");
|
|
assert.ok(petsRoute.includes("app.post"), "Missing POST");
|
|
assert.ok(petsRoute.includes("app.put"), "Missing PUT");
|
|
assert.ok(petsRoute.includes("app.delete"), "Missing DELETE");
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("5 — src/middleware/（中间件）", () => {
|
|
it("生成 JWT 认证中间件", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.files["src/middleware/auth.ts"]);
|
|
const content = result.files["src/middleware/auth.ts"];
|
|
assert.ok(content.includes("authenticate"), "Missing authenticate");
|
|
assert.ok(content.includes("requireAdmin"), "Missing requireAdmin");
|
|
assert.ok(content.includes("optionalAuth"), "Missing optionalAuth");
|
|
assert.ok(content.includes("jwtVerify"), "Missing jwtVerify call");
|
|
assert.ok(content.includes("status(401)"), "Missing 401 response");
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("6 — src/services/（服务层）", () => {
|
|
it("生成服务文件", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.stats.services >= 3, `Expected >= 3 services, got ${result.stats.services}`);
|
|
assert.ok(result.files["src/services/pet.ts"], "Missing pet service");
|
|
assert.ok(result.files["src/services/schedule.ts"], "Missing schedule service");
|
|
});
|
|
|
|
it("服务文件包含 CRUD 方法", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const svc = result.files["src/services/pet.ts"];
|
|
assert.ok(svc.includes("list()"), "Missing list()");
|
|
assert.ok(svc.includes("getById"), "Missing getById()");
|
|
assert.ok(svc.includes("create"), "Missing create()");
|
|
assert.ok(svc.includes("update"), "Missing update()");
|
|
assert.ok(svc.includes("delete"), "Missing delete()");
|
|
assert.ok(svc.includes("class"), "Missing class definition");
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("7 — src/types/（类型定义）", () => {
|
|
it("生成类型文件", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.files["src/types/index.ts"]);
|
|
const types = result.files["src/types/index.ts"];
|
|
assert.ok(types.includes("export interface"), "Missing interfaces");
|
|
});
|
|
|
|
it("包含数据模型类型", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const types = result.files["src/types/index.ts"];
|
|
assert.ok(types.includes("interface Pet"), "Missing Pet type");
|
|
assert.ok(types.includes("interface Schedule"), "Missing Schedule type");
|
|
assert.ok(types.includes("interface User"), "Missing User type");
|
|
});
|
|
|
|
it("包含 Create/Update 输入类型", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const types = result.files["src/types/index.ts"];
|
|
assert.ok(types.includes("CreatePetInput"), "Missing CreatePetInput");
|
|
assert.ok(types.includes("UpdatePetInput"), "Missing UpdatePetInput");
|
|
});
|
|
|
|
it("包含 Auth 类型", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const types = result.files["src/types/index.ts"];
|
|
assert.ok(types.includes("LoginInput"), "Missing LoginInput");
|
|
assert.ok(types.includes("RegisterInput"), "Missing RegisterInput");
|
|
assert.ok(types.includes("AuthResponse"), "Missing AuthResponse");
|
|
});
|
|
|
|
it("包含 JWT payload 类型", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const types = result.files["src/types/index.ts"];
|
|
assert.ok(types.includes("JwtPayload"), "Missing JwtPayload");
|
|
});
|
|
|
|
it("包含 API 响应类型", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const types = result.files["src/types/index.ts"];
|
|
assert.ok(types.includes("ApiResponse"), "Missing ApiResponse");
|
|
assert.ok(types.includes("PaginatedResponse"), "Missing PaginatedResponse");
|
|
assert.ok(types.includes("ErrorResponse"), "Missing ErrorResponse");
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("8 — 测试生成", () => {
|
|
it("生成测试文件", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
assert.ok(result.stats.tests >= 2, `Expected >= 2 test files, got ${result.stats.tests}`);
|
|
assert.ok(result.files["src/__tests__/auth.test.ts"], "Missing auth test");
|
|
});
|
|
|
|
it("auth 测试包含 register/login/me", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const test = result.files["src/__tests__/auth.test.ts"];
|
|
assert.ok(test.includes("registers a new user"), "Missing register test");
|
|
assert.ok(test.includes("logs in with correct credentials"), "Missing login test");
|
|
assert.ok(test.includes("returns current user"), "Missing me test");
|
|
assert.ok(test.includes("rejects without token"), "Missing auth fail test");
|
|
});
|
|
|
|
it("CRUD 测试包含完整生命周期", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const test = result.files["src/__tests__/pets.test.ts"];
|
|
if (!test) return; // pets test may not exist depending on naming
|
|
assert.ok(test.includes("creates"), "Missing create test");
|
|
assert.ok(test.includes("updates"), "Missing update test");
|
|
assert.ok(test.includes("deletes"), "Missing delete test");
|
|
assert.ok(test.includes("returns 404 after delete"), "Missing 404-after-delete test");
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("9 — 错误处理", () => {
|
|
it("invalid PRD 返回错误", () => {
|
|
const result = buildBackend({ error: "test" }, {});
|
|
assert.equal(result.error, "INVALID_PRD");
|
|
});
|
|
|
|
it("invalid Architecture 返回错误", () => {
|
|
const result = buildBackend(DEMO_PRD, { error: "test" });
|
|
assert.equal(result.error, "INVALID_ARCH");
|
|
});
|
|
|
|
it("null PRD 返回错误", () => {
|
|
const result = buildBackend(null, {});
|
|
assert.equal(result.error, "INVALID_PRD");
|
|
});
|
|
|
|
it("空的 databaseSchema 仍然生成基础项目", () => {
|
|
const result = buildBackend(DEMO_PRD, { ...DEMO_ARCH, databaseSchema: [] });
|
|
assert.ok(!result.error);
|
|
assert.ok(result.files["src/index.ts"]);
|
|
assert.ok(result.files["src/routes/auth.ts"]);
|
|
assert.ok(result.stats.totalFiles >= 8, `Expected >= 8 files with empty schema, got ${result.stats.totalFiles}`);
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("10 — 文件写入 I/O", () => {
|
|
it("writeBackend 写入完整项目", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const tmpDir = resolve(WORKSPACE, ".tmp-backend-test");
|
|
|
|
writeBackend(result, tmpDir);
|
|
|
|
assert.ok(existsSync(resolve(tmpDir, "package.json")));
|
|
assert.ok(existsSync(resolve(tmpDir, "tsconfig.json")));
|
|
assert.ok(existsSync(resolve(tmpDir, ".env.example")));
|
|
assert.ok(existsSync(resolve(tmpDir, "README.md")));
|
|
assert.ok(existsSync(resolve(tmpDir, "src/index.ts")));
|
|
assert.ok(existsSync(resolve(tmpDir, "src/db/schema.ts")));
|
|
assert.ok(existsSync(resolve(tmpDir, "src/db/client.ts")));
|
|
assert.ok(existsSync(resolve(tmpDir, "src/middleware/auth.ts")));
|
|
assert.ok(existsSync(resolve(tmpDir, "src/routes/auth.ts")));
|
|
assert.ok(existsSync(resolve(tmpDir, "src/types/index.ts")));
|
|
|
|
// Check at least one route & service file
|
|
const routesDir = resolve(tmpDir, "src/routes");
|
|
const servicesDir = resolve(tmpDir, "src/services");
|
|
assert.ok(existsSync(routesDir));
|
|
assert.ok(existsSync(servicesDir));
|
|
|
|
rmSync(tmpDir, { recursive: true, force: true });
|
|
});
|
|
|
|
it("loadJSON 读取文件", () => {
|
|
const { data } = loadJSON(resolve(WORKSPACE, "prd-example.json"));
|
|
assert.ok(data.projectName);
|
|
});
|
|
|
|
it("loadJSON 不存在的文件返回 error", () => {
|
|
const { data, error } = loadJSON("/nonexistent.json");
|
|
assert.equal(data, null);
|
|
assert.ok(error);
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("11 — npm install & build", () => {
|
|
it("npm install 成功", async () => {
|
|
const generateAndInstall = async () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const tmpDir = resolve(WORKSPACE, ".tmp-backend-build");
|
|
writeBackend(result, tmpDir);
|
|
|
|
const { execSync } = await import("node:child_process");
|
|
try {
|
|
execSync("npm install --no-audit --no-fund --prefer-offline", {
|
|
cwd: tmpDir,
|
|
encoding: "utf-8",
|
|
timeout: 120_000,
|
|
stdio: "pipe",
|
|
});
|
|
return { success: true, tmpDir };
|
|
} catch (e) {
|
|
return { success: false, error: e.stderr || e.message, tmpDir };
|
|
}
|
|
};
|
|
|
|
const { success, error, tmpDir } = await generateAndInstall();
|
|
|
|
if (!success) {
|
|
console.error("npm install failed:", error?.slice(0, 500));
|
|
}
|
|
|
|
assert.ok(success, `npm install failed: ${error?.slice(0, 200)}`);
|
|
|
|
// Cleanup
|
|
rmSync(tmpDir, { recursive: true, force: true });
|
|
});
|
|
|
|
it("npm run build 成功", async () => {
|
|
const generateAndBuild = async () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const tmpDir = resolve(WORKSPACE, ".tmp-backend-build");
|
|
writeBackend(result, tmpDir);
|
|
|
|
const { execSync } = await import("node:child_process");
|
|
try {
|
|
execSync("npm install --no-audit --no-fund --prefer-offline", {
|
|
cwd: tmpDir,
|
|
encoding: "utf-8",
|
|
timeout: 120_000,
|
|
stdio: "pipe",
|
|
});
|
|
execSync("npx tsc --noEmit", {
|
|
cwd: tmpDir,
|
|
encoding: "utf-8",
|
|
timeout: 60_000,
|
|
stdio: "pipe",
|
|
});
|
|
return { success: true, tmpDir };
|
|
} catch (e) {
|
|
return { success: false, error: e.stderr || e.message, tmpDir };
|
|
}
|
|
};
|
|
|
|
const { success, error, tmpDir } = await generateAndBuild();
|
|
|
|
if (!success) {
|
|
console.error("Build failed:", error?.slice(0, 1000));
|
|
}
|
|
|
|
assert.ok(success, `Build failed: ${error?.slice(0, 300)}`);
|
|
|
|
// Cleanup
|
|
rmSync(tmpDir, { recursive: true, force: true });
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("12 — CLI 集成", () => {
|
|
it("--prd + --arch CLI 模式", async () => {
|
|
const result = buildBackend(
|
|
loadPRD("ecommerce"),
|
|
loadArch()
|
|
);
|
|
writeBackend(result, resolve(WORKSPACE, ".tmp-cli-backend"));
|
|
assert.ok(!result.error);
|
|
rmSync(resolve(WORKSPACE, ".tmp-cli-backend"), { recursive: true, force: true });
|
|
});
|
|
|
|
it("--help 显示帮助", async () => {
|
|
const { execSync } = await import("node:child_process");
|
|
const output = execSync("node scripts/backend-builder-agent.mjs --help", {
|
|
cwd: WORKSPACE,
|
|
encoding: "utf-8",
|
|
});
|
|
assert.ok(output.includes("Backend Builder"));
|
|
assert.ok(output.includes("Usage"));
|
|
});
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("13 — 多领域覆盖", () => {
|
|
const domains = ["ecommerce", "enterprise", "education", "note"];
|
|
|
|
for (const domain of domains) {
|
|
it(`${domain} 域生成成功`, () => {
|
|
const prd = loadPRD(domain);
|
|
const result = buildBackend(prd, loadArch());
|
|
|
|
assert.ok(!result.error, `${domain}: ${result.message}`);
|
|
assert.ok(result.stats.totalFiles >= 8, `${domain}: expected >= 8 files, got ${result.stats.totalFiles}`);
|
|
assert.ok(result.stats.routes >= 2, `${domain}: expected >= 2 routes, got ${result.stats.routes}`);
|
|
assert.ok(result.stats.services >= 2, `${domain}: expected >= 2 services, got ${result.stats.services}`);
|
|
});
|
|
}
|
|
});
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
describe("14 — 生成的内容非空且有意义", () => {
|
|
it("所有生成的文件内容非空（>50 字符）", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
|
|
for (const [path, content] of Object.entries(result.files)) {
|
|
assert.ok(content.length > 50, `${path}: too short (${content.length} chars)`);
|
|
}
|
|
});
|
|
|
|
it("package.json 可解析为合法 JSON", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const pkg = JSON.parse(result.files["package.json"]);
|
|
assert.ok(pkg.name);
|
|
assert.ok(pkg.dependencies);
|
|
assert.ok(pkg.scripts);
|
|
});
|
|
|
|
it("tsconfig.json 可解析为合法 JSON", () => {
|
|
const result = buildBackend(DEMO_PRD, DEMO_ARCH);
|
|
const cfg = JSON.parse(result.files["tsconfig.json"]);
|
|
assert.ok(cfg.compilerOptions);
|
|
});
|
|
});
|