nebula-cms 0.1.3 → 0.1.4

package/tests/client/js/storage/workers/storage.test.ts

@@ -1,299 +0,0 @@
-import { describe, it, expect, vi, afterEach, type MockInstance } from 'vitest';
-
-//////////////////////////////
-// Storage worker tests
-//
-// The worker module uses self.addEventListener('connect', ...) to register a
-// SharedWorker entry point. We mock self before importing so the listener is
-// captured, then invoke it with plain event-like objects (not real
-// MessageEvent instances, because MessageEvent.ports is a readonly getter).
-//
-// The worker's `adapter` variable is module-level singleton state. Each test
-// creates its own isolated port and drives its own init + request sequence
-// rather than sharing state via beforeEach. This avoids cross-test pollution
-// where an adapter set by one test's init is still active when the next test
-// starts.
-//
-// Adapters are loaded via dynamic import() inside the 'init' case. We mock
-// those modules via vi.mock so no real FSA or GitHub code runs.
-//////////////////////////////
-
-import type { StorageRequest } from '../../../../../src/client/js/storage/adapter';
-import { makeWorkerMockPort as makeMockPort } from '../mock-port';
-
-// ── Mock adapter modules ────────────────────────────────────────────────────
-
-vi.mock('../../../../../src/client/js/storage/fsa', () => ({
-  FsaAdapter: function () {
-    return {
-      listFiles: vi
-        .fn()
-        .mockResolvedValue([{ filename: 'a.md', content: 'A' }]),
-      readFile: vi.fn().mockResolvedValue('A content'),
-      writeFile: vi.fn().mockResolvedValue(undefined),
-      writeFiles: vi.fn().mockResolvedValue(undefined),
-      deleteFile: vi.fn().mockResolvedValue(undefined),
-    };
-  },
-}));
-
-vi.mock('../../../../../src/client/js/storage/github', () => ({
-  GitHubAdapter: function () {
-    return {
-      validate: vi.fn().mockResolvedValue(undefined),
-      listFiles: vi
-        .fn()
-        .mockResolvedValue([{ filename: 'b.md', content: 'B' }]),
-      readFile: vi.fn().mockResolvedValue('B content'),
-      writeFile: vi.fn().mockResolvedValue(undefined),
-      writeFiles: vi.fn().mockResolvedValue(undefined),
-      deleteFile: vi.fn().mockResolvedValue(undefined),
-    };
-  },
-}));
-
-// ── Self mock ──────────────────────────────────────────────────────────────
-
-// Capture the connect listener registered by the worker module at import time.
-// The handler type uses a plain object because MessageEvent.ports is a
-// readonly getter — we cannot assign to it on a real MessageEvent.
-let connectHandler: ((event: { ports: MessagePort[] }) => void) | null = null;
-
-vi.stubGlobal('self', {
-  addEventListener: vi.fn((type: string, handler: unknown) => {
-    if (type === 'connect') {
-      connectHandler = handler as (event: { ports: MessagePort[] }) => void;
-    }
-  }),
-  postMessage: vi.fn(),
-});
-
-// ── Import module under test (after mocks are in place) ─────────────────────
-
-await import('../../../../../src/client/js/storage/workers/storage');
-
-// ── Helpers ────────────────────────────────────────────────────────────────
-
-/**
- * Connects a port to the worker by invoking the captured connect handler
- * with a plain object. MessageEvent.ports is a readonly getter so we cannot
- * use a real MessageEvent here.
- * @param {MessagePort} port - The port to register with the worker
- * @return {void}
- */
-function connectPort(port: MessagePort): void {
-  connectHandler!({ ports: [port] });
-}
-
-/**
- * Connects a port, sends an FSA init, and waits for the ok response.
- * @param {MockInstance} postSpy - The port's postMessage spy
- * @param {(req: StorageRequest & { _id?: string }) => void} send - The send helper
- * @param {string} id - A unique _id for this init request
- * @return {Promise<void>}
- */
-async function initFSA(
-  postSpy: MockInstance,
-  send: (req: StorageRequest & { _id?: string }) => void,
-  id: string,
-): Promise<void> {
-  send({
-    type: 'init',
-    backend: { type: 'fsa', handle: {} as FileSystemDirectoryHandle },
-    _id: id,
-  });
-  await vi.waitUntil(() => postSpy.mock.calls.some((c) => c[0]._id === id), {
-    timeout: 2000,
-  });
-}
-
-// ── Tests ─────────────────────────────────────────────────────────────────────
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('storage worker', () => {
-  it('registers a connect listener on self', () => {
-    expect(connectHandler).toBeTypeOf('function');
-  });
-
-  it('sends port-connected immediately when a port connects', () => {
-    const { port, postSpy } = makeMockPort();
-    connectPort(port);
-    const portConnected = postSpy.mock.calls.find(
-      (c) => c[0].type === 'port-connected',
-    );
-    expect(portConnected).toBeDefined();
-  });
-
-  it('responds to FSA init with ok: true', async () => {
-    const { port, postSpy, send } = makeMockPort();
-    connectPort(port);
-    await initFSA(postSpy, send, 'init-fsa-1');
-    const resp = postSpy.mock.calls.find((c) => c[0]._id === 'init-fsa-1')[0];
-    expect(resp.ok).toBe(true);
-    expect(resp.type).toBe('init');
-    // Clean up shared adapter state
-    send({ type: 'teardown', _id: 'teardown-fsa-1' });
-    await vi.waitUntil(() =>
-      postSpy.mock.calls.some((c) => c[0]._id === 'teardown-fsa-1'),
-    );
-  });
-
-  it('responds to GitHub init with ok: true', async () => {
-    const { port, postSpy, send } = makeMockPort();
-    connectPort(port);
-    send({
-      type: 'init',
-      backend: { type: 'github', token: 'tok', repo: 'owner/repo' },
-      _id: 'init-gh-1',
-    });
-    await vi.waitUntil(
-      () => postSpy.mock.calls.some((c) => c[0]._id === 'init-gh-1'),
-      { timeout: 2000 },
-    );
-    const resp = postSpy.mock.calls.find((c) => c[0]._id === 'init-gh-1')[0];
-    expect(resp.ok).toBe(true);
-    // Clean up
-    send({ type: 'teardown', _id: 'teardown-gh-1' });
-    await vi.waitUntil(() =>
-      postSpy.mock.calls.some((c) => c[0]._id === 'teardown-gh-1'),
-    );
-  });
-
-  it('responds to listFiles after init', async () => {
-    const { port, postSpy, send } = makeMockPort();
-    connectPort(port);
-    await initFSA(postSpy, send, 'init-list');
-
-    send({
-      type: 'listFiles',
-      collection: 'posts',
-      extensions: ['.md', '.mdx'],
-      _id: 'list-1',
-    });
-    await vi.waitUntil(
-      () => postSpy.mock.calls.some((c) => c[0]._id === 'list-1'),
-      { timeout: 2000 },
-    );
-
-    const resp = postSpy.mock.calls.find((c) => c[0]._id === 'list-1')[0];
-    expect(resp.type).toBe('listFiles');
-    expect(resp.ok).toBe(true);
-    expect(resp.files).toEqual([{ filename: 'a.md', content: 'A' }]);
-
-    send({ type: 'teardown', _id: 'teardown-list' });
-    await vi.waitUntil(() =>
-      postSpy.mock.calls.some((c) => c[0]._id === 'teardown-list'),
-    );
-  });
-
-  it('returns an error response for listFiles before init', async () => {
-    // Teardown any adapter left by previous tests
-    const {
-      port: cleanPort,
-      postSpy: cleanSpy,
-      send: cleanSend,
-    } = makeMockPort();
-    connectPort(cleanPort);
-    cleanSend({ type: 'teardown', _id: 'pre-teardown' });
-    await vi.waitUntil(() =>
-      cleanSpy.mock.calls.some((c) => c[0]._id === 'pre-teardown'),
-    );
-
-    const { port, postSpy, send } = makeMockPort();
-    connectPort(port);
-    send({
-      type: 'listFiles',
-      collection: 'posts',
-      extensions: ['.md', '.mdx'],
-      _id: 'list-no-adapter',
-    });
-    await vi.waitUntil(
-      () => postSpy.mock.calls.some((c) => c[0]._id === 'list-no-adapter'),
-      { timeout: 2000 },
-    );
-
-    const resp = postSpy.mock.calls.find(
-      (c) => c[0]._id === 'list-no-adapter',
-    )[0];
-    expect(resp.ok).toBe(false);
-    expect(resp.error).toContain('No backend');
-  });
-
-  it('responds to deleteFile after init', async () => {
-    const { port, postSpy, send } = makeMockPort();
-    connectPort(port);
-    await initFSA(postSpy, send, 'init-delete');
-
-    send({
-      type: 'deleteFile',
-      collection: 'posts',
-      filename: 'old.md',
-      _id: 'delete-1',
-    });
-    await vi.waitUntil(
-      () => postSpy.mock.calls.some((c) => c[0]._id === 'delete-1'),
-      { timeout: 2000 },
-    );
-
-    const resp = postSpy.mock.calls.find((c) => c[0]._id === 'delete-1')[0];
-    expect(resp.type).toBe('deleteFile');
-    expect(resp.ok).toBe(true);
-
-    send({ type: 'teardown', _id: 'teardown-delete' });
-    await vi.waitUntil(() =>
-      postSpy.mock.calls.some((c) => c[0]._id === 'teardown-delete'),
-    );
-  });
-
-  it('returns an error response for deleteFile before init', async () => {
-    // Teardown any adapter left by previous tests
-    const {
-      port: cleanPort,
-      postSpy: cleanSpy,
-      send: cleanSend,
-    } = makeMockPort();
-    connectPort(cleanPort);
-    cleanSend({ type: 'teardown', _id: 'pre-teardown-del' });
-    await vi.waitUntil(() =>
-      cleanSpy.mock.calls.some((c) => c[0]._id === 'pre-teardown-del'),
-    );
-
-    const { port, postSpy, send } = makeMockPort();
-    connectPort(port);
-    send({
-      type: 'deleteFile',
-      collection: 'posts',
-      filename: 'old.md',
-      _id: 'delete-no-adapter',
-    });
-    await vi.waitUntil(
-      () => postSpy.mock.calls.some((c) => c[0]._id === 'delete-no-adapter'),
-      { timeout: 2000 },
-    );
-
-    const resp = postSpy.mock.calls.find(
-      (c) => c[0]._id === 'delete-no-adapter',
-    )[0];
-    expect(resp.ok).toBe(false);
-    expect(resp.error).toContain('No backend');
-  });
-
-  it('responds to teardown with ok: true and clears the adapter', async () => {
-    const { port, postSpy, send } = makeMockPort();
-    connectPort(port);
-    await initFSA(postSpy, send, 'init-teardown');
-
-    send({ type: 'teardown', _id: 'td-1' });
-    await vi.waitUntil(
-      () => postSpy.mock.calls.some((c) => c[0]._id === 'td-1'),
-      { timeout: 2000 },
-    );
-
-    const resp = postSpy.mock.calls.find((c) => c[0]._id === 'td-1')[0];
-    expect(resp.type).toBe('teardown');
-    expect(resp.ok).toBe(true);
-  });
-});

