The Project | About Us | Contribute | Donations | License

HOME

Unit testing is a crucial part of software development that ensures individual units of code (usually functions or methods) work as expected. Python's built-in unittest module provides a framework for creating and running unit tests.

Key Concepts

Test Case: The smallest unit of testing. It checks for a specific response to a particular set of inputs.
Test Suite: A collection of test cases, test suites, or both.
Test Runner: A component that orchestrates the execution of tests and provides the outcome to the user.

Setting Up unittest

To use unittest, you need to import it and create a class that inherits from unittest.TestCase. Each test method in the class should start with the word test.

import unittest

class TestExample(unittest.TestCase):
    
    def test_addition(self):
        self.assertEqual(1 + 1, 2)

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

Explanation

Importing unittest: The unittest module is imported.
Creating a Test Class: TestExample inherits from unittest.TestCase.
Defining a Test Method: test_addition checks if 1 + 1 equals 2 using self.assertEqual.
Running the Tests: unittest.main() is called to run the tests.

Common Assertions

unittest provides several assertion methods to check for various conditions:

Assertion Method	Description
`assertEqual(a, b)`	Check if `a` equals `b`.
`assertNotEqual(a, b)`	Check if `a` does not equal `b`.
`assertTrue(x)`	Check if `x` is `True`.
`assertFalse(x)`	Check if `x` is `False`.
`assertIs(a, b)`	Check if `a` is `b` (same object).
`assertIsNot(a, b)`	Check if `a` is not `b` (different objects).
`assertIsNone(x)`	Check if `x` is `None`.
`assertIsNotNone(x)`	Check if `x` is not `None`.
`assertIn(a, b)`	Check if `a` is in `b`.
`assertNotIn(a, b)`	Check if `a` is not in `b`.
`assertIsInstance(a, b)`	Check if `a` is an instance of `b`.
`assertNotIsInstance(a, b)`	Check if `a` is not an instance of `b`.

Practical Example

Let's create a simple calculator class and write unit tests for its methods.

Calculator Class

class Calculator:
    
    def add(self, a, b):
        return a + b
    
    def subtract(self, a, b):
        return a - b
    
    def multiply(self, a, b):
        return a * b
    
    def divide(self, a, b):
        if b == 0:
            raise ValueError("Cannot divide by zero")
        return a / b

Unit Tests for Calculator

import unittest

class TestCalculator(unittest.TestCase):
    
    def setUp(self):
        self.calc = Calculator()
    
    def test_add(self):
        self.assertEqual(self.calc.add(1, 2), 3)
        self.assertEqual(self.calc.add(-1, 1), 0)
    
    def test_subtract(self):
        self.assertEqual(self.calc.subtract(10, 5), 5)
        self.assertEqual(self.calc.subtract(-1, -1), 0)
    
    def test_multiply(self):
        self.assertEqual(self.calc.multiply(3, 7), 21)
        self.assertEqual(self.calc.multiply(-1, 1), -1)
    
    def test_divide(self):
        self.assertEqual(self.calc.divide(10, 2), 5)
        self.assertRaises(ValueError, self.calc.divide, 10, 0)

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

Explanation

setUp Method: setUp is a special method that runs before each test. It initializes the Calculator object.
Test Methods: Each method tests a specific functionality of the Calculator class.
Assertions: Various assertions check if the methods return the expected results.

Practical Exercises

Exercise 1: Extend the Calculator

Add a modulus method to the Calculator class and write unit tests for it.

Solution

class Calculator:
    
    # Existing methods...

    def modulus(self, a, b):
        return a % b

class TestCalculator(unittest.TestCase):
    
    # Existing tests...

    def test_modulus(self):
        self.assertEqual(self.calc.modulus(10, 3), 1)
        self.assertEqual(self.calc.modulus(10, 5), 0)

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

Exercise 2: Test Edge Cases

Write unit tests for edge cases in the divide method, such as dividing by negative numbers.

Solution

class TestCalculator(unittest.TestCase):
    
    # Existing tests...

    def test_divide_edge_cases(self):
        self.assertEqual(self.calc.divide(10, -2), -5)
        self.assertEqual(self.calc.divide(-10, -2), 5)

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

Common Mistakes and Tips

Not Using setUp: Always use setUp to initialize objects that are used in multiple tests.
Ignoring Edge Cases: Test for edge cases like zero division, negative numbers, and large inputs.
Not Running Tests Frequently: Run your tests frequently to catch issues early.

Conclusion

Unit testing with unittest is a powerful way to ensure your code works as expected. By writing comprehensive tests, you can catch bugs early and maintain a high level of code quality. In the next section, we will explore Test-Driven Development (TDD) and how it integrates with unittest.

Unit Testing with unittest

Key Concepts

Setting Up unittest

Explanation

Common Assertions

Practical Example

Calculator Class

Unit Tests for Calculator

Explanation

Practical Exercises

Exercise 1: Extend the Calculator

Solution

Exercise 2: Test Edge Cases

Solution

Common Mistakes and Tips

Conclusion

Python Programming Course

Module 1: Introduction to Python

Module 2: Control Structures

Module 3: Functions and Modules

Module 4: Data Structures

Module 5: Object-Oriented Programming

Module 6: File Handling

Module 7: Error Handling and Exceptions

Module 8: Advanced Topics

Module 9: Testing and Debugging

Module 10: Web Development with Python

Module 11: Data Science with Python

Module 12: Final Project