@sylix/coworker 2.0.11 → 2.0.12

package/dist/skills/defaults/testing/python-testing-patterns.md

@@ -0,0 +1,351 @@
+---
+name: python-testing-patterns
+description: Implement comprehensive testing strategies with pytest, fixtures, mocking, and test-driven development. Use when writing Python tests, setting up test suites, or implementing testing best practices.
+---
+
+# Python Testing Patterns
+
+Comprehensive guide to implementing robust testing strategies in Python using pytest, fixtures, mocking, parameterization, and test-driven development practices.
+
+## When to Use This Skill
+
+- Writing unit tests for Python code
+- Setting up test suites and test infrastructure
+- Implementing test-driven development (TDD)
+- Creating integration tests for APIs and services
+- Mocking external dependencies and services
+- Testing async code and concurrent operations
+- Setting up continuous testing in CI/CD
+- Implementing property-based testing
+- Testing database operations
+- Debugging failing tests
+
+## Core Concepts
+
+### 1. Test Types
+
+- **Unit Tests**: Test individual functions/classes in isolation
+- **Integration Tests**: Test interaction between components
+- **Functional Tests**: Test complete features end-to-end
+- **Performance Tests**: Measure speed and resource usage
+
+### 2. Test Structure (AAA Pattern)
+
+- **Arrange**: Set up test data and preconditions
+- **Act**: Execute the code under test
+- **Assert**: Verify the results
+
+### 3. Test Coverage
+
+- Measure what code is exercised by tests
+- Identify untested code paths
+- Aim for meaningful coverage, not just high percentages
+
+## Quick Start
+
+```python
+def add(a, b):
+    return a + b
+
+def test_add():
+    result = add(2, 3)
+    assert result == 5
+```
+
+## Fundamental Patterns
+
+### Pattern 1: Basic pytest Tests
+
+```python
+import pytest
+
+class Calculator:
+    def add(self, a: float, b: float) -> float:
+        return a + b
+
+    def divide(self, a: float, b: float) -> float:
+        if b == 0:
+            raise ValueError("Cannot divide by zero")
+        return a / b
+
+def test_addition():
+    calc = Calculator()
+    assert calc.add(2, 3) == 5
+
+def test_division_by_zero():
+    calc = Calculator()
+    with pytest.raises(ValueError, match="Cannot divide by zero"):
+        calc.divide(5, 0)
+```
+
+### Pattern 2: Fixtures for Setup and Teardown
+
+```python
+import pytest
+from typing import Generator
+
+class Database:
+    def __init__(self, connection_string: str):
+        self.connection_string = connection_string
+        self.connected = False
+
+    def connect(self):
+        self.connected = True
+
+    def disconnect(self):
+        self.connected = False
+
+@pytest.fixture
+def db() -> Generator[Database, None, None]:
+    database = Database("sqlite:///:memory:")
+    database.connect()
+    yield database
+    database.disconnect()
+
+def test_database_query(db):
+    assert db.connected is True
+```
+
+### Pattern 3: Parameterized Tests
+
+```python
+import pytest
+
+def is_valid_email(email: str) -> bool:
+    return "@" in email and "." in email.split("@")[1]
+
+@pytest.mark.parametrize("email,expected", [
+    ("user@example.com", True),
+    ("invalid.email", False),
+    ("@example.com", False),
+])
+def test_email_validation(email, expected):
+    assert is_valid_email(email) == expected
+```
+
+### Pattern 4: Mocking with unittest.mock
+
+```python
+import pytest
+from unittest.mock import Mock, patch
+
+class APIClient:
+    def __init__(self, base_url: str):
+        self.base_url = base_url
+
+    def get_user(self, user_id: int) -> dict:
+        import requests
+        response = requests.get(f"{self.base_url}/users/{user_id}")
+        response.raise_for_status()
+        return response.json()
+
+def test_get_user_success():
+    client = APIClient("https://api.example.com")
+
+    mock_response = Mock()
+    mock_response.json.return_value = {"id": 1, "name": "John Doe"}
+    mock_response.raise_for_status.return_value = None
+
+    with patch("requests.get", return_value=mock_response) as mock_get:
+        user = client.get_user(1)
+        assert user["id"] == 1
+        mock_get.assert_called_once_with("https://api.example.com/users/1")
+```
+
+### Pattern 5: Testing Exceptions
+
+```python
+import pytest
+
+def divide(a: float, b: float) -> float:
+    if b == 0:
+        raise ZeroDivisionError("Division by zero")
+    return a / b
+
+def test_zero_division():
+    with pytest.raises(ZeroDivisionError):
+        divide(10, 0)
+
+def test_exception_message():
+    with pytest.raises(ZeroDivisionError, match="Division by zero"):
+        divide(5, 0)
+```
+
+## Advanced Patterns
+
+### Pattern 6: Testing Async Code
+
+```python
+import pytest
+import asyncio
+
+async def fetch_data(url: str) -> dict:
+    await asyncio.sleep(0.1)
+    return {"url": url, "data": "result"}
+
+@pytest.mark.asyncio
+async def test_fetch_data():
+    result = await fetch_data("https://api.example.com")
+    assert result["url"] == "https://api.example.com"
+
+@pytest.mark.asyncio
+async def test_concurrent_fetches():
+    urls = ["url1", "url2", "url3"]
+    tasks = [fetch_data(url) for url in urls]
+    results = await asyncio.gather(*tasks)
+    assert len(results) == 3
+```
+
+### Pattern 7: Monkeypatch for Testing
+
+```python
+import os
+import pytest
+
+def get_database_url() -> str:
+    return os.environ.get("DATABASE_URL", "sqlite:///:memory:")
+
+def test_database_url_custom(monkeypatch):
+    monkeypatch.setenv("DATABASE_URL", "postgresql://localhost/test")
+    assert get_database_url() == "postgresql://localhost/test"
+```
+
+### Pattern 8: Temporary Files and Directories
+
+```python
+import pytest
+from pathlib import Path
+
+def save_data(filepath: Path, data: str):
+    filepath.write_text(data)
+
+def test_file_operations(tmp_path):
+    test_file = tmp_path / "test_data.txt"
+    save_data(test_file, "Hello, World!")
+    assert test_file.exists()
+    assert test_file.read_text() == "Hello, World!"
+```
+
+### Pattern 9: Property-Based Testing
+
+```python
+from hypothesis import given, strategies as st
+
+def reverse_string(s: str) -> str:
+    return s[::-1]
+
+@given(st.text())
+def test_reverse_twice_is_original(s):
+    assert reverse_string(reverse_string(s)) == s
+
+@given(st.integers(), st.integers())
+def test_addition_commutative(a, b):
+    assert a + b == b + a
+```
+
+### Pattern 10: Testing Retry Behavior
+
+```python
+from unittest.mock import Mock
+
+def test_retries_on_transient_error():
+    client = Mock()
+    client.request.side_effect = [
+        ConnectionError("Failed"),
+        ConnectionError("Failed"),
+        {"status": "ok"},
+    ]
+
+    service = ServiceWithRetry(client, max_retries=3)
+    result = service.fetch()
+
+    assert result == {"status": "ok"}
+    assert client.request.call_count == 3
+```
+
+### Pattern 11: Mocking Time with Freezegun
+
+```python
+from freezegun import freeze_time
+from datetime import datetime
+
+@freeze_time("2026-01-15 10:00:00")
+def test_token_expiry():
+    token = create_token(expires_in_seconds=3600)
+    assert token.expires_at == datetime(2026, 1, 15, 11, 0, 0)
+```
+
+## Test Design Principles
+
+### One Behavior Per Test
+
+```python
+# BAD - testing multiple behaviors
+def test_user_service():
+    user = service.create_user(data)
+    assert user.id is not None
+    assert user.email == data["email"]
+
+# GOOD - focused tests
+def test_create_user_assigns_id():
+    user = service.create_user(data)
+    assert user.id is not None
+
+def test_create_user_stores_email():
+    user = service.create_user(data)
+    assert user.email == data["email"]
+```
+
+## Testing Best Practices
+
+1. **Write tests first** (TDD) or alongside code
+2. **One assertion per test** when possible
+3. **Use descriptive test names** that explain behavior
+4. **Keep tests independent** and isolated
+5. **Use fixtures** for setup and teardown
+6. **Mock external dependencies** appropriately
+7. **Parametrize tests** to reduce duplication
+8. **Test edge cases** and error conditions
+9. **Measure coverage** but focus on quality
+10. **Run tests in CI/CD** on every commit
+
+## Test Organization
+
+```
+tests/
+  conftest.py           # Shared fixtures
+  test_unit/            # Unit tests
+  test_integration/     # Integration tests
+  test_e2e/            # End-to-end tests
+```
+
+## CI/CD Integration
+
+```yaml
+name: Tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Run tests
+        run: pytest --cov=myapp --cov-report=xml
+      - name: Upload coverage
+        uses: codecov/codecov-action@v3
+```
+
+## Configuration
+
+```toml
+# pyproject.toml
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = ["-v", "--cov=myapp", "--cov-report=term-missing"]
+
+[tool.coverage.run]
+source = ["myapp"]
+omit = ["*/tests/*", "*/migrations/*"]
+```

