265 lines
10 KiB
JavaScript
265 lines
10 KiB
JavaScript
import { describe, expect, it, vi } from 'vitest';
|
|
import os from 'os';
|
|
import path from 'path';
|
|
import { mkdtemp, readFile, rm, writeFile } from 'fs/promises';
|
|
import { createScheduledTaskService } from './service.js';
|
|
import { registerScheduledTaskRoutes } from './routes.js';
|
|
|
|
const createService = (overrides = {}) => {
|
|
const projectConfigRuntime = {
|
|
listScheduledTasks: vi.fn(async () => []),
|
|
deleteScheduledTask: vi.fn(async () => ({ deleted: true, tasks: [] })),
|
|
...(overrides.projectConfigRuntime || {}),
|
|
};
|
|
const scheduledTasksRuntime = {
|
|
syncProject: vi.fn(async () => []),
|
|
...(overrides.scheduledTasksRuntime || {}),
|
|
};
|
|
const service = createScheduledTaskService({
|
|
readSettingsFromDiskMigrated: async () => ({
|
|
projects: [{ id: 'project-test', path: '/repo' }],
|
|
}),
|
|
sanitizeProjects: (projects) => projects,
|
|
projectConfigRuntime,
|
|
scheduledTasksRuntime,
|
|
});
|
|
return { service, projectConfigRuntime, scheduledTasksRuntime };
|
|
};
|
|
|
|
const loopTask = {
|
|
id: 'loop:project:daily-digest',
|
|
name: 'daily-digest',
|
|
enabled: true,
|
|
loopFile: '/repo/.agents/loops/daily-digest.md',
|
|
schedule: { kind: 'cron', cron: '0 9 * * *', timezone: 'UTC' },
|
|
execution: { prompt: 'digest', providerID: 'openai', modelID: 'gpt-4.1' },
|
|
};
|
|
|
|
describe('scheduled-task service list', () => {
|
|
it('reconciles loop files before returning tasks', async () => {
|
|
const syncedTasks = [loopTask];
|
|
const { service, projectConfigRuntime, scheduledTasksRuntime } = createService({
|
|
scheduledTasksRuntime: {
|
|
syncProject: vi.fn(async () => syncedTasks),
|
|
},
|
|
});
|
|
|
|
await expect(service.list('project-test')).resolves.toBe(syncedTasks);
|
|
expect(scheduledTasksRuntime.syncProject).toHaveBeenCalledOnce();
|
|
expect(scheduledTasksRuntime.syncProject).toHaveBeenCalledWith('project-test');
|
|
expect(projectConfigRuntime.listScheduledTasks).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('surfaces reconciliation failure instead of returning a stale list', async () => {
|
|
const syncError = new Error('loop reconciliation failed');
|
|
const { service, projectConfigRuntime } = createService({
|
|
scheduledTasksRuntime: {
|
|
syncProject: vi.fn(async () => {
|
|
throw syncError;
|
|
}),
|
|
},
|
|
});
|
|
|
|
await expect(service.list('project-test')).rejects.toBe(syncError);
|
|
expect(projectConfigRuntime.listScheduledTasks).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('scheduled-task loop-file mutations', () => {
|
|
it('updates only enabled in loop frontmatter and reconciles the task', async () => {
|
|
const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'oc-loop-toggle-'));
|
|
try {
|
|
const loopFilePath = path.join(tempRoot, 'daily.md');
|
|
await writeFile(loopFilePath, `---
|
|
name: daily-digest
|
|
schedule: "0 9 * * *"
|
|
enabled: true
|
|
model: openai/gpt-5
|
|
custom: keep-me
|
|
---
|
|
|
|
Run the digest.
|
|
`, 'utf8');
|
|
const currentTask = { ...loopTask, loopFile: loopFilePath };
|
|
const updatedTask = { ...currentTask, enabled: false };
|
|
const syncProject = vi.fn()
|
|
.mockResolvedValueOnce([currentTask])
|
|
.mockResolvedValueOnce([updatedTask]);
|
|
const { service } = createService({ scheduledTasksRuntime: { syncProject } });
|
|
|
|
await expect(service.setLoopEnabled('project-test', currentTask.id, false)).resolves.toEqual(updatedTask);
|
|
|
|
const content = await readFile(loopFilePath, 'utf8');
|
|
expect(content).toContain('enabled: false');
|
|
expect(content).toContain('custom: keep-me');
|
|
expect(content).toContain('Run the digest.');
|
|
expect(syncProject).toHaveBeenCalledTimes(2);
|
|
} finally {
|
|
await rm(tempRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it('deletes the authoritative loop file and reconciles the task away', async () => {
|
|
const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'oc-loop-remove-'));
|
|
try {
|
|
const loopFilePath = path.join(tempRoot, 'daily.md');
|
|
await writeFile(loopFilePath, 'loop', 'utf8');
|
|
const currentTask = { ...loopTask, loopFile: loopFilePath };
|
|
const syncProject = vi.fn()
|
|
.mockResolvedValueOnce([currentTask])
|
|
.mockResolvedValueOnce([]);
|
|
const { service } = createService({ scheduledTasksRuntime: { syncProject } });
|
|
|
|
await expect(service.removeLoopFile('project-test', currentTask.id)).resolves.toEqual([]);
|
|
await expect(readFile(loopFilePath, 'utf8')).rejects.toMatchObject({ code: 'ENOENT' });
|
|
expect(syncProject).toHaveBeenCalledTimes(2);
|
|
} finally {
|
|
await rm(tempRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it('does not rewrite a malformed loop when toggling', async () => {
|
|
const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'oc-loop-invalid-'));
|
|
try {
|
|
const loopFilePath = path.join(tempRoot, 'daily.md');
|
|
const malformed = '---\nname: daily-digest\n---\nRun.\n';
|
|
await writeFile(loopFilePath, malformed, 'utf8');
|
|
const currentTask = { ...loopTask, loopFile: loopFilePath };
|
|
const syncProject = vi.fn(async () => [currentTask]);
|
|
const { service } = createService({ scheduledTasksRuntime: { syncProject } });
|
|
|
|
await expect(service.setLoopEnabled('project-test', currentTask.id, false)).rejects.toMatchObject({ statusCode: 400 });
|
|
await expect(readFile(loopFilePath, 'utf8')).resolves.toBe(malformed);
|
|
expect(syncProject).toHaveBeenCalledOnce();
|
|
} finally {
|
|
await rm(tempRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('scheduled-task loop-file routes', () => {
|
|
const createResponse = () => ({
|
|
statusCode: 200,
|
|
payload: null,
|
|
status(code) {
|
|
this.statusCode = code;
|
|
return this;
|
|
},
|
|
json(payload) {
|
|
this.payload = payload;
|
|
return this;
|
|
},
|
|
});
|
|
|
|
const captureHandlers = (scheduledTaskService) => {
|
|
const handlers = new Map();
|
|
const app = {
|
|
get: vi.fn(),
|
|
put: vi.fn(),
|
|
post: vi.fn(),
|
|
patch: vi.fn((route, handler) => handlers.set(`PATCH ${route}`, handler)),
|
|
delete: vi.fn((route, handler) => handlers.set(`DELETE ${route}`, handler)),
|
|
};
|
|
registerScheduledTaskRoutes(app, {
|
|
scheduledTaskService,
|
|
readSettingsFromDiskMigrated: vi.fn(),
|
|
sanitizeProjects: vi.fn(),
|
|
projectConfigRuntime: {},
|
|
scheduledTasksRuntime: {},
|
|
getOpenChamberEventClients: () => new Set(),
|
|
writeSseEvent: vi.fn(),
|
|
});
|
|
return handlers;
|
|
};
|
|
|
|
it('routes loop enabled changes through the loop-file service', async () => {
|
|
const setLoopEnabled = vi.fn(async () => ({ ...loopTask, enabled: false }));
|
|
const handlers = captureHandlers({ setLoopEnabled });
|
|
const handler = handlers.get('PATCH /api/projects/:projectId/scheduled-tasks/:taskId/loop-file');
|
|
const res = createResponse();
|
|
|
|
await handler({ params: { projectId: 'project-test', taskId: loopTask.id }, body: { enabled: false } }, res);
|
|
|
|
expect(setLoopEnabled).toHaveBeenCalledWith('project-test', loopTask.id, false);
|
|
expect(res.statusCode).toBe(200);
|
|
expect(res.payload.task.enabled).toBe(false);
|
|
});
|
|
|
|
it('routes loop deletion through the loop-file service', async () => {
|
|
const removeLoopFile = vi.fn(async () => []);
|
|
const handlers = captureHandlers({ removeLoopFile });
|
|
const handler = handlers.get('DELETE /api/projects/:projectId/scheduled-tasks/:taskId/loop-file');
|
|
const res = createResponse();
|
|
|
|
await handler({ params: { projectId: 'project-test', taskId: loopTask.id } }, res);
|
|
|
|
expect(removeLoopFile).toHaveBeenCalledWith('project-test', loopTask.id);
|
|
expect(res.statusCode).toBe(200);
|
|
expect(res.payload).toEqual({ tasks: [] });
|
|
});
|
|
});
|
|
|
|
describe('scheduled-task service remove', () => {
|
|
it('rejects deleting a loop-sourced task while its loop file still exists', async () => {
|
|
const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'oc-loop-delete-'));
|
|
try {
|
|
const loopFilePath = path.join(tempRoot, 'daily.md');
|
|
await writeFile(loopFilePath, '---\nname: daily-digest\n---\nRun.\n', 'utf8');
|
|
|
|
const { service, projectConfigRuntime, scheduledTasksRuntime } = createService({
|
|
projectConfigRuntime: {
|
|
listScheduledTasks: vi.fn(async () => [{ ...loopTask, loopFile: loopFilePath }]),
|
|
},
|
|
});
|
|
|
|
await expect(service.remove('project-test', loopTask.id)).rejects.toMatchObject({
|
|
statusCode: 400,
|
|
message: expect.stringContaining('delete the file to remove the task'),
|
|
});
|
|
expect(projectConfigRuntime.deleteScheduledTask).not.toHaveBeenCalled();
|
|
expect(scheduledTasksRuntime.syncProject).not.toHaveBeenCalled();
|
|
} finally {
|
|
await rm(tempRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it('allows deleting a loop-sourced task once its loop file is gone', async () => {
|
|
const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'oc-loop-delete-'));
|
|
try {
|
|
// The loop file was removed from disk; the orphan task is allowed to be
|
|
// deleted directly instead of waiting for the next reconcile.
|
|
const loopFilePath = path.join(tempRoot, 'gone.md');
|
|
|
|
const { service, projectConfigRuntime, scheduledTasksRuntime } = createService({
|
|
projectConfigRuntime: {
|
|
listScheduledTasks: vi.fn(async () => [{ ...loopTask, loopFile: loopFilePath }]),
|
|
},
|
|
});
|
|
|
|
const tasks = await service.remove('project-test', loopTask.id);
|
|
|
|
expect(projectConfigRuntime.deleteScheduledTask).toHaveBeenCalledWith('project-test', loopTask.id);
|
|
expect(scheduledTasksRuntime.syncProject).toHaveBeenCalled();
|
|
expect(Array.isArray(tasks)).toBe(true);
|
|
} finally {
|
|
await rm(tempRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it('deletes JSON-configured tasks normally', async () => {
|
|
const jsonTask = { ...loopTask, id: 'json-task', loopFile: undefined };
|
|
const { service, projectConfigRuntime, scheduledTasksRuntime } = createService({
|
|
projectConfigRuntime: {
|
|
listScheduledTasks: vi.fn(async () => [jsonTask]),
|
|
deleteScheduledTask: vi.fn(async () => ({ deleted: true, tasks: [] })),
|
|
},
|
|
});
|
|
|
|
const tasks = await service.remove('project-test', jsonTask.id);
|
|
|
|
expect(projectConfigRuntime.deleteScheduledTask).toHaveBeenCalledWith('project-test', jsonTask.id);
|
|
expect(scheduledTasksRuntime.syncProject).toHaveBeenCalled();
|
|
expect(Array.isArray(tasks)).toBe(true);
|
|
});
|
|
});
|