package/tests/client/js/storage/workers/toml-parser.test.ts

@@ -1,169 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-//////////////////////////////
-// TOML parser worker tests
-//
-// The worker registers a self.addEventListener('message', ...) listener that
-// handles 'parse', 'parse-batch', and 'stringify' message types. We stub self
-// before importing the module, capture the handler, then invoke it with plain
-// event-like objects rather than real MessageEvent instances.
-//
-// Real MessageEvent validates its payload structure at construction time;
-// plain objects are used instead so tests remain in Node.js without a real
-// Worker context.
-//////////////////////////////
-
-// ── Self mock ──────────────────────────────────────────────────────────────
-
-// The handler type uses a loose event shape: the worker reads event.data
-// only, so we only need to match that property.
-let messageHandler:
-  | ((event: { data: Record<string, unknown> }) => void)
-  | null = null;
-const selfPostMessage = vi.fn();
-
-vi.stubGlobal('self', {
-  addEventListener: vi.fn((type: string, handler: unknown) => {
-    if (type === 'message') {
-      messageHandler = handler as (event: {
-        data: Record<string, unknown>;
-      }) => void;
-    }
-  }),
-  postMessage: selfPostMessage,
-});
-
-// ── Import module (after stubs) ────────────────────────────────────────────
-
-await import('../../../../../src/client/js/storage/workers/toml-parser');
-
-// ── Helpers ────────────────────────────────────────────────────────────────
-
-/**
- * Dispatches a fake event to the captured handler by calling it directly with a plain object.
- * MessageEvent construction is bypassed because the constructor validates its payload.
- * @param {Record<string, unknown>} data - The message data payload
- * @return {void}
- */
-function dispatch(data: Record<string, unknown>): void {
-  messageHandler!({ data });
-}
-
-// ── Tests ─────────────────────────────────────────────────────────────────────
-
-describe('toml-parser worker', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('registers a message listener on self', () => {
-    expect(messageHandler).toBeTypeOf('function');
-  });
-
-  describe('parse message', () => {
-    it('parses a valid TOML string and posts a parse-result with the data', () => {
-      dispatch({
-        type: 'parse',
-        id: 'p1',
-        content: 'title = "Hello"\ncount = 42\n',
-      });
-
-      expect(selfPostMessage).toHaveBeenCalledWith({
-        type: 'parse-result',
-        id: 'p1',
-        ok: true,
-        data: { title: 'Hello', count: 42 },
-      });
-    });
-
-    it('posts a parse-result with ok: false for invalid TOML', () => {
-      dispatch({
-        type: 'parse',
-        id: 'p2',
-        content: 'this is not = = valid toml',
-      });
-
-      const call = selfPostMessage.mock.calls[0][0];
-      expect(call.type).toBe('parse-result');
-      expect(call.id).toBe('p2');
-      expect(call.ok).toBe(false);
-      expect(typeof call.error).toBe('string');
-    });
-  });
-
-  describe('parse-batch message', () => {
-    it('parses a batch of TOML strings and posts a parse-batch-result with a results map', () => {
-      dispatch({
-        type: 'parse-batch',
-        id: 'b1',
-        items: [
-          { key: 'alpha', content: 'value = 1\n' },
-          { key: 'beta', content: 'value = 2\n' },
-        ],
-      });
-
-      expect(selfPostMessage).toHaveBeenCalledWith({
-        type: 'parse-batch-result',
-        id: 'b1',
-        ok: true,
-        results: {
-          alpha: { value: 1 },
-          beta: { value: 2 },
-        },
-      });
-    });
-
-    it('posts a parse-batch-result with ok: false when a batch item is invalid', () => {
-      dispatch({
-        type: 'parse-batch',
-        id: 'b2',
-        items: [{ key: 'bad', content: 'not = = valid' }],
-      });
-
-      const call = selfPostMessage.mock.calls[0][0];
-      expect(call.type).toBe('parse-batch-result');
-      expect(call.id).toBe('b2');
-      expect(call.ok).toBe(false);
-      expect(typeof call.error).toBe('string');
-    });
-  });
-
-  describe('stringify message', () => {
-    it('serializes an object to a TOML string and posts a stringify-result', () => {
-      dispatch({
-        type: 'stringify',
-        id: 's1',
-        data: { name: 'test', count: 5 },
-      });
-
-      const call = selfPostMessage.mock.calls[0][0];
-      expect(call.type).toBe('stringify-result');
-      expect(call.id).toBe('s1');
-      expect(call.ok).toBe(true);
-      expect(typeof call.content).toBe('string');
-      // Verify round-trip: the output must contain the original values
-      expect(call.content).toContain('name');
-      expect(call.content).toContain('test');
-    });
-
-    it('posts a stringify-result with ok: false when serialization fails', () => {
-      // smol-toml cannot serialize values that are not TOML-compatible (e.g. undefined)
-      dispatch({
-        type: 'stringify',
-        id: 's2',
-        // A nested object with a circular-ish unsupported value
-        data: { bad: undefined as unknown },
-      });
-
-      // smol-toml may succeed (skipping undefined) or fail — either way the
-      // response must be a stringify-result with a defined id
-      const call = selfPostMessage.mock.calls[0][0];
-      expect(call.type).toBe('stringify-result');
-      expect(call.id).toBe('s2');
-    });
-  });
-});

