Testing applications have become a necessary skill set to become a proficient developer today. The Python community supports testing and the Python standard library has well-built tools to support testing. In the Python environment, there are abundant testing tools to handle the complex testing needs.

Unittest

Inspired by the JUnit framework and having similar characteristics, this unit testing framework supports test automation, sharing of setup and shutdown codes and acts independently of the tests from the reporting environment. The UNittest comprises of several Object-Oriented Concepts such as:

Test Fixture: A test fixture is a representation of the preparation which is needed to execute one or more tests, and collaborates cleanup actions

Test Suite: It is a collection of test cases, test suites which are used as aggregate tests which will be executed together

Test Case: It is an individual unit of testing that tries to find a specific response to appropriate input sets. A test case can be used to create new test cases which provide base classes for the unit test

Test Runner: The basic operation of a test runner is to execute tests and provide the output to the user. The procedure may use a graphical interface, a textual interface, or a special attribute to specify the results of executed tests

Here’s the sample code:

import unittest
class TSM(unittest.TestCase):

   def test_upper(auto):
       auto.assertEqual(‘abc’.upper(), ‘ABC’)

   def test_isupper(auto):
       auto.assertTrue(‘ABC’.isupper())
       auto.assertFalse(‘Abc’.isupper())

   def test_split(auto):
       s = ‘hello world’
       auto.assertEqual(s.split(), [‘This’,’Is’, ‘Python’])
       # check that given condition and s.split fails when the separator is not a string
       with auto.assertRaises(TypeError):
           s.split(2)

if __name__ == ‘__main__’:
   unittest.main()

Nose Testing

An updated form of Unitest framework, the nose testing framework automatically collects the tests from the subclasses of the unittest. Users need to script simple test functions to execute them. The Nose provides various helpful functions for implementing timed tests, testing for exceptions, and other uses.

Sample Code

def dimension_overlap(ranges):
   “””Returns common overlap among a set of [minimum, maximum] ranges”””
   minimum = dimention[0][0]
   maximum = dimention[0][1]
   for (min_1, max_1) in dimention:
       minimum = max(minimum, min_1)
      maximum = min(maximum, max_1)
       if minimum >= maximum:
           return None
       else:
           return (minimum, maximum)

Pytest

Preferred by most of the Python developers, Pytest framework is largely used for Unit testing. The package offers various sub packages collectively known as Pytest framework. The refined and Pythonic expressions which were introduced for testing development have made it preferable for test suites to be scripted in a high-toned firm pattern. It is widely used for small projects and has the best test automation technique. One of the best features of Pytest is that it offers complete information about the failures in the testing case, which will help the developers to address the issue in a relevant and fast way.

Sample Code:

      pip install pytest (installing pytest)

      import pytest (installing pytest into work environment)
      from Purse import purse, InsufficientAmount (user-defined package)


def test_default_initial_amount():
   purse = Purse()
   assert purse.balance == 0

def test_setting_initial_amount():
purse = Purse(100)
   assert Purse.balance == 100

def test_purse_add_cash():
   purse = Purse(10)
   purse.add_cash(90)
   assert purse.balance == 100

def test_purse_spend_cash():
   purse =Purse(20)
   purse.spend_cash(10)
   assert purse.balance == 10

   def test_purse_spend_cash_raises_exception_on_insufficient_amount():
   purse= Purse()
   with pytest.raises(insufficient amount):
       purse.spend_cash(100)

Robot Framework

Being an operating system and application independent, Robot framework is a universal test automation framework for acceptance testing and acceptance driven development(ATDD). Giving access to the easy usage of test data and best suited for the keyword drove testing approach, the robot framework testing capabilities can be drawn out of test libraries either by using Python or Java. The framework gives users the scope to create new high-level keywords from current ones that are in usage by using the same syntax that is used for building test cases.

Sample Code

*** Settings ***
Library  SeleniumLibrary  (set the working library)

*** Test Cases ***
The user can search for colleges
   [Tags]    search_colleges
   Open browser    http://XYZ..com/   Chrome
   Select From List By Value   xpath://select[@name=’most_preferred’]  India
   Select From List by Value   xpath://select[@name=’least_preferred’]    India
   Click Button    css:input[type=’submit’]
   @{colleges}=  Get WebElements    css:table[class=’table’]>tbody tr
   Should Not Be Empty     ${colleges}
   Close All Browsers

Zope Testing

The Zope debugger allows the user to point out the exact step where there is a problem in the running process. The Zope facilitates logging options which permit the user to issue warnings and error messages. The testing provides information through various sources and allows to combine channels to fetch information about the debugging.

The Control Panel

The control panel gives various views that can help user debug zope, specifically in the area of accomplishments, the debugging information link present on the control panel gives two views, debugging info and profiling.

Product Refresh Settings

Zope provides a refreshing view of all control panel devices. This allows the user to reload the products modules as they are being changed or updated.

Debug Mode

Once you set the debug mode, it reduces the Zope performance and gives effects such as

• Tracebacks will be displayed on the browser when errors raise
• External methods and DTML file objects are analyzed to see if they have been updated every time they have been called for an update and they are reloaded

The Python Debugger

Integrated with Python debugger Zope can shut down the server and produce a request through a command line. It develops an infrastructure to raise new objects and debug them immediately.

Sample Code

from zope.interface.verify import verifyClass, verifyObject
from uspkg.app import SampleApp (uspkg=user defined package)
from uspkg.interfaces import ISampleApp

def test_app_create():
   # Assure we can create instances of `Sample_App`
   app_1 = SampleApp_1()
   assert app_1 is not None

def test_app_1_class_iface():
   # Assure the class implements the declared interface
   assert verifyClass(ISample_App, Sample_App)

def test_app_1_instance_iface():
   # Assure instances of the class provide the declared interface
   assert verifyObject(ISample_App, Sample_App())