Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

7.7 KB
Raw Blame
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { LOCAL_DIR, type SyncMode } from '@inkeep/open-knowledge-core';
import simpleGit from 'simple-git';
import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
import { configureTestGitRepository } from '../../../test-support/configure-git-fixture.test-helper.ts';
import { createTestConflictAuthority } from './conflict-authority.test-helper.ts';
import { getLogger } from './logger.ts';
import { SyncEngine } from './sync-engine.ts';

const stubContentFilter = {
  isExcluded: (_path: string) => false,
  isDirExcluded: (_path: string) => false,
};

interface CapturedLog {
  data: Record<string, unknown>;
  msg: string;
  level: 'info' | 'warn' | 'error';
}

function captureSyncLogs(): { entries: CapturedLog[]; restore: () => void } {
  const entries: CapturedLog[] = [];
  const logger = getLogger('sync-engine');
  const record =
    (level: CapturedLog['level']) =>
    (data: unknown, msg?: string): void => {
      entries.push({ data: (data ?? {}) as Record<string, unknown>, msg: msg ?? '', level });
    };
  const infoSpy = vi.spyOn(logger, 'info').mockImplementation(record('info') as never);
  const warnSpy = vi.spyOn(logger, 'warn').mockImplementation(record('warn') as never);
  const errorSpy = vi.spyOn(logger, 'error').mockImplementation(record('error') as never);
  return {
    entries,
    restore: () => {
      infoSpy.mockRestore();
      warnSpy.mockRestore();
      errorSpy.mockRestore();
    },
  };
}

let tmpDir = '';
let projectDir = '';
let okDir = '';

beforeEach(() => {
  tmpDir = mkdtempSync(join(tmpdir(), 'sync-engine-unborn-head-'));
  projectDir = join(tmpDir, 'project');
  okDir = join(projectDir, '.ok', LOCAL_DIR);
  mkdirSync(projectDir, { recursive: true });
  mkdirSync(okDir, { recursive: true });
});

