Unit testing and integration testing

Unit Testing vs. Integration Testing: Basic Concepts

Unit testing involves testing the smallest testable units of software, typically functions or methods. Integration testing, on the other hand, combines multiple units and tests their interactions to ensure they work together correctly. Both play distinct yet complementary roles in the software development process.

// Unit test example: Testing a simple addition function
function add(a, b) {
  return a + b;
}

// Integration test example: Testing a shopping cart class that uses the addition function
class ShoppingCart {
  constructor() {
    this.items = [];
  }
  
  addItem(item) {
    this.items.push(item);
  }
  
  calculateTotal() {
    return this.items.reduce((total, item) => add(total, item.price), 0);
  }
}

Characteristics and Implementation of Unit Testing

Unit tests are isolated, with each test case focusing on a specific functionality. They typically run quickly and can be executed frequently during development. Common unit testing frameworks include Jest and Mocha.

Key advantages of unit testing:

• Provides rapid feedback on issues during development
• Makes it easier to pinpoint the exact location of defects
• Serves as code documentation
• Offers a safety net during refactoring

// Example of unit testing with Jest
test('add function should return correct sum', () => {
  expect(add(2, 3)).toBe(5);
  expect(add(-1, 1)).toBe(0);
  expect(add(0, 0)).toBe(0);
});

Characteristics and Implementation of Integration Testing

Integration testing focuses on interactions between modules and their interfaces. It verifies whether multiple units work together as expected. Integration tests are generally more complex and slower to execute than unit tests.

Typical scenarios for integration testing:

• API endpoints interacting with databases
• Frontend components integrated with state management
• Communication between microservices
• Integration with third-party services

// Example of API integration testing with Supertest
const request = require('supertest');
const app = require('../app');

describe('GET /api/products', () => {
  it('should return all products', async () => {
    const response = await request(app)
      .get('/api/products')
      .expect(200);
    
    expect(response.body).toBeInstanceOf(Array);
    expect(response.body.length).toBeGreaterThan(0);
  });
});

Comparison Between Unit Testing and Integration Testing

Testing Pyramid and Best Practices

The testing pyramid recommends a test composition of: numerous unit tests, a moderate number of integration tests, and a few end-to-end tests. This structure ensures quality while optimizing test execution efficiency.

Practical development recommendations:

1. Start by writing unit tests to cover core logic
2. Then write integration tests to verify critical interactions
3. Keep tests independent and avoid execution order dependencies
4. Set up dedicated test databases for integration tests
5. Use mocks judiciously to reduce external dependencies

// Example of a testing pyramid for an Express application
// Unit test layer
test('User model validation', () => {
  // Test user model validation logic
});

// Integration test layer
test('POST /users should create new user', async () => {
  // Test API route and database interaction
});

// E2E test layer
test('User registration flow', () => {
  // Test the complete flow from UI to backend
});

Common Challenges and Solutions

Challenges encountered when implementing tests in real projects:

1. Slow Test Execution: Mark time-consuming tests as "slow" and run them separately
2. Test Data Management: Use factory functions or fixtures to generate test data
3. Test Environment Differences: Use container technology to ensure environment consistency
4. Misconceptions About Test Coverage: Focus on critical paths rather than blindly pursuing 100% coverage
5. Difficult Test Maintenance: Follow the DRY principle and extract common test utility functions

// Example of a test data factory function
const createUser = (overrides = {}) => ({
  name: 'Test User',
  email: 'test@example.com',
  ...overrides
});

test('User update should work', async () => {
  const testUser = createUser({ role: 'admin' });
  // Use factory function to create test data
});

Testing Practices in Modern Frontend Frameworks

Modern frontend frameworks like React, Vue, etc., have specialized testing tools:

• React: Jest + React Testing Library
• Vue: Jest + Vue Test Utils
• Angular: Jasmine/Karma + Angular Testing Utilities

// React component testing example
import { render, screen } from '@testing-library/react';
import Button from './Button';

test('Button renders with correct text', () => {
  render(<Button>Click me</Button>);
  expect(screen.getByText('Click me')).toBeInTheDocument();
});

// Vue component integration testing example
import { mount } from '@vue/test-utils';
import Cart from '@/components/Cart';

test('Cart displays items correctly', () => {
  const wrapper = mount(Cart, {
    propsData: {
      items: [{ id: 1, name: 'Product', price: 100 }]
    }
  });
  expect(wrapper.text()).toContain('Product');
});

Test-Driven Development (TDD) and Behavior-Driven Development (BDD)

TDD and BDD are two common testing methodologies:

TDD workflow:

1. Write a failing test
2. Implement the minimal code to pass
3. Refactor the code

BDD characteristics:

• Uses natural language to describe tests
• Focuses on system behavior rather than implementation
• Facilitates team communication

// TDD example: Developing a stack data structure
describe('Stack', () => {
  it('should be empty when created', () => {
    const stack = new Stack();
    expect(stack.isEmpty()).toBe(true);
  });
  
  // Write the test first, then implement the Stack class
});

// BDD example using Cucumber syntax
Feature: User login
  Scenario: Successful login with valid credentials
    Given I am on the login page
    When I enter valid credentials
    Then I should be redirected to the dashboard

Testing Strategies in Continuous Integration

Properly configure tests in CI/CD pipelines:

1. Rapid feedback stage: Run unit tests
2. Build stage: Run integration tests
3. Pre-deployment stage: Run end-to-end tests
4. Production environment: Monitoring and smoke tests

# GitHub Actions configuration example
name: CI Pipeline

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - run: npm install
      - run: npm test       # Run unit tests
      - run: npm run test:integration  # Run integration tests

Ensuring Quality of Test Code

Test code itself must maintain high quality:

1. Follow the ARRANGE-ACT-ASSERT pattern
2. One assertion per test (with exceptions for special cases)
3. Use descriptive test names
4. Avoid testing internal implementation details
5. Regularly clean up outdated tests

// Example of well-structured test code
test('calculateDiscount should apply 10% discount for premium users', () => {
  // Arrange
  const user = { type: 'premium' };
  const amount = 100;
  
  // Act
  const result = calculateDiscount(user, amount);
  
  // Assert
  expect(result).toBe(90);
});