backnotprop__plannotator/packages/editor/sourceDocumentClient.test.ts

import { afterEach, describe, expect, test } from 'bun:test';
import {
  fetchHtmlDocumentSnapshot,
  fetchSourceDocumentSnapshot,
  probeSourceSave,
} from './sourceDocumentClient';

const originalFetch = globalThis.fetch;

function mockFetch(response: Response | Error) {
  globalThis.fetch = (async () => {
    if (response instanceof Error) throw response;
    return response;
  }) as typeof fetch;
}

afterEach(() => {
  globalThis.fetch = originalFetch;
});

describe('source document client', () => {
  test('probes source-save metadata from /api/doc', async () => {
    mockFetch(Response.json({
      sourceSave: {
        enabled: true,
        kind: 'local-text-file',
        scope: 'folder-file',
        path: '/repo/docs/a.md',
        basename: 'a.md',
        language: 'markdown',
        hash: 'sha256:after',
        mtimeMs: 1000,
        size: 6,
        eol: 'lf',
      },
    }));

    expect(await probeSourceSave('/repo/docs/a.md')).toEqual({
      status: 'ok',
      sourceSave: {
        enabled: true,
        kind: 'local-text-file',
        scope: 'folder-file',
        path: '/repo/docs/a.md',
        basename: 'a.md',
        language: 'markdown',
        hash: 'sha256:after',
        mtimeMs: 1000,
        size: 6,
        eol: 'lf',
      },
    });
  });

  test('distinguishes missing and unavailable source probes', async () => {
    mockFetch(new Response('missing', { status: 404 }));
    expect(await probeSourceSave('/repo/docs/missing.md')).toEqual({ status: 'missing' });

    mockFetch(new Error('network'));
    expect(await probeSourceSave('/repo/docs/a.md')).toEqual({ status: 'unavailable' });
  });

  test('fetches markdown source snapshots and rejects html documents', async () => {
    mockFetch(Response.json({
      markdown: 'after\n',
      sourceSave: {
        enabled: true,
        kind: 'local-text-file',
        scope: 'folder-file',
        path: '/repo/docs/a.md',
        basename: 'a.md',
        language: 'markdown',
        hash: 'sha256:after',
        mtimeMs: 1000,
        size: 6,
        eol: 'lf',
      },
    }));
    expect(await fetchSourceDocumentSnapshot('/repo/docs/a.md')).toEqual({
      status: 'ok',
      snapshot: {
        markdown: 'after\n',
        sourceSave: {
          enabled: true,
          kind: 'local-text-file',
          scope: 'folder-file',
          path: '/repo/docs/a.md',
          basename: 'a.md',
          language: 'markdown',
          hash: 'sha256:after',
          mtimeMs: 1000,
          size: 6,
          eol: 'lf',
        },
      },
    });

    mockFetch(Response.json({ markdown: '<p>after</p>', renderAs: 'html' }));
    expect(await fetchSourceDocumentSnapshot('/repo/docs/a.html')).toEqual({ status: 'unavailable' });
  });

  test('distinguishes missing and unavailable source snapshots', async () => {
    mockFetch(new Response('missing', { status: 404 }));
    expect(await fetchSourceDocumentSnapshot('/repo/docs/missing.md')).toEqual({ status: 'missing' });

    mockFetch(new Error('network'));
    expect(await fetchSourceDocumentSnapshot('/repo/docs/a.md')).toEqual({ status: 'unavailable' });
  });

  test('fetches a rendered html snapshot without requiring source-save support', async () => {
    mockFetch(Response.json({
      rawHtml: '<main>after</main>',
      filepath: '/repo/docs/a.html',
      renderAs: 'html',
      sourceSave: { enabled: false, reason: 'html-render' },
    }));

    expect(await fetchHtmlDocumentSnapshot('/repo/docs/a.html')).toEqual({
      status: 'ok',
      snapshot: {
        rawHtml: '<main>after</main>',
        filepath: '/repo/docs/a.html',
      },
    });
  });

  test('keeps the current html available when refresh cannot load a valid snapshot', async () => {
    mockFetch(new Response('missing', { status: 404 }));
    expect(await fetchHtmlDocumentSnapshot('/repo/docs/missing.html')).toEqual({ status: 'missing' });

    mockFetch(Response.json({ markdown: '# Not HTML', renderAs: 'markdown' }));
    expect(await fetchHtmlDocumentSnapshot('/repo/docs/a.html')).toEqual({ status: 'unavailable' });

    mockFetch(new Error('network'));
    expect(await fetchHtmlDocumentSnapshot('/repo/docs/a.html')).toEqual({ status: 'unavailable' });
  });
});