\documentclass{beamer}

\usetheme{Warsaw}

\title[Python Certificate: System Development]{System Development with Python: Week 1}

\author{Christopher Barker}

\institute{UW Continuing Education}

\date{March 26, 2013}

\usepackage{listings}

\usepackage{hyperref}

\begin{document}

\begin{frame}

\titlepage

\end{frame}

\begin{frame}

\frametitle{Table of Contents}

\tableofcontents

\end{frame}

\section{Class Overview}

\begin{frame}[fragile]{Class Structure}

{\Large

\begin{itemize}

\item Lecture

\item Labs

\item Summary

\item Project time

\end{itemize}

}

\end{frame}

\section{Testing}

\begin{frame}[fragile]{Testing}

{\Large I hope I don't need to tell you why testing is important}

{\Large I'll focus on testing your Python code -- not another system}

{\Large Mostly unit testing}

{\Large And an introduction to some of the tools}

\end{frame}

\begin{frame}[fragile]{Python Testing Taxonomy}

\begin{enumerate}

\item Unit Testing Tools

\item Mock Testing Tools

\item Fuzz Testing Tools

\item Web Testing Tools

\item Acceptance/Business Logic Testing Tools

\item GUI Testing Tools

\item Source Code Checking Tools

\item Code Coverage Tools

\item Continuous Integration Tools

\item Automatic Test Runners

\item Test Fixtures

\item Miscellaneous Python Testing Tools

\end{enumerate}

\url{http://wiki.python.org/moin/PythonTestingToolsTaxonomy}

\end{frame}

\begin{frame}[fragile]{Testing}

{\LARGE Regression Testing:}

{\Large Regression testing is any type of software testing that seeks to

uncover new software bugs, or regressions, in existing functional and

non-functional areas of a system after changes}

{\LARGE Unit Testing:}

{\Large Unit testing is a method by which individual units of source code,

sets of one or more computer program modules together with associated control

data, usage procedures, and operating procedures, are tested to determine if

they are fit for use}

\end{frame}

\begin{frame}[fragile]{doctest}

{\LARGEdoctest}

{\Large \vspace{0.3in} -- In the stdlib}

{\Large \vspace{0.3in} -- Unique to Python?}

{\Large \vspace{0.3in} -- Literate programming}

{\Large \vspace{0.3in} -- Verify examples in the docs}

\url{http://docs.python.org/library/doctest.html}

\end{frame}

\begin{frame}[fragile]{doctest example}

\begin{verbatim}

\end{verbatim}

(\verb|code/the_answer.py|)

{\Large An exact dump of the command line output}

\url{http://docs.python.org/library/doctest.html}

\end{frame}

\begin{frame}[fragile]{doctest uses}

{\large

}

\url{http://docs.python.org/library/doctest.html}

\end{frame}

\begin{frame}[fragile]{running doctests}

{\Large In \verb|__name__ == "__main__"| block:}

\begin{verbatim}

\end{verbatim}

{\large (Tests the current module) }

\url{http://docs.python.org/library/doctest.html}

\end{frame}

\begin{frame}[fragile]{running doctests}

{\Large In an external file:}

\begin{verbatim}

\end{verbatim}

{\large Tests the docs in the file (ReSt format...) }

{\large With a test runner: more on that later}

\end{frame}

\begin{frame}[fragile]{running doctests}

{\large In a documentation system:}

{\LARGE Sphinx:}

{\Large Sphinx is a tool that makes it easy to create intelligent and beautiful documentation}

{\Large -- Lots of output options: html, pdf, epub, etc, etc...}

{\Large -- Can auto-generate docs from docstrings}

{\Large -- And run the doctests}

\url{http://sphinx.pocoo.org/}

\end{frame}

\begin{frame}[fragile]{Code Checking}

{\LARGE Not Really testing, but...}

{\LARGE pychecker}\\

\url{http://pychecker.sourceforge.net/}

{\LARGE pylint}\\

\url{http://www.logilab.org/857/}

{\LARGE pyflakes}\\

\url{http://pypi.python.org/pypi/pyflakes}

{\Large Will help you keep your source code clean}

\end{frame}

\begin{frame}[fragile]{Coding Style}

{\Large Coding style really helps readability}

Keep it consistent within your project

{\Large Options:}

\begin{itemize}

\item Your company style guide

\item PEP 8 \\

\url{http://www.python.org/dev/peps/pep-0008/}

\item Another Established Style (Google's is pretty good) \\

\url{http://google-styleguide.googlecode.com/svn/trunk/pyguide.html}

\end{itemize}

\end{frame}

\begin{frame}[fragile]{Coding Style}

{\LARGE\verb|pep8.py|}

{\Large Tells you when you have code \\

that doesn't follow PEP 8}

{\large \verb| pip install pep8 | }

\url{http://pypi.python.org/pypi/pep8/}

\end{frame}

\begin{frame}[fragile]{LAB}

{\Large doctests:}

\begin{itemize}

\item doctest

\begin{itemize}

\item Add doctests to the Circle class in the code dir

\item Run it from the \verb|if __name__ == "__main__"| clause\\

(\verb|code\circle.py|)

\end{itemize}

\item Code style

\begin{itemize}

\item Try running \verb|pylint, pychecker or pyflakes| on it

\item Run pep8 on it

\item (or your own code)

\end{itemize}

\end{itemize}

\end{frame}

\section{Unit Testing}

\begin{frame}[fragile]{Unit Testing}

{\LARGE Gaining Traction}

{\Large You need to test your code when you write it -- why not preserve those tests?}

{\Large And allow you to auto-run them later?}

{\LARGE Test-Driven development:}\\[0.1in]

{\Large \hspace{0.3in} Write the tests before the code}

\end{frame}

\begin{frame}[fragile]{Unit Testing}

{\LARGE My thoughts:}

{\Large Unit testing encourages clean, decoupled design}

{\Large If it's hard to write unit tests for -- it's not well designed}

{\Large but...}

{\Large ``complete'' test coverage is a fantasy}

\end{frame}

\begin{frame}[fragile]{PyUnit}

{\LARGE PyUnit: the stdlib unit testing framework}

{\Large \verb|import unittest|}

{\Large More or less a port of Junit from Java}

{\Large A bit verbose: you have to write classes \& methods}

\end{frame}

\begin{frame}[fragile]{unittest example}

{\small

\begin{verbatim}

\end{verbatim}

}

\end{frame}

\begin{frame}[fragile]{unittest example (cont)}

{\small

\begin{verbatim}

\end{verbatim}

}

(\verb|code/unitest_example.py|)

\url{http://docs.python.org/library/unittest.html}

\end{frame}

\begin{frame}[fragile]{unittest}

{\Large Lots of good tutorials out there:}

{\Large Google: ``python unittest tutorial''}

{\Large I first learned from this one:}\\[0.1in]

\url{http://www.diveintopython.net/unit_testing/index.html}

\end{frame}

\begin{frame}[fragile]{nose and pytest}

{\Large Due to its Java heritage, unittest is kind of verbose}

{\Large Also no test discovery}\\

\hspace{0.2in}(though unittest2 does add that...)

{\Large So folks invented nose and pytest}

\end{frame}

\begin{frame}[fragile]{nose}

{\LARGE \verb|nose|}

{\Large \hspace{0.2in} Is nicer testing for python}

{\Large \hspace{0.2in} nose extends unittest to make testing easier.}

\begin{verbatim}

\end{verbatim}

\url{http://nose.readthedocs.org/en/latest/}

\end{frame}

\begin{frame}[fragile]{nose example}

{\Large The same example -- with nose}

{\small

\begin{verbatim}

\end{verbatim}

}

\end{frame}

\begin{frame}[fragile]{nose example (cont) }

{\small

\begin{verbatim}

\end{verbatim}

}

(\verb|code/test_random_nose.py|)

\end{frame}

\begin{frame}[fragile]{pytest}

{\LARGE \verb|pytest|}

{\Large \hspace{0.2in} A mature full-featured testing tool}

{\Large \hspace{0.2in} Provides no-boilerplate testing}

{\Large \hspace{0.2in} Integrates many common testing methods}

\begin{verbatim}

\end{verbatim}

\url{http://pytest.org/latest/}

\end{frame}

\begin{frame}[fragile]{pytest example}

{\Large The same example -- with pytest}

{\small

\begin{verbatim}

\end{verbatim}

}

\end{frame}

\begin{frame}[fragile]{pytest example (cont) }

{\small

\begin{verbatim}

\end{verbatim}

}

(\verb|code/test_random_pytest.py|)

\end{frame}

\begin{frame}[fragile]{A Diversion:}

{\LARGE Context Managers:} {\Large the \verb|with| statement}

{\Large A class with \verb|__enter__()| and \verb|__exit__()| methods.}

{\Large \verb|__enter__()| is run before your block of code}

{\Large \verb|__exit__()| is run after your block of code}

{\Large Can be used to setup/cleanup before and after: open/closing files, db connections, etc}

\end{frame}

\begin{frame}[fragile]{A Diversion }

{\Large ``PEP 343: the \verb|with| statement''} \\

\hspace{0.2in} -- A.M. Kuchling

\url{http://docs.python.org/dev/whatsnew/2.6.html#pep-343-the-with-statement}

{\Large ``Understanding Python's \verb|with| statement''} \\

\hspace{0.2in} -- Fredrik Lundh

\url{http://effbot.org/zone/python-with-statement.htm}

{\Large ``The Python \verb|with| Statement by Example''} \\

\hspace{0.2in} -- Jeff Preshing

\url{http://preshing.com/20110920/the-python-with-statement-by-example}

\end{frame}

\begin{frame}[fragile]{Parameterized Tests}

{\Large A whole set of inputs and outputs to test?}

{\Large \verb|pytest| has a nice way to do that (so does nose...)}

\begin{verbatim}

\end{verbatim}

\url{http://pytest.org/latest/example/parametrize.html}

(\verb|code/test_pytest_parameter.py|)

\end{frame}

\begin{frame}[fragile]{Test Coverage}

{\LARGE \verb|coverage.py |}

{\Large Uses debugging hook to see which lines of code are actually executed

-- plugins exist for most (all?) test runners}

{\Large \verb|pip install coverage |}

{\Large \verb|nosetests --with-coverage test_codingbat.py|}

\url{http://nedbatchelder.com/code/coverage/}

\end{frame}

\begin{frame}[fragile]{Coding Bat}

{\LARGE Coding Bat:}

\url{http://codingbat.com/python}

{\Large Quicky little code excercises}

{\Large Tells you what unit tests to write:}

\url{http://codingbat.com/prob/p118406}

{\Large We'll use them for our lab}

{\large ...and you might want to do a few for practice anyway...}

\end{frame}

\begin{frame}[fragile]{LAB}

{\Large Unit Testing:}

\begin{itemize}

\item unittest

\begin{itemize}

\item Pick a \url{codingbat.com} example

\item Write a set of unit tests using \verb|unittest|

(\verb|code\codingbat.py codingbat_unittest.py|)

\end{itemize}

\item pytest / nose

\begin{itemize}

\item Test a \url{codingbat.com} with nose or pytest

\item Try doing test-driven development

(\verb|code\test_codingbat.py|)

\end{itemize}

\item try running your circle doctest with nose, pytest\\

(and/or add doctests to your codingbat example)

\item try running \verb|coverage| on your tests

\end{itemize}

\end{frame}

\section{Packaging Your Stuff}

\begin{frame}[fragile]{Distributing}

{\LARGE What if you need to distribute you own code?}

{\Large Scripts}

{\Large Libraries }

{\Large Applications }

\end{frame}

\begin{frame}[fragile]{Scripts}

{\LARGE Often you can just copy, share, or check in the script to source

control and call it good.}

{\large (But only if it's a single file, and doesn't need anything non-standard) }

\end{frame}

\begin{frame}[fragile]{Scripts}

{\LARGE When the script needs more than just the stdlib (or your company standard environment)}

{\LARGE You have an application, not a script}

\end{frame}

\begin{frame}[fragile]{Libraries}

{\LARGE When you read the distutils docs, it's usually libraries they're talking about}

{\LARGE Scripts + library is the same...}

(\url{http://docs.python.org/distutils/})

\end{frame}

\begin{frame}[fragile]{distutils}

{\LARGE \verb|distutils| makes it easy to do the easy stuff:}

{\Large Distribute and install to multiple platforms, etc.}

{\Large Even binaries, installers and compiled packages}

{\Large (Except dependencies)}

(\url{http://docs.python.org/distutils/})

\end{frame}

\begin{frame}[fragile]{distutils basics}

{\Large It's all in the \verb|setup.py file|:}

\begin{verbatim}

\end{verbatim}

(\url{http://docs.python.org/distutils/})

\end{frame}

\begin{frame}[fragile]{distutils basics}

{\Large Once your setup.py is written, you can:}

\begin{verbatim}

\end{verbatim}

\end{frame}

\begin{frame}[fragile]{More Complex Packaging}

{\Large For a complex package:}

{\Large You want to use a well structured setup:}

\url{http://guide.python-distribute.org/creation.html}

\end{frame}

\begin{frame}[fragile]{Package Structure}

\begin{verbatim}

\end{verbatim}

\end{frame}

\begin{frame}[fragile]{develop mode}

{\Large While you are developing your package, Installing it is a pain.}

{\Large But you want your code to be able to import, etc. as though it were installed.}

{\Large \verb|setup.py develop|

installs links to your code, rather than copies

-- so it looks like it's installed, but it's using the original source}

{\Large You need \verb|distribute| (or \verb|setuptools|) to use it.}

\end{frame}

\begin{frame}[fragile]{Applications}

{\Large For a complete application:}

\begin{itemize}

\item Web apps

\item GUI apps

\end{itemize}

{\Large Multiple options:}

\begin{itemize}

\item Virtualenv + RCS

\item zc.buildout ( \url{http://www.buildout.org/} )

\item System packages (rpm, deb, ...)

\item Bundles...

\end{itemize}

\end{frame}

\begin{frame}[fragile]{Bundles}

{\Large

Bundles are Python + all your code + plus all the dependencies --

all in one single ``bundle''

Most popular on Windows and OS-X

}

\begin{verbatim}

\end{verbatim}

{\Large User doesn't even have to know it's python }

Examples: \\

\hspace{0.5in} \url{http://www.bitpim.org/} \\

\hspace{0.5in} \url{http://response.restoration.noaa.gov/nucos}

\end{frame}

\begin{frame}[fragile]{Wrap up}

{\Large Hopefully you've got a bit of an idea how to do\\[0.1in]

unit testing in Python.}

{\Large And will now start doing it.}

{\Large And an idea how to set up your package...}

\end{frame}

\begin{frame}[fragile]{Next Week:}

{\LARGE The python debugger pdb}

{\Large -- Jeff}

{\Large And of course, your projects...}

\end{frame}

\begin{frame}[fragile]{Homework}

For the entire quarter, your homework is to work on your projects

For next week:

\begin{itemize}

\item Set up the package structure

\item Put it in gitHub (or some RCS)

\item Map out the design