What are the different types of software testing? Explain the difference between unit, integration, and end-to-end tests.

Question

Accepted Answer

## Types of Software Testing

### Unit Testing

Tests **individual functions or components in isolation**. The smallest testable parts of an application.

```javascript
// Function to test
function add(a, b) {
  return a + b;
}

// Unit test
test('add returns sum of two numbers', () => {
  expect(add(2, 3)).toBe(5);
  expect(add(-1, 1)).toBe(0);
});
```

**Characteristics:**
- Fast execution (milliseconds)
- Tests one thing at a time
- Dependencies are mocked
- Catches bugs early

### Integration Testing

Tests how **multiple components work together**. Verifies that modules interact correctly.

```javascript
// Testing API endpoint with database
test('POST /users creates a new user', async () => {
  const response = await request(app)
    .post('/users')
    .send({ name: 'Alice', email: 'alice@test.com' });

  expect(response.status).toBe(201);

  // Verify it's actually in the database
  const user = await db.users.findOne({ email: 'alice@test.com' });
  expect(user).toBeDefined();
});
```

**Characteristics:**
- Tests interactions between modules
- May use real databases (often test DB)
- Slower than unit tests
- Catches integration issues

### End-to-End (E2E) Testing

Tests the **entire application flow** from the user's perspective.

```javascript
// Cypress E2E test
describe('User Registration', () => {
  it('allows a new user to sign up', () => {
    cy.visit('/signup');
    cy.get('input[name="email"]').type('alice@test.com');
    cy.get('input[name="password"]').type('password123');
    cy.get('button[type="submit"]').click();
    cy.url().should('include', '/dashboard');
    cy.contains('Welcome, Alice');
  });
});
```

**Characteristics:**
- Tests real user scenarios
- Uses actual browser/app
- Slowest to run
- Catches UI and flow issues

## Comparison

| Type | Speed | Scope | Dependencies | Catches |
|------|-------|-------|--------------|---------|
| **Unit** | Fast (ms) | Single function | Mocked | Logic bugs |
| **Integration** | Medium (s) | Multiple modules | Some real | Interface issues |
| **E2E** | Slow (min) | Entire app | All real | User flow issues |

## The Testing Pyramid

```
        /\
       /E2E\        Few (slow, expensive)
      /------\
     /  Integ  \    Medium
    /------------\
   /    Unit      \  Many (fast, cheap)
  ------------------
```

**Best Practice:** Have many unit tests, fewer integration tests, and even fewer E2E tests.