@comfanion/workflow 4.36.59 → 4.36.60

package/src/opencode/skills/test-design/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: test-design
-description: How to design and write effective tests for implementations
+description: Use when designing test strategy, writing unit/integration tests, or improving coverage
 license: MIT
 compatibility: opencode
 metadata:
@@ -10,314 +10,102 @@ metadata:
 
 # Test Design Skill
 
-How to design and write effective tests for implementations.
+Principles for writing effective tests.
 
-## Test Pyramid
+## Test Naming
 
 ```
-        /\
-       /  \     E2E Tests (few)
-      /----\    
-     /      \   Integration Tests (some)
-    /--------\  
-   /          \ Unit Tests (many)
-  /------------\
-```
-
-## Unit Tests
-
-### When to Write
-- Every public function
-- Every method with business logic
-- Edge cases and error paths
-
-### Structure (Arrange-Act-Assert)
+Test{Component}_{Method}_{Scenario}_{Expected}
 
-```go
-func TestFunction_Scenario_ExpectedBehavior(t *testing.T) {
-    // Arrange - Setup test data
-    input := createTestInput()
-    expected := expectedOutput()
-    sut := NewSystemUnderTest()
-    
-    // Act - Execute the function
-    result, err := sut.Function(input)
-    
-    // Assert - Verify the outcome
-    if err != nil {
-        t.Fatalf("unexpected error: %v", err)
-    }
-    if result != expected {
-        t.Errorf("got %v, want %v", result, expected)
-    }
-}
+Examples:
+- TestUser_Create_ValidData_Success
+- TestUser_Create_EmptyEmail_ReturnsError
+- TestOrder_Cancel_AlreadyShipped_Fails
 ```
 
-### Naming Convention
-
-```
-Test{Type}_{Method}_{Scenario}
+## Test Structure (AAA)
 
-Examples:
-- TestOffer_UpdatePrice_Success
-- TestOffer_UpdatePrice_NegativePrice_ReturnsError
-- TestOffer_Activate_FromPendingStatus_Success
-- TestOffer_Activate_FromDeclinedStatus_Fails
 ```
+// Arrange - Setup
+input := ...
+expected := ...
 
-### Table-Driven Tests
+// Act - Execute
+result := sut.Method(input)
 
-```go
-func TestOffer_Validate(t *testing.T) {
-    tests := []struct {
-        name    string
-        offer   Offer
-        wantErr bool
-    }{
-        {
-            name:    "valid offer",
-            offer:   validOffer(),
-            wantErr: false,
-        },
-        {
-            name:    "zero price",
-            offer:   offerWithZeroPrice(),
-            wantErr: true,
-        },
-        {
-            name:    "negative quantity",
-            offer:   offerWithNegativeQty(),
-            wantErr: true,
-        },
-    }
-    
-    for _, tt := range tests {
-        t.Run(tt.name, func(t *testing.T) {
-            err := tt.offer.Validate()
-            if (err != nil) != tt.wantErr {
-                t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
-            }
-        })
-    }
-}
+// Assert - Verify
+assert(result == expected)
 ```
 
-## Integration Tests
-
-### When to Write
-- Repository implementations
-- API endpoints
-- External service integrations
-- Multi-component workflows
+## Table-Driven Tests
 
-### Setup/Teardown
+When testing multiple scenarios of same function:
 
-```go
-func TestMain(m *testing.M) {
-    // Setup
-    testDB = setupTestDatabase()
-    
-    // Run tests
-    code := m.Run()
-    
-    // Teardown
-    teardownTestDatabase(testDB)
-    
-    os.Exit(code)
-}
 ```
+tests := []struct {
+    name     string
+    input    Input
+    expected Output
+    wantErr  bool
+}{
+    {"valid input", validInput(), expectedOutput(), false},
+    {"empty input", emptyInput(), nil, true},
+}
 
-### Test Isolation
-
-```go
-func TestRepository_Save(t *testing.T) {
-    // Use transaction that rolls back
-    tx := testDB.Begin()
-    defer tx.Rollback()
-    
-    repo := NewRepository(tx)
-    
-    // Test code here
+for _, tt := range tests {
+    t.Run(tt.name, func(t *testing.T) {
+        result, err := sut.Method(tt.input)
+        // assert
+    })
 }
 ```
 
-## Test Coverage Requirements
-
-| Type | Minimum Coverage |
-|------|-----------------|
-| Domain/Business Logic | 80%+ |
-| Use Cases/Handlers | 70%+ |
-| Repositories | 60%+ |
-| HTTP Handlers | 50%+ |
-
 ## What to Test
 
-### Domain Layer
-- All aggregate methods
-- All value object validation
-- Domain service logic
+**Always test:**
+- Public API / exported functions
+- Business logic / domain rules
+- Error handling paths
+- Edge cases (empty, nil, zero, max)
 - State transitions
 
