@comfanion/workflow 4.38.4-dev.1 → 4.39.0

package/src/opencode/skills/test-design/unit-tests-patterns.md

@@ -0,0 +1,181 @@
+# Unit Testing Patterns
+
+Common patterns for writing effective unit tests.
+
+## Table-Driven Tests
+
+Test multiple scenarios with same logic.
+
+**Go Example:**
+```go
+func TestValidateEmail(t *testing.T) {
+    tests := []struct {
+        name    string
+        email   string
+        wantErr bool
+    }{
+        {"valid", "test@example.com", false},
+        {"missing @", "testexample.com", true},
+        {"empty", "", true},
+    }
+    
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            err := ValidateEmail(tt.email)
+            if (err != nil) != tt.wantErr {
+                t.Errorf("got error = %v, want %v", err, tt.wantErr)
+            }
+        })
+    }
+}
+```
+
+**TypeScript Example:**
+```typescript
+describe('validateEmail', () => {
+  test.each([
+    { email: 'test@example.com', valid: true },
+    { email: 'testexample.com', valid: false },
+    { email: '', valid: false },
+  ])('validates $email', ({ email, valid }) => {
+    expect(validateEmail(email).isValid).toBe(valid);
+  });
+});
+```
+
+---
+
+## State Transitions
+
+Test state machine behavior.
+
+```typescript
+describe('Order state transitions', () => {
+  it('transitions DRAFT → PENDING on submit', () => {
+    const order = new Order(); // DRAFT
+    
+    order.submit();
+    
+    expect(order.status).toBe('PENDING');
+  });
+  
+  it('throws error on invalid transition', () => {
+    const order = new Order();
+    order.submit(); // DRAFT → PENDING
+    
+    expect(() => order.submit()).toThrow('Invalid state');
+  });
+});
+```
+
+---
+
+## Validation Testing
+
+Test input validation rules.
+
+```typescript
+describe('Order validation', () => {
+  it('rejects empty items', () => {
+    const order = new Order();
+    
+    const result = order.validate();
+    
+    expect(result.isValid).toBe(false);
+    expect(result.errors).toContain('Order must have items');
+  });
+  
+  it('rejects negative quantities', () => {
+    const order = new Order();
+    order.addItem({ price: 100, quantity: -1 });
+    
+    const result = order.validate();
+    
+    expect(result.errors).toContain('Quantity must be positive');
+  });
+});
+```
+
+---
+
+## Error Handling
+
+Test error scenarios and recovery.
+
+```typescript
+describe('OrderService error handling', () => {
+  it('handles database errors', async () => {
+    const mockDb = {
+      save: jest.fn().mockRejectedValue(new Error('DB error'))
+    };
+    const service = new OrderService(mockDb);
+    
+    await expect(service.createOrder(order))
+      .rejects.toThrow('Failed to create order');
+  });
+  
+  it('retries on transient errors', async () => {
+    const mockDb = {
+      save: jest.fn()
+        .mockRejectedValueOnce(new Error('Timeout'))
+        .mockResolvedValueOnce({ id: '123' })
+    };
+    
+    const result = await service.createOrder(order);
+    
+    expect(result.id).toBe('123');
+    expect(mockDb.save).toHaveBeenCalledTimes(2);
+  });
+});
+```
+
+---
+
+## Boundary Testing
+
+Test edge cases and limits.
+
+```typescript
+describe('boundary conditions', () => {
+  it('handles empty input', () => {
+    expect(calculateTotal([])).toBe(0);
+  });
+  
+  it('handles single item', () => {
+    expect(calculateTotal([{ price: 100 }])).toBe(100);
+  });
+  
+  it('handles maximum items', () => {
+    const items = Array(1000).fill({ price: 1 });
+    expect(calculateTotal(items)).toBe(1000);
+  });
+  
+  it('handles zero price', () => {
+    expect(calculateTotal([{ price: 0 }])).toBe(0);
+  });
+});
+```
+
+---
+
+## Tips
+
+**Table-driven tests:**
+- Use for multiple input/output combinations
+- Name each case clearly
+- Include edge cases
+
+**State transitions:**
+- Test all valid transitions
+- Test invalid transitions (should error)
+- Verify state after transition
+
+**Validation:**
+- Test each validation rule separately
+- Test combinations of errors
+- Verify error messages
+
+**Error handling:**
+- Test error paths
+- Test recovery/retry logic
+- Verify error messages

package/src/opencode/skills/test-design/unit-tests.md

@@ -0,0 +1,117 @@
+# Unit Testing Guide
+
+Unit tests verify individual components in isolation.
+
+## What to Test
+
+### ✅ Always Test
+- **Public API** - Public methods, exported interfaces
+- **Business Logic** - Domain rules, calculations, validations
+- **Error Handling** - Invalid input, exceptions
+- **Edge Cases** - Empty/null/zero, min/max, boundaries
+
+### ❌ Don't Test
+- **Private methods** - Test through public API
+- **Trivial code** - Getters/setters, pass-through
+- **Framework internals** - Third-party libraries
+
+---
+
+## AAA Pattern
+
+**Structure:** Arrange → Act → Assert
+
+```typescript
+it('calculates order total', () => {
+  // Arrange - setup
+  const order = new Order();
+  order.addItem({ price: 100, quantity: 2 });
+  
+  // Act - execute
+  const total = order.calculateTotal();
+  
+  // Assert - verify
+  expect(total).toBe(200);
+});
+```
+
+---
+
+## Test Naming
+
+**Format:** `Test{Component}_{Method}_{Scenario}_{Expected}`
+
+**Examples:**
+```
+TestOrder_CalculateTotal_WithItems_ReturnsSum
+TestOrder_CalculateTotal_EmptyOrder_ReturnsZero
+TestOrder_AddItem_DuplicateSKU_MergesQuantity
+```
+
+**TypeScript/Jest:**
+```typescript
+describe('Order', () => {
+  describe('calculateTotal', () => {
+    it('returns sum when order has items', () => {});
+    it('returns zero when order is empty', () => {});
+  });
+});
+```
+
+---
+
+## Coverage Targets
+
+| Layer | Target | Focus |
+|-------|--------|-------|
+| **Domain** | 80%+ | Business logic, rules |
+| **Application** | 70%+ | Use cases |
+| **Infrastructure** | 50%+ | Adapters |
+
+**Don't chase 100%** - Focus on critical paths.
+
+---
+
+## Advanced Topics
+
+**For more details, see:**
+- [unit-tests-patterns.md](unit-tests-patterns.md) - Table-driven tests, state transitions, validation
+- [unit-tests-mocking.md](unit-tests-mocking.md) - Mocking, dependency injection, test isolation
+
+---
+
+## Quick Example
+
+```typescript
+describe('validateEmail', () => {
+  it('accepts valid email', () => {
+    expect(validateEmail('test@example.com').isValid).toBe(true);
+  });
+  
+  it('rejects invalid email', () => {
+    expect(validateEmail('invalid').isValid).toBe(false);
+  });
+  
+  it('rejects empty email', () => {
+    expect(validateEmail('').isValid).toBe(false);
+  });
+});
+```
+
+---
+
+## Tips
+
+**Keep tests simple:**
+- One assertion per test
+- Clear test names
+- Minimal setup
+
+**Test behavior, not implementation:**
+- Test what it does, not how
+- Refactor shouldn't break tests
+
+**Make tests fast:**
+- No real I/O (mock it)
+- No sleep/delays
+- Parallel execution