package/tests/client/js/storage/workers/yaml-parser.test.ts

@@ -1,168 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-//////////////////////////////
-// YAML parser worker tests
-//
-// The worker registers a self.addEventListener('message', ...) listener that
-// handles 'parse', 'parse-batch', and 'stringify' message types. We stub self
-// before importing the module, capture the handler, then invoke it with plain
-// event-like objects rather than real MessageEvent instances.
-//
-// Real MessageEvent validates that items in the `ports` array are actual
-// MessagePort instances — since we cannot construct those in Node.js without
-// a real Worker context, we pass plain objects that satisfy the fields the
-// worker code actually reads (event.data).
-//////////////////////////////
-
-// ── Self mock ──────────────────────────────────────────────────────────────
-
-// The handler type uses a loose event shape: real MessageEvent validates
-// that ports[] entries are actual MessagePort instances, which we cannot
-// construct in Node.js. We type the captured handler loosely and call it
-// with plain objects that mirror the fields the worker actually reads.
-let messageHandler:
-  | ((event: { data: Record<string, unknown> }) => Promise<void>)
-  | null = null;
-const selfPostMessage = vi.fn();
-
-vi.stubGlobal('self', {
-  addEventListener: vi.fn((type: string, handler: unknown) => {
-    if (type === 'message') {
-      messageHandler = handler as (event: {
-        data: Record<string, unknown>;
-      }) => Promise<void>;
-    }
-  }),
-  postMessage: selfPostMessage,
-});
-
-// ── Import module (after stubs) ────────────────────────────────────────────
-
-await import('../../../../../src/client/js/storage/workers/yaml-parser');
-
-// ── Helpers ────────────────────────────────────────────────────────────────
-
-/**
- * Dispatches a fake event to the captured handler by calling it directly
- * with a plain object. We bypass MessageEvent construction because the
- * constructor validates that ports[] entries are real MessagePort instances.
- * @param {Record<string, unknown>} data - The message data payload
- * @return {Promise<void>}
- */
-async function dispatch(data: Record<string, unknown>): Promise<void> {
-  await messageHandler!({ data });
-}
-
-// ── Tests ─────────────────────────────────────────────────────────────────────
-
-describe('yaml-parser worker', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('registers a message listener on self', () => {
-    expect(messageHandler).toBeTypeOf('function');
-  });
-
-  describe('parse message', () => {
-    it('parses a valid YAML string and posts a parse-result with ok: true', async () => {
-      await dispatch({
-        type: 'parse',
-        id: 'req-1',
-        content: 'title: Hello World\ncount: 42',
-      });
-
-      expect(selfPostMessage).toHaveBeenCalledOnce();
-      const msg = selfPostMessage.mock.calls[0][0];
-      expect(msg.type).toBe('parse-result');
-      expect(msg.id).toBe('req-1');
-      expect(msg.ok).toBe(true);
-      expect(msg.data).toEqual({ title: 'Hello World', count: 42 });
-    });
-
-    it('posts a parse-result with ok: false for invalid YAML', async () => {
-      await dispatch({
-        type: 'parse',
-        id: 'req-err',
-        // Intentionally malformed: tab characters are not allowed in YAML
-        content: 'key:\n\t- bad',
-      });
-
-      expect(selfPostMessage).toHaveBeenCalledOnce();
-      const msg = selfPostMessage.mock.calls[0][0];
-      expect(msg.type).toBe('parse-result');
-      expect(msg.id).toBe('req-err');
-      expect(msg.ok).toBe(false);
-      expect(typeof msg.error).toBe('string');
-    });
-  });
-
-  describe('parse-batch message', () => {
-    it('parses a batch of YAML strings and posts a parse-batch-result with ok: true', async () => {
-      await dispatch({
-        type: 'parse-batch',
-        id: 'batch-1',
-        items: [
-          { key: 'file-a', content: 'title: File A' },
-          { key: 'file-b', content: 'title: File B\nactive: true' },
-        ],
-      });
-
-      expect(selfPostMessage).toHaveBeenCalledOnce();
-      const msg = selfPostMessage.mock.calls[0][0];
-      expect(msg.type).toBe('parse-batch-result');
-      expect(msg.id).toBe('batch-1');
-      expect(msg.ok).toBe(true);
-      expect(msg.results).toEqual({
-        'file-a': { title: 'File A' },
-        'file-b': { title: 'File B', active: true },
-      });
-    });
-
-    it('posts a parse-batch-result with ok: false when any item has invalid YAML', async () => {
-      await dispatch({
-        type: 'parse-batch',
-        id: 'batch-err',
-        items: [
-          { key: 'good', content: 'title: Good' },
-          { key: 'bad', content: 'key:\n\t- bad' },
-        ],
-      });
-
-      expect(selfPostMessage).toHaveBeenCalledOnce();
-      const msg = selfPostMessage.mock.calls[0][0];
-      expect(msg.type).toBe('parse-batch-result');
-      expect(msg.id).toBe('batch-err');
-      expect(msg.ok).toBe(false);
-      expect(typeof msg.error).toBe('string');
-    });
-  });
-
-  describe('stringify message', () => {
-    it('serializes an object to a YAML string and posts a stringify-result with ok: true', async () => {
-      await dispatch({
-        type: 'stringify',
-        id: 'str-1',
-        data: { title: 'My Post', tags: ['a', 'b'], count: 7 },
-      });
-
-      expect(selfPostMessage).toHaveBeenCalledOnce();
-      const msg = selfPostMessage.mock.calls[0][0];
-      expect(msg.type).toBe('stringify-result');
-      expect(msg.id).toBe('str-1');
-      expect(msg.ok).toBe(true);
-      expect(typeof msg.content).toBe('string');
-      // Verify the serialized YAML round-trips back to the original data
-      const { load } = await import('js-yaml');
-      expect(load(msg.content)).toEqual({
-        title: 'My Post',
-        tags: ['a', 'b'],
-        count: 7,
-      });
-    });
-  });
-});