116 lines
7.9 KiB
JavaScript
116 lines
7.9 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { scheduleDraft, serializeSchedule, scheduleDueLabel, scheduleRuleLabel } from '../src/schedules.js';
|
|
import { createSchedulesView } from '../src/views/schedules.js';
|
|
|
|
const pipeline = { id: 42, version: 7 };
|
|
const make = () => ({ ...scheduleDraft({ pipeline, workspace: '/srv/research', timezone: 'UTC' }), name: 'AI news', prompt: 'Research AI news' });
|
|
const serialize = draft => serializeSchedule(draft, { pipelineId: 42 });
|
|
|
|
test('new schedules independently snapshot prompts and positive pinned versions', () => {
|
|
const a = serialize(make());
|
|
const b = serialize({ ...make(), prompt: 'Research batteries', every: '48h' });
|
|
assert.equal(a.id, 0); assert.equal(a.version, 7); assert.equal(a.pipeline_id, 42);
|
|
assert.notEqual(a.input.prompt, b.input.prompt); assert.equal(a.rule.every, '24h');
|
|
assert.equal(b.rule.every, '48h');
|
|
for (const version of ['0', '-1', '1.2', '7junk', 'Infinity']) assert.throws(() => serialize({ ...make(), version }), /pinned version/);
|
|
});
|
|
|
|
test('existing record roundtrip preserves CAS, unknown fields and typed extra inputs', () => {
|
|
const original = { ...serialize(make()), id: 9, revision: 13, server_extra: { keep: true },
|
|
input: { prompt: 'Topic', count: 4, flag: false, nested: { list: [null, 2] } },
|
|
rule: { times: ['09:00', '17:30'], days: ['mon', 'fri'], timezone: '', future: 'keep' },
|
|
model: 'provider/model', stage_models: { research: 'provider/other' }, title: 'Saved title', output_format: 'json', notify_mode: 'off' };
|
|
const draft = scheduleDraft({ pipeline, schedule: original });
|
|
const result = serializeSchedule(draft, { pipelineId: 42, schedule: original });
|
|
assert.equal(result.id, 9); assert.equal(result.revision, 13);
|
|
assert.deepEqual(result.input, original.input); assert.deepEqual(result.server_extra, original.server_extra);
|
|
assert.equal(result.rule.future, 'keep'); assert.equal(draft.timezone, '');
|
|
assert.deepEqual(result.stage_models, original.stage_models); assert.equal(result.title, 'Saved title');
|
|
draft.prompt = 'Changed';
|
|
assert.equal(original.input.prompt, 'Topic');
|
|
});
|
|
|
|
test('run seeding copies only RunSpec and never origin metadata or a locked title', () => {
|
|
const run = { version: 3, workspace: '/server/run', input: { prompt: 'Past run', count: 2 },
|
|
model: 'p/m', stage_models: { a: 'p/x' }, notify_mode: 'on', title: 'User title', title_source:'explicit', output_format: 'markdown',
|
|
id: 87, origin: { kind: 'schedule' }, request_key: 'no-copy' };
|
|
const draft = scheduleDraft({ pipeline, run, workspace: '/different', timezone: 'UTC' });
|
|
const saved = serialize({ ...draft, name: 'From run', prompt: 'Editable title and prompt', otherInput: '{"count":2,"prompt":"ignored","array":[1,false]}' });
|
|
assert.equal(saved.version, 3); assert.equal(saved.workspace, '/server/run');
|
|
assert.equal(saved.input.prompt, 'Editable title and prompt'); assert.deepEqual(saved.input.array, [1, false]);
|
|
assert.equal(saved.title, 'User title'); assert.equal(saved.model, 'p/m');
|
|
assert.equal(saved.origin, undefined); assert.equal(saved.request_key, undefined); assert.equal(saved.id, 0);
|
|
});
|
|
|
|
test('rule modes mutually exclude interval and clock, validate days, timezone and times', () => {
|
|
const old = { ...serialize(make()), id: 3, rule: { every: '24h', days: ['mon'] } };
|
|
const draft = { ...scheduleDraft({ pipeline, schedule: old }), mode: 'clock', times: '09:00, 23:59' };
|
|
const clock = serializeSchedule(draft, { schedule: old });
|
|
assert.equal(clock.rule.every, undefined); assert.deepEqual(clock.rule.times, ['09:00', '23:59']);
|
|
const interval = serializeSchedule({ ...draft, mode: 'interval', every: '1.5m' }, { schedule: clock });
|
|
assert.equal(interval.rule.times, undefined); assert.equal(interval.rule.every, '1.5m');
|
|
assert.equal(serialize({ ...make(), every: '.5h' }).rule.every, '.5h');
|
|
for (const times of ['', '24:00', '9:00', '09:60', '09:00,09:00']) assert.throws(() => serialize({ ...make(), mode: 'clock', times }), /24-hour/);
|
|
for (const every of ['59s', 'NaN', '-1h', '1.1x', 'Infinityh']) assert.throws(() => serialize({ ...make(), every }), /at least 1m/);
|
|
for (const days of [['Monday'], ['mon', 'mon']]) assert.throws(() => serialize({ ...make(), days }), /weekdays/);
|
|
assert.throws(() => serialize({ ...make(), timezone: 'Nowhere/Invalid' }), /IANA/);
|
|
});
|
|
|
|
test('invalid JSON, model and workspace reject without mutating the draft', () => {
|
|
for (const otherInput of ['null', '[]', '{bad']) assert.throws(() => serialize({ ...make(), otherInput }), /JSON/);
|
|
for (const stageModels of ['null', '[]', '{"a":2}', '{"a":"no-provider"}']) assert.throws(() => serialize({ ...make(), stageModels }), /JSON|provider\/model/);
|
|
for (const model of ['plain', '/model', 'p/', 'p/m x']) assert.throws(() => serialize({ ...make(), model }), /provider\/model/);
|
|
for (const workspace of ['', 'relative', '~/repo', '/srv\npath']) assert.throws(() => serialize({ ...make(), workspace }), /absolute workspace/);
|
|
const draft = { ...make(), otherInput: 'null' }; const copy = structuredClone(draft);
|
|
assert.throws(() => serialize(draft)); assert.deepEqual(draft, copy);
|
|
});
|
|
|
|
test('display is honest for invalid or absent next_due', () => {
|
|
assert.equal(scheduleDueLabel('invalid'), 'Next time unavailable');
|
|
assert.equal(scheduleDueLabel(null), 'Not scheduled');
|
|
assert.match(scheduleRuleLabel({ every: '24h' }), /Server timezone/);
|
|
assert.match(scheduleRuleLabel({ every: '24h', timezone:'Local' }), /Server timezone/);
|
|
assert.match(scheduleDueLabel('2026-10-21T09:00:00Z','Asia/Tokyo'), /Asia\/Tokyo/);
|
|
assert.match(scheduleDueLabel('2026-10-21T09:00:00Z'), /your local time/);
|
|
});
|
|
|
|
test('saved run-level write restrictions survive scheduling without widening edits', () => {
|
|
const run={version:3,input:{prompt:'Scoped change'},workspace:'/srv/research',write_paths:['src/file.go'],allow_tools:true,title:'Automatic title',title_source:'model'};
|
|
const draft=scheduleDraft({pipeline,run});
|
|
const result=serialize({...draft,name:'Scoped run'});
|
|
assert.deepEqual(result.write_paths,['src/file.go']);
|
|
assert.equal(result.allow_tools,true);
|
|
assert.equal(result.title,undefined,'generated titles must not become locked run titles');
|
|
for(const writePaths of ['null','{}','[1]','["../outside"]','["/absolute"]','["src/*.go"]']) {
|
|
assert.throws(()=>serialize({...make(),writePaths}),/Write paths/);
|
|
}
|
|
assert.equal(serialize({...make(),timezone:'Local'}).rule.timezone,'Local');
|
|
});
|
|
|
|
test('a prompt-only edit preserves the existing weekday order and timer rule', () => {
|
|
const original={...serialize(make()),id:4,revision:2,rule:{every:'24h',days:['fri','mon'],timezone:'UTC'}};
|
|
const draft={...scheduleDraft({pipeline,schedule:original}),prompt:'New topic',days:['mon','fri']};
|
|
const saved=serializeSchedule(draft,{schedule:original});
|
|
assert.deepEqual(saved.rule,original.rule);
|
|
});
|
|
|
|
test('view cache shares pending reads, refreshes explicitly and recovers after refusal', async () => {
|
|
let calls = 0; let resolveRead; let fail = false; let renders = 0;
|
|
const view = createSchedulesView({ repo: { listSchedules() {
|
|
calls++; if (fail) throw new Error('unknown command list_schedules');
|
|
return new Promise(resolve => { resolveRead = resolve; });
|
|
} }, renderContent() { renders++; } });
|
|
const a = view.loadPipelineSchedules(42);
|
|
const b = view.loadPipelineSchedules(42, { force: true });
|
|
assert.equal(a, b); await Promise.resolve(); assert.equal(calls, 1);
|
|
resolveRead([{ id: 1 }]); assert.deepEqual(await a, [{ id: 1 }]);
|
|
await view.loadPipelineSchedules(42); assert.equal(calls, 1);
|
|
fail = true; assert.equal(await view.loadPipelineSchedules(42, { force: true }), null);
|
|
fail = false; const retry = view.loadPipelineSchedules(42, { force: true });
|
|
await Promise.resolve(); resolveRead([]); assert.deepEqual(await retry, []);
|
|
view.clearScheduleCache(); const newRead = view.loadPipelineSchedules(42);
|
|
await Promise.resolve(); resolveRead([]); await newRead;
|
|
assert.equal(calls, 4); assert.equal(renders, 4);
|
|
});
|