4. Using Mock Objects to Test Interactions | Test Driven Python Development

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Test Driven Python Development

By : Siddharta Govindaraj

4.4 (5)

Test Driven Python Development

4.4 (5)

By: Siddharta Govindaraj

Overview of this book

This book starts with a look at the test-driven development process, and how it is different from the traditional way of writing code. All the concepts are presented in the context of a real application that is developed in a step-by-step manner over the course of the book. While exploring the common types of smelly code, we will go back into our example project and clean up the smells that we find. Additionally, we will use mocking to implement the parts of our example project that depend on other systems. Towards the end of the book, we'll take a look at the most common patterns and anti-patterns associated with test-driven development, including integration of test results into the development process.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Getting Started with Test-Driven Development

1. Getting Started with Test-Driven Development

Prerequisites

Understanding test-driven development

Using TDD to build a stock alert application

Reorganizing the test code

Summary

2. Red-Green-Refactor – The TDD Cycle

2. Red-Green-Refactor – The TDD Cycle

Tests are executable requirements

Arrange-Act-Assert

Documenting our tests

Testing for exceptions

Exploring assert methods

Specific asserts versus generic asserts

Setup and teardown

Brittle tests

Refactoring the design

Refactoring tests

Exploring the Rule classes

Exercise

Summary

3. Code Smells and Refactoring

3. Code Smells and Refactoring

A dual crossover moving average

Implementing the dual crossover moving average

Identifying code smells

Refactoring

The importance of tests

Exercise

Wrapping up

Summary

4. Using Mock Objects to Test Interactions

4. Using Mock Objects to Test Interactions

Hand writing a simple mock

Using the Python mocking framework

Tying it all together

Summary

5. Working with Legacy Code

5. Working with Legacy Code

What is legacy code?

Understanding the code

Techniques to break dependencies

The cycle continues

Time to refactor

Summary

6. Maintaining Your Test Suite

6. Maintaining Your Test Suite

Goals of test maintenance

Organizing tests

Making tests readable

Writing tests closer to the domain

Summary

7. Executable Documentation with doctest

7. Executable Documentation with doctest

Our first doctest

Test failures

Testing for exceptions

Package-level doctests

Maintaining doctests

Limitations of doctest

How do doctests fit into the TDD process?

Summary

8. Extending unittest with nose2

8. Extending unittest with nose2

Getting started with nose2

Writing tests for nose2

nose2 plugins

Summary

9. Unit Testing Patterns

9. Unit Testing Patterns

Pattern – fast tests

Pattern – running a subset of tests

Pattern – using attributes

Pattern – expected failures

Pattern – data-driven tests

Pattern – integration and system tests

Pattern – spies

Summary

10. Tools to Improve Test-Driven Development

10. Tools to Improve Test-Driven Development

TDD tools

Integrating with build tools

Integrating with packaging tools

Distutils

Integrating with continuous integration tools

Other tools

IDE integration

Summary

A. Answers to Exercises

A. Answers to Exercises

Red-Green-Refactor – The TDD Cycle

Code Smells and Refactoring

B. Working with Older Python Versions

B. Working with Older Python Versions

Writing code that is compatible across versions

Running tests from the command line

Running the examples in this book

Index

Index

Hand writing a simple mock

To start with, let us look at the code for the Event class so that we can understand what the tests need to do. The following code is in the file event.py in the source directory:

class Event:
    """A generic class that provides signal/slot functionality"""

    def __init__(self):
        self.listeners = []

    def connect(self, listener):
        self.listeners.append(listener)

    def fire(self, *args, **kwargs):
        for listener in self.listeners:
            listener(*args, **kwargs)

The way this code works is fairly simple. Classes that want to get notified of the event should call the connect method and pass a function. This will register the function for the event. Then, when the event is fired using the fire method, all the registered functions will be notified of the event. The following is a walk-through of how this class is used:

>>> def handle_event(num):
...   print("I got number {0}".format(num))
...
>>> event = Event()
&gt...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Test Driven Python Development

Search

Your notes and bookmarks