Testing Strategies: Unit, Integration, and E2E Testing Best Practices

Testing is a critical aspect of software development that ensures code quality, reliability, and maintainability. A comprehensive testing strategy includes unit tests, integration tests, and end-to-end tests, each serving different purposes in the software development lifecycle.

This comprehensive guide covers testing strategies from fundamentals to advanced practices. You'll learn about different testing types, best practices, popular tools, and how to build a robust testing strategy for your applications.

The testing pyramid is a model that describes the ideal distribution of tests:

Testing Pyramid Structure:

• Unit Tests (Base): Many fast, isolated tests

• Integration Tests (Middle): Fewer tests that verify component interactions

• E2E Tests (Top): Few tests that verify complete user workflows

Why the Pyramid?

• Unit Tests: Fast, cheap, catch most bugs

• Integration Tests: Verify component interactions

• E2E Tests: Slow, expensive, verify user experience

Test Distribution:

• 70% Unit Tests: Fast, isolated, comprehensive

• 20% Integration Tests: Component interactions

• 10% E2E Tests: Critical user paths

// utils/calculator.js
export function add(a, b) {
    return a + b;
}

export function divide(a, b) {
    if (b === 0) {
        throw new Error('Division by zero');
    }
    return a / b;
}

// utils/calculator.test.js
import { add, divide } from './calculator';

describe('Calculator', () => {
    describe('add', () => {
        test('adds two positive numbers', () => {
            expect(add(2, 3)).toBe(5);
        });
        
        test('adds negative numbers', () => {
            expect(add(-2, -3)).toBe(-5);
        });
        
        test('adds zero', () => {
            expect(add(5, 0)).toBe(5);
        });
    });
    
    describe('divide', () => {
        test('divides two numbers', () => {
            expect(divide(10, 2)).toBe(5);
        });
        
        test('throws error on division by zero', () => {
            expect(() => divide(10, 0)).toThrow('Division by zero');
        });
    });
});

# utils/calculator.py
def add(a, b):
    return a + b

def divide(a, b):
    if b == 0:
        raise ValueError('Division by zero')
    return a / b

# test_calculator.py
import pytest
from utils.calculator import add, divide

def test_add_positive_numbers():
    assert add(2, 3) == 5

def test_add_negative_numbers():
    assert add(-2, -3) == -5

def test_divide():
    assert divide(10, 2) == 5

def test_divide_by_zero():
    with pytest.raises(ValueError, match='Division by zero'):
        divide(10, 0)

// tests/integration/api.test.js
const request = require('supertest');
const app = require('../../app');
const { setupDatabase, teardownDatabase } = require('../helpers/database');

describe('User API Integration', () => {
    beforeAll(async () => {
        await setupDatabase();
    });
    
    afterAll(async () => {
        await teardownDatabase();
    });
    
    test('POST /api/users creates a user', async () => {
        const response = await request(app)
            .post('/api/users')
            .send({
                name: 'John Doe',
                email: 'john@example.com'
            })
            .expect(201);
        
        expect(response.body).toHaveProperty('id');
        expect(response.body.name).toBe('John Doe');
    });
    
    test('GET /api/users returns all users', async () => {
        const response = await request(app)
            .get('/api/users')
            .expect(200);
        
        expect(Array.isArray(response.body)).toBe(true);
    });
});

# tests/integration/test_user_service.py
import pytest
from app import create_app
from app.database import db
from app.models import User

@pytest.fixture
def app():
    app = create_app('testing')
    with app.app_context():
        db.create_all()
        yield app
        db.drop_all()

@pytest.fixture
def client(app):
    return app.test_client()

def test_create_user(client):
    response = client.post('/api/users', json={
        'name': 'John Doe',
        'email': 'john@example.com'
    })
    assert response.status_code == 201
    assert response.json['name'] == 'John Doe'

def test_get_users(client):
    # Create test user
    user = User(name='John', email='john@example.com')
    db.session.add(user)
    db.session.commit()
    
    response = client.get('/api/users')
    assert response.status_code == 200
    assert len(response.json) > 0

// cypress/e2e/user.cy.js
describe('User Management', () => {
    beforeEach(() => {
        cy.visit('/');
    });
    
    it('should create a new user', () => {
        cy.get('[data-testid=create-user-button]').click();
        cy.get('[data-testid=name-input]').type('John Doe');
        cy.get('[data-testid=email-input]').type('john@example.com');
        cy.get('[data-testid=submit-button]').click();
        
        cy.contains('User created successfully').should('be.visible');
        cy.get('[data-testid=user-list]').should('contain', 'John Doe');
    });
    
    it('should display user list', () => {
        cy.get('[data-testid=user-list]').should('be.visible');
        cy.get('[data-testid=user-item]').should('have.length.greaterThan', 0);
    });
});

// tests/e2e/user.spec.js
const { test, expect } = require('@playwright/test');

test.describe('User Management', () => {
    test('should create a new user', async ({ page }) => {
        await page.goto('/');
        await page.click('[data-testid=create-user-button]');
        await page.fill('[data-testid=name-input]', 'John Doe');
        await page.fill('[data-testid=email-input]', 'john@example.com');
        await page.click('[data-testid=submit-button]');
        
        await expect(page.locator('text=User created successfully')).toBeVisible();
        await expect(page.locator('[data-testid=user-list]')).toContainText('John Doe');
    });
});

// Step 1: Write failing test
// test/calculator.test.js
describe('Calculator', () => {
    test('multiplies two numbers', () => {
        expect(multiply(3, 4)).toBe(12);
    });
});

// Step 2: Write minimal code
// utils/calculator.js
export function multiply(a, b) {
    return a * b;
}

// Step 3: Refactor if needed

// Mock external dependencies
jest.mock('../api/client', () => ({
    fetchUser: jest.fn()
}));

// Stub functions
const mockFunction = jest.fn().mockReturnValue('mocked value');

Popular testing tools and frameworks:

JavaScript/TypeScript:

• Jest: Popular testing framework

• Mocha: Flexible test framework

• Cypress: E2E testing

• Playwright: Modern E2E testing

• Testing Library: Component testing

Python:

• pytest: Popular testing framework

• unittest: Built-in testing framework

• Selenium: Browser automation

• Robot Framework: Acceptance testing

Java:

• JUnit: Unit testing

• TestNG: Advanced testing

• Selenium: Web testing

• Mockito: Mocking framework