​

Writing Tests

​

Basic Test Generation

> Write unit tests for the UserService class

• Analyze the code to understand its behavior
• Generate comprehensive tests covering:
  • Happy path scenarios
  • Edge cases
  • Error conditions
• Follow testing conventions for your language/framework
• Include appropriate assertions and mocks

​

Test-Driven Development (TDD)

> I need a function that validates email addresses. Help me write the test first.

> Now implement the email validation function to make this test pass

​

Testing Patterns and Best Practices

​

Three-Phase Test Pattern

use pretty_assertions::assert_eq;

fn test_user_creation() {
    // Setup: Create test fixtures
    let fixture = User::test().age(25).name("Alice");
    
    // Execute: Run the code under test
    let actual = create_user(fixture);
    
    // Assert: Verify the expected result
    let expected = User::default().age(25).name("Alice").id(1);
    assert_eq!(actual, expected);
}

​

Using Fixtures

> Create a test fixture for the User model

• Generic, reusable test data
• Builder pattern with derive_setters
• Default values for required fields
• Methods to customize specific fields

​

Descriptive Variable Names

fn test_calculate_discount() {
    let fixture = Order::test().total(100).discount_code("SAVE20");
    let actual = calculate_discount(fixture);
    let expected = 80;
    assert_eq!(actual, expected);
}

​

Language-Specific Testing

​

Rust Testing

> Write Rust tests for this service function

• Tests are in the same file as source code
• pretty_assertions is used for better error messages
• unwrap() is used in tests (not production code)
• expect() with messages for clarity when needed
• Full object comparison with assert_eq!

use pretty_assertions::assert_eq;

#[test]
fn test_user_validation() {
    let fixture = User::test().age(15); // Below minimum age
    let actual = validate_user(fixture).is_err();
    assert!(actual, "Should reject users under 18");
}

​

JavaScript/TypeScript Testing

> Write Jest tests for this React component

• Proper test setup with required imports
• Mocks for dependencies
• Async/await handling where needed
• Component rendering and interaction tests

​

Python Testing

> Write pytest tests for this API endpoint

• Test fixtures with pytest decorators
• Proper assertions using pytest features
• Mock objects for external dependencies
• Parameterized tests for multiple scenarios

​

Real-World Testing Scenarios

​

Scenario 1: Testing API Endpoints

> Write integration tests for the user registration endpoint

​

Scenario 2: Testing React Components

> Write tests for the UserProfile component

• Component rendering with different props
• User interactions (clicks, form submissions)
• State changes
• API calls and loading states
• Error handling and edge cases

​

Scenario 3: Testing Business Logic

> Write comprehensive tests for the pricing calculation service

• Basic calculations
• Discount applications
• Tax calculations
• Edge cases (zero amounts, negative values)
• Boundary conditions (minimum/maximum values)

​

Test Coverage and Completeness

​

Ensuring Complete Coverage

> Analyze test coverage for the authentication module and add missing tests

• Identify untested code paths
• Suggest additional test cases
• Generate tests for missing scenarios
• Highlight edge cases that need coverage

​

Edge Case Testing

> What edge cases should I test for this date parsing function?

• Null/undefined inputs
• Empty strings
• Invalid formats
• Boundary dates (leap years, timezone changes)
• Locale-specific issues

​

Mocking and Test Doubles

​

Creating Mocks

> Create a mock for the external payment API

• Mock objects that match the real API interface
• Configurable responses for different test scenarios
• Verification methods to check mock calls

​

Dependency Injection for Testing

> Refactor this service to be more testable using dependency injection

• Constructor injection
• Interface-based dependencies
• Configurable behavior for tests

​

Integration and E2E Testing

​

Integration Tests

> Write integration tests for the order processing workflow

• Set up complete test environments
• Test interactions between components
• Verify end-to-end functionality
• Clean up test data afterward

​

Database Testing

> Write tests for these database queries

• Setting up test databases
• Creating seed data
• Running migrations
• Cleaning up after tests
• Testing transactions and rollbacks

​

Performance Testing

> Add performance benchmarks for this sorting algorithm

• Benchmark tests with various data sizes
• Performance assertions
• Comparison with baseline measurements
• Memory usage tracking

​

Testing Best Practices

1. Test behavior, not implementation: Focus on what code does, not how
2. One assertion per test: Keep tests focused and specific
3. Use descriptive test names: Name should explain what’s being tested
4. Make tests independent: Tests shouldn’t depend on each other
5. Keep tests fast: Unit tests should run in milliseconds
6. Use fixtures: Create reusable test data
7. Test edge cases: Don’t just test the happy path

​

Test Maintenance

​

Updating Tests After Refactoring

> I refactored the UserService. Update the tests to match.

• Analyze changes in the implementation
• Update test setup to match new interfaces
• Preserve test intent while adapting structure
• Ensure all tests still pass

​

Fixing Failing Tests

> These tests are failing after my changes. Help me fix them.

• Should the implementation change to match tests?
• Or should tests update to match new behavior?
• Are the tests revealing actual bugs?

​

Testing Anti-Patterns to Avoid

​

Don’t: Test Implementation Details

expect(component.state.counter).toBe(5);

expect(screen.getByText('Count: 5')).toBeInTheDocument();

​

Don’t: Share State Between Tests

let user; // Shared across tests
test('creates user', () => { user = createUser(); });
test('updates user', () => { updateUser(user); });

test('creates user', () => {
    const user = createUser();
    expect(user).toBeDefined();
});

test('updates user', () => {
    const user = createUser();
    updateUser(user);
    expect(user.updated).toBe(true);
});

​

Don’t: Use Multiple Assertions for Parts

assert_eq!(actual.name, expected.name);
assert_eq!(actual.age, expected.age);
assert_eq!(actual.email, expected.email);

assert_eq!(actual, expected);

​

Common Testing Commands

​

Verification After Writing Tests

# For Rust projects
cargo insta test --accept

# For JavaScript projects
npm test

# For Python projects
pytest

​

Next Steps

• Learn about Code Review including test quality
• Explore Refactoring to improve testability
• Review Best Practices for development workflows