// ✅ DO: Clear AAA pattern, descriptive names
describe('UserService', () => {
  describe('createUser', () => {
    it('should create user with valid data', async () => {
      // Arrange
      const userData = {
        email: 'test@example.com',
        name: 'Test User',
      };
      const mockRepo = {
        save: jest.fn().mockResolvedValue({ id: '123', ...userData }),
      };
      const service = new UserService(mockRepo);
      
      // Act
      const result = await service.createUser(userData);
      
      // Assert
      expect(result.id).toBe('123');
      expect(result.email).toBe('test@example.com');
      expect(mockRepo.save).toHaveBeenCalledWith(userData);
    });
    
    it('should throw ValidationError for invalid email', async () => {
      // Arrange
      const userData = { email: 'invalid', name: 'Test' };
      const service = new UserService(mockRepo);
      
      // Act & Assert
      await expect(service.createUser(userData))
        .rejects.toThrow(ValidationError);
    });
    
    it('should handle duplicate email gracefully', async () => {
      // Arrange
      const userData = { email: 'existing@example.com', name: 'Test' };
      const mockRepo = {
        save: jest.fn().mockRejectedValue(new DuplicateKeyError()),
      };
      const service = new UserService(mockRepo);
      
      // Act & Assert
      await expect(service.createUser(userData))
        .rejects.toThrow(UserAlreadyExistsError);
    });
  });
});

// ❌ DON'T: Vague names, unclear structure
test('user test', async () => {
  const result = await createUser({ email: 'test@example.com' });
  expect(result).toBeTruthy();
});

// ✅ DO: Real dependencies, transaction rollback
#[tokio::test]
async fn test_create_user_integration() {
    // Arrange
    let db = test_database().await;
    let repo = UserRepository::new(db.pool());
    let service = UserService::new(repo);
    
    let user_data = CreateUserRequest {
        email: "test@example.com".to_string(),
        name: "Test User".to_string(),
    };
    
    // Act
    let user = service.create_user(user_data).await.unwrap();
    
    // Assert
    assert_eq!(user.email, "test@example.com");
    
    // Verify persisted
    let fetched = service.get_user(user.id).await.unwrap();
    assert_eq!(fetched.name, "Test User");
    
    // Cleanup (or use test transaction)
    db.cleanup().await;
}

#[tokio::test]
async fn test_duplicate_email_constraint() {
    let db = test_database().await;
    let service = UserService::new(UserRepository::new(db.pool()));
    
    let user_data = CreateUserRequest {
        email: "duplicate@example.com".to_string(),
        name: "User 1".to_string(),
    };
    
    // First creation succeeds
    service.create_user(user_data.clone()).await.unwrap();
    
    // Second creation fails
    let result = service.create_user(user_data).await;
    assert!(matches!(result, Err(UserError::DuplicateEmail(_))));
    
    db.cleanup().await;
}

# ✅ DO: Full user flow, realistic scenarios
import pytest
from playwright.async_api import async_playwright

@pytest.mark.e2e
async def test_user_registration_flow():
    """Test complete user registration from landing page to dashboard."""
    async with async_playwright() as p:
        # Arrange
        browser = await p.chromium.launch()
        page = await browser.new_page()
        
        # Act - Navigate and register
        await page.goto('http://localhost:3000')
        await page.click('text=Sign Up')
        await page.fill('[name="email"]', 'newuser@example.com')
        await page.fill('[name="password"]', 'SecurePass123!')
        await page.fill('[name="name"]', 'New User')
        await page.click('button[type="submit"]')
        
        # Assert - Redirected to dashboard
        await page.wait_for_url('**/dashboard')
        welcome_text = await page.text_content('h1')
        assert 'Welcome, New User' in welcome_text
        
        # Assert - Can see user profile
        await page.click('[data-testid="user-menu"]')
        email_display = await page.text_content('[data-testid="user-email"]')
        assert email_display == 'newuser@example.com'
        
        await browser.close()

@pytest.mark.e2e
async def test_invalid_login_shows_error():
    """Test that invalid credentials show appropriate error."""
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        
        await page.goto('http://localhost:3000/login')
        await page.fill('[name="email"]', 'nonexistent@example.com')
        await page.fill('[name="password"]', 'wrongpassword')
        await page.click('button[type="submit"]')
        
        # Should show error, not redirect
        error_message = await page.text_content('[role="alert"]')
        assert 'Invalid credentials' in error_message
        
        await browser.close()

