大海
831 lines
34 KiB
JavaScript
831 lines
34 KiB
JavaScript
/**
|
|
* PR-37 Domain Intelligence & Delivery Planning — Test Suite
|
|
*
|
|
* Part M：全覆盖测试
|
|
*
|
|
* 覆盖：
|
|
* A — Domain Registry
|
|
* B — Domain Classification
|
|
* C — Industry Epic Generation
|
|
* D — Industry Feature Generation
|
|
* E — Domain Validation
|
|
* F — Sprint Planning
|
|
* G — Release Planning
|
|
* H — Batch Planning
|
|
* I — Capacity Planning
|
|
* J — Roadmap Alignment
|
|
* K — Factory Integration
|
|
* Z — Regression (SF-01, SF-02, PR-35, PR-36)
|
|
*/
|
|
|
|
import { describe, it } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
// ─── Domain Registry (Part A) ──────────────────────
|
|
import {
|
|
getDomainRegistry, getDomain, listDomains,
|
|
getDomainsByCategory, searchDomains, DOMAINS, DOMAIN_CATEGORY,
|
|
} from "../src/pr-37-domain-intelligence/domain-registry.mjs";
|
|
|
|
// ─── Domain Intelligence (Parts B, C, D, E) ────────
|
|
import {
|
|
classifyProduct,
|
|
} from "../src/pr-37-domain-intelligence/domain-classifier.mjs";
|
|
|
|
import {
|
|
generateIndustryEpics, resetEpicCounter, describeDomain, listDomainEpics,
|
|
} from "../src/pr-37-domain-intelligence/industry-epic-generator.mjs";
|
|
|
|
import {
|
|
generateIndustryFeatures, resetFeatureCounter, detectFeatureType,
|
|
} from "../src/pr-37-domain-intelligence/industry-feature-generator.mjs";
|
|
|
|
import {
|
|
validateEpics, validateFeatures,
|
|
} from "../src/pr-37-domain-intelligence/domain-validator.mjs";
|
|
|
|
import { createDomainIntelligenceFactory } from "../src/pr-37-domain-intelligence/index.mjs";
|
|
|
|
// ─── Delivery Planning (Parts F, G, H, I, J) ──────
|
|
import {
|
|
generateSprintPlan, defaultSprintConfig,
|
|
} from "../src/pr-37-delivery-planning/sprint-planner.mjs";
|
|
|
|
import {
|
|
generateReleasePlan,
|
|
} from "../src/pr-37-delivery-planning/release-planner.mjs";
|
|
|
|
import {
|
|
generateBatchPlan,
|
|
} from "../src/pr-37-delivery-planning/batch-planner.mjs";
|
|
|
|
import {
|
|
generateCapacityPlan, defaultCapacityConfig,
|
|
} from "../src/pr-37-delivery-planning/capacity-planner.mjs";
|
|
|
|
import {
|
|
alignRoadmapWithPlans,
|
|
} from "../src/pr-37-delivery-planning/roadmap-aligner.mjs";
|
|
|
|
import {
|
|
createDeliveryPlanningFactory, PR37_ARTIFACTS,
|
|
} from "../src/pr-37-delivery-planning/index.mjs";
|
|
|
|
// ─── Regression Suite ──────────────────────────────
|
|
import { createFactoryRegistry } from "../src/software-factory-core/factory-registry.mjs";
|
|
import { createFactoryInput } from "../src/software-factory-core/factory-contract.mjs";
|
|
import { registerSF01 } from "../src/sf-01-product-strategy/index.mjs";
|
|
import { registerSF02 } from "../src/sf-02-requirement-engineering/index.mjs";
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// Test Fixtures
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
function mockStories(count = 30) {
|
|
return Array.from({ length: count }, (_, i) => ({
|
|
id: `us-${i + 1}`,
|
|
statement: `As a user, I want feature ${i + 1}, so that I can work better.`,
|
|
role: "用户",
|
|
goal: `feature ${i + 1}`,
|
|
value: "better work",
|
|
priority: i < 10 ? "Must Have" : i < 20 ? "Should Have" : "Could Have",
|
|
storyPoints: i < 10 ? 3 : i < 20 ? 2 : 1,
|
|
featureId: `ft-${Math.floor(i / 5) + 1}`,
|
|
epicId: `ep-${Math.floor(i / 8) + 1}`,
|
|
}));
|
|
}
|
|
|
|
function mockEpics(count = 4) {
|
|
return Array.from({ length: count }, (_, i) => ({
|
|
id: `ep-${i + 1}`,
|
|
title: ["财务管理", "采购管理", "库存管理", "销售管理"][i] || `Epic ${i + 1}`,
|
|
description: `Description for epic ${i + 1}`,
|
|
category: "管理",
|
|
objective: `Objective ${i + 1}`,
|
|
}));
|
|
}
|
|
|
|
function mockFeatures(count = 6) {
|
|
return Array.from({ length: count }, (_, i) => ({
|
|
id: `ft-${i + 1}`,
|
|
title: `Feature ${i + 1}`,
|
|
description: `Description for feature ${i + 1}`,
|
|
epicId: `ep-${Math.floor(i / 2) + 1}`,
|
|
featureType: "CRUD",
|
|
}));
|
|
}
|
|
|
|
function mockMVPScope() {
|
|
return {
|
|
mvp: { label: "MVP", epics: 2, features: 2, userStories: 10, totalStoryPoints: 30 },
|
|
v1: { label: "V1", epics: 4, features: 4, userStories: 20, totalStoryPoints: 50 },
|
|
v2: { label: "V2", epics: 4, features: 6, userStories: 30, totalStoryPoints: 60 },
|
|
enterprise: { label: "Enterprise", epics: 4, features: 6, userStories: 30 },
|
|
global: { label: "Global", epics: 4, features: 6, userStories: 30 },
|
|
phases: [
|
|
{ name: "mvp", scope: "最小可行产品", duration: 3, budget: 300000 },
|
|
{ name: "v1", scope: "第一完整版本", duration: 4, budget: 500000 },
|
|
{ name: "v2", scope: "功能增强版本", duration: 3, budget: 300000 },
|
|
],
|
|
};
|
|
}
|
|
|
|
function mockPriors(stories) {
|
|
return stories.map(s => ({
|
|
itemId: s.id, itemType: "story", category: s.priority,
|
|
score: s.priority === "Must Have" ? 100 : s.priority === "Should Have" ? 70 : 40,
|
|
}));
|
|
}
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// A — Domain Registry
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part A — Domain Registry", () => {
|
|
|
|
it("registers exactly 16 domains", () => {
|
|
const domains = listDomains();
|
|
assert.equal(domains.length, 16);
|
|
});
|
|
|
|
it("each domain has all 10 knowledge dimensions", () => {
|
|
for (const name of listDomains()) {
|
|
const d = getDomain(name);
|
|
assert.ok(d.name);
|
|
assert.ok(d.displayName);
|
|
assert.ok(d.description);
|
|
assert.ok(d.coreProcesses.length >= 3, `${name}: coreProcesses`);
|
|
assert.ok(d.coreEntities.length >= 3, `${name}: coreEntities`);
|
|
assert.ok(d.coreEpics.length >= 5, `${name}: coreEpics`);
|
|
assert.ok(Object.keys(d.coreFeatures).length >= 3, `${name}: coreFeatures`);
|
|
assert.ok(d.coreKPIs.length >= 3, `${name}: coreKPIs`);
|
|
assert.ok(d.coreRoles.length >= 3, `${name}: coreRoles`);
|
|
assert.ok(d.terminology.length >= 2, `${name}: terminology`);
|
|
assert.ok(d.constraints.length >= 1, `${name}: constraints`);
|
|
}
|
|
});
|
|
|
|
it("ERP domain has 10 core epics", () => {
|
|
const erp = getDomain("ERP");
|
|
assert.equal(erp.coreEpics.length, 10);
|
|
const titles = erp.coreEpics.map(e => e.title);
|
|
assert.ok(titles.includes("财务管理"));
|
|
assert.ok(titles.includes("采购管理"));
|
|
assert.ok(titles.includes("库存管理"));
|
|
assert.ok(titles.includes("生产管理"));
|
|
});
|
|
|
|
it("MES domain has 10 core epics", () => {
|
|
const mes = getDomain("MES");
|
|
assert.equal(mes.coreEpics.length, 10);
|
|
const titles = mes.coreEpics.map(e => e.title);
|
|
assert.ok(titles.includes("生产执行"));
|
|
assert.ok(titles.includes("质量管理"));
|
|
assert.ok(titles.includes("设备管理"));
|
|
assert.ok(titles.includes("工单管理"));
|
|
});
|
|
|
|
it("CRM domain has 9 core epics", () => {
|
|
const crm = getDomain("CRM");
|
|
assert.ok(crm.coreEpics.length >= 7);
|
|
const titles = crm.coreEpics.map(e => e.title);
|
|
assert.ok(titles.includes("客户管理"));
|
|
assert.ok(titles.includes("商机管理"));
|
|
assert.ok(titles.includes("销售漏斗"));
|
|
});
|
|
|
|
it("AI Platform domain has 8 core epics", () => {
|
|
const ai = getDomain("AI Platform");
|
|
assert.ok(ai.coreEpics.length >= 6);
|
|
const titles = ai.coreEpics.map(e => e.title);
|
|
assert.ok(titles.includes("知识库管理"));
|
|
assert.ok(titles.includes("Agent管理"));
|
|
});
|
|
|
|
it("getDomain returns null for unknown domain", () => {
|
|
assert.equal(getDomain("UnknownDomain"), null);
|
|
});
|
|
|
|
it("searchDomains finds by keyword", () => {
|
|
const results = searchDomains("MES");
|
|
assert.ok(results.length >= 1);
|
|
assert.equal(results[0].name, "MES");
|
|
});
|
|
|
|
it("getDomainsByCategory filters correctly", () => {
|
|
const enterprise = getDomainsByCategory(DOMAIN_CATEGORY.ENTERPRISE_SOFTWARE);
|
|
assert.ok(enterprise.length >= 3);
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// B — Domain Classification
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part B — Domain Classification", () => {
|
|
|
|
it("classifies ERP system correctly", () => {
|
|
const result = classifyProduct({ productName: "ERP系统", description: "企业资源计划" });
|
|
assert.equal(result.primaryDomain, "ERP");
|
|
assert.ok(result.confidenceScore >= 0.3);
|
|
assert.ok(result.matchedKeywords.length >= 1);
|
|
});
|
|
|
|
it("classifies MES system correctly", () => {
|
|
const result = classifyProduct({ productName: "工业MES系统", description: "制造执行系统" });
|
|
assert.equal(result.primaryDomain, "MES");
|
|
assert.ok(result.confidenceScore >= 0.5);
|
|
});
|
|
|
|
it("classifies AI customer service platform", () => {
|
|
const result = classifyProduct({ productName: "AI客服平台", description: "智能客服系统" });
|
|
assert.equal(result.primaryDomain, "AI Platform");
|
|
});
|
|
|
|
it("classifies CRM system", () => {
|
|
const result = classifyProduct({ productName: "CRM系统", description: "客户关系管理" });
|
|
assert.equal(result.primaryDomain, "CRM");
|
|
});
|
|
|
|
it("classifies cross-border ecommerce with secondary", () => {
|
|
const result = classifyProduct({ productName: "跨境电商平台", description: "跨境电商" });
|
|
assert.equal(result.primaryDomain, "E-Commerce");
|
|
assert.ok(result.secondaryDomain);
|
|
});
|
|
|
|
it("classifies industrial AI quality inspection", () => {
|
|
const result = classifyProduct({ productName: "工业AI质检", description: "智能制造AI质检" });
|
|
assert.equal(result.primaryDomain, "MES");
|
|
});
|
|
|
|
it("classifies WMS warehouse", () => {
|
|
const result = classifyProduct({ productName: "WMS仓库", description: "仓储管理" });
|
|
assert.equal(result.primaryDomain, "WMS");
|
|
});
|
|
|
|
it("returns null for empty input", () => {
|
|
const result = classifyProduct({ productName: "", description: "" });
|
|
assert.equal(result.primaryDomain, null);
|
|
assert.equal(result.confidenceScore, 0);
|
|
assert.ok(result.classificationReason);
|
|
});
|
|
|
|
it("returns null for null input", () => {
|
|
const result = classifyProduct(null);
|
|
assert.equal(result.primaryDomain, null);
|
|
assert.equal(result.confidenceScore, 0);
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// C — Industry Epic Generation
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part C — Industry Epic Generation", () => {
|
|
|
|
it("generates ERP-specific epics with domain vocabulary", () => {
|
|
resetEpicCounter();
|
|
const epics = generateIndustryEpics("ERP", { productName: "ERP系统" });
|
|
assert.equal(epics.length, 10);
|
|
const titles = epics.map(e => e.title);
|
|
assert.ok(titles.includes("财务管理"));
|
|
assert.ok(titles.includes("采购管理"));
|
|
assert.ok(titles.includes("生产管理"));
|
|
// Should NOT have generic "内容管理"
|
|
assert.ok(!titles.includes("内容管理"));
|
|
});
|
|
|
|
it("generates MES-specific epics", () => {
|
|
resetEpicCounter();
|
|
const epics = generateIndustryEpics("MES", { productName: "工业MES系统" });
|
|
assert.equal(epics.length, 10);
|
|
const titles = epics.map(e => e.title);
|
|
assert.ok(titles.includes("质量管理"));
|
|
assert.ok(titles.includes("设备管理"));
|
|
assert.ok(titles.includes("追溯管理"));
|
|
});
|
|
|
|
it("generates AI Platform epics", () => {
|
|
resetEpicCounter();
|
|
const epics = generateIndustryEpics("AI Platform", { productName: "AI客服平台" });
|
|
assert.ok(epics.length >= 6);
|
|
const titles = epics.map(e => e.title);
|
|
assert.ok(titles.includes("知识库管理"));
|
|
assert.ok(titles.includes("Agent管理"));
|
|
});
|
|
|
|
it("each epic has all required fields", () => {
|
|
resetEpicCounter();
|
|
const epics = generateIndustryEpics("ERP", { productName: "ERP系统" });
|
|
for (const epic of epics) {
|
|
assert.ok(epic.id.startsWith("ep-"));
|
|
assert.ok(epic.title);
|
|
assert.ok(epic.description);
|
|
assert.ok(epic.category);
|
|
assert.ok(epic.objective);
|
|
assert.ok(epic.successMetric);
|
|
}
|
|
});
|
|
|
|
it("falls back to generic template for unknown domain", () => {
|
|
resetEpicCounter();
|
|
const epics = generateIndustryEpics("量子计算", { productName: "量子计算机" });
|
|
assert.ok(epics.length >= 5);
|
|
// Generic epics shouldn't have ERP-specific ones
|
|
const titles = epics.map(e => e.title);
|
|
assert.ok(!titles.includes("财务管理"));
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// D — Industry Feature Generation
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part D — Industry Feature Generation", () => {
|
|
|
|
it("generates ERP features from domain registry", () => {
|
|
resetEpicCounter(); resetFeatureCounter();
|
|
const epics = generateIndustryEpics("ERP", { productName: "ERP系统" });
|
|
const features = generateIndustryFeatures("ERP", epics);
|
|
assert.ok(features.length >= 50);
|
|
const titles = features.map(f => f.title);
|
|
assert.ok(titles.includes("总账管理"));
|
|
assert.ok(titles.includes("供应商管理"));
|
|
});
|
|
|
|
it("detects feature types correctly", () => {
|
|
assert.equal(detectFeatureType("数据分析"), "analytics");
|
|
assert.equal(detectFeatureType("审批流程"), "workflow");
|
|
assert.equal(detectFeatureType("统计分析"), "analytics");
|
|
assert.equal(detectFeatureType("消息推送"), "notification");
|
|
assert.equal(detectFeatureType("搜索"), "search");
|
|
assert.equal(detectFeatureType("系统设置"), "configuration");
|
|
assert.equal(detectFeatureType("用户管理"), "CRUD");
|
|
});
|
|
|
|
it("each feature references correct epicId", () => {
|
|
resetEpicCounter(); resetFeatureCounter();
|
|
const epics = generateIndustryEpics("ERP", { productName: "ERP系统" });
|
|
const features = generateIndustryFeatures("ERP", epics);
|
|
const epicIds = new Set(epics.map(e => e.id));
|
|
for (const f of features) {
|
|
assert.ok(epicIds.has(f.epicId), `Feature ${f.title} epicId ${f.epicId} not in epics`);
|
|
}
|
|
});
|
|
|
|
it("each feature has id with ft- prefix", () => {
|
|
resetEpicCounter(); resetFeatureCounter();
|
|
const epics = generateIndustryEpics("MES", { productName: "MES系统" });
|
|
const features = generateIndustryFeatures("MES", epics);
|
|
for (const f of features) {
|
|
assert.ok(f.id.startsWith("ft-"));
|
|
}
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// E — Domain Validation
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part E — Domain Validation", () => {
|
|
|
|
it("validates ERP epics with 100% coverage", () => {
|
|
resetEpicCounter();
|
|
const epics = generateIndustryEpics("ERP", { productName: "ERP系统" });
|
|
const result = validateEpics(epics, "ERP");
|
|
assert.equal(result.overallVerdict, "pass");
|
|
assert.equal(result.coverageScore, 100);
|
|
assert.equal(result.completenessScore, 100);
|
|
});
|
|
|
|
it("validates MES epics with 100% coverage", () => {
|
|
resetEpicCounter();
|
|
const epics = generateIndustryEpics("MES", { productName: "MES系统" });
|
|
const result = validateEpics(epics, "MES");
|
|
assert.equal(result.overallVerdict, "pass");
|
|
assert.equal(result.coverageScore, 100);
|
|
});
|
|
|
|
it("detects generic epics as low coverage for ERP", () => {
|
|
const genericEpics = [
|
|
{ title: "用户管理" }, { title: "内容管理" }, { title: "业务流程" },
|
|
];
|
|
const result = validateEpics(genericEpics, "ERP");
|
|
assert.ok(result.coverageScore < 100);
|
|
assert.ok(result.missingEpics.length > 0);
|
|
assert.equal(result.overallVerdict, "fail");
|
|
});
|
|
|
|
it("validates features consistency", () => {
|
|
resetEpicCounter(); resetFeatureCounter();
|
|
const epics = generateIndustryEpics("ERP", { productName: "ERP系统" });
|
|
const features = generateIndustryFeatures("ERP", epics);
|
|
const result = validateFeatures(features, "ERP");
|
|
assert.ok(result.consistencyScore >= 70);
|
|
});
|
|
|
|
it("handles unknown domain gracefully", () => {
|
|
const result = validateEpics([{ title: "Test" }], "UnknownDomain");
|
|
assert.equal(result.coverageScore, 0);
|
|
assert.equal(result.overallVerdict, "fail");
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// F — Sprint Planning
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part F — Sprint Planning", () => {
|
|
|
|
it("generates sprints from Must Have stories", () => {
|
|
const stories = mockStories(30);
|
|
const priors = mockPriors(stories);
|
|
const result = generateSprintPlan({
|
|
stories, dependencies: [], priorities: priors,
|
|
config: defaultSprintConfig({ teamVelocity: 20 }),
|
|
});
|
|
assert.ok(result.sprints.length >= 1, `Expected >=1 sprints, got ${result.sprints.length}`);
|
|
assert.ok(result.metrics.totalSprints >= 1);
|
|
});
|
|
|
|
it("respects sprint capacity", () => {
|
|
const stories = mockStories(30);
|
|
const priors = mockPriors(stories);
|
|
const result = generateSprintPlan({
|
|
stories, dependencies: [], priorities: priors,
|
|
config: defaultSprintConfig({ teamVelocity: 15, maxStoryPointsPerSprint: 15 }),
|
|
});
|
|
for (const sprint of result.sprints) {
|
|
assert.ok(sprint.totalStoryPoints <= 15 + 5, // allow small overflow
|
|
`Sprint ${sprint.sprintNumber}: ${sprint.totalStoryPoints} pts > 20`);
|
|
}
|
|
});
|
|
|
|
it("each sprint has required fields", () => {
|
|
const result = generateSprintPlan({
|
|
stories: mockStories(20), dependencies: [], priorities: mockPriors(mockStories(20)),
|
|
});
|
|
for (const s of result.sprints) {
|
|
assert.ok(s.sprintNumber);
|
|
assert.ok(s.sprintGoal);
|
|
assert.ok(s.startDate);
|
|
assert.ok(s.endDate);
|
|
assert.ok(Array.isArray(s.storyIds));
|
|
assert.ok(s.totalStoryPoints >= 0);
|
|
assert.ok(Array.isArray(s.risks));
|
|
}
|
|
});
|
|
|
|
it("handles single story", () => {
|
|
const stories = [{ id: "us-1", statement: "test", priority: "Must Have", storyPoints: 3, featureId: "ft-1", epicId: "ep-1" }];
|
|
const priors = [{ itemId: "us-1", itemType: "story", category: "Must Have", score: 100 }];
|
|
const result = generateSprintPlan({ stories, dependencies: [], priorities: priors });
|
|
assert.equal(result.sprints.length, 1);
|
|
assert.equal(result.sprints[0].storyIds.length, 1);
|
|
});
|
|
|
|
it("handles empty stories", () => {
|
|
const result = generateSprintPlan({ stories: [], dependencies: [], priorities: [] });
|
|
assert.equal(result.sprints.length, 0);
|
|
assert.equal(result.metrics.totalSprints, 0);
|
|
});
|
|
|
|
it("respects dependency order", () => {
|
|
const stories = [
|
|
{ id: "us-1", statement: "base", priority: "Must Have", storyPoints: 5, featureId: "ft-1", epicId: "ep-1" },
|
|
{ id: "us-2", statement: "dependent", priority: "Must Have", storyPoints: 5, featureId: "ft-1", epicId: "ep-1" },
|
|
{ id: "us-3", statement: "filler", priority: "Should Have", storyPoints: 3, featureId: "ft-1", epicId: "ep-1" },
|
|
];
|
|
const priors = [
|
|
{ itemId: "us-1", itemType: "story", category: "Must Have", score: 100 },
|
|
{ itemId: "us-2", itemType: "story", category: "Must Have", score: 95 },
|
|
{ itemId: "us-3", itemType: "story", category: "Should Have", score: 70 },
|
|
];
|
|
// us-2 depends on us-1 (us-2 → us-1 means us-2 requires us-1 first)
|
|
const deps = { edges: [{ from: "us-2", to: "us-1", critical: true }] };
|
|
const result = generateSprintPlan({ stories, dependencies: deps, priorities: priors, config: defaultSprintConfig({ teamVelocity: 8 }) });
|
|
// Both us-1 and us-2 should be in the sprint plan
|
|
const allIds = result.sprints.flatMap(s => s.storyIds);
|
|
assert.ok(allIds.includes("us-1"), "us-1 should be planned");
|
|
assert.ok(allIds.includes("us-2"), "us-2 should be planned");
|
|
// us-2 must not be assigned before us-1 (dependency constraint)
|
|
const s1 = result.sprints.find(s => s.storyIds.includes("us-1"));
|
|
const s2 = result.sprints.find(s => s.storyIds.includes("us-2"));
|
|
assert.ok(s1.sprintNumber <= s2.sprintNumber,
|
|
`us-1 (Sprint ${s1.sprintNumber}) must not be after us-2 (Sprint ${s2.sprintNumber})`);
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// G — Release Planning
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part G — Release Planning", () => {
|
|
|
|
it("generates 5 releases from mvpScope", () => {
|
|
const result = generateReleasePlan({
|
|
mvpScope: mockMVPScope(),
|
|
priorities: mockPriors(mockStories(30)),
|
|
dependencies: [],
|
|
stories: mockStories(30),
|
|
epics: mockEpics(4),
|
|
features: mockFeatures(6),
|
|
});
|
|
assert.equal(result.releases.length, 5);
|
|
const versions = result.releases.map(r => r.version);
|
|
assert.ok(versions.includes("1.0.0"));
|
|
assert.ok(versions.includes("2.0.0"));
|
|
});
|
|
|
|
it("R1.0 (MVP) contains Must Have stories", () => {
|
|
const stories = mockStories(30);
|
|
const result = generateReleasePlan({
|
|
mvpScope: mockMVPScope(),
|
|
priorities: mockPriors(stories),
|
|
dependencies: [],
|
|
stories,
|
|
epics: mockEpics(4),
|
|
features: mockFeatures(6),
|
|
});
|
|
const r1 = result.releases[0];
|
|
assert.ok(r1.features.storyCount > 0);
|
|
assert.ok(r1.validationGates.length >= 3);
|
|
});
|
|
|
|
it("each release has validation gates and goals", () => {
|
|
const result = generateReleasePlan({
|
|
mvpScope: mockMVPScope(),
|
|
priorities: mockPriors(mockStories(30)),
|
|
dependencies: [],
|
|
stories: mockStories(30),
|
|
epics: mockEpics(4),
|
|
features: mockFeatures(6),
|
|
});
|
|
for (const release of result.releases) {
|
|
assert.ok(release.version);
|
|
assert.ok(release.name);
|
|
assert.ok(Array.isArray(release.validationGates));
|
|
assert.ok(release.releaseGoals);
|
|
}
|
|
});
|
|
|
|
it("handles null mvpScope gracefully", () => {
|
|
const result = generateReleasePlan({
|
|
mvpScope: null,
|
|
priorities: [],
|
|
dependencies: [],
|
|
stories: [],
|
|
epics: [],
|
|
features: [],
|
|
});
|
|
assert.ok(result.releases);
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// H — Batch Planning
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part H — Batch Planning", () => {
|
|
|
|
it("generates batches with dependency levels", () => {
|
|
const stories = [
|
|
{ id: "us-1", statement: "no deps", priority: "Must Have", storyPoints: 3, featureId: "ft-1", epicId: "ep-1" },
|
|
{ id: "us-2", statement: "dep on 1", priority: "Must Have", storyPoints: 2, featureId: "ft-1", epicId: "ep-1" },
|
|
{ id: "us-3", statement: "dep on 2", priority: "Should Have", storyPoints: 1, featureId: "ft-1", epicId: "ep-1" },
|
|
];
|
|
const deps = {
|
|
edges: [
|
|
{ from: "us-2", to: "us-1", critical: true },
|
|
{ from: "us-3", to: "us-2", critical: true },
|
|
],
|
|
};
|
|
const result = generateBatchPlan({
|
|
stories,
|
|
dependencies: deps,
|
|
priorities: mockPriors(stories),
|
|
sprints: { sprints: [] },
|
|
releases: { releases: [] },
|
|
});
|
|
assert.ok(result.batches.length >= 1);
|
|
// Should have at least a DevelopmentBatch with dependency levels
|
|
const devBatch = result.batches.find(b => b.batchType === "DevelopmentBatch");
|
|
assert.ok(devBatch);
|
|
});
|
|
|
|
it("generates all 4 batch types when data is sufficient", () => {
|
|
const stories = mockStories(20);
|
|
const sp = generateSprintPlan({ stories, dependencies: [], priorities: mockPriors(stories) });
|
|
const rp = generateReleasePlan({
|
|
mvpScope: mockMVPScope(), priorities: mockPriors(stories),
|
|
dependencies: [], stories, epics: mockEpics(4), features: mockFeatures(6),
|
|
});
|
|
const result = generateBatchPlan({
|
|
stories, dependencies: [], priorities: mockPriors(stories),
|
|
sprints: sp, releases: rp.releases,
|
|
});
|
|
assert.ok(result.batches.length >= 1);
|
|
const types = new Set(result.batches.map(b => b.batchType));
|
|
assert.ok(types.has("DevelopmentBatch"));
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// I — Capacity Planning
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part I — Capacity Planning", () => {
|
|
|
|
it("calculates capacity from sprint plan", () => {
|
|
const stories = mockStories(20);
|
|
const sp = generateSprintPlan({ stories, dependencies: [], priorities: mockPriors(stories) });
|
|
const cp = generateCapacityPlan({ sprints: sp.sprints, releases: [] });
|
|
assert.ok(cp.totalEffort > 0);
|
|
assert.ok(cp.totalCapacity > 0);
|
|
assert.ok(cp.capacityUtilization.includes("%"));
|
|
});
|
|
|
|
it("delivery forecast provides realistic date", () => {
|
|
const stories = mockStories(20);
|
|
const sp = generateSprintPlan({ stories, dependencies: [], priorities: mockPriors(stories) });
|
|
const cp = generateCapacityPlan({ sprints: sp.sprints, releases: [] });
|
|
assert.ok(cp.deliveryForecast.realistic);
|
|
assert.notEqual(cp.deliveryForecast.realistic, "N/A");
|
|
});
|
|
|
|
it("handles empty sprint list gracefully", () => {
|
|
const cp = generateCapacityPlan({ sprints: [], releases: [] });
|
|
assert.equal(cp.totalEffort, 0);
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// J — Roadmap Alignment
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part J — Roadmap Alignment", () => {
|
|
|
|
it("aligns roadmap with sprint and release plans", () => {
|
|
const stories = mockStories(30);
|
|
const sp = generateSprintPlan({ stories, dependencies: [], priorities: mockPriors(stories) });
|
|
const rp = generateReleasePlan({
|
|
mvpScope: mockMVPScope(), priorities: mockPriors(stories),
|
|
dependencies: [], stories, epics: mockEpics(4), features: mockFeatures(6),
|
|
});
|
|
const bp = generateBatchPlan({ stories, dependencies: [], priorities: mockPriors(stories), sprints: sp.sprints, releases: rp.releases });
|
|
|
|
const result = alignRoadmapWithPlans({
|
|
roadmap: mockMVPScope(),
|
|
sprintPlan: sp,
|
|
releasePlan: rp,
|
|
batchPlan: bp,
|
|
mvpScope: mockMVPScope(),
|
|
});
|
|
assert.ok(["aligned", "partial", "misaligned"].includes(result.overallVerdict));
|
|
assert.ok(result.alignmentScore >= 0 && result.alignmentScore <= 100);
|
|
assert.ok(result.summary);
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// K — Factory Integration
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part K — Factory Integration", () => {
|
|
|
|
it("createDomainIntelligenceFactory produces epics + features + validation", () => {
|
|
const result = createDomainIntelligenceFactory({ productName: "ERP系统" });
|
|
assert.equal(result.classification.primaryDomain, "ERP");
|
|
assert.ok(result.epics.length >= 8);
|
|
assert.ok(result.features.length >= 50);
|
|
assert.ok(result.validation);
|
|
assert.equal(result.validation.overallVerdict, "pass");
|
|
});
|
|
|
|
it("createDomainIntelligenceFactory accepts domainOverride", () => {
|
|
const result = createDomainIntelligenceFactory(
|
|
{ productName: "神秘系统" },
|
|
{ domainOverride: "MES" }
|
|
);
|
|
assert.equal(result.classification.primaryDomain, "MES");
|
|
assert.equal(result.classification.confidenceScore, 1.0);
|
|
});
|
|
|
|
it("createDeliveryPlanningFactory produces 4 plans", () => {
|
|
const stories = mockStories(30);
|
|
const sf02Data = {
|
|
userStories: stories,
|
|
epics: mockEpics(4),
|
|
features: mockFeatures(6),
|
|
dependencies: { nodes: [], edges: [] },
|
|
priorities: mockPriors(stories),
|
|
mvpScope: mockMVPScope(),
|
|
roadmap: mockMVPScope().phases,
|
|
};
|
|
const result = createDeliveryPlanningFactory(sf02Data);
|
|
assert.equal(result.status, "passed");
|
|
assert.ok(result.sprintPlan.sprints.length >= 1);
|
|
assert.ok(result.releasePlan.releases.length >= 1);
|
|
assert.ok(result.batchPlan.batches.length >= 1);
|
|
assert.ok(result.capacityPlan.totalEffort > 0);
|
|
assert.ok(result.alignmentReport);
|
|
assert.ok(["aligned", "partial", "misaligned"].includes(result.alignmentReport.overallVerdict));
|
|
});
|
|
|
|
it("createDeliveryPlanningFactory fails gracefully with no data", () => {
|
|
const result = createDeliveryPlanningFactory(null);
|
|
assert.equal(result.status, "failed");
|
|
assert.ok(result.error);
|
|
});
|
|
|
|
it("PR37_ARTIFACTS has all artifact types", () => {
|
|
const types = Object.values(PR37_ARTIFACTS);
|
|
assert.ok(types.includes("sprint-plan"));
|
|
assert.ok(types.includes("release-plan"));
|
|
assert.ok(types.includes("batch-plan"));
|
|
assert.ok(types.includes("capacity-plan"));
|
|
assert.ok(types.includes("alignment-report"));
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════
|
|
// Z — Regression: SF-01, SF-02, PR-35, PR-36
|
|
// ═════════════════════════════════════════════════════
|
|
|
|
describe("PR-37 Part Z — Regression", () => {
|
|
|
|
it("SF-01 factory still works after PR-37", () => {
|
|
const registry = createFactoryRegistry();
|
|
registerSF01(registry);
|
|
const input = createFactoryInput({ factoryId: "SF-01", parameters: { idea: "AI客服平台" } });
|
|
const output = registry.execute("SF-01", input);
|
|
assert.equal(output.status, "passed");
|
|
});
|
|
|
|
it("SF-02 factory still works after PR-37", () => {
|
|
const registry = createFactoryRegistry();
|
|
registerSF01(registry);
|
|
registerSF02(registry);
|
|
const sf01Out = registry.execute("SF-01", createFactoryInput({ factoryId: "SF-01", parameters: { idea: "AI客服平台" } }));
|
|
const sf02Out = registry.execute("SF-02", createFactoryInput({ factoryId: "SF-02", upstreamArtifacts: sf01Out.artifacts }));
|
|
assert.equal(sf02Out.status, "passed");
|
|
assert.ok(sf02Out.artifacts.length >= 10);
|
|
});
|
|
|
|
it("SF-01 → SF-02 → PR-37 full pipeline", () => {
|
|
const registry = createFactoryRegistry();
|
|
registerSF01(registry);
|
|
registerSF02(registry);
|
|
|
|
const sf01Out = registry.execute("SF-01", createFactoryInput({ factoryId: "SF-01", parameters: { idea: "ERP系统" } }));
|
|
const sf02Out = registry.execute("SF-02", createFactoryInput({ factoryId: "SF-02", upstreamArtifacts: sf01Out.artifacts }));
|
|
|
|
// Extract SF-02 data
|
|
const stories = JSON.parse(sf02Out.artifacts.find(a => a.metadata?.artifactType === "user-story-catalog").content);
|
|
const epics = JSON.parse(sf02Out.artifacts.find(a => a.metadata?.artifactType === "epic-catalog").content);
|
|
const features = JSON.parse(sf02Out.artifacts.find(a => a.metadata?.artifactType === "feature-catalog").content);
|
|
const depGraph = JSON.parse(sf02Out.artifacts.find(a => a.metadata?.artifactType === "dependency-graph").content);
|
|
const priMatrix = JSON.parse(sf02Out.artifacts.find(a => a.metadata?.artifactType === "priority-matrix").content);
|
|
const mvpScope = JSON.parse(sf02Out.artifacts.find(a => a.metadata?.artifactType === "mvp-scope").content);
|
|
|
|
// Build pri entries from priMatrix
|
|
const priEntries = [];
|
|
const catMap = { mustHave: "Must Have", shouldHave: "Should Have", couldHave: "Could Have", wontHave: "Won't Have" };
|
|
if (priMatrix?.story) {
|
|
for (const [cat, ids] of Object.entries(priMatrix.story)) {
|
|
if (cat === "summary") continue;
|
|
for (const id of ids) priEntries.push({ itemId: id, itemType: "story", category: catMap[cat] || cat, score: cat === "mustHave" ? 100 : cat === "shouldHave" ? 70 : 40 });
|
|
}
|
|
}
|
|
|
|
// PR-37 Domain Intelligence
|
|
const diResult = createDomainIntelligenceFactory({ productName: "ERP系统" });
|
|
assert.equal(diResult.classification.primaryDomain, "ERP");
|
|
assert.ok(diResult.epics.length >= 8);
|
|
assert.equal(diResult.validation.overallVerdict, "pass");
|
|
|
|
// PR-37 Delivery Planning
|
|
const dpResult = createDeliveryPlanningFactory({
|
|
userStories: stories, epics, features,
|
|
dependencies: depGraph,
|
|
priorities: priEntries,
|
|
mvpScope,
|
|
roadmap: mvpScope.phases,
|
|
});
|
|
assert.equal(dpResult.status, "passed");
|
|
assert.ok(dpResult.sprintPlan.sprints.length >= 1);
|
|
assert.ok(dpResult.releasePlan.releases.length >= 1);
|
|
assert.ok(dpResult.alignmentReport);
|
|
});
|
|
|
|
it("PR-35/PR-36 factory registry topological order preserved", () => {
|
|
const registry = createFactoryRegistry();
|
|
registerSF01(registry);
|
|
registerSF02(registry);
|
|
const order = registry.getTopologicalOrder();
|
|
const sf01Idx = order.indexOf("SF-01");
|
|
const sf02Idx = order.indexOf("SF-02");
|
|
assert.ok(sf01Idx < sf02Idx, "SF-01 must come before SF-02 in topological order");
|
|
});
|
|
});
|