root
230 lines
11 KiB
TypeScript
230 lines
11 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { test } from "bun:test";
|
|
|
|
import { createTaskTreeDispatcher } from "./dispatcher.ts";
|
|
import { createTaskTreeHttpApp } from "./http.ts";
|
|
import { numberTaskTree } from "./outline-ref.ts";
|
|
import { projectTimelineTasks, TaskTreeStore } from "./store.ts";
|
|
|
|
test("HTTP command endpoint returns the same dispatcher DTO", async () => {
|
|
const group = {
|
|
id: "tg_contract",
|
|
name: "Contract",
|
|
description: "",
|
|
createdAt: "2026-07-16T00:00:00.000Z",
|
|
updatedAt: "2026-07-16T00:00:00.000Z"
|
|
};
|
|
const store = {
|
|
async listGroups() { return [group]; }
|
|
};
|
|
const dispatch = createTaskTreeDispatcher({ store: store as TaskTreeStore });
|
|
const expected = await dispatch({ operation: "group.list" });
|
|
const app = createTaskTreeHttpApp({ dispatch });
|
|
const response = await app.fetch(new Request("http://tasktree/v1/tasktree/commands", {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json" },
|
|
body: JSON.stringify({ operation: "group.list" })
|
|
}));
|
|
|
|
assert.equal(response.status, 200);
|
|
assert.deepEqual(await response.json(), expected);
|
|
});
|
|
|
|
test("outline references follow the current sibling order and tree depth", () => {
|
|
const task = (id: string, parentId: string | null, sortOrder: number): any => ({
|
|
id, groupId: "tg_1", parentId, kind: parentId ? "subtask" : "task", title: id, description: "", status: "pending",
|
|
startAt: null, dueAt: null, sortOrder, createdAt: `2026-07-21T00:00:0${sortOrder}.000Z`, updatedAt: "2026-07-21T00:00:00.000Z"
|
|
});
|
|
const numbered = numberTaskTree([
|
|
task("root-2", null, 5), task("child-2", "root-1", 4), task("grandchild", "child-1", 3),
|
|
task("root-1", null, 0), task("child-1", "root-1", 2)
|
|
]);
|
|
assert.deepEqual(Object.fromEntries(numbered.map((item) => [item.id, item.outlineRef])), {
|
|
"root-1": "R1", "child-1": "R1.1", grandchild: "R1.1.1", "child-2": "R1.2", "root-2": "R2"
|
|
});
|
|
const afterSiblingDeletion = numberTaskTree(numbered.filter((item) => item.id !== "child-2"));
|
|
assert.equal(afterSiblingDeletion.find((item) => item.id === "child-1")?.outlineRef, "R1.1");
|
|
});
|
|
|
|
test("dispatcher keeps batch validation atomic and completion gated", async () => {
|
|
let batchCalls = 0;
|
|
let createCalls = 0;
|
|
let updateCalls = 0;
|
|
const store = {
|
|
async createTask() { createCalls += 1; return null; },
|
|
async createTasks() { batchCalls += 1; return []; },
|
|
async updateTask() { updateCalls += 1; return null; },
|
|
async deleteTask() { return false; }
|
|
};
|
|
const dispatch = createTaskTreeDispatcher({ store: store as TaskTreeStore });
|
|
|
|
const batch = await dispatch({ operation: "task.create-batch", groupId: "tg_1", titles: ["valid", "invalid\nline"] });
|
|
assert.equal(batch.ok, false);
|
|
assert.equal(batch.error?.code, "invalid_title");
|
|
assert.equal(batchCalls, 0);
|
|
|
|
const invalidRange = await dispatch({
|
|
operation: "task.create",
|
|
groupId: "tg_1",
|
|
title: "Invalid range",
|
|
startAt: "2026-07-19T00:00:00.000Z",
|
|
dueAt: "2026-07-18T00:00:00.000Z"
|
|
});
|
|
assert.equal(invalidRange.ok, false);
|
|
assert.equal(invalidRange.error?.code, "invalid_time_range");
|
|
assert.equal(createCalls, 0);
|
|
|
|
const bypass = await dispatch({ operation: "task.update", taskId: "tt_1", status: "completed" });
|
|
assert.equal(bypass.ok, false);
|
|
assert.equal(bypass.error?.code, "completion_command_required");
|
|
assert.equal(updateCalls, 0);
|
|
|
|
const missing = await dispatch({ operation: "task.delete", taskId: "tt_missing" });
|
|
assert.equal(missing.ok, false);
|
|
assert.equal(missing.error?.code, "task_not_found");
|
|
|
|
const workflow = await dispatch({ operation: "workflow.start", taskId: "tt_1" });
|
|
assert.equal(workflow.ok, false);
|
|
assert.equal(workflow.error?.code, "temporal_address_required");
|
|
});
|
|
|
|
test("timeline projects lifecycle timestamps and expands parents around descendants", () => {
|
|
const tasks = projectTimelineTasks([
|
|
{
|
|
id: "tt_root", groupId: "tg_1", parentId: null, kind: "task", title: "Root", description: "", status: "in_progress",
|
|
startAt: "2026-07-21T10:00:00.000Z", dueAt: "2026-07-21T11:00:00.000Z", sortOrder: 0,
|
|
createdAt: "2026-07-21T10:00:00.000Z", updatedAt: "2026-07-21T11:00:00.000Z"
|
|
},
|
|
{
|
|
id: "tt_child", groupId: "tg_1", parentId: "tt_root", kind: "subtask", title: "Child", description: "", status: "completed",
|
|
startAt: null, dueAt: null, sortOrder: 1,
|
|
createdAt: "2026-07-21T09:00:00.000Z", updatedAt: "2026-07-21T12:00:00.000Z"
|
|
},
|
|
{
|
|
id: "tt_grandchild", groupId: "tg_1", parentId: "tt_child", kind: "subsubtask", title: "Grandchild", description: "", status: "pending",
|
|
startAt: null, dueAt: "2026-07-21T15:00:00.000Z", sortOrder: 2,
|
|
createdAt: "2026-07-21T13:00:00.000Z", updatedAt: "2026-07-21T13:00:00.000Z"
|
|
}
|
|
], [{
|
|
id: "tr_1", taskId: "tt_child", title: "Execution", body: "done", status: "succeeded",
|
|
createdAt: "2026-07-21T14:00:00.000Z"
|
|
}]);
|
|
|
|
assert.deepEqual(tasks.map(({ id, startAt, dueAt }) => ({ id, startAt, dueAt })), [
|
|
{ id: "tt_root", startAt: "2026-07-21T09:00:00.000Z", dueAt: "2026-07-21T15:00:00.000Z" },
|
|
{ id: "tt_child", startAt: "2026-07-21T09:00:00.000Z", dueAt: "2026-07-21T15:00:00.000Z" },
|
|
{ id: "tt_grandchild", startAt: "2026-07-21T13:00:00.000Z", dueAt: "2026-07-21T15:00:00.000Z" }
|
|
]);
|
|
});
|
|
|
|
test("native PostgreSQL store exposes overview and three task levels", async () => {
|
|
const databaseUrl = process.env.TASKTREE_DATABASE_URL;
|
|
assert.ok(databaseUrl, "TASKTREE_DATABASE_URL is required for the TaskTree store integration test");
|
|
const store = new TaskTreeStore(databaseUrl);
|
|
const group = await store.createGroup(`TaskTree test ${Date.now()}`);
|
|
const otherGroup = await store.createGroup(`TaskTree cross-group test ${Date.now()}`);
|
|
try {
|
|
const task = await store.createTask({
|
|
groupId: group.id,
|
|
title: "Root task",
|
|
startAt: "2026-07-16T00:00:00.000Z",
|
|
dueAt: "2026-07-18T00:00:00.000Z"
|
|
});
|
|
const subtask = await store.createTask({ groupId: group.id, parentId: task.id, title: "Subtask" });
|
|
const subsubtask = await store.createTask({ groupId: group.id, parentId: subtask.id, title: "Subsubtask" });
|
|
const batch = await store.createTasks({ groupId: group.id, parentId: task.id, titles: ["Batch one", "Batch two"] });
|
|
assert.deepEqual(batch.map((item) => item.title), ["Batch one", "Batch two"]);
|
|
await store.createMilestone({ groupId: group.id, taskId: task.id, title: "Review", occursAt: "2026-07-17T00:00:00.000Z" });
|
|
await assert.rejects(
|
|
store.createMilestone({ groupId: otherGroup.id, taskId: task.id, title: "Wrong group", occursAt: "2026-07-17T00:00:00.000Z" }),
|
|
(error: any) => error?.code === "task_group_mismatch"
|
|
);
|
|
await assert.rejects(
|
|
store.createMilestone({ groupId: "tg_missing", title: "Missing group", occursAt: "2026-07-17T00:00:00.000Z" }),
|
|
(error: any) => error?.code === "group_not_found"
|
|
);
|
|
await assert.rejects(
|
|
store.createMilestone({ groupId: group.id, taskId: "tt_missing", title: "Missing task", occursAt: "2026-07-17T00:00:00.000Z" }),
|
|
(error: any) => error?.code === "task_not_found"
|
|
);
|
|
await assert.rejects(
|
|
store.createTask({
|
|
groupId: group.id,
|
|
title: "Invalid range",
|
|
startAt: "2026-07-19T00:00:00.000Z",
|
|
dueAt: "2026-07-18T00:00:00.000Z"
|
|
}),
|
|
(error: any) => error?.code === "invalid_time_range"
|
|
);
|
|
await assert.rejects(
|
|
store.updateTask(task.id, { dueAt: "2026-07-15T00:00:00.000Z" }),
|
|
(error: any) => error?.code === "invalid_time_range"
|
|
);
|
|
assert.equal((await store.getTask(task.id))?.dueAt, "2026-07-18T00:00:00.000Z");
|
|
await assert.rejects(
|
|
store.completeTask(task.id),
|
|
(error: any) => error?.code === "execution_report_required"
|
|
);
|
|
const firstReport = await store.writeReport({ taskId: task.id, title: "Execution", body: "passed" });
|
|
assert.equal(firstReport.task.status, "completed");
|
|
assert.equal(firstReport.taskMutation, true);
|
|
const repeatedReport = await store.writeReport({ taskId: task.id, title: "Execution", body: "passed" });
|
|
assert.equal(repeatedReport.taskMutation, false);
|
|
await store.updateTask(task.id, { status: "blocked" });
|
|
const correctedReport = await store.writeReport({ taskId: task.id, title: "Execution", body: "passed" });
|
|
assert.equal(correctedReport.mutation, false);
|
|
assert.equal(correctedReport.taskMutation, true);
|
|
assert.equal(correctedReport.task.status, "completed");
|
|
const changedReport = await store.writeReport({ taskId: task.id, title: "Execution", body: "passed with evidence" });
|
|
assert.equal(firstReport.mutation, true);
|
|
assert.equal(repeatedReport.mutation, false);
|
|
assert.equal(changedReport.mutation, true);
|
|
assert.equal(changedReport.taskMutation, false);
|
|
assert.equal(firstReport.report.id, repeatedReport.report.id);
|
|
assert.equal(firstReport.report.id, changedReport.report.id);
|
|
assert.equal((await store.completeTask(task.id))?.status, "completed");
|
|
|
|
await assert.rejects(
|
|
store.createTask({ groupId: group.id, parentId: subsubtask.id, title: "Unsupported fourth level" }),
|
|
(error: any) => error?.code === "maximum_depth_exceeded"
|
|
);
|
|
const countBeforeRejectedBatch = (await store.listTasks(group.id)).length;
|
|
await assert.rejects(
|
|
store.createTasks({ groupId: group.id, parentId: subsubtask.id, titles: ["Unsupported one", "Unsupported two"] }),
|
|
(error: any) => error?.code === "maximum_depth_exceeded"
|
|
);
|
|
assert.equal((await store.listTasks(group.id)).length, countBeforeRejectedBatch);
|
|
const timeline = await store.timeline(group.id);
|
|
assert.equal(timeline?.tasks.length, 5);
|
|
assert.equal(timeline?.tasks[0]?.kind, "task");
|
|
assert.equal(timeline?.tasks[1]?.kind, "subtask");
|
|
assert.equal(timeline?.tasks[2]?.kind, "subsubtask");
|
|
assert.equal(timeline?.milestones.length, 1);
|
|
assert.equal(timeline?.reports.length, 1);
|
|
assert.ok(timeline?.tasks.every((item) => item.startAt !== null && item.dueAt !== null));
|
|
const timelineStart = Math.min(...timeline!.tasks.map((item) => new Date(item.startAt!).valueOf()));
|
|
const timelineDue = Math.max(...timeline!.tasks.map((item) => new Date(item.dueAt!).valueOf()));
|
|
assert.equal(timeline?.tasks[0]?.startAt, new Date(timelineStart).toISOString());
|
|
assert.equal(timeline?.tasks[0]?.dueAt, new Date(timelineDue).toISOString());
|
|
assert.equal((await store.getTask(subtask.id))?.title, "Subtask");
|
|
assert.equal((await store.listReports(task.id)).length, 1);
|
|
assert.equal((await store.getReport(firstReport.report.id))?.body, "passed with evidence");
|
|
const stats = await store.groupStats(group.id);
|
|
assert.equal(stats.total, 5);
|
|
assert.equal(stats.completed, 1);
|
|
assert.equal(stats.reports, 1);
|
|
const overview = (await store.groupOverview()).find((item) => item.group.id === group.id);
|
|
assert.equal(overview?.taskCount, 1);
|
|
assert.equal(overview?.subtaskCount, 3);
|
|
assert.equal(overview?.subsubtaskCount, 1);
|
|
assert.equal(overview?.completedCount, 1);
|
|
assert.equal(overview?.reportCount, 1);
|
|
assert.equal(overview?.startAt, new Date(timelineStart).toISOString());
|
|
assert.equal(overview?.dueAt, new Date(timelineDue).toISOString());
|
|
} finally {
|
|
await store.deleteGroup(otherGroup.id);
|
|
await store.deleteGroup(group.id);
|
|
await store.close();
|
|
}
|
|
});
|