specweave 1.0.240 → 1.0.241

package/plugins/specweave-testing/commands/test-generate.md

@@ -1,1160 +0,0 @@
----
-description: Generate comprehensive unit, integration, and E2E tests from components, functions, and API endpoints.
----
-
-# /sw-testing:test-generate
-
-Generate comprehensive unit, integration, and E2E tests from components, functions, and API endpoints.
-
-You are an expert test generation engineer who creates thorough, production-ready test suites.
-
-## Your Task
-
-Analyze code and automatically generate complete test coverage with unit tests, integration tests, and E2E tests.
-
-### 1. Test Generation Strategy
-
-**Unit Tests**:
-- Test individual functions/methods in isolation
-- Mock all external dependencies
-- Cover edge cases and error conditions
-- Achieve 100% branch coverage
-- Fast execution (<10ms per test)
-
-**Integration Tests**:
-- Test component interactions
-- Use real dependencies where practical
-- Test data flow between modules
-- Verify API contracts
-- Database integration testing
-
-**E2E Tests**:
-- Test complete user workflows
-- Verify real browser behavior
-- Test authentication flows
-- Check responsive design
-- Validate accessibility
-
-### 2. Unit Test Generation
-
-**Function Analysis Example**:
-```typescript
-// Source: src/utils/formatters.ts
-export function formatCurrency(
-  amount: number,
-  currency: string = 'USD',
-  locale: string = 'en-US'
-): string {
-  if (typeof amount !== 'number' || isNaN(amount)) {
-    throw new Error('Invalid amount: must be a number');
-  }
-
-  if (amount < 0) {
-    throw new Error('Invalid amount: must be non-negative');
-  }
-
-  return new Intl.NumberFormat(locale, {
-    style: 'currency',
-    currency,
-  }).format(amount);
-}
-```
-
-**Generated Unit Test**:
-```typescript
-// Generated: tests/unit/utils/formatters.test.ts
-import { describe, it, expect } from 'vitest';
-import { formatCurrency } from '@/utils/formatters';
-
-describe('formatCurrency', () => {
-  describe('valid inputs', () => {
-    it('should format USD currency with default locale', () => {
-      expect(formatCurrency(1234.56)).toBe('$1,234.56');
-    });
-
-    it('should format EUR currency', () => {
-      expect(formatCurrency(1234.56, 'EUR', 'de-DE')).toBe('1.234,56 €');
-    });
-
-    it('should format GBP currency', () => {
-      expect(formatCurrency(1234.56, 'GBP', 'en-GB')).toBe('£1,234.56');
-    });
-
-    it('should handle zero amount', () => {
-      expect(formatCurrency(0)).toBe('$0.00');
-    });
-
-    it('should handle large amounts', () => {
-      expect(formatCurrency(1000000)).toBe('$1,000,000.00');
-    });
-
-    it('should handle small amounts', () => {
-      expect(formatCurrency(0.01)).toBe('$0.01');
-    });
-
-    it('should handle floating point precision', () => {
-      expect(formatCurrency(0.1 + 0.2)).toBe('$0.30');
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should throw error for NaN', () => {
-      expect(() => formatCurrency(NaN)).toThrow('Invalid amount: must be a number');
-    });
-
-    it('should throw error for non-number input', () => {
-      expect(() => formatCurrency('123' as any)).toThrow('Invalid amount: must be a number');
-    });
-
-    it('should throw error for negative amounts', () => {
-      expect(() => formatCurrency(-100)).toThrow('Invalid amount: must be non-negative');
-    });
-
-    it('should throw error for undefined', () => {
-      expect(() => formatCurrency(undefined as any)).toThrow('Invalid amount: must be a number');
-    });
-
-    it('should throw error for null', () => {
-      expect(() => formatCurrency(null as any)).toThrow('Invalid amount: must be a number');
-    });
-  });
-
-  describe('locale variations', () => {
-    it('should use French locale', () => {
-      expect(formatCurrency(1234.56, 'EUR', 'fr-FR')).toContain('1');
-    });
-
-    it('should use Japanese locale', () => {
-      expect(formatCurrency(1234, 'JPY', 'ja-JP')).toContain('¥');
-    });
-  });
-});
-```
-
-### 3. Component Test Generation
-
-**React Component Analysis**:
-```typescript
-// Source: src/components/Button.tsx
-interface ButtonProps {
-  children: React.ReactNode;
-  onClick?: () => void;
-  variant?: 'primary' | 'secondary' | 'danger';
-  disabled?: boolean;
-  loading?: boolean;
-  icon?: React.ReactNode;
-  fullWidth?: boolean;
-}
-
-export function Button({
-  children,
-  onClick,
-  variant = 'primary',
-  disabled = false,
-  loading = false,
-  icon,
-  fullWidth = false,
-}: ButtonProps) {
-  return (
-    <button
-      onClick={onClick}
-      disabled={disabled || loading}
-      className={`btn btn-${variant} ${fullWidth ? 'w-full' : ''}`}
-      data-testid="button"
-    >
-      {loading && <Spinner />}
-      {icon && <span className="icon">{icon}</span>}
-      {children}
-    </button>
-  );
-}
-```
-
-**Generated Component Test**:
-```typescript
-// Generated: tests/unit/components/Button.test.tsx
-import { describe, it, expect, vi } from 'vitest';
-import { render, screen, fireEvent } from '@/tests/utils/test-utils';
-import { Button } from '@/components/Button';
-
-describe('Button', () => {
-  describe('rendering', () => {
-    it('should render button with text', () => {
-      render(<Button>Click me</Button>);
-      expect(screen.getByText('Click me')).toBeInTheDocument();
-    });
-
-    it('should render primary variant by default', () => {
-      render(<Button>Click me</Button>);
-      expect(screen.getByTestId('button')).toHaveClass('btn-primary');
-    });
-
-    it('should render secondary variant', () => {
-      render(<Button variant="secondary">Click me</Button>);
-      expect(screen.getByTestId('button')).toHaveClass('btn-secondary');
-    });
-
-    it('should render danger variant', () => {
-      render(<Button variant="danger">Delete</Button>);
-      expect(screen.getByTestId('button')).toHaveClass('btn-danger');
-    });
-
-    it('should render with icon', () => {
-      const icon = <span data-testid="custom-icon">📧</span>;
-      render(<Button icon={icon}>Send</Button>);
-      expect(screen.getByTestId('custom-icon')).toBeInTheDocument();
-    });
-
-    it('should render full width', () => {
-      render(<Button fullWidth>Click me</Button>);
-      expect(screen.getByTestId('button')).toHaveClass('w-full');
-    });
-  });
-
-  describe('interactions', () => {
-    it('should call onClick when clicked', () => {
-      const handleClick = vi.fn();
-      render(<Button onClick={handleClick}>Click me</Button>);
-
-      fireEvent.click(screen.getByTestId('button'));
-      expect(handleClick).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not call onClick when disabled', () => {
-      const handleClick = vi.fn();
-      render(<Button onClick={handleClick} disabled>Click me</Button>);
-
-      fireEvent.click(screen.getByTestId('button'));
-      expect(handleClick).not.toHaveBeenCalled();
-    });
-
-    it('should not call onClick when loading', () => {
-      const handleClick = vi.fn();
-      render(<Button onClick={handleClick} loading>Click me</Button>);
-
-      fireEvent.click(screen.getByTestId('button'));
-      expect(handleClick).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('states', () => {
-    it('should be disabled when disabled prop is true', () => {
-      render(<Button disabled>Click me</Button>);
-      expect(screen.getByTestId('button')).toBeDisabled();
-    });
-
-    it('should be disabled when loading', () => {
-      render(<Button loading>Click me</Button>);
-      expect(screen.getByTestId('button')).toBeDisabled();
-    });
-
-    it('should show spinner when loading', () => {
-      render(<Button loading>Click me</Button>);
-      expect(screen.getByTestId('spinner')).toBeInTheDocument();
-    });
-  });
-
-  describe('accessibility', () => {
-    it('should have button role', () => {
-      render(<Button>Click me</Button>);
-      expect(screen.getByRole('button')).toBeInTheDocument();
-    });
-
-    it('should be keyboard accessible', () => {
-      const handleClick = vi.fn();
-      render(<Button onClick={handleClick}>Click me</Button>);
-
-      const button = screen.getByTestId('button');
-      button.focus();
-      expect(button).toHaveFocus();
-    });
-  });
-});
-```
-
-### 4. API Endpoint Test Generation
-
-**API Route Analysis**:
-```typescript
-// Source: src/api/users.ts
-export async function GET(request: Request) {
-  const { searchParams } = new URL(request.url);
-  const page = parseInt(searchParams.get('page') || '1');
-  const limit = parseInt(searchParams.get('limit') || '10');
-
-  if (page < 1 || limit < 1 || limit > 100) {
-    return Response.json(
-      { error: 'Invalid pagination parameters' },
-      { status: 400 }
-    );
-  }
-
-  const users = await db.users.findMany({
-    skip: (page - 1) * limit,
-    take: limit,
-  });
-
-  return Response.json({ users, page, limit });
-}
-
-export async function POST(request: Request) {
-  const body = await request.json();
-
-  const { email, name, role } = body;
-
-  if (!email || !name) {
-    return Response.json(
-      { error: 'Email and name are required' },
-      { status: 400 }
-    );
-  }
-
-  const existingUser = await db.users.findUnique({ where: { email } });
-  if (existingUser) {
-    return Response.json(
-      { error: 'User already exists' },
-      { status: 409 }
-    );
-  }
-
-  const user = await db.users.create({
-    data: { email, name, role: role || 'user' },
-  });
-
-  return Response.json({ user }, { status: 201 });
-}
-```
-
-**Generated API Test**:
-```typescript
-// Generated: tests/integration/api/users.test.ts
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { GET, POST } from '@/api/users';
-import { db } from '@/lib/db';
-
-// Mock database
-vi.mock('@/lib/db', () => ({
-  db: {
-    users: {
-      findMany: vi.fn(),
-      findUnique: vi.fn(),
-      create: vi.fn(),
-    },
-  },
-}));
-
-describe('Users API', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('GET /api/users', () => {
-    it('should return users with default pagination', async () => {
-      const mockUsers = [
-        { id: '1', email: 'user1@example.com', name: 'User 1' },
-        { id: '2', email: 'user2@example.com', name: 'User 2' },
-      ];
-
-      vi.mocked(db.users.findMany).mockResolvedValue(mockUsers);
-
-      const request = new Request('http://localhost/api/users');
-      const response = await GET(request);
-      const data = await response.json();
-
-      expect(response.status).toBe(200);
-      expect(data.users).toEqual(mockUsers);
-      expect(data.page).toBe(1);
-      expect(data.limit).toBe(10);
-      expect(db.users.findMany).toHaveBeenCalledWith({
-        skip: 0,
-        take: 10,
-      });
-    });
-
-    it('should handle custom pagination', async () => {
-      vi.mocked(db.users.findMany).mockResolvedValue([]);
-
-      const request = new Request('http://localhost/api/users?page=2&limit=20');
-      const response = await GET(request);
-      const data = await response.json();
-
-      expect(data.page).toBe(2);
-      expect(data.limit).toBe(20);
-      expect(db.users.findMany).toHaveBeenCalledWith({
-        skip: 20,
-        take: 20,
-      });
-    });
-
-    it('should reject invalid page number', async () => {
-      const request = new Request('http://localhost/api/users?page=0');
-      const response = await GET(request);
-      const data = await response.json();
-
-      expect(response.status).toBe(400);
-      expect(data.error).toBe('Invalid pagination parameters');
-    });
-
-    it('should reject limit over 100', async () => {
-      const request = new Request('http://localhost/api/users?limit=101');
-      const response = await GET(request);
-      const data = await response.json();
-
-      expect(response.status).toBe(400);
-      expect(data.error).toBe('Invalid pagination parameters');
-    });
-
-    it('should handle database errors', async () => {
-      vi.mocked(db.users.findMany).mockRejectedValue(new Error('DB error'));
-
-      const request = new Request('http://localhost/api/users');
-
-      await expect(GET(request)).rejects.toThrow('DB error');
-    });
-  });
-
-  describe('POST /api/users', () => {
-    it('should create new user', async () => {
-      const newUser = {
-        email: 'new@example.com',
-        name: 'New User',
-        role: 'user',
-      };
-
-      vi.mocked(db.users.findUnique).mockResolvedValue(null);
-      vi.mocked(db.users.create).mockResolvedValue({
-        id: '123',
-        ...newUser,
-      });
-
-      const request = new Request('http://localhost/api/users', {
-        method: 'POST',
-        body: JSON.stringify(newUser),
-      });
-
-      const response = await POST(request);
-      const data = await response.json();
-
-      expect(response.status).toBe(201);
-      expect(data.user).toMatchObject(newUser);
-      expect(db.users.create).toHaveBeenCalledWith({
-        data: newUser,
-      });
-    });
-
-    it('should default role to user', async () => {
-      vi.mocked(db.users.findUnique).mockResolvedValue(null);
-      vi.mocked(db.users.create).mockResolvedValue({
-        id: '123',
-        email: 'test@example.com',
-        name: 'Test',
-        role: 'user',
-      });
-
-      const request = new Request('http://localhost/api/users', {
-        method: 'POST',
-        body: JSON.stringify({ email: 'test@example.com', name: 'Test' }),
-      });
-
-      await POST(request);
-
-      expect(db.users.create).toHaveBeenCalledWith({
-        data: {
-          email: 'test@example.com',
-          name: 'Test',
-          role: 'user',
-        },
-      });
-    });
-
-    it('should reject missing email', async () => {
-      const request = new Request('http://localhost/api/users', {
-        method: 'POST',
-        body: JSON.stringify({ name: 'Test' }),
-      });
-
-      const response = await POST(request);
-      const data = await response.json();
-
-      expect(response.status).toBe(400);
-      expect(data.error).toBe('Email and name are required');
-    });
-
-    it('should reject missing name', async () => {
-      const request = new Request('http://localhost/api/users', {
-        method: 'POST',
-        body: JSON.stringify({ email: 'test@example.com' }),
-      });
-
-      const response = await POST(request);
-      const data = await response.json();
-
-      expect(response.status).toBe(400);
-      expect(data.error).toBe('Email and name are required');
-    });
-
-    it('should reject duplicate email', async () => {
-      vi.mocked(db.users.findUnique).mockResolvedValue({
-        id: '123',
-        email: 'existing@example.com',
-        name: 'Existing',
-        role: 'user',
-      });
-
-      const request = new Request('http://localhost/api/users', {
-        method: 'POST',
-        body: JSON.stringify({
-          email: 'existing@example.com',
-          name: 'Test',
-        }),
-      });
-
-      const response = await POST(request);
-      const data = await response.json();
-
-      expect(response.status).toBe(409);
-      expect(data.error).toBe('User already exists');
-    });
-  });
-});
-```
-
-### 5. Custom Hook Test Generation
-
-**Hook Analysis**:
-```typescript
-// Source: src/hooks/useDebounce.ts
-import { useState, useEffect } from 'react';
-
-export function useDebounce<T>(value: T, delay: number): T {
-  const [debouncedValue, setDebouncedValue] = useState<T>(value);
-
-  useEffect(() => {
-    const handler = setTimeout(() => {
-      setDebouncedValue(value);
-    }, delay);
-
-    return () => {
-      clearTimeout(handler);
-    };
-  }, [value, delay]);
-
-  return debouncedValue;
-}
-```
-
-**Generated Hook Test**:
-```typescript
-// Generated: tests/unit/hooks/useDebounce.test.ts
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { renderHook, waitFor } from '@testing-library/react';
-import { useDebounce } from '@/hooks/useDebounce';
-
-describe('useDebounce', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('should return initial value immediately', () => {
-    const { result } = renderHook(() => useDebounce('initial', 500));
-    expect(result.current).toBe('initial');
-  });
-
-  it('should debounce value changes', async () => {
-    const { result, rerender } = renderHook(
-      ({ value, delay }) => useDebounce(value, delay),
-      { initialProps: { value: 'initial', delay: 500 } }
-    );
-
-    expect(result.current).toBe('initial');
-
-    // Update value
-    rerender({ value: 'updated', delay: 500 });
-
-    // Value should not change immediately
-    expect(result.current).toBe('initial');
-
-    // Fast-forward time
-    vi.advanceTimersByTime(500);
-
-    // Value should update after delay
-    await waitFor(() => {
-      expect(result.current).toBe('updated');
-    });
-  });
-
-  it('should cancel previous timeout on rapid changes', async () => {
-    const { result, rerender } = renderHook(
-      ({ value }) => useDebounce(value, 500),
-      { initialProps: { value: 'initial' } }
-    );
-
-    // Rapid updates
-    rerender({ value: 'update1' });
-    vi.advanceTimersByTime(200);
-
-    rerender({ value: 'update2' });
-    vi.advanceTimersByTime(200);
-
-    rerender({ value: 'final' });
-    vi.advanceTimersByTime(500);
-
-    await waitFor(() => {
-      expect(result.current).toBe('final');
-    });
-  });
-
-  it('should handle delay changes', async () => {
-    const { result, rerender } = renderHook(
-      ({ value, delay }) => useDebounce(value, delay),
-      { initialProps: { value: 'initial', delay: 500 } }
-    );
-
-    rerender({ value: 'updated', delay: 1000 });
-    vi.advanceTimersByTime(500);
-
-    // Should not update yet (new delay is 1000ms)
-    expect(result.current).toBe('initial');
-
-    vi.advanceTimersByTime(500);
-
-    await waitFor(() => {
-      expect(result.current).toBe('updated');
-    });
-  });
-
-  it('should handle different value types', async () => {
-    // Number
-    const { result: numberResult } = renderHook(() => useDebounce(42, 100));
-    expect(numberResult.current).toBe(42);
-
-    // Object
-    const obj = { name: 'test' };
-    const { result: objResult } = renderHook(() => useDebounce(obj, 100));
-    expect(objResult.current).toBe(obj);
-
-    // Array
-    const arr = [1, 2, 3];
-    const { result: arrResult } = renderHook(() => useDebounce(arr, 100));
-    expect(arrResult.current).toBe(arr);
-  });
-});
-```
-
-### 6. Store/State Management Test Generation
-
-**Zustand Store Analysis**:
-```typescript
-// Source: src/stores/useCartStore.ts
-import { create } from 'zustand';
-
-interface CartItem {
-  id: string;
-  name: string;
-  price: number;
-  quantity: number;
-}
-
-interface CartStore {
-  items: CartItem[];
-  addItem: (item: Omit<CartItem, 'quantity'>) => void;
-  removeItem: (id: string) => void;
-  updateQuantity: (id: string, quantity: number) => void;
-  clearCart: () => void;
-  total: () => number;
-}
-
-export const useCartStore = create<CartStore>((set, get) => ({
-  items: [],
-
-  addItem: (item) => {
-    set((state) => {
-      const existing = state.items.find((i) => i.id === item.id);
-      if (existing) {
-        return {
-          items: state.items.map((i) =>
-            i.id === item.id ? { ...i, quantity: i.quantity + 1 } : i
-          ),
-        };
-      }
-      return { items: [...state.items, { ...item, quantity: 1 }] };
-    });
-  },
-
-  removeItem: (id) => {
-    set((state) => ({
-      items: state.items.filter((i) => i.id !== id),
-    }));
-  },
-
-  updateQuantity: (id, quantity) => {
-    if (quantity <= 0) {
-      get().removeItem(id);
-      return;
-    }
-    set((state) => ({
-      items: state.items.map((i) =>
-        i.id === id ? { ...i, quantity } : i
-      ),
-    }));
-  },
-
-  clearCart: () => {
-    set({ items: [] });
-  },
-
-  total: () => {
-    return get().items.reduce((sum, item) => sum + item.price * item.quantity, 0);
-  },
-}));
-```
-
-**Generated Store Test**:
-```typescript
-// Generated: tests/unit/stores/useCartStore.test.ts
-import { describe, it, expect, beforeEach } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import { useCartStore } from '@/stores/useCartStore';
-
-describe('useCartStore', () => {
-  beforeEach(() => {
-    // Reset store before each test
-    const { result } = renderHook(() => useCartStore());
-    act(() => {
-      result.current.clearCart();
-    });
-  });
-
-  describe('addItem', () => {
-    it('should add new item to cart', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({
-          id: '1',
-          name: 'Product A',
-          price: 29.99,
-        });
-      });
-
-      expect(result.current.items).toHaveLength(1);
-      expect(result.current.items[0]).toMatchObject({
-        id: '1',
-        name: 'Product A',
-        price: 29.99,
-        quantity: 1,
-      });
-    });
-
-    it('should increment quantity for existing item', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({
-          id: '1',
-          name: 'Product A',
-          price: 29.99,
-        });
-        result.current.addItem({
-          id: '1',
-          name: 'Product A',
-          price: 29.99,
-        });
-      });
-
-      expect(result.current.items).toHaveLength(1);
-      expect(result.current.items[0].quantity).toBe(2);
-    });
-
-    it('should add multiple different items', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({ id: '1', name: 'Product A', price: 29.99 });
-        result.current.addItem({ id: '2', name: 'Product B', price: 39.99 });
-      });
-
-      expect(result.current.items).toHaveLength(2);
-    });
-  });
-
-  describe('removeItem', () => {
-    it('should remove item from cart', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({ id: '1', name: 'Product A', price: 29.99 });
-        result.current.removeItem('1');
-      });
-
-      expect(result.current.items).toHaveLength(0);
-    });
-
-    it('should not affect other items', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({ id: '1', name: 'Product A', price: 29.99 });
-        result.current.addItem({ id: '2', name: 'Product B', price: 39.99 });
-        result.current.removeItem('1');
-      });
-
-      expect(result.current.items).toHaveLength(1);
-      expect(result.current.items[0].id).toBe('2');
-    });
-
-    it('should handle removing non-existent item', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({ id: '1', name: 'Product A', price: 29.99 });
-        result.current.removeItem('999');
-      });
-
-      expect(result.current.items).toHaveLength(1);
-    });
-  });
-
-  describe('updateQuantity', () => {
-    it('should update item quantity', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({ id: '1', name: 'Product A', price: 29.99 });
-        result.current.updateQuantity('1', 5);
-      });
-
-      expect(result.current.items[0].quantity).toBe(5);
-    });
-
-    it('should remove item when quantity is 0', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({ id: '1', name: 'Product A', price: 29.99 });
-        result.current.updateQuantity('1', 0);
-      });
-
-      expect(result.current.items).toHaveLength(0);
-    });
-
-    it('should remove item when quantity is negative', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({ id: '1', name: 'Product A', price: 29.99 });
-        result.current.updateQuantity('1', -1);
-      });
-
-      expect(result.current.items).toHaveLength(0);
-    });
-  });
-
-  describe('clearCart', () => {
-    it('should remove all items', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({ id: '1', name: 'Product A', price: 29.99 });
-        result.current.addItem({ id: '2', name: 'Product B', price: 39.99 });
-        result.current.clearCart();
-      });
-
-      expect(result.current.items).toHaveLength(0);
-    });
-  });
-
-  describe('total', () => {
-    it('should calculate total for single item', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({ id: '1', name: 'Product A', price: 29.99 });
-      });
-
-      expect(result.current.total()).toBe(29.99);
-    });
-
-    it('should calculate total for multiple items', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({ id: '1', name: 'Product A', price: 29.99 });
-        result.current.addItem({ id: '2', name: 'Product B', price: 39.99 });
-      });
-
-      expect(result.current.total()).toBe(69.98);
-    });
-
-    it('should calculate total with quantities', () => {
-      const { result } = renderHook(() => useCartStore());
-
-      act(() => {
-        result.current.addItem({ id: '1', name: 'Product A', price: 10 });
-        result.current.updateQuantity('1', 3);
-      });
-
-      expect(result.current.total()).toBe(30);
-    });
-
-    it('should return 0 for empty cart', () => {
-      const { result } = renderHook(() => useCartStore());
-      expect(result.current.total()).toBe(0);
-    });
-  });
-});
-```
-
-### 7. Test Generation CLI
-
-**Test Generator Script**:
-```typescript
-// scripts/generate-tests.ts
-import fs from 'fs';
-import path from 'path';
-import { parse } from '@babel/parser';
-import traverse from '@babel/traverse';
-
-interface TestConfig {
-  sourceFile: string;
-  testType: 'unit' | 'integration' | 'e2e';
-  outputFile?: string;
-}
-
-export async function generateTests(config: TestConfig) {
-  const code = fs.readFileSync(config.sourceFile, 'utf-8');
-  const ast = parse(code, {
-    sourceType: 'module',
-    plugins: ['typescript', 'jsx'],
-  });
-
-  const tests: string[] = [];
-
-  traverse(ast, {
-    FunctionDeclaration(path) {
-      const name = path.node.id?.name;
-      if (name) {
-        tests.push(generateFunctionTest(name, path.node));
-      }
-    },
-    ExportNamedDeclaration(path) {
-      if (path.node.declaration?.type === 'FunctionDeclaration') {
-        const name = path.node.declaration.id?.name;
-        if (name) {
-          tests.push(generateFunctionTest(name, path.node.declaration));
-        }
-      }
-    },
-  });
-
-  const outputPath = config.outputFile || generateOutputPath(config.sourceFile);
-  const testContent = generateTestFile(tests, config.sourceFile);
-
-  fs.writeFileSync(outputPath, testContent, 'utf-8');
-  console.log(`✓ Generated tests: ${outputPath}`);
-}
-
-function generateOutputPath(sourceFile: string): string {
-  const relativePath = path.relative('src', sourceFile);
-  return path.join('tests', 'unit', relativePath.replace(/\.ts$/, '.test.ts'));
-}
-
-function generateFunctionTest(name: string, node: any): string {
-  return `
-  describe('${name}', () => {
-    it('should work correctly', () => {
-      // TODO: Implement test
-      expect(${name}).toBeDefined();
-    });
-  });
-  `;
-}
-
-function generateTestFile(tests: string[], sourceFile: string): string {
-  const importPath = path.relative(
-    path.dirname(generateOutputPath(sourceFile)),
-    sourceFile
-  ).replace(/\.ts$/, '');
-
-  return `
-import { describe, it, expect } from 'vitest';
-import { } from '${importPath}';
-
-describe('${path.basename(sourceFile)}', () => {
-  ${tests.join('\n')}
-});
-  `.trim();
-}
-```
-
-### 8. Test Templates
-
-**Template Registry** (`tests/templates/`):
-```typescript
-// tests/templates/component.template.ts
-export const componentTestTemplate = `
-import { describe, it, expect, vi } from 'vitest';
-import { render, screen } from '@/tests/utils/test-utils';
-import { {{ComponentName}} } from '@/components/{{ComponentName}}';
-
-describe('{{ComponentName}}', () => {
-  it('should render correctly', () => {
-    render(<{{ComponentName}} />);
-    expect(screen.getByTestId('{{testId}}')).toBeInTheDocument();
-  });
-
-  it('should handle user interactions', () => {
-    const handleClick = vi.fn();
-    render(<{{ComponentName}} onClick={handleClick} />);
-
-    fireEvent.click(screen.getByTestId('{{testId}}'));
-    expect(handleClick).toHaveBeenCalled();
-  });
-});
-`;
-
-// tests/templates/api.template.ts
-export const apiTestTemplate = `
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { {{functionName}} } from '@/api/{{fileName}}';
-
-describe('{{functionName}}', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should return success response', async () => {
-    const request = new Request('http://localhost/api/{{endpoint}}');
-    const response = await {{functionName}}(request);
-
-    expect(response.status).toBe(200);
-  });
-
-  it('should handle errors', async () => {
-    // TODO: Implement error case
-  });
-});
-`;
-```
-
-### 9. Coverage Gaps Detection
-
-**Coverage Analyzer**:
-```typescript
-// scripts/analyze-coverage-gaps.ts
-import fs from 'fs';
-import path from 'path';
-
-interface CoverageSummary {
-  total: {
-    lines: { pct: number };
-    statements: { pct: number };
-    functions: { pct: number };
-    branches: { pct: number };
-  };
-}
-
-export function analyzeCoverageGaps(coverageFile: string) {
-  const coverage: CoverageSummary = JSON.parse(
-    fs.readFileSync(coverageFile, 'utf-8')
-  );
-
-  const gaps = [];
-
-  Object.entries(coverage).forEach(([file, data]) => {
-    if (file === 'total') return;
-
-    const { lines, functions, branches } = data as any;
-
-    if (lines.pct < 80) {
-      gaps.push({
-        file,
-        type: 'lines',
-        current: lines.pct,
-        target: 80,
-        gap: 80 - lines.pct,
-      });
-    }
-
-    if (functions.pct < 80) {
-      gaps.push({
-        file,
-        type: 'functions',
-        current: functions.pct,
-        target: 80,
-        gap: 80 - functions.pct,
-      });
-    }
-
-    if (branches.pct < 80) {
-      gaps.push({
-        file,
-        type: 'branches',
-        current: branches.pct,
-        target: 80,
-        gap: 80 - branches.pct,
-      });
-    }
-  });
-
-  return gaps.sort((a, b) => b.gap - a.gap);
-}
-
-// Generate test stubs for gaps
-export function generateGapTests(gaps: any[]) {
-  gaps.slice(0, 10).forEach((gap) => {
-    console.log(`
-Priority: ${gap.file}
-Coverage: ${gap.current}% ${gap.type}
-Gap: ${gap.gap}%
-
-Suggested tests:
-- Add ${gap.type} coverage for uncovered paths
-- Focus on edge cases and error handling
-    `);
-  });
-}
-```
-
-### 10. Package Scripts
-
-```json
-{
-  "scripts": {
-    "test:generate": "tsx scripts/generate-tests.ts",
-    "test:generate:component": "tsx scripts/generate-tests.ts --type component",
-    "test:generate:api": "tsx scripts/generate-tests.ts --type api",
-    "test:coverage:gaps": "tsx scripts/analyze-coverage-gaps.ts coverage/coverage-summary.json",
-    "test:stub": "tsx scripts/generate-test-stubs.ts"
-  }
-}
-```
-
-## Workflow
-
-1. Ask about code to generate tests for (file path or pattern)
-2. Analyze code structure and identify test targets
-3. Determine appropriate test types (unit/integration/E2E)
-4. Generate test scaffolding with proper imports
-5. Create test cases for happy paths
-6. Add edge case and error handling tests
-7. Generate mocks and fixtures
-8. Add accessibility and performance tests (if applicable)
-9. Run tests to verify they work
-10. Analyze coverage and suggest improvements
-
-## When to Use
-
-- Adding tests to existing code
-- Achieving test coverage targets
-- Creating test stubs for new features
-- Migrating to new testing framework
-- Identifying coverage gaps
-- Implementing TDD workflow
-- Standardizing test patterns
-
-Generate comprehensive test coverage automatically!