package/dist/skills/defaults/testing/testing.md

@@ -0,0 +1,332 @@
+---
+name: testing
+description: Write effective unit, integration, and E2E tests with modern testing patterns and best practices.
+---
+
+# Testing Best Practices — CoWorker Edition
+
+Write tests that give you confidence.
+
+## When to Use This Skill
+
+- Writing new tests
+- Improving test coverage
+- Setting up test infrastructure
+- Debugging test failures
+
+## Core Concepts
+
+### 1. Unit Tests
+
+```typescript
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { UserService } from './UserService';
+import { UserRepository } from './UserRepository';
+
+describe('UserService', () => {
+  let userService: UserService;
+  let mockRepository: UserRepository;
+  
+  beforeEach(() => {
+    // Create mock
+    mockRepository = {
+      findById: vi.fn(),
+      save: vi.fn(),
+      delete: vi.fn()
+    } as UserRepository;
+    
+    userService = new UserService(mockRepository);
+  });
+  
+  describe('getUser', () => {
+    it('should return user when found', async () => {
+      const mockUser = { id: '1', name: 'John' };
+      mockRepository.findById.mockResolvedValue(mockUser);
+      
+      const result = await userService.getUser('1');
+      
+      expect(result).toEqual(mockUser);
+      expect(mockRepository.findById).toHaveBeenCalledWith('1');
+    });
+    
+    it('should throw when user not found', async () => {
+      mockRepository.findById.mockResolvedValue(null);
+      
+      await expect(userService.getUser('999')).rejects.toThrow('User not found');
+    });
+  });
+  
+  describe('createUser', () => {
+    it('should create user with hashed password', async () => {
+      mockRepository.save.mockResolvedValue({ id: '1', email: 'test@test.com' });
+      
+      const result = await userService.createUser({
+        email: 'test@test.com',
+        password: 'plaintext123'
+      });
+      
+      expect(mockRepository.save).toHaveBeenCalled();
+      const savedUser = mockRepository.save.mock.calls[0][0];
+      expect(savedUser.passwordHash).toBeDefined();
+      expect(savedUser.passwordHash).not.toBe('plaintext123');
+    });
+  });
+});
+```
+
+### 2. Integration Tests
+
+```typescript
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { setupTestDatabase, teardownTestDatabase } from './testUtils';
+import { app } from '../src/app';
+import request from 'supertest';
+
+describe('API Integration Tests', () => {
+  beforeAll(async () => {
+    await setupTestDatabase();
+  });
+  
+  afterAll(async () => {
+    await teardownTestDatabase();
+  });
+  
+  beforeEach(async () => {
+    await clearTestData();
+  });
+  
+  describe('POST /api/users', () => {
+    it('should create a new user', async () => {
+      const response = await request(app)
+        .post('/api/users')
+        .send({
+          email: 'test@example.com',
+          name: 'Test User'
+        });
+      
+      expect(response.status).toBe(201);
+      expect(response.body).toMatchObject({
+        email: 'test@example.com',
+        name: 'Test User'
+      });
+      expect(response.body.id).toBeDefined();
+    });
+    
+    it('should return 400 for invalid email', async () => {
+      const response = await request(app)
+        .post('/api/users')
+        .send({
+          email: 'invalid-email',
+          name: 'Test'
+        });
+      
+      expect(response.status).toBe(400);
+      expect(response.body.error).toContain('email');
+    });
+  });
+  
+  describe('GET /api/users/:id', () => {
+    it('should return user by id', async () => {
+      // First create a user
+      const created = await request(app)
+        .post('/api/users')
+        .send({ email: 'test@test.com', name: 'Test' });
+      
+      const response = await request(app)
+        .get(`/api/users/${created.body.id}`);
+      
+      expect(response.status).toBe(200);
+      expect(response.body.email).toBe('test@test.com');
+    });
+    
+    it('should return 404 for non-existent user', async () => {
+      const response = await request(app)
+        .get('/api/users/999999');
+      
+      expect(response.status).toBe(404);
+    });
+  });
+});
+```
+
+### 3. E2E Tests with Playwright
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('User Registration Flow', () => {
+  test('should register a new user', async ({ page }) => {
+    await page.goto('/register');
+    
+    await page.fill('[data-testid="email"]', 'newuser@example.com');
+    await page.fill('[data-testid="password"]', 'password123');
+    await page.fill('[data-testid="confirm-password"]', 'password123');
+    await page.click('[data-testid="register-button"]');
+    
+    // Should redirect to dashboard
+    await expect(page).toHaveURL('/dashboard');
+    
+    // Should show success message
+    await expect(page.locator('.toast')).toContainText('Welcome');
+  });
+  
+  test('should show validation errors', async ({ page }) => {
+    await page.goto('/register');
+    
+    await page.fill('[data-testid="email"]', 'invalid');
+    await page.click('[data-testid="register-button"]');
+    
+    await expect(page.locator('[data-testid="email-error"]'))
+      .toContainText('Valid email required');
+  });
+});
+
+test.describe('Authentication', () => {
+  test.beforeEach(async ({ page }) => {
+    // Login before each test
+    await page.goto('/login');
+    await page.fill('[data-testid="email"]', 'test@example.com');
+    await page.fill('[data-testid="password"]', 'password123');
+    await page.click('[data-testid="login-button"]');
+  });
+  
+  test('should protect dashboard', async ({ page }) => {
+    await page.goto('/dashboard');
+    await expect(page).toHaveURL('/dashboard');
+  });
+});
+```
+
+### 4. Test Fixtures
+
+```typescript
+import { test as base, fixtures } from '@playwright/test';
+
+interface UserFixtures {
+  testUser: { email: string; password: string };
+  adminUser: { email: string; role: string };
+}
+
+const myFixtures = fixtures({
+  testUser: async ({}, use) => {
+    const user = {
+      email: 'test@example.com',
+      password: 'testpass123'
+    };
+    await createTestUser(user);
+    await use(user);
+    await deleteTestUser(user.email);
+  },
+  
+  adminUser: async ({}, use) => {
+    const user = {
+      email: 'admin@example.com',
+      role: 'admin'
+    };
+    await createAdminUser(user);
+    await use(user);
+    await deleteTestUser(user.email);
+  }
+});
+
+export const test = base.extend<UserFixtures>(myFixtures);
+```
+
+### 5. Mocking External Services
+
+```typescript
+import { vi } from 'vitest';
+import nock from 'nock';
+
+describe('PaymentService', () => {
+  afterEach(() => {
+    nock.cleanAll();
+  });
+  
+  it('should process payment via Stripe', async () => {
+    // Mock Stripe API
+    nock('https://api.stripe.com')
+      .post('/v1/charges')
+      .reply(200, {
+        id: 'ch_123',
+        status: 'succeeded',
+        amount: 1000
+      });
+    
+    const service = new PaymentService();
+    const result = await service.processPayment({
+      amount: 1000,
+      currency: 'usd',
+      token: 'tok_visa'
+    });
+    
+    expect(result.status).toBe('succeeded');
+  });
+  
+  it('should handle payment failures', async () => {
+    nock('https://api.stripe.com')
+      .post('/v1/charges')
+      .reply(402, {
+        error: {
+          code: 'card_declined',
+          message: 'Card was declined'
+        }
+      });
+    
+    const service = new PaymentService();
+    
+    await expect(service.processPayment({
+      amount: 1000,
+      currency: 'usd',
+      token: 'tok_chargeDeclined'
+    })).rejects.toThrow('Payment failed');
+  });
+});
+```
+
+### 6. Test Coverage
+
+```typescript
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      include: [
+        'src/**/*.ts',
+        '!src/**/*.d.ts'
+      ],
+      exclude: [
+        'src/**/*.test.ts',
+        'src/**/*.spec.ts'
+      ]
+    }
+  }
+});
+
+// Run with coverage
+// npm run test:coverage
+```
+
+## Best Practices
+
+1. **AAA Pattern** - Arrange, Act, Assert
+2. **One assertion per test** - Better failure messages
+3. **Test behavior, not implementation** - Refactor safe
+4. **Descriptive names** - Document what's tested
+5. **Fast tests** - No network calls in unit tests
+6. **Isolation** - Tests don't depend on each other
+7. **Mocks external services** - Speed and reliability
+
+## Common Mistakes
+
+- Testing implementation details
+- Not cleaning up test data
+- Over-mocking
+- Slow test suites
+- Brittle selectors
+- Not testing edge cases
+- Skipping E2E tests