{"id":1139,"date":"2023-06-29T16:11:00","date_gmt":"2023-06-29T10:41:00","guid":{"rendered":"https:\/\/geekpython.in\/?p=1139"},"modified":"2024-03-01T17:12:15","modified_gmt":"2024-03-01T11:42:15","slug":"unit-tests-in-python","status":"publish","type":"post","link":"https:\/\/geekpython.in\/unit-tests-in-python","title":{"rendered":"Understanding Unit Testing in Python with the unittest Module"},"content":{"rendered":"\n

Unit testing is a crucial part of software development, ensuring that functions and tasks within code work as intended. By dividing code into small units and testing them independently, developers can catch errors early and simplify the debugging process.<\/p>\n\n\n\n

This article explores how to implement unit testing in Python using the unittest<\/code> module.<\/p>\n\n\n\n

<\/a>Getting Started With unittest<\/h2>\n\n\n\n

The unittest<\/code> module includes a number of methods and classes for creating and running test cases. Let’s look at a simple example where we used the unittest<\/code> module to create a test case.<\/p>\n\n\n\n

# basic.py\nimport unittest\n\nclass TestSample(unittest.TestCase):\n    def test_equal(self):\n        self.assertEqual(round(3.155), 3.0)\n\n    def test_search(self):\n        self.assertIn(\"G\", \"Geek\")<\/pre><\/div>\n\n\n\n
First, we imported the unittest<\/code> module, which will enable us to use the classes that will be used to write and execute test cases.<\/p>\n\n\n\n
The TestSample<\/code> class is defined that inherits from the unittest.TestCase<\/code> which will allow us to use the various assertion methods<\/strong> within our test cases.<\/p>\n\n\n\n
We defined two test methods within our TestSample<\/code> class: test_equal<\/code> and test_search<\/code>.<\/p>\n\n\n\n
The test method test_equal()<\/code> tests if round(3.155)<\/code> is equal to 3.0<\/code> using the assertEqual()<\/code> assertion method.<\/p>\n\n\n\n
The test method test_search()<\/code> tests if the character \"G\"<\/code> is present in the string \"Geek\"<\/code> using the assertIn()<\/code> assertion method.<\/p>\n\n\n\n
To run these tests, we need to execute the following command in the terminal.<\/p>\n\n\n\n
python -m unittest basic.py<\/pre><\/div>\n\n\n\n
This command will launch unittest<\/code> as a module that searches for and executes the tests in the basic.py<\/code> file.<\/p>\n\n\n\n
Note: The unittest<\/code> module only discovers and executes those methods that start with test_<\/code> or test<\/code>.<\/p>\n\n\n\n
\"unittest<\/figure>\n\n\n\n
By the way, these dots represent a successful test.<\/p>\n\n\n\n
We can use the unittest.main()<\/code> function and put it in the following form at the end of the test script to load and run the tests from the module.<\/p>\n\n\n\n
if __name__ == '__main__':\n    unittest.main()<\/pre><\/div>\n\n\n\n
This will allow us to run our test file, basic.py<\/code> in this case, as the main module.<\/p>\n\n\n\n
\"Output\"<\/figure>\n\n\n\n
More Detailed Result<\/strong><\/p>\n\n\n\n
We can use the -v<\/code> flag in the terminal or pass an argument verbosity=2<\/code> inside the unittest.main()<\/code> function to get a detailed output of the test.<\/p>\n\n\n\n
\"Vervosity<\/figure>\n\n\n\n
<\/a>Commonly Used Assertion Methods<\/h3>\n\n\n\n
Here is the list of the most commonly used assertion methods in unit testing.<\/p>\n\n\n\n
Method<\/td>Checks that<\/td><\/tr><\/thead>
assertEqual(a, b)<\/code><\/td>a == b<\/code><\/td><\/tr>
assertNotEqual(a, b)<\/code><\/td>a != b<\/code><\/td><\/tr>
assertTrue(x)<\/code><\/td>bool(x) is True<\/code><\/td><\/tr>
assertFalse(x)<\/code><\/td>bool(x) is False<\/code><\/td><\/tr>
assertIs(a, b)<\/code><\/td>a is b<\/code><\/td><\/tr>
assertIsNot(a, b)<\/code><\/td>a is not b<\/code><\/td><\/tr>
assertIsNone(x)<\/code><\/td>x is None<\/code><\/td><\/tr>
assertIsNotNone(x)<\/code><\/td>x is not None<\/code><\/td><\/tr>
assertIn(a, b)<\/code><\/td>a in b<\/code><\/td><\/tr>
assertNotIn(a, b)<\/code><\/td>a not in b<\/code><\/td><\/tr>
assertIsInstance(a, b)<\/code><\/td>isinstance(a, b)<\/code><\/td><\/tr>
assertNotIsInstance(a, b)<\/code><\/td>not isinstance(a, b)<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
<\/a>Example<\/h2>\n\n\n\n
Assume we have some code and want to perform unit testing on it using the unittest<\/code> module.<\/p>\n\n\n\n
# triangle.py\nclass Triangle:\n    def __init__(self, base, height):\n        self.base = base\n        self.height = height\n\n    def area(self):\n        return 0.5 * self.base * self.height\n\n    def perimeter(self, side):\n        return self.base + self.height + side<\/pre><\/div>\n\n\n\n
The code defines a class called Triangle<\/code> which has an init method that initializes the object with the instance variables self.base<\/code> and self.height<\/code>.<\/p>\n\n\n\n
There are two more methods in the Triangle<\/code> class: area()<\/code> and perimeter()<\/code>.<\/p>\n\n\n\n
The area()<\/code> method returns the area of the triangle, which is half the product of the base and height (0.5 * self.base * self.height<\/code>).<\/p>\n\n\n\n
The method parameter()<\/code> accepts a parameter called side<\/code>, and because the triangle’s parameter is the sum of its three sides, the base<\/code> and height<\/code> variables take the place of the other two sides.<\/p>\n\n\n\n
Now we can create another Python file in which we’ll write some tests and then execute them.<\/p>\n\n\n\n
# test_sample.py\nfrom triangle import Triangle\nimport unittest\n\nclass TestTriangle(unittest.TestCase):\n    t = Triangle(9, 8)\n\n    def test_area(self):\n        self.assertEqual(self.t.area(), 36)\n\n    def test_perimeter(self):\n        self.assertEqual(self.t.perimeter(5), 22)\n\n    def test_valid_base(self):\n        self.assertGreater(self.t.base, 0)\n\n    def test_valid_height(self):\n        self.assertGreater(self.t.height, 0)\n\nif __name__ == '__main__':\n    unittest.main(verbosity=2)<\/pre><\/div>\n\n\n\n
The above code imports the Triangle<\/code> class from the triangle<\/code> module (triangle.py<\/code> file) as well as imports the unittest<\/code> module to write test cases.<\/p>\n\n\n\n
The TestTriangle<\/code> class inherits from the unittest.TestCase<\/code> which has four test methods. The Triangle<\/code> class was instantiated with a base<\/code> of 9<\/code> and height<\/code> of 8<\/code> and stored inside the variable t<\/code>.<\/p>\n\n\n\n
The test_area<\/code> method tests whether self.t.area()<\/code> is equal to the expected result 36<\/code> using the assertEqual()<\/code> assertion.<\/p>\n\n\n\n
The test_perimeter<\/code> method tests whether self.t.perimeter(5)<\/code> is equal to 22<\/code> using the assertEqual()<\/code> assertion.<\/p>\n\n\n\n
The test_valid_base<\/code> and test_valid_height<\/code> methods are defined to test if the base (self.t.base<\/code>) and height (self.t.height<\/code>) of the triangle are greater than 0<\/code> using the assertGreater()<\/code> assertion.<\/p>\n\n\n\n
The unittest.main(verbosity=2)<\/code> method retrieves and executes the tests from the TestTriangle<\/code> class. We’ll get a detailed output because we used the verbosity=2<\/code> argument.<\/p>\n\n\n\n
\"TestTriangle<\/figure>\n\n\n\n
<\/a>Test for Exception<\/h2>\n\n\n\n
If you’ve used assert statements<\/a> before, you’ll know that when one fails, it throws an AssertionError<\/code>. Similarly, whenever a test method fails, an AssertionError<\/code> is raised.<\/p>\n\n\n\n
We can predetermine the conditions under which our code will generate an error, and then test those conditions to see if they generate errors. This is possible with the assertRaises()<\/code> method.<\/p>\n\n\n\n
The assertRaises()<\/code> method can be used with context manager<\/a> so we’ll use it in the following form:<\/p>\n\n\n\n
def test_method(self):\n    with assertRaises(exception_name):\n        function_name(argument)<\/pre><\/div>\n\n\n\n
Consider the following function gen_odd()<\/code>, which generates a series of odd numbers up to the argument n<\/code> by incrementing the num<\/code> by 3<\/code> and contains only a few checks, where the argument n<\/code> must be of type int<\/code> and greater than 0<\/code>.<\/p>\n\n\n\n
# odd.py\ndef gen_odd(n):\n    if type(n) != int:\n        raise TypeError(\"Invalid argument type.\")\n    if n < 0:\n        raise ValueError(\"Value must be greater than 0.\")\n    num = 0\n    while num <= n:\n        if num % 2 == 1:\n            print(num)\n        num += 3<\/pre><\/div>\n\n\n\n
Now we’ll write test methods to simulate conditions that could cause the above code to fail.<\/p>\n\n\n\n
from odd import gen_odd\nimport unittest\n\nclass OddTestCase(unittest.TestCase):\n\n    def test_negative_val(self):\n        with self.assertRaises(ValueError):\n            gen_odd(-5)\n\n    def test_float_val(self):\n        with self.assertRaises(TypeError):\n            gen_odd(99.9)\n\n    def test_string_val(self):\n        with self.assertRaises(TypeError):\n            gen_odd('10')\n\nif __name__ == '__main__':\n    unittest.main(verbosity=2)<\/pre><\/div>\n\n\n\n
We wrote three test methods in the OddTestCase<\/code> class to ensure that when invalid arguments are passed, the corresponding error is raised.<\/p>\n\n\n\n
The test_negative_val()<\/code> method asserts that ValueError<\/code> is raised when gen_odd(-5)<\/code> is called.<\/p>\n\n\n\n
Similarly, the test_float_val()<\/code> and test_string_val()<\/code> methods assert that when gen_odd(99.9)<\/code> and gen_odd('10')<\/code> are called, respectively, TypeError<\/code> is raised.<\/p>\n\n\n\n
\"OddTestCase<\/figure>\n\n\n\n
All three tests in the above code passed, which means they all raised corresponding errors, otherwise, the tests would have failed or raised the errors if another exception was raised. Let’s put it to the test.<\/p>\n\n\n\n
from odd import gen_odd\nimport unittest\n\nclass OddTestCase(unittest.TestCase):\n\n    def test_valid_arg(self):\n        with self.assertRaises(TypeError, msg=\"Valid argument\"):\n            gen_odd(10)\n\nif __name__ == '__main__':\n    unittest.main(verbosity=2)<\/pre><\/div>\n\n\n\n
The above condition within the test_valid_arg()<\/code> method will not throw a TypeError<\/code> because gen_odd()<\/code> function is passed with a valid argument.<\/p>\n\n\n\n
\"Output\"<\/figure>\n\n\n\n
The above test method failed and raised an AssertionError<\/code> with the message TypeError not raised : Valid argument<\/code>.<\/p>\n\n\n\n
<\/a>Skipping Tests<\/h2>\n\n\n\n
The unittest<\/code> makes use of the skip()<\/code> decorator or skipTest()<\/code> to skip any test method or whole test class on purpose, and we are required to specify the reason why the test is being skipped.<\/p>\n\n\n\n
Consider the previous example’s code, which we modified by adding the skip()<\/code> decorator.<\/p>\n\n\n\n
from odd import gen_odd\nimport unittest\n\nclass OddTestCase(unittest.TestCase):\n\n    @unittest.skip(\"Valid argument\")\n    def test_valid_arg(self):\n        with self.assertRaises(TypeError):\n            gen_odd(10)\n\nif __name__ == '__main__':\n    unittest.main(verbosity=2)<\/pre><\/div>\n\n\n\n
It’s clear that the above condition will fail and throw an AssertionError<\/code>, so we skipped the testing on purpose.<\/p>\n\n\n\n
\"Skipped<\/figure>\n\n\n\n
What if we wanted to skip the test if a particular condition was true?<\/strong> We can accomplish this by using the skipIf()<\/code> decorator, which allows us to specify a condition and skip the test if it is true.<\/p>\n\n\n\n
from odd import gen_odd\nimport sys\nimport unittest\n\nclass OddTestCase(unittest.TestCase):\n\n    @unittest.skipIf(sys.getsizeof(gen_odd(10)) > 10, \"Exceeded limit\")\n    def test_memory_use(self):\n        self.assertTrue(sys.getsizeof(gen_odd(10)) > 10)\n        print(f\"Size: {sys.getsizeof(gen_odd(10))} bytes\")\n\nif __name__ == '__main__':\n    unittest.main(verbosity=2)<\/pre><\/div>\n\n\n\n
The condition in the above skipIf()<\/code> decorator checks whether the size of gen_odd(10)<\/code> is greater than 10<\/code> bytes, if the condition is true<\/strong>, the test method test_memory_use()<\/code> is skipped, otherwise, the test is executed.<\/p>\n\n\n\n
\"Output\"<\/figure>\n\n\n\n
<\/a>Expected Failure<\/h3>\n\n\n\n
If we have a test method or test class with conditions that are expected to be false, we can use the expectedFailure()<\/code> decorator to mark them as expected failures instead of checking for errors.<\/p>\n\n\n\n
from odd import gen_odd\nimport sys\nimport unittest\n\nclass OddTestCase(unittest.TestCase):\n\n    @unittest.expectedFailure\n    def test_memory_use(self):\n        self.assertTrue(sys.getsizeof(gen_odd(10)) < 10, msg=\"Expected to be failed\")\n        print(f\"Size: {sys.getsizeof(gen_odd(10))} bytes\")\n\nif __name__ == '__main__':\n    unittest.main(verbosity=2)<\/pre><\/div>\n\n\n\n
We’ve modified the previous code and the condition we are checking inside the test_memory_use()<\/code> method is expected to be false, which is why the method is decorated with the @unittest.expectedFailure<\/code> decorator.<\/p>\n\n\n\n
\"Expected<\/figure>\n\n\n\n
<\/a>Conclusion<\/h2>\n\n\n\n
We can use the unittest<\/code> module to write and run tests to ensure that the code is working properly. The test can result in one of three outcomes: OK, FAIL, or Error.<\/p>\n\n\n\n
The unittest<\/code> module provides several assertion methods that are used to validate the code.<\/p>\n\n\n\n
Let’s recall, what we’ve learned:<\/p>\n\n\n\n