nebula-cms 0.1.0

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

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+
+//////////////////////////////
+// adapter.ts type-export tests
+//
+// adapter.ts is a pure type/interface file — there is no runtime code to
+// exercise. These tests confirm that the named exports are importable and
+// that the module resolves without errors, providing a compile-time
+// regression guard.
+//////////////////////////////
+
+import type {
+  FileEntry,
+  FileWrite,
+  StorageAdapter,
+  StorageRequest,
+  StorageResponse,
+} from '../../../../src/client/js/storage/adapter';
+
+describe('adapter type exports', () => {
+  it('FileEntry type is usable as a value shape', () => {
+    // Constructing a conformant object validates the type at compile time
+    const entry: FileEntry = { filename: 'post.md', content: '# Hello' };
+    expect(entry.filename).toBe('post.md');
+    expect(entry.content).toBe('# Hello');
+  });
+
+  it('FileWrite type is usable as a value shape', () => {
+    const write: FileWrite = {
+      collection: 'posts',
+      filename: 'post.md',
+      content: '# Hello',
+    };
+    expect(write.collection).toBe('posts');
+  });
+
+  it('StorageAdapter interface shape has the expected method names', () => {
+    // Verify the interface contract can be satisfied by a plain object
+    const adapter: StorageAdapter = {
+      listFiles: async () => [],
+      readFile: async () => '',
+      writeFile: async () => undefined,
+      writeFiles: async () => undefined,
+      deleteFile: async () => undefined,
+    };
+    expect(typeof adapter.listFiles).toBe('function');
+    expect(typeof adapter.readFile).toBe('function');
+    expect(typeof adapter.writeFile).toBe('function');
+    expect(typeof adapter.writeFiles).toBe('function');
+    expect(typeof adapter.deleteFile).toBe('function');
+  });
+
+  it('StorageRequest union members resolve without type errors', () => {
+    const init: StorageRequest = {
+      type: 'init',
+      backend: { type: 'github', token: 'tok', repo: 'owner/repo' },
+    };
+    const list: StorageRequest = {
+      type: 'listFiles',
+      collection: 'posts',
+      extensions: ['.md', '.mdx'],
+    };
+    const read: StorageRequest = {
+      type: 'readFile',
+      collection: 'posts',
+      filename: 'a.md',
+    };
+    const write: StorageRequest = {
+      type: 'writeFile',
+      collection: 'posts',
+      filename: 'a.md',
+      content: 'body',
+    };
+    const writeMany: StorageRequest = {
+      type: 'writeFiles',
+      files: [{ collection: 'posts', filename: 'a.md', content: 'body' }],
+    };
+    const del: StorageRequest = {
+      type: 'deleteFile',
+      collection: 'posts',
+      filename: 'old.md',
+    };
+    const teardown: StorageRequest = { type: 'teardown' };
+
+    expect(init.type).toBe('init');
+    expect(list.type).toBe('listFiles');
+    expect(read.type).toBe('readFile');
+    expect(write.type).toBe('writeFile');
+    expect(writeMany.type).toBe('writeFiles');
+    expect(del.type).toBe('deleteFile');
+    expect(teardown.type).toBe('teardown');
+  });
+
+  it('StorageResponse union members resolve without type errors', () => {
+    const ok: StorageResponse = { type: 'init', ok: true };
+    const fail: StorageResponse = {
+      type: 'init',
+      ok: false,
+      error: 'bad token',
+    };
+    const delOk: StorageResponse = { type: 'deleteFile', ok: true };
+    const delFail: StorageResponse = {
+      type: 'deleteFile',
+      ok: false,
+      error: 'not found',
+    };
+    const portConn: StorageResponse = { type: 'port-connected' };
+
+    expect(ok.type).toBe('init');
+    expect(fail.ok).toBe(false);
+    expect(delOk.type).toBe('deleteFile');
+    expect(delFail.ok).toBe(false);
+    expect(portConn.type).toBe('port-connected');
+  });
+});

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

