How to test a class with unittest Python?

To test a class using the unittest module in Python, you can follow these steps:

Import the necessary modules:

import unittestCode language: Python (python)

Create a test class that inherits from unittest.TestCase:

class TestClassName(unittest.TestCase):
    passCode language: Python (python)

Define test methods within the test class. Each test method should start with the word “test” and should contain assertions to verify the behavior of the class being tested:

class TestClassName(unittest.TestCase):
    def test_method_name(self):
        # Create an instance of the class
        instance = ClassName()
        
        # Call the method being tested
        result = instance.method_name()
        
        # Make assertions to validate the result
        self.assertEqual(result, expected_value)Code language: Python (python)

Optionally, you can include additional methods such as setUp() and tearDown() to set up any necessary resources before each test or clean up after each test, respectively.
Finally, you can run the tests using the unittest.main() function, which discovers all the test methods in the test class and executes them:

if __name__ == '__main__':
    unittest.main()Code language: Python (python)

Here’s a complete example to demonstrate the process:

import unittest

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

class TestCalculator(unittest.TestCase):
    def test_add(self):
        calc = Calculator()
        result = calc.add(2, 3)
        self.assertEqual(result, 5)

if __name__ == '__main__':
    unittest.main()
Code language: Python (python)

In this example, the Calculator class has an add method that adds two numbers. The TestCalculator test class contains a single test method test_add that verifies the correctness of the add method. When you run this script, the test will be executed, and if all assertions pass, you’ll see an output indicating that the test was successful.

How do you mock a class object in Python unittest?

To mock a class object in Python unittest, you can use the unittest.mock module, which provides a Mock class that allows you to create mock objects.

Here’s an example of how you can mock a class object using unittest.mock:

import unittest
from unittest.mock import Mock

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

class CalculatorUser:
    def __init__(self, calculator):
        self.calculator = calculator

    def calculate(self, a, b):
        return self.calculator.add(a, b)

class TestCalculatorUser(unittest.TestCase):
    def test_calculate(self):
        # Create a mock object for the Calculator class
        calculator_mock = Mock(spec=Calculator)
        calculator_mock.add.return_value = 5

        # Create an instance of CalculatorUser with the mock object
        calculator_user = CalculatorUser(calculator_mock)

        # Call the method being tested
        result = calculator_user.calculate(2, 3)

        # Make assertions to validate the result
        self.assertEqual(result, 5)
        calculator_mock.add.assert_called_once_with(2, 3)

if __name__ == '__main__':
    unittest.main()
Code language: Python (python)

In this example, the CalculatorUser class depends on the Calculator class to perform calculations. In the TestCalculatorUser test class, we want to test the calculate method of CalculatorUser without relying on the actual Calculator class. Instead, we create a mock object calculator_mock using Mock(spec=Calculator), which ensures that the mock object has the same interface as the Calculator class.

We then set the return value of the add method of the mock object to 5 using calculator_mock.add.return_value = 5. This allows us to control the behavior of the mock object for testing purposes.

Next, we create an instance of CalculatorUser with the mock object as the calculator parameter. When the calculate method is called, it internally calls the add method of the mock object, which returns the mocked value.

Finally, we make assertions to validate the result and also check that the add method of the mock object was called with the expected arguments using assert_called_once_with.

By using the Mock object from unittest.mock, you can create flexible and controllable mock objects to simulate the behavior of real classes during testing.

Read More;

Dmytro Iliushko

I am a middle python software engineer with a bachelor's degree in Software Engineering from Kharkiv National Aerospace University. My expertise lies in Python, Django, Flask, Docker, REST API, Odoo development, relational databases, and web development. I am passionate about creating efficient and scalable software solutions that drive innovation in the industry.
LinkedIn | Github

View all posts

How do you mock a class object in Python unittest?

Leave a Comment Cancel reply