09 Unittests.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What you learn:**\n",
    "\n",
    "In this notebook you will learn about automatic unit tests in Python.   \n",
    "\n",
    "Jens Dittrich, [Big Data Analytics Group](https://bigdata.uni-saarland.de/), [CC-BY-SA](https://creativecommons.org/licenses/by-sa/4.0/legalcode)\n",
    "\n",
    "This notebook is available on https://github.com/BigDataAnalyticsGroup/python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## unittests\n",
    "\n",
    "How do we make sure that a certain function does what we expect it to do?\n",
    "\n",
    "The answer is **unittests**. A unittest checks whether a given function produces an expected output for a given input.\n",
    "\n",
    "So, for any Python function out = f(in) that we implement, a unittest defines typically multiple (in, out)-tuples.\n",
    "\n",
    "In any **real** software delevopment unittests are the state-of-the-art method to control the correctness of your software. Unittests are typically executed automatically (every night, every time you change anything, etc.)\n",
    "\n",
    "Do not confuse the terms `try out` with `testing`.\n",
    "\n",
    "`try out`: let's run my program with a couple of inputs and see what happens, if it looks good, we are done. Really?\n",
    "\n",
    "`testing`: write unittests for each and every situation we expect our function to do. Run these tests systematically every time you change anything in your code. This is also called `automatic testing`. If we pass all tests, we are done.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Principle structure of a test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "# 'class' wraps a number of tests into a single unit\n",
    "# this comes from a programming paradigm called \"object-oriented programming\" (OOP),\n",
    "# which you do not really need for this lecture\n",
    "# simply read it as \"a class bundles a couple of test-functions into one unit\"\n",
    "#\n",
    "# in OOP-terms:\n",
    "# \"this is a class definition extending/inheriting from unittest.TestCase\" \n",
    "class MyTest(unittest.TestCase):\n",
    "\n",
    "    # the following function will be called before every test-function:\n",
    "    def setUp(self):\n",
    "        print('setUp MyTest')\n",
    "        \n",
    "    # each test-function must have a name starting with 'test':\n",
    "    def test_1(self):\n",
    "        print('test_1')\n",
    "\n",
    "    def test_2(self):\n",
    "        print('test_2')\n",
    "\n",
    "    def test_3(self):\n",
    "        print('test_3')\n",
    "\n",
    "    # the following function will be called after every test-function:\n",
    "    def tearDown(self):\n",
    "        print('tearDown')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_1 (__main__.MyTest) ... ok\n",
      "test_2 (__main__.MyTest) ... ok\n",
      "test_3 (__main__.MyTest) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 3 tests in 0.007s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setUp MyTest\n",
      "test_1\n",
      "tearDown\n",
      "setUp MyTest\n",
      "test_2\n",
      "tearDown\n",
      "setUp MyTest\n",
      "test_3\n",
      "tearDown\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x10b6efe50>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run the unit test without shutting down the jupyter kernel\n",
    "# notice that this call will look for all test classes, i.e.\n",
    "# all classes inheriting from unittest.TestCase\n",
    "# each of these functions will be executed once\n",
    "# unittest.main(argv=['ignored', '-v'], verbosity=2, exit=False)\n",
    "\n",
    "# only execute a specific Test-class:\n",
    "unittest.main(argv=['ignored', '-v'], defaultTest='MyTest', verbosity=2, exit=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example Testing Scenario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# some class we implemented:\n",
    "class Bar:\n",
    "    def __init__(self):\n",
    "        self.a = 42\n",
    "\n",
    "    def whatever(self, par):\n",
    "        if par == 0:\n",
    "            raise ValueError(\"Division by zero is not defined.\")\n",
    "        self.a /= par\n",
    "        return self.a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = Bar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b.whatever(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# unittests in Python are very similar to unittests in Java:\n",
    "import unittest\n",
    "\n",
    "class BarTest(unittest.TestCase):\n",
    "    # the following method will be called before every test-Method\n",
    "    def setUp(self):\n",
    "        print(\"setup BarTest\")\n",
    "        self.bar = Bar()\n",
    "        \n",
    "    def test_div(self):\n",
    "        print('test_div')\n",
    "        self.assertEqual(self.bar.a, 42)\n",
    "        local_a = 42\n",
    "        par = 77\n",
    "        ret = self.bar.whatever(par)\n",
    "        self.assertEqual(ret, local_a/par)\n",
    "        self.assertEqual(self.bar.a, local_a/par)\n",
    "        \n",
    "    def test_init(self):\n",
    "        print('test_init')\n",
    "        self.assertEqual(self.bar.a, 42)\n",
    "\n",
    "    def test_divbyzero(self):\n",
    "        print('test_divbyzero')\n",
    "        with self.assertRaises(ValueError):\n",
    "            self.bar.whatever(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_div (__main__.BarTest) ... ok\n",
      "test_divbyzero (__main__.BarTest) ... ok\n",
      "test_init (__main__.BarTest) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 3 tests in 0.005s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setup BarTest\n",
      "test_div\n",
      "setup BarTest\n",
      "test_divbyzero\n",
      "setup BarTest\n",
      "test_init\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x10b6fd1f0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# only execute a specific Test-class:\n",
    "unittest.main(argv=['ignored', '-v'], defaultTest='BarTest', verbosity=2, exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: sum of squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to compute $$ \\sum_{i=low}^{high} i^2$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# returns the sum of squares in the int interval [low;high]\n",
    "# a straightforward implementation of a squaredSum\n",
    "def mySquaredSum(low, high):\n",
    "    _sum = 0\n",
    "    for i in range(low,high+1): # note the 'high+1' (rather than 'high')\n",
    "        _sum += i*i\n",
    "\n",
    "    return _sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "385"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's \"try it out\":\n",
    "mySquaredSum(1,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's \"try it out\" even more:\n",
    "mySquaredSum(12,11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's \"try it out\" even more:\n",
    "mySquaredSum(0,-12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks good. But are we done here? No, we need to write proper unittests for this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Unittest for sum of squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, let's write a real unittest for our squaredSum-function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# returns the sum of squares in the int interval [low;high]\n",
    "def squaredSumRecursive(low, high, count=0, indent=''):\n",
    "    #print(indent, 'sqsr', low, high)\n",
    "    if count > 15: # recursion emergency brake...\n",
    "        return 0\n",
    "    _sum = 0\n",
    "    if high>low:\n",
    "        middleLeft = low + (high-low)//2\n",
    "        middleRight = middleLeft + 1\n",
    "        _sum += squaredSumRecursive(low, middleLeft, count+1, indent+'  ')\n",
    "        _sum += squaredSumRecursive(middleRight, high, count+1, indent+'  ')\n",
    "        return _sum\n",
    "    elif high<low:\n",
    "        return 0\n",
    "    else:\n",
    "        return high**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1,2\n",
    "\n",
    "3,4,5\n",
    "\n",
    "6,7,8,\n",
    "\n",
    "9,10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "385"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squaredSumRecursive(1,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An alternative implementation of squared sums:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random as rand\n",
    "import unittest\n",
    "\n",
    "# 'class' wraps a number of tests into a single unit\n",
    "class SumTest(unittest.TestCase):\n",
    "\n",
    "    # test one specific call to squaredSum:\n",
    "    def test_Simple(self):\n",
    "        self.assertEqual(mySquaredSum(1,10), 385)\n",
    "\n",
    "    # test multiple specific calls to squaredSum:\n",
    "    def test_EmptyInterval(self):\n",
    "        self.assertEqual(mySquaredSum(12,11), 0)\n",
    "        self.assertEqual(mySquaredSum(0,-12), 0)\n",
    "        \n",
    "    # test several random calls to squaredSum:\n",
    "    def test_randomRanges(self):\n",
    "        rand.seed(42)\n",
    "        for i in range(100000):\n",
    "            low = rand.randrange(1,50)\n",
    "            high = low + rand.randrange(-3,10)\n",
    "            #print(low,high)\n",
    "            # the following hardly makes sense if we copy-pasted the code for mySquaredSum from squaredSum above:\n",
    "            # self.assertEqual(squaredSum(low, high), mySquaredSum(low, high))\n",
    "            # so actually we need an alternate implementation of squaredSum...\n",
    "            # print(low,high)\n",
    "            self.assertEqual(mySquaredSum(low, high), squaredSumRecursive(low, high))\n",
    "            # or using a list comprehension:\n",
    "            self.assertEqual(mySquaredSum(low, high), sum([i*i for i in range(low,high+1)]))\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_EmptyInterval (__main__.SumTest) ... ok\n",
      "test_Simple (__main__.SumTest) ... ok\n",
      "test_randomRanges (__main__.SumTest) ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 3 tests in 0.749s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x10b71b460>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run the unit test without shutting down the jupyter kernel\n",
    "# here we are running only SumTest!\n",
    "unittest.main(argv=['ignored', '-v'], defaultTest='SumTest', verbosity=2, exit=False)"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "840px",
    "left": "0px",
    "right": "1111px",
    "top": "113px",
    "width": "253px"
   },
   "toc_section_display": "block",
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}