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); });