mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-05 01:50:27 +08:00
357 lines
13 KiB
TypeScript
357 lines
13 KiB
TypeScript
/**
|
|
* Integration tests for issue routes (issues + solutions + queue).
|
|
*
|
|
* Notes:
|
|
* - Targets runtime implementation shipped in `ccw/dist`.
|
|
* - Uses a temporary project root to isolate `.workflow/issues` JSONL storage.
|
|
*/
|
|
|
|
import { after, before, beforeEach, describe, it, mock } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import http from 'node:http';
|
|
import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { join } from 'node:path';
|
|
|
|
const issueRoutesUrl = new URL('../../dist/core/routes/issue-routes.js', import.meta.url);
|
|
issueRoutesUrl.searchParams.set('t', String(Date.now()));
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
let mod: any;
|
|
|
|
type JsonResponse = { status: number; json: any; text: string };
|
|
|
|
async function requestJson(
|
|
baseUrl: string,
|
|
method: string,
|
|
path: string,
|
|
body?: unknown,
|
|
): Promise<JsonResponse> {
|
|
const url = new URL(path, baseUrl);
|
|
const payload = body === undefined ? null : Buffer.from(JSON.stringify(body), 'utf8');
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const req = http.request(
|
|
url,
|
|
{
|
|
method,
|
|
headers: {
|
|
Accept: 'application/json',
|
|
...(payload
|
|
? { 'Content-Type': 'application/json', 'Content-Length': String(payload.length) }
|
|
: {}),
|
|
},
|
|
},
|
|
(res) => {
|
|
let responseBody = '';
|
|
res.on('data', (chunk) => {
|
|
responseBody += chunk.toString();
|
|
});
|
|
res.on('end', () => {
|
|
let json: any = null;
|
|
try {
|
|
json = responseBody ? JSON.parse(responseBody) : null;
|
|
} catch {
|
|
json = null;
|
|
}
|
|
resolve({ status: res.statusCode || 0, json, text: responseBody });
|
|
});
|
|
},
|
|
);
|
|
req.on('error', reject);
|
|
if (payload) req.write(payload);
|
|
req.end();
|
|
});
|
|
}
|
|
|
|
function handlePostRequest(req: http.IncomingMessage, res: http.ServerResponse, handler: (body: any) => Promise<any>): void {
|
|
let body = '';
|
|
req.on('data', (chunk) => {
|
|
body += chunk.toString();
|
|
});
|
|
req.on('end', async () => {
|
|
try {
|
|
const parsed = body ? JSON.parse(body) : {};
|
|
const result = await handler(parsed);
|
|
|
|
if (result?.error) {
|
|
res.writeHead(result.status || 500, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: result.error }));
|
|
} else {
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify(result));
|
|
}
|
|
} catch (err: any) {
|
|
res.writeHead(500, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: err?.message || String(err) }));
|
|
}
|
|
});
|
|
}
|
|
|
|
function readJsonl(path: string): any[] {
|
|
if (!existsSync(path)) return [];
|
|
return readFileSync(path, 'utf8')
|
|
.split('\n')
|
|
.filter((line) => line.trim().length > 0)
|
|
.map((line) => JSON.parse(line));
|
|
}
|
|
|
|
describe('issue routes integration', async () => {
|
|
let server: http.Server | null = null;
|
|
let baseUrl = '';
|
|
let projectRoot = '';
|
|
|
|
before(async () => {
|
|
projectRoot = mkdtempSync(join(tmpdir(), 'ccw-issue-routes-project-'));
|
|
|
|
mock.method(console, 'log', () => {});
|
|
mock.method(console, 'error', () => {});
|
|
|
|
mod = await import(issueRoutesUrl.href);
|
|
|
|
server = http.createServer(async (req, res) => {
|
|
const url = new URL(req.url || '/', 'http://localhost');
|
|
const pathname = url.pathname;
|
|
|
|
const ctx = {
|
|
pathname,
|
|
url,
|
|
req,
|
|
res,
|
|
initialPath: projectRoot,
|
|
handlePostRequest,
|
|
};
|
|
|
|
try {
|
|
const handled = await mod.handleIssueRoutes(ctx);
|
|
if (!handled) {
|
|
res.writeHead(404, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: 'Not Found' }));
|
|
}
|
|
} catch (err: any) {
|
|
res.writeHead(500, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: err?.message || String(err) }));
|
|
}
|
|
});
|
|
|
|
await new Promise<void>((resolve) => server!.listen(0, () => resolve()));
|
|
const addr = server.address();
|
|
const port = typeof addr === 'object' && addr ? addr.port : 0;
|
|
baseUrl = `http://127.0.0.1:${port}`;
|
|
});
|
|
|
|
beforeEach(() => {
|
|
rmSync(join(projectRoot, '.workflow'), { recursive: true, force: true });
|
|
});
|
|
|
|
after(async () => {
|
|
mock.restoreAll();
|
|
if (server) {
|
|
await new Promise<void>((resolve) => server!.close(() => resolve()));
|
|
server = null;
|
|
}
|
|
if (projectRoot) {
|
|
rmSync(projectRoot, { recursive: true, force: true });
|
|
projectRoot = '';
|
|
}
|
|
});
|
|
|
|
it('GET /api/issues returns empty issues list with metadata', async () => {
|
|
const res = await requestJson(baseUrl, 'GET', '/api/issues');
|
|
assert.equal(res.status, 200);
|
|
assert.ok(res.json);
|
|
assert.equal(Array.isArray(res.json.issues), true);
|
|
assert.equal(res.json.issues.length, 0);
|
|
assert.equal(res.json._metadata.storage, 'jsonl');
|
|
});
|
|
|
|
it('POST /api/issues creates a new issue and writes JSONL', async () => {
|
|
const issueId = 'ISS-IR-1';
|
|
const res = await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Issue routes test' });
|
|
assert.equal(res.status, 200);
|
|
assert.equal(res.json?.success, true);
|
|
assert.equal(res.json.issue.id, issueId);
|
|
|
|
const issuesPath = join(projectRoot, '.workflow', 'issues', 'issues.jsonl');
|
|
const lines = readJsonl(issuesPath);
|
|
assert.equal(lines.length, 1);
|
|
assert.equal(lines[0].id, issueId);
|
|
assert.equal(typeof lines[0].created_at, 'string');
|
|
});
|
|
|
|
it('GET /api/issues returns enriched issue list with counts', async () => {
|
|
const issueId = 'ISS-IR-2';
|
|
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Counts' });
|
|
|
|
const res = await requestJson(baseUrl, 'GET', '/api/issues');
|
|
assert.equal(res.status, 200);
|
|
const issue = res.json.issues.find((i: any) => i.id === issueId);
|
|
assert.ok(issue);
|
|
assert.equal(issue.solution_count, 0);
|
|
assert.equal(issue.task_count, 0);
|
|
});
|
|
|
|
it('GET /api/issues/:id returns issue detail with solutions/tasks arrays', async () => {
|
|
const issueId = 'ISS-IR-3';
|
|
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Detail' });
|
|
|
|
const res = await requestJson(baseUrl, 'GET', `/api/issues/${encodeURIComponent(issueId)}`);
|
|
assert.equal(res.status, 200);
|
|
assert.equal(res.json.id, issueId);
|
|
assert.equal(Array.isArray(res.json.solutions), true);
|
|
assert.equal(Array.isArray(res.json.tasks), true);
|
|
assert.equal(res.json.solutions.length, 0);
|
|
assert.equal(res.json.tasks.length, 0);
|
|
});
|
|
|
|
it('POST /api/issues/:id/solutions appends a solution to solutions JSONL', async () => {
|
|
const issueId = 'ISS-IR-4';
|
|
const solutionId = 'SOL-ISS-IR-4-1';
|
|
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Solution add' });
|
|
|
|
const tasks = [{ id: 'T1', title: 'Do thing' }];
|
|
const res = await requestJson(baseUrl, 'POST', `/api/issues/${encodeURIComponent(issueId)}/solutions`, { id: solutionId, tasks });
|
|
assert.equal(res.status, 200);
|
|
assert.equal(res.json?.success, true);
|
|
assert.equal(res.json.solution.id, solutionId);
|
|
assert.equal(res.json.solution.is_bound, false);
|
|
|
|
const solutionsPath = join(projectRoot, '.workflow', 'issues', 'solutions', `${issueId}.jsonl`);
|
|
const lines = readJsonl(solutionsPath);
|
|
assert.equal(lines.length, 1);
|
|
assert.equal(lines[0].id, solutionId);
|
|
assert.equal(Array.isArray(lines[0].tasks), true);
|
|
});
|
|
|
|
it('PATCH /api/issues/:id binds solution and updates planned status', async () => {
|
|
const issueId = 'ISS-IR-5';
|
|
const solutionId = 'SOL-ISS-IR-5-1';
|
|
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Bind' });
|
|
await requestJson(baseUrl, 'POST', `/api/issues/${encodeURIComponent(issueId)}/solutions`, { id: solutionId, tasks: [{ id: 'T1' }] });
|
|
|
|
const res = await requestJson(baseUrl, 'PATCH', `/api/issues/${encodeURIComponent(issueId)}`, { bound_solution_id: solutionId });
|
|
assert.equal(res.status, 200);
|
|
assert.equal(res.json?.success, true);
|
|
assert.ok(res.json.updated.includes('bound_solution_id'));
|
|
|
|
const detail = await requestJson(baseUrl, 'GET', `/api/issues/${encodeURIComponent(issueId)}`);
|
|
assert.equal(detail.status, 200);
|
|
assert.equal(detail.json.bound_solution_id, solutionId);
|
|
assert.equal(detail.json.status, 'planned');
|
|
assert.ok(detail.json.planned_at);
|
|
assert.equal(detail.json.tasks.length, 1);
|
|
|
|
const solutionsPath = join(projectRoot, '.workflow', 'issues', 'solutions', `${issueId}.jsonl`);
|
|
const lines = readJsonl(solutionsPath);
|
|
assert.equal(lines.length, 1);
|
|
assert.equal(lines[0].is_bound, true);
|
|
});
|
|
|
|
it('PATCH /api/issues/:id/tasks/:taskId updates bound solution task fields', async () => {
|
|
const issueId = 'ISS-IR-6';
|
|
const solutionId = 'SOL-ISS-IR-6-1';
|
|
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Task update' });
|
|
await requestJson(baseUrl, 'POST', `/api/issues/${encodeURIComponent(issueId)}/solutions`, { id: solutionId, tasks: [{ id: 'T1', status: 'pending' }] });
|
|
await requestJson(baseUrl, 'PATCH', `/api/issues/${encodeURIComponent(issueId)}`, { bound_solution_id: solutionId });
|
|
|
|
const res = await requestJson(baseUrl, 'PATCH', `/api/issues/${encodeURIComponent(issueId)}/tasks/T1`, { status: 'completed', result: { ok: true } });
|
|
assert.equal(res.status, 200);
|
|
assert.equal(res.json?.success, true);
|
|
assert.ok(res.json.updated.includes('status'));
|
|
assert.ok(res.json.updated.includes('result'));
|
|
|
|
const solutionsPath = join(projectRoot, '.workflow', 'issues', 'solutions', `${issueId}.jsonl`);
|
|
const lines = readJsonl(solutionsPath);
|
|
const task = lines[0].tasks.find((t: any) => t.id === 'T1');
|
|
assert.equal(task.status, 'completed');
|
|
assert.deepEqual(task.result, { ok: true });
|
|
assert.ok(task.updated_at);
|
|
});
|
|
|
|
it('DELETE /api/issues/:id removes issue and deletes solutions JSONL', async () => {
|
|
const issueId = 'ISS-IR-7';
|
|
const solutionId = 'SOL-ISS-IR-7-1';
|
|
await requestJson(baseUrl, 'POST', '/api/issues', { id: issueId, title: 'Delete me' });
|
|
await requestJson(baseUrl, 'POST', `/api/issues/${encodeURIComponent(issueId)}/solutions`, { id: solutionId, tasks: [{ id: 'T1' }] });
|
|
|
|
const res = await requestJson(baseUrl, 'DELETE', `/api/issues/${encodeURIComponent(issueId)}`);
|
|
assert.equal(res.status, 200);
|
|
assert.equal(res.json?.success, true);
|
|
|
|
const issuesPath = join(projectRoot, '.workflow', 'issues', 'issues.jsonl');
|
|
assert.equal(readJsonl(issuesPath).length, 0);
|
|
|
|
const solutionsPath = join(projectRoot, '.workflow', 'issues', 'solutions', `${issueId}.jsonl`);
|
|
assert.equal(existsSync(solutionsPath), false);
|
|
});
|
|
|
|
it('GET /api/queue returns grouped queue structure', async () => {
|
|
const res = await requestJson(baseUrl, 'GET', '/api/queue');
|
|
assert.equal(res.status, 200);
|
|
assert.ok(res.json);
|
|
assert.equal(Array.isArray(res.json.execution_groups), true);
|
|
assert.equal(typeof res.json.grouped_items, 'object');
|
|
});
|
|
|
|
it('POST /api/queue/merge merges source queue into target and skips duplicates', async () => {
|
|
const { writeFileSync, mkdirSync } = await import('fs');
|
|
const { join } = await import('path');
|
|
|
|
// Create queues directory
|
|
const queuesDir = join(projectRoot, '.workflow', 'issues', 'queues');
|
|
mkdirSync(queuesDir, { recursive: true });
|
|
|
|
// Create target queue
|
|
const targetQueue = {
|
|
id: 'QUE-TARGET',
|
|
status: 'active',
|
|
issue_ids: ['ISS-1'],
|
|
solutions: [
|
|
{ item_id: 'S-1', issue_id: 'ISS-1', solution_id: 'SOL-1', status: 'pending' }
|
|
],
|
|
conflicts: []
|
|
};
|
|
writeFileSync(join(queuesDir, 'QUE-TARGET.json'), JSON.stringify(targetQueue));
|
|
|
|
// Create source queue with one duplicate and one new item
|
|
const sourceQueue = {
|
|
id: 'QUE-SOURCE',
|
|
status: 'active',
|
|
issue_ids: ['ISS-1', 'ISS-2'],
|
|
solutions: [
|
|
{ item_id: 'S-1', issue_id: 'ISS-1', solution_id: 'SOL-1', status: 'pending' }, // Duplicate
|
|
{ item_id: 'S-2', issue_id: 'ISS-2', solution_id: 'SOL-2', status: 'pending' } // New
|
|
],
|
|
conflicts: []
|
|
};
|
|
writeFileSync(join(queuesDir, 'QUE-SOURCE.json'), JSON.stringify(sourceQueue));
|
|
|
|
// Create index
|
|
writeFileSync(join(queuesDir, 'index.json'), JSON.stringify({
|
|
active_queue_id: 'QUE-TARGET',
|
|
queues: [
|
|
{ id: 'QUE-TARGET', status: 'active' },
|
|
{ id: 'QUE-SOURCE', status: 'active' }
|
|
]
|
|
}));
|
|
|
|
// Merge
|
|
const res = await requestJson(baseUrl, 'POST', '/api/queue/merge', {
|
|
sourceQueueId: 'QUE-SOURCE',
|
|
targetQueueId: 'QUE-TARGET'
|
|
});
|
|
|
|
assert.equal(res.status, 200);
|
|
assert.equal(res.json.success, true);
|
|
assert.equal(res.json.mergedItemCount, 1); // Only new item merged
|
|
assert.equal(res.json.skippedDuplicates, 1); // Duplicate skipped
|
|
assert.equal(res.json.totalItems, 2); // Target now has 2 items
|
|
|
|
// Verify source queue is marked as merged
|
|
const sourceContent = JSON.parse(readFileSync(join(queuesDir, 'QUE-SOURCE.json'), 'utf8'));
|
|
assert.equal(sourceContent.status, 'merged');
|
|
assert.equal(sourceContent._metadata.merged_into, 'QUE-TARGET');
|
|
});
|
|
});
|
|
|