company-goal-task-routes.test.js
13.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
/**
* goal / task 两级模型的路由层(27-P3C §六,批 1)。
*
* 这里只验**不需要真起 run** 的那一半:列表 / 详情 / 改 / 归档,外加两条闸门的 HTTP 翻译
* (描述冻结 → 409、depends_on 非法 → 400 且库里不留脏数据)。起 run 的那条路要真公司 +
* 真 org graph + Claude CLI,属于 §八 验收清单里在浏览器上点的部分,不在单测射程内。
*
* 进度那条断言(2/3)是本文件的重点:验收 10 点名要挡的就是「列表页逐行查进度」的 N+1,
* 路由这边走的是 taskProgress 的一条 GROUP BY —— 结果对不对必须有人盯着,
* 否则改成逐行查也一样是绿的。
*/
const fs = require('fs');
const os = require('os');
const path = require('path');
const TEST_DB_PATH = '/tmp/test-company-goal-task-routes.sqlite';
const DB_FILES = [TEST_DB_PATH, `${TEST_DB_PATH}-shm`, `${TEST_DB_PATH}-wal`];
// 这几个模块在加载时快照 GRAPH_DB_PATH / GRAPH_RUNS_DIR,必须先设 env 再 require(见 §八 验收 12b)
const MODULES = ['../../services/graph-db', '../../services/work-graph-db', '../../routes/company'];
const CID = 'route-test-co';
let wdb;
let server;
let base;
let origin;
let origCompanyGet;
/** 一次请求 → [status, json](没有 supertest,express 起在随机端口上用 fetch 打) */
async function call(method, url, body) {
const r = await fetch(base + url, {
method,
headers: { 'Content-Type': 'application/json' },
body: body === undefined ? undefined : JSON.stringify(body),
});
return [r.status, await r.json()];
}
/** 同上,但公司 id 自己指定(验「打错公司 id → 404」那条要打到别的公司上) */
async function callCompany(cid, method, url) {
const r = await fetch(`${origin}/api/company/${cid}${url}`, { method });
return [r.status, await r.json()];
}
describe('company goal/task routes(27-P3C §六)', () => {
let goal; let t1; let t2;
beforeAll(async () => {
for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch { /* 本来就没有 */ } }
process.env.GRAPH_DB_PATH = TEST_DB_PATH;
// 产物根挪到临时目录:不设的话任何走到默认路径的写入都会往仓库 data/companies/ 里堆
process.env.GRAPH_RUNS_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'p3c-routes-'));
for (const m of MODULES) delete require.cache[require.resolve(m)];
wdb = require('../../services/work-graph-db');
// 公司实体:`company-service` 的 DATA_DIR 是硬编码的仓库 data/companies/,不认任何 env,
// 真建一家公司就是往用户仓库里落目录。这里只让 CID 这一家存在 —— 别的 id 一律 null,
// 「打错公司 id → 404」(缺陷 F9)那条断言要靠它。
const { CompanyService } = require('../../services/company-service');
origCompanyGet = CompanyService.prototype.get;
CompanyService.prototype.get = (companyId) =>
(companyId === CID ? { id: CID, name: CID, status: 'running' } : null);
const express = require('express');
const app = express();
app.use(express.json());
app.use('/api/company', require('../../routes/company'));
await new Promise((resolve) => {
server = app.listen(0, resolve);
});
origin = `http://127.0.0.1:${server.address().port}`;
base = `${origin}/api/company/${CID}`;
goal = wdb.createGoal({ companyId: CID, title: '做个官网', description: '做个官网,含首页和后台' });
t1 = wdb.createTask({ goalId: goal.id, title: '首页', description: '写首页' });
t2 = wdb.createTask({ goalId: goal.id, title: '后台', description: '写后台', dependsOn: [t1.id] });
// 给 t1 挂一条 run + 3 个节点行(2 success / 1 pending),用来验进度口径
const db = wdb.getDb();
const now = new Date().toISOString();
db.prepare(`INSERT INTO graph_runs (id, graph_kind, graph_id, company_id, root_run_id, run_status, created_at, updated_at)
VALUES ('run_rt','org',?,?, 'run_rt','running',?,?)`).run(CID, CID, now, now);
['success', 'success', 'pending'].forEach((status, i) => {
db.prepare(`INSERT INTO graph_run_nodes (id, run_id, def_node_id, status, created_at, updated_at)
VALUES (?, 'run_rt', ?, ?, ?, ?)`).run(`rn_rt${i}`, `d${i}`, status, now, now);
});
wdb.updateTask(t1.id, { currentRunId: 'run_rt', status: 'running' });
});
afterAll(() => {
if (server) server.close();
if (origCompanyGet) require('../../services/company-service').CompanyService.prototype.get = origCompanyGet;
for (const f of DB_FILES) { try { fs.unlinkSync(f); } catch { /* 已经删了 */ } }
try { fs.rmSync(process.env.GRAPH_RUNS_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
delete process.env.GRAPH_DB_PATH;
delete process.env.GRAPH_RUNS_DIR;
for (const m of MODULES) delete require.cache[require.resolve(m)];
});
it('GET /goals?withTasks=1 一次带出两级树,进度走一条 GROUP BY', async () => {
const [status, body] = await call('GET', '/goals?withTasks=1');
expect(status).toBe(200);
expect(body.goals).toHaveLength(1);
const tasks = body.goals[0].tasks;
expect(tasks.map((t) => t.taskId)).toEqual([t1.id, t2.id]); // 树的顺序是 seq,不是队列位次
expect(tasks[0].progress).toEqual({ done: 2, total: 3 });
// 没有 run 的 task 是 null 而不是 0/0:前端据此画「未开始」,画成 0/0 会像是「跑了但没进展」
expect(tasks[1].progress).toBeNull();
expect(tasks[1].dependsOn).toEqual([t1.id]);
});
it('GET /tasks 支持按 status 过滤,且默认不含已归档', async () => {
const [status, body] = await call('GET', '/tasks?status=running');
expect(status).toBe(200);
expect(body.tasks.map((t) => t.taskId)).toEqual([t1.id]);
});
it('GET /goals/:goalId 带出每条 task 的当前 run 摘要', async () => {
const [status, body] = await call('GET', `/goals/${goal.id}`);
expect(status).toBe(200);
expect(body.tasks[0].run).toMatchObject({ runId: 'run_rt', runStatus: 'running' });
expect(body.tasks[1].run).toBeNull();
});
it('不属于本公司 / 不存在的 goal 一律 404', async () => {
const [status] = await call('GET', '/goals/G-nope');
expect(status).toBe(404);
});
it('描述冻结:未下达可改,dispatched_at 一非空就 409 + hint(§四.4)', async () => {
const [ok, before] = await call('PATCH', `/goals/${goal.id}`, { description: '换个需求' });
expect(ok).toBe(200);
expect(before.description).toBe('换个需求');
wdb.updateGoal(goal.id, { dispatchedAt: new Date().toISOString() });
const [conflict, body] = await call('PATCH', `/goals/${goal.id}`, { description: '再换一次' });
expect(conflict).toBe(409);
expect(body.frozenFields).toEqual(['description']);
expect(body.hint).toBeTruthy(); // 「取消后新建」这句必须给出来,否则用户只知道被拒不知道该怎么办
// title 是列表上的标签、不进 agent 上下文,冻结之后仍可改
const [stillOk] = await call('PATCH', `/goals/${goal.id}`, { title: '改个名' });
expect(stillOk).toBe(200);
});
it('depends_on 非法 → 400,且库里不留半条脏数据(§六.3)', async () => {
const [status, body] = await call('PATCH', `/tasks/${t2.id}`, { depends_on: [t2.id] });
expect(status).toBe(400);
expect(body.error).toMatch(/依赖自己/);
expect(JSON.parse(wdb.getTask(t2.id).depends_on)).toEqual([t1.id]);
});
it('跑起来之后不许改依赖(判据在数据层,路由只负责翻成 409)', async () => {
const [status] = await call('PATCH', `/tasks/${t1.id}`, { depends_on: [] });
expect(status).toBe(409);
});
it('归档:正在跑的 task 拦下来并指出该先停哪条 run', async () => {
const [status, body] = await call('DELETE', `/goals/${goal.id}`);
expect(status).toBe(409);
expect(body.runningTasks).toEqual([t1.id]);
expect(body.hint).toContain('run_rt');
});
it('归档只是隐藏:默认列表不出现,includeArchived=1 查得回来', async () => {
const [status] = await call('DELETE', `/tasks/${t2.id}`);
expect(status).toBe(200);
const [, plain] = await call('GET', '/tasks');
expect(plain.tasks.map((t) => t.taskId)).toEqual([t1.id]);
const [, all] = await call('GET', '/tasks?includeArchived=1');
expect(all.tasks).toHaveLength(2);
});
it('OKR 的 /goals 别名已退役:这条路径下只剩 goal 两级模型(§六.1)', async () => {
// 别名还在的话,GET /goals 会被 OkrService 接走、返回 objective 数组而不是 { goals: [...] }
const [status, body] = await call('GET', '/goals');
expect(status).toBe(200);
expect(Array.isArray(body.goals)).toBe(true);
expect(body.goals[0].goalId).toBe(goal.id);
});
// ──────────────────────────────────────────────────────────────
// 复核缺陷 F3 / F4 / F5 / F7 / F9
// ──────────────────────────────────────────────────────────────
it('打错公司 id 的两个新 GET 端点回 404,不拿空列表冒充「没有目标」(缺陷 F9)', async () => {
for (const p of ['/goals', '/tasks']) {
const [status, body] = await callCompany('route-test-c0', 'GET', p);
expect(status).toBe(404);
expect(body.error).toMatch(/不存在/);
}
});
it('建 goal 时 tasks[].depends_on 可按 seq 引用同批兄弟,响应回真 id(缺陷 F5)', async () => {
const [status, body] = await call('POST', '/goals', {
description: '上线一个服务',
tasks: [
{ description: '构建镜像' },
{ description: '部署到测试环境', depends_on: [1] }, // 1 = 本次第 1 条的 seq
],
});
expect(status).toBe(201);
const [build, deploy] = body.tasks;
expect(deploy.seq).toBe(2);
// 翻译成真 id 才算数:回 [1] 或 [] 都会让批 3 的调度器把这条依赖当不存在
expect(deploy.dependsOn).toEqual([build.taskId]);
expect(JSON.parse(wdb.getTask(deploy.taskId).depends_on)).toEqual([build.taskId]);
// 环仍然要被数据层挡住(seq 引用不是绕过校验的后门)
const [cyclic, err] = await call('POST', '/goals', {
description: '互相依赖',
tasks: [
{ description: 'A', depends_on: [2] },
{ description: 'B', depends_on: [1] },
],
});
expect(cyclic).toBe(400);
expect(err.error).toMatch(/环/);
});
it('tasks[k] 非法 → 400,且 goals / tasks 两张表都不留残行(缺陷 F4)', async () => {
const before = wdb.listCompanyGoals(CID, { includeArchived: true }).length;
// task 也要数:只数 goal 的话,「goal 回滚了但第 0 条 task 已提交」这种半回滚是绿的
const beforeTasks = wdb.listCompanyTasks(CID, { includeArchived: true }).length;
const [status, body] = await call('POST', '/goals', {
description: '两条活,第二条写错了',
tasks: [{ description: '合法的第一条' }, { description: '第二条', mode: 'AUTO' }],
});
expect(status).toBe(400);
expect(body.error).toMatch(/tasks\[1\]\.mode/);
// 修之前:goal 已提交、第 0 条 task 已 INSERT,客户端改完重发就是第二个 goal,
// 第一个孤儿 goal 带着孤儿 task 永远躺在列表里
expect(wdb.listCompanyGoals(CID, { includeArchived: true }).length).toBe(before);
expect(wdb.listCompanyTasks(CID, { includeArchived: true }).length).toBe(beforeTasks);
});
it('建 goal 时申报的 budget 落库到 task 行(缺陷 F3 的写侧)', async () => {
const budget = { total_agent_calls: 7, total_tokens: 123456 };
const [status, body] = await call('POST', '/goals', { description: '带预算的需求', budget });
expect(status).toBe(201);
// 只有写侧没有读侧等于没写;读侧(dispatch 起 run 时用它)在 goal-task-acceptance.test.js 里验
expect(JSON.parse(wdb.getTask(body.tasks[0].taskId).budget_json)).toEqual(budget);
// 也要回得出来:查不到自己填的额度,用户就只能等任务 blocked 才发现不对
expect(body.tasks[0].budget).toEqual(budget);
});
it('PATCH 的 mode 走同一道信任边界:非法值 400 而不是 500 泄 SQLite 原文(缺陷 F7)', async () => {
const [, created] = await call('POST', '/goals', { description: '改 mode 用的 goal' });
const taskId = created.tasks[0].taskId;
const [bad, err] = await call('PATCH', `/tasks/${taskId}`, { mode: 'AUTO' });
expect(bad).toBe(400); // 修之前:直送 DB 撞 CHECK 约束 → 500 + "CHECK constraint failed: …"
expect(err.error).toMatch(/manual/);
// null 既不是「没传」也不是合法值:修之前被 `!== undefined` 过滤掉 → 200 但什么都没改
const [nulled] = await call('PATCH', `/tasks/${taskId}`, { mode: null });
expect(nulled).toBe(400);
const [ok, patched] = await call('PATCH', `/tasks/${taskId}`, { mode: 'auto' });
expect(ok).toBe(200);
expect(patched.mode).toBe('auto');
});
});