@doswiftly/storefront-sdk 4.3.0 → 4.5.0

package/src/__tests__/unit/cart-store.test.ts

@@ -1,349 +0,0 @@
-/**
- * Unit tests for createCartStore — DI-based cart state management.
- *
- * Tests factory creation, cookie persistence, UI actions, initCart orchestration
- * (including deduplication), mutations, callbacks, and error handling.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { createCartStore, type CartActions, type CartData } from '../../react/stores/cart.store';
-
-// Mock cookies module
-vi.mock('../../react/cookies', () => ({
-  getCookie: vi.fn(() => null),
-  setCookie: vi.fn(),
-  deleteCookie: vi.fn(),
-}));
-
-import { getCookie, setCookie, deleteCookie } from '../../react/cookies';
-const mockGetCookie = vi.mocked(getCookie);
-const mockSetCookie = vi.mocked(setCookie);
-const mockDeleteCookie = vi.mocked(deleteCookie);
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function createMockActions(overrides?: Partial<CartActions>): CartActions {
-  return {
-    fetchCart: vi.fn(async () => ({ id: 'cart-1', totalQuantity: 1 })),
-    createCart: vi.fn(async () => 'new-cart-id'),
-    addLines: vi.fn(async () => ({ id: 'cart-1', totalQuantity: 2 })),
-    updateLines: vi.fn(async () => ({ id: 'cart-1', totalQuantity: 3 })),
-    removeLines: vi.fn(async () => ({ id: 'cart-1', totalQuantity: 0 })),
-    ...overrides,
-  };
-}
-
-function createTestStore(
-  actions?: CartActions,
-  options?: {
-    onMutationSuccess?: (action: string, cart: CartData) => void;
-    onMutationError?: (action: string, error: unknown) => void;
-  },
-) {
-  const mockActions = actions ?? createMockActions();
-  return {
-    store: createCartStore({
-      getActions: () => mockActions,
-      onMutationSuccess: options?.onMutationSuccess,
-      onMutationError: options?.onMutationError,
-    }),
-    actions: mockActions,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Task 3.1: Factory, cookie persistence, UI actions
-// ---------------------------------------------------------------------------
-
-describe('createCartStore — factory & UI actions', () => {
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should create a valid store instance with initial state', () => {
-    const { store } = createTestStore();
-    const state = store.getState();
-
-    expect(state.cartId).toBeNull();
-    expect(state.isOpen).toBe(false);
-    expect(state.isLoading).toBe(false);
-    expect(state.error).toBeNull();
-  });
-
-  it('should read initial cartId from cookie', () => {
-    mockGetCookie.mockReturnValueOnce('existing-cart-from-cookie');
-    const actions = createMockActions();
-    const store = createCartStore({ getActions: () => actions });
-
-    expect(store.getState().cartId).toBe('existing-cart-from-cookie');
-    expect(mockGetCookie).toHaveBeenCalledWith('cart-id');
-  });
-
-  it('should write cartId to cookie when set', () => {
-    const { store } = createTestStore();
-
-    store.setState({ cartId: 'new-cart' });
-
-    expect(mockSetCookie).toHaveBeenCalledWith('cart-id', 'new-cart', { maxAge: 30 * 24 * 60 * 60 });
-  });
-
-  it('should delete cookie when cartId cleared', () => {
-    const { store } = createTestStore();
-    store.setState({ cartId: 'to-clear' });
-    vi.clearAllMocks();
-
-    store.getState().clearCart();
-
-    expect(mockDeleteCookie).toHaveBeenCalledWith('cart-id');
-    expect(store.getState().cartId).toBeNull();
-  });
-
-  it('openCart should set isOpen to true', () => {
-    const { store } = createTestStore();
-    store.getState().openCart();
-    expect(store.getState().isOpen).toBe(true);
-  });
-
-  it('closeCart should set isOpen to false', () => {
-    const { store } = createTestStore();
-    store.getState().openCart();
-    store.getState().closeCart();
-    expect(store.getState().isOpen).toBe(false);
-  });
-
-  it('toggleCart should flip isOpen', () => {
-    const { store } = createTestStore();
-    expect(store.getState().isOpen).toBe(false);
-    store.getState().toggleCart();
-    expect(store.getState().isOpen).toBe(true);
-    store.getState().toggleCart();
-    expect(store.getState().isOpen).toBe(false);
-  });
-
-  it('clearCart should reset all state', () => {
-    const { store } = createTestStore();
-    store.setState({ cartId: 'cart-1', isOpen: true, isLoading: true, error: new Error('err') });
-
-    store.getState().clearCart();
-
-    const state = store.getState();
-    expect(state.cartId).toBeNull();
-    expect(state.isOpen).toBe(false);
-    expect(state.isLoading).toBe(false);
-    expect(state.error).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Task 3.2: initCart orchestration
-// ---------------------------------------------------------------------------
-
-describe('createCartStore — initCart orchestration', () => {
-  afterEach(() => { vi.clearAllMocks(); });
-
-  it('should fetch existing cart when cartId is set', async () => {
-    const actions = createMockActions({
-      fetchCart: vi.fn(async () => ({ id: 'existing-cart', totalQuantity: 5 })),
-    });
-    const { store } = createTestStore(actions);
-    store.setState({ cartId: 'existing-cart' });
-
-    await store.getState().initCart();
-
-    expect(actions.fetchCart).toHaveBeenCalledWith('existing-cart');
-    expect(actions.createCart).not.toHaveBeenCalled();
-    expect(store.getState().cartId).toBe('existing-cart');
-    expect(store.getState().isLoading).toBe(false);
-  });
-
-  it('should create new cart when fetchCart returns null (expired)', async () => {
-    const actions = createMockActions({
-      fetchCart: vi.fn(async () => null),
-      createCart: vi.fn(async () => 'brand-new-cart'),
-    });
-    const { store } = createTestStore(actions);
-    store.setState({ cartId: 'expired-cart' });
-
-    await store.getState().initCart();
-
-    expect(actions.fetchCart).toHaveBeenCalledWith('expired-cart');
-    expect(actions.createCart).toHaveBeenCalled();
-    expect(store.getState().cartId).toBe('brand-new-cart');
-    expect(store.getState().isLoading).toBe(false);
-  });
-
-  it('should create new cart when cartId is null', async () => {
-    const actions = createMockActions({
-      createCart: vi.fn(async () => 'fresh-cart'),
-    });
-    const { store } = createTestStore(actions);
-
-    await store.getState().initCart();
-
-    expect(actions.fetchCart).not.toHaveBeenCalled();
-    expect(actions.createCart).toHaveBeenCalled();
-    expect(store.getState().cartId).toBe('fresh-cart');
-  });
-
-  it('should deduplicate concurrent initCart calls', async () => {
-    let resolveCreate: (value: string) => void;
-    const createPromise = new Promise<string>((resolve) => {
-      resolveCreate = resolve;
-    });
-
-    const actions = createMockActions({
-      createCart: vi.fn(() => createPromise),
-    });
-    const { store } = createTestStore(actions);
-
-    // Fire two concurrent initCart calls
-    const p1 = store.getState().initCart();
-    const p2 = store.getState().initCart();
-
-    // Resolve
-    resolveCreate!('deduped-cart');
-    await Promise.all([p1, p2]);
-
-    // createCart should be called only once
-    expect(actions.createCart).toHaveBeenCalledTimes(1);
-    expect(store.getState().cartId).toBe('deduped-cart');
-  });
-
-  it('should set error and call onMutationError on initCart failure', async () => {
-    const err = new Error('Network error');
-    const actions = createMockActions({
-      createCart: vi.fn(async () => { throw err; }),
-    });
-    const onMutationError = vi.fn();
-    const { store } = createTestStore(actions, { onMutationError });
-
-    await store.getState().initCart();
-
-    expect(store.getState().error).toBe(err);
-    expect(store.getState().isLoading).toBe(false);
-    expect(onMutationError).toHaveBeenCalledWith('initCart', err);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Task 3.3: Mutations and callbacks
-// ---------------------------------------------------------------------------
-
-describe('createCartStore — mutations', () => {
-  afterEach(() => { vi.clearAllMocks(); });
-
-  it('addToCart with existing cartId should call addLines', async () => {
-    const cartData: CartData = { id: 'cart-1', totalQuantity: 2 };
-    const actions = createMockActions({
-      addLines: vi.fn(async () => cartData),
-    });
-    const onMutationSuccess = vi.fn();
-    const { store } = createTestStore(actions, { onMutationSuccess });
-    store.setState({ cartId: 'cart-1' });
-
-    await store.getState().addToCart([{ merchandiseId: 'var-1', quantity: 1 }]);
-
-    expect(actions.addLines).toHaveBeenCalledWith('cart-1', [{ merchandiseId: 'var-1', quantity: 1 }]);
-    expect(onMutationSuccess).toHaveBeenCalledWith('addToCart', cartData);
-    expect(store.getState().isLoading).toBe(false);
-  });
-
-  it('addToCart without cartId should auto-init then addLines', async () => {
-    const actions = createMockActions({
-      createCart: vi.fn(async () => 'auto-cart'),
-      addLines: vi.fn(async () => ({ id: 'auto-cart', totalQuantity: 1 })),
-    });
-    const { store } = createTestStore(actions);
-
-    await store.getState().addToCart([{ merchandiseId: 'var-1' }]);
-
-    expect(actions.createCart).toHaveBeenCalled();
-    expect(actions.addLines).toHaveBeenCalledWith('auto-cart', [{ merchandiseId: 'var-1' }]);
-    expect(store.getState().cartId).toBe('auto-cart');
-  });
-
-  it('updateQuantity should call updateLines with correct args', async () => {
-    const cartData: CartData = { id: 'cart-1', totalQuantity: 3 };
-    const actions = createMockActions({
-      updateLines: vi.fn(async () => cartData),
-    });
-    const onMutationSuccess = vi.fn();
-    const { store } = createTestStore(actions, { onMutationSuccess });
-    store.setState({ cartId: 'cart-1' });
-
-    await store.getState().updateQuantity([{ id: 'line-1', quantity: 5 }]);
-
-    expect(actions.updateLines).toHaveBeenCalledWith('cart-1', [{ id: 'line-1', quantity: 5 }]);
-    expect(onMutationSuccess).toHaveBeenCalledWith('updateQuantity', cartData);
-  });
-
-  it('updateQuantity without cartId should set error', async () => {
-    const onMutationError = vi.fn();
-    const { store, actions } = createTestStore(undefined, { onMutationError });
-
-    await store.getState().updateQuantity([{ id: 'line-1', quantity: 5 }]);
-
-    expect(actions.updateLines).not.toHaveBeenCalled();
-    expect(store.getState().error).toBeInstanceOf(Error);
-    expect(onMutationError).toHaveBeenCalledWith('updateQuantity', expect.any(Error));
-  });
-
-  it('removeFromCart should call removeLines with correct args', async () => {
-    const cartData: CartData = { id: 'cart-1', totalQuantity: 0 };
-    const actions = createMockActions({
-      removeLines: vi.fn(async () => cartData),
-    });
-    const onMutationSuccess = vi.fn();
-    const { store } = createTestStore(actions, { onMutationSuccess });
-    store.setState({ cartId: 'cart-1' });
-
-    await store.getState().removeFromCart(['line-1']);
-
-    expect(actions.removeLines).toHaveBeenCalledWith('cart-1', ['line-1']);
-    expect(onMutationSuccess).toHaveBeenCalledWith('removeFromCart', cartData);
-  });
-
-  it('removeFromCart without cartId should silently return', async () => {
-    const { store, actions } = createTestStore();
-
-    await store.getState().removeFromCart(['line-1']);
-
-    expect(actions.removeLines).not.toHaveBeenCalled();
-    expect(store.getState().isLoading).toBe(false);
-  });
-
-  it('should set error state and call onMutationError on DI failure', async () => {
-    const err = new Error('GraphQL error');
-    const actions = createMockActions({
-      addLines: vi.fn(async () => { throw err; }),
-    });
-    const onMutationError = vi.fn();
-    const { store } = createTestStore(actions, { onMutationError });
-    store.setState({ cartId: 'cart-1' });
-
-    await store.getState().addToCart([{ merchandiseId: 'var-1' }]);
-
-    expect(store.getState().error).toBe(err);
-    expect(store.getState().isLoading).toBe(false);
-    expect(onMutationError).toHaveBeenCalledWith('addToCart', err);
-  });
-
-  it('should call getActions on every operation (freshness)', async () => {
-    const actions = createMockActions();
-    const getActions = vi.fn(() => actions);
-    const store = createCartStore({
-      getActions,
-      onMutationSuccess: vi.fn(),
-    });
-    store.setState({ cartId: 'cart-1' });
-
-    await store.getState().addToCart([{ merchandiseId: 'v1' }]);
-    await store.getState().updateQuantity([{ id: 'l1', quantity: 2 }]);
-    await store.getState().removeFromCart(['l1']);
-
-    // getActions called at least once per operation
-    expect(getActions.mock.calls.length).toBeGreaterThanOrEqual(3);
-  });
-});

package/src/__tests__/unit/create-client.test.ts

@@ -1,356 +0,0 @@
-/**
- * Unit tests for createStorefrontClient — transport factory.
- *
- * Tests: query/mutate, middleware pipeline, request deduplication,
- * lazy pipeline compilation, use() API, TypedDocumentString support.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { createStorefrontClient } from '../../core/client/create-client';
-import { TypedDocumentString } from '../../core/client/types';
-import { createSpyFetch, createMockFetch } from './test-helpers';
-
-const PRODUCT_QUERY = 'query Product($handle: String!) { product(handle: $handle) { id title } }';
-const CART_CREATE = 'mutation CartCreate($input: CartInput!) { cartCreate(input: $input) { cart { id } userErrors { message } } }';
-
-describe('createStorefrontClient', () => {
-  it('should create a client with query and mutate methods', () => {
-    const client = createStorefrontClient({
-      apiUrl: 'https://api.test.com',
-      shopSlug: 'test-shop',
-      fetch: createMockFetch({}),
-    });
-
-    expect(client.query).toBeDefined();
-    expect(client.mutate).toBeDefined();
-    expect(client.use).toBeDefined();
-  });
-
-  describe('query()', () => {
-    it('should send POST request with correct body', async () => {
-      const { fetch, calls } = createSpyFetch({ product: { id: '1', title: 'Test' } });
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'my-shop',
-        fetch,
-      });
-
-      await client.query(PRODUCT_QUERY, { handle: 'test-product' });
-
-      expect(calls).toHaveLength(1);
-      expect(calls[0].url).toBe('https://api.test.com/storefront/graphql');
-
-      const body = JSON.parse(calls[0].init.body as string);
-      expect(body.query).toBe(PRODUCT_QUERY);
-      expect(body.variables).toEqual({ handle: 'test-product' });
-      expect(body.operationName).toBe('Product');
-    });
-
-    it('should include X-Shop-Slug header', async () => {
-      const { fetch, calls } = createSpyFetch({ product: null });
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'my-shop',
-        fetch,
-      });
-
-      await client.query(PRODUCT_QUERY, { handle: 'test' });
-
-      const headers = calls[0].init.headers as Record<string, string>;
-      expect(headers['X-Shop-Slug']).toBe('my-shop');
-    });
-
-    it('should include X-Operation-Name header for named queries', async () => {
-      const { fetch, calls } = createSpyFetch({ product: null });
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch,
-      });
-
-      await client.query(PRODUCT_QUERY, { handle: 'test' });
-
-      const headers = calls[0].init.headers as Record<string, string>;
-      expect(headers['X-Operation-Name']).toBe('Product');
-    });
-
-    it('should NOT include X-Operation-Name for anonymous queries', async () => {
-      const { fetch, calls } = createSpyFetch({ something: true });
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch,
-      });
-
-      await client.query('{ shop { id } }');
-
-      const headers = calls[0].init.headers as Record<string, string>;
-      expect(headers['X-Operation-Name']).toBeUndefined();
-    });
-
-    it('should return data from response', async () => {
-      const mockData = { product: { id: '1', title: 'Cool Shirt' } };
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch: createMockFetch(mockData),
-      });
-
-      const result = await client.query(PRODUCT_QUERY, { handle: 'cool-shirt' });
-      expect(result).toEqual(mockData);
-    });
-
-    it('should strip trailing slash from apiUrl', async () => {
-      const { fetch, calls } = createSpyFetch({});
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com/',
-        shopSlug: 'test',
-        fetch,
-      });
-
-      await client.query('{ shop { id } }');
-      expect(calls[0].url).toBe('https://api.test.com/storefront/graphql');
-    });
-
-    it('should merge defaultHeaders into request', async () => {
-      const { fetch, calls } = createSpyFetch({});
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        defaultHeaders: { 'X-Custom': 'value' },
-        fetch,
-      });
-
-      await client.query('{ shop { id } }');
-
-      const headers = calls[0].init.headers as Record<string, string>;
-      expect(headers['X-Custom']).toBe('value');
-    });
-
-    it('should support TypedDocumentString', async () => {
-      const typedDoc = new TypedDocumentString<{ product: { id: string } }, { handle: string }>(PRODUCT_QUERY);
-
-      const { fetch, calls } = createSpyFetch({ product: { id: '1' } });
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch,
-      });
-
-      const result = await client.query(typedDoc, { handle: 'test' });
-
-      const body = JSON.parse(calls[0].init.body as string);
-      expect(body.query).toBe(PRODUCT_QUERY);
-      expect(result).toEqual({ product: { id: '1' } });
-    });
-
-    it('should not include empty variables in request body', async () => {
-      const { fetch, calls } = createSpyFetch({});
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch,
-      });
-
-      await client.query('{ shop { id } }');
-
-      const body = JSON.parse(calls[0].init.body as string);
-      expect(body.variables).toBeUndefined();
-    });
-  });
-
-  describe('mutate()', () => {
-    it('should send mutation correctly', async () => {
-      const mockData = { cartCreate: { cart: { id: 'cart-1' }, userErrors: [] } };
-      const { fetch, calls } = createSpyFetch(mockData);
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch,
-      });
-
-      const result = await client.mutate(CART_CREATE, { input: {} });
-
-      expect(result).toEqual(mockData);
-      const body = JSON.parse(calls[0].init.body as string);
-      expect(body.operationName).toBe('CartCreate');
-    });
-  });
-
-  describe('request deduplication', () => {
-    it('should deduplicate identical concurrent queries', async () => {
-      const { fetch, calls } = createSpyFetch({ product: { id: '1' } });
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch,
-      });
-
-      // Fire 3 identical queries concurrently
-      const [r1, r2, r3] = await Promise.all([
-        client.query(PRODUCT_QUERY, { handle: 'test' }),
-        client.query(PRODUCT_QUERY, { handle: 'test' }),
-        client.query(PRODUCT_QUERY, { handle: 'test' }),
-      ]);
-
-      // Only 1 actual fetch
-      expect(calls).toHaveLength(1);
-      // All return same data
-      expect(r1).toEqual(r2);
-      expect(r2).toEqual(r3);
-    });
-
-    it('should NOT deduplicate queries with different variables', async () => {
-      const { fetch, calls } = createSpyFetch({ product: { id: '1' } });
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch,
-      });
-
-      await Promise.all([
-        client.query(PRODUCT_QUERY, { handle: 'product-a' }),
-        client.query(PRODUCT_QUERY, { handle: 'product-b' }),
-      ]);
-
-      expect(calls).toHaveLength(2);
-    });
-
-    it('should NOT deduplicate mutations', async () => {
-      const { fetch, calls } = createSpyFetch({ cartCreate: { cart: { id: '1' }, userErrors: [] } });
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch,
-      });
-
-      await Promise.all([
-        client.mutate(CART_CREATE, { input: {} }),
-        client.mutate(CART_CREATE, { input: {} }),
-      ]);
-
-      expect(calls).toHaveLength(2);
-    });
-  });
-
-  describe('use() — imperative middleware', () => {
-    it('should add middleware that runs on subsequent requests', async () => {
-      const { fetch, calls } = createSpyFetch({ data: true });
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch,
-      });
-
-      client.use((req, next) => {
-        req.headers['X-Added'] = 'by-use';
-        return next(req);
-      });
-
-      await client.query('{ shop { id } }');
-
-      const headers = calls[0].init.headers as Record<string, string>;
-      expect(headers['X-Added']).toBe('by-use');
-    });
-
-    it('should invalidate compiled pipeline on use()', async () => {
-      let callOrder: string[] = [];
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch: createMockFetch({}),
-        middleware: [
-          async (req, next) => { callOrder.push('A'); return next(req); },
-        ],
-      });
-
-      await client.query('{ shop { id } }');
-      expect(callOrder).toEqual(['A']);
-
-      callOrder = [];
-      client.use(async (req, next) => { callOrder.push('B'); return next(req); });
-
-      await client.query('{ shop { id } }');
-      expect(callOrder).toEqual(['A', 'B']);
-    });
-  });
-
-  describe('middleware pipeline', () => {
-    it('should execute middleware in registration order', async () => {
-      const order: string[] = [];
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch: createMockFetch({}),
-        middleware: [
-          async (req, next) => { order.push('first'); return next(req); },
-          async (req, next) => { order.push('second'); return next(req); },
-          async (req, next) => { order.push('third'); return next(req); },
-        ],
-      });
-
-      await client.query('{ shop { id } }');
-      expect(order).toEqual(['first', 'second', 'third']);
-    });
-
-    it('should allow middleware to modify request headers', async () => {
-      const { fetch, calls } = createSpyFetch({});
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch,
-        middleware: [
-          async (req, next) => {
-            req.headers['Authorization'] = 'Bearer test-token';
-            return next(req);
-          },
-        ],
-      });
-
-      await client.query('{ shop { id } }');
-
-      const headers = calls[0].init.headers as Record<string, string>;
-      expect(headers['Authorization']).toBe('Bearer test-token');
-    });
-
-    it('should allow middleware to short-circuit', async () => {
-      const { fetch, calls } = createSpyFetch({});
-
-      const client = createStorefrontClient({
-        apiUrl: 'https://api.test.com',
-        shopSlug: 'test',
-        fetch,
-        middleware: [
-          async (_req, _next) => {
-            // Short-circuit — don't call next()
-            return {
-              data: { cached: true },
-              status: 200,
-              headers: new Headers(),
-            };
-          },
-        ],
-      });
-
-      const result = await client.query('{ shop { id } }');
-      expect(result).toEqual({ cached: true });
-      expect(calls).toHaveLength(0); // No fetch call
-    });
-  });
-});