Add material on testing

Author: gjbex

source-code/README.md

@@ -6,6 +6,7 @@ was used to develop it.
 
 ## What is it?
 
+1. `code-testing`: illustrations of using assertions and unit tests.
 1. `context-manager`: illustrates how to write your own context managers.
 1. `coroutines`: illustrates how to write coroutines in Python.
 1. `decorators`: illustrates how to write decorators in Python.

source-code/code-testing/Asserts/README.md

@@ -0,0 +1,12 @@
+# Asserts
+
+`assert` is a Python statement, so it not part of unit testing per se.
+It is mainly intended for contract-based programming and one can prevent
+code to be emitted for asserts by using the `-O` optimizatino flag when
+running the code.
+
+## What is it?
+1. `fac.py`: implements factorial function, checking whether the
+    argument is of type integer, and positive using asserts.
+1. `run.sh`: Bash shell script to run the Python code, once with, and once
+    without code generated for assertions.

source-code/code-testing/Asserts/fac.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+
+def fac(n):
+    '''compute the factorial of given number'''
+    assert type(n) == int, 'argument must be integer'
+    assert n >= 0, 'argument must be positive'
+    if n > 1:
+        return n*fac(n - 1)
+    else:
+        return 1
+
+if __name__ == '__main__':
+    for i in range(5):
+        print('{0}! = {1}'.format(i, fac(i)))
+    for i in [-2, 0.3, 3.0]:
+        try:
+            print('{0}! = {1}'.format(i, fac(i)))
+        except AssertionError as error:
+            print('{0}! failed: "{1}"'.format(i, error))

source-code/code-testing/Asserts/run.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+echo '# run with assertions enabled (default):'
+python ./fac.py
+echo '# --------------------'
+echo '# run with assertions disabled (-O optimization flag):'
+python -O ./fac.py

source-code/code-testing/README.md

@@ -0,0 +1,31 @@
+CodeTesting
+===========
+
+Python's standard library contains the `unittest` module, which allows
+to easily implement unit testing, i.e., it is a framework for setting
+up code for regression testing while developing, modifying, or refactoring
+a code base.
+
+What is it?
+-----------
+1. `constant_db.py`: implements a class that creates a database containing
+    constants (mathematical or fysical), and defines a number of methods
+    to query it.
+1. `constant_db_test.py`: `unittest.TestCase` extension that implements a
+    number of tests for the database.  The database is set up in the
+    `setUp` method, and closed and removed in the `tearDown` method.
+    Various tests are implemented to illustrate some of the assert methods
+    defined by `unittest.TestCase`.
+1. `run_test.sh`: shell script that actually runs the test code, and that
+    uses discovery to minimize maintenance of test code.
+1. `Asserts`: `assert` is a Python statement, so it not part of unit
+    testing per se.  It is mainly intended for contract-based programming
+    and one can prevent code to be emitted for asserts by using the
+    `-O` optimizatino flag when running the code.
+
+Note
+----
+The unit test that checks the number of entries in the database should
+fail to illustrate the output.  Although there are only three constants
+defined in the database, `pi` was added twice, so the total number of
+rows is 4, not 3.

source-code/code-testing/constant_db.py

@@ -0,0 +1,58 @@
+import sqlite3
+
+
+class UnknownConstantError(Exception):
+    pass
+
+
+class ConstantDb(object):
+
+    def __init__(self, file_name='const.db'):
+        self._conn = sqlite3.connect(file_name)
+
+    def close(self):
+        self._conn.close()
+
+    def init(self):
+        constants = {
+            'g': (9.81, 'm/s**2'),
+            'pi': (3.14, None),
+            'mach': (0.00338, 'm/s'),
+        }
+        cursor = self._conn.cursor()
+        cursor.execute('''CREATE TABLE constants (
+                              name  TEXT NOT NULL,
+                              value REAL NOT NULL,
+                              unit  TEXT
+                          )''')
+        for name, data in constants.items():
+            cursor.execute('''INSERT INTO constants
+                                  (name, value, unit) VALUES (?, ?, ?)''',
+                           (name, data[0], data[1]))
+        cursor.execute('''INSERT INTO constants
+                              (name, value, unit) VALUES (?, ?, ?)''',
+                       ('pi', 3.1415, None))
+        self._conn.commit()
+        cursor.close()
+
+    def get_value(self, name):
+        cursor = self._conn.cursor()
+        cursor.execute('''SELECT value FROM constants
+                              WHERE name = ?''', (name, ))
+        rows = cursor.fetchall()
+        cursor.close()
+        if not rows:
+            msg = "constant '{0}' is undefined".format(name)
+            raise UnknownConstantError(msg)
+        else:
+            return rows[0][0]
+
+    def get_names(self):
+        cursor = self._conn.cursor()
+        cursor.execute('''SELECT name FROM constants''')
+        rows = cursor.fetchall()
+        cursor.close()
+        return [row[0] for row in rows]
+
+    def get_nr_constants(self):
+        return len(self.get_names())

source-code/code-testing/constant_db_test.py

@@ -0,0 +1,37 @@
+import os
+import unittest
+
+from constant_db import ConstantDb, UnknownConstantError
+
+
+class ConstantDbTest(unittest.TestCase):
+
+    def setUp(self):
+        self.file_name = 'test.db'
+        self.db = ConstantDb(self.file_name)
+        self.db.init()
+
+    def test_g_value(self):
+        expected_value = 9.81
+        value = self.db.get_value('g')
+        self.assertAlmostEqual(expected_value, value, 1.0e-4)
+
+    def test_constant_names(self):
+        expected_names = {'g', 'pi', 'mach'}
+        names = self.db.get_names()
+        for name in names:
+            self.assertIn(name, expected_names)
+
+    def test_constant_unknown(self):
+        self.assertRaises(UnknownConstantError, self.db.get_value, 'c')
+
+    def test_nr_constants(self):
+        expected_nr_constants = 3
+        nr_constats = self.db.get_nr_constants()
+        self.assertEquals(expected_nr_constants, nr_constats,
+                          'This test is supposed to fail by way '
+                          'of illustration')
+
+    def tearDown(self):
+        self.db.close()
+        os.remove(self.file_name)

source-code/code-testing/run_tests.sh

@@ -0,0 +1,3 @@
+#!/bin/bash -l
+
+python -m unittest discover -p '*_test.py'