nebula-cms 0.1.0

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

@@ -0,0 +1,299 @@
+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

@@ -0,0 +1,169 @@
+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

@@ -0,0 +1,168 @@
+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,
+      });
+    });
+  });
+});