afterEach(() => {
  rmSync(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
});

function statePath(): string {
  return join(okDir, 'sync-state.json');
}

async function emptyProject() {
  const git = simpleGit(projectDir);
  await git.init(['--initial-branch=main']);
  configureTestGitRepository(projectDir);
  await git.raw('config', 'user.name', 'Test');
  await git.raw('config', 'user.email', '[email protected]');
  return git;
}

async function emptyProjectWithBareOrigin() {
  const bare = join(tmpDir, 'bare.git');
  mkdirSync(bare, { recursive: true });
  await simpleGit(bare).init(true);
  configureTestGitRepository(bare);
  await simpleGit(bare).raw('symbolic-ref', 'HEAD', 'refs/heads/main');

  const git = await emptyProject();
  await git.addRemote('origin', bare);
  return { git, bare };
}

function makeEngine(opts: { mode?: SyncMode } = {}) {
  return new SyncEngine({
    conflicts: createTestConflictAuthority(projectDir),
    projectDir,
    contentDir: projectDir,
    contentFilter: stubContentFilter,
    mode: opts.mode ?? 'off',
    pullIntervalSeconds: 99999,
    pushIntervalSeconds: 99999,
  });
}

describe('SyncEngine push refusal on an unborn HEAD', () => {
  test('a push with a remote and no commits names the missing first commit', async () => {
    await emptyProjectWithBareOrigin();

    const logs = captureSyncLogs();
    const engine = makeEngine();
    try {
      await engine.start();
      await engine.pushOnce();

      const status = engine.getStatus();
      expect(status.pausedReason).toBe('no-commits-yet');
      expect(status.state).toBe('disabled');

      const refusals = logs.entries.filter(
        (e) => e.level === 'error' && e.data.event === 'unborn-head-refusal',
      );
      expect(refusals).toHaveLength(1);
      expect(refusals[0].data).toMatchObject({ branch: 'main' });
      expect(refusals[0].msg).toContain('no commits yet');
    } finally {
      logs.restore();
      await engine.destroy();
    }
  });

  test('the notice clears once a first commit exists', async () => {
    const { git } = await emptyProjectWithBareOrigin();

    const engine = makeEngine();
    try {
      await engine.start();
      await engine.pushOnce();
      expect(engine.getStatus().pausedReason).toBe('no-commits-yet');

      writeFileSync(join(projectDir, 'doc.md'), 'v1\n', 'utf-8');
      await git.add('doc.md');
      await git.commit('first');
      await engine.pushOnce();

      expect(engine.getStatus().pausedReason).toBeUndefined();
      expect(engine.getStatus().pushError).toBeUndefined();
    } finally {
      await engine.destroy();
    }
  });

  test('a full auto-sync push with no commits names the condition instead of going silent', async () => {
    await emptyProjectWithBareOrigin();

    const logs = captureSyncLogs();
    const engine = makeEngine({ mode: 'full' });
    try {
      await engine.start();
      expect(engine.getStatus().state).not.toBe('disabled');
      await engine.pushOnce();

      const status = engine.getStatus();
      expect(status.pausedReason).toBe('no-commits-yet');
      expect(status.state).not.toBe('disabled');

      const refusals = logs.entries.filter(
        (e) => e.level === 'error' && e.data.event === 'unborn-head-refusal',
      );
      expect(refusals).toHaveLength(1);
      expect(refusals[0]?.data).toMatchObject({ branch: 'main' });
    } finally {
      logs.restore();
      await engine.destroy();
    }
  });

  test('a repeating full-mode push cycle logs the refusal once per condition, not per tick', async () => {
    await emptyProjectWithBareOrigin();

    const logs = captureSyncLogs();
    const engine = makeEngine({ mode: 'full' });
    try {
      await engine.start();
      await engine.pushOnce();
      await engine.pushOnce();
      await engine.pushOnce();

      expect(engine.getStatus().pausedReason).toBe('no-commits-yet');
      expect(logs.entries.filter((e) => e.data.event === 'unborn-head-refusal')).toHaveLength(1);
    } finally {
      logs.restore();
      await engine.destroy();
    }
  });

  test('a full-mode project with no remote is not paused on the missing first commit', async () => {
    await emptyProject();

    const logs = captureSyncLogs();
    const engine = makeEngine({ mode: 'full' });
    try {
      await engine.start();
      await engine.pushOnce();

      expect(engine.getStatus().pausedReason).toBeUndefined();
      expect(logs.entries.filter((e) => e.data.event === 'unborn-head-refusal')).toHaveLength(0);
    } finally {
      logs.restore();
      await engine.destroy();
    }
  });

  test('a project with no remote is left alone', async () => {
    await emptyProject();

    const engine = makeEngine();
    try {
      await engine.start();
      await engine.pushOnce();
      expect(engine.getStatus().pausedReason).toBeUndefined();
    } finally {
      await engine.destroy();
    }
  });

  test('the notice is neither written to the state file nor restored from it', async () => {
    await emptyProjectWithBareOrigin();

    const engine = makeEngine();
    try {
      await engine.start();
      await engine.pushOnce();
      expect(engine.getStatus().pausedReason).toBe('no-commits-yet');

      const internal = engine as unknown as { saveStateNow: () => void };
      internal.saveStateNow();
      expect(JSON.parse(readFileSync(statePath(), 'utf-8')).pausedReason).toBeUndefined();
    } finally {
      await engine.destroy();
    }

    writeFileSync(
      statePath(),
      JSON.stringify({
        version: 1,
        lastSyncUtc: null,
        lastFetchUtc: null,
        lastPushedSha: null,
        pausedReason: 'no-commits-yet',
      }),
      'utf-8',
    );

    const restarted = makeEngine();
    try {
      await restarted.start();
      expect(restarted.getStatus().pausedReason).toBeUndefined();
    } finally {
      await restarted.destroy();
    }
  });
});