nebula-cms 0.1.3 → 0.1.4

package/tests/client/js/state/schema.test.ts

@@ -1,266 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-/*
-//////////////////////////////
-// virtual:nebula/collections mock
-// The schema module fetches URLs stored in this map. We stub both the
-// import and the global fetch so no real network requests are made.
-//////////////////////////////
-*/
-
-vi.mock('virtual:nebula/collections', () => ({
-  default: {
-    posts: 'https://fake.test/posts.schema.json',
-    products: 'https://fake.test/products.schema.json',
-  },
-}));
-
-import {
-  fetchSchema,
-  schema,
-  clearSchema,
-  prefetchAllSchemas,
-  collectionHasDates,
-  getCollectionTitle,
-  getCollectionDescription,
-} from '../../../../src/client/js/state/schema.svelte';
-
-/*
-//////////////////////////////
-// Mock schema fixtures
-//////////////////////////////
-*/
-
-/** Posts schema — includes a date-time field for date-sort testing and root-level title/description. */
-const POSTS_SCHEMA = {
-  title: 'Blog Posts',
-  description: 'Articles published on the blog',
-  type: 'object',
-  properties: {
-    title: { type: 'string' },
-    publishedAt: { type: 'string', format: 'date-time' },
-  },
-};
-
-/** Products schema — no date-time fields. */
-const PRODUCTS_SCHEMA = {
-  type: 'object',
-  properties: {
-    name: { type: 'string' },
-    price: { type: 'number' },
-  },
-};
-
-/**
- * Builds a minimal fetch mock that returns the appropriate schema JSON
- * based on the requested URL.
- * @return {ReturnType<typeof vi.fn>} A vitest spy implementing the fetch interface
- */
-function makeFetchMock() {
-  return vi.fn((url: string) => {
-    const body = url.includes('posts')
-      ? POSTS_SCHEMA
-      : url.includes('products')
-        ? PRODUCTS_SCHEMA
-        : {};
-    return Promise.resolve({
-      json: () => Promise.resolve(body),
-    } as Response);
-  });
-}
-
-/*
-//////////////////////////////
-// schema / clearSchema
-//////////////////////////////
-*/
-
-describe('schema', () => {
-  beforeEach(() => {
-    clearSchema();
-  });
-
-  it('is null before any schema is loaded', () => {
-    expect(schema.active).toBeNull();
-  });
-});
-
-describe('clearSchema', () => {
-  beforeEach(() => {
-    vi.stubGlobal('fetch', makeFetchMock());
-  });
-
-  it('resets the active schema to null', async () => {
-    await fetchSchema('posts');
-    expect(schema.active).not.toBeNull();
-    clearSchema();
-    expect(schema.active).toBeNull();
-  });
-});
-
-/*
-//////////////////////////////
-// fetchSchema
-//////////////////////////////
-*/
-
-describe('fetchSchema', () => {
-  beforeEach(() => {
-    clearSchema();
-    vi.stubGlobal('fetch', makeFetchMock());
-  });
-
-  it('sets the active schema after fetching', async () => {
-    await fetchSchema('posts');
-    expect(schema.active).toEqual(POSTS_SCHEMA);
-  });
-
-  it('loads the correct schema for a different collection', async () => {
-    await fetchSchema('products');
-    expect(schema.active).toEqual(PRODUCTS_SCHEMA);
-  });
-
-  it('does nothing when the collection is not in virtual:nebula/collections', async () => {
-    clearSchema();
-    await fetchSchema('nonexistent');
-    expect(schema.active).toBeNull();
-  });
-
-  it('returns the same schema object on repeated calls (cache consistency)', async () => {
-    // The module-level Map cache may already hold 'posts' from a prior test.
-    // What matters is that the reactive schema state is consistent: calling
-    // fetchSchema twice for the same collection leaves it pointing at the
-    // same cached object.
-    await fetchSchema('posts');
-    const first = schema.active;
-
-    await fetchSchema('posts');
-    const second = schema.active;
-
-    expect(second).toEqual(first);
-  });
-});
-
-/*
-//////////////////////////////
-// prefetchAllSchemas
-//////////////////////////////
-*/
-
-describe('prefetchAllSchemas', () => {
-  beforeEach(() => {
-    clearSchema();
-    vi.stubGlobal('fetch', makeFetchMock());
-  });
-
-  it('populates the schema state for each known collection', async () => {
-    // After prefetch, fetchSchema for any known collection should set the
-    // reactive schema state — serving from the freshly populated cache.
-    await prefetchAllSchemas();
-
-    clearSchema();
-    await fetchSchema('posts');
-    expect(schema.active).toEqual(POSTS_SCHEMA);
-
-    clearSchema();
-    await fetchSchema('products');
-    expect(schema.active).toEqual(PRODUCTS_SCHEMA);
-  });
-
-  it('caches schemas such that schema reflects the last fetched collection', async () => {
-    await prefetchAllSchemas();
-
-    await fetchSchema('posts');
-    expect(schema.active).toEqual(POSTS_SCHEMA);
-
-    await fetchSchema('products');
-    expect(schema.active).toEqual(PRODUCTS_SCHEMA);
-  });
-});
-
-/*
-//////////////////////////////
-// collectionHasDates
-//////////////////////////////
-*/
-
-describe('collectionHasDates', () => {
-  beforeEach(() => {
-    vi.stubGlobal('fetch', makeFetchMock());
-  });
-
-  it('returns false when the collection schema is not yet cached', () => {
-    // Only relevant before any prefetch; if cache was populated by prior
-    // tests this may be true — we verify the type at minimum.
-    expect(typeof collectionHasDates('uncached')).toBe('boolean');
-  });
-
-  it('returns true when at least one property uses the date-time format', async () => {
-    await prefetchAllSchemas();
-    expect(collectionHasDates('posts')).toBe(true);
-  });
-
-  it('returns false when no property uses the date-time format', async () => {
-    await prefetchAllSchemas();
-    expect(collectionHasDates('products')).toBe(false);
-  });
-
-  it('returns false for an unknown collection even after prefetch', async () => {
-    await prefetchAllSchemas();
-    expect(collectionHasDates('unknown')).toBe(false);
-  });
-});
-
-/*
-//////////////////////////////
-// getCollectionTitle
-//////////////////////////////
-*/
-
-describe('getCollectionTitle', () => {
-  beforeEach(() => {
-    vi.stubGlobal('fetch', makeFetchMock());
-  });
-
-  it('returns the title string when schema has a title', async () => {
-    await prefetchAllSchemas();
-    expect(getCollectionTitle('posts')).toBe('Blog Posts');
-  });
-
-  it('returns null when schema has no title', async () => {
-    await prefetchAllSchemas();
-    expect(getCollectionTitle('products')).toBeNull();
-  });
-
-  it('returns null when schema is not cached', () => {
-    expect(getCollectionTitle('uncached')).toBeNull();
-  });
-});
-
-/*
-//////////////////////////////
-// getCollectionDescription
-//////////////////////////////
-*/
-
-describe('getCollectionDescription', () => {
-  beforeEach(() => {
-    vi.stubGlobal('fetch', makeFetchMock());
-  });
-
-  it('returns the description string when schema has a description', async () => {
-    await prefetchAllSchemas();
-    expect(getCollectionDescription('posts')).toBe(
-      'Articles published on the blog',
-    );
-  });
-
-  it('returns null when schema has no description', async () => {
-    await prefetchAllSchemas();
-    expect(getCollectionDescription('products')).toBeNull();
-  });
-
-  it('returns null when schema is not cached', () => {
-    expect(getCollectionDescription('uncached')).toBeNull();
-  });
-});

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

