Software Testing Guide 2026

// sum.js
export function sum(a, b) {
  return a + b
}

// sum.test.js
import { describe, it, expect } from 'vitest'
import { sum } from './sum'

describe('sum function', () => {
  it('should add two numbers correctly', () => {
    expect(sum(2, 3)).toBe(5)
  })

  it('should handle negative numbers', () => {
    expect(sum(-1, 1)).toBe(0)
  })

  it('should handle zero', () => {
    expect(sum(0, 5)).toBe(5)
  })
})

// Run tests
npm test

import { vi } from 'vitest'

// Mock function
const mockFn = vi.fn()
mockFn('hello')
expect(mockFn).toHaveBeenCalledWith('hello')

// Mock module
vi.mock('./api', () => ({
  fetchUser: vi.fn(() => Promise.resolve({ id: 1, name: 'John' }))
}))

// Mock fetch
global.fetch = vi.fn(() =>
  Promise.resolve({
    json: () => Promise.resolve({ data: 'test' })
  })
)

// API Integration Test
import request from 'supertest'
import app from './app'

describe('POST /api/users', () => {
  it('should create a new 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')
  })

  it('should return 400 for invalid email', async () => {
    await request(app)
      .post('/api/users')
      .send({
        name: 'John',
        email: 'invalid-email'
      })
      .expect(400)
  })
})

// tests/login.spec.js
import { test, expect } from '@playwright/test'

test('user can login successfully', async ({ page }) => {
  // Navigate to login page
  await page.goto('http://localhost:3000/login')

  // Fill in form
  await page.fill('input[name="email"]', 'user@example.com')
  await page.fill('input[name="password"]', 'password123')

  // Click login button
  await page.click('button[type="submit"]')

  // Wait for navigation
  await page.waitForURL('**/dashboard')

  // Verify user is logged in
  await expect(page.locator('h1')).toContainText('Dashboard')
  await expect(page.locator('.user-name')).toContainText('John Doe')
})

test('shows error for invalid credentials', async ({ page }) => {
  await page.goto('http://localhost:3000/login')

  await page.fill('input[name="email"]', 'wrong@example.com')
  await page.fill('input[name="password"]', 'wrongpass')
  await page.click('button[type="submit"]')

  await expect(page.locator('.error-message')).toContainText('Invalid credentials')
})

// Run tests
npx playwright test

import { render, screen, fireEvent } from '@testing-library/react'
import { describe, it, expect, vi } from 'vitest'
import Button from './Button'

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

  it('calls onClick when clicked', () => {
    const handleClick = vi.fn()
    render(<Button onClick={handleClick}>Click</Button>)
    
    fireEvent.click(screen.getByText('Click'))
    expect(handleClick).toHaveBeenCalledTimes(1)
  })

  it('is disabled when disabled prop is true', () => {
    render(<Button disabled>Click</Button>)
    expect(screen.getByRole('button')).toBeDisabled()
  })
})

// 1. Red - Write failing test
test('should validate email format', () => {
  expect(isValidEmail('test@example.com')).toBe(true)
  expect(isValidEmail('invalid')).toBe(false)
})

// 2. Green - Implement function
function isValidEmail(email) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)
}

// 3. Refactor - Improve if needed
function isValidEmail(email) {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
  return emailRegex.test(email)
}

// package.json
{
  "scripts": {
    "test": "vitest",
    "test:coverage": "vitest --coverage"
  }
}

// Run with coverage
npm run test:coverage

// Coverage Report
File      | % Stmts | % Branch | % Funcs | % Lines
----------|---------|----------|---------|--------
All files |   85.5  |   78.2   |   90.1  |   84.8
utils.js  |   92.3  |   85.7   |   100   |   91.2
api.js    |   78.9  |   70.5   |   80.0  |   78.3

// Aim for:
• 80%+ overall coverage
• 100% for critical paths
• Don't chase 100% blindly