wk7/MY470_wk7_class.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### MY470 Computer Programming\n",
    "# Unit Testing, Exceptions, and Assertions in Python\n",
    "# GitHub Copilot\n",
    "### Week 7 Lab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Testing\n",
    "Running a program to confirm it works as intended\n",
    "\n",
    "## Debugging\n",
    "Fixing a program that does not work as intended"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "**Note:** You should design your program to facilitate testing and debugging. You should break your program into components (this is *modularity*). You should *document* (comments & doc strings) constraints and expectations using function specification. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Unit Testing\n",
    "\n",
    "Verifies that individual units of the code work as expected. You generally work with the smallest atomic element of the code, such as a function or a method in a Class.\n",
    "\n",
    "### Random Testing\n",
    "*Explore a large set of random input values.*\n",
    "\n",
    "### Black-Box Testing\n",
    "*Focus on function specification.* First, we test the boundary conditions (i.e. empty list), then we test all natural partitions (type, i.e. numeric), finally we test extremes (i.e. very large values).\n",
    "\n",
    "### Glass-Box Testing\n",
    "*Focus on the code.* Here, we are testing every possible path through the program, so it is easier to be more thorough. We test all branches including ```if``` statements, ```except``` clauses, ```for``` loops, ```while``` loops (including not entering the loop), and recursive calls. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "**It is good to combine the ideas of black-box and glass-box testing!** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Steps of Testing\n",
    "\n",
    "1. **Make sure code runs** — remove syntax or static semantic errors\n",
    "2. **Unit testing** — test individual functions and methods\n",
    "3. **Regression testing** — fix bugs and perform 2) again\n",
    "4. **Integration testing** — test the program as a whole"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### If your test fails, what should you do?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Option 1:** Fix the bug / error.\n",
    "\n",
    "**Option 2:** Rewrite the function specification."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `.ipynb` and `.py`\n",
    "\n",
    "For Jupyter notebooks the file extension is `.ipynb` which stands for Interactive Python Notebook. We can't run these files in the command line. \n",
    "\n",
    "However, we can run python files, which have the extension `.py`.\n",
    "\n",
    "We can convert a Jupyter notebook to an `.py` file. To do this go to:\n",
    "\n",
    "    File > Save As > Format [Python]\n",
    "\n",
    "Note that when you download a jupyter notebook as a `.py` all the markdown is converted to comments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Key Terms\n",
    "\n",
    "### Module \n",
    "Python files with a `.py` extension. The module is a simple Python file that contains collections of functions and global variables. Generally, a `.py` file is a **module** if it is made to be imported into another file and a `.py` file is a **script** if it is intended to be run directly.\n",
    "\n",
    "### Package\n",
    "A collection of modules within a directory. The directory contains Python modules as well as an `__init__.py` file by which the interpreter understands it as a Package. You don't have to write anything in `__init__.py` file but must be there in the directory.\n",
    "\n",
    "### Library\n",
    "A library is an umbrella term that loosely means \"a bundle of code.\" These can have tens or even hundreds of individual modules that can provide a wide range of functionality."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using the Terminal in VS Code\n",
    "\n",
    "Use the `Toggle Panel` button in the top right corner to display the lower panel. Select `TERMINAL` from it.\n",
    "\n",
    "The output in the Terminal shows the current working directory and the user. If the current working directory is not where the file you want to run is, you should change it:\n",
    "\n",
    "``` bash\n",
    "# Use \"cd\" to change your current directory to a new destination \n",
    "# So, to go to the \"MY470\" folder:\n",
    "cd Users/Milena/Documents/MY470\n",
    "\n",
    "# If your file path has a space in it, wrap the file path in quotes\n",
    "cd \"Users/Milena/Documents/MY 470\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Running Code in the Terminal in VS Code\n",
    "\n",
    "To run the code, you can press the triangle button in the upper right corner that says `Run Python File`.\n",
    "\n",
    "Alternatively, you can type `python` or `python3` followed by the name of the `.py` file in the command line in the Terminal panel. \n",
    "\n",
    "In either case, remember that you need to be in the directory of the file that you want to run or otherwise python will not be able to find it.\n",
    "\n",
    "\n",
    "``` bash\n",
    "# Run the python file\n",
    "> python3 test_leading.py\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "**The default python interpreter in VS Code may not be the Ananconda one, which means that you will not be able to access its installed packages and libraries.** If you want to change this, go to `Code > Preferences > Settings > Extensions > Python` and change the `Default Interpreter Path`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Structuring Your Programs with `.py` Files\n",
    "\n",
    "* Keep functions/classes that are logically related in the same `.py` file\n",
    "    * E.g. `tests.py`, `tools.py`, `plots.py`\n",
    "* Keep the main execution code in a `.ipynb` or `.py` file\n",
    "* Import modules to access functions/classes\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 8, 11, 15, 20]\n"
     ]
    }
   ],
   "source": [
    "# A module saved in the same directory\n",
    "import tools\n",
    "\n",
    "ls = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Function from module\n",
    "tools.running_sum(ls)\n",
    "\n",
    "print(ls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## General Structure of `.py` Files\n",
    "\n",
    "``` python\n",
    "\n",
    "# Start with importing required modules\n",
    "import some_module\n",
    "\n",
    "# Define any required global variables\n",
    "GlOB_VAR = None\n",
    "\n",
    "# Start with main() function to define what to do if the file\n",
    "# is ran as a script.\n",
    "def main():\n",
    "    pass\n",
    "\n",
    "# Define classes and/or functions\n",
    "def your_function():\n",
    "    pass\n",
    "\n",
    "# End your code with this statement\n",
    "if __name__ == '__main__': \n",
    "    main()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Understanding `if __name__ == '__main__':`\n",
    "\n",
    "Whenever python runs a file it sets some special variables. `__name__` is one of these special variables.\n",
    "\n",
    "`__name__` is `__main__` if we run the file directly.\n",
    "\n",
    "If we import the file, `__name__` is set to the name of the python file, without the `.py` extension (i.e. `using_name`).\n",
    "\n",
    "We use this because there are cases where we want to run the code as the main file, and run different code if it is imported."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Anything that comes after if `__name__ == '__main__':` will be run only when you explicitly run your file. \n",
    "\n",
    "If you call your file elsewhere (import) nothing under `__name__ == '__main__':` will be called.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Understanding `if __name__ == '__main__':`\n",
    "\n",
    "Assume that we have a file that is called `using_name.py`. The file contains the code below.\n",
    "\n",
    "``` python\n",
    "# Filename: using_name.py\n",
    "if __name__ == '__main__':\n",
    "    print('This program is being run by itself')\n",
    "else:\n",
    "    print('I am being imported from another module')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "#### Question 1\n",
    "\n",
    "If I were to run the files directly (below), what output would I see?\n",
    "```bash\n",
    "> python3 using_name.py\n",
    "```\n",
    "\n",
    "#### Question 2\n",
    "\n",
    "If I were to import the file into another (below), what output would I see?\n",
    "```\n",
    "import using_name\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Testing with `unittest`\n",
    "\n",
    "* Create a `.py` file (or several for more complex projects) for unit tests\n",
    "* Use a separate class for each function or method you are testing\n",
    "* Consult the documentation to find the assert method you should use\n",
    "* Do not define your own `main()`, use `unittest.main()` instead\n",
    "* **Do not include testing in the main program!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Working with GitHub Copilot\n",
    "\n",
    "1. Make sure you have applied for free student access via [GitHub Education](https://education.github.com/discount_requests/application).\n",
    "2. Install the GitHub Copilot extension in VS Code and log in with your GitHub student account.\n",
    "3. Copilot icon should appear in bottom right corner when properly installed.\n",
    "4. Code and comment/documentation suggestions would pop up as you write. You can accept the suggestion with `Tab` and then edit if necessary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Best Practice with GitHub Copilot\n",
    "\n",
    "For best results, **provide context** with:\n",
    "\n",
    "1. Comments on module, function, or code\n",
    "2. Doctring of function\n",
    "3. Informative function and variable names\n",
    "4. Imports, open files, library documentation, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Remember, you remain the pilot!** Copilot can assist you but you need to prompt it correctly and review and correct its suggestions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "**It takes practice to learn how to prompt Copilot best, as well as to get used to its capabilities and pitfalls.** If it is more confusing/overwhelming than helpful, turn it off and write your code independently."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 1: Using unittest, write all informative tests \n",
    "# for the program below. Save the program in a file called \n",
    "# leading.py and the tests in a file called test_leading.py. \n",
    "# Then run the tests.\n",
    "\n",
    "# What cases should we test for?\n",
    "\n",
    "def leading_substrings(s):\n",
    "    \"\"\"Take string s as input and return a list of all \n",
    "    the substrings that start from the beginning.\n",
    "    E.g., leading_substrings('bear') will return \n",
    "    ['b', 'be', 'bea', 'bear'].\n",
    "    \"\"\"\n",
    "    return [s[:i+1] for i in range(len(s))]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 2: Rewrite the function below with \n",
    "# try and except to handle situations in which the user \n",
    "# does not enter an integer.\n",
    "\n",
    "def get_user_age():\n",
    "    \"\"\"Ask user to input their age and return the input \n",
    "    as an integer.\n",
    "    \"\"\"\n",
    "    s = input(\"Please enter your age: \")\n",
    "    return int(s)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 3: Consider the function below. Rewrite the function \n",
    "# with try and except to handle the situation when the list \n",
    "# with the name provided doesn't exist in the dictionary yet, \n",
    "# instead of checking beforehand whether it does. Include else and \n",
    "# finally clauses to print the text as in the original function.\n",
    "\n",
    "def add_to_list_in_dict(dic, lname, element):\n",
    "    \"\"\"Add element to list with lname in dictionary dic.\"\"\"\n",
    "    \n",
    "    if lname not in dic:\n",
    "        dic[lname] = []\n",
    "        print('Added', lname, 'to dictionary')\n",
    "    else:\n",
    "        x = dic[lname]\n",
    "        print(lname, 'already has', len(x), 'items')\n",
    "        \n",
    "    dic[lname].append(element)\n",
    "    print('Item', element, 'successfully added to', lname)\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}