# ✅ DO: Test properties that should always hold
from hypothesis import given, strategies as st

@given(st.integers(min_value=0, max_value=1000))
def test_user_age_validation(age: int):
    """User age should always be validated correctly."""
    user = User(name="Test", age=age)
    
    if age < 13:
        assert not user.is_eligible_for_account()
    elif 13 <= age < 18:
        assert user.requires_parental_consent()
    else:
        assert user.is_eligible_for_account()

@given(st.emails())
def test_email_normalization_is_idempotent(email: str):
    """Normalizing an email twice should give same result."""
    normalized_once = normalize_email(email)
    normalized_twice = normalize_email(normalized_once)
    assert normalized_once == normalized_twice

@given(st.lists(st.integers(), min_size=0, max_size=100))
def test_sort_always_produces_sorted_list(numbers: list[int]):
    """Our sort function should always produce sorted output."""
    sorted_nums = custom_sort(numbers)
    
    # Property: result should be sorted
    for i in range(len(sorted_nums) - 1):
        assert sorted_nums[i] <= sorted_nums[i + 1]
    
    # Property: result should contain same elements
    assert sorted(sorted_nums) == sorted(numbers)

// Example function with 6 branches
async function createUser(data: UserData): Promise<User> {
  // Branch 1 & 2: Email validation
  if (!data.email || !isValidEmail(data.email)) {
    throw new ValidationError('email', 'Invalid email format');
  }
  
  // Branch 3 & 4: Name validation
  if (!data.name || data.name.length < 2) {
    throw new ValidationError('name', 'Name too short');
  }
  
  try {
    // Branch 5: Success path
    return await userRepository.save(data);
  } catch (error) {
    // Branch 6: Database error path
    if (isDatabaseError(error) && error.code === '23505') {
      throw new DuplicateUserError('User already exists');
    }
    throw new DatabaseError('Failed to create user', { cause: error });
  }
}

describe('createUser - Branch Coverage', () => {
  // Branch 1: Missing email
  it('should throw ValidationError when email is missing', async () => {
    const data = { name: 'John Doe' } as UserData;
    await expect(createUser(data)).rejects.toThrow(ValidationError);
    await expect(createUser(data)).rejects.toThrow('Invalid email format');
  });
  
  // Branch 2: Invalid email format
  it('should throw ValidationError when email format is invalid', async () => {
    const data = { email: 'invalid-email', name: 'John Doe' };
    await expect(createUser(data)).rejects.toThrow(ValidationError);
  });
  
  // Branch 3: Missing name
  it('should throw ValidationError when name is missing', async () => {
    const data = { email: 'john@example.com' } as UserData;
    await expect(createUser(data)).rejects.toThrow(ValidationError);
    await expect(createUser(data)).rejects.toThrow('Name too short');
  });
  
  // Branch 4: Name too short
  it('should throw ValidationError when name is too short', async () => {
    const data = { email: 'john@example.com', name: 'J' };
    await expect(createUser(data)).rejects.toThrow(ValidationError);
  });
  
  // Branch 5: Success path
  it('should create user when data is valid', async () => {
    const data = { email: 'john@example.com', name: 'John Doe' };
    const user = await createUser(data);
    expect(user.email).toBe('john@example.com');
    expect(user.name).toBe('John Doe');
  });
  
  // Branch 6: Duplicate key error
  it('should throw DuplicateUserError when email already exists', async () => {
    const data = { email: 'existing@example.com', name: 'John Doe' };
    // Setup: Create user first
    await createUser(data);
    // Test: Try to create again
    await expect(createUser(data)).rejects.toThrow(DuplicateUserError);
  });
  
  // Branch 7: General database error
  it('should throw DatabaseError when database operation fails', async () => {
    const data = { email: 'john@example.com', name: 'John Doe' };
    // Mock database failure
    jest.spyOn(userRepository, 'save').mockRejectedValueOnce(new Error('Connection lost'));
    await expect(createUser(data)).rejects.toThrow(DatabaseError);
  });
});

