specweave 0.23.16 → 0.24.0

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

@@ -0,0 +1,1156 @@
+# /specweave-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!