Python Testing With Unittest Tutorial – Complete Guide

Welcome all coding enthusiasts young and old to another comprehensive tutorial. This time we’re diving into the world of Python testing using unittest. Whether you’ve just begun your coding journey or already have years of experience under your belt, this tutorial serves to enrich your understanding of Python testing.

What is unittest?

Python’s unittest module, sometimes known as PyUnit, is a built-in library for testing your Python code. In essence, it’s a free way to perform a self-check on your code, verify its correctness, and ensure that the functionality holds true under a diverse range of scenarios.

Now, testing could sound like an additional, unnecessary step in your coding process. However, let’s imagine your code as a game stage you’ve built for players to undergo. Wouldn’t you prefer to identify any potential glitches or pitfalls beforehand, rather than receive complaints from disgruntled players who encountered them during their playtime?

That’s precisely what unittest helps you achieve – error-free, reliable code that’s game-ready! It provides you with a robust testing framework, where you can simulate different inputs and conditions to ensure the successful operation of your code’s logic under all circumstances.

Importance of Python Testing

Python testing, much like all code testing, forms the basis of clean, well-organized and efficient code. It helps to ensure:

  • Smoother execution without halts or crashes.
  • Reduced bug counts and the easy identification of errors.
  • Confidence in the code’s functionality and performance, akin to having a well-tested game level.
  • Error prevention in new code by catching repercussions caused due to modifications or improvements.

In the following sections, we’ll provide ground-up guidance on utilizing unittest for Python testing, making this handy tool an integral part of your coding strategy. Stay with us as we deep dive into the nuts and bolts of unittest!

CTA Small Image

Getting Started with unittest

First things first, implementation of unittest in your Python code is as easy as adding an import statement at the beginning of your program.

The syntax to import the unittest module is as follows:

import unittest

Let’s get a feel for how unittest works in Python with a basic example of an addition function, and how we can test its operation with unittest.

# Simple function to add two numbers
def add_numbers(num1, num2):
    return num1 + num2

Now, suppose you want to test this function to ensure it works as expected. This is where unittest comes into play.

import unittest

class TestAddition(unittest.TestCase):

    def test_addition(self):
        self.assertEqual(add_numbers(2, 3), 5)

if __name__ == '__main__':

In the above piece of code, we defined a test case for our function through unittest. We accomplished this by creating a new class that inherits from the unittest.TestCase class and then defining a method inside it to test the function.

Assert Functions in unittest

The assertEqual() function, used in the above code, is one of the assert functions provided by unittest for comparison of actual and expected results. Python’s unittest library offers several others.

Let’s demonstrate a few:

class TestAssertFunctions(unittest.TestCase):

    def test_assertTrue(self):
        self.assertTrue(is_prime(7))  # Test if the function returns True

    def test_assertFalse(self):
        self.assertFalse(is_even(5))  # Test if the function returns False

    def test_assertEqual(self):
        self.assertEqual(add(2, 2), 4)  # Test if the function returns the right output

    def test_assertNotEqual(self):
        self.assertNotEqual(multiply(3, 3), 8)  # Test if the two values are not equal

if __name__ == '__main__':

In the above unittest methods, you’ll observe various assert functions such as assertTrue(), assertFalse(), assertEqual() and assertNotEqual(). These functions aid in verifying if your function’s output is as expected, making them crucial for successful unit testing.

Setup and Teardown in unittest

unittest also provides setup and teardown functionality. The setup() method runs before each test case, where you can declare objects or variables used in your test cases. The teardown() method is designed to clean up any unnecessary remnants after a test has been executed.

class TestSetupTeardown(unittest.TestCase):

    def setUp(self):
        self.list = [1, 2, 3]

    def test_list_length(self):
        self.assertEqual(len(self.list), 3)

    def tearDown(self):
        self.list = None

if __name__ == '__main__':

The setUp() method initializes the ‘self.list’ variable, which can be accessed across all test methods within the test class. After each test method is executed, the tearDown() function resets ‘self.list’ to None.