@@ -0,0 +1,250 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+//////////////////////////////
+// StorageClient tests
+//
+// StorageClient wraps a MessagePort with request/response correlation.
+// We simulate the port with a plain EventTarget + a manual postMessage spy
+// so we can fire synthetic message events and verify that calls are
+// matched back to their originating promise.
+//////////////////////////////
+
+import { StorageClient } from '../../../../src/client/js/storage/client';
+import type { StorageResponse } from '../../../../src/client/js/storage/adapter';
+import { makeClientMockPort as makeMockPort } from './mock-port';
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe('StorageClient', () => {
+  let postSpy: ReturnType<typeof vi.fn>;
+  let respond: (data: StorageResponse & { _id?: string }) => void;
+  let client: StorageClient;
+
+  beforeEach(() => {
+    const mock = makeMockPort();
+    postSpy = mock.postSpy;
+    respond = mock.respond;
+    client = new StorageClient(mock.port);
+  });
+
+  it('calls port.start() in the constructor', () => {
+    const mock = makeMockPort();
+    // start() is called during construction
+    new StorageClient(mock.port);
+    expect(
+      (mock.port.start as ReturnType<typeof vi.fn>).mock.calls.length,
+    ).toBe(1);
+  });
+
+  describe('init', () => {
+    it('sends an init message and resolves when a matching ok response arrives', async () => {
+      const promise = client.init({
+        type: 'init',
+        backend: { type: 'github', token: 'tok', repo: 'owner/repo' },
+      });
+
+      // Grab the _id from the sent message
+      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
+      respond({ type: 'init', ok: true, _id: sentMsg._id } as any);
+
+      await expect(promise).resolves.toBeUndefined();
+    });
+
+    it('rejects when the worker responds with ok: false', async () => {
+      const promise = client.init({
+        type: 'init',
+        backend: { type: 'github', token: 'tok', repo: 'owner/repo' },
+      });
+
+      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
+      respond({
+        type: 'init',
+        ok: false,
+        error: 'bad credentials',
+        _id: sentMsg._id,
+      } as any);
+
+      await expect(promise).rejects.toThrow('bad credentials');
+    });
+  });
+
+  describe('listFiles', () => {
+    it('resolves with the files array from the worker response', async () => {
+      const files = [{ filename: 'a.md', content: 'A' }];
+      const promise = client.listFiles('posts', ['.md', '.mdx']);
+
+      const sentMsg = postSpy.mock.calls[0][0] as {
+        _id: string;
+        type: string;
+        collection: string;
+        extensions: string[];
+      };
+      expect(sentMsg.type).toBe('listFiles');
+      expect(sentMsg.collection).toBe('posts');
+      expect(sentMsg.extensions).toEqual(['.md', '.mdx']);
+
+      respond({
+        type: 'listFiles',
+        ok: true,
+        files,
+        _id: sentMsg._id,
+      } as any);
+
+      const result = await promise;
+      expect(result).toEqual(files);
+    });
+
+    it('rejects on error response', async () => {
+      const promise = client.listFiles('posts', ['.md', '.mdx']);
+      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
+      respond({
+        type: 'listFiles',
+        ok: false,
+        error: 'storage error',
+        _id: sentMsg._id,
+      } as any);
+      await expect(promise).rejects.toThrow('storage error');
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('resolves when the worker responds with ok: true', async () => {
+      const promise = client.deleteFile('posts', 'old.md');
+      const sentMsg = postSpy.mock.calls[0][0] as {
+        _id: string;
+        type: string;
+        collection: string;
+        filename: string;
+      };
+      expect(sentMsg.type).toBe('deleteFile');
+      expect(sentMsg.collection).toBe('posts');
+      expect(sentMsg.filename).toBe('old.md');
+      respond({ type: 'deleteFile', ok: true, _id: sentMsg._id } as any);
+      await expect(promise).resolves.toBeUndefined();
+    });
+
+    it('rejects on error response', async () => {
+      const promise = client.deleteFile('posts', 'missing.md');
+      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
+      respond({
+        type: 'deleteFile',
+        ok: false,
+        error: 'File not found',
+        _id: sentMsg._id,
+      } as any);
+      await expect(promise).rejects.toThrow('File not found');
+    });
+  });
+
+  describe('readFile', () => {
+    it('resolves with the content from the worker response', async () => {
+      const promise = client.readFile('posts', 'hello.md');
+
+      const sentMsg = postSpy.mock.calls[0][0] as {
+        _id: string;
+        collection: string;
+        filename: string;
+      };
+      expect(sentMsg.collection).toBe('posts');
+      expect(sentMsg.filename).toBe('hello.md');
+
+      respond({
+        type: 'readFile',
+        ok: true,
+        content: '# Hello',
+        _id: sentMsg._id,
+      } as any);
+
+      const result = await promise;
+      expect(result).toBe('# Hello');
+    });
+  });
+
+  describe('writeFile', () => {
+    it('resolves when the worker responds with ok: true', async () => {
+      const promise = client.writeFile('posts', 'test.md', 'body');
+      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
+      respond({ type: 'writeFile', ok: true, _id: sentMsg._id } as any);
+      await expect(promise).resolves.toBeUndefined();
+    });
+  });
+
+  describe('writeFiles', () => {
+    it('sends the files array and resolves on ok response', async () => {
+      const files = [
+        { collection: 'posts', filename: 'a.md', content: 'A' },
+        { collection: 'posts', filename: 'b.md', content: 'B' },
+      ];
+      const promise = client.writeFiles(files);
+
+      const sentMsg = postSpy.mock.calls[0][0] as {
+        _id: string;
+        type: string;
+        files: typeof files;
+      };
+      expect(sentMsg.type).toBe('writeFiles');
+      expect(sentMsg.files).toEqual(files);
+
+      respond({ type: 'writeFiles', ok: true, _id: sentMsg._id } as any);
+      await expect(promise).resolves.toBeUndefined();
+    });
+  });
+
+  describe('teardown', () => {
+    it('sends a teardown message and resolves on ok response', async () => {
+      const promise = client.teardown();
+      const sentMsg = postSpy.mock.calls[0][0] as {
+        _id: string;
+        type: string;
+      };
+      expect(sentMsg.type).toBe('teardown');
+      respond({ type: 'teardown', ok: true, _id: sentMsg._id } as any);
+      await expect(promise).resolves.toBeUndefined();
+    });
+  });
+
+  describe('message correlation', () => {
+    it('ignores broadcast messages without an _id', async () => {
+      // port-connected has no _id and should not reject any pending promise
+      const promise = client.listFiles('posts', ['.md', '.mdx']);
+      respond({ type: 'port-connected' } as any);
+      // Promise should still be pending — resolve it now with a proper response
+      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
+      respond({
+        type: 'listFiles',
+        ok: true,
+        files: [],
+        _id: sentMsg._id,
+      } as any);
+      await expect(promise).resolves.toEqual([]);
+    });
+
+    it('increments _id for each request so concurrent calls are independent', async () => {
+      const p1 = client.listFiles('posts', ['.md', '.mdx']);
+      const p2 = client.readFile('posts', 'a.md');
+
+      const msg1 = postSpy.mock.calls[0][0] as { _id: string };
+      const msg2 = postSpy.mock.calls[1][0] as { _id: string };
+      expect(msg1._id).not.toBe(msg2._id);
+
+      // Resolve in reverse order to prove there's no ordering dependency
+      respond({
+        type: 'readFile',
+        ok: true,
+        content: 'content',
+        _id: msg2._id,
+      } as any);
+      respond({
+        type: 'listFiles',
+        ok: true,
+        files: [{ filename: 'x.md', content: 'x' }],
+        _id: msg1._id,
+      } as any);
+
+      const list = await p1;
+      const read = await p2;
+      expect(list[0].filename).toBe('x.md');
+      expect(read).toBe('content');
+    });
+  });
+});

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

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+
+//////////////////////////////
+// openDB tests
+//
+// Uses fake-indexeddb (polyfilled via the setup file) to exercise the
+// actual IDB open/upgrade logic in a Node.js environment.
+//////////////////////////////
+
+import { openDB } from '../../../../src/client/js/storage/db';
+
+describe('openDB', () => {
+  it('resolves to an IDBDatabase instance', async () => {
+    const db = await openDB();
+    expect(db).toBeDefined();
+    expect(typeof db.transaction).toBe('function');
+  });
+
+  it('creates a "handles" object store', async () => {
+    const db = await openDB();
+    expect(db.objectStoreNames.contains('handles')).toBe(true);
+  });
+
+  it('creates a "drafts" object store', async () => {
+    const db = await openDB();
+    expect(db.objectStoreNames.contains('drafts')).toBe(true);
+  });
+
+  it('returns a usable database that can perform readwrite transactions on "handles"', async () => {
+    const db = await openDB();
+    // A successful transaction confirms the store was created with correct configuration
+    await new Promise<void>((resolve, reject) => {
+      const tx = db.transaction('handles', 'readwrite');
+      tx.objectStore('handles').put({ test: true }, 'probe-key');
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  });
+
+  it('returns a usable database that can perform readwrite transactions on "drafts"', async () => {
+    const db = await openDB();
+    // The drafts store uses { keyPath: 'id' }, so the object must include an id field
+    await new Promise<void>((resolve, reject) => {
+      const tx = db.transaction('drafts', 'readwrite');
+      tx.objectStore('drafts').put({ id: 'probe-draft', data: 'x' });
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  });
+
+  it('subsequent calls return a database with the same stores', async () => {
+    const db1 = await openDB();
+    const db2 = await openDB();
+    expect(db2.objectStoreNames.contains('handles')).toBe(true);
+    expect(db2.objectStoreNames.contains('drafts')).toBe(true);
+    db1.close();
+    db2.close();
+  });
+});