• Prevent regressions
  
• Prevent fear
  
• Prevent bad design
  

$ sudo pip install virtualenv
$ virtualenv test --no-site-packages
$ ~/.virtualenvs/test/bin/activate 

$ pip install nose

$ pip install coverage 

$ pip install mock

$ pip install Django
# Install django-nose
$ pip install django-nose 

def fact(n):
    """
    Factorial function

    :arg n: Number
    :returns: factorial of n

    >>> fact(0)
    1
    >>> fact(4)
    24
    """
    if n == 0:
        return 1
    return n * fact(n -1) 

$ python -m doctest factorial.py 

# You can add the following at the end of the file
if __name__ == '__main__':
    import doctest
    doctest.test_method()
# Execute tests from shell as below.
$ python factorial.py

import sys

def fact(n):
    """
    Factorial function

    :arg n: Number
    :returns: factorial of n

    """
    if n == 0:
        return 1
    return n * fact(n -1)

def div(n):
    """
    Just divide
    """
    res = 10 / n
    return res


def main(n):
    res = fact(n)
    print res

if __name__ == '__main__':
    if len(sys.argv) > 1:
        main(int(sys.argv[1])) 

$ python factorial.py
120 

import unittest
from factorial import fact

class TestFactorial(unittest.TestCase):
    """
    Our basic test class
    """

    def test_fact(self):
        """
        The actual test.
        Any method which starts with ``test_`` will considered as a test case.
        """
        res = fact(5)
        self.assertEqual(res, 120)


if __name__ == '__main__':
    unittest.main() 

$ python factorial_test.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK 

$ python -m unittest factorial_test

Method	Checks that	New in
assertEqual(a, b)	a == b	 
assertNotEqual(a, b)	a != b	 
assertTrue(x)	bool(x) is True	 
assertFalse(x)	bool(x) is False	 
assertIs(a, b)	a is b	2.7
assertIsNot(a, b)	a is not b	2.7
assertIsNone(x)	x is None	2.7
assertIsNotNone(x)	x is not None	2.7
assertIn(a, b)	a in b	2.7
assertNotIn(a, b)	a not in b	2.7
assertIsInstance(a, b)	isinstance(a, b)	2.7
assertNotIsInstance(a, b)	not isinstance(a, b)	2.7 

# nosetests finds all tests in the current directory
# and runs them.
$ nosetests
# You can also run tests from a particular module/package$ nosetests factorial.test_factorial
# You can even run a particular Test Case$ nosetests factorial.test_factorial:TestFactorial
# Or a test method$ nosetests factorial.test_factorial:TestFactorial.test_fact

• monitors your program, noting which part of code got executed.
  
• also, finds out which executable code was not executed.
  
• works as a gauge to measure the effectiveness of test cases.
  

$ coverage -x test_factorial.py
$ coverage -rm
Name             Stmts   Miss  Cover   Missing
----------------------------------------------
factorial           14      6    57%   25-26, 30-31, 35-36
test_factorial       8      0   100%   
----------------------------------------------
TOTAL               22      6    73%  

>>> import mock
>>> m = mock.Mock()
>>> m.called
False
>>> m.call_count
0
>>> m()
>>> m.called
True
>>> m.call_count
1 >>> m.return_value = 'foo'>>> m()'foo'>>> m.side_effect = Exception('Boom!')
>>> m()
Traceback (most recent call last):
  ...
Exception: Boom!

>>> mock = Mock()
>>> mock.method(1, 2, 3, test='wow')

>>> mock.method.assert_called_with(1, 2, 3, test='wow') 

>>> mock = Mock(return_value=None)
>>> mock('foo', bar='baz')
>>> mock.assert_called_once_with('foo', bar='baz')
>>> mock('foo', bar='baz')
>>> mock.assert_called_once_with('foo', bar='baz')
Traceback (most recent call last):
  ...
AssertionError: Expected to be called once. Called 2 times. 

>>> mock = Mock(return_value=None)
>>> mock(1, 2, arg='thing')
>>> mock('some', 'thing', 'else')
>>> mock.assert_any_call(1, 2, arg='thing') 

>>> mock = Mock(return_value=None)
>>> mock('hello')
>>> mock.called
True
>>> mock.reset_mock()
>>> mock.called
False 

>>> @patch('__main__.SomeClass')
... def function(normal_argument, mock_class):
...     print mock_class is SomeClass
...
>>> function(None)
True