17-CodeTesting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Course Announcements**\n",
    "\n",
    "- **CL8** due next Wednesday (posted later today)\n",
    "- **A5** due Monday of week 10 (5/31)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "**Q&A**\n",
    "\n",
    "Q: If you did the code differently from the autograder but still had functional code using a different method, will you still only get partial credit? \n",
    "A: On an assignment, you'd get credit. On an exam, if we specified that a certain method/object/function be used and it was not, you would only get partial credit.\n",
    "\n",
    "Q: Does numpy only apply to making matrices?  \n",
    "A: For the most part; it's really made for creating and operating on matrices.\n",
    "\n",
    "Q: When indexing arrays or DataFrame objects, how can include a range of columns and/or rows? We talked about how we can do this for individual or all columns or rows, but what if I wanted to only find the values from rows 2-4 or columns 1-3?\n",
    "A: This is where the `loc` method is quite helpful. `df.loc[2:5, 1:4]` would do what you're looking for!\n",
    "\n",
    "Q: Does plotting only serve for drawing graphs?  \n",
    "A: Hmmm....making plots is typically for creating lots of different types of graphs. Not sure what else you had in mind here, so do reach out if still unsure!\n",
    "\n",
    "Q: I am curious on how often pandas are used for heterogenous data like the example from lecture on logging subject information from possibly some type of experiment. I always assumed people just used excel or spreadsheets to log this kind of data, but I was wondering how often Python is used to store this data, since it appears to be much faster?  \n",
    "A: Python (and R, another programming language) are used *all* the time for operating on data. The reason is b/c 1) it is faster, but 2) it's reproducible. If I give you the data and the code, you can generate the results as well. With Excel that's not exactly possible unless you meticulously write down all the pointing and clicking you did.\n",
    "\n",
    "Q: This is more so for my final project, but for the plotting section, can you use that to create a map in a sense?  \n",
    "A: Yup! There is a package called `geopandas` that may be helpful for this purpose! \n",
    "\n",
    "Q: Is it always required to include the imported module name before using one of its methods?  \n",
    "A: If you import the module/package directly `import module`, then yes, you always have to specify the module/package name before referring to a function from it. However if you import the function directly `from module import function`, then you can call `function` directly. The exception here is when we're talking about methods. Once an object of a particular class is created (DataFrame, numpy array, etc.), you can call the methods directly `df.method()` without the package/module name before it.\n",
    "\n",
    "Q: Is there a website that introduces these packages, or if I want to use other packages, where can I find them?  \n",
    "A: There is a lot of documentation on line. Searching the package name and python (`'pandas python`) will help you find the documentation! [PyP](https://pypi.org/project/pip/) is a searchable place for packages as well. \n",
    "\n",
    "Q: Pandas vs Scipy??\n",
    "A: Pandas for getting the data into the format you need; Scipy (the package) is for analyzing those data after you get them into the format you need. \n",
    "\n",
    "Q: Can we invite tables from Excel into python?  \n",
    "A: Yup! There are `read_` methods in pandas to read external files in.\n",
    "\n",
    "Q: Will we be covering other major libraries?  \n",
    "A: No this quarter.\n",
    "\n",
    "Q: The plotting won't be on the exam correct?  \n",
    "A: Correct. The plotting & stats (t-test) at the end were just shared for an FYI.\n",
    "\n",
    "Q: Since packages like numpy use objects like arrays and pandas use objects like DataFrame, does that mean they can only be used with those packages?  \n",
    "A: Kind of. These packages are often designed to work well together. So, while the DataFrame object is a pandas object, it sometimes borrows from other related packages. Happy to answer this question in more detail and discuss dependencies in office hours!\n",
    "\n",
    "Q: will we incorporate these into our final project somehow, or is it just there as an option?  \n",
    "A: Up to you if you use these in your final project; not required! DataFrames and matrices (and the methods we've discussed) are fair game for the final exam, however.\n",
    "\n",
    "Q: How might we use these to facilitate something on our final project?  \n",
    "A: If your project involves keeping track of information in rows and columns, consider a `numpy` array. If your project involves storing data and using it (analyzing, plotting, etc.), consider `pandas`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Code Testing\n",
    "\n",
    "- smoke tests\n",
    "- unit tests\n",
    "- `pytest`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Writing Good Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "All in all, write code that is:\n",
    "\n",
    "- **Tested**\n",
    "- Documented\n",
    "- Well organized (follows a style guide)\n",
    "\n",
    "And you will have understandable, maintainable, and trustable code. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #1\n",
    "\n",
    "Given the following code, which assert will fail?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def extend(input_arg):\n",
    "    output = input_arg.copy()\n",
    "    for element in input_arg:\n",
    "        output.append(element)\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- A) `assert isinstance(extend([1, 2]), list)`\n",
    "- B) `assert extend([1, 2]) == [1, 2, 1, 2]`\n",
    "- C) `assert extend((1, 2)) == (1, 2, 1, 2)` \n",
    "- D) `assert extend(['a', 'b', 'c']) == ['a', 'b', 'c', 'a', 'b', 'c']`\n",
    "- E) `assert extend([]) == []`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Clicker Question - Asserts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Check that extend returns a list\n",
    "assert isinstance(extend([1, 2]), list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Check that an input list returns the expected result\n",
    "assert extend([1, 2]) == [1, 2, 1, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Check if the function works on tuples\n",
    "assert extend((1, 2)) == (1, 2, 1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Check that a different input list (different lengths / contents) returns expected result\n",
    "assert extend(['a', 'b', 'c']) == ['a', 'b', 'c', 'a', 'b', 'c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Check that an empty list executes, executing an empty list\n",
    "assert extend([]) == []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Code Testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Code tests is code that runs and checks other code, to make sure it does what it is expected to do. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Why Write Tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- To ensure code does what it is supposed to\n",
    "- To have a system for checking things when you change things in the code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Tests, when run, help identify code that will give an error if something has gone wrong. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Best (Laziest) Argument for Writing Tests\n",
    "\n",
    "Whenever you write new code, you will find yourself using little snippets of code to check it. \n",
    "\n",
    "Collect these snippets into a test function, and you get re-runnable tests for free."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![](img/code_testing.png)\n",
    "\n",
    "Source: https://twitter.com/jimhester_/status/1361697676832739328"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## How to Write Tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Given a function or class you want to test:\n",
    "- You need to have an expectation for what it should do\n",
    "- Write out some example cases, with known answers\n",
    "- Use `assert` to check that your example cases do run as expected\n",
    "- Collect these examples into test functions, stored in test files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example Test Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def add(num1, num2):\n",
    "    return num1 + num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# import math\n",
    "\n",
    "def test_add():\n",
    "    \"\"\"Tests for the `add` function.\"\"\"\n",
    "    \n",
    "    # Test adding positve numbers\n",
    "    assert add(2, 2) == 4\n",
    "    \n",
    "    # Test adding negative numbers\n",
    "    assert add(-2, -2) == -4\n",
    "    \n",
    "    # Test adding floats\n",
    "    assert add(2.7, 1.2) == 3.9\n",
    "    # assert math.isclose(add(2.7, 1.2), 3.9)\n",
    "    \n",
    "    # Test adding with 0\n",
    "    assert add(2, 0) == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Run our test function\n",
    "test_add()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "add(2.7, 1.2) == 3.9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Given the following function:\n",
    "def divide_list(in_list):    \n",
    "    output = []\n",
    "    \n",
    "    for el1, el2 in zip(in_list[1:], in_list[0:-1]):\n",
    "        output.append(el1 / el2)\n",
    "    \n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# And the following test function:\n",
    "def test_divide_list():\n",
    "    assert isinstance(divide_list([1, 2]), list)\n",
    "    assert divide_list([1, 2, 4]) == [2, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_divide_list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- A) These tests will pass, and this function is well tested\n",
    "- B) These tests will pass, but this function needs more tests\n",
    "- C) These tests will fail, but they cover the needed cases\n",
    "- D) These tests will fail, and we should also have more tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "divide_list((0,2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Test Driven Development"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "In software development, <b>test-driven development</b> is an approach in which you write tests first -  and then write code to pass the tests. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Test Driven Development"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Ensures you go into writing code with a good plan / outline\n",
    "- Ensures that you have a test suite, as you can not decide to neglect test code after the fact\n",
    "- Note: when you complete (or at least write) assignments for this class, you are effectively doing test-driven development"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Test Coverage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Test coverage</b> is the proportion of a software project that is run by the test suite. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Levels of Code Testing:\n",
    "\n",
    "- Smoke Tests\n",
    "- **Unit Tests**\n",
    "- Integration Tests\n",
    "- System Tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "### Four general types\n",
    "\n",
    "1. **Smoke tests** - preliminary tests to basic functionality; checks if something runs (but not necessarily if it does the right thing) (sanity check) \n",
    "2. **Unit tests** - test functions & objects to ensure that they code is behaving as expected\n",
    "3. **Integration tests** - tests functions, classes & modules interacting\n",
    "4. **System tests** - tests end-to-end behavior "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Unit Tests\n",
    "\n",
    "- one test for each \"piece\" of your code (each function, each class, each module, etc)\n",
    "- passes silently if true\n",
    "- error if it fails\n",
    "- consider \"edge cases\"\n",
    "- help you resist the urge to assume computers will act how you think it will work \n",
    "- functions used with pytest start with `test_`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Not tests, but related\n",
    "- asserts - make a statement of fact about code \n",
    "- static checks - check your code as you go that it behaves as expected\n",
    "- argument validation - checks to see if the input given to a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #3\n",
    "\n",
    "Write a test function that checks the following piece of code:\n",
    "\n",
    "- A) I did it!\n",
    "- B) I think I did it!\n",
    "- C) I'm lost."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thought process:\n",
    "1. Define test function `def test_...`\n",
    "2. make `assert`ion within the test function\n",
    "    - check that the function is callable\n",
    "    - check that function sums the list (which was our expectation)\n",
    "    - check the output is expected output / expected type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def sum_list(input_list):\n",
    "    \"\"\"add all values in a list - return sum\"\"\"\n",
    "    \n",
    "    output = 0\n",
    "    \n",
    "    for val in input_list:\n",
    "        output += val\n",
    "        \n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "### YOUR TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_sum_list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## PyTest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-info\">\n",
    "<b><a href = 'https://docs.pytest.org/en/latest/'> PyTest </a></b> is a module that for writing and running test code. It is available from Anaconda and datahub.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `pytest`\n",
    "\n",
    "- check if error raised when expected to be raised\n",
    "- autorun all of your tests\n",
    "- formal testing to your code/projects\n",
    "\n",
    "#### Executing `pytest`\n",
    "\n",
    "1. Look for any file called `test_...`\n",
    "2. If everything works, silently moves along. \n",
    "4. For anything that fails, will alert you.\n",
    "\n",
    "**Available from Anaconda and on datahub**"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.7.9"
  },
  "rise": {
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}