Cursor rule

1---
2globs: **/*.test.ts,**/*.test.tsx,**/*.spec.ts,**/*.spec.tsx,**/*_test.go,**/test/**,**/tests/**
3description: Comprehensive testing patterns for React Testing Library and Go testing in POS System
4---
5 
6# 🧪 Testing Patterns & Best Practices
7 
8## 🎯 Testing Philosophy
9 
10### Testing Pyramid for POS System
11```
12    E2E Tests (Few)
13    ↑ Full user workflows
14    ↑ Critical business flows
15    
16  Integration Tests (Some)
17  ↑ API + Database interactions
18  ↑ Component + API integration
19  
20    Unit Tests (Many)
21    ↑ Individual functions
22    ↑ Component behavior
23    ↑ Business logic validation
24```
25 
26### Test Coverage Targets
27- **Unit Tests:** 80%+ coverage for business logic
28- **Integration Tests:** All API endpoints with database
29- **E2E Tests:** Core user journeys (login → order → payment → kitchen)
30 
31## ⚛️ Frontend Testing Patterns (React Testing Library)
32 
33### Component Testing Setup
34```typescript
35// test-utils.tsx - Custom testing utilities
36import { render, RenderOptions } from '@testing-library/react'
37import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
38import { ReactElement } from 'react'
39import { BrowserRouter } from '@tanstack/react-router'
40 
41// Create a test query client with no retries
42const createTestQueryClient = () => new QueryClient({
43  defaultOptions: {
44    queries: {
45      retry: false,      // Don't retry on test failures
46      gcTime: Infinity,  // Keep data in cache
47    },
48    mutations: {
49      retry: false,
50    },
51  },
52})
53 
54interface CustomRenderOptions extends Omit<RenderOptions, 'wrapper'> {
55  queryClient?: QueryClient
56  initialEntries?: string[]
57}
58 
59// Custom render with providers
60export const renderWithProviders = (
61  ui: ReactElement,
62  {
63    queryClient = createTestQueryClient(),
64    initialEntries = ['/'],
65    ...renderOptions
66  }: CustomRenderOptions = {}
67) => {
68  const Wrapper = ({ children }: { children: React.ReactNode }) => (
69    <QueryClientProvider client={queryClient}>
70      <BrowserRouter initialEntries={initialEntries}>
71        {children}
72      </BrowserRouter>
73    </QueryClientProvider>
74  )
75 
76  return { ...render(ui, { wrapper: Wrapper, ...renderOptions }), queryClient }
77}
78 
79// Re-export everything
80export * from '@testing-library/react'
81```
82 
83### Component Testing Examples
84 
85#### 1. Testing POS Product Card
86```typescript
87// ProductCard.test.tsx
88import { screen, userEvent } from '@testing-library/react'
89import { renderWithProviders } from '../test-utils'
90import { ProductCard } from '@/components/pos/ProductCard'
91import { Product } from '@/types'
92 
93const mockProduct: Product = {
94  id: '123',
95  name: 'Cheeseburger',
96  price: 12.99,
97  category_id: 'burgers',
98  is_available: true,
99  description: 'Delicious beef burger',
100  image_url: null,
101}
102 
103describe('ProductCard', () => {
104  const mockOnSelect = jest.fn()
105 
106  beforeEach(() => {
107    mockOnSelect.mockClear()
108  })
109 
110  it('displays product information correctly', () => {
111    renderWithProviders(
112      <ProductCard 
113        product={mockProduct} 
114        onSelect={mockOnSelect} 
115        isSelected={false} 
116      />
117    )
118 
119    expect(screen.getByText('Cheeseburger')).toBeInTheDocument()
120    expect(screen.getByText('$12.99')).toBeInTheDocument()
121    expect(screen.getByText('Delicious beef burger')).toBeInTheDocument()
122  })
123 
124  it('calls onSelect when clicked', async () => {
125    const user = userEvent.setup()
126    
127    renderWithProviders(
128      <ProductCard 
129        product={mockProduct} 
130        onSelect={mockOnSelect} 
131        isSelected={false} 
132      />
133    )
134 
135    await user.click(screen.getByText('Cheeseburger'))
136    expect(mockOnSelect).toHaveBeenCalledWith(mockProduct)
137  })
138 
139  it('shows selected state correctly', () => {
140    renderWithProviders(
141      <ProductCard 
142        product={mockProduct} 
143        onSelect={mockOnSelect} 
144        isSelected={true} 
145      />
146    )
147 
148    const card = screen.getByRole('button')
149    expect(card).toHaveClass('ring-2', 'ring-primary')
150  })
151 
152  it('disables unavailable products', () => {
153    const unavailableProduct = { ...mockProduct, is_available: false }
154    
155    renderWithProviders(
156      <ProductCard 
157        product={unavailableProduct} 
158        onSelect={mockOnSelect} 
159        isSelected={false} 
160      />
161    )
162 
163    const card = screen.getByRole('button')
164    expect(card).toBeDisabled()
165    expect(screen.getByText('Unavailable')).toBeInTheDocument()
166  })
167})
168```
169 
170#### 2. Testing Forms with React Hook Form
171```typescript
172// OrderForm.test.tsx
173import { screen, userEvent, waitFor } from '@testing-library/react'
174import { renderWithProviders } from '../test-utils'
175import { OrderForm } from '@/components/forms/OrderForm'
176import { CreateOrderRequest } from '@/types'
177 
178// Mock API client
179jest.mock('@/api/client', () => ({
180  createOrder: jest.fn(),
181}))
182 
183describe('OrderForm', () => {
184  const mockOnSubmit = jest.fn()
185  const mockOnCancel = jest.fn()
186 
187  beforeEach(() => {
188    mockOnSubmit.mockClear()
189    mockOnCancel.mockClear()
190  })
191 
192  it('renders form fields correctly', () => {
193    renderWithProviders(
194      <OrderForm onSubmit={mockOnSubmit} onCancel={mockOnCancel} />
195    )
196 
197    expect(screen.getByLabelText(/order type/i)).toBeInTheDocument()
198    expect(screen.getByLabelText(/customer name/i)).toBeInTheDocument()
199    expect(screen.getByRole('button', { name: /create order/i })).toBeInTheDocument()
200    expect(screen.getByRole('button', { name: /cancel/i })).toBeInTheDocument()
201  })
202 
203  it('validates required fields', async () => {
204    const user = userEvent.setup()
205    
206    renderWithProviders(
207      <OrderForm onSubmit={mockOnSubmit} onCancel={mockOnCancel} />
208    )
209 
210    // Try to submit without selecting order type
211    await user.click(screen.getByRole('button', { name: /create order/i }))
212 
213    await waitFor(() => {
214      expect(screen.getByText(/order type is required/i)).toBeInTheDocument()
215    })
216 
217    expect(mockOnSubmit).not.toHaveBeenCalled()
218  })
219 
220  it('submits valid form data', async () => {
221    const user = userEvent.setup()
222    
223    renderWithProviders(
224      <OrderForm onSubmit={mockOnSubmit} onCancel={mockOnCancel} />
225    )
226 
227    // Fill out form
228    await user.selectOptions(screen.getByLabelText(/order type/i), 'dine_in')
229    await user.type(screen.getByLabelText(/customer name/i), 'John Doe')
230 
231    // Submit
232    await user.click(screen.getByRole('button', { name: /create order/i }))
233 
234    await waitFor(() => {
235      expect(mockOnSubmit).toHaveBeenCalledWith({
236        order_type: 'dine_in',
237        customer_name: 'John Doe',
238        items: [],
239        notes: '',
240      })
241    })
242  })
243})
244```
245 
246#### 3. Testing API Integration with MSW
247```typescript
248// api-integration.test.tsx
249import { rest } from 'msw'
250import { setupServer } from 'msw/node'
251import { screen, userEvent, waitFor } from '@testing-library/react'
252import { renderWithProviders } from '../test-utils'
253import { ProductList } from '@/components/pos/ProductList'
254 
255// Mock API server
256const server = setupServer(
257  rest.get('http://localhost:8080/api/v1/products', (req, res, ctx) => {
258    return res(
259      ctx.json({
260        success: true,
261        data: [
262          { id: '1', name: 'Burger', price: 10.99, is_available: true },
263          { id: '2', name: 'Pizza', price: 15.99, is_available: true },
264        ]
265      })
266    )
267  }),
268  
269  rest.post('http://localhost:8080/api/v1/orders', (req, res, ctx) => {
270    return res(
271      ctx.json({
272        success: true,
273        data: { id: 'order-1', order_number: 'ORD-001' }
274      })
275    )
276  })
277)
278 
279beforeAll(() => server.listen())
280afterEach(() => server.resetHandlers())
281afterAll(() => server.close())
282 
283describe('ProductList Integration', () => {
284  it('loads and displays products from API', async () => {
285    renderWithProviders(<ProductList onProductSelect={jest.fn()} />)
286 
287    // Wait for products to load
288    await waitFor(() => {
289      expect(screen.getByText('Burger')).toBeInTheDocument()
290      expect(screen.getByText('Pizza')).toBeInTheDocument()
291    })
292  })
293 
294  it('handles API errors gracefully', async () => {
295    // Mock server error
296    server.use(
297      rest.get('http://localhost:8080/api/v1/products', (req, res, ctx) => {
298        return res(ctx.status(500), ctx.json({ error: 'Server error' }))
299      })
300    )
301 
302    renderWithProviders(<ProductList onProductSelect={jest.fn()} />)
303 
304    await waitFor(() => {
305      expect(screen.getByText(/failed to load products/i)).toBeInTheDocument()
306    })
307  })
308})
309```
310 
311### Custom Hooks Testing
312```typescript
313// useCart.test.ts
314import { renderHook, act } from '@testing-library/react'
315import { useCart } from '@/hooks/useCart'
316import { Product } from '@/types'
317 
318const mockProduct: Product = {
319  id: '1',
320  name: 'Test Product',
321  price: 10.00,
322  category_id: 'test',
323  is_available: true,
324}
325 
326describe('useCart', () => {
327  it('adds items to cart correctly', () => {
328    const { result } = renderHook(() => useCart())
329 
330    act(() => {
331      result.current.addItem(mockProduct, 2)
332    })
333 
334    expect(result.current.items).toHaveLength(1)
335    expect(result.current.items[0]).toEqual({
336      product: mockProduct,
337      quantity: 2,
338      subtotal: 20.00,
339    })
340    expect(result.current.total).toBe(20.00)
341  })
342 
343  it('updates item quantity correctly', () => {
344    const { result } = renderHook(() => useCart())
345 
346    act(() => {
347      result.current.addItem(mockProduct, 1)
348      result.current.updateQuantity(mockProduct.id, 3)
349    })
350 
351    expect(result.current.items[0].quantity).toBe(3)
352    expect(result.current.total).toBe(30.00)
353  })
354 
355  it('removes items from cart', () => {
356    const { result } = renderHook(() => useCart())
357 
358    act(() => {
359      result.current.addItem(mockProduct, 1)
360      result.current.removeItem(mockProduct.id)
361    })
362 
363    expect(result.current.items).toHaveLength(0)
364    expect(result.current.total).toBe(0)
365  })
366})
367```
368 
369## 🔧 Backend Testing Patterns (Go)
370 
371### Test Structure and Setup
372```go
373// handlers_test.go
374package handlers
375 
376import (
377    "bytes"
378    "encoding/json"
379    "net/http"
380    "net/http/httptest"
381    "testing"
382 
383    "github.com/gin-gonic/gin"
384    "github.com/stretchr/testify/assert"
385    "github.com/stretchr/testify/require"
386    "your-project/internal/models"
387)
388 
389// Setup test router with middleware
390func setupTestRouter() *gin.Engine {
391    gin.SetMode(gin.TestMode)
392    router := gin.New()
393    
394    // Add necessary middleware for tests
395    router.Use(gin.Recovery())
396    
397    return router
398}
399 
400// Helper to create authenticated request
401func createAuthenticatedRequest(method, url string, body interface{}, userID, role string) *http.Request {
402    var reqBody []byte
403    if body != nil {
404        reqBody, _ = json.Marshal(body)
405    }
406    
407    req := httptest.NewRequest(method, url, bytes.NewBuffer(reqBody))
408    req.Header.Set("Content-Type", "application/json")
409    
410    // Add auth context for testing
411    req.Header.Set("X-User-ID", userID)
412    req.Header.Set("X-User-Role", role)
413    
414    return req
415}
416```
417 
418### Testing HTTP Handlers
419```go
420// order_handler_test.go
421func TestOrderHandler_CreateOrder(t *testing.T) {
422    db := setupTestDB(t)
423    defer teardownTestDB(t, db)
424    
425    orderHandler := NewOrderHandler(db)
426    router := setupTestRouter()
427    router.POST("/orders", orderHandler.CreateOrder)
428 
429    tests := []struct {
430        name         string
431        request      models.CreateOrderRequest
432        userRole     string
433        expectedCode int
434        expectError  string
435    }{
436        {
437            name: "valid dine-in order",
438            request: models.CreateOrderRequest{
439                OrderType:    "dine_in",
440                CustomerName: stringPtr("John Doe"),
441                Items: []models.CreateOrderItem{
442                    {ProductID: "product-1", Quantity: 2},
443                },
444            },
445            userRole:     "server",
446            expectedCode: http.StatusCreated,
447        },
448        {
449            name: "empty order items",
450            request: models.CreateOrderRequest{
451                OrderType: "dine_in",
452                Items:     []models.CreateOrderItem{},
453            },
454            userRole:     "server",
455            expectedCode: http.StatusBadRequest,
456            expectError:  "empty_order",
457        },
458        {
459            name: "invalid order type",
460            request: models.CreateOrderRequest{
461                OrderType: "invalid_type",
462                Items: []models.CreateOrderItem{
463                    {ProductID: "product-1", Quantity: 1},
464                },
465            },
466            userRole:     "server",
467            expectedCode: http.StatusBadRequest,
468            expectError:  "invalid_order_type",
469        },
470    }
471 
472    for _, tt := range tests {
473        t.Run(tt.name, func(t *testing.T) {
474            req := createAuthenticatedRequest("POST", "/orders", tt.request, "user-1", tt.userRole)
475            w := httptest.NewRecorder()
476            
477            router.ServeHTTP(w, req)
478            
479            assert.Equal(t, tt.expectedCode, w.Code)
480            
481            var response models.APIResponse
482            err := json.Unmarshal(w.Body.Bytes(), &response)
483            require.NoError(t, err)
484            
485            if tt.expectError != "" {
486                assert.False(t, response.Success)
487                assert.NotNil(t, response.Error)
488                assert.Equal(t, tt.expectError, *response.Error)
489            } else {
490                assert.True(t, response.Success)
491                assert.NotNil(t, response.Data)
492            }
493        })
494    }
495}
496```
497 
498### Database Integration Testing
499```go
500// database_test.go
501func setupTestDB(t *testing.T) *sql.DB {
502    db, err := sql.Open("postgres", "postgresql://test:test@localhost:5433/pos_test?sslmode=disable")
503    require.NoError(t, err)
504    
505    // Run migrations or seed test data
506    seedTestData(t, db)
507    
508    return db
509}
510 
511func teardownTestDB(t *testing.T, db *sql.DB) {
512    // Clean up test data
513    cleanupTestData(t, db)
514    db.Close()
515}
516 
517func seedTestData(t *testing.T, db *sql.DB) {
518    // Insert test products
519    _, err := db.Exec(`
520        INSERT INTO products (id, name, price, category_id, is_available)
521        VALUES 
522            ('product-1', 'Test Burger', 10.99, 'category-1', true),
523            ('product-2', 'Test Pizza', 15.99, 'category-1', true)
524    `)
525    require.NoError(t, err)
526    
527    // Insert test users
528    _, err = db.Exec(`
529        INSERT INTO users (id, username, role, password_hash)
530        VALUES 
531            ('user-1', 'testserver', 'server', '$2b$10$hash'),
532            ('user-2', 'testadmin', 'admin', '$2b$10$hash')
533    `)
534    require.NoError(t, err)
535}
536 
537func cleanupTestData(t *testing.T, db *sql.DB) {
538    tables := []string{"order_items", "orders", "products", "categories", "users"}
539    for _, table := range tables {
540        _, err := db.Exec(fmt.Sprintf("DELETE FROM %s", table))
541        require.NoError(t, err)
542    }
543}
544```
545 
546### Testing Business Logic
547```go
548// order_service_test.go
549func TestCalculateOrderTotal(t *testing.T) {
550    tests := []struct {
551        name     string
552        items    []models.OrderItem
553        expected float64
554    }{
555        {
556            name: "single item",
557            items: []models.OrderItem{
558                {Price: 10.99, Quantity: 1},
559            },
560            expected: 10.99,
561        },
562        {
563            name: "multiple items",
564            items: []models.OrderItem{
565                {Price: 10.99, Quantity: 2},
566                {Price: 5.50, Quantity: 1},
567            },
568            expected: 27.48,
569        },
570        {
571            name:     "empty order",
572            items:    []models.OrderItem{},
573            expected: 0.00,
574        },
575    }
576 
577    for _, tt := range tests {
578        t.Run(tt.name, func(t *testing.T) {
579            total := calculateOrderTotal(tt.items)
580            assert.Equal(t, tt.expected, total)
581        })
582    }
583}
584```
585 
586## 🎭 E2E Testing Strategy
587 
588### Critical User Journeys
589```typescript
590// e2e/order-flow.spec.ts
591import { test, expect } from '@playwright/test'
592 
593test.describe('Complete Order Flow', () => {
594  test('admin can process full order lifecycle', async ({ page }) => {
595    // Login as admin
596    await page.goto('/login')
597    await page.fill('[name="username"]', 'admin')
598    await page.fill('[name="password"]', 'admin123')
599    await page.click('button[type="submit"]')
600    
601    // Navigate to server interface
602    await page.click('text=Server Interface')
603    
604    // Create order
605    await page.click('text=Cheeseburger')
606    await page.click('text=Add Fries')
607    await page.click('button:has-text("Create Order")')
608    
609    // Verify order created
610    await expect(page.locator('text=Order Created')).toBeVisible()
611    
612    // Switch to kitchen interface
613    await page.click('text=Kitchen Display')
614    
615    // Update order status
616    await page.click('button:has-text("Start Preparing")')
617    await page.click('button:has-text("Ready")')
618    
619    // Switch to counter for payment
620    await page.click('text=Counter/Checkout')
621    
622    // Process payment
623    await page.click('button:has-text("Cash")')
624    await page.fill('[name="amount_received"]', '25.00')
625    await page.click('button:has-text("Complete Payment")')
626    
627    // Verify payment processed
628    await expect(page.locator('text=Payment Complete')).toBeVisible()
629  })
630})
631```
632 
633## 🎯 Testing Best Practices
634 
635### Do's ✅
636- **Test behavior, not implementation** - Focus on what users see and do
637- **Use meaningful test names** - Describe the behavior being tested
638- **Follow AAA pattern** - Arrange, Act, Assert
639- **Mock external dependencies** - Keep tests isolated and fast
640- **Test error states** - Ensure graceful error handling
641- **Use test data builders** - Create reusable test data factories
642 
643### Don'ts ❌
644- **Don't test implementation details** - Avoid testing internal component state
645- **Don't create brittle selectors** - Prefer semantic queries over CSS selectors
646- **Don't share state between tests** - Each test should be independent
647- **Don't mock what you don't own** - Avoid mocking third-party libraries unnecessarily
648- **Don't write tests without assertions** - Every test should verify something
649 
650### Test Organization
651```
652src/
653├── components/
654│   ├── __tests__/           # Component tests
655│   │   ├── ProductCard.test.tsx
656│   │   └── OrderForm.test.tsx
657│   └── ProductCard.tsx
658├── hooks/
659│   ├── __tests__/           # Hook tests
660│   │   └── useCart.test.ts
661│   └── useCart.ts
662├── api/
663│   ├── __tests__/           # API integration tests
664│   │   └── client.test.ts
665│   └── client.ts
666└── __tests__/
667    ├── test-utils.tsx       # Test utilities
668    └── setup.ts             # Test setup
669```
670 
671## 🚀 Development Commands
672 
673### Frontend Testing
674```bash
675# Run all tests
676npm test
677 
678# Run tests in watch mode
679npm run test:watch
680 
681# Run tests with coverage
682npm run test:coverage
683 
684# Run E2E tests
685npm run test:e2e
686```
687 
688### Backend Testing
689```bash
690# Run all Go tests
691go test ./...
692 
693# Run tests with coverage
694go test -coverprofile=coverage.out ./...
695go tool cover -html=coverage.out
696 
697# Run specific test
698go test -run TestOrderHandler_CreateOrder ./internal/handlers
699 
700# Run tests with verbose output
701go test -v ./...
702```
703 
704### Integration Testing
705```bash
706# Start test database
707make test-db
708 
709# Run integration tests
710make test-integration
711 
712# Run full test suite
713make test-all
714```
715 
716## 🛡️ Advanced QA Integration & Error Prevention
717 
718### 1. Proactive Error Prevention Testing
719```typescript
720// ✅ ERROR PREVENTION: Business logic boundary testing
721describe('Business Logic Boundary Tests', () => {
722  describe('Order Value Boundaries', () => {
723    const boundaryTestCases = [
724      { value: 0, expected: 'reject', reason: 'zero_amount' },
725      { value: 0.01, expected: 'accept', reason: 'minimum_valid' },
726      { value: 999.99, expected: 'accept', reason: 'maximum_normal' },
727      { value: 1000.00, expected: 'require_approval', reason: 'high_value_threshold' },
728      { value: 10000.00, expected: 'reject', reason: 'exceeds_daily_limit' },
729      { value: -1, expected: 'reject', reason: 'negative_amount' },
730      { value: Number.MAX_VALUE, expected: 'reject', reason: 'overflow_protection' }
731    ]
732 
733    boundaryTestCases.forEach(({ value, expected, reason }) => {
734      it(`should ${expected} order with value ${value} (${reason})`, async () => {
735        const order = createMockOrder({ total_amount: value })
736        const validator = new OrderValidator()
737        
738        const result = await validator.validateOrderValue(order)
739        
740        expect(result.decision).toBe(expected)
741        expect(result.reason).toBe(reason)
742      })
743    })
744  })
745 
746  describe('Edge Case Scenarios', () => {
747    it('should handle concurrent order modifications gracefully', async () => {
748      const order = await createTestOrder()
749      
750      // Simulate concurrent modifications
751      const modifications = Array(10).fill(null).map((_, index) => 
752        orderService.addItem(order.id, {
753          product_id: `item-${index}`,
754          quantity: 1
755        })
756      )
757      
758      const results = await Promise.allSettled(modifications)
759      const successful = results.filter(r => r.status === 'fulfilled')
760      const failed = results.filter(r => r.status === 'rejected')
761      
762      // Should handle gracefully without data corruption
763      expect(successful.length + failed.length).toBe(10)
764      expect(failed.every(f => 
765        f.reason instanceof ConcurrencyError
766      )).toBe(true)
767    })
768 
769    it('should handle network interruption during payment', async () => {
770      const payment = createMockPayment({ amount: 25.99 })
771      
772      // Mock network interruption
773      jest.spyOn(paymentGateway, 'process')
774        .mockRejectedValueOnce(new NetworkError('Connection timeout'))
775        .mockResolvedValueOnce({ success: true, transaction_id: 'txn_123' })
776      
777      const result = await paymentService.processWithRetry(payment)
778      
779      expect(result.success).toBe(true)
780      expect(result.retry_count).toBe(1)
781      expect(result.error_recovery).toBe('automatic_retry')
782    })
783  })
784})
785 
786// Property-based testing for business rules
787describe('Property-Based Business Logic Tests', () => {
788  it('should maintain order total consistency', () => {
789    fc.assert(fc.property(
790      fc.array(fc.record({
791        price: fc.float({ min: 0.01, max: 100 }),
792        quantity: fc.integer({ min: 1, max: 10 })
793      })),
794      (items) => {
795        const order = createOrderFromItems(items)
796        const calculatedTotal = items.reduce(
797          (sum, item) => sum + (item.price * item.quantity), 
798          0
799        )
800        
801        expect(order.total_amount).toBeCloseTo(calculatedTotal, 2)
802      }
803    ))
804  })
805 
806  it('should preserve business invariants across operations', () => {
807    fc.assert(fc.property(
808      fc.array(fc.oneof(
809        fc.record({ type: 'add_item', ...itemGenerator }),
810        fc.record({ type: 'remove_item', item_id: fc.string() }),
811        fc.record({ type: 'update_quantity', item_id: fc.string(), quantity: fc.nat() })
812      )),
813      (operations) => {
814        const order = createEmptyOrder()
815        
816        operations.forEach(op => {
817          try {
818            orderService.applyOperation(order, op)
819            
820            // Verify invariants after each operation
821            expect(order.total_amount).toBeGreaterThanOrEqual(0)
822            expect(order.items.every(item => item.quantity > 0)).toBe(true)
823            expect(order.items.length).toBeLessThanOrEqual(MAX_ORDER_ITEMS)
824          } catch (error) {
825            // Operations can fail, but should fail gracefully
826            expect(error).toBeInstanceOf(BusinessRuleError)
827          }
828        })
829      }
830    ))
831  })
832})
833```
834 
835### 2. Quality Gates Automation
836```typescript
837// ✅ AUTOMATION: Quality gates with business context
838class QualityGatesAutomation {
839  // Automated business logic validation
840  static createBusinessLogicValidator(): BusinessLogicValidator {
841    return {
842      validateBusinessRules: async (changeset: CodeChangeset): Promise<ValidationResult> => {
843        const violations: BusinessRuleViolation[] = []
844        
845        // Check for business logic consistency
846        const businessLogicFiles = changeset.files.filter(f => 
847          f.path.includes('handlers') || 
848          f.path.includes('services') || 
849          f.path.includes('business-logic')
850        )
851        
852        for (const file of businessLogicFiles) {
853          const analysis = await this.analyzeBusinessLogic(file)
854          
855          if (analysis.hasInconsistentPricing) {
856            violations.push({
857              type: 'PRICING_CONSISTENCY',
858              severity: 'high',
859              file: file.path,
860              message: 'Pricing calculation inconsistency detected',
861              suggestion: 'Use centralized pricing service'
862            })
863          }
864          
865          if (analysis.hasUnvalidatedUserInput) {
866            violations.push({
867              type: 'INPUT_VALIDATION',
868              severity: 'critical',
869              file: file.path,
870              message: 'User input not properly validated',
871              suggestion: 'Add input validation using business validation rules'
872            })
873          }
874        }
875        
876        return {
877          passed: violations.length === 0,
878          violations,
879          businessImpact: this.assessBusinessImpact(violations)
880        }
881      },
882 
883      validatePerformanceImpact: async (changeset: CodeChangeset): Promise<PerformanceImpact> => {
884        const performanceAnalysis = await this.analyzePerformanceChanges(changeset)
885        
886        return {
887          databaseQueryImpact: performanceAnalysis.queryChanges,
888          memoryImpact: performanceAnalysis.memoryChanges,
889          bundleSizeImpact: performanceAnalysis.bundleChanges,
890          businessCriticalPathsAffected: performanceAnalysis.criticalPaths,
891          recommendations: this.generatePerformanceRecommendations(performanceAnalysis)
892        }
893      }
894    }
895  }
896 
897  // Automated deployment quality gates
898  static createDeploymentQualityGates(): DeploymentQualityGates {
899    return {
900      preDeploymentChecks: [
901        {
902          name: 'Business Logic Regression Tests',
903          check: async () => {
904            const regressionResults = await this.runBusinessRegressionTests()
905            return {
906              passed: regressionResults.allPassed,
907              critical_failures: regressionResults.criticalFailures,
908              business_impact: regressionResults.businessImpact
909            }
910          }
911        },
912        {
913          name: 'Performance Validation',
914          check: async () => {
915            const performanceResults = await this.validateDeploymentPerformance()
916            return {
917              passed: performanceResults.meetsThresholds,
918              response_times: performanceResults.responseTimes,
919              resource_usage: performanceResults.resourceUsage
920            }
921          }
922        }
923      ],
924 
925      postDeploymentVerification: [
926        {
927          name: 'Business Critical Flows',
928          verify: async () => {
929            const flowResults = await this.verifyBusinessCriticalFlows()
930            return {
931              order_creation: flowResults.orderCreation.success,
932              payment_processing: flowResults.paymentProcessing.success,
933              kitchen_workflow: flowResults.kitchenWorkflow.success,
934              overall_health: flowResults.overallHealth
935            }
936          }
937        }
938      ]
939    }
940  }
941}
942```
943 
944### Enhanced Testing Commands
945 
946#### Advanced Frontend Testing
947```bash
948# Business logic validation
949npm run test:business-logic
950 
951# Performance regression tests  
952npm run test:performance
953 
954# Quality gates validation
955npm run test:quality-gates
956 
957# Property-based testing
958npm run test:property-based
959 
960# Error boundary testing
961npm run test:error-boundaries
962```
963 
964#### Advanced Backend Testing
965```bash
966# Business logic consistency tests
967go test -run TestBusinessLogic ./...
968 
969# Load and performance tests
970go test -run TestLoad ./...
971 
972# Integration tests with business scenarios
973go test -tags=business-integration ./...
974 
975# Boundary and edge case tests
976go test -run TestBoundary ./...
977```