Python - Example Code Using Unit test

Python  Example Code Using unittest

What is Unit Testing in Python?

Unit testing is a crucial part of Python programming that ensures individual components of your code work correctly. Python provides a built-in module called unittest that helps developers write and execute test cases efficiently. In this guide, we will cover everything you need to know about Python unit testing, including unittest examples, test case creation, test suites, assertions, and best practices.

Unit testing refers to the practice of testing individual units or components of a program in isolation to verify that each part works as expected. In Python, the unittest module provides tools to create, organize, and run tests, making your code more reliable and maintainable.

Benefits of Unit Testing

• Detects errors early in development
• Improves code quality and maintainability
• Facilitates refactoring without breaking existing code
• Serves as documentation for code functionality
• Supports automation of tests to save time

Python unittest Module Overview

The unittest module is inspired by the Java JUnit framework and provides a robust testing framework for Python. Key components include:

• Test Case: The smallest unit of testing. Created by subclassing unittest.TestCase.
• Assertions: Methods used to check whether test results meet expectations.
• Test Suite: A collection of test cases that can be run together.
• Test Runner: Orchestrates the execution of tests and reports results.

Writing Your First Unit Test in Python

Let's create a simple function and write a unit test for it using unittest.

Example: Testing a Simple Addition Function

# calculator.py

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

# test_calculator.py

import unittest
from calculator import add

class TestCalculator(unittest.TestCase):

    def test_add_positive_numbers(self):
        result = add(5, 10)
        self.assertEqual(result, 15)

    def test_add_negative_numbers(self):
        result = add(-5, -10)
        self.assertEqual(result, -15)

    def test_add_zero(self):
        result = add(0, 0)
        self.assertEqual(result, 0)

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

Testing Exceptions

We can also test whether a function raises an exception correctly using assertRaises.

# calculator.py

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

# test_calculator.py

import unittest
from calculator import divide

class TestCalculator(unittest.TestCase):

    def test_divide_by_zero(self):
        with self.assertRaises(ValueError):
            divide(10, 0)

    def test_divide_normal(self):
        result = divide(10, 2)
        self.assertEqual(result, 5)

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

Organizing Tests with Test Suites

Test suites allow grouping multiple test cases to run together. This is useful in large projects.

import unittest
from test_calculator import TestCalculator

def suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(TestCalculator))
    return suite

if __name__ == '__main__':
    runner = unittest.TextTestRunner()
    runner.run(suite())

Advanced unittest Features

Setup and Teardown Methods

Sometimes you need to set up certain conditions before running a test or clean up afterward. unittest provides setUp() and tearDown() methods:

import unittest

class TestExample(unittest.TestCase):

    def setUp(self):
        print("Setting up test environment")
        self.data = [1, 2, 3]

    def tearDown(self):
        print("Cleaning up test environment")
        self.data = None

    def test_sum(self):
        self.assertEqual(sum(self.data), 6)

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

Setup and Teardown for Class-Level Operations

import unittest

class TestClassExample(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        print("Setup class resources")
        cls.shared_data = [10, 20, 30]

    @classmethod
    def tearDownClass(cls):
        print("Clean up class resources")
        cls.shared_data = None

    def test_average(self):
        self.assertEqual(sum(self.shared_data)/len(self.shared_data), 20)

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

 Python Unit Testing

• Write tests for each function or method separately.
• Use descriptive test method names, e.g., test_add_negative_numbers.
• Keep tests independent from each other.
• Test both normal and edge cases.
• Use setup and teardown methods to avoid code repetition.
• Use test suites to organize large numbers of tests.
• Automate tests using CI/CD pipelines whenever possible.

Testing a Bank Account Class

# bank_account.py

class BankAccount:

    def __init__(self, balance=0):
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        self.balance += amount

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount

# test_bank_account.py

import unittest
from bank_account import BankAccount

class TestBankAccount(unittest.TestCase):

    def setUp(self):
        self.account = BankAccount(100)

    def test_deposit(self):
        self.account.deposit(50)
        self.assertEqual(self.account.balance, 150)

    def test_withdraw(self):
        self.account.withdraw(40)
        self.assertEqual(self.account.balance, 60)

    def test_withdraw_insufficient_funds(self):
        with self.assertRaises(ValueError):
            self.account.withdraw(200)

    def test_deposit_negative(self):
        with self.assertRaises(ValueError):
            self.account.deposit(-50)

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

Python's unittest module provides a powerful and flexible framework for writing and managing unit tests. By using assertions, test cases, test suites, and setup/teardown methods, developers can ensure their code behaves as expected, detect bugs early, and maintain high code quality. Unit testing is essential for professional Python development and helps build reliable and maintainable software.