test(FN-1084): expand mission workflow automated test coverage
- Add dashboard mission e2e coverage for autopilot endpoint flows and mission summary behavior - Add comprehensive mission interview tests for planning, step progression, and output handling - Extend CLI mission command tests for add/link workflows and argument validation paths - Strengthen engine mission scheduler assertions around activation sequencing and state transitions - Add core mission store tests to validate mission persistence and related edge cases
This commit is contained in:
gsxdsm
@@ -38,6 +38,10 @@ const {
|
||||
runMissionShow,
|
||||
runMissionDelete,
|
||||
runMissionActivateSlice,
|
||||
runMilestoneAdd,
|
||||
runSliceAdd,
|
||||
runFeatureAdd,
|
||||
runFeatureLinkTask,
|
||||
} = await import("./mission.js");
|
||||
|
||||
// Helper to mock console output
|
||||
@@ -103,12 +107,44 @@ function createMockMissionStore(overrides = {}) {
|
||||
title: "Test Mission",
|
||||
status: "active",
|
||||
}),
|
||||
deleteMission: vi.fn(),
|
||||
addMilestone: vi.fn().mockReturnValue({
|
||||
id: "MS-001",
|
||||
title: "New Milestone",
|
||||
status: "planning",
|
||||
}),
|
||||
getMilestone: vi.fn().mockReturnValue({
|
||||
id: "MS-001",
|
||||
title: "Milestone 1",
|
||||
status: "active",
|
||||
}),
|
||||
addSlice: vi.fn().mockReturnValue({
|
||||
id: "SL-001",
|
||||
title: "New Slice",
|
||||
status: "pending",
|
||||
}),
|
||||
getSlice: vi.fn().mockReturnValue({
|
||||
id: "SL-001",
|
||||
title: "Test Slice",
|
||||
status: "pending",
|
||||
}),
|
||||
addFeature: vi.fn().mockReturnValue({
|
||||
id: "F-001",
|
||||
title: "New Feature",
|
||||
status: "defined",
|
||||
acceptanceCriteria: undefined,
|
||||
}),
|
||||
getFeature: vi.fn().mockReturnValue({
|
||||
id: "F-001",
|
||||
title: "Feature 1",
|
||||
status: "defined",
|
||||
}),
|
||||
linkFeatureToTask: vi.fn().mockImplementation((featureId: string, taskId: string) => ({
|
||||
id: featureId,
|
||||
title: "Feature 1",
|
||||
status: "triaged",
|
||||
taskId,
|
||||
})),
|
||||
deleteMission: vi.fn(),
|
||||
activateSlice: vi.fn().mockReturnValue({
|
||||
id: "SL-001",
|
||||
title: "Test Slice",
|
||||
@@ -119,6 +155,17 @@ function createMockMissionStore(overrides = {}) {
|
||||
};
|
||||
}
|
||||
|
||||
function mockResolvedProjectStore(
|
||||
missionStore: ReturnType<typeof createMockMissionStore>,
|
||||
overrides: Partial<{ getTask: ReturnType<typeof vi.fn> }> = {},
|
||||
) {
|
||||
vi.mocked(getStore).mockResolvedValue({
|
||||
getMissionStore: () => missionStore,
|
||||
getTask: vi.fn().mockResolvedValue({ id: "FN-001" }),
|
||||
...overrides,
|
||||
} as any);
|
||||
}
|
||||
|
||||
describe("mission commands", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
@@ -512,4 +559,228 @@ describe("mission commands", () => {
|
||||
mockError.mockRestore();
|
||||
});
|
||||
});
|
||||
|
||||
describe("runMilestoneAdd", () => {
|
||||
it("adds a milestone successfully", async () => {
|
||||
const mockMissionStore = createMockMissionStore({
|
||||
addMilestone: vi.fn().mockReturnValue({ id: "MS-010", title: "M2", status: "planning" }),
|
||||
});
|
||||
mockResolvedProjectStore(mockMissionStore);
|
||||
|
||||
const consoleCapture = captureConsole();
|
||||
try {
|
||||
await runMilestoneAdd("M-001", "M2", "Details");
|
||||
expect(mockMissionStore.addMilestone).toHaveBeenCalledWith("M-001", {
|
||||
title: "M2",
|
||||
description: "Details",
|
||||
});
|
||||
expect(consoleCapture.logs.some((line) => line.includes("Added MS-010"))).toBe(true);
|
||||
} finally {
|
||||
consoleCapture.restore();
|
||||
}
|
||||
});
|
||||
|
||||
it("exits when mission does not exist", async () => {
|
||||
const mockMissionStore = createMockMissionStore({ getMission: vi.fn().mockReturnValue(undefined) });
|
||||
mockResolvedProjectStore(mockMissionStore);
|
||||
|
||||
const mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
|
||||
throw new Error("process.exit");
|
||||
});
|
||||
const mockError = vi.spyOn(console, "error").mockImplementation(() => {});
|
||||
|
||||
await expect(runMilestoneAdd("M-404", "M2")).rejects.toThrow("process.exit");
|
||||
expect(mockError).toHaveBeenCalledWith("✗ Mission M-404 not found");
|
||||
expect(mockExit).toHaveBeenCalledWith(1);
|
||||
|
||||
mockExit.mockRestore();
|
||||
mockError.mockRestore();
|
||||
});
|
||||
|
||||
it("prompts interactively when title is omitted", async () => {
|
||||
const mockMissionStore = createMockMissionStore();
|
||||
mockResolvedProjectStore(mockMissionStore);
|
||||
|
||||
const mockRl = {
|
||||
question: vi.fn().mockResolvedValueOnce("Interactive milestone").mockResolvedValueOnce("Interactive desc"),
|
||||
close: vi.fn(),
|
||||
};
|
||||
vi.mocked(createInterface).mockReturnValue(mockRl as any);
|
||||
|
||||
await runMilestoneAdd("M-001");
|
||||
|
||||
expect(mockRl.question).toHaveBeenCalledWith("Milestone title: ");
|
||||
expect(mockMissionStore.addMilestone).toHaveBeenCalledWith("M-001", {
|
||||
title: "Interactive milestone",
|
||||
description: "Interactive desc",
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("runSliceAdd", () => {
|
||||
it("adds a slice successfully", async () => {
|
||||
const mockMissionStore = createMockMissionStore({
|
||||
addSlice: vi.fn().mockReturnValue({ id: "SL-010", title: "Slice", status: "pending" }),
|
||||
});
|
||||
mockResolvedProjectStore(mockMissionStore);
|
||||
|
||||
const consoleCapture = captureConsole();
|
||||
try {
|
||||
await runSliceAdd("MS-001", "Slice", "Slice details");
|
||||
expect(mockMissionStore.addSlice).toHaveBeenCalledWith("MS-001", {
|
||||
title: "Slice",
|
||||
description: "Slice details",
|
||||
});
|
||||
expect(consoleCapture.logs.some((line) => line.includes("Added SL-010"))).toBe(true);
|
||||
} finally {
|
||||
consoleCapture.restore();
|
||||
}
|
||||
});
|
||||
|
||||
it("exits when milestone does not exist", async () => {
|
||||
const mockMissionStore = createMockMissionStore({ getMilestone: vi.fn().mockReturnValue(undefined) });
|
||||
mockResolvedProjectStore(mockMissionStore);
|
||||
|
||||
const mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
|
||||
throw new Error("process.exit");
|
||||
});
|
||||
const mockError = vi.spyOn(console, "error").mockImplementation(() => {});
|
||||
|
||||
await expect(runSliceAdd("MS-404", "Slice")).rejects.toThrow("process.exit");
|
||||
expect(mockError).toHaveBeenCalledWith("✗ Milestone MS-404 not found");
|
||||
expect(mockExit).toHaveBeenCalledWith(1);
|
||||
|
||||
mockExit.mockRestore();
|
||||
mockError.mockRestore();
|
||||
});
|
||||
|
||||
it("prompts interactively when title is omitted", async () => {
|
||||
const mockMissionStore = createMockMissionStore();
|
||||
mockResolvedProjectStore(mockMissionStore);
|
||||
|
||||
const mockRl = {
|
||||
question: vi.fn().mockResolvedValueOnce("Interactive slice").mockResolvedValueOnce("Interactive slice desc"),
|
||||
close: vi.fn(),
|
||||
};
|
||||
vi.mocked(createInterface).mockReturnValue(mockRl as any);
|
||||
|
||||
await runSliceAdd("MS-001");
|
||||
|
||||
expect(mockRl.question).toHaveBeenCalledWith("Slice title: ");
|
||||
expect(mockMissionStore.addSlice).toHaveBeenCalledWith("MS-001", {
|
||||
title: "Interactive slice",
|
||||
description: "Interactive slice desc",
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("runFeatureAdd", () => {
|
||||
it("adds a feature with acceptance criteria", async () => {
|
||||
const mockMissionStore = createMockMissionStore({
|
||||
addFeature: vi.fn().mockReturnValue({
|
||||
id: "F-010",
|
||||
title: "Feature",
|
||||
status: "defined",
|
||||
acceptanceCriteria: "Ship works",
|
||||
}),
|
||||
});
|
||||
mockResolvedProjectStore(mockMissionStore);
|
||||
|
||||
await runFeatureAdd("SL-001", "Feature", "Feature details", "Ship works");
|
||||
|
||||
expect(mockMissionStore.addFeature).toHaveBeenCalledWith("SL-001", {
|
||||
title: "Feature",
|
||||
description: "Feature details",
|
||||
acceptanceCriteria: "Ship works",
|
||||
});
|
||||
});
|
||||
|
||||
it("exits when slice does not exist", async () => {
|
||||
const mockMissionStore = createMockMissionStore({ getSlice: vi.fn().mockReturnValue(undefined) });
|
||||
mockResolvedProjectStore(mockMissionStore);
|
||||
|
||||
const mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
|
||||
throw new Error("process.exit");
|
||||
});
|
||||
const mockError = vi.spyOn(console, "error").mockImplementation(() => {});
|
||||
|
||||
await expect(runFeatureAdd("SL-404", "Feature")).rejects.toThrow("process.exit");
|
||||
expect(mockError).toHaveBeenCalledWith("✗ Slice SL-404 not found");
|
||||
expect(mockExit).toHaveBeenCalledWith(1);
|
||||
|
||||
mockExit.mockRestore();
|
||||
mockError.mockRestore();
|
||||
});
|
||||
|
||||
it("prompts interactively when title is omitted", async () => {
|
||||
const mockMissionStore = createMockMissionStore();
|
||||
mockResolvedProjectStore(mockMissionStore);
|
||||
|
||||
const mockRl = {
|
||||
question: vi.fn()
|
||||
.mockResolvedValueOnce("Interactive feature")
|
||||
.mockResolvedValueOnce("Interactive feature desc")
|
||||
.mockResolvedValueOnce("Interactive acceptance"),
|
||||
close: vi.fn(),
|
||||
};
|
||||
vi.mocked(createInterface).mockReturnValue(mockRl as any);
|
||||
|
||||
await runFeatureAdd("SL-001");
|
||||
|
||||
expect(mockRl.question).toHaveBeenCalledWith("Feature title: ");
|
||||
expect(mockMissionStore.addFeature).toHaveBeenCalledWith("SL-001", {
|
||||
title: "Interactive feature",
|
||||
description: "Interactive feature desc",
|
||||
acceptanceCriteria: "Interactive acceptance",
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("runFeatureLinkTask", () => {
|
||||
it("links a feature to a task", async () => {
|
||||
const mockMissionStore = createMockMissionStore();
|
||||
const getTask = vi.fn().mockResolvedValue({ id: "FN-001" });
|
||||
mockResolvedProjectStore(mockMissionStore, { getTask });
|
||||
|
||||
await runFeatureLinkTask("F-001", "FN-001");
|
||||
|
||||
expect(getTask).toHaveBeenCalledWith("FN-001");
|
||||
expect(mockMissionStore.linkFeatureToTask).toHaveBeenCalledWith("F-001", "FN-001");
|
||||
});
|
||||
|
||||
it("exits when feature does not exist", async () => {
|
||||
const mockMissionStore = createMockMissionStore({ getFeature: vi.fn().mockReturnValue(undefined) });
|
||||
mockResolvedProjectStore(mockMissionStore);
|
||||
|
||||
const mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
|
||||
throw new Error("process.exit");
|
||||
});
|
||||
const mockError = vi.spyOn(console, "error").mockImplementation(() => {});
|
||||
|
||||
await expect(runFeatureLinkTask("F-404", "FN-001")).rejects.toThrow("process.exit");
|
||||
expect(mockError).toHaveBeenCalledWith("✗ Feature F-404 not found");
|
||||
expect(mockExit).toHaveBeenCalledWith(1);
|
||||
|
||||
mockExit.mockRestore();
|
||||
mockError.mockRestore();
|
||||
});
|
||||
|
||||
it("exits when task does not exist", async () => {
|
||||
const mockMissionStore = createMockMissionStore();
|
||||
const getTask = vi.fn().mockRejectedValue(new Error("missing"));
|
||||
mockResolvedProjectStore(mockMissionStore, { getTask });
|
||||
|
||||
const mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
|
||||
throw new Error("process.exit");
|
||||
});
|
||||
const mockError = vi.spyOn(console, "error").mockImplementation(() => {});
|
||||
|
||||
await expect(runFeatureLinkTask("F-001", "FN-404")).rejects.toThrow("process.exit");
|
||||
expect(mockError).toHaveBeenCalledWith("✗ Task FN-404 not found");
|
||||
expect(mockExit).toHaveBeenCalledWith(1);
|
||||
|
||||
mockExit.mockRestore();
|
||||
mockError.mockRestore();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -169,6 +169,117 @@ describe("MissionStore", () => {
|
||||
});
|
||||
});
|
||||
|
||||
// ── Mission Summary & Slice Discovery Tests ───────────────────────────
|
||||
|
||||
describe("Mission summary helpers", () => {
|
||||
it("getMissionSummary returns zeros for an empty mission", () => {
|
||||
const mission = store.createMission({ title: "Empty" });
|
||||
|
||||
const summary = store.getMissionSummary(mission.id);
|
||||
|
||||
expect(summary).toEqual({
|
||||
totalMilestones: 0,
|
||||
completedMilestones: 0,
|
||||
totalFeatures: 0,
|
||||
completedFeatures: 0,
|
||||
progressPercent: 0,
|
||||
});
|
||||
});
|
||||
|
||||
it("getMissionSummary falls back to milestone progress when no features exist", () => {
|
||||
const mission = store.createMission({ title: "Milestones only" });
|
||||
const m1 = store.addMilestone(mission.id, { title: "M1" });
|
||||
store.addMilestone(mission.id, { title: "M2" });
|
||||
store.updateMilestone(m1.id, { status: "complete" });
|
||||
|
||||
const summary = store.getMissionSummary(mission.id);
|
||||
|
||||
expect(summary.totalMilestones).toBe(2);
|
||||
expect(summary.completedMilestones).toBe(1);
|
||||
expect(summary.totalFeatures).toBe(0);
|
||||
expect(summary.completedFeatures).toBe(0);
|
||||
expect(summary.progressPercent).toBe(50);
|
||||
});
|
||||
|
||||
it("getMissionSummary reports partial feature completion", () => {
|
||||
const mission = store.createMission({ title: "Partial features" });
|
||||
const milestone = store.addMilestone(mission.id, { title: "M1" });
|
||||
const slice = store.addSlice(milestone.id, { title: "Slice" });
|
||||
const f1 = store.addFeature(slice.id, { title: "F1" });
|
||||
const f2 = store.addFeature(slice.id, { title: "F2" });
|
||||
store.addFeature(slice.id, { title: "F3" });
|
||||
|
||||
store.updateFeature(f1.id, { status: "done" });
|
||||
store.updateFeature(f2.id, { status: "done" });
|
||||
|
||||
const summary = store.getMissionSummary(mission.id);
|
||||
|
||||
expect(summary.totalFeatures).toBe(3);
|
||||
expect(summary.completedFeatures).toBe(2);
|
||||
expect(summary.progressPercent).toBe(67);
|
||||
});
|
||||
|
||||
it("getMissionSummary reports 100% when all features are done", () => {
|
||||
const mission = store.createMission({ title: "All done" });
|
||||
const milestone = store.addMilestone(mission.id, { title: "M1" });
|
||||
const slice = store.addSlice(milestone.id, { title: "Slice" });
|
||||
const f1 = store.addFeature(slice.id, { title: "F1" });
|
||||
const f2 = store.addFeature(slice.id, { title: "F2" });
|
||||
|
||||
store.updateFeature(f1.id, { status: "done" });
|
||||
store.updateFeature(f2.id, { status: "done" });
|
||||
|
||||
const summary = store.getMissionSummary(mission.id);
|
||||
expect(summary.progressPercent).toBe(100);
|
||||
});
|
||||
|
||||
it("getMissionSummary rounds progress percent accurately", () => {
|
||||
const mission = store.createMission({ title: "Rounding" });
|
||||
const milestone = store.addMilestone(mission.id, { title: "M1" });
|
||||
const slice = store.addSlice(milestone.id, { title: "Slice" });
|
||||
const f1 = store.addFeature(slice.id, { title: "F1" });
|
||||
store.addFeature(slice.id, { title: "F2" });
|
||||
store.addFeature(slice.id, { title: "F3" });
|
||||
|
||||
store.updateFeature(f1.id, { status: "done" });
|
||||
|
||||
const summary = store.getMissionSummary(mission.id);
|
||||
expect(summary.progressPercent).toBe(33);
|
||||
});
|
||||
|
||||
it("findNextPendingSlice skips completed slices in earlier milestones", () => {
|
||||
const mission = store.createMission({ title: "Next pending" });
|
||||
const m1 = store.addMilestone(mission.id, { title: "M1" });
|
||||
const m2 = store.addMilestone(mission.id, { title: "M2" });
|
||||
const completed = store.addSlice(m1.id, { title: "Done slice" });
|
||||
const pending = store.addSlice(m2.id, { title: "Pending slice" });
|
||||
|
||||
store.updateSlice(completed.id, { status: "complete" });
|
||||
|
||||
const next = store.findNextPendingSlice(mission.id);
|
||||
expect(next?.id).toBe(pending.id);
|
||||
});
|
||||
|
||||
it("findNextPendingSlice returns undefined when no pending slices exist", () => {
|
||||
const mission = store.createMission({ title: "No pending" });
|
||||
const milestone = store.addMilestone(mission.id, { title: "M1" });
|
||||
const slice = store.addSlice(milestone.id, { title: "Completed" });
|
||||
store.updateSlice(slice.id, { status: "complete" });
|
||||
|
||||
const next = store.findNextPendingSlice(mission.id);
|
||||
expect(next).toBeUndefined();
|
||||
});
|
||||
|
||||
it("findNextPendingSlice returns first pending slice in a single-milestone mission", () => {
|
||||
const mission = store.createMission({ title: "Single" });
|
||||
const milestone = store.addMilestone(mission.id, { title: "M1" });
|
||||
const pending = store.addSlice(milestone.id, { title: "Pending" });
|
||||
|
||||
const next = store.findNextPendingSlice(mission.id);
|
||||
expect(next?.id).toBe(pending.id);
|
||||
});
|
||||
});
|
||||
|
||||
// ── Milestone CRUD Tests ──────────────────────────────────────────────
|
||||
|
||||
describe("Milestone CRUD", () => {
|
||||
|
||||
@@ -287,8 +287,6 @@ function createMockMissionStore() {
|
||||
|
||||
// Mission status helpers for pause/stop
|
||||
computeMissionStatus: vi.fn(() => "active"),
|
||||
getMilestone: vi.fn((id: string) => milestones.get(id)),
|
||||
getMission: vi.fn((id: string) => missions.get(id)),
|
||||
|
||||
on: vi.fn(),
|
||||
off: vi.fn(),
|
||||
@@ -303,11 +301,28 @@ function createMockStore(): TaskStore {
|
||||
} as unknown as TaskStore;
|
||||
}
|
||||
|
||||
function buildApp() {
|
||||
function createMockMissionAutopilot() {
|
||||
return {
|
||||
watchMission: vi.fn(),
|
||||
unwatchMission: vi.fn(),
|
||||
isWatching: vi.fn().mockReturnValue(false),
|
||||
getAutopilotStatus: vi.fn().mockReturnValue({
|
||||
enabled: false,
|
||||
state: "inactive",
|
||||
watched: false,
|
||||
lastActivityAt: undefined,
|
||||
}),
|
||||
checkAndStartMission: vi.fn().mockResolvedValue(undefined),
|
||||
start: vi.fn(),
|
||||
stop: vi.fn(),
|
||||
};
|
||||
}
|
||||
|
||||
function buildApp(options?: { missionAutopilot?: ReturnType<typeof createMockMissionAutopilot> }) {
|
||||
const app = express();
|
||||
app.use(express.json());
|
||||
const store = createMockStore();
|
||||
app.use("/api/missions", createMissionRouter(store));
|
||||
app.use("/api/missions", createMissionRouter(store, options?.missionAutopilot));
|
||||
return { app, store, missionStore: store.getMissionStore() };
|
||||
}
|
||||
|
||||
@@ -1203,4 +1218,263 @@ describe("Mission API", () => {
|
||||
expect(res.status).toBe(400);
|
||||
});
|
||||
});
|
||||
|
||||
// ── Autopilot Endpoints ──────────────────────────────────────────────────
|
||||
|
||||
describe("autopilot endpoints", () => {
|
||||
describe("GET /api/missions/:missionId/autopilot", () => {
|
||||
it("returns autopilot status from service when provided", async () => {
|
||||
const missionAutopilot = createMockMissionAutopilot();
|
||||
const { app, missionStore } = buildApp({ missionAutopilot });
|
||||
const mission = missionStore.createMission({ title: "Autopilot Mission" });
|
||||
|
||||
missionAutopilot.getAutopilotStatus.mockReturnValue({
|
||||
enabled: true,
|
||||
state: "watching",
|
||||
watched: true,
|
||||
lastActivityAt: "2026-04-07T12:00:00.000Z",
|
||||
});
|
||||
|
||||
const res = await get(app, `/api/missions/${mission.id}/autopilot`);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body).toEqual({
|
||||
enabled: true,
|
||||
state: "watching",
|
||||
watched: true,
|
||||
lastActivityAt: "2026-04-07T12:00:00.000Z",
|
||||
});
|
||||
expect(missionAutopilot.getAutopilotStatus).toHaveBeenCalledWith(mission.id);
|
||||
});
|
||||
|
||||
it("returns fallback mission status when autopilot service is unavailable", async () => {
|
||||
const { app, missionStore } = buildApp();
|
||||
const mission = missionStore.createMission({ title: "Fallback Mission" });
|
||||
missionStore.updateMission(mission.id, {
|
||||
autopilotEnabled: true,
|
||||
autopilotState: "watching",
|
||||
lastAutopilotActivityAt: "2026-04-07T13:00:00.000Z",
|
||||
});
|
||||
|
||||
const res = await get(app, `/api/missions/${mission.id}/autopilot`);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body).toEqual({
|
||||
enabled: true,
|
||||
state: "watching",
|
||||
watched: false,
|
||||
lastActivityAt: "2026-04-07T13:00:00.000Z",
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("PATCH /api/missions/:missionId/autopilot", () => {
|
||||
it("enables autopilot and starts planning missions", async () => {
|
||||
const missionAutopilot = createMockMissionAutopilot();
|
||||
const { app, missionStore } = buildApp({ missionAutopilot });
|
||||
const mission = missionStore.createMission({ title: "Enable Autopilot" });
|
||||
|
||||
missionAutopilot.getAutopilotStatus.mockReturnValue({
|
||||
enabled: true,
|
||||
state: "watching",
|
||||
watched: true,
|
||||
lastActivityAt: undefined,
|
||||
});
|
||||
|
||||
const res = await request(
|
||||
app,
|
||||
"PATCH",
|
||||
`/api/missions/${mission.id}/autopilot`,
|
||||
JSON.stringify({ enabled: true }),
|
||||
{ "content-type": "application/json" },
|
||||
);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(missionAutopilot.watchMission).toHaveBeenCalledWith(mission.id);
|
||||
expect(missionAutopilot.checkAndStartMission).toHaveBeenCalledWith(mission.id);
|
||||
expect(missionStore.updateMission).toHaveBeenCalledWith(mission.id, { autopilotEnabled: true });
|
||||
});
|
||||
|
||||
it("disables autopilot and unwatches mission", async () => {
|
||||
const missionAutopilot = createMockMissionAutopilot();
|
||||
const { app, missionStore } = buildApp({ missionAutopilot });
|
||||
const mission = missionStore.createMission({ title: "Disable Autopilot" });
|
||||
|
||||
missionAutopilot.getAutopilotStatus.mockReturnValue({
|
||||
enabled: false,
|
||||
state: "inactive",
|
||||
watched: false,
|
||||
lastActivityAt: undefined,
|
||||
});
|
||||
|
||||
const res = await request(
|
||||
app,
|
||||
"PATCH",
|
||||
`/api/missions/${mission.id}/autopilot`,
|
||||
JSON.stringify({ enabled: false }),
|
||||
{ "content-type": "application/json" },
|
||||
);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(missionAutopilot.unwatchMission).toHaveBeenCalledWith(mission.id);
|
||||
expect(missionAutopilot.checkAndStartMission).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("returns 400 when enabled is missing or not boolean", async () => {
|
||||
const { app, missionStore } = buildApp();
|
||||
const mission = missionStore.createMission({ title: "Invalid Payload" });
|
||||
|
||||
const missingRes = await request(
|
||||
app,
|
||||
"PATCH",
|
||||
`/api/missions/${mission.id}/autopilot`,
|
||||
JSON.stringify({}),
|
||||
{ "content-type": "application/json" },
|
||||
);
|
||||
expect(missingRes.status).toBe(400);
|
||||
|
||||
const invalidRes = await request(
|
||||
app,
|
||||
"PATCH",
|
||||
`/api/missions/${mission.id}/autopilot`,
|
||||
JSON.stringify({ enabled: "yes" }),
|
||||
{ "content-type": "application/json" },
|
||||
);
|
||||
expect(invalidRes.status).toBe(400);
|
||||
});
|
||||
|
||||
it("returns fallback response without autopilot service", async () => {
|
||||
const { app, missionStore } = buildApp();
|
||||
const mission = missionStore.createMission({ title: "No Autopilot Service" });
|
||||
|
||||
const res = await request(
|
||||
app,
|
||||
"PATCH",
|
||||
`/api/missions/${mission.id}/autopilot`,
|
||||
JSON.stringify({ enabled: true }),
|
||||
{ "content-type": "application/json" },
|
||||
);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body).toEqual({
|
||||
enabled: true,
|
||||
state: "inactive",
|
||||
watched: false,
|
||||
lastActivityAt: undefined,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("POST /api/missions/:missionId/autopilot/start", () => {
|
||||
it("starts watching when autopilot is enabled", async () => {
|
||||
const missionAutopilot = createMockMissionAutopilot();
|
||||
const { app, missionStore } = buildApp({ missionAutopilot });
|
||||
const mission = missionStore.createMission({ title: "Start Autopilot" });
|
||||
missionStore.updateMission(mission.id, { autopilotEnabled: true });
|
||||
|
||||
missionAutopilot.getAutopilotStatus.mockReturnValue({
|
||||
enabled: true,
|
||||
state: "watching",
|
||||
watched: true,
|
||||
lastActivityAt: undefined,
|
||||
});
|
||||
|
||||
const res = await request(
|
||||
app,
|
||||
"POST",
|
||||
`/api/missions/${mission.id}/autopilot/start`,
|
||||
JSON.stringify({}),
|
||||
{ "content-type": "application/json" },
|
||||
);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(missionAutopilot.watchMission).toHaveBeenCalledWith(mission.id);
|
||||
expect(missionAutopilot.checkAndStartMission).toHaveBeenCalledWith(mission.id);
|
||||
});
|
||||
|
||||
it("returns 400 when mission autopilot is disabled", async () => {
|
||||
const missionAutopilot = createMockMissionAutopilot();
|
||||
const { app, missionStore } = buildApp({ missionAutopilot });
|
||||
const mission = missionStore.createMission({ title: "Disabled Autopilot" });
|
||||
|
||||
const res = await request(
|
||||
app,
|
||||
"POST",
|
||||
`/api/missions/${mission.id}/autopilot/start`,
|
||||
JSON.stringify({}),
|
||||
{ "content-type": "application/json" },
|
||||
);
|
||||
|
||||
expect(res.status).toBe(400);
|
||||
expect(res.body.error).toContain("not enabled");
|
||||
});
|
||||
|
||||
it("returns 503 when autopilot service is unavailable", async () => {
|
||||
const { app, missionStore } = buildApp();
|
||||
const mission = missionStore.createMission({ title: "Service Unavailable" });
|
||||
missionStore.updateMission(mission.id, { autopilotEnabled: true });
|
||||
|
||||
const res = await request(
|
||||
app,
|
||||
"POST",
|
||||
`/api/missions/${mission.id}/autopilot/start`,
|
||||
JSON.stringify({}),
|
||||
{ "content-type": "application/json" },
|
||||
);
|
||||
|
||||
expect(res.status).toBe(503);
|
||||
});
|
||||
});
|
||||
|
||||
describe("POST /api/missions/:missionId/autopilot/stop", () => {
|
||||
it("stops watching when autopilot service is available", async () => {
|
||||
const missionAutopilot = createMockMissionAutopilot();
|
||||
const { app, missionStore } = buildApp({ missionAutopilot });
|
||||
const mission = missionStore.createMission({ title: "Stop Autopilot" });
|
||||
|
||||
missionAutopilot.getAutopilotStatus.mockReturnValue({
|
||||
enabled: true,
|
||||
state: "inactive",
|
||||
watched: false,
|
||||
lastActivityAt: undefined,
|
||||
});
|
||||
|
||||
const res = await request(
|
||||
app,
|
||||
"POST",
|
||||
`/api/missions/${mission.id}/autopilot/stop`,
|
||||
JSON.stringify({}),
|
||||
{ "content-type": "application/json" },
|
||||
);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(missionAutopilot.unwatchMission).toHaveBeenCalledWith(mission.id);
|
||||
});
|
||||
|
||||
it("returns fallback status when autopilot service is unavailable", async () => {
|
||||
const { app, missionStore } = buildApp();
|
||||
const mission = missionStore.createMission({ title: "Stop Fallback" });
|
||||
missionStore.updateMission(mission.id, {
|
||||
autopilotEnabled: true,
|
||||
lastAutopilotActivityAt: "2026-04-07T15:00:00.000Z",
|
||||
});
|
||||
|
||||
const res = await request(
|
||||
app,
|
||||
"POST",
|
||||
`/api/missions/${mission.id}/autopilot/stop`,
|
||||
JSON.stringify({}),
|
||||
{ "content-type": "application/json" },
|
||||
);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body).toEqual({
|
||||
enabled: true,
|
||||
state: "inactive",
|
||||
watched: false,
|
||||
lastActivityAt: "2026-04-07T15:00:00.000Z",
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
241
packages/dashboard/src/mission-interview.test.ts
Normal file
241
packages/dashboard/src/mission-interview.test.ts
Normal file
@@ -0,0 +1,241 @@
|
||||
// @vitest-environment node
|
||||
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
const { mockCreateKbAgent } = vi.hoisted(() => ({
|
||||
mockCreateKbAgent: vi.fn(),
|
||||
}));
|
||||
|
||||
vi.mock("@fusion/engine", () => ({
|
||||
createKbAgent: mockCreateKbAgent,
|
||||
}));
|
||||
|
||||
import {
|
||||
__resetMissionInterviewState,
|
||||
cancelMissionInterviewSession,
|
||||
checkRateLimit,
|
||||
cleanupMissionInterviewSession,
|
||||
createMissionInterviewSession,
|
||||
getMissionInterviewSession,
|
||||
getMissionInterviewSummary,
|
||||
getRateLimitResetTime,
|
||||
InvalidSessionStateError,
|
||||
missionInterviewStreamManager,
|
||||
parseMissionAgentResponse,
|
||||
RateLimitError,
|
||||
SessionNotFoundError,
|
||||
submitMissionInterviewResponse,
|
||||
} from "./mission-interview.js";
|
||||
|
||||
function createQuestionJson(id = "q-1"): string {
|
||||
return JSON.stringify({
|
||||
type: "question",
|
||||
data: {
|
||||
id,
|
||||
type: "text",
|
||||
question: "What should we build first?",
|
||||
description: "Initial scope",
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
function createCompleteJson(): string {
|
||||
return JSON.stringify({
|
||||
type: "complete",
|
||||
data: {
|
||||
missionTitle: "Mission Ready",
|
||||
missionDescription: "Complete plan",
|
||||
milestones: [
|
||||
{
|
||||
title: "Milestone 1",
|
||||
slices: [
|
||||
{
|
||||
title: "Slice 1",
|
||||
features: [
|
||||
{ title: "Feature 1", acceptanceCriteria: "Works" },
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
function createMockAgent(responses: string[]) {
|
||||
const queue = [...responses];
|
||||
const messages: Array<{ role: string; content: string }> = [];
|
||||
|
||||
return {
|
||||
session: {
|
||||
state: { messages },
|
||||
prompt: vi.fn(async () => {
|
||||
const response = queue.shift() ?? createQuestionJson("q-fallback");
|
||||
messages.push({ role: "assistant", content: response });
|
||||
}),
|
||||
dispose: vi.fn(),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
async function waitForCurrentQuestion(sessionId: string): Promise<void> {
|
||||
for (let i = 0; i < 50; i++) {
|
||||
if (getMissionInterviewSession(sessionId)?.currentQuestion) {
|
||||
return;
|
||||
}
|
||||
await new Promise((resolve) => setTimeout(resolve, 5));
|
||||
}
|
||||
throw new Error("Timed out waiting for currentQuestion");
|
||||
}
|
||||
|
||||
describe("mission-interview module", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
__resetMissionInterviewState();
|
||||
mockCreateKbAgent.mockImplementation(async () => createMockAgent([createQuestionJson()]));
|
||||
});
|
||||
|
||||
describe("session lifecycle", () => {
|
||||
it("creates, retrieves, and cleans up a session", async () => {
|
||||
const sessionId = await createMissionInterviewSession("127.0.0.1", "Launch platform", "/tmp/project");
|
||||
|
||||
const session = getMissionInterviewSession(sessionId);
|
||||
expect(session).toBeDefined();
|
||||
expect(session?.missionTitle).toBe("Launch platform");
|
||||
|
||||
cleanupMissionInterviewSession(sessionId);
|
||||
expect(getMissionInterviewSession(sessionId)).toBeUndefined();
|
||||
});
|
||||
|
||||
it("cancels a session and throws when canceling missing session", async () => {
|
||||
const sessionId = await createMissionInterviewSession("127.0.0.2", "Cancel mission", "/tmp/project");
|
||||
await waitForCurrentQuestion(sessionId);
|
||||
|
||||
await cancelMissionInterviewSession(sessionId);
|
||||
expect(getMissionInterviewSession(sessionId)).toBeUndefined();
|
||||
|
||||
await expect(cancelMissionInterviewSession(sessionId)).rejects.toBeInstanceOf(SessionNotFoundError);
|
||||
});
|
||||
});
|
||||
|
||||
describe("rate limiting", () => {
|
||||
it("enforces max sessions per IP and exposes reset time", async () => {
|
||||
const ip = "10.0.0.1";
|
||||
|
||||
for (let i = 0; i < 5; i++) {
|
||||
await createMissionInterviewSession(ip, `Mission ${i}`, "/tmp/project");
|
||||
}
|
||||
|
||||
await expect(createMissionInterviewSession(ip, "Mission 6", "/tmp/project")).rejects.toBeInstanceOf(RateLimitError);
|
||||
expect(getRateLimitResetTime(ip)).toBeInstanceOf(Date);
|
||||
});
|
||||
|
||||
it("checkRateLimit tracks allowance and lockout", () => {
|
||||
const ip = "10.0.0.2";
|
||||
for (let i = 0; i < 5; i++) {
|
||||
expect(checkRateLimit(ip)).toBe(true);
|
||||
}
|
||||
expect(checkRateLimit(ip)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("submitMissionInterviewResponse", () => {
|
||||
it("processes response and returns completed summary", async () => {
|
||||
mockCreateKbAgent.mockImplementationOnce(async () =>
|
||||
createMockAgent([createQuestionJson("q-plan"), createCompleteJson()]),
|
||||
);
|
||||
|
||||
const sessionId = await createMissionInterviewSession("172.16.0.1", "Build mission", "/tmp/project");
|
||||
await waitForCurrentQuestion(sessionId);
|
||||
|
||||
const session = getMissionInterviewSession(sessionId);
|
||||
const questionId = session?.currentQuestion?.id;
|
||||
expect(questionId).toBe("q-plan");
|
||||
|
||||
const result = await submitMissionInterviewResponse(sessionId, {
|
||||
[questionId as string]: "We should prioritize auth first",
|
||||
});
|
||||
|
||||
expect(result.type).toBe("complete");
|
||||
expect(getMissionInterviewSummary(sessionId)?.missionTitle).toBe("Mission Ready");
|
||||
});
|
||||
|
||||
it("throws SessionNotFoundError for unknown session", async () => {
|
||||
await expect(submitMissionInterviewResponse("missing", {})).rejects.toBeInstanceOf(SessionNotFoundError);
|
||||
});
|
||||
|
||||
it("throws InvalidSessionStateError when no active question", async () => {
|
||||
const sessionId = await createMissionInterviewSession("172.16.0.2", "No question", "/tmp/project");
|
||||
await waitForCurrentQuestion(sessionId);
|
||||
|
||||
const session = getMissionInterviewSession(sessionId);
|
||||
if (!session) throw new Error("session should exist");
|
||||
session.currentQuestion = undefined;
|
||||
|
||||
await expect(submitMissionInterviewResponse(sessionId, {})).rejects.toBeInstanceOf(InvalidSessionStateError);
|
||||
});
|
||||
});
|
||||
|
||||
describe("stream manager", () => {
|
||||
it("subscribes, broadcasts, unsubscribes, and cleans up", () => {
|
||||
const callback = vi.fn();
|
||||
const unsubscribe = missionInterviewStreamManager.subscribe("session-1", callback);
|
||||
|
||||
expect(missionInterviewStreamManager.hasSubscribers("session-1")).toBe(true);
|
||||
|
||||
missionInterviewStreamManager.broadcast("session-1", { type: "thinking", data: "analyzing" });
|
||||
expect(callback).toHaveBeenCalledWith({ type: "thinking", data: "analyzing" });
|
||||
|
||||
unsubscribe();
|
||||
expect(missionInterviewStreamManager.hasSubscribers("session-1")).toBe(false);
|
||||
|
||||
missionInterviewStreamManager.cleanupSession("session-1");
|
||||
expect(missionInterviewStreamManager.hasSubscribers("session-1")).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("response parsing", () => {
|
||||
it("parses direct JSON question responses", () => {
|
||||
const parsed = parseMissionAgentResponse(createQuestionJson("q-direct"));
|
||||
expect(parsed.type).toBe("question");
|
||||
if (parsed.type === "question") {
|
||||
expect(parsed.data.id).toBe("q-direct");
|
||||
}
|
||||
});
|
||||
|
||||
it("parses markdown-wrapped complete responses", () => {
|
||||
const wrapped = `\n\`\`\`json\n${createCompleteJson()}\n\`\`\``;
|
||||
const parsed = parseMissionAgentResponse(wrapped);
|
||||
expect(parsed.type).toBe("complete");
|
||||
});
|
||||
|
||||
it("parses embedded JSON inside prose", () => {
|
||||
const text = `Here is the plan output:\n${createQuestionJson("q-embedded")}\nThanks.`;
|
||||
const parsed = parseMissionAgentResponse(text);
|
||||
expect(parsed.type).toBe("question");
|
||||
if (parsed.type === "question") {
|
||||
expect(parsed.data.id).toBe("q-embedded");
|
||||
}
|
||||
});
|
||||
|
||||
it("repairs and parses JSON with trailing commas", () => {
|
||||
const malformed = '{"type":"question","data":{"id":"q-fix","type":"text","question":"Q?",},}';
|
||||
const parsed = parseMissionAgentResponse(malformed);
|
||||
expect(parsed.type).toBe("question");
|
||||
});
|
||||
|
||||
it("throws on invalid response structure", () => {
|
||||
expect(() =>
|
||||
parseMissionAgentResponse(JSON.stringify({ type: "unknown", data: null })),
|
||||
).toThrow("invalid response structure");
|
||||
});
|
||||
});
|
||||
|
||||
describe("custom errors", () => {
|
||||
it("sets expected error names", () => {
|
||||
expect(new RateLimitError("rate").name).toBe("RateLimitError");
|
||||
expect(new SessionNotFoundError("missing").name).toBe("SessionNotFoundError");
|
||||
expect(new InvalidSessionStateError("bad").name).toBe("InvalidSessionStateError");
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -23,7 +23,7 @@ function createMockMissionStore(): any {
|
||||
getMission: vi.fn(),
|
||||
getMissionWithHierarchy: vi.fn(),
|
||||
getFeatureByTaskId: vi.fn(),
|
||||
updateFeatureStatus: vi.fn().mockResolvedValue(undefined),
|
||||
updateFeatureStatus: vi.fn(),
|
||||
computeSliceStatus: vi.fn(),
|
||||
on: vi.fn(),
|
||||
off: vi.fn(),
|
||||
@@ -38,6 +38,8 @@ function createMockTaskStore(): any {
|
||||
updateTask: vi.fn().mockResolvedValue(undefined),
|
||||
moveTask: vi.fn().mockResolvedValue(undefined),
|
||||
logEntry: vi.fn().mockResolvedValue(undefined),
|
||||
parseFileScopeFromPrompt: vi.fn().mockResolvedValue([]),
|
||||
getTasksDir: vi.fn().mockReturnValue("/test/project/.fusion/tasks"),
|
||||
getRootDir: vi.fn().mockReturnValue("/test/project"),
|
||||
on: vi.fn(),
|
||||
off: vi.fn(),
|
||||
@@ -106,12 +108,20 @@ describe("Scheduler Mission Integration", () => {
|
||||
let taskStore: any;
|
||||
let missionStore: any;
|
||||
let scheduler: Scheduler;
|
||||
let listeners: Record<string, Array<(...args: any[]) => void>>;
|
||||
|
||||
beforeEach(() => {
|
||||
listeners = {};
|
||||
taskStore = createMockTaskStore();
|
||||
missionStore = createMockMissionStore();
|
||||
taskStore.getMissionStore.mockReturnValue(missionStore);
|
||||
|
||||
taskStore.on.mockImplementation((event: string, handler: (...args: any[]) => void) => {
|
||||
listeners[event] ??= [];
|
||||
listeners[event].push(handler);
|
||||
return taskStore;
|
||||
});
|
||||
|
||||
const semaphore = new AgentSemaphore(2);
|
||||
scheduler = new Scheduler(taskStore, {
|
||||
pollIntervalMs: 1000,
|
||||
@@ -152,6 +162,44 @@ describe("Scheduler Mission Integration", () => {
|
||||
expect(result).toEqual(mockActivated);
|
||||
});
|
||||
|
||||
it("skips milestones with unmet dependencies and activates the next eligible pending slice", async () => {
|
||||
const mockActivated = createMockSlice({ id: "SL-ELIGIBLE", status: "active" });
|
||||
|
||||
missionStore.getMissionWithHierarchy.mockReturnValue({
|
||||
id: "M-001",
|
||||
status: "active",
|
||||
milestones: [
|
||||
{
|
||||
id: "MS-BLOCKED",
|
||||
orderIndex: 0,
|
||||
dependencies: ["MS-DEP"],
|
||||
status: "planning",
|
||||
slices: [{ id: "SL-BLOCKED", status: "pending", orderIndex: 0 }],
|
||||
},
|
||||
{
|
||||
id: "MS-DEP",
|
||||
orderIndex: 1,
|
||||
dependencies: [],
|
||||
status: "planning",
|
||||
slices: [{ id: "SL-DEP", status: "complete", orderIndex: 0 }],
|
||||
},
|
||||
{
|
||||
id: "MS-ELIGIBLE",
|
||||
orderIndex: 2,
|
||||
dependencies: [],
|
||||
status: "active",
|
||||
slices: [{ id: "SL-ELIGIBLE", status: "pending", orderIndex: 0 }],
|
||||
},
|
||||
],
|
||||
});
|
||||
missionStore.activateSlice.mockReturnValue(mockActivated);
|
||||
|
||||
const result = await scheduler.activateNextPendingSlice("M-001");
|
||||
|
||||
expect(missionStore.activateSlice).toHaveBeenCalledWith("SL-ELIGIBLE");
|
||||
expect(result).toEqual(mockActivated);
|
||||
});
|
||||
|
||||
it("should return null when no pending slices", async () => {
|
||||
missionStore.getMissionWithHierarchy.mockReturnValue({
|
||||
id: "M-001",
|
||||
@@ -200,68 +248,79 @@ describe("Scheduler Mission Integration", () => {
|
||||
});
|
||||
|
||||
describe("Mission-aware scheduling", () => {
|
||||
it("should handle task completion with mission integration", async () => {
|
||||
const feature = createMockFeature({ id: "F-001", sliceId: "SL-001", taskId: "FN-001" });
|
||||
const slice = createMockSlice({ id: "SL-001", milestoneId: "MS-001" });
|
||||
const milestone = createMockMilestone({ id: "MS-001", missionId: "M-001" });
|
||||
const mission = createMockMission({ id: "M-001", autoAdvance: true });
|
||||
const nextSlice = createMockSlice({ id: "SL-002", status: "pending" });
|
||||
it("filters out todo tasks whose mission is blocked", async () => {
|
||||
const blockedTask = {
|
||||
id: "FN-001",
|
||||
title: "Blocked task",
|
||||
column: "todo",
|
||||
paused: false,
|
||||
dependencies: [],
|
||||
steps: [],
|
||||
currentStep: 0,
|
||||
sliceId: "SL-001",
|
||||
createdAt: new Date().toISOString(),
|
||||
updatedAt: new Date().toISOString(),
|
||||
};
|
||||
|
||||
missionStore.getFeatureByTaskId.mockReturnValue(feature);
|
||||
missionStore.getSlice.mockReturnValue(slice);
|
||||
missionStore.getMilestone.mockReturnValue(milestone);
|
||||
missionStore.getMission.mockReturnValue(mission);
|
||||
missionStore.computeSliceStatus.mockReturnValue("complete");
|
||||
missionStore.findNextPendingSlice.mockReturnValue(nextSlice);
|
||||
missionStore.activateSlice.mockReturnValue({ ...nextSlice, status: "active" });
|
||||
taskStore.listTasks.mockResolvedValue([blockedTask]);
|
||||
taskStore.getSettings.mockResolvedValue({
|
||||
maxConcurrent: 2,
|
||||
maxWorktrees: 2,
|
||||
});
|
||||
missionStore.getSlice.mockReturnValue(createMockSlice({ id: "SL-001", milestoneId: "MS-001" }));
|
||||
missionStore.getMilestone.mockReturnValue(createMockMilestone({ id: "MS-001", missionId: "M-001" }));
|
||||
missionStore.getMission.mockReturnValue(createMockMission({ id: "M-001", status: "blocked" }));
|
||||
|
||||
// Verify the scheduler has access to mission store
|
||||
expect(scheduler).toBeDefined();
|
||||
vi.spyOn(scheduler as any, "validateTaskFilesystem").mockResolvedValue({ valid: true });
|
||||
|
||||
await scheduler.schedule();
|
||||
|
||||
expect(taskStore.moveTask).not.toHaveBeenCalled();
|
||||
expect(taskStore.updateTask).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("should not auto-advance when mission is blocked", async () => {
|
||||
const feature = createMockFeature({ id: "F-001", sliceId: "SL-001", taskId: "FN-001" });
|
||||
const slice = createMockSlice({ id: "SL-001", milestoneId: "MS-001" });
|
||||
const milestone = createMockMilestone({ id: "MS-001", missionId: "M-001" });
|
||||
const mission = createMockMission({ id: "M-001", status: "blocked" });
|
||||
it("delegates completion progression to missionAutopilot when a linked mission slice completes", async () => {
|
||||
const localTaskStore = createMockTaskStore();
|
||||
const localMissionStore = createMockMissionStore();
|
||||
const localListeners: Record<string, Array<(...args: any[]) => void>> = {};
|
||||
const missionAutopilot = {
|
||||
handleTaskCompletion: vi.fn().mockResolvedValue(undefined),
|
||||
stop: vi.fn(),
|
||||
};
|
||||
|
||||
missionStore.getFeatureByTaskId.mockReturnValue(feature);
|
||||
missionStore.getSlice.mockReturnValue(slice);
|
||||
missionStore.getMilestone.mockReturnValue(milestone);
|
||||
missionStore.getMission.mockReturnValue(mission);
|
||||
missionStore.computeSliceStatus.mockReturnValue("complete");
|
||||
localTaskStore.on.mockImplementation((event: string, handler: (...args: any[]) => void) => {
|
||||
localListeners[event] ??= [];
|
||||
localListeners[event].push(handler);
|
||||
return localTaskStore;
|
||||
});
|
||||
|
||||
// Verify that scheduler has the mission store
|
||||
expect(scheduler).toBeDefined();
|
||||
});
|
||||
const localScheduler = new Scheduler(localTaskStore, {
|
||||
pollIntervalMs: 1000,
|
||||
semaphore: new AgentSemaphore(2),
|
||||
missionStore: localMissionStore,
|
||||
missionAutopilot: missionAutopilot as any,
|
||||
});
|
||||
|
||||
it("should handle task with no linked feature gracefully", async () => {
|
||||
missionStore.getFeatureByTaskId.mockReturnValue(undefined);
|
||||
localMissionStore.getFeatureByTaskId.mockReturnValue(
|
||||
createMockFeature({ id: "F-001", sliceId: "SL-001", taskId: "FN-001", status: "triaged" }),
|
||||
);
|
||||
localMissionStore.getSlice.mockReturnValue(createMockSlice({ id: "SL-001", status: "complete" }));
|
||||
localMissionStore.updateFeatureStatus.mockReturnValue(undefined);
|
||||
|
||||
// Should not throw when feature is not found
|
||||
expect(scheduler).toBeDefined();
|
||||
});
|
||||
const handler = localListeners["task:moved"]?.[0];
|
||||
expect(handler).toBeDefined();
|
||||
|
||||
it("should handle multiple slices becoming ready simultaneously", async () => {
|
||||
const mission = createMockMission({ id: "M-001" });
|
||||
const pendingSlice1 = createMockSlice({ id: "SL-002", status: "pending" });
|
||||
const pendingSlice2 = createMockSlice({ id: "SL-003", status: "pending" });
|
||||
handler?.({
|
||||
task: { id: "FN-001", sliceId: "SL-001" },
|
||||
from: "in-progress",
|
||||
to: "done",
|
||||
});
|
||||
|
||||
missionStore.getMission.mockReturnValue(mission);
|
||||
await vi.waitFor(() => {
|
||||
expect(missionAutopilot.handleTaskCompletion).toHaveBeenCalledWith("FN-001");
|
||||
});
|
||||
|
||||
// First call returns SL-002
|
||||
missionStore.findNextPendingSlice
|
||||
.mockReturnValueOnce(pendingSlice1)
|
||||
.mockReturnValueOnce(pendingSlice2)
|
||||
.mockReturnValueOnce(null);
|
||||
|
||||
// Activate should be called for each slice
|
||||
missionStore.activateSlice
|
||||
.mockReturnValueOnce({ ...pendingSlice1, status: "active" })
|
||||
.mockReturnValueOnce({ ...pendingSlice2, status: "active" });
|
||||
|
||||
// Verify that the scheduler has the mission store
|
||||
expect(scheduler).toBeDefined();
|
||||
localScheduler.stop();
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
Reference in New Issue
Block a user