@signalium/query 0.0.0

package/src/__tests__/utils.ts

@@ -0,0 +1,242 @@
+import { watchOnce, watcher, withContexts } from 'signalium';
+import { QueryClient, QueryClientContext } from '../QueryClient.js';
+import { QueryStore } from '../QueryStore.js';
+import { EntityStore } from '../EntityMap.js';
+
+// Re-export watchOnce for convenience
+export { watchOnce };
+
+interface MockFetchOptions {
+  status?: number;
+  headers?: Record<string, string>;
+  delay?: number;
+  error?: Error;
+  jsonError?: Error;
+}
+
+interface MockFetch {
+  (url: string, options?: RequestInit): Promise<Response>;
+
+  get(url: string, response: unknown, opts?: MockFetchOptions): void;
+  post(url: string, response: unknown, opts?: MockFetchOptions): void;
+  put(url: string, response: unknown, opts?: MockFetchOptions): void;
+  delete(url: string, response: unknown, opts?: MockFetchOptions): void;
+  patch(url: string, response: unknown, opts?: MockFetchOptions): void;
+
+  reset(): void;
+  calls: Array<{ url: string; options: RequestInit }>;
+}
+
+interface MockRoute {
+  url: string;
+  method: string;
+  response: unknown;
+  options: MockFetchOptions;
+  used: boolean;
+}
+
+/**
+ * Creates a mock fetch function with a fluent API for setting up responses.
+ *
+ * @example
+ * const fetch = createMockFetch();
+ * fetch.get('/users/123', { id: 123, name: 'Alice' });
+ * fetch.post('/users', { id: 456, name: 'Bob' }, { status: 201 });
+ *
+ * const response = await fetch('/users/123', { method: 'GET' });
+ * const data = await response.json(); // { id: 123, name: 'Alice' }
+ */
+export function createMockFetch(): MockFetch {
+  const routes: MockRoute[] = [];
+  const calls: Array<{ url: string; options: RequestInit }> = [];
+
+  const matchRoute = (url: string, method: string): MockRoute | undefined => {
+    // First try exact match
+    const exactMatch = routes.find(r => r.url === url && r.method === method && !r.used);
+    if (exactMatch) return exactMatch;
+
+    // Then try pattern matching (for URLs with query params or path segments)
+    return routes.find(r => {
+      if (r.method !== method || r.used) return false;
+
+      // Simple pattern: check if the route URL is a prefix or matches the base path
+      const routeBase = r.url.split('?')[0];
+      const urlBase = url.split('?')[0];
+
+      // Check if URL starts with the route (for exact matches)
+      if (urlBase === routeBase) return true;
+
+      // Check if route contains path params [...]
+      if (r.url.includes('[')) {
+        const routeParts = routeBase.split('/');
+        const urlParts = urlBase.split('/');
+
+        if (routeParts.length !== urlParts.length) return false;
+
+        return routeParts.every((part, i) => {
+          if (part.startsWith('[') && part.endsWith(']')) return true;
+          return part === urlParts[i];
+        });
+      }
+
+      return false;
+    });
+  };
+
+  const mockFetch = async (url: string, options: RequestInit = {}): Promise<Response> => {
+    const method = (options.method || 'GET').toUpperCase();
+
+    calls.push({ url, options });
+
+    const route = matchRoute(url, method);
+
+    if (!route) {
+      throw new Error(
+        `No mock response configured for ${method} ${url}\n` +
+          `Available routes:\n${routes.map(r => `  ${r.method} ${r.url}`).join('\n')}`,
+      );
+    }
+
+    route.used = true;
+
+    if (route.options.delay) {
+      await new Promise(resolve => setTimeout(resolve, route.options.delay));
+    }
+
+    if (route.options.error) {
+      throw route.options.error;
+    }
+
+    const status = route.options.status ?? 200;
+    const headers = route.options.headers ?? {};
+
+    // Create a mock Response object
+    const response = {
+      ok: status >= 200 && status < 300,
+      status,
+      statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : status === 204 ? 'No Content' : 'Error',
+      headers: new Headers(headers),
+      json: async () => {
+        if (route.options.jsonError) {
+          throw route.options.jsonError;
+        }
+        return route.response;
+      },
+      text: async () => JSON.stringify(route.response),
+      blob: async () => new Blob([JSON.stringify(route.response)]),
+      arrayBuffer: async () => new TextEncoder().encode(JSON.stringify(route.response)).buffer,
+      clone: () => response,
+    } as Response;
+
+    return response;
+  };
+
+  const addRoute = (method: string, url: string, response: unknown, opts: MockFetchOptions = {}) => {
+    routes.push({
+      url,
+      method: method.toUpperCase(),
+      response,
+      options: opts,
+      used: false,
+    });
+  };
+
+  mockFetch.get = (url: string, response: unknown, opts?: MockFetchOptions) => {
+    addRoute('GET', url, response, opts);
+  };
+
+  mockFetch.post = (url: string, response: unknown, opts?: MockFetchOptions) => {
+    addRoute('POST', url, response, opts);
+  };
+
+  mockFetch.put = (url: string, response: unknown, opts?: MockFetchOptions) => {
+    addRoute('PUT', url, response, opts);
+  };
+
+  mockFetch.delete = (url: string, response: unknown, opts?: MockFetchOptions) => {
+    addRoute('DELETE', url, response, opts);
+  };
+
+  mockFetch.patch = (url: string, response: unknown, opts?: MockFetchOptions) => {
+    addRoute('PATCH', url, response, opts);
+  };
+
+  mockFetch.reset = () => {
+    routes.length = 0;
+    calls.length = 0;
+  };
+
+  mockFetch.calls = calls;
+
+  return mockFetch as MockFetch;
+}
+
+/**
+ * Creates a test watcher that tracks all values emitted by a reactive function.
+ * Returns an object with the values array and an unsubscribe function.
+ *
+ * Note: This creates a continuous watcher. For one-time execution, use `watchOnce` instead.
+ */
+export function createTestWatcher<T>(fn: () => T): {
+  values: T[];
+  unsub: () => void;
+} {
+  const values: T[] = [];
+
+  const w = watcher(() => {
+    const value = fn();
+    values.push(value);
+  });
+
+  const unsub = w.addListener(() => {});
+
+  return { values, unsub };
+}
+
+/**
+ * Test helper that combines query client context injection and automatic watcher cleanup.
+ * Wraps the test in a watcher and awaits it, keeping relays active during the test.
+ *
+ * @example
+ * await testWithClient(client, async () => {
+ *   const relay = getItem({ id: '1' });
+ *   await relay;
+ *   expect(relay.value).toBeDefined();
+ *   // Watcher is automatically cleaned up
+ * });
+ */
+export async function testWithClient(client: QueryClient, fn: () => Promise<void>): Promise<void> {
+  return withContexts([[QueryClientContext, client]], () => watchOnce(fn));
+}
+
+export const sleep = (ms: number = 0) =>
+  new Promise(resolve => {
+    setTimeout(() => {
+      resolve(true);
+    }, ms);
+  });
+
+/**
+ * Test helper to access the internal store of a QueryClient.
+ * Uses bracket notation to bypass TypeScript access checks.
+ */
+export function getClientStore(client: QueryClient): QueryStore {
+  return client['store'];
+}
+
+/**
+ * Test helper to access the internal entity map of a QueryClient.
+ * Uses bracket notation to bypass TypeScript access checks.
+ */
+export function getClientEntityMap(client: QueryClient): EntityStore {
+  return client['entityMap'];
+}
+
+/**
+ * Test helper to get the size of the entity map.
+ * EntityStore doesn't expose a size property, so we access the internal map.
+ */
+export function getEntityMapSize(client: QueryClient): number {
+  const entityMap = getClientEntityMap(client);
+  return entityMap['map'].size;
+}