Grouping Test Cases with Test Suites

Test Suites are used to aggregate tests that should be executed together. For instance, if we have multiple test cases spread across several classes, and we want to execute the ones that test a specific system module.

import unittest

# Define the test cases
class TestMathOperations(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(add_numbers(3, 5), 8)

    def test_subtraction(self):
        self.assertEqual(subtract_numbers(10, 5), 5)

class TestStringOperations(unittest.TestCase):
    def test_string_upper(self):
        self.assertEqual('hello'.upper(), 'HELLO')

    def test_string_lower(self):
        self.assertEqual('WORLD'.lower(), 'world')

# Constitute the test suite
def suite():
    suite = unittest.TestSuite()
    return suite

# Run the test suite

Here, we grouped our test cases into a suite and executed it all at once. This grouping of test cases streamlines testing, facilitating the simultaneous checking of multiple areas of your code.

Error Handling in unittest

unittest also enables us to handle scenarios where we expect our function to raise an exception. The assertRaises() function is used to verify that a particular function or method call raises a specific exception.

class TestException(unittest.TestCase):

    def test_raise_exception(self):
        with self.assertRaises(ZeroDivisionError):
            divide_numbers(5, 0)

if __name__ == '__main__':

In this example, there is an expectation that the function divide_numbers() will raise a ZeroDivisionError because dividing by zero is not mathematically possible. This is verified with unittest by encapsulating the function in a with block and asserting that it raises the anticipated exception.

Skipping Tests

There are situations where you might want to skip certain test cases for a period of time – maybe you are still developing the associated functionality, or the tests are failing due to an unknown bug. unittest provides decorators like @unittest.skip() and @unittest.skipIf() to handle such situations.

class TestSkipping(unittest.TestCase):

    @unittest.skip("Skipping for now")
    def test_addition(self):
        self.assertEqual(add_numbers(3, 2), 5)

    @unittest.skipIf(3 > 2, "Skipping due to the condition")
    def test_subtraction(self):
        self.assertEqual(subtract_numbers(4, 2), 2)

if __name__ == '__main__':

In the above code, test_addition() is completely skipped, while test_subtraction() is skipped based on the condition that 3 is greater than 2.

Where to Go Next with Python and unittest

Empowering your Python journey with testing capabilities using unittest is just the start. The journey of Python development is endless, exciting, and filled with opportunities to create robust, efficient and purposeful code.

To further your Python programming skills, our Python Mini-Degree provides a comprehensive, project-based curriculum. The Python Mini-Degree covers coding basics, algorithms, object-oriented programming, game development, app development and more!

With a blend of enriching theoretical understanding and practical, hands-on experience, our Python courses cater to both beginners and seasoned coders. Learn at your own pace, anytime, and revisit lessons as needed. The mini-degree proves flexible and is regularly updated to keep you in step with industry developments.

Our courses culminate with real-life projects like creating games, medical diagnosis bots, and even real-world applications! And, as a bonus, you get certification upon completion, validating the skills and knowledge that you’ve gained.

Our courses are designed to help you not only elevate your coding abilities but also offer you the potential to land that dream job, elevate your career, or start your own business.


With this deep exploration of Python’s unittest, we’ve armed you with the tools and insights you need to ensure you’re always delivering clean, error-free, and efficient code. The knowledge you’ve gained here is a crucial step towards mastering Python and becoming a reliable developer who can confidently address any coding challenge.

Remember, success in coding is just as much about preventing errors as it is about crafting impressive, creative solutions. Keep practicing, continue challenging your limits, and always make full use of the powers of unittest for executing reliable Python code.

We at Zenva are excited about your coding journey and are always here to guide you in upgrading your skills and knowledge. Whether you’re starting out or aiming to master advanced topics, Zenva’s selection of courses has got you covered!

Python’s horizon is broad and limitless. Dive in, code with confidence, and remember – it’s not just about the destination, but also the insightful journey. Happy coding!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.