summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--slides/test_driven_development/tdd_advanced.ipyml674
-rw-r--r--slides/test_driven_development/tdd_advanced.ipynb844
2 files changed, 1518 insertions, 0 deletions
diff --git a/slides/test_driven_development/tdd_advanced.ipyml b/slides/test_driven_development/tdd_advanced.ipyml
new file mode 100644
index 0000000..a146951
--- /dev/null
+++ b/slides/test_driven_development/tdd_advanced.ipyml
@@ -0,0 +1,674 @@
+cells:
+
+- markdown: |
+ # Advanced topics in test driven development
+
+ metadata:
+ slideshow:
+ slide_type: slide
+
+- markdown: |
+ ## Introduction
+
+
+ - Already seen the basics
+ - Learn some advanced topics
+
+ metadata:
+ slideshow:
+ slide_type: slide
+
+- markdown: |
+ ## The hypothesis package
+
+ - http://hypothesis.readthedocs.io
+
+ - `pip install hypothesis`
+
+ - General idea earlier:
+ - Make test data.
+ - Perform operations
+ - Assert something after operation
+
+ - Hypothesis automates this!
+ - Describe range of scenarios
+ - Computer explores these and tests
+
+ - With hypothesis:
+ - Generate random data using specification
+ - Perform operations
+ - assert something about result
+
+
+ metadata:
+ slideshow:
+ slide_type: slide
+
+- markdown: |
+ ### Example
+
+ metadata:
+ slideshow:
+ slide_type: slide
+
+- code: |
+
+ from hypothesis import given
+ from hypothesis import strategies as st
+
+ from gcd import gcd
+
+ @given(st.integers(min_value=0), st.integers(min_value=0))
+ def test_gcd(a, b):
+ result = gcd(a, b)
+ # Now what?
+ # assert a%result == 0
+
+ id: 0
+ metadata:
+ collapsed: true
+ slideshow:
+ slide_type: fragment
+
+- markdown: |
+ ### Example: adding a specific case
+
+ metadata:
+ slideshow:
+ slide_type: slide
+
+- code: |
+ @given(st.integers(min_value=0), st.integers(min_value=0))
+
+ @example(a=44, b=19)
+
+ def test_gcd(a, b):
+ result = gcd(a, b)
+ # Now what?
+ # assert a%result == 0
+
+ id: 1
+ metadata:
+ collapsed: true
+ slideshow:
+ slide_type: fragment
+
+- markdown: |
+ ### More details
+
+ - `given` generates inputs
+ - `strategies`: provides a strategy for inputs
+ - Different stratiegies
+ - `integers`
+ - `floats`
+ - `text`
+ - `booleans`
+ - `tuples`
+ - `lists`
+ - ...
+
+ - See: http://hypothesis.readthedocs.io/en/latest/data.html
+
+ metadata:
+ slideshow:
+ slide_type: slide
+
+- markdown: |
+ ### Example exercise
+
+ - Write a simple run-length encoding function called `encode`
+ - Write another called `decode` to produce the same input from the output of
+ `encode`
+
+ metadata:
+ slideshow:
+ slide_type: slide
+
+- code: |
+ def encode(text):
+ return []
+
+ def decode(lst):
+ return ''
+
+
+ id: 2
+ metadata:
+ collapsed: true
+ slideshow:
+ slide_type: fragment
+
+- markdown: |
+ ### The test
+
+
+- code: |
+ from hypothesis import given
+ from hypothesis import strategies as st
+
+ @given(st.text())
+ def test_decode_inverts_encode(s):
+ assert decode(encode(s)) == s
+
+ id: 3
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ### Summary
+
+ - Much easier to test
+ - hypothesis does the hard work
+ - Can do a lot more!
+ - Read the docs for more
+ - For some detailed articles:
+ http://hypothesis.works/articles/intro/
+ - Here in particular is one interesting article:
+ http://hypothesis.works/articles/calculating-the-mean/
+
+ ----
+
+ ## Unittest module
+
+ - Basic idea and style is from JUnit
+ - Some consider this old style
+
+
+ ### How to use unittest
+
+ - Subclass `unittest.TestCase`
+ - Create test methods
+
+ ### A simple example
+
+ - Let us test gcd.py with unittest
+
+
+- code: |
+ # gcd.py
+ def gcd(a, b):
+ if b == 0:
+ return a
+ return gcd(b, a%b)
+
+ id: 4
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ### Writing the test
+
+
+- code: |
+ # test_gcd.py
+ from gcd import gcd
+ import unittest
+
+ class TestGCD(unittest.TestCase):
+ def test_gcd_works_for_positive_integers(self):
+ self.assertEqual(gcd(48, 64), 16)
+ self.assertEqual(gcd(44, 19), 1)
+
+ if __name__ == '__main__':
+ unittest.main()
+
+ id: 5
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ### Running it
+
+ - Just run `python test_gcd.py`
+ - Also works with `nosetests` and `pytest`
+
+
+ ### Notes
+
+ - Note the name of the method.
+ - Note the use of `self.assertEqual`
+ - Also available: `assertNotEqual, assertTrue, assertFalse, assertIs, assertIsNot`
+ - `assertIsNone, assertIn, assertIsInstance, assertRaises`
+ - `assertAlmostEqual, assertListEqual, assertSequenceEqual ` ...
+
+ - https://docs.python.org/2/library/unittest.html
+
+
+ ### Fixtures
+
+ - What if you want to do something common before all tests?
+ - Typically called a **fixture**
+
+ - Use the `setUp` and `tearDown` methods for method-level fixtures
+
+ ### Silly fixture example
+
+
+- code: |
+ # test_gcd.py
+ import gcd
+ import unittest
+
+ class TestGCD(unittest.TestCase):
+ def setUp(self):
+ print("setUp")
+ def tearDown(self):
+ print("tearDown")
+ def test_gcd_works_for_positive_integers(self):
+ self.assertEqual(gcd(48, 64), 16)
+ self.assertEqual(gcd(44, 19), 1)
+
+ if __name__ == '__main__':
+ unittest.main()
+
+ id: 6
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ### Exercise
+
+ - Fix bug with negative numbers in gcd.py.
+ - Use TDD.
+
+
+ ### Using hypothesis with unittest
+
+
+- code: |
+ # test_gcd.py
+ from hypothesis import given
+ from hypothesis import strategies as st
+
+ import gcd
+ import unittest
+
+ class TestGCD(unittest.TestCase):
+ @given(a=st.integers(min_value=0), b=st.integers(min_value=0))
+ def test_gcd_works_for_positive_integers(self, a, b):
+ result = gcd(a, b)
+ assert a%result == 0
+ assert b%result == 0
+ assert result <= a and result <= b
+
+ if __name__ == '__main__':
+ unittest.main()
+
+ id: 7
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ### Some notes on style
+
+ - Use descriptive function names
+ - Intent matters
+
+ - Segregate the test code into the following
+
+
+- code: |
+ - Given: what is the context of the test?
+ - When: what action is taken to actually test the problem
+ - Then: what do we actually ensure.
+
+ id: 8
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ### More on intent driven programming
+
+ - "Programs must be written for people to read, and only incidentally for
+ machines to execute.” Harold Abelson
+
+ - The code should make the intent clear.
+
+ For example:
+
+
+- code: |
+ if self.temperature > 600 and self.pressure > 10e5:
+ message = 'hello you have a problem here!'
+ message += 'current temp is %s'%(self.temperature)
+ print(message)
+ self.valve.close()
+ self.raise_warning()
+
+ id: 9
+ metadata:
+ collapsed: true
+
+- markdown: |
+ is totally unclear as to the intent. Instead refactor as follows:
+
+
+- code: |
+ if self.reactor_is_critical():
+ self.shutdown_with_warning()
+
+ id: 10
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ### A more involved testing example
+
+ - Motivational problem:
+
+ > Find all the git repositories inside a given directory recursively.
+ > Make this a command line tool supporting command line use.
+
+ - Write tests for the code
+ - Some rules:
+
+ 0. The test should be runnable by anyone (even by a computer), almost anywhere.
+ 1. Don't write anything in the current directory (use a temporary directory).
+ 2. Cleanup any files you create while testing.
+ 3. Make sure tests do not affect global state too much.
+
+
+ ### Solution
+
+ 1. Create some test data.
+ 2. Test!
+ 3. Cleanup the test data
+
+
+ ### Class-level fixtures
+
+ - Use `setupClass` and `tearDownClass` classmethods for class level fixtures.
+
+
+ ### Module-level fixtures
+
+ - `setup_module`, `teardown_module`
+ - Can be used for a module-level fixture
+
+ - http://nose.readthedocs.io/en/latest/writing_tests.html
+
+
+ ## Coverage
+
+ - Assess the amount of code that is covered by testing
+ - http://coverage.readthedocs.io/
+ - `pip install coverage`
+ - Integrates with nosetests/pytest
+
+ ### Typical coverage usage
+
+
+- code: |
+ $ coverage run -m nose.core my_package
+ $ coverage report -m
+ $ coverage html
+
+ id: 11
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ## mock
+
+ - Mocking for advanced testing.
+
+ - Example: reading some twitter data
+ - Example: function to post an update to facebook or twitter
+ - Example: email user when simulation crashes
+
+ - Can you test it? How?
+
+ ### Using mock: the big picture
+
+ - Do you really want to post something on facebook?
+ - Or do you want to know if the right method was called with the right arguments?
+
+ - Idea: "mock" the objects that do something and test them
+
+ - Quoting from the Python docs:
+
+ > It allows you to replace parts of your system under test with mock objects
+ > and make assertions about how they have been used.
+
+ ### Installation
+
+ - Built-in on Python >= 3.3
+
+
+- code: |
+ - `from unittest import mock`
+
+ id: 12
+ metadata:
+ collapsed: true
+
+- markdown: |
+ - else `pip install mock`
+
+
+- code: |
+ - `import mock`
+
+ id: 13
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ### Simple examples
+
+ Say we have a class:
+
+
+- code: |
+ class ProductionClass(object):
+ def method(self, *args):
+ # This does something we do not want to actually run in the test
+ # ...
+ pass
+
+ id: 14
+ metadata:
+ collapsed: true
+
+- markdown: |
+ To mock the `ProductionClass.method` do this:
+
+
+- code: |
+ from unittest.mock import MagicMock
+ thing = ProductionClass()
+ thing.method = MagicMock(return_value=3)
+ thing.method(3, 4, 5, key='value')
+ thing.method.assert_called_with(3, 4, 5, key='value')
+
+ id: 15
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ### More practical use case
+
+ - Mocking a module or system call
+ - Mocking an object or method
+ - Remember that after testing you want to restore original state
+ - Use `mock.patch`
+
+ ### An example
+
+ - Write code to remove generated files from LaTeX compilation, i.e. remove the
+ *.aux, *.log, *.pdf etc.
+
+ Here is a simple attempt:
+
+
+- code: |
+ # clean_tex.py
+ import os
+
+ def cleanup(tex_file_pth):
+ base = os.path.splitext(tex_file_pth)[0]
+ for ext in ('.aux', '.log'):
+ f = base + ext
+ if os.path.exists(f):
+ os.remove(f)
+
+ id: 16
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ### Testing this with mock
+
+
+- code: |
+ import mock
+
+ @mock.patch('clean_tex.os.remove')
+ def test_cleanup_removes_extra_files(mock_remove):
+ cleanup('foo.tex')
+
+ expected = [mock.call('foo.' + x) for x in ('aux', 'log')]
+
+ mock_remove.assert_has_calls(expected)
+
+ id: 17
+ metadata:
+ collapsed: true
+
+- markdown: |
+ - Note the mocked argument that is passed.
+ - Note that we did not mock `os.remove`
+ - Mock where the object is looked up
+
+ ### Doing more
+
+
+- code: |
+ import mock
+
+ @mock.patch('clean_tex.os.path')
+ @mock.patch('clean_tex.os.remove')
+ def test_cleanup_does_not_fail_when_files_dont_exist(mock_remove, mock_path):
+ # Setup the mock_path to return False
+ mock_path.exists.return_value = False
+
+ cleanup('foo.tex')
+
+ mock_remove.assert_not_called()
+
+ id: 18
+ metadata:
+ collapsed: true
+
+- markdown: |
+ - Note the order of the passed arguments
+ - Note the name of the method
+
+ ### Patching instance methods
+
+ Use `mock.patch.object` to patch an instance method
+
+
+- code: |
+ @mock.patch.object(ProductionClass, 'method')
+ def test_method(mock_method):
+ obj = ProductionClass()
+ obj.method(1)
+
+ mock_method.assert_called_once_with(1)
+
+ id: 19
+ metadata:
+ collapsed: true
+
+- markdown: |
+ Mock works as a context manager:
+
+
+- code: |
+ with mock.patch.object(ProductionClass, 'method') as mock_method:
+ obj = ProductionClass()
+ obj.method(1)
+
+ mock_method.assert_called_once_with(1)
+
+ id: 20
+ metadata:
+ collapsed: true
+
+- markdown: |
+ ### More articles on mock
+
+ - See more here https://docs.python.org/3/library/unittest.mock.html
+ - https://www.toptal.com/python/an-introduction-to-mocking-in-python
+
+
+ ## Pytest
+
+ Offers many useful and convenient features that are useful
+
+
+ ## Odds and ends
+
+ ### Linters
+
+ - `pyflakes`
+ - `flake8`
+
+ ### IPython goodies
+
+ - Use `%run`
+ - Use `%pdb`
+ - `%debug`
+
+ ### Debugging
+
+ - Debug with `%run`
+ - pdb.set_trace()
+ - IPython set trace:
+
+
+- code: |
+ from IPython.core.debugger import Tracer; Tracer()()
+
+ id: 21
+ metadata:
+ collapsed: true
+
+- markdown: |
+ - See here: http://www.scipy-lectures.org/advanced/debugging/
+
+
+# The lines below here may be deleted if you do not need them.
+# ---------------------------------------------------------------------------
+metadata:
+ celltoolbar: Slideshow
+ kernelspec:
+ display_name: Python 2
+ language: python
+ name: python2
+ language_info:
+ codemirror_mode:
+ name: ipython
+ version: 2
+ file_extension: .py
+ mimetype: text/x-python
+ name: python
+ nbconvert_exporter: python
+ pygments_lexer: ipython2
+ version: 2.7.11
+nbformat: 4
+nbformat_minor: 0
+
+# ---------------------------------------------------------------------------
+data:
+ [{execution_count: null, outputs: []}, {execution_count: null, outputs: []}, {execution_count: null,
+ outputs: []}, {execution_count: null, outputs: []}, {execution_count: null, outputs: []},
+ {execution_count: null, outputs: []}, {execution_count: null, outputs: []}, {execution_count: null,
+ outputs: []}, {execution_count: null, outputs: []}, {execution_count: null, outputs: []},
+ {execution_count: null, outputs: []}, {execution_count: null, outputs: []}, {execution_count: null,
+ outputs: []}, {execution_count: null, outputs: []}, {execution_count: null, outputs: []},
+ {execution_count: null, outputs: []}, {execution_count: null, outputs: []}, {execution_count: null,
+ outputs: []}, {execution_count: null, outputs: []}, {execution_count: null, outputs: []},
+ {execution_count: null, outputs: []}, {execution_count: null, outputs: []}]
+
diff --git a/slides/test_driven_development/tdd_advanced.ipynb b/slides/test_driven_development/tdd_advanced.ipynb
new file mode 100644
index 0000000..e780dc8
--- /dev/null
+++ b/slides/test_driven_development/tdd_advanced.ipynb
@@ -0,0 +1,844 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Advanced topics in test driven development"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Introduction\n",
+ "\n",
+ "\n",
+ "- Already seen the basics\n",
+ "- Learn some advanced topics"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## The hypothesis package\n",
+ "\n",
+ "- http://hypothesis.readthedocs.io\n",
+ "\n",
+ "- `pip install hypothesis`\n",
+ "\n",
+ "- General idea earlier:\n",
+ " - Make test data.\n",
+ " - Perform operations\n",
+ " - Assert something after operation\n",
+ "\n",
+ "- Hypothesis automates this!\n",
+ " - Describe range of scenarios\n",
+ " - Computer explores these and tests\n",
+ "\n",
+ "- With hypothesis:\n",
+ " - Generate random data using specification\n",
+ " - Perform operations\n",
+ " - assert something about result\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Example"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true,
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "\n",
+ "from hypothesis import given\n",
+ "from hypothesis import strategies as st\n",
+ "\n",
+ "from gcd import gcd\n",
+ "\n",
+ "@given(st.integers(min_value=0), st.integers(min_value=0))\n",
+ "def test_gcd(a, b):\n",
+ " result = gcd(a, b)\n",
+ " # Now what?\n",
+ " # assert a%result == 0\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Example: adding a specific case"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true,
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "@given(st.integers(min_value=0), st.integers(min_value=0))\n",
+ "\n",
+ "@example(a=44, b=19)\n",
+ "\n",
+ "def test_gcd(a, b):\n",
+ " result = gcd(a, b)\n",
+ " # Now what?\n",
+ " # assert a%result == 0\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### More details\n",
+ "\n",
+ "- `given` generates inputs\n",
+ "- `strategies`: provides a strategy for inputs\n",
+ "- Different stratiegies\n",
+ " - `integers`\n",
+ " - `floats`\n",
+ " - `text`\n",
+ " - `booleans`\n",
+ " - `tuples`\n",
+ " - `lists`\n",
+ " - ...\n",
+ "\n",
+ "- See: http://hypothesis.readthedocs.io/en/latest/data.html"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "### Example exercise\n",
+ "\n",
+ "- Write a simple run-length encoding function called `encode`\n",
+ "- Write another called `decode` to produce the same input from the output of\n",
+ " `encode`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true,
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def encode(text):\n",
+ " return []\n",
+ "\n",
+ "def decode(lst):\n",
+ " return ''\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### The test"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "from hypothesis import given\n",
+ "from hypothesis import strategies as st\n",
+ "\n",
+ "@given(st.text())\n",
+ "def test_decode_inverts_encode(s):\n",
+ " assert decode(encode(s)) == s"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Summary\n",
+ "\n",
+ "- Much easier to test\n",
+ "- hypothesis does the hard work\n",
+ "- Can do a lot more!\n",
+ "- Read the docs for more\n",
+ "- For some detailed articles:\n",
+ " http://hypothesis.works/articles/intro/\n",
+ "- Here in particular is one interesting article:\n",
+ " http://hypothesis.works/articles/calculating-the-mean/\n",
+ "\n",
+ "----\n",
+ "\n",
+ "## Unittest module\n",
+ "\n",
+ "- Basic idea and style is from JUnit\n",
+ "- Some consider this old style\n",
+ "\n",
+ "\n",
+ "### How to use unittest\n",
+ "\n",
+ "- Subclass `unittest.TestCase`\n",
+ "- Create test methods\n",
+ "\n",
+ "### A simple example\n",
+ "\n",
+ "- Let us test gcd.py with unittest"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "# gcd.py\n",
+ "def gcd(a, b):\n",
+ " if b == 0:\n",
+ " return a\n",
+ " return gcd(b, a%b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Writing the test"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "# test_gcd.py\n",
+ "from gcd import gcd\n",
+ "import unittest\n",
+ "\n",
+ "class TestGCD(unittest.TestCase):\n",
+ " def test_gcd_works_for_positive_integers(self):\n",
+ " self.assertEqual(gcd(48, 64), 16)\n",
+ " self.assertEqual(gcd(44, 19), 1)\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " unittest.main()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Running it\n",
+ "\n",
+ "- Just run `python test_gcd.py`\n",
+ "- Also works with `nosetests` and `pytest`\n",
+ "\n",
+ "\n",
+ "### Notes\n",
+ "\n",
+ "- Note the name of the method.\n",
+ "- Note the use of `self.assertEqual`\n",
+ "- Also available: `assertNotEqual, assertTrue, assertFalse, assertIs, assertIsNot`\n",
+ "- `assertIsNone, assertIn, assertIsInstance, assertRaises`\n",
+ "- `assertAlmostEqual, assertListEqual, assertSequenceEqual ` ...\n",
+ "\n",
+ "- https://docs.python.org/2/library/unittest.html\n",
+ "\n",
+ "\n",
+ "### Fixtures\n",
+ "\n",
+ "- What if you want to do something common before all tests?\n",
+ "- Typically called a **fixture**\n",
+ "\n",
+ "- Use the `setUp` and `tearDown` methods for method-level fixtures\n",
+ "\n",
+ "### Silly fixture example"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "# test_gcd.py\n",
+ "import gcd\n",
+ "import unittest\n",
+ "\n",
+ "class TestGCD(unittest.TestCase):\n",
+ " def setUp(self):\n",
+ " print(\"setUp\")\n",
+ " def tearDown(self):\n",
+ " print(\"tearDown\")\n",
+ " def test_gcd_works_for_positive_integers(self):\n",
+ " self.assertEqual(gcd(48, 64), 16)\n",
+ " self.assertEqual(gcd(44, 19), 1)\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " unittest.main()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Exercise\n",
+ "\n",
+ "- Fix bug with negative numbers in gcd.py.\n",
+ "- Use TDD.\n",
+ "\n",
+ "\n",
+ "### Using hypothesis with unittest"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "# test_gcd.py\n",
+ "from hypothesis import given\n",
+ "from hypothesis import strategies as st\n",
+ "\n",
+ "import gcd\n",
+ "import unittest\n",
+ "\n",
+ "class TestGCD(unittest.TestCase):\n",
+ " @given(a=st.integers(min_value=0), b=st.integers(min_value=0))\n",
+ " def test_gcd_works_for_positive_integers(self, a, b):\n",
+ " result = gcd(a, b)\n",
+ " assert a%result == 0\n",
+ " assert b%result == 0\n",
+ " assert result <= a and result <= b\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " unittest.main()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Some notes on style\n",
+ "\n",
+ "- Use descriptive function names\n",
+ "- Intent matters\n",
+ "\n",
+ "- Segregate the test code into the following"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "- Given: what is the context of the test?\n",
+ "- When: what action is taken to actually test the problem\n",
+ "- Then: what do we actually ensure."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### More on intent driven programming\n",
+ "\n",
+ "- \"Programs must be written for people to read, and only incidentally for\n",
+ " machines to execute.” Harold Abelson\n",
+ "\n",
+ "- The code should make the intent clear.\n",
+ "\n",
+ "For example:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "if self.temperature > 600 and self.pressure > 10e5:\n",
+ " message = 'hello you have a problem here!'\n",
+ " message += 'current temp is %s'%(self.temperature)\n",
+ " print(message)\n",
+ " self.valve.close()\n",
+ " self.raise_warning()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "is totally unclear as to the intent. Instead refactor as follows:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "if self.reactor_is_critical():\n",
+ " self.shutdown_with_warning()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### A more involved testing example\n",
+ "\n",
+ "- Motivational problem:\n",
+ "\n",
+ "> Find all the git repositories inside a given directory recursively.\n",
+ "> Make this a command line tool supporting command line use.\n",
+ "\n",
+ "- Write tests for the code\n",
+ "- Some rules:\n",
+ "\n",
+ " 0. The test should be runnable by anyone (even by a computer), almost anywhere.\n",
+ " 1. Don't write anything in the current directory (use a temporary directory).\n",
+ " 2. Cleanup any files you create while testing.\n",
+ " 3. Make sure tests do not affect global state too much.\n",
+ "\n",
+ "\n",
+ "### Solution\n",
+ "\n",
+ "1. Create some test data.\n",
+ "2. Test!\n",
+ "3. Cleanup the test data\n",
+ "\n",
+ "\n",
+ "### Class-level fixtures\n",
+ "\n",
+ "- Use `setupClass` and `tearDownClass` classmethods for class level fixtures.\n",
+ "\n",
+ "\n",
+ "### Module-level fixtures\n",
+ "\n",
+ "- `setup_module`, `teardown_module`\n",
+ "- Can be used for a module-level fixture\n",
+ "\n",
+ "- http://nose.readthedocs.io/en/latest/writing_tests.html\n",
+ "\n",
+ "\n",
+ "## Coverage\n",
+ "\n",
+ "- Assess the amount of code that is covered by testing\n",
+ "- http://coverage.readthedocs.io/\n",
+ "- `pip install coverage`\n",
+ "- Integrates with nosetests/pytest\n",
+ "\n",
+ "### Typical coverage usage"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "$ coverage run -m nose.core my_package\n",
+ "$ coverage report -m\n",
+ "$ coverage html"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## mock\n",
+ "\n",
+ "- Mocking for advanced testing.\n",
+ "\n",
+ "- Example: reading some twitter data\n",
+ "- Example: function to post an update to facebook or twitter\n",
+ "- Example: email user when simulation crashes\n",
+ "\n",
+ "- Can you test it? How?\n",
+ "\n",
+ "### Using mock: the big picture\n",
+ "\n",
+ "- Do you really want to post something on facebook?\n",
+ "- Or do you want to know if the right method was called with the right arguments?\n",
+ "\n",
+ "- Idea: \"mock\" the objects that do something and test them\n",
+ "\n",
+ "- Quoting from the Python docs:\n",
+ "\n",
+ "> It allows you to replace parts of your system under test with mock objects\n",
+ "> and make assertions about how they have been used.\n",
+ "\n",
+ "### Installation\n",
+ "\n",
+ "- Built-in on Python >= 3.3"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "- `from unittest import mock`"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- else `pip install mock`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "- `import mock`\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Simple examples\n",
+ "\n",
+ "Say we have a class:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "class ProductionClass(object):\n",
+ " def method(self, *args):\n",
+ " # This does something we do not want to actually run in the test\n",
+ " # ...\n",
+ " pass"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "To mock the `ProductionClass.method` do this:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "from unittest.mock import MagicMock\n",
+ "thing = ProductionClass()\n",
+ "thing.method = MagicMock(return_value=3)\n",
+ "thing.method(3, 4, 5, key='value')\n",
+ "thing.method.assert_called_with(3, 4, 5, key='value')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### More practical use case\n",
+ "\n",
+ "- Mocking a module or system call\n",
+ "- Mocking an object or method\n",
+ "- Remember that after testing you want to restore original state\n",
+ "- Use `mock.patch`\n",
+ "\n",
+ "### An example\n",
+ "\n",
+ "- Write code to remove generated files from LaTeX compilation, i.e. remove the\n",
+ " *.aux, *.log, *.pdf etc.\n",
+ "\n",
+ "Here is a simple attempt:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "# clean_tex.py\n",
+ "import os\n",
+ "\n",
+ "def cleanup(tex_file_pth):\n",
+ " base = os.path.splitext(tex_file_pth)[0]\n",
+ " for ext in ('.aux', '.log'):\n",
+ " f = base + ext\n",
+ " if os.path.exists(f):\n",
+ " os.remove(f)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Testing this with mock"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "import mock\n",
+ "\n",
+ "@mock.patch('clean_tex.os.remove')\n",
+ "def test_cleanup_removes_extra_files(mock_remove):\n",
+ " cleanup('foo.tex')\n",
+ "\n",
+ " expected = [mock.call('foo.' + x) for x in ('aux', 'log')]\n",
+ "\n",
+ " mock_remove.assert_has_calls(expected)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Note the mocked argument that is passed.\n",
+ "- Note that we did not mock `os.remove`\n",
+ "- Mock where the object is looked up\n",
+ "\n",
+ "### Doing more"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "import mock\n",
+ "\n",
+ "@mock.patch('clean_tex.os.path')\n",
+ "@mock.patch('clean_tex.os.remove')\n",
+ "def test_cleanup_does_not_fail_when_files_dont_exist(mock_remove, mock_path):\n",
+ " # Setup the mock_path to return False\n",
+ " mock_path.exists.return_value = False\n",
+ "\n",
+ " cleanup('foo.tex')\n",
+ "\n",
+ " mock_remove.assert_not_called()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Note the order of the passed arguments\n",
+ "- Note the name of the method\n",
+ "\n",
+ "### Patching instance methods\n",
+ "\n",
+ "Use `mock.patch.object` to patch an instance method"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "@mock.patch.object(ProductionClass, 'method')\n",
+ "def test_method(mock_method):\n",
+ " obj = ProductionClass()\n",
+ " obj.method(1)\n",
+ "\n",
+ " mock_method.assert_called_once_with(1)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Mock works as a context manager:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "with mock.patch.object(ProductionClass, 'method') as mock_method:\n",
+ " obj = ProductionClass()\n",
+ " obj.method(1)\n",
+ "\n",
+ "mock_method.assert_called_once_with(1)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### More articles on mock\n",
+ "\n",
+ "- See more here https://docs.python.org/3/library/unittest.mock.html\n",
+ "- https://www.toptal.com/python/an-introduction-to-mocking-in-python\n",
+ "\n",
+ "\n",
+ "## Pytest\n",
+ "\n",
+ "Offers many useful and convenient features that are useful\n",
+ "\n",
+ "\n",
+ "## Odds and ends\n",
+ "\n",
+ "### Linters\n",
+ "\n",
+ "- `pyflakes`\n",
+ "- `flake8`\n",
+ "\n",
+ "### IPython goodies\n",
+ "\n",
+ "- Use `%run`\n",
+ "- Use `%pdb`\n",
+ "- `%debug`\n",
+ "\n",
+ "### Debugging\n",
+ "\n",
+ "- Debug with `%run`\n",
+ "- pdb.set_trace()\n",
+ "- IPython set trace:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "from IPython.core.debugger import Tracer; Tracer()()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- See here: http://www.scipy-lectures.org/advanced/debugging/"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Slideshow",
+ "kernelspec": {
+ "display_name": "Python 2",
+ "language": "python",
+ "name": "python2"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 2
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython2",
+ "version": "2.7.11"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
generated by cgit (git 2.34.1) at 2025-03-12 14:47:32 +0000