How to do Unit Testing in Python

Unit testing in Python is a way of checking for bugs or irregularities in your code. They are extremely crucial when dealing with real projects as it helps you ensure things are working out the way you intend them to be. 

It is always good practice to test your project during the development stage. At this level, bugs are usually less recurring and less expensive to deal with. 

In situations where bugs are allowed to linger, such bugs can affect other functions or blocks of codes that are its dependencies. Again, the bugs in the new code would affect programs that it’s dependent on. This interwoven cycle can become grave if things continue unchecked. 

After reading this tutorial, here’s what you’d learn. 

• The techniques of unit testing in Python
• The Unit Testing Framework in Python
• How yo use PyUnit
• A Basic Test Case Architecture
• Why you should use Unit Testing in Python

Let’s see some of the common techniques deployed in unit testing. 

Techniques for Unit Testing in Python

Recall the unit testing involves checking for bugs on a chunk of code while it is independent of any other code. There are two common techniques for achieving this. The first is:

• Using mocks and stubs: After writing a code, mocks and stubs can be used in isolating each function dependencies and test them on separate and individual levels. A mock fakes the object that we want to test. So the object where we put assertions is simulated using mocks. A stub on the other hand is used as a replacement for any dependency that the code would require for the test to be run rightly.
• Using the Test-Driven Development approach: This approach, commonly called the TDD approach involves you carrying out tests before building the actual code. The test is done such that possible failures/loopholes are observed. It then opens up discussions on how these failures can be avoided when developing the actual project. The TTD may seem counterintuitive but can be very effective in real practice. 

The Python Unit Testing Framework

The Python Unit Framework allows you to make changes in an easier and improved manner. The framework includes the following:

1. PyUnit
2. Doctest
3. Nose

PyUnit

You can use PyUnit for automating the testing process. It supports test suites, test cases, and test running for its automation. You can use the same fixtures to organize test cases into test suites. 

Doctest

In Doctest, you can test your code based on the Docstong of that code. Usually, functions and methods come with a Docstring where there are snippets of how to use the function with examples. Doctest allows you to test your code based on the example given in the Docstring and checking whether it returns the expected result. The downside of this is the fact that the doctest is not usually detailed and cannot be used for very specific codes or special cases. 

They only thrive as a popular use case of modules, functions, or methods. 

Nose

The nose is a built-in plugin that makes testing easier. It can assist you in doing doctest, output capture, code coverage, etc. It’s more like an extension of unittest that takes off the burden of manually doing the tests from scratch. 

Using PyUnit for Unit Testing

There are five major classes in the unittest module. Let’s discuss what these classes do. 

• TestCase class: This is used to define the fixture to run more than one test. 
• TestSuite class: This can be seen as the amalgamation of tests. The class can run a set of test cases. 
• TestLoader class: This class load tests according to some defined criteria and then returns them wrapped in one Test.
• TestRunner class: The class handles the execution of various tests and returns the result to the user. 
•  TestResult class: The class is dedicated to collecting the result of an executed test case. 

The Test Case Arhitecture using PyUnit 

When carrying out test cases, you’d need to create a base class and a test case which may be used to create other test cases. 

When creating a unit test, you’d need to create a setUp() method and a teardown() method. The setUp() method is always run before the test route whereas the teardown() automatically runs after a test routine is complete. 

This is the architecture of a unittest

setUp()
teardown()
 
skipTest(yourMessage)
fail(yourMessage)
 
id()
shortDescription()

The skitTest() and fail() methods are used to control how the test routine is executed. They both take strings as arguments and are used to terminate a test. The skipTest() method terminates only the current test. The fail() method on the other hand terminates all tests completely. 

The id() and shortDescription() method are used to determine the test exactly. The id() method returns the name of the test case object as well as the test routine. The shortDescription() method in contrast returns the doc string comment at the point of beginning a test routine. 

Why use Python Unit Testing

• It is great for spotting abnormalities or bugs early enough
• Overall, you can write better codes
• It can be synchronized with other test tools very easily
• You can easily change things up in a few with minimal repercussion. 

So that’s it about Python unit testing. In this tutorial, you have learned how to do Python unit testing and the class necessary to get it done. You have also come to appreciate why it is vital to do testing before deploying your models/products in production.