-### Application Layer
-- Use case happy paths
-- Error scenarios
-- Validation failures
-- Authorization checks
-
-### Infrastructure Layer
-- Repository CRUD operations
-- External service adapters
-- Event publishing/consuming
-
-## What NOT to Test
-
-- Private functions (test via public interface)
+**Skip testing:**
+- Private implementation details
 - Simple getters/setters
-- Framework code
-- Generated code (SQLC, etc.)
+- Generated code
+- Framework internals
 
 ## Mocking
 
-### When to Mock
-- External services
-- Databases (for unit tests)
-- Time-dependent operations
-- Random/non-deterministic operations
-
-### Interface-Based Mocking
-
-```go
-// Define interface
-type UserRepository interface {
-    FindByID(ctx context.Context, id string) (*User, error)
-}
-
-// Create mock
-type MockUserRepository struct {
-    FindByIDFunc func(ctx context.Context, id string) (*User, error)
-}
-
-func (m *MockUserRepository) FindByID(ctx context.Context, id string) (*User, error) {
-    return m.FindByIDFunc(ctx, id)
-}
-
-// Use in test
-func TestUseCase(t *testing.T) {
-    mockRepo := &MockUserRepository{
-        FindByIDFunc: func(ctx context.Context, id string) (*User, error) {
-            return &User{ID: id, Name: "Test"}, nil
-        },
-    }
-    
-    useCase := NewUseCase(mockRepo)
-    // ...
-}
-```
-
-## Test Data
-
-### Builders
-
-```go
-func NewTestOffer() *Offer {
-    return &Offer{
-        ID:         NewOfferID(),
-        MerchantID: NewMerchantID(),
-        Price:      decimal.NewFromInt(100),
-        Status:     OfferStatusPending,
-    }
-}
-
-func (o *Offer) WithPrice(price decimal.Decimal) *Offer {
-    o.Price = price
-    return o
-}
-
-func (o *Offer) WithStatus(status OfferStatus) *Offer {
-    o.Status = status
-    return o
-}
-
-// Usage
-offer := NewTestOffer().WithPrice(decimal.NewFromInt(200)).WithStatus(OfferStatusActive)
-```
-
-## Red-Green-Refactor Cycle
-
-### 1. RED - Write Failing Test
-
-```go
-func TestOffer_UpdatePrice_Success(t *testing.T) {
-    offer := NewTestOffer()
-    newPrice := decimal.NewFromInt(150)
-    
-    err := offer.UpdatePrice(newPrice)
-    
-    if err != nil {
-        t.Fatalf("unexpected error: %v", err)
-    }
-    if !offer.Price.Equal(newPrice) {
-        t.Errorf("price not updated")
-    }
-}
-```
-
-Run test - it should FAIL.
-
-### 2. GREEN - Minimal Implementation
+Mock when:
+- External services (HTTP, DB)
+- Non-deterministic (time, random)
+- Slow operations
 
-```go
-func (o *Offer) UpdatePrice(price decimal.Decimal) error {
-    o.Price = price
-    return nil
-}
+Prefer interfaces for testability:
 ```
-
-Run test - it should PASS.
-
-### 3. REFACTOR - Improve Code
-
-```go
-func (o *Offer) UpdatePrice(price decimal.Decimal) error {
-    if price.LessThanOrEqual(decimal.Zero) {
-        return ErrInvalidPrice
-    }
-    o.Price = price
-    return nil
+type Repository interface {
+    Find(id string) (*Entity, error)
 }
-```
-
-Run test - it should still PASS.
-
-Add test for new validation:
 
-```go
-func TestOffer_UpdatePrice_ZeroPrice_ReturnsError(t *testing.T) {
-    offer := NewTestOffer()
-    
-    err := offer.UpdatePrice(decimal.Zero)
-    
-    if !errors.Is(err, ErrInvalidPrice) {
-        t.Errorf("expected ErrInvalidPrice, got %v", err)
-    }
-}
+// Production: RealRepository
+// Tests: MockRepository
 ```
 
-## Test Commands
-
-```bash
-# Run all tests
-go test ./...
+## Test Isolation
 
-# Run with coverage
-go test -cover ./...
+Each test should:
+- Setup its own data
+- Not depend on other tests
+- Clean up after itself
+- Run in any order
 
-# Run specific test
-go test -run TestOffer_UpdatePrice ./...
+## Coverage Guidelines
 
-# Run with race detection
-go test -race ./...
+| Layer | Target |
+|-------|--------|
+| Domain/Business | 80%+ |
+| Application/UseCase | 70%+ |
+| Infrastructure | 50%+ |
 
-# Verbose output
-go test -v ./...
-```
+Focus on critical paths, not 100% coverage.

package/src/opencode/skills/translation/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: translation
-description: Translate technical docs to user language, export to Confluence format
+description: Use when translating docs to user language or exporting to Confluence format
 license: MIT
 compatibility: opencode
 metadata: