Unit Testing and Test-Driven Development Python

What You’ll Learn 📚

• Understand the basics of unit testing and TDD
• Learn key terminology and concepts
• Work through progressively complex examples
• Troubleshoot common issues
• Answer common questions with clear explanations

Introduction to Unit Testing and TDD

Unit testing is like giving your code a regular health check-up. It’s a way to ensure each part of your code works as expected. Test-Driven Development (TDD) is a software development approach where you write tests before writing the actual code. Sounds interesting, right? 🤔

Think of unit testing as a safety net that catches bugs before they cause trouble!

Key Terminology

• Unit Test: A test that checks a small, isolated piece of code (a ‘unit’).
• TDD: A development process where tests are written before the code.
• Test Case: A set of conditions under which a tester will determine if a feature works as expected.
• Assertion: A statement that checks if a condition is true.

Getting Started with a Simple Example

Let’s start with the simplest example: testing a function that adds two numbers.

def add(a, b):
    return a + b

# Unit test for the add function
def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

# Running the test
test_add()
print('All tests passed! 🎉')

Progressively Complex Examples

Example 1: Testing a Function with Edge Cases

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

# Unit test for the divide function
def test_divide():
    assert divide(10, 2) == 5
    assert divide(9, 3) == 3
    try:
        divide(1, 0)
    except ValueError as e:
        assert str(e) == 'Cannot divide by zero!'

# Running the test
test_divide()
print('All tests passed! 🎉')

Example 2: Using Python’s unittest Module

Let’s take it up a notch by using Python’s built-in unittest module.

import unittest

class TestMathFunctions(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)
        self.assertEqual(add(-1, 1), 0)
        self.assertEqual(add(0, 0), 0)

    def test_divide(self):
        self.assertEqual(divide(10, 2), 5)
        self.assertEqual(divide(9, 3), 3)
        with self.assertRaises(ValueError):
            divide(1, 0)

if __name__ == '__main__':
    unittest.main()

Example 3: Test-Driven Development in Action

Now, let’s see TDD in action by developing a simple calculator class.

class Calculator:
    def add(self, a, b):
        return a + b

    def subtract(self, a, b):
        return a - b

# TDD: Write tests before implementing the multiply method
class TestCalculator(unittest.TestCase):
    def setUp(self):
        self.calc = Calculator()

    def test_add(self):
        self.assertEqual(self.calc.add(2, 3), 5)

    def test_subtract(self):
        self.assertEqual(self.calc.subtract(5, 3), 2)

    def test_multiply(self):
        # Test fails because multiply is not implemented yet
        self.assertEqual(self.calc.multiply(2, 3), 6)

if __name__ == '__main__':
    unittest.main()

Common Questions and Answers

1. Why use unit tests?

   Unit tests help catch bugs early, make code refactoring safer, and improve code quality.

2. What is the difference between unit testing and integration testing?

   Unit testing focuses on individual components, while integration testing checks how different components work together.

3. How do I run my tests?

   You can run tests using the unittest module by executing your test script, or use a test runner like pytest.

4. What if my test fails?

   Don’t panic! A failing test is an opportunity to improve your code. Check your logic and fix any issues.

5. Can I skip tests?

   It’s possible, but not recommended. Skipping tests can lead to undetected bugs.

Troubleshooting Common Issues

• Test not running: Ensure your test function names start with test_ and your test class inherits from unittest.TestCase.
• Import errors: Check your import statements and ensure all dependencies are installed.
• Assertion errors: Double-check your expected and actual values in assertions.

Remember, practice makes perfect! Keep experimenting with different test cases and scenarios.

Practice Exercises

• Create a multiply method for the Calculator class and write tests for it.
• Write a unit test for a function that checks if a number is prime.
• Try using pytest as an alternative to unittest and compare the experience.

Keep coding and testing, and you’ll become a TDD pro in no time! 🚀