python_2.4_unit_testing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python: Unit Testing and Debugging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Required Reading\n",
    "1. [Debugging](http://swcarpentry.github.io/python-novice-inflammation/09-debugging/index.html) from Software Carpentry. This resource will guide you through \n",
    "2. [Understanding Unit Testing](https://jeffknupp.com/blog/2013/12/09/improve-your-python-understanding-unit-testing/) by Jeff Knupp. This tutorial guides the reader through the basics of unit testing and using Python's [unittest](https://docs.python.org/3/library/unittest.html#assert-methods) package.\n",
    "\n",
    "## Optional Reading\n",
    "Components that come up frequently with debugging and unit testing are errors and exceptions. To learn more about how they work in Python, read this tutorial on [Errors and Exceptions](http://swcarpentry.github.io/python-novice-inflammation/07-errors/index.html) from Software Carpentry."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Practical Example\n",
    "This may come as a surprise, but as a fellow human, we all make mistakes. As explained in the above resources, we can either fix code when it breaks (a reactive approach) or take steps to ensure we write good code at each step along the way anticipating the needs of each component of our program through unit testing (a more proactive approach).\n",
    "\n",
    "For a working example here, let's start with our `ismultiple()` function from earlier in the tutorial. As a reminder, this function took two arguments: (1) a number and (2) a possible multiple of the number. Here's the function we had for that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Determine if one number is a multiple of another\n",
    "def ismultiple(multiple,number):\n",
    "    if multiple % number == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In an ideal world, we'd create our unit tests BEFORE we wrote the code, that way we could check along the way to know when we'd satisfied all of the conditions we would need to meet. So let's first list our requirements that we'll want to test for this code. Of course, there are the requirements that you or your colleagues need to decide on for what \"correct\" functionality should be. These will be specified by the needs of the project. I want to be extremely thorough for this example (probably overly so for this example), so you'll see there are a surprising number when you try to cover everything. \n",
    "\n",
    "1. The function should return the correct answer for known examples including:\n",
    "    1. 6 is a multiple of 2\n",
    "    2. 12 is a multiple of 3\n",
    "    3. 9 is not a multiple of 4\n",
    "    4. 7 is not a multiple of 13\n",
    "2. All numbers greater than or equal to 1 have a multiple of 1\n",
    "3. A number is always a multiple of itself\n",
    "4. A number has no multiple smaller than itself\n",
    "5. Negative numbers and zero are invalid inputs and if a negative number is input, it should return False\n",
    "6. Any non-integer arguments should cause the function to return false"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with the absolute simplest approach. We could make a short test function that makes sure outputs match and prints the result of the test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def test(result, expected):\n",
    "  if result == expected:\n",
    "    outcome = ' OK '\n",
    "  else:\n",
    "    outcome = ' X  '\n",
    "  print('{} result: {} expected: {}'.format(outcome,result,expected))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could apply this to our `ismultiple` function. For example, we know that 6 is a multiple of 2, so that should be OK:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " OK  result: True expected: True\n"
     ]
    }
   ],
   "source": [
    "test(ismultiple(6,2), True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Excellent! Had we said the expected result was False, we would have seen this output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " X   result: True expected: False\n"
     ]
    }
   ],
   "source": [
    "result   = ismultiple(6,2)\n",
    "expected = False\n",
    "test(result, expected)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Excellent - now we can write our tests to check to make sure the output is right above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n"
     ]
    }
   ],
   "source": [
    "\"\"\"1) It should return the correct answer for known examples\"\"\"\n",
    "test(ismultiple(6,  2 ), True)\n",
    "test(ismultiple(12, 3 ), True)\n",
    "test(ismultiple(9,  4 ), False)\n",
    "test(ismultiple(7,  13), False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great - all the tests associated with the first condition passed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n"
     ]
    }
   ],
   "source": [
    "\"\"\"2) 1 is a multiple of all numbers greater than or equal to 1\"\"\"\n",
    "test(ismultiple(1 ,1), True)\n",
    "test(ismultiple(2 ,1), True)\n",
    "test(ismultiple(3 ,1), True)\n",
    "test(ismultiple(99,1), True)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great - all the tests associated with the second condition passed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n"
     ]
    }
   ],
   "source": [
    "\"\"\"3) A number is always a multiple of itself\"\"\"\n",
    "test(ismultiple( 2, 2), True)\n",
    "test(ismultiple( 3, 3), True)\n",
    "test(ismultiple(99,99), True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great - all the tests associated with the third condition passed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n"
     ]
    }
   ],
   "source": [
    "\"\"\"4) A number has no multiples larger than itself\"\"\"\n",
    "test(ismultiple(2,99), False)\n",
    "test(ismultiple(3, 4), False)\n",
    "test(ismultiple(4, 5), False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great - all the tests associated with the fourth condition passed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " X   result: True expected: False\n",
      " X   result: True expected: False\n",
      " X   result: True expected: False\n",
      " X   result: True expected: False\n"
     ]
    },
    {
     "ename": "ZeroDivisionError",
     "evalue": "integer division or modulo by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-3ace19f5bdda>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mismultiple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mismultiple\u001b[0m\u001b[0;34m(\u001b[0m  \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m  \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mismultiple\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0;36m50\u001b[0m\u001b[0;34m,\u001b[0m   \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mismultiple\u001b[0m\u001b[0;34m(\u001b[0m  \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m   \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-2-1d6db13dc853>\u001b[0m in \u001b[0;36mismultiple\u001b[0;34m(multiple, number)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Determine if one number is a multiple of another\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mismultiple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmultiple\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnumber\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0mmultiple\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mnumber\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: integer division or modulo by zero"
     ]
    }
   ],
   "source": [
    "\"\"\"5) Negative numbers and zero are invalid inputs and if a\n",
    "negative number is input, it should return False\"\"\"\n",
    "test(ismultiple(-50,  10), False)\n",
    "test(ismultiple( 50, -10), False)\n",
    "test(ismultiple(-50, -10), False)\n",
    "test(ismultiple(  0,  10), False)\n",
    "test(ismultiple( 50,   0), False)\n",
    "test(ismultiple(  0,   0), False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uh oh - the tests for the fifth condition didn't pass and even resulted in errors. We need to redevelop our code to handle negative numbers and zero values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "not all arguments converted during string formatting",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-f522a480a328>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;34m\"\"\"6) Any non-integer arguments should cause the function to return false\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mismultiple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'string'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mismultiple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'string'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mismultiple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'string'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'string'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mismultiple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m7.5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-2-1d6db13dc853>\u001b[0m in \u001b[0;36mismultiple\u001b[0;34m(multiple, number)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Determine if one number is a multiple of another\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mismultiple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmultiple\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnumber\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0mmultiple\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mnumber\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: not all arguments converted during string formatting"
     ]
    }
   ],
   "source": [
    "\"\"\"6) Any non-integer arguments should cause the function to return false\"\"\"\n",
    "test(ismultiple('string',3), False)\n",
    "test(ismultiple(3,'string'), False)\n",
    "test(ismultiple('string','string'), False)\n",
    "test(ismultiple(7.5, 4), False)\n",
    "test(ismultiple(8, 4.1), False)\n",
    "test(ismultiple([6,4],2), False)\n",
    "test(ismultiple(12,(1,4)), False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Condition 6 posed a problem as well: it also looks like non-integer arguments caused errors - we need to fix how this is handled."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try to address the issues above. To do this, any invalid input should cause the function to return `False`. This includes non-integer arguments, zero values, and negative numbers.\n",
    "\n",
    "Below you'll see the `isinstance(a,b)` function, which checks to see whether `a` is an instance of, or is of type  `b`. So if `a` is an integer, and `b` is `int`, then this would return `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Determine if one number is a multiple of another\n",
    "def ismultiple(multiple, number):\n",
    "    \n",
    "    # Check the input to see if it's valid\n",
    "    if isinstance(number,int) and isinstance(multiple,int):\n",
    "        if number <= 0 or multiple <= 0:\n",
    "            return False\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "    # Check if one numbers ia multiple of another\n",
    "    if multiple % number == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's rerun our tests once again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n"
     ]
    }
   ],
   "source": [
    "\"\"\"1) It should return the correct answer for known examples\"\"\"\n",
    "test(ismultiple(6,  2 ), True)\n",
    "test(ismultiple(12, 3 ), True)\n",
    "test(ismultiple(9,  4 ), False)\n",
    "test(ismultiple(7,  13), False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n"
     ]
    }
   ],
   "source": [
    "\"\"\"2) 1 is a multiple of all numbers greater than or equal to 1\"\"\"\n",
    "test(ismultiple(1 ,1), True)\n",
    "test(ismultiple(2 ,1), True)\n",
    "test(ismultiple(3 ,1), True)\n",
    "test(ismultiple(99,1), True)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n",
      " OK  result: True expected: True\n"
     ]
    }
   ],
   "source": [
    "\"\"\"3) A number is always a multiple of itself\"\"\"\n",
    "test(ismultiple( 2, 2), True)\n",
    "test(ismultiple( 3, 3), True)\n",
    "test(ismultiple(99,99), True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n"
     ]
    }
   ],
   "source": [
    "\"\"\"4) A number has no multiples larger than itself\"\"\"\n",
    "test(ismultiple(2,99), False)\n",
    "test(ismultiple(3, 4), False)\n",
    "test(ismultiple(4, 5), False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n"
     ]
    }
   ],
   "source": [
    "\"\"\"5) Negative numbers and zero are invalid inputs and if a\n",
    "negative number is input, it should return False\"\"\"\n",
    "test(ismultiple(-50,  10), False)\n",
    "test(ismultiple( 50, -10), False)\n",
    "test(ismultiple(-50, -10), False)\n",
    "test(ismultiple(  0,  10), False)\n",
    "test(ismultiple( 50,   0), False)\n",
    "test(ismultiple(  0,   0), False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n",
      " OK  result: False expected: False\n"
     ]
    }
   ],
   "source": [
    "\"\"\"6) Any non-integer arguments should cause the function to return false\"\"\"\n",
    "test(ismultiple('string',3), False)\n",
    "test(ismultiple(3,'string'), False)\n",
    "test(ismultiple('string','string'), False)\n",
    "test(ismultiple(7.5, 4), False)\n",
    "test(ismultiple(8, 4.1), False)\n",
    "test(ismultiple([6,4],2), False)\n",
    "test(ismultiple(12,(1,4)), False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wonderful! All our tests passed and we're ready to use our `ismultiple` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our simple `test` function allowed us to test all of the use cases we specified earlier. However, Python has a module for running unit tests called `unittest`. While you may not need to use this module, it's good to be aware of the tool. To run it, you create a class that uses methods from `unittest`. `assertEqual` has approximately the same functionality as our `test` function, but you'll notice that this "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "......\n",
      "----------------------------------------------------------------------\n",
      "Ran 6 tests in 0.009s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "class IsmultipleTest(unittest.TestCase):\n",
    "    \"\"\"Tests for `ismultiple()`.\"\"\"\n",
    "\n",
    "    def test_known_values(self):\n",
    "        \"\"\"1) It should return the correct answer for known examples\"\"\"\n",
    "        self.assertEqual(ismultiple(6,  2 ), True)\n",
    "        self.assertEqual(ismultiple(12, 3 ), True)\n",
    "        self.assertEqual(ismultiple(9,  4 ), False)\n",
    "        self.assertEqual(ismultiple(7,  13), False)\n",
    "        \n",
    "    def test_1(self):\n",
    "        \"\"\"2) 1 is a multiple of all numbers greater than or equal to 1\"\"\"\n",
    "        self.assertEqual(ismultiple(1 ,1), True)\n",
    "        self.assertEqual(ismultiple(2 ,1), True)\n",
    "        self.assertEqual(ismultiple(3 ,1), True)\n",
    "        self.assertEqual(ismultiple(99,1), True)\n",
    "        \n",
    "    def test_all_multiples_of_themselves(self):\n",
    "        \"\"\"3) A number is always a multiple of itself\"\"\"\n",
    "        self.assertEqual(ismultiple( 2, 2), True)\n",
    "        self.assertEqual(ismultiple( 3, 3), True)\n",
    "        self.assertEqual(ismultiple(99,99), True)\n",
    "        \n",
    "    def test_no_multiples_larger_than_itself(self):\n",
    "        \"\"\"4) A number has no multiples larger than itself\"\"\"\n",
    "        self.assertEqual(ismultiple(2,99), False)\n",
    "        self.assertEqual(ismultiple(3, 4), False)\n",
    "        self.assertEqual(ismultiple(4, 5), False)\n",
    "        \n",
    "    def test_negative_and_zero(self):\n",
    "        \"\"\"5) Negative numbers and zero are invalid inputs and if a\n",
    "        negative number is input, it should return False\"\"\"\n",
    "        self.assertEqual(ismultiple(-50,  10), False)\n",
    "        self.assertEqual(ismultiple( 50, -10), False)\n",
    "        self.assertEqual(ismultiple(-50, -10), False)\n",
    "        self.assertEqual(ismultiple(  0,  10), False)\n",
    "        self.assertEqual(ismultiple( 50,   0), False)\n",
    "        self.assertEqual(ismultiple(  0,   0), False)\n",
    "        \n",
    "    def test_non_integer(self):\n",
    "        \"\"\"6) Any non-integer arguments should cause the function to return false\"\"\"\n",
    "        self.assertEqual(ismultiple('string',3), False)\n",
    "        self.assertEqual(ismultiple(3,'string'), False)\n",
    "        self.assertEqual(ismultiple('string','string'), False)\n",
    "        self.assertEqual(ismultiple(7.5, 4), False)\n",
    "        self.assertEqual(ismultiple(8, 4.1), False)\n",
    "        self.assertEqual(ismultiple([6,4],2), False)\n",
    "        self.assertEqual(ismultiple(12,(1,4)), False)\n",
    "        \n",
    "if __name__ == '__main__':\n",
    "    unittest.main(argv=['first-arg-is-ignored'], exit=False)\n",
    "    # If this was in a file instead of a Jupyter Notebook, you would write \n",
    "    #   the following instead of the line above:\n",
    "    # unittest.main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These tests have 3 possible outcomes:\n",
    "1. OK, The test passes. This is represented with a '`.`' at the top of the output.\n",
    "2. FAIL: the test does not pass, and raises an AssertionError exception.\n",
    "3. ERROR: The test raises an exception other than AssertionError.\n",
    "\n",
    "If the output was:\n",
    "```\n",
    "...F.E\n",
    "```\n",
    "As it would have been for our earlier version of the `ismultiple` function, then of the 6 tests presented, two situations did not meet specifications, and would have indicated :\n",
    "- FAILED: 5) Negative numbers and zero are invalid inputs and if a negative number is input, it should return False\n",
    "- ERROR: 6) Any non-integer arguments should cause the function to return false"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If this was a function that we were giving to other users, we may very well want to be sure that our tests represent the desired behavior so those users could benefit from a well-functioning program. We also know that we can build on this function in a larger code base with confidence in its operation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next\n",
    "With an ever growing collection of tools at your disposal, it's time to take a moment to discuss best practices for programming, which we'll do in the final section of this unit."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}