@doswiftly/storefront-sdk 4.4.0 → 4.5.0

package/src/__tests__/unit/helpers.test.ts

@@ -1,377 +0,0 @@
-/**
- * Unit tests for helper utilities.
- *
- * Tests: assertNoUserErrors, hashQuery, getOperationName,
- * cache strategies, StorefrontError, TypedDocumentString.
- */
-
-import { describe, it, expect } from 'vitest';
-import { assertNoUserErrors } from '../../core/helpers/assert-no-user-errors';
-import { hashQuery } from '../../core/client/hash';
-import { getOperationName } from '../../core/client/operation-name';
-import { compose } from '../../core/client/compose';
-import { StorefrontError, ErrorCodes } from '../../core/errors';
-import { TypedDocumentString } from '../../core/client/types';
-import {
-  cacheLong,
-  cacheShort,
-  cacheNone,
-  cachePrivate,
-  cacheCustom,
-  generateCacheControlHeader,
-} from '../../core/cache';
-import type { ExecuteFn, GraphQLRequest, Middleware } from '../../core/client/types';
-
-// ---------------------------------------------------------------------------
-// assertNoUserErrors
-// ---------------------------------------------------------------------------
-
-describe('assertNoUserErrors', () => {
-  it('should not throw when userErrors is empty', () => {
-    expect(() => assertNoUserErrors({ userErrors: [] })).not.toThrow();
-  });
-
-  it('should not throw when userErrors is null', () => {
-    expect(() => assertNoUserErrors({ userErrors: null })).not.toThrow();
-  });
-
-  it('should not throw when userErrors is undefined', () => {
-    expect(() => assertNoUserErrors({})).not.toThrow();
-  });
-
-  it('should throw StorefrontError with USER_ERROR code', () => {
-    try {
-      assertNoUserErrors({
-        userErrors: [{ message: 'Invalid email', field: ['email'] }],
-      });
-      expect.fail('Should have thrown');
-    } catch (err) {
-      expect(err).toBeInstanceOf(StorefrontError);
-      const sfErr = err as StorefrontError;
-      expect(sfErr.code).toBe(ErrorCodes.USER_ERROR);
-      expect(sfErr.message).toBe('Invalid email');
-      expect(sfErr.userErrors).toHaveLength(1);
-      expect(sfErr.hasUserErrors).toBe(true);
-    }
-  });
-
-  it('should use first error message', () => {
-    try {
-      assertNoUserErrors({
-        userErrors: [
-          { message: 'First error' },
-          { message: 'Second error' },
-        ],
-      });
-    } catch (err) {
-      expect((err as StorefrontError).message).toBe('First error');
-      expect((err as StorefrontError).userErrors).toHaveLength(2);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// hashQuery
-// ---------------------------------------------------------------------------
-
-describe('hashQuery', () => {
-  it('should produce consistent hash for same query', () => {
-    const h1 = hashQuery('{ shop { id } }');
-    const h2 = hashQuery('{ shop { id } }');
-    expect(h1).toBe(h2);
-  });
-
-  it('should produce different hashes for different queries', () => {
-    const h1 = hashQuery('{ shop { id } }');
-    const h2 = hashQuery('{ product { id } }');
-    expect(h1).not.toBe(h2);
-  });
-
-  it('should produce same hash regardless of variable key order', () => {
-    const h1 = hashQuery('query Q', { a: 1, b: 2 });
-    const h2 = hashQuery('query Q', { b: 2, a: 1 });
-    expect(h1).toBe(h2);
-  });
-
-  it('should produce different hashes for different variables', () => {
-    const h1 = hashQuery('query Q', { handle: 'a' });
-    const h2 = hashQuery('query Q', { handle: 'b' });
-    expect(h1).not.toBe(h2);
-  });
-
-  it('should handle nested objects in variables', () => {
-    const h1 = hashQuery('query Q', { filter: { a: 1, b: 2 } });
-    const h2 = hashQuery('query Q', { filter: { b: 2, a: 1 } });
-    expect(h1).toBe(h2);
-  });
-
-  it('should handle undefined variables', () => {
-    const h1 = hashQuery('{ shop { id } }');
-    const h2 = hashQuery('{ shop { id } }', undefined);
-    expect(h1).toBe(h2);
-  });
-
-  it('should trim whitespace in query', () => {
-    const h1 = hashQuery('  { shop { id } }  ');
-    const h2 = hashQuery('{ shop { id } }');
-    expect(h1).toBe(h2);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// getOperationName
-// ---------------------------------------------------------------------------
-
-describe('getOperationName', () => {
-  it('should extract query name', () => {
-    expect(getOperationName('query Product($id: ID!) { product(id: $id) { id } }')).toBe('Product');
-  });
-
-  it('should extract mutation name', () => {
-    expect(getOperationName('mutation CartCreate($input: CartInput!) { cartCreate(input: $input) { cart { id } } }')).toBe('CartCreate');
-  });
-
-  it('should extract subscription name', () => {
-    expect(getOperationName('subscription OrderUpdated { orderUpdated { id } }')).toBe('OrderUpdated');
-  });
-
-  it('should return "anonymous" for unnamed operations', () => {
-    expect(getOperationName('{ shop { id } }')).toBe('anonymous');
-  });
-
-  it('should return "anonymous" for empty string', () => {
-    expect(getOperationName('')).toBe('anonymous');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// compose
-// ---------------------------------------------------------------------------
-
-describe('compose', () => {
-  it('should execute middleware in order', async () => {
-    const order: number[] = [];
-
-    const m1: Middleware = async (req, next) => { order.push(1); return next(req); };
-    const m2: Middleware = async (req, next) => { order.push(2); return next(req); };
-    const m3: Middleware = async (req, next) => { order.push(3); return next(req); };
-
-    const execute: ExecuteFn = async () => ({
-      data: {},
-      status: 200,
-      headers: new Headers(),
-    });
-
-    const pipeline = compose([m1, m2, m3], execute);
-    await pipeline({ query: '', headers: {}, isMutation: false });
-
-    expect(order).toEqual([1, 2, 3]);
-  });
-
-  it('should return execute directly when no middleware', async () => {
-    const execute: ExecuteFn = async () => ({
-      data: { test: true },
-      status: 200,
-      headers: new Headers(),
-    });
-
-    const pipeline = compose([], execute);
-    const result = await pipeline({ query: '', headers: {}, isMutation: false });
-
-    expect(result.data).toEqual({ test: true });
-  });
-
-  it('should allow middleware to modify response', async () => {
-    const addField: Middleware = async (req, next) => {
-      const response = await next(req);
-      return { ...response, data: { ...response.data as object, added: true } };
-    };
-
-    const execute: ExecuteFn = async () => ({
-      data: { original: true },
-      status: 200,
-      headers: new Headers(),
-    });
-
-    const pipeline = compose([addField], execute);
-    const result = await pipeline({ query: '', headers: {}, isMutation: false });
-
-    expect(result.data).toEqual({ original: true, added: true });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// StorefrontError
-// ---------------------------------------------------------------------------
-
-describe('StorefrontError', () => {
-  it('should be instance of Error', () => {
-    const err = new StorefrontError({ code: 'TEST', message: 'test' });
-    expect(err).toBeInstanceOf(Error);
-    expect(err).toBeInstanceOf(StorefrontError);
-  });
-
-  it('should have correct name', () => {
-    const err = new StorefrontError({ code: 'TEST', message: 'test' });
-    expect(err.name).toBe('StorefrontError');
-  });
-
-  it('should default status to 0', () => {
-    const err = new StorefrontError({ code: 'TEST', message: 'test' });
-    expect(err.status).toBe(0);
-  });
-
-  it('should default arrays to empty', () => {
-    const err = new StorefrontError({ code: 'TEST', message: 'test' });
-    expect(err.graphqlErrors).toEqual([]);
-    expect(err.userErrors).toEqual([]);
-  });
-
-  it('should preserve all fields', () => {
-    const err = new StorefrontError({
-      code: ErrorCodes.GRAPHQL_ERROR,
-      message: 'Field not found',
-      status: 200,
-      graphqlErrors: [{ message: 'Field not found', path: ['product', 'nonexistent'] }],
-      userErrors: [{ message: 'Invalid', field: ['email'] }],
-    });
-
-    expect(err.code).toBe(ErrorCodes.GRAPHQL_ERROR);
-    expect(err.message).toBe('Field not found');
-    expect(err.status).toBe(200);
-    expect(err.graphqlErrors).toHaveLength(1);
-    expect(err.userErrors).toHaveLength(1);
-  });
-
-  it('hasUserErrors should be true when userErrors exist', () => {
-    const err = new StorefrontError({
-      code: ErrorCodes.USER_ERROR,
-      message: 'test',
-      userErrors: [{ message: 'Error' }],
-    });
-    expect(err.hasUserErrors).toBe(true);
-  });
-
-  it('hasUserErrors should be false when userErrors are empty', () => {
-    const err = new StorefrontError({ code: 'TEST', message: 'test' });
-    expect(err.hasUserErrors).toBe(false);
-  });
-
-  it('isNetworkError should be true for NETWORK_ERROR code', () => {
-    const err = new StorefrontError({ code: ErrorCodes.NETWORK_ERROR, message: 'fetch failed' });
-    expect(err.isNetworkError).toBe(true);
-    expect(err.isTimeout).toBe(false);
-  });
-
-  it('isTimeout should be true for TIMEOUT code', () => {
-    const err = new StorefrontError({ code: ErrorCodes.TIMEOUT, message: 'timeout' });
-    expect(err.isTimeout).toBe(true);
-    expect(err.isNetworkError).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// TypedDocumentString
-// ---------------------------------------------------------------------------
-
-describe('TypedDocumentString', () => {
-  it('should extend String', () => {
-    const doc = new TypedDocumentString('query { shop { id } }');
-    expect(doc).toBeInstanceOf(String);
-  });
-
-  it('should return query string via toString()', () => {
-    const query = 'query Product { product { id } }';
-    const doc = new TypedDocumentString(query);
-    expect(doc.toString()).toBe(query);
-  });
-
-  it('should return query string via valueOf()', () => {
-    const query = 'query Product { product { id } }';
-    const doc = new TypedDocumentString(query);
-    expect(doc.valueOf()).toBe(query);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Cache strategies
-// ---------------------------------------------------------------------------
-
-describe('cache strategies', () => {
-  describe('cacheNone', () => {
-    it('should return no-store mode', () => {
-      const cache = cacheNone();
-      expect(cache.mode).toBe('no-store');
-      expect(cache.maxAge).toBe(0);
-    });
-
-    it('should accept tags override', () => {
-      const cache = cacheNone({ tags: ['cart'] });
-      expect(cache.tags).toEqual(['cart']);
-    });
-  });
-
-  describe('cacheShort', () => {
-    it('should default to 1s max-age, 9s swr', () => {
-      const cache = cacheShort();
-      expect(cache.maxAge).toBe(1);
-      expect(cache.staleWhileRevalidate).toBe(9);
-      expect(cache.mode).toBe('public');
-    });
-
-    it('should accept overrides', () => {
-      const cache = cacheShort({ maxAge: 5, staleWhileRevalidate: 30, tags: ['products'] });
-      expect(cache.maxAge).toBe(5);
-      expect(cache.staleWhileRevalidate).toBe(30);
-      expect(cache.tags).toEqual(['products']);
-    });
-  });
-
-  describe('cacheLong', () => {
-    it('should default to 1h max-age, 23h swr', () => {
-      const cache = cacheLong();
-      expect(cache.maxAge).toBe(3600);
-      expect(cache.staleWhileRevalidate).toBe(82800);
-      expect(cache.mode).toBe('public');
-    });
-
-    it('should accept tags', () => {
-      const cache = cacheLong({ tags: ['product', 'cool-shirt'] });
-      expect(cache.tags).toEqual(['product', 'cool-shirt']);
-    });
-  });
-
-  describe('cachePrivate', () => {
-    it('should return private mode', () => {
-      const cache = cachePrivate();
-      expect(cache.mode).toBe('private');
-      expect(cache.maxAge).toBe(1);
-    });
-  });
-
-  describe('cacheCustom', () => {
-    it('should pass through all options', () => {
-      const cache = cacheCustom({ maxAge: 300, staleWhileRevalidate: 600, mode: 'public', tags: ['custom'] });
-      expect(cache.maxAge).toBe(300);
-      expect(cache.staleWhileRevalidate).toBe(600);
-      expect(cache.mode).toBe('public');
-      expect(cache.tags).toEqual(['custom']);
-    });
-  });
-
-  describe('generateCacheControlHeader', () => {
-    it('should generate no-store for cacheNone', () => {
-      expect(generateCacheControlHeader(cacheNone())).toBe('no-store, no-cache, must-revalidate');
-    });
-
-    it('should generate public max-age for cacheLong', () => {
-      const header = generateCacheControlHeader(cacheLong());
-      expect(header).toBe('public, max-age=3600, stale-while-revalidate=82800');
-    });
-
-    it('should generate private max-age for cachePrivate', () => {
-      const header = generateCacheControlHeader(cachePrivate());
-      expect(header).toBe('private, max-age=1, stale-while-revalidate=9');
-    });
-  });
-});