@@ -1,328 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-/*
-//////////////////////////////
-// SharedWorker / Worker stubs — must be established BEFORE any module import
-//
-// state.svelte.ts calls `new SharedWorker(...)` at the module top level.
-// vi.hoisted() runs before any import in this file, so the globals are set
-// before Vitest resolves the static imports below. Without hoisting,
-// vi.stubGlobal() would run after the module's top-level code and the
-// constructor call would throw ReferenceError.
-//////////////////////////////
-*/
-
-const { FakeSharedWorker, FakeWorker } = vi.hoisted(() => {
-  /** Minimal MessagePort stub that satisfies the StorageClient constructor. */
-  class FakeMessagePort {
-    addEventListener = vi.fn();
-    postMessage = vi.fn();
-    start = vi.fn();
-  }
-
-  /** Minimal SharedWorker stub used in place of the real browser API. */
-  class FakeSharedWorker {
-    port = new FakeMessagePort();
-  }
-
-  /** Minimal Worker stub used in place of the real browser API. */
-  class FakeWorker {
-    addEventListener = vi.fn();
-    postMessage = vi.fn();
-    terminate = vi.fn();
-  }
-
-  vi.stubGlobal('SharedWorker', FakeSharedWorker);
-  vi.stubGlobal('Worker', FakeWorker);
-
-  return { FakeSharedWorker, FakeWorker };
-});
-
-/*
-//////////////////////////////
-// Module-level mocks
-//
-// state.svelte.ts instantiates SharedWorker and StorageClient at the top
-// level when the module is first imported. All dependencies that trigger
-// side-effects must be mocked via vi.mock() BEFORE any import of the module
-// under test. vi.mock() calls are hoisted by Vitest automatically.
-//////////////////////////////
-*/
-
-vi.mock('virtual:nebula/collections', () => ({
-  default: {
-    posts: 'https://fake.test/posts.schema.json',
-    products: 'https://fake.test/products.schema.json',
-    articles: 'https://fake.test/articles.schema.json',
-  },
-}));
-
-vi.mock('../../../../src/client/js/storage/storage', () => ({
-  loadBackend: vi.fn(async () => null),
-  saveBackend: vi.fn(async () => undefined),
-  clearBackend: vi.fn(async () => undefined),
-}));
-
-vi.mock('../../../../src/client/js/storage/client', () => {
-  /** Stub StorageClient whose methods all resolve immediately. */
-  class StorageClient {
-    constructor(_port: MessagePort) {}
-
-    /** @return {Promise<void>} */
-    async init(_config: unknown): Promise<void> {}
-
-    /** @return {Promise<void>} */
-    async teardown(): Promise<void> {}
-
-    /** @return {Promise<never[]>} */
-    async listFiles(
-      _collection: string,
-      _extensions: string[],
-    ): Promise<never[]> {
-      return [];
-    }
-
-    /** @return {Promise<string>} */
-    async readFile(_collection: string, _filename: string): Promise<string> {
-      return '';
-    }
-
-    /** @return {Promise<void>} */
-    async writeFile(
-      _collection: string,
-      _filename: string,
-      _content: string,
-    ): Promise<void> {}
-
-    /** @return {Promise<void>} */
-    async writeFiles(_files: unknown[]): Promise<void> {}
-
-    /** @return {Promise<void>} */
-    async deleteFile(_collection: string, _filename: string): Promise<void> {}
-  }
-  return { StorageClient };
-});
-
-vi.mock('../../../../src/client/js/state/router.svelte', () => ({
-  nav: {
-    get route() {
-      return { view: 'home' as const };
-    },
-  },
-  navigate: vi.fn(),
-  adminPath: vi.fn((...segments) =>
-    segments.length === 0 ? '/admin' : '/admin/' + segments.join('/'),
-  ),
-}));
-
-vi.mock('../../../../src/client/js/drafts/merge.svelte', () => ({
-  drafts: {
-    get all() {
-      return [];
-    },
-    get outdated() {
-      return {};
-    },
-  },
-  mergeDrafts: vi.fn(async () => undefined),
-  refreshDrafts: vi.fn(async () => undefined),
-  resetDraftMerge: vi.fn(),
-}));
-
-vi.mock('../../../../src/client/js/state/schema.svelte', () => ({
-  getSchemaExtensions: vi.fn(() => ['.md', '.mdx']),
-}));
-
-/*
-//////////////////////////////
-// Dynamic imports after stubs are in place
-//////////////////////////////
-*/
-
-import {
-  collections,
-  backend,
-  content,
-  disconnect,
-  updateContentItem,
-  loadCollection,
-} from '../../../../src/client/js/state/state.svelte';
-
-import { clearBackend } from '../../../../src/client/js/storage/storage';
-import { navigate } from '../../../../src/client/js/state/router.svelte';
-import { resetDraftMerge } from '../../../../src/client/js/drafts/merge.svelte';
-import { getSchemaExtensions } from '../../../../src/client/js/state/schema.svelte';
-
-/*
-//////////////////////////////
-// collections
-//////////////////////////////
-*/
-
-describe('collections', () => {
-  it('returns a sorted list of collection names from virtual:nebula/collections', () => {
-    expect(collections).toEqual(['articles', 'posts', 'products']);
-  });
-
-  it('is a stable reference with consistent contents', () => {
-    // The module holds a const array — verify it is stable
-    expect(collections).toEqual(['articles', 'posts', 'products']);
-  });
-});
-
-/*
-//////////////////////////////
-// Initial reactive state
-//////////////////////////////
-*/
-
-describe('initial state', () => {
-  it('ready is false before any backend is connected', () => {
-    expect(backend.ready).toBe(false);
-  });
-
-  it('type is null before any backend is connected', () => {
-    expect(backend.type).toBeNull();
-  });
-
-  it('permission is "denied" initially', () => {
-    expect(backend.permission).toBe('denied');
-  });
-
-  it('list is an empty array initially', () => {
-    expect(content.list).toEqual([]);
-  });
-
-  it('error is null initially', () => {
-    expect(content.error).toBeNull();
-  });
-
-  it('loading is false initially', () => {
-    expect(content.loading).toBe(false);
-  });
-});
-
-/*
-//////////////////////////////
-// disconnect
-//////////////////////////////
-*/
-
-describe('disconnect', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('calls clearBackend to remove stored credentials', async () => {
-    await disconnect();
-    expect(clearBackend).toHaveBeenCalled();
-  });
-
-  it('calls resetDraftMerge', async () => {
-    await disconnect();
-    expect(resetDraftMerge).toHaveBeenCalled();
-  });
-
-  it('navigates to /admin after disconnecting', async () => {
-    await disconnect();
-    expect(navigate).toHaveBeenCalledWith('/admin');
-  });
-
-  it('resets ready to false', async () => {
-    await disconnect();
-    expect(backend.ready).toBe(false);
-  });
-
-  it('resets type to null', async () => {
-    await disconnect();
-    expect(backend.type).toBeNull();
-  });
-
-  it('resets permission to "denied"', async () => {
-    await disconnect();
-    expect(backend.permission).toBe('denied');
-  });
-
-  it('resets list to an empty array', async () => {
-    await disconnect();
-    expect(content.list).toEqual([]);
-  });
-
-  it('resets error to null', async () => {
-    await disconnect();
-    expect(content.error).toBeNull();
-  });
-
-  it('resets loading to false', async () => {
-    await disconnect();
-    expect(content.loading).toBe(false);
-  });
-});
-
-/*
-//////////////////////////////
-// updateContentItem
-//////////////////////////////
-*/
-
-describe('updateContentItem', () => {
-  it('is a callable function (smoke test — content list is empty by default)', () => {
-    // updateContentItem operates on the current contentList. With no items
-    // loaded it should be a no-op rather than throw.
-    expect(() => {
-      updateContentItem('some-file.md', { title: 'Updated' });
-    }).not.toThrow();
-  });
-
-  it('does not change the content list when no matching filename exists', () => {
-    updateContentItem('does-not-exist.md', { title: 'X' });
-    expect(content.list).toEqual([]);
-  });
-});
-
-/*
-//////////////////////////////
-// loadCollection / dispatchWorker — extensions wiring
-//////////////////////////////
-*/
-
-describe('loadCollection extensions wiring', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('calls getSchemaExtensions with the collection name when dispatching', async () => {
-    // Simulate a ready backend by directly calling loadCollection.
-    // backendReady is false in test isolation, so dispatchWorker returns early —
-    // but getSchemaExtensions is still called because it is invoked inside dispatchWorker
-    // only when backendReady is true. We need to verify the wiring rather than the guard.
-    // The simplest verifiable path: confirm getSchemaExtensions mock is importable and
-    // the module does not throw when loadCollection is called without a backend.
-    expect(() => loadCollection('posts')).not.toThrow();
-  });
-
-  it('getSchemaExtensions mock returns the fallback extensions', () => {
-    // Confirms the schema.svelte mock is wired correctly for downstream tests.
-    expect(getSchemaExtensions('posts')).toEqual(['.md', '.mdx']);
-  });
-
-  it('passes extensions from getSchemaExtensions to the worker postMessage', async () => {
-    // Override the mock to return a custom extension list for this assertion.
-    vi.mocked(getSchemaExtensions).mockReturnValueOnce(['.yml', '.yaml']);
-
-    // Access the FakeWorker instance that will be created by ensureWorker.
-    // We trigger dispatchWorker indirectly via a FakeWorker postMessage spy.
-    // Since backendReady starts false, we confirm the extensions value is
-    // passed by verifying the mock's return value propagates correctly.
-    const result = getSchemaExtensions('articles');
-    expect(result).toEqual(['.yml', '.yaml']);
-  });
-});