// 1. Connection Failures
describe('DatabaseClient - Error Paths', () => {
  it('should throw DatabaseConnectionError when connection fails', async () => {
    const client = new DatabaseClient({ connectionString: 'invalid' });
    await expect(client.connect()).rejects.toThrow(DatabaseConnectionError);
  });
  
  it('should throw when querying without connection', async () => {
    const client = new DatabaseClient(config);
    // Don't connect first
    await expect(client.query('SELECT 1')).rejects.toThrow('Not connected');
  });
});

// 2. Async Operation Errors
describe('MigrationRunner - Async Errors', () => {
  it('should handle migration execution failure', async () => {
    const runner = new MigrationRunner();
    const badMigration = { name: '001', sql: 'INVALID SQL' };
    await expect(runner.executeMigration(badMigration))
      .rejects.toThrow(MigrationExecutionError);
  });
  
  it('should cleanup connection even if migration fails', async () => {
    const runner = new MigrationRunner();
    const disconnectSpy = jest.spyOn(DatabaseClient.prototype, 'disconnect');
    
    try {
      await runner.run({ migrations: [badMigration] });
    } catch {
      // Expected to fail
    }
    
    // But should still cleanup
    expect(disconnectSpy).toHaveBeenCalled();
  });
});

// 3. Null/Undefined Checks
describe('ConfigLoader - Null Handling', () => {
  it('should throw when config file does not exist', () => {
    expect(() => loadConfig('/nonexistent/config.json'))
      .toThrow(ConfigurationError);
  });
  
  it('should throw when config JSON is invalid', () => {
    fs.writeFileSync('/tmp/bad.json', '{ invalid json }');
    expect(() => loadConfig('/tmp/bad.json'))
      .toThrow('Invalid JSON');
  });
  
  it('should throw when required field is missing', () => {
    fs.writeFileSync('/tmp/incomplete.json', '{"database":{}}');
    expect(() => loadConfig('/tmp/incomplete.json'))
      .toThrow(ValidationError);
  });
});

// 4. CLI Argument Validation
describe('CLI - Argument Validation', () => {
  it('should exit with code 1 when direction is invalid', async () => {
    const exitSpy = jest.spyOn(process, 'exit').mockImplementation();
    
    await program.parseAsync(['node', 'cli', 'migrate', '--direction', 'sideways']);
    
    expect(exitSpy).toHaveBeenCalledWith(1);
  });
  
  it('should show error message for missing required option', async () => {
    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
    
    await program.parseAsync(['node', 'cli', 'migrate']);
    
    expect(consoleErrorSpy).toHaveBeenCalledWith(
      expect.stringContaining('required option')
    );
  });
});

// Empty inputs
it('should handle empty array', () => {
  expect(processUsers([])).toEqual([]);
});

// Null/undefined
it('should handle null input', () => {
  expect(() => validateUser(null)).toThrow(ValidationError);
});

// Boundary values
it('should accept minimum valid age', () => {
  expect(validateAge(13)).toBe(true);
});

it('should reject below minimum age', () => {
  expect(validateAge(12)).toBe(false);
});

// Type coercion issues (TypeScript strict mode catches these)
it('should reject string when number expected', () => {
  expect(() => validateAge('18' as any)).toThrow(TypeError);
});

// jest.config.js
module.exports = {
  coverageThreshold: {
    global: {
      statements: 80,
      branches: 70,    // Focus on branches!
      functions: 80,
      lines: 80,
    },
  },
};

# Generate detailed coverage report
npm test -- --coverage

# View HTML report (shows untested branches)
open coverage/lcov-report/index.html

# Focus on specific file
npm test -- --coverage --testPathPattern=userService

File              | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
------------------|---------|----------|---------|---------|-------------------
userService.ts    |   95.00 |   80.00  |  100.00 |   95.00 | 45-47,89
database.ts       |   88.23 |   62.50  |   85.71 |   88.23 | 123,145-150,201
                                  ⬆️
                           FOCUS HERE FIRST

// ❌ Only tests success case
it('should connect to database', async () => {
  await client.connect();
  expect(client.isConnected()).toBe(true);
});

// ✅ Also test failure case
it('should throw on connection failure', async () => {
  const badClient = new DatabaseClient({ connectionString: 'invalid' });
  await expect(badClient.connect()).rejects.toThrow(DatabaseConnectionError);
});

// ❌ Catches error but doesn't validate type
it('should handle duplicate email', async () => {
  try {
    await createUser({ email: 'existing@example.com' });
  } catch (error) {
    // Test passes even if wrong error thrown
  }
});

