Test-Driven Development (TDD) Crash Course

TDD is a software development approach where you write tests first before writing the code to implement functionality. It ensures reliability, maintainability, and clean design.

TDD Workflow

Write a Test

• Define what the function/class should do (expected behavior).
• Write a failing test for the functionality you want to implement.

Write Minimal Code

• Implement just enough code to pass the test.

Refactor

• Clean up the code, ensuring readability and performance without changing behavior.

Repeat

• Continue adding tests for new functionality

Key Principles of TDD

• Red, Green, Refactor:
• Red: Write a test that fails.
• Green: Write code to make the test pass.
• Refactor: Improve the implementation without breaking the test.
• Tests should be small, isolated, and fast.
• Focus on the public API of the code (what it does, not how it does it.

Advantages of TDD

• Fewer bugs and better code quality.
• Confidence to refactor or extend functionality.
• Clear documentation through tests.

Crash Course Outline

1. Understanding Testing

• Unit Tests: Test individual components/functions.
• Integration Tests: Test combined parts of an application.
• End-to-End Tests: Test the application as a whole.

2. Setting Up the Environment

• Choose a testing framework:
• JavaScript: Jest, Mocha
• Python: pytest, unittest
• Java: JUnit, TestNG
• Install tools and configure them for your project.

3. Writing Your First Test

• Example in JavaScript with Jest:

// math.js
function add(a, b) {
    return a + b;
}
module.exports = add;

// math.test.js
const add = require('./math');

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

Run the test:

npm test        

4. Practicing TDD

• Example: Building a calculator

1. Write the Test (Red):

const calculator = require('./calculator');

test('should add two numbers', () => {
    expect(calculator.add(1, 2)).toBe(3);
});        

2. Write Minimal Code (Green):

const calculator = {
    add: (a, b) => a + b
};

module.exports = calculator;        

3. Refactor:

5. Testing Edge Cases

• Handle invalid inputs:

test('should return 0 if arguments are not numbers', () => {
    expect(calculator.add('a', 2)).toBe(0);
});        

6. Real-World Example: TDD for a To-Do List

• Requirements: Add, remove, and mark tasks as completed.

1. Write the Tests:

const todo = require('./todo');

test('should add a task', () => {
    expect(todo.addTask('Learn TDD')).toEqual(['Learn TDD']);
});

test('should mark task as complete', () => {
    todo.addTask('Learn TDD');
    expect(todo.completeTask(0)).toBe(true);
});

test('should delete a task', () => {
    todo.addTask('Learn TDD');
    expect(todo.deleteTask(0)).toEqual([]);
});        

2. Implement the Functions:

const tasks = [];

const todo = {
    addTask: (task) => {
        tasks.push({ task, completed: false });
        return tasks.map(t => t.task);
    },
    completeTask: (index) => {
        tasks[index].completed = true;
        return tasks[index].completed;
    },
    deleteTask: (index) => {
        tasks.splice(index, 1);
        return tasks.map(t => t.task);
    }
};

module.exports = todo;        

7. Refactor and Expand

• Add error handling.
• Create integration tests to test the app flow.
• Best Practices

• Keep your tests simple and meaningful.
• Write one test case per functionality.
• Use mocking for external dependencies.
• Run tests frequently and ensure they are all passing.

By following this TDD crash course, you'll have a structured approach to build high-quality, reliable, and maintainable software!

Subscribe to this Saturday with code.