Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

6.4 KB
Raw Blame
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { EventEmitter } from 'node:events';

const scheduleMock = vi.fn();
const cancelMock = vi.fn();
const settingsEvents = new EventEmitter();
let registeredEvent = null;
vi.mock('./settings.js', () => ({ settingsEvents }));
vi.mock('./eventScheduler.js', () => ({
  schedule: (event) => { registeredEvent = event; return scheduleMock(event); },
  cancel: (id) => { registeredEvent = null; return cancelMock(id); },
  getEvent: () => registeredEvent,
}));

const { createSyncScheduler } = await import('./createSettingsGatedSyncScheduler.js');

let logs;
let logSpy;

beforeEach(() => {
  scheduleMock.mockClear();
  cancelMock.mockClear();
  registeredEvent = null;
  logs = [];
  logSpy = vi.spyOn(console, 'log').mockImplementation((line) => { logs.push(line); });
});

afterEach(() => {
  logSpy.mockRestore();
  settingsEvents.removeAllListeners();
});

const build = (getConfig, runSync = vi.fn(), getLastRunAt = undefined) => ({
  start: createSyncScheduler({
    id: 'demo-sync',
    label: 'Demo',
    icon: '🧪',
    source: 'demoScheduler',
    getConfig,
    runSync,
    getLastRunAt,
  }),
  runSync,
});

describe('createSyncScheduler', () => {
  it('reconciles enable, cadence change, unrelated save, and disable after boot', async () => {
    let config = { enabled: false, intervalMinutes: 25 };
    const { start } = build(async () => config);
    await start();
    expect(scheduleMock).not.toHaveBeenCalled();

    config = { enabled: true, intervalMinutes: 25 };
    settingsEvents.emit('settings:updated');
    await start();
    expect(scheduleMock).toHaveBeenCalledTimes(1);
    expect(scheduleMock.mock.calls[0][0].intervalMs).toBe(25 * 60 * 1000);
    expect(scheduleMock.mock.calls[0][0].handler).toBeTypeOf('function');

    settingsEvents.emit('settings:updated');
    await start();
    expect(scheduleMock).toHaveBeenCalledTimes(1);

    config = { enabled: true, intervalMinutes: 40 };
    settingsEvents.emit('settings:updated');
    await start();
    expect(scheduleMock).toHaveBeenCalledTimes(2);
    expect(scheduleMock.mock.calls[1][0].intervalMs).toBe(40 * 60 * 1000);

    config = { enabled: false, intervalMinutes: 40 };
    settingsEvents.emit('settings:updated');
    await start();
    expect(cancelMock).toHaveBeenCalledExactlyOnceWith('demo-sync');
  });

  it('no-ops (and never schedules) when disabled in settings', async () => {
    const { start } = build(vi.fn(async () => ({ enabled: false, intervalMinutes: 25 })));

    await start();

    expect(scheduleMock).not.toHaveBeenCalled();
    expect(logs).toContain('🧪 Demo sync scheduler: disabled in settings — skipping');
  });

  it('registers one interval job with the domain id, interval, and metadata source', async () => {
    const { start } = build(vi.fn(async () => ({ enabled: true, intervalMinutes: 25 })));

    await start();

    expect(scheduleMock).toHaveBeenCalledTimes(1);
    const [event] = scheduleMock.mock.calls[0];
    expect(event.id).toBe('demo-sync');
    expect(event.type).toBe('interval');
    // Minutes → ms, so a cadence change in settings can't silently become seconds.
    expect(event.intervalMs).toBe(25 * 60 * 1000);
    expect(event.metadata).toEqual({ source: 'demoScheduler' });
    expect(logs).toContain('🧪 Demo sync scheduler: registered every 25min');
  });

  it('runs the sync on tick while still enabled', async () => {
    const { start, runSync } = build(vi.fn(async () => ({ enabled: true, intervalMinutes: 25 })));

    await start();
    await scheduleMock.mock.calls[0][0].handler();

    expect(runSync).toHaveBeenCalledTimes(1);
  });

  it('re-reads enabled per tick so disabling in settings stops runs without a restart', async () => {
    const getConfig = vi.fn()
      .mockResolvedValueOnce({ enabled: true, intervalMinutes: 25 })
      .mockResolvedValue({ enabled: false, intervalMinutes: 25 });
    const { start, runSync } = build(getConfig);

    await start();
    await scheduleMock.mock.calls[0][0].handler();

    expect(runSync).not.toHaveBeenCalled();
    expect(logs).toContain('🧪 Demo sync scheduler: disabled since registration — skipping run');
  });

  it('keeps the registration interval locked even when settings change mid-flight', async () => {
    const getConfig = vi.fn()
      .mockResolvedValueOnce({ enabled: true, intervalMinutes: 25 })
      .mockResolvedValue({ enabled: true, intervalMinutes: 480 });
    const { start, runSync } = build(getConfig);

    await start();
    await scheduleMock.mock.calls[0][0].handler();

    expect(scheduleMock.mock.calls[0][0].intervalMs).toBe(25 * 60 * 1000);
    expect(runSync).toHaveBeenCalledTimes(1);
  });

  it('throws when runSync reports a detected failure via { ok: false }, so the run is recorded failed (#7549)', async () => {
    const runSync = vi.fn(async () => ({ ok: false, error: 'Full Disk Access required' }));
    const { start } = build(vi.fn(async () => ({ enabled: true, intervalMinutes: 25 })), runSync);

    await start();

    await expect(scheduleMock.mock.calls[0][0].handler()).rejects.toThrow('Full Disk Access required');
  });

  it('does not throw when runSync succeeds with { ok: true }', async () => {
    const runSync = vi.fn(async () => ({ ok: true }));
    const { start } = build(vi.fn(async () => ({ enabled: true, intervalMinutes: 25 })), runSync);

    await start();

    await expect(scheduleMock.mock.calls[0][0].handler()).resolves.toBeUndefined();
  });

  it('passes getLastRunAt reader result to schedule() (#12624)', async () => {
    const lastRunAt = '2026-10-20T12:00:00.000Z';
    const getLastRunAt = vi.fn(async () => lastRunAt);
    const { start } = build(
      vi.fn(async () => ({ enabled: true, intervalMinutes: 25 })),
      vi.fn(),
      getLastRunAt
    );

    await start();

    expect(getLastRunAt).toHaveBeenCalledTimes(1);
    expect(scheduleMock).toHaveBeenCalledTimes(1);
    expect(scheduleMock.mock.calls[0][0].lastRunAt).toBe(lastRunAt);
  });

  it('handles failing getLastRunAt gracefully by scheduling with null lastRunAt (#12624)', async () => {
    const getLastRunAt = vi.fn(async () => { throw new Error('disk read failed'); });
    const { start } = build(
      vi.fn(async () => ({ enabled: true, intervalMinutes: 25 })),
      vi.fn(),
      getLastRunAt
    );

    await start();

    expect(getLastRunAt).toHaveBeenCalledTimes(1);
    expect(scheduleMock).toHaveBeenCalledTimes(1);
    expect(scheduleMock.mock.calls[0][0].lastRunAt).toBeNull();
  });
});