1. Introduction to Software Testing

🏗️ The Testing Pyramid

The testing pyramid is a visual metaphor for the ideal test distribution in a project. At the base are unit tests — they're fast, cheap, and numerous. In the middle are integration tests — they test how components work together. At the top are end-to-end tests — they test the entire system but are slow and expensive. The pyramid suggests that most of your tests should be unit tests, fewer should be integration tests, and even fewer should be end-to-end tests. This distribution gives you the best balance of speed, cost, and coverage.

Many teams make the mistake of having an ice cream cone (few unit tests, many E2E tests). This is expensive and slow. The pyramid is the proven pattern for efficient testing. Understanding the pyramid helps you decide what to test and how.

📝 Testing Principles

Several key principles guide effective testing. The FIRST principles: Fast (tests should run quickly), Independent (tests should not depend on each other), Repeatable (tests should produce the same results every time), Self-validating (tests should pass or fail automatically), and Timely (tests should be written alongside code). These principles ensure your test suite remains useful and maintainable.

Test-Driven Development (TDD) is a practice where you write tests before code. The red-green-refactor cycle: write a failing test (red), write the minimal code to pass (green), then refactor while keeping tests green. TDD forces you to think about design before implementation, resulting in cleaner, more testable code. While TDD takes practice, it's a powerful tool for building reliable software.

• Fast: Tests should run quickly to provide immediate feedback.
• Independent: Tests should not depend on each other's state.
• Repeatable: Tests should produce the same results every time.
• Self-validating: Tests should pass or fail automatically.
• Timely: Tests should be written alongside code, not after.

📝 Try It Yourself: Your First Test

Before diving into the details, let's write your first test. This will give you a feel for the testing workflow.

Step 1: Set up a project
mkdir my-test-project
cd my-test-project
npm init -y
npm install --save-dev jest

Step 2: Create a function
Create math.js:
function add(a, b) { return a + b; }
module.exports = { add };

Step 3: Create a test
Create math.test.js:
const { add } = require('./math');

test('adds 1 + 2 to equal 3', () => {
expect(add(1, 2)).toBe(3);
});

test('adds negative numbers correctly', () => {
expect(add(-1, -2)).toBe(-3);
});

Step 4: Run the test
npx jest
You'll see the tests pass. This is the basic testing workflow you'll use throughout this course.

Step 5: Make a change
Break the add function by changing it to return a - b;. Run the tests again. You'll see a failure. This is how tests catch bugs.

Try It Yourself: Write a test for a multiply function. Write tests for edge cases like multiplying by zero or negative numbers.