# 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