Preface
Why I Wrote a Book About Test-Driven Development
Aims of This Book
Outline
Conventions Used in This Book
Submitting Errata
Using Code Examples
O’Reilly Safari
Contacting O’Reilly
Prerequisites and Assumptions
Python 3 and Programming
How HTML Works
Django
JavaScript
Required Software Installations
Setting Up Your Virtualenv
Companion Video
Acknowledgments
I. The Basics of TDD and Django
1. Getting Django Set Up Using a Functional Test
Obey the Testing Goat! Do Nothing Until You Have a Test
Getting Django Up and Running
Starting a Git Repository
2. Extending Our Functional Test Using the unittest Module
Using a Functional Test to Scope Out a Minimum Viable App
The Python Standard Library’s unittest Module
Commit
3. Testing a Simple Home Page with Unit Tests
Our First Django App, and Our First Unit Test
Unit Tests, and How They Differ from Functional Tests
Unit Testing in Django
Django’s MVC, URLs, and View Functions
At Last! We Actually Write Some Application Code!
urls.py
Unit Testing a View
4. What Are We Doing with All These Tests? (And, Refactoring)
Programming Is Like Pulling a Bucket of Water Up from a Well
Using Selenium to Test User Interactions
The “Don’t Test Constants” Rule, and Templates to the Rescue
Refactoring to Use a Template
The Django Test Client
On Refactoring
A Little More of Our Front Page
Recap: The TDD Process
5. Saving User Input: Testing the Database
Wiring Up Our Form to Send a POST Request
Processing a POST Request on the Server
Passing Python Variables to Be Rendered in the Template
Three Strikes and Refactor
The Django ORM and Our First Model
Saving the POST to the Database
Redirect After a POST
Rendering Items in the Template
Creating Our Production Database with migrate
Recap
6. Improving Functional Tests: Ensuring Isolation and Removing Voodoo Sleeps
Ensuring Test Isolation in Functional Tests
Aside: Upgrading Selenium and Geckodriver
On Implicit and Explicit Waits, and Voodoo time.sleeps
7. Working Incrementally
Small Design When Necessary
Implementing the New Design Incrementally Using TDD
Ensuring We Have a Regression Test
Iterating Towards the New Design
Taking a First, Self-Contained Step: One New URL
Green? Refactor
Another Small Step: A Separate Template for Viewing Lists
A Third Small Step: A URL for Adding List Items
Biting the Bullet: Adjusting Our Models
Each List Should Have Its Own URL
The Functional Tests Detect Another Regression
One More View to Handle Adding Items to an Existing List
A Final Refactor Using URL includes
II. Web Development Sine Qua Nons
8. Prettification: Layout and Styling, and What to Test About It
What to Functionally Test About Layout and Style
Prettification: Using a CSS Framework
Django Template Inheritance
Integrating Bootstrap
Static Files in Django
Using Bootstrap Components to Improve the Look of the Site
Using Our Own CSS
What We Glossed Over: collectstatic and Other Static Directories
A Few Things That Didn’t Make It
9. Testing Deployment Using a Staging Site
TDD and the Danger Areas of Deployment
As Always, Start with a Test
Getting a Domain Name
Manually Provisioning a Server to Host Our Site
Deploying Our Code Manually
Adjusting the Database Location
Creating a Virtualenv Manually, and Using requirements.txt
Simple Nginx Configuration
Creating the Database with migrate
Success! Our Hack Deployment Works
10. Getting to a Production-Ready Deployment
Switching to Gunicorn
Getting Nginx to Serve Static Files
Switching to Using Unix Sockets
Switching DEBUG to False and Setting ALLOWED_HOSTS
Using Systemd to Make Sure Gunicorn Starts on Boot
Thinking About Automating
Saving Our Progress
11. Automating Deployment with Fabric
Breakdown of a Fabric Script for Our Deployment
Trying It Out
Deploying to Live
Nginx and Gunicorn Config Using sed
Git Tag the Release
Further Reading
12. Splitting Our Tests into Multiple Files, and a Generic Wait Helper
Start on a Validation FT: Preventing Blank Items
Skipping a Test
Splitting Functional Tests Out into Many Files
Running a Single Test File
A New Functional Test Tool: A Generic Explicit Wait Helper
Finishing Off the FT
Refactoring Unit Tests into Several Files
13. Validation at the Database Layer
Model-Layer Validation
Surfacing Model Validation Errors in the View
Django Pattern: Processing POST Requests in the Same View as Renders the Form
Refactor: Removing Hardcoded URLs
14. A Simple Form
Moving Validation Logic into a Form
Exploring the Forms API with a Unit Test
Switching to a Django ModelForm
Testing and Customising Form Validation
Using the Form in Our Views
Using the Form in a View That Takes POST Requests
Using the Form in the Other View
A Pat on the Back
But Have We Wasted a Lot of Time?
Using the Form’s Own Save Method
15. More Advanced Forms
Another FT for Duplicate Items
Preventing Duplicates at the Model Layer
A Little Digression on Queryset Ordering and String Representations
Rewriting the Old Model Test
Some Integrity Errors Do Show Up on Save
Experimenting with Duplicate Item Validation at the Views Layer
A More Complex Form to Handle Uniqueness Validation
Using the Existing List Item Form in the List View
Wrapping Up: What We’ve Learned About Testing Django
16. Dipping Our Toes, Very Tentatively, into JavaScript
Starting with an FT
Setting Up a Basic JavaScript Test Runner
Using jQuery and the Fixtures Div
Building a JavaScript Unit Test for Our Desired Functionality
Fixtures, Execution Order, and Global State: Key Challenges of JS Testing
Columbo Says: Onload Boilerplate and Namespacing
JavaScript Testing in the TDD Cycle
A Few Things That Didn’t Make It
17. Deploying Our New Code
III. More Advanced Topics in Testing
18. User Authentication, Spiking, and De-Spiking
Passwordless Auth
Exploratory Coding, aka “Spiking”
Starting a Branch for the Spike
Frontend Log in UI
Sending Emails from Django
Using Environment Variables to Avoid Secrets in Source Code
Storing Tokens in the Database
Custom Authentication Models
Finishing the Custom Django Auth
De-spiking
A Minimal Custom User Model
A Token Model to Link Emails with a Unique ID
19. Using Mocks to Test External Dependencies or Reduce Duplication
Before We Start: Getting the Basic Plumbing In
Mocking Manually, aka Monkeypatching
The Python Mock Library
Using unittest.patch
Getting the FT a Little Further Along
Testing the Django Messages Framework
Adding Messages to Our HTML
Starting on the Login URL
Checking That We Send the User a Link with a Token
De-spiking Our Custom Authentication Backend
1 if = 1 More Test
The get_user Method
Using Our Auth Backend in the Login View
An Alternative Reason to Use Mocks: Reducing Duplication
The Moment of Truth: Will the FT Pass?
It Works in Theory! Does It Work in Practice?
Finishing Off Our FT, Testing Logout
20. Test Fixtures and a Decorator for Explicit Waits
Skipping the Login Process by Pre-creating a Session
Our Final Explicit Wait Helper: A Wait Decorator
21. Server-Side Debugging
The Proof Is in the Pudding: Using Staging to Catch Final Bugs
Setting Secret Environment Variables on the Server
Adapting Our FT to Be Able to Test Real Emails via POP3
Managing the Test Database on Staging
A Django Management Command to Create Sessions
Getting the FT to Run the Management Command on the Server
Using Fabric Directly from Python
Recap: Creating Sessions Locally Versus Staging
Baking In Our Logging Code
Wrap-Up
22. Finishing “My Lists”: Outside-In TDD
The Alternative: “Inside-Out”
Why Prefer “Outside-In”?
The FT for “My Lists”
The Outside Layer: Presentation and Templates
Moving Down One Layer to View Functions (the Controller)
Another Pass, Outside-In
The Next “Requirement” from the Views Layer: New Lists Should Record Owner
Moving Down to the Model Layer
23. Test Isolation, and “Listening to Your Tests”
Revisiting Our Decision Point: The Views Layer Depends on Unwritten Models Code
A First Attempt at Using Mocks for Isolation
Listen to Your Tests: Ugly Tests Signal a Need to Refactor
Rewriting Our Tests for the View to Be Fully Isolated
Keep the Old Integrated Test Suite Around as a Sanity Check
A New Test Suite with Full Isolation
Thinking in Terms of Collaborators
Moving Down to the Forms Layer
Finally, Moving Down to the Models Layer
The Moment of Truth (and the Risks of Mocking)
Thinking of Interactions Between Layers as “Contracts”
One More Test
Tidy Up: What to Keep from Our Integrated Test Suite
Conclusions: When to Write Isolated Versus Integrated Tests
24. Continuous Integration (CI)
Installing Jenkins
Configuring Jenkins
Setting Up Our Project
First Build!
Setting Up a Virtual Display So the FTs Can Run Headless
Taking Screenshots
If in Doubt, Try Bumping the Timeout!
Running Our QUnit JavaScript Tests in Jenkins with PhantomJS
More Things to Do with a CI Server
25. The Token Social Bit, the Page Pattern, and an Exercise for the Reader
An FT with Multiple Users, and addCleanup
The Page Pattern
Extend the FT to a Second User, and the “My Lists” Page
An Exercise for the Reader
26. Fast Tests, Slow Tests, and Hot Lava
Thesis: Unit Tests Are Superfast and Good Besides That
The Problems with “Pure” Unit Tests
Synthesis: What Do We Want from Our Tests, Anyway?
Architectural Solutions
Conclusion
Obey the Testing Goat!
A. PythonAnywhere
B. Django Class-Based Views
Class-Based Generic Views
The Home Page as a FormView
Using form_valid to Customise a CreateView
A More Complex View to Handle Both Viewing and Adding to a List
Compare Old and New
Best Practices for Unit Testing CBGVs?
C. Provisioning with Ansible
D. Testing Database Migrations
E. Behaviour-Driven Development (BDD)
What Is BDD?
Basic Housekeeping
Writing an FT as a “Feature” Using Gherkin Syntax
Coding the Step Functions
First Step Definition
setUp and tearDown Equivalents in environment.py
Another Run
Capturing Parameters in Steps
Comparing the Inline-Style FT
BDD Encourages Structured Test Code
The Page Pattern as an Alternative
BDD Might Be Less Expressive than Inline Comments
Will Nonprogrammers Write Tests?
Some Tentative Conclusions
F. Building a REST API: JSON, Ajax, and Mocking with JavaScript
Our Approach for This Appendix
Choosing Our Test Approach
Basic Piping
Actually Responding with Something
Adding POST
Testing the Client-Side Ajax with Sinon.js
Wiring It All Up in the Template to See If It Really Works
Implementing Ajax POST, Including the CSRF Token
Mocking in JavaScript
Data Validation: An Exercise for the Reader?
G. Django-Rest-Framework
Installation
Serializers (Well, ModelSerializers, Really)
Viewsets (Well, ModelViewsets, Really) and Routers
A Different URL for POST Item
Adapting the Client Side
What Django-Rest-Framework Gives You
H. Cheat Sheet
I. What to Do Next
J. Source Code Examples
Bibliography
Index
· · · · · · (
收起)
