Initial commit

commands/testing-patterns.md

@@ -0,0 +1,720 @@
+# Testing & Quality Assurance Patterns
+
+Comprehensive testing strategies and patterns across languages and frameworks.
+
+## Unit Testing Patterns
+
+### Test Structure: Arrange-Act-Assert (AAA)
+
+```typescript
+// TypeScript with Jest
+describe('UserService', () => {
+  it('should create user with valid data', async () => {
+    // Arrange
+    const userData = { email: 'test@example.com', name: 'Test User' };
+    const mockRepository = {
+      save: jest.fn().mockResolvedValue({ id: 1, ...userData })
+    };
+    const service = new UserService(mockRepository);
+
+    // Act
+    const result = await service.createUser(userData);
+
+    // Assert
+    expect(result.id).toBe(1);
+    expect(result.email).toBe(userData.email);
+    expect(mockRepository.save).toHaveBeenCalledWith(userData);
+  });
+});
+```
+
+### Python with pytest
+
+```python
+import pytest
+from myapp.services import UserService
+from unittest.mock import Mock, AsyncMock
+
+class TestUserService:
+    @pytest.fixture
+    def mock_repository(self):
+        repo = Mock()
+        repo.save = AsyncMock(return_value={'id': 1, 'email': 'test@example.com'})
+        return repo
+
+    @pytest.fixture
+    def service(self, mock_repository):
+        return UserService(mock_repository)
+
+    @pytest.mark.asyncio
+    async def test_create_user_with_valid_data(self, service, mock_repository):
+        # Arrange
+        user_data = {'email': 'test@example.com', 'name': 'Test User'}
+
+        # Act
+        result = await service.create_user(user_data)
+
+        # Assert
+        assert result['id'] == 1
+        assert result['email'] == user_data['email']
+        mock_repository.save.assert_called_once_with(user_data)
+```
+
+### Go Table-Driven Tests
+
+```go
+package user_test
+
+import (
+    "testing"
+    "github.com/stretchr/testify/assert"
+    "github.com/stretchr/testify/mock"
+)
+
+type MockRepository struct {
+    mock.Mock
+}
+
+func (m *MockRepository) Save(user *User) error {
+    args := m.Called(user)
+    return args.Error(0)
+}
+
+func TestUserService_CreateUser(t *testing.T) {
+    tests := []struct {
+        name        string
+        input       *User
+        mockSetup   func(*MockRepository)
+        wantErr     bool
+        errContains string
+    }{
+        {
+            name: "valid user",
+            input: &User{Email: "test@example.com", Name: "Test"},
+            mockSetup: func(m *MockRepository) {
+                m.On("Save", mock.Anything).Return(nil)
+            },
+            wantErr: false,
+        },
+        {
+            name: "invalid email",
+            input: &User{Email: "invalid", Name: "Test"},
+            mockSetup: func(m *MockRepository) {},
+            wantErr: true,
+            errContains: "invalid email",
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            // Arrange
+            mockRepo := new(MockRepository)
+            tt.mockSetup(mockRepo)
+            service := NewUserService(mockRepo)
+
+            // Act
+            err := service.CreateUser(tt.input)
+
+            // Assert
+            if tt.wantErr {
+                assert.Error(t, err)
+                assert.Contains(t, err.Error(), tt.errContains)
+            } else {
+                assert.NoError(t, err)
+                mockRepo.AssertExpectations(t)
+            }
+        })
+    }
+}
+```
+
+### Rust with rstest
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rstest::*;
+    use mockall::predicate::*;
+    use mockall::mock;
+
+    mock! {
+        Repository {}
+        impl UserRepository for Repository {
+            fn save(&self, user: &User) -> Result<User, Error>;
+        }
+    }
+
+    #[fixture]
+    fn user_data() -> UserData {
+        UserData {
+            email: "test@example.com".to_string(),
+            name: "Test User".to_string(),
+        }
+    }
+
+    #[rstest]
+    fn test_create_user_success(user_data: UserData) {
+        // Arrange
+        let mut mock_repo = MockRepository::new();
+        mock_repo
+            .expect_save()
+            .times(1)
+            .returning(|user| Ok(user.clone()));
+
+        let service = UserService::new(mock_repo);
+
+        // Act
+        let result = service.create_user(user_data.clone());
+
+        // Assert
+        assert!(result.is_ok());
+        let user = result.unwrap();
+        assert_eq!(user.email, user_data.email);
+    }
+
+    #[rstest]
+    #[case("invalid-email", "Test", "invalid email")]
+    #[case("test@example.com", "", "name required")]
+    fn test_create_user_validation_errors(
+        #[case] email: &str,
+        #[case] name: &str,
+        #[case] expected_error: &str
+    ) {
+        let mock_repo = MockRepository::new();
+        let service = UserService::new(mock_repo);
+
+        let user_data = UserData {
+            email: email.to_string(),
+            name: name.to_string(),
+        };
+
+        let result = service.create_user(user_data);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains(expected_error));
+    }
+}
+```
+
+## Test Data Builders Pattern
+
+### TypeScript
+
+```typescript
+class UserBuilder {
+  private user: Partial<User> = {
+    email: 'test@example.com',
+    name: 'Test User',
+    role: 'user',
+    active: true,
+  };
+
+  withEmail(email: string): this {
+    this.user.email = email;
+    return this;
+  }
+
+  withRole(role: string): this {
+    this.user.role = role;
+    return this;
+  }
+
+  inactive(): this {
+    this.user.active = false;
+    return this;
+  }
+
+  build(): User {
+    return this.user as User;
+  }
+}
+
+// Usage in tests
+const adminUser = new UserBuilder()
+  .withEmail('admin@example.com')
+  .withRole('admin')
+  .build();
+
+const inactiveUser = new UserBuilder()
+  .inactive()
+  .build();
+```
+
+### Python Factory Boy
+
+```python
+import factory
+from factory import fuzzy
+from myapp.models import User, Post
+
+class UserFactory(factory.Factory):
+    class Meta:
+        model = User
+
+    email = factory.Sequence(lambda n: f'user{n}@example.com')
+    name = factory.Faker('name')
+    role = 'user'
+    active = True
+
+class AdminUserFactory(UserFactory):
+    role = 'admin'
+
+class PostFactory(factory.Factory):
+    class Meta:
+        model = Post
+
+    title = factory.Faker('sentence')
+    content = factory.Faker('text')
+    author = factory.SubFactory(UserFactory)
+    published_at = factory.Faker('date_time_this_year')
+
+# Usage in tests
+def test_user_can_create_post():
+    user = UserFactory()
+    post = PostFactory(author=user)
+    assert post.author.id == user.id
+
+def test_admin_has_permissions():
+    admin = AdminUserFactory()
+    assert admin.role == 'admin'
+```
+
+## Integration Testing Patterns
+
+### Database Integration Tests (TypeScript)
+
+```typescript
+import { DataSource } from 'typeorm';
+
+describe('UserRepository Integration Tests', () => {
+  let dataSource: DataSource;
+  let repository: UserRepository;
+
+  beforeAll(async () => {
+    // Setup test database
+    dataSource = new DataSource({
+      type: 'postgres',
+      host: 'localhost',
+      port: 5433, // Test DB port
+      database: 'test_db',
+      entities: [User],
+      synchronize: true,
+    });
+    await dataSource.initialize();
+    repository = new UserRepository(dataSource);
+  });
+
+  afterAll(async () => {
+    await dataSource.destroy();
+  });
+
+  beforeEach(async () => {
+    // Clean database before each test
+    await dataSource.synchronize(true);
+  });
+
+  it('should persist and retrieve user', async () => {
+    const userData = { email: 'test@example.com', name: 'Test' };
+
+    const saved = await repository.save(userData);
+    expect(saved.id).toBeDefined();
+
+    const retrieved = await repository.findById(saved.id);
+    expect(retrieved?.email).toBe(userData.email);
+  });
+
+  it('should enforce unique email constraint', async () => {
+    const userData = { email: 'unique@example.com', name: 'Test' };
+
+    await repository.save(userData);
+
+    await expect(
+      repository.save(userData)
+    ).rejects.toThrow(/duplicate key/);
+  });
+});
+```
+
+### API Integration Tests (Python with pytest)
+
+```python
+import pytest
+from httpx import AsyncClient
+from myapp.main import app
+
+@pytest.fixture
+async def client():
+    async with AsyncClient(app=app, base_url="http://test") as ac:
+        yield ac
+
+@pytest.fixture
+async def authenticated_client(client):
+    # Login and get token
+    response = await client.post("/auth/login", json={
+        "email": "test@example.com",
+        "password": "password123"
+    })
+    token = response.json()["access_token"]
+    client.headers["Authorization"] = f"Bearer {token}"
+    return client
+
+@pytest.mark.asyncio
+async def test_create_user_endpoint(client):
+    response = await client.post("/users", json={
+        "email": "new@example.com",
+        "name": "New User"
+    })
+
+    assert response.status_code == 201
+    data = response.json()
+    assert data["email"] == "new@example.com"
+    assert "id" in data
+
+@pytest.mark.asyncio
+async def test_get_protected_resource(authenticated_client):
+    response = await authenticated_client.get("/users/me")
+
+    assert response.status_code == 200
+    assert response.json()["email"] == "test@example.com"
+```
+
+## End-to-End Testing
+
+### Playwright (TypeScript)
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('User Registration Flow', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/');
+  });
+
+  test('should register new user successfully', async ({ page }) => {
+    // Navigate to registration
+    await page.click('text=Sign Up');
+
+    // Fill form
+    await page.fill('[data-testid="email-input"]', 'newuser@example.com');
+    await page.fill('[data-testid="password-input"]', 'SecurePass123!');
+    await page.fill('[data-testid="name-input"]', 'New User');
+
+    // Submit
+    await page.click('[data-testid="submit-button"]');
+
+    // Verify success
+    await expect(page.locator('text=Welcome')).toBeVisible();
+    await expect(page).toHaveURL(/\/dashboard/);
+  });
+
+  test('should show validation errors', async ({ page }) => {
+    await page.click('text=Sign Up');
+
+    // Submit empty form
+    await page.click('[data-testid="submit-button"]');
+
+    // Check for error messages
+    await expect(page.locator('text=Email is required')).toBeVisible();
+    await expect(page.locator('text=Password is required')).toBeVisible();
+  });
+
+  test('should handle server errors gracefully', async ({ page }) => {
+    // Intercept API call and force error
+    await page.route('**/api/auth/register', route =>
+      route.fulfill({ status: 500, body: 'Server Error' })
+    );
+
+    await page.click('text=Sign Up');
+    await page.fill('[data-testid="email-input"]', 'test@example.com');
+    await page.fill('[data-testid="password-input"]', 'password123');
+    await page.click('[data-testid="submit-button"]');
+
+    await expect(page.locator('text=Something went wrong')).toBeVisible();
+  });
+});
+
+// Page Object Model pattern
+class LoginPage {
+  constructor(private page: Page) {}
+
+  async navigate() {
+    await this.page.goto('/login');
+  }
+
+  async login(email: string, password: string) {
+    await this.page.fill('[data-testid="email-input"]', email);
+    await this.page.fill('[data-testid="password-input"]', password);
+    await this.page.click('[data-testid="login-button"]');
+  }
+
+  async getErrorMessage() {
+    return this.page.locator('[data-testid="error-message"]').textContent();
+  }
+}
+
+test('login with invalid credentials', async ({ page }) => {
+  const loginPage = new LoginPage(page);
+  await loginPage.navigate();
+  await loginPage.login('wrong@example.com', 'wrongpass');
+
+  const error = await loginPage.getErrorMessage();
+  expect(error).toContain('Invalid credentials');
+});
+```
+
+## Test Coverage and Quality Metrics
+
+### Jest Coverage Configuration
+
+```javascript
+// jest.config.js
+module.exports = {
+  collectCoverageFrom: [
+    'src/**/*.{js,ts}',
+    '!src/**/*.d.ts',
+    '!src/**/*.test.{js,ts}',
+    '!src/**/index.{js,ts}',
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80,
+    },
+    './src/critical/**/*.ts': {
+      branches: 95,
+      functions: 95,
+      lines: 95,
+      statements: 95,
+    },
+  },
+  coverageReporters: ['text', 'lcov', 'html'],
+};
+```
+
+### pytest-cov Configuration
+
+```ini
+# pytest.ini
+[tool:pytest]
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+addopts =
+    --cov=myapp
+    --cov-report=html
+    --cov-report=term-missing
+    --cov-fail-under=80
+    --cov-branch
+```
+
+## Mocking and Stubbing Strategies
+
+### Mocking External APIs
+
+```typescript
+// Using MSW (Mock Service Worker)
+import { rest } from 'msw';
+import { setupServer } from 'msw/node';
+
+const handlers = [
+  rest.get('https://api.github.com/users/:username', (req, res, ctx) => {
+    const { username } = req.params;
+    return res(
+      ctx.status(200),
+      ctx.json({
+        login: username,
+        name: 'Test User',
+        public_repos: 42,
+      })
+    );
+  }),
+
+  rest.post('https://api.stripe.com/v1/charges', (req, res, ctx) => {
+    return res(
+      ctx.status(200),
+      ctx.json({
+        id: 'ch_test_123',
+        status: 'succeeded',
+        amount: 1000,
+      })
+    );
+  }),
+];
+
+const server = setupServer(...handlers);
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+test('fetches user from GitHub', async () => {
+  const user = await fetchGithubUser('testuser');
+  expect(user.name).toBe('Test User');
+  expect(user.public_repos).toBe(42);
+});
+```
+
+### Time Mocking
+
+```typescript
+import { jest } from '@jest/globals';
+
+test('schedules task for future execution', () => {
+  jest.useFakeTimers();
+  const callback = jest.fn();
+
+  scheduleTask(callback, 5000);
+
+  expect(callback).not.toHaveBeenCalled();
+
+  jest.advanceTimersByTime(5000);
+
+  expect(callback).toHaveBeenCalledTimes(1);
+
+  jest.useRealTimers();
+});
+```
+
+## Snapshot Testing
+
+```typescript
+import renderer from 'react-test-renderer';
+
+test('UserCard renders correctly', () => {
+  const user = {
+    name: 'John Doe',
+    email: 'john@example.com',
+    avatar: 'https://example.com/avatar.jpg',
+  };
+
+  const tree = renderer.create(<UserCard user={user} />).toJSON();
+  expect(tree).toMatchSnapshot();
+});
+
+// Inline snapshots
+test('formats currency correctly', () => {
+  expect(formatCurrency(1234.56)).toMatchInlineSnapshot(`"$1,234.56"`);
+  expect(formatCurrency(0)).toMatchInlineSnapshot(`"$0.00"`);
+});
+```
+
+## Contract Testing
+
+```typescript
+// Pact consumer test
+import { Pact } from '@pact-foundation/pact';
+
+const provider = new Pact({
+  consumer: 'FrontendApp',
+  provider: 'UserAPI',
+});
+
+describe('User API Contract', () => {
+  beforeAll(() => provider.setup());
+  afterAll(() => provider.finalize());
+
+  test('get user by id', async () => {
+    await provider.addInteraction({
+      state: 'user exists',
+      uponReceiving: 'a request for user',
+      withRequest: {
+        method: 'GET',
+        path: '/users/123',
+        headers: { Accept: 'application/json' },
+      },
+      willRespondWith: {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+        body: {
+          id: 123,
+          name: 'John Doe',
+          email: 'john@example.com',
+        },
+      },
+    });
+
+    const api = new UserAPI(provider.mockService.baseUrl);
+    const user = await api.getUser(123);
+
+    expect(user.name).toBe('John Doe');
+    await provider.verify();
+  });
+});
+```
+
+## Best Practices
+
+### 1. Test Independence
+- Each test should be independent and not rely on other tests
+- Use beforeEach/afterEach for setup and teardown
+- Avoid shared mutable state
+
+### 2. Test Naming
+```typescript
+// Good: Describes what is being tested and expected outcome
+test('should return 404 when user does not exist', () => {});
+test('should send email notification after successful registration', () => {});
+
+// Bad: Vague or unclear
+test('test1', () => {});
+test('it works', () => {});
+```
+
+### 3. Avoid Test Interdependence
+```typescript
+// Bad
+let userId: number;
+
+test('creates user', async () => {
+  userId = await createUser({ name: 'Test' });
+});
+
+test('updates user', async () => {
+  await updateUser(userId, { name: 'Updated' }); // Depends on previous test
+});
+
+// Good
+test('updates user', async () => {
+  const user = await createUser({ name: 'Test' });
+  await updateUser(user.id, { name: 'Updated' });
+});
+```
+
+### 4. Test the Interface, Not Implementation
+```typescript
+// Bad: Testing implementation details
+test('should call internal method', () => {
+  const service = new UserService();
+  const spy = jest.spyOn(service as any, '_validateEmail');
+  service.createUser({ email: 'test@example.com' });
+  expect(spy).toHaveBeenCalled();
+});
+
+// Good: Testing behavior
+test('should reject invalid email', async () => {
+  const service = new UserService();
+  await expect(
+    service.createUser({ email: 'invalid' })
+  ).rejects.toThrow('Invalid email');
+});
+```
+
+### 5. Use Fixtures and Factories
+Keep test data DRY and maintainable
+
+### 6. Avoid Testing External Dependencies Directly
+Mock external services and APIs
+
+### 7. Keep Tests Fast
+- Use in-memory databases for tests
+- Mock expensive operations
+- Run unit tests in parallel
+- Separate slow integration/E2E tests
+
+### 8. Measure What Matters
+- Focus on critical paths
+- Aim for meaningful coverage, not just high percentages
+- Test edge cases and error conditions