// ✅ Validates specific error type
it('should throw DuplicateUserError for duplicate email', async () => {
  await expect(createUser({ email: 'existing@example.com' }))
    .rejects.toThrow(DuplicateUserError);
});

// ❌ Mocks so much that branches aren't exercised
it('should create user', async () => {
  const mockRepo = {
    save: jest.fn().mockResolvedValue({ id: '123' })
  };
  // Never tests validation logic branches!
  const result = await createUser({ email: 'test@example.com' });
});

// ✅ Test real validation branches
it('should validate email before saving', async () => {
  await expect(createUser({ email: 'invalid' }))
    .rejects.toThrow(ValidationError);
});

// ❌ Doesn't test cleanup path
it('should run migrations', async () => {
  await runner.run(migrations);
  // Never tests if disconnect() is called
});

// ✅ Test cleanup even on error
it('should cleanup connection on migration failure', async () => {
  const disconnectSpy = jest.spyOn(client, 'disconnect');
  
  try {
    await runner.run([badMigration]);
  } catch {
    // Expected
  }
  
  expect(disconnectSpy).toHaveBeenCalled();
});

tests/
├── unit/                  # Fast, isolated unit tests
│   ├── services/
│   │   ├── userService.test.ts
│   │   └── authService.test.ts
│   └── utils/
│       └── validation.test.ts
├── integration/           # Tests with real dependencies
│   ├── database/
│   │   └── userRepository.test.ts
│   └── api/
│       └── userEndpoints.test.ts
├── e2e/                   # Full user flow tests
│   ├── registration.spec.ts
│   └── checkout.spec.ts
├── fixtures/              # Test data
│   ├── users.json
│   └── products.json
└── helpers/               # Test utilities
    ├── testDatabase.ts
    └── mockServices.ts

// ✅ DO: Use factories for test data
export class UserFactory {
  private static counter = 0;
  
  static create(overrides: Partial<User> = {}): User {
    const id = ++this.counter;
    return {
      id: `user-${id}`,
      email: `user${id}@example.com`,
      name: `Test User ${id}`,
      createdAt: new Date(),
      isActive: true,
      ...overrides,
    };
  }
  
  static createMany(count: number, overrides: Partial<User> = {}): User[] {
    return Array.from({ length: count }, () => this.create(overrides));
  }
}

// Usage
const user = UserFactory.create({ email: 'specific@example.com' });
const users = UserFactory.createMany(10, { isActive: false });

// ❌ DON'T: Hardcode test data everywhere
const user = {
  id: '123',
  email: 'test@example.com',
  name: 'Test',
  createdAt: new Date('2024-01-01'),
  isActive: true,
};

// ✅ DO: Clear mocks with expected behavior
const mockEmailService = {
  sendEmail: jest.fn().mockResolvedValue({ messageId: '123' }),
};

// Verify interaction
await service.registerUser(userData);
expect(mockEmailService.sendEmail).toHaveBeenCalledWith({
  to: 'user@example.com',
  subject: 'Welcome!',
  body: expect.stringContaining('registration'),
});

// ❌ DON'T: Mock everything
// (Testing mocks, not real behavior)

/**
 * User Service Test Suite
 * 
 * Covers:
 * - User creation with validation
 * - User retrieval and updates
 * - Authentication flows
 * - Error handling (duplicate emails, invalid data)
 * 
 * Test Data: Uses UserFactory for consistent test users
 * External Dependencies: Mocked EmailService, real in-memory database
 */
describe('UserService', () => {
  // Tests here
});

## Test Generation Evidence

**Component**: UserService
**Test Count**: 23 tests (18 unit, 5 integration)
**Coverage**: 94% (lines), 89% (branches)
**Execution Time**: 142ms (unit), 3.2s (integration)

### Test Scenarios Covered
- ✅ User creation (happy path)
- ✅ Validation errors (invalid email, weak password)
- ✅ Duplicate email handling
- ✅ User retrieval (found/not found)
- ✅ Authentication flows
- ✅ Password reset workflow
- ✅ Email verification

### Coverage Gaps
- ⚠️ Concurrent user creation (race condition testing)
- ⚠️ Account deletion (soft delete verification)

### Recommendations
- Add property-based tests for email normalization
- Increase integration test coverage for database constraints