
Development Tools
*****************

The modules described in this chapter help you write software.  For
example, the ``pydoc`` module takes a module and generates
documentation based on the module's contents.  The ``doctest`` and
``unittest`` modules contains frameworks for writing unit tests that
automatically exercise code and verify that the expected output is
produced.  **2to3** can translate Python 2.x source code into valid
Python 3.x code.

The list of modules described in this chapter is:

* ``pydoc`` --- Documentation generator and online help system
* ``doctest`` --- Test interactive Python examples
  * Simple Usage: Checking Examples in Docstrings
  * Simple Usage: Checking Examples in a Text File
  * How It Works
    * Which Docstrings Are Examined?
    * How are Docstring Examples Recognized?
    * What's the Execution Context?
    * What About Exceptions?
    * Option Flags
    * Directives
    * Warnings
  * Basic API
  * Unittest API
  * Advanced API
    * DocTest Objects
    * Example Objects
    * DocTestFinder objects
    * DocTestParser objects
    * DocTestRunner objects
    * OutputChecker objects
  * Debugging
  * Soapbox
* ``unittest`` --- Unit testing framework
  * Basic example
  * Command-Line Interface
    * Command-line options
  * Test Discovery
  * Organizing test code
  * Re-using old test code
  * Skipping tests and expected failures
  * Classes and functions
    * Test cases
      * Deprecated aliases
    * Grouping tests
    * Loading and running tests
      * load_tests Protocol
  * Class and Module Fixtures
    * setUpClass and tearDownClass
    * setUpModule and tearDownModule
  * Signal Handling
* ``unittest.mock`` --- mock object library
  * Quick Guide
  * The Mock Class
    * Calling
    * Deleting Attributes
    * Mock names and the name attribute
    * Attaching Mocks as Attributes
  * The patchers
    * patch
    * patch.object
    * patch.dict
    * patch.multiple
    * patch methods: start and stop
    * TEST_PREFIX
    * Nesting Patch Decorators
    * Where to patch
    * Patching Descriptors and Proxy Objects
  * MagicMock and magic method support
    * Mocking Magic Methods
    * Magic Mock
  * Helpers
    * sentinel
    * DEFAULT
    * call
    * create_autospec
    * ANY
    * FILTER_DIR
    * mock_open
    * Autospeccing
* ``unittest.mock`` --- getting started
  * Using Mock
    * Mock Patching Methods
    * Mock for Method Calls on an Object
    * Mocking Classes
    * Naming your mocks
    * Tracking all Calls
    * Setting Return Values and Attributes
    * Raising exceptions with mocks
    * Side effect functions and iterables
    * Creating a Mock from an Existing Object
  * Patch Decorators
  * Further Examples
    * Mocking chained calls
    * Partial mocking
    * Mocking a Generator Method
    * Applying the same patch to every test method
    * Mocking Unbound Methods
    * Checking multiple calls with mock
    * Coping with mutable arguments
    * Nesting Patches
    * Mocking a dictionary with MagicMock
    * Mock subclasses and their attributes
    * Mocking imports with patch.dict
    * Tracking order of calls and less verbose call assertions
    * More complex argument matching
* 2to3 - Automated Python 2 to 3 code translation
  * Using 2to3
  * Fixers
  * ``lib2to3`` - 2to3's library
* ``test`` --- Regression tests package for Python
  * Writing Unit Tests for the ``test`` package
  * Running tests using the command-line interface
* ``test.support`` --- Utilities for the Python test suite
* ``venv`` --- Creation of virtual environments
  * Creating virtual environments
  * API
  * An example of extending ``EnvBuilder``