Home Page Icon
Home Page
Table of Contents for
Index
Close
Index
by Harry J.W. Percival
Test-Driven Development with Python
Praise for Test-Driven Development with Python
Preface
Why I Wrote a Book About Test-Driven Development
Aims of This Book
Outline
Conventions Used in This Book
Using Code Examples
Safari® Books Online
Contacting O’Reilly
Prerequisites and Assumptions
Python 3 and Programming
How HTML Works
JavaScript
Required Software Installations
Git’s Default Editor, and Other Basic Git Config
Required Python Packages
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
Implicit waits
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
The Unit-Test/Code Cycle
4. What Are We Doing with All These Tests?
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
On Refactoring
A Little More of Our Front Page
Recap: The TDD Process
5. Saving User Input
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
Our First Database Migration
The Test Gets Surprisingly Far
A New Field Means a New Migration
Saving the POST to the Database
Redirect After a POST
Better Unit Testing Practice: Each Test Should Test One Thing
Rendering Items in the Template
Creating Our Production Database with migrate
6. Getting to the Minimum Viable Site
Ensuring Test Isolation in Functional Tests
Running Just the Unit Tests
Small Design When Necessary
YAGNI!
REST
Implementing the New Design Using TDD
Iterating Towards the New Design
Testing Views, Templates, and URLs Together with the Django Test Client
A New Test Class
A New URL
A New View Function
Green? Refactor
A Separate Template for Viewing Lists
Another URL and View for Adding List Items
A Test Class for New List Creation
A URL and View for New List Creation
Removing Now-Redundant Code and Tests
Pointing Our Forms at the New URL
Adjusting Our Models
A Foreign Key Relationship
Adjusting the Rest of the World to Our New Models
Each List Should Have Its Own URL
Capturing Parameters from URLs
Adjusting new_list to the New World
One More View to Handle Adding Items to an Existing List
Beware of Greedy Regular Expressions!
The Last New URL
The Last New View
But How to Use That URL in the Form?
A Final Refactor Using URL includes
II. Web Development Sine Qua Nons
7. 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
Rows and Columns
Static Files in Django
Switching to StaticLiveServerTestCase
Using Bootstrap Components to Improve the Look of the Site
Jumbotron!
Large Inputs
Table Styling
Using Our Own CSS
What We Glossed Over: collectstatic and Other Static Directories
A Few Things That Didn’t Make It
8. 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
Choosing Where to Host Our Site
Spinning Up a Server
User Accounts, SSH, and Privileges
Installing Nginx
Configuring Domains for Staging and Live
Using the FT to Confirm the Domain Works and Nginx Is Running
Deploying Our Code Manually
Adjusting the Database Location
Creating a Virtualenv
Simple Nginx Configuration
Creating the Database with migrate
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 Upstart to Make Sure Gunicorn Starts on Boot
Saving Our Changes: Adding Gunicorn to Our requirements.txt
Automating
“Saving Your Progress”
9. 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
10. Input Validation and Test Organisation
Validation FT: Preventing Blank Items
Skipping a Test
Splitting Functional Tests out into Many Files
Running a Single Test File
Fleshing Out the FT
Using Model-Layer Validation
Refactoring Unit Tests into Several Files
Unit Testing Model Validation and the self.assertRaises Context Manager
A Django Quirk: Model Save Doesn’t Run Validation
Surfacing Model Validation Errors in the View
Checking Invalid Input Isn’t Saved to the Database
Django Pattern: Processing POST Requests in the Same View as Renders the Form
Refactor: Transferring the new_item Functionality into view_list
Enforcing Model Validation in view_list
Refactor: Removing Hardcoded URLs
The {% url %} Template Tag
Using get_absolute_url for Redirects
11. 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 with a GET Request
A Big Find and Replace
Using the Form in a View That Takes POST Requests
Adapting the Unit Tests for the new_list View
Using the Form in the View
Using the Form to Display Errors in the Template
Using the Form in the Other View
A Helper Method for Several Short Tests
Using the Form’s Own Save Method
12. 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
13. 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
Javascript Testing in the TDD Cycle
Columbo Says: Onload Boilerplate and Namespacing
A Few Things That Didn’t Make It
14. Deploying Our New Code
Staging Deploy
Live Deploy
What to Do If You See a Database Error
Wrap-Up: git tag the New Release
III. More Advanced Topics
15. User Authentication, Integrating Third-Party Plugins, and Mocking with JavaScript
Mozilla Persona (BrowserID)
Exploratory Coding, aka “Spiking”
Starting a Branch for the Spike
Frontend and JavaScript Code
The Browser-ID Protocol
The Server Side: Custom Authentication
De-spiking
A Common Selenium Technique: Explicit Waits
Reverting Our Spiked Code
JavaScript Unit Tests Involving External Components: Our First Mocks!
Housekeeping: A Site-Wide Static Files Folder
Mocking: Who, Why, What?
Namespacing
A Simple Mock to Unit Tests Our initialize Function
More Advanced Mocking
Using a sinon.js mock to check we call the API correctly
Checking Call Arguments
QUnit setup and teardown, Testing Ajax
Logout
More Nested Callbacks! Testing Asynchronous Code
16. Server-Side Authentication and Mocking in Python
A Look at Our Spiked Login View
Mocking in Python
Testing Our View by Mocking Out authenticate
Checking the View Actually Logs the User In
De-spiking Our Custom Authentication Backend: Mocking Out an Internet Request
1 if = 1 More Test
Patching at the Class Level
Beware of Mocks in Boolean Comparisons
Creating a User if Necessary
The get_user Method
A Minimal Custom User Model
A Slight Disappointment
Tests as Documentation
Users Are Authenticated
The Moment of Truth: Will the FT Pass?
Finishing Off Our FT, Testing Logout
17. Test Fixtures, Logging, and Server-Side Debugging
Skipping the Login Process by Pre-creating a Session
Checking It Works
The Proof Is in the Pudding: Using Staging to Catch Final Bugs
Setting Up Logging
Fixing the Persona Bug
Managing the Test Database on Staging
A Django Management Command to Create Sessions
Getting the FT to Run the Management Command on the Server
An Additional Hop via subprocess
Baking In Our Logging Code
Using Hierarchical Logging Config
Wrap-Up
18. 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
A Quick Restructure of the Template Inheritance Hierarchy
Designing Our API Using the Template
Moving Down to the Next Layer: What the View Passes to the Template
The Next “Requirement” from the Views Layer: New Lists Should Record Owner
A Decision Point: Whether to Proceed to the Next Layer with a Failing Test
Moving Down to the Model Layer
Final Step: Feeding Through the .name API from the Template
19. 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
Using Mock side_effects to Check the Sequence of Events
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
Keep Listening to Your Tests: Removing ORM Code from Our Application
Finally, Moving Down to the Models Layer
Back to Views
The Moment of Truth (and the Risks of Mocking)
Thinking of Interactions Between Layers as “Contracts”
Identifying Implicit Contracts
Fixing the Oversight
One More Test
Tidy Up: What to Keep from Our Integrated Test Suite
Removing Redundant Code at the Forms Layer
Removing the Old Implementation of the View
Removing Redundant Code at the Forms Layer
Conclusions: When to Write Isolated Versus Integrated Tests
Let Complexity Be Your Guide
Should You Do Both?
Onwards!
20. Continuous Integration (CI)
Installing Jenkins
Configuring Jenkins Security
Adding Required Plugins
Telling Jenkins where to find Python 3 and Xvfb
Setting Up Our Project
First Build!
Setting Up a Virtual Display so the FTs Can Run Headless
Taking Screenshots
A Common Selenium Problem: Race Conditions
Running Our QUnit JavaScript Tests in Jenkins with PhantomJS
Installing node
Adding the Build Steps to Jenkins
More Things to Do with a CI Server
21. The Token Social Bit, the Page Pattern, and an Exercise for the Reader
An FT with Multiple Users, and addCleanup
Implementing the Selenium Interact/Wait Pattern
The Page Pattern
Extend the FT to a Second User, and the “My Lists” Page
An Exercise for the Reader
22. Fast Tests, Slow Tests, and Hot Lava
Thesis: Unit Tests Are Superfast and Good Besides That
Faster Tests Mean Faster Development
The Holy Flow State
Slow Tests Don’t Get Run as Often, Which Causes Bad Code
We’re Fine Now, but Integrated Tests Get Slower Over Time
Don’t Take It from Me
And Unit Tests Drive Good Design
The Problems with “Pure” Unit Tests
Isolated Tests Can Be Harder to Read and Write
Isolated Tests Don’t Automatically Test Integration
Unit Tests Seldom Catch Unexpected Bugs
Mocky Tests Can Become Closely Tied to Implementation
But All These Problems Can Be Overcome
Synthesis: What Do We Want from Our Tests, Anyway?
Correctness
Clean, Maintainable Code
Productive Workflow
Evaluate Your Tests Against the Benefits You Want from Them
Architectural Solutions
Ports and Adapters/Hexagonal/Clean Architecture
Functional Core, Imperative Shell
Conclusion
Obey the Testing Goat!
Testing Is Hard
Keep Your CI Builds Green
Take Pride in Your Tests, as You Do in Your Code
Remember to Tip the Bar Staff
Don’t Be a Stranger!
A. PythonAnywhere
Running Firefox Selenium Sessions with Xvfb
Setting Up Django as a PythonAnywhere Web App
Cleaning Up /tmp
Screenshots
The Deployment Chapter
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
The Tests Guide Us, for a While
Until We’re Left with Trial and Error
Back on Track
Is That Your Final Answer?
Compare Old and New
Best Practices for Unit Testing CBGVs?
Take-Home: Having Multiple, Isolated View Tests with Single Assertions Helps
C. Provisioning with Ansible
Installing System Packages and Nginx
Configuring Gunicorn, and Using Handlers to Restart Services
What to Do Next
Move Deployment out of Fabric and into Ansible
Use Vagrant to Spin Up a Local VM
D. Testing Database Migrations
An Attempted Deploy to Staging
Running a Test Migration Locally
Entering Problematic Data
Copying Test Data from the Live Site
Confirming the Error
Inserting a Data Migration
Re-creating the Old Migration
Testing the New Migrations Together
Conclusions
E. What to Do Next
Notifications—Both on the Site and by Email
Switch to Postgres
Run Your Tests Against Different Browsers
404 and 500 Tests
The Django Admin Site
Investigate a BDD Tool
Write Some Security Tests
Test for Graceful Degradation
Caching and Performance Testing
JavaScript MVC Frameworks
Async and Websockets
Switch to Using py.test
Client-Side Encryption
Your Suggestion Here
F. Cheat Sheet
Initial Project Setup
The Basic TDD Workflow
Moving Beyond dev-only Testing
General Testing Best Practices
Selenium/Functional Testing Best Practices
Outside-In, Test Isolation Versus Integrated Tests, and Mocking
G. Bibliography
Index
Colophon
Copyright
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
G. Bibliography
Next
Next Chapter
Colophon
Index
A
acceptance test (see functional tests/testing (FT))
acceptance tests,
Fast Tests, Slow Tests, and Hot Lava
aesthetics (see layout and style)
agile movement in software development,
Small Design When Necessary
Ajax,
The Server Side: Custom Authentication
,
QUnit setup and teardown, Testing Ajax
ALLOWED_HOSTS,
Switching DEBUG to False and Setting ALLOWED_HOSTS
Anderson, Ross,
Wiring Up Our Form to Send a POST Request
Ansible,
Further Reading
,
Provisioning with Ansible
–
Move Deployment out of Fabric and into Ansible
any function,
Using Selenium to Test User Interactions
,
A Little More of Our Front Page
architectural solutions to test problems,
Architectural Solutions
assertion messages,
The Python Standard Library’s unittest Module
,
The Python Standard Library’s unittest Module
,
Passing Python Variables to Be Rendered in the Template
,
A Simple Mock to Unit Tests Our initialize Function
AssertionError,
A Little More of Our Front Page
assertRegex,
Implementing the New Design Using TDD
assertTemplateUsed,
A Separate Template for Viewing Lists
assertTrue,
A Little More of Our Front Page
asynchronous JavaScript,
More Nested Callbacks! Testing Asynchronous Code
–
More Nested Callbacks! Testing Asynchronous Code
authentication,
User Authentication, Integrating Third-Party Plugins, and Mocking with JavaScript
backend,
De-spiking Our Custom Authentication Backend: Mocking Out an Internet Request
–
The get_user Method
customising,
The Server Side: Custom Authentication
–
The Server Side: Custom Authentication
,
A Look at Our Spiked Login View
in Django,
Checking the View Actually Logs the User In
login view,
Checking the View Actually Logs the User In
–
Checking the View Actually Logs the User In
minimum custom user model,
A Minimal Custom User Model
–
Users Are Authenticated
mocking (see mocks/mocking)
Mozilla Persona,
Mozilla Persona (BrowserID)
pre-authentication,
Skipping the Login Process by Pre-creating a Session
–
Checking It Works
testing logout,
Finishing Off Our FT, Testing Logout
testing view,
Testing Our View by Mocking Out authenticate
tests as documentation,
Tests as Documentation
automation, in deployment,
TDD and the Danger Areas of Deployment
,
Automating Deployment with Fabric
–
Further Reading
(see also deployment)
automation, in provisioning,
Further Reading
B
Bash,
Adjusting the Database Location
Beck, Kent,
Programming Is like Pulling a Bucket of Water up from a Well
,
On Refactoring
Behavior-Driven Development (BDD) tools,
Investigate a BDD Tool
Bernhardt, Gary,
Test Isolation, and “Listening to Your Tests”
,
Don’t Take It from Me
,
Functional Core, Imperative Shell
best practices in testing,
Fast Tests, Slow Tests, and Hot Lava
Big Design Up Front,
Small Design When Necessary
black box test (see functional tests/testing (FT))
Bootstrap,
Prettification: Using a CSS Framework
–
Using Our Own CSS
jumbotron,
Jumbotron!
large inputs,
Large Inputs
table styling,
Table Styling
boundaries,
Ports and Adapters/Hexagonal/Clean Architecture
browsers,
Run Your Tests Against Different Browsers
browsers, headless,
Setting Up a Virtual Display so the FTs Can Run Headless
C
caching,
Caching and Performance Testing
CI server (see continuous integration (CI))
class-based generic views,
Django Class-Based Views
–
Take-Home: Having Multiple, Isolated View Tests with Single Assertions Helps
class-based views,
Django Class-Based Views
clean architecture,
Ports and Adapters/Hexagonal/Clean Architecture
code smell,
Three Strikes and Refactor
,
Saving the POST to the Database
,
Moving Validation Logic into a Form
,
Finishing Off Our FT, Testing Logout
collectstatic,
What We Glossed Over: collectstatic and Other Static Directories
–
What We Glossed Over: collectstatic and Other Static Directories
comments,
Using a Functional Test to Scope Out a Minimum Viable App
,
Implementing the New Design Using TDD
commits,
Commit
,
Unit Testing in Django
,
urls.py
,
But How to Use That URL in the Form?
configuration management tools,
Further Reading
(see also Fabric)
context managers,
Unit Testing Model Validation and the self.assertRaises Context Manager
continuous integration (CI),
Continuous Integration (CI)
–
More Things to Do with a CI Server
,
Keep Your CI Builds Green
adding required plugins,
Adding Required Plugins
best practices,
More Things to Do with a CI Server
configuring Jenkins,
Configuring Jenkins Security
debugging with screenshots,
Taking Screenshots
–
Taking Screenshots
installing Jenkins,
Installing Jenkins
JavaScript tests,
Running Our QUnit JavaScript Tests in Jenkins with PhantomJS
–
Adding the Build Steps to Jenkins
project setup,
Setting Up Our Project
Selenium race conditions,
A Common Selenium Problem: Race Conditions
–
A Common Selenium Problem: Race Conditions
for staging server test automation,
More Things to Do with a CI Server
virtual display setup,
Setting Up a Virtual Display so the FTs Can Run Headless
–
Setting Up a Virtual Display so the FTs Can Run Headless
contracts, implicit,
Identifying Implicit Contracts
cookies,
Checking the View Actually Logs the User In
,
Skipping the Login Process by Pre-creating a Session
Cross-Site Request Forgery (CSRF) error,
Wiring Up Our Form to Send a POST Request
CSS (Cascading Style Sheets) framework,
What to Functionally Test About Layout and Style
,
Prettification: Using a CSS Framework
(see also Bootstrap)
where Bootstrap won’t work,
Using Our Own CSS
cutting corners,
Testing Is Hard
D
data migrations,
An Attempted Deploy to Staging
–
Conclusions
database deployment issues,
TDD and the Danger Areas of Deployment
database location,
Adjusting the Database Location
De-spiking,
De-spiking
,
De-spiking Our Custom Authentication Backend: Mocking Out an Internet Request
–
The get_user Method
debugging,
Testing a Simple Home Page with Unit Tests
,
Wiring Up Our Form to Send a POST Request
,
The Server Side: Custom Authentication
Ajax,
The Server Side: Custom Authentication
Django debug screen,
Simple Nginx Configuration
improving error messages,
Passing Python Variables to Be Rendered in the Template
in continuous integration,
Taking Screenshots
–
Taking Screenshots
in JavaScript,
A Simple Mock to Unit Tests Our initialize Function
staging for,
The Proof Is in the Pudding: Using Staging to Catch Final Bugs
–
Fixing the Persona Bug
switching DEBUG to false,
Switching DEBUG to False and Setting ALLOWED_HOSTS
screenshots, for debugging,
Taking Screenshots
–
Taking Screenshots
dependencies
and deployment,
TDD and the Danger Areas of Deployment
mocking out,
Testing Our View by Mocking Out authenticate
virtualenv,
Creating a Virtualenv
deployment,
The Deployment Chapter
adjusting database location,
Adjusting the Database Location
automating,
Automating
–
Automating
,
Automating Deployment with Fabric
–
Further Reading
danger areas,
TDD and the Danger Areas of Deployment
dependencies and,
TDD and the Danger Areas of Deployment
deploying to live,
Deploying to Live
further reading,
Further Reading
key points,
Automating
to live,
Live Deploy
migrate,
Creating the Database with migrate
Nginx,
Simple Nginx Configuration
–
Simple Nginx Configuration
overview,
Automating
production-ready,
Getting to a Production-Ready Deployment
–
Saving Our Changes: Adding Gunicorn to Our requirements.txt
vs. provisioning,
Deploying Our Code Manually
sample script,
Breakdown of a Fabric Script for Our Deployment
–
Breakdown of a Fabric Script for Our Deployment
saving progress,
“Saving Your Progress”
staging,
Staging Deploy
,
An Attempted Deploy to Staging
virtualenvs,
Creating a Virtualenv
–
Creating a Virtualenv
deployment testing,
Testing Deployment Using a Staging Site
–
“Saving Your Progress”
domain name for,
Getting a Domain Name
manual provisioning for hosting,
Manually Provisioning a Server to Host Our Site
–
Using the FT to Confirm the Domain Works and Nginx Is Running
overview,
TDD and the Danger Areas of Deployment
design (see layout and style)
Django,
Obey the Testing Goat! Do Nothing Until You Have a Test
admin site,
The Django Admin Site
apps,
Our First Django App, and Our First Unit Test
authentication in,
The Server Side: Custom Authentication
–
The Server Side: Custom Authentication
,
Checking the View Actually Logs the User In
class-based views,
Django Class-Based Views
–
Take-Home: Having Multiple, Isolated View Tests with Single Assertions Helps
(see also class-based views)
collectstatic,
What We Glossed Over: collectstatic and Other Static Directories
–
What We Glossed Over: collectstatic and Other Static Directories
custom user model,
A Minimal Custom User Model
–
Users Are Authenticated
debugging screen,
Simple Nginx Configuration
,
Switching DEBUG to False and Setting ALLOWED_HOSTS
field types,
The Test Gets Surprisingly Far
foreign key relationship,
A Foreign Key Relationship
forms in (see forms)
FormView,
The Home Page as a FormView
functional tests (FT) in (see functional tests/testing (FT))
and Gunicorn,
Switching to Gunicorn
LiveServerTestCase,
Ensuring Test Isolation in Functional Tests
management commands,
A Django Management Command to Create Sessions
–
Getting the FT to Run the Management Command on the Server
,
Wrap-Up
migrations,
Our First Database Migration
–
A New Field Means a New Migration
,
Creating Our Production Database with migrate
–
Creating Our Production Database with migrate
,
Deploying Our New Code
model adjustment in,
Adjusting Our Models
model-layer validation,
Using Model-Layer Validation
–
Enforcing Model Validation in view_list
Model-View-Controller (MVC),
Django’s MVC, URLs, and View Functions
notifications,
Notifications—Both on the Site and by Email
Object-Relational Mapper (ORM),
The Django ORM and Our First Model
–
A New Field Means a New Migration
POST requests (see POST requests)
as PythonAnywhere app,
Setting Up Django as a PythonAnywhere Web App
startproject,
Getting Django Up and Running
static files in,
Static Files in Django
static live server case,
Switching to StaticLiveServerTestCase
template inheritance,
Django Template Inheritance
–
Django Template Inheritance
templates,
Rendering Items in the Template
–
Rendering Items in the Template
,
A Separate Template for Viewing Lists
test class in,
A Test Class for New List Creation
test client,
A New Test Class
,
A Test Class for New List Creation
test fixtures,
Skipping the Login Process by Pre-creating a Session
TestCase,
Unit Testing in Django
unit testing in,
Unit Testing in Django
URLs in,
Django’s MVC, URLs, and View Functions
–
urls.py
,
A New URL
,
A URL and View for New List Creation
,
Pointing Our Forms at the New URL
,
Each List Should Have Its Own URL
,
The Last New URL
,
But How to Use That URL in the Form?
,
A Final Refactor Using URL includes
validation quirk,
A Django Quirk: Model Save Doesn’t Run Validation
view functions in,
Django’s MVC, URLs, and View Functions
,
A New View Function
,
A URL and View for New List Creation
,
One More View to Handle Adding Items to an Existing List
–
The Last New View
,
Moving Down One Layer to View Functions (the Controller)
and virtualenvs,
Creating a Virtualenv
–
Creating a Virtualenv
Django-BrowserID,
Exploratory Coding, aka “Spiking”
documentation, tests as,
Tests as Documentation
domain names,
Getting a Domain Name
Don’t Test Constants rule,
The “Don’t Test Constants” Rule, and Templates to the Rescue
double-loop TDD,
Recap: The TDD Process
,
Finishing “My Lists”: Outside-In TDD
DRY (don’t repeat yourself),
Three Strikes and Refactor
,
An Exercise for the Reader
duplicates, eliminating,
Passing Python Variables to Be Rendered in the Template
,
Another FT for Duplicate Items
–
A More Complex Form to Handle Uniqueness Validation
E
encryption,
Client-Side Encryption
end-to-end test (see functional tests/testing (FT))
error messages,
Test for Graceful Degradation
error pages,
404 and 500 Tests
evaluating third-party systems,
De-spiking
expected failure,
Using a Functional Test to Scope Out a Minimum Viable App
,
Commit
explicit waits,
A Common Selenium Technique: Explicit Waits
exploratory coding,
Exploring the Forms API with a Unit Test
,
Exploratory Coding, aka “Spiking”
(see also spiking)
F
Fabric,
Further Reading
,
An Additional Hop via subprocess
,
Move Deployment out of Fabric and into Ansible
configuration,
Trying It Out
installing,
Automating Deployment with Fabric
sample deployment script,
Breakdown of a Fabric Script for Our Deployment
–
Breakdown of a Fabric Script for Our Deployment
Fake XMLHttpRequest,
QUnit setup and teardown, Testing Ajax
fixtures
in functional tests,
Skipping the Login Process by Pre-creating a Session
in JavaScript tests,
Using jQuery and the Fixtures Div
on staging server,
Managing the Test Database on Staging
–
An Additional Hop via subprocess
foreign key relationship,
A Foreign Key Relationship
forms
advanced,
More Advanced Forms
–
Using the Existing List Item Form in the List View
autogeneration,
Switching to a Django ModelForm
customising form field input,
Exploring the Forms API with a Unit Test
experimenting with,
Exploring the Forms API with a Unit Test
ModelForm,
Switching to a Django ModelForm
save methods,
Using the Form’s Own Save Method
simple,
A Simple Form
–
Using the Form’s Own Save Method
thin views,
Using the Form’s Own Save Method
tips for,
Using the Form’s Own Save Method
using in views,
Using the Form in Our Views
–
A Helper Method for Several Short Tests
validation testing and customising,
Testing and Customising Form Validation
Functional Core, Imperative Shell architecture,
Functional Core, Imperative Shell
functional tests/testing (FT),
Obey the Testing Goat! Do Nothing Until You Have a Test
,
Fast Tests, Slow Tests, and Hot Lava
automation of (see continuous integration (CI))
cleanup,
Getting to the Minimum Viable Site
–
Ensuring Test Isolation in Functional Tests
,
Removing Now-Redundant Code and Tests
,
An FT with Multiple Users, and addCleanup
de-duplication,
Wrap-Up
defining,
Using a Functional Test to Scope Out a Minimum Viable App
for de-spiking,
De-spiking
for duplicate items,
Another FT for Duplicate Items
–
A More Complex Form to Handle Uniqueness Validation
isolation in,
Getting to the Minimum Viable Site
–
Ensuring Test Isolation in Functional Tests
,
A Final Refactor Using URL includes
in JavaScript,
Building a JavaScript Unit Test for Our Desired Functionality
–
Javascript Testing in the TDD Cycle
for layout and style,
What to Functionally Test About Layout and Style
–
What to Functionally Test About Layout and Style
,
Switching to Gunicorn
,
Splitting Functional Tests out into Many Files
multiple users,
An FT with Multiple Users, and addCleanup
,
Extend the FT to a Second User, and the “My Lists” Page
–
Extend the FT to a Second User, and the “My Lists” Page
pros and cons,
Onwards!
in provisioning,
Using the FT to Confirm the Domain Works and Nginx Is Running
running unit tests only,
Running Just the Unit Tests
safeguards with,
An Additional Hop via subprocess
splitting,
Splitting Functional Tests out into Many Files
for staging sites,
TDD and the Danger Areas of Deployment
,
As Always, Start with a Test
unittest module,
Extending Our Functional Test Using the unittest Module
–
Commit
vs. unit tests,
Unit Tests, and How They Differ from Functional Tests
,
Test Fixtures, Logging, and Server-Side Debugging
in views,
Using the Existing List Item Form in the List View
G
generator expression,
Using Selenium to Test User Interactions
GET requests,
Using the Form in a View with a GET Request
,
Using the Form in the Other View
get_user,
The get_user Method
Git
repository setup,
Starting a Git Repository
–
Starting a Git Repository
reset --hard,
What to Functionally Test About Layout and Style
tags,
Git Tag the Release
,
Wrap-Up: git tag the New Release
global variables,
Setting Up a Basic JavaScript Test Runner
greedy regular expressions,
Beware of Greedy Regular Expressions!
Gunicorn,
Switching to Gunicorn
–
Automating
,
Nginx and Gunicorn Config Using sed
,
Setting Up Logging
,
Configuring Gunicorn, and Using Handlers to Restart Services
H
headless browsers,
Setting Up a Virtual Display so the FTs Can Run Headless
helper functions/methods,
Three Strikes and Refactor
,
Splitting Functional Tests out into Many Files
,
Fleshing Out the FT
,
A Helper Method for Several Short Tests
,
Starting with an FT
,
Keep Listening to Your Tests: Removing ORM Code from Our Application
,
The Page Pattern
–
The Page Pattern
hexagonal architecture,
Ports and Adapters/Hexagonal/Clean Architecture
hosting options,
Choosing Where to Host Our Site
hosting, manual provisioning,
Manually Provisioning a Server to Host Our Site
–
Using the FT to Confirm the Domain Works and Nginx Is Running
I
Idempotency,
Further Reading
implicit waits,
Implicit waits
in-memory model objects,
Finally, Moving Down to the Models Layer
integrated tests,
Finally, Moving Down to the Models Layer
–
Onwards!
,
Ports and Adapters/Hexagonal/Clean Architecture
vs. integration test,
Keep the Old Integrated Test Suite Around as a Sanity Check
vs. isolated tests,
Conclusions: When to Write Isolated Versus Integrated Tests
,
Fast Tests, Slow Tests, and Hot Lava
pros and cons,
Onwards!
vs. unit tests,
The Django ORM and Our First Model
integration tests,
Keep the Old Integrated Test Suite Around as a Sanity Check
,
Fast Tests, Slow Tests, and Hot Lava
integrity errors,
Some Integrity Errors Do Show Up on Save
isolated tests,
Test Isolation, and “Listening to Your Tests”
,
Ports and Adapters/Hexagonal/Clean Architecture
(see also test isolation)
vs. integrated tests,
Conclusions: When to Write Isolated Versus Integrated Tests
,
Fast Tests, Slow Tests, and Hot Lava
problems with,
Isolated Tests Can Be Harder to Read and Write
pros and cons,
Onwards!
J
JavaScript,
Dipping Our Toes, Very Tentatively, into JavaScript
de-spiking in,
De-spiking
debug console,
A Simple Mock to Unit Tests Our initialize Function
functional test (FT) building in,
Building a JavaScript Unit Test for Our Desired Functionality
–
Javascript Testing in the TDD Cycle
jQuery and Fixtures Div,
Using jQuery and the Fixtures Div
–
Using jQuery and the Fixtures Div
linters,
Setting Up a Basic JavaScript Test Runner
MVC frameworks,
JavaScript MVC Frameworks
onload boilerplate and namespacing,
Columbo Says: Onload Boilerplate and Namespacing
QUnit,
Setting Up a Basic JavaScript Test Runner
running tests in continuous integration,
Running Our QUnit JavaScript Tests in Jenkins with PhantomJS
–
Adding the Build Steps to Jenkins
spiking with,
Exploratory Coding, aka “Spiking”
–
Reverting Our Spiked Code
(see also spiking)
in TDD Cycle,
Javascript Testing in the TDD Cycle
test runner setup,
Setting Up a Basic JavaScript Test Runner
testing notes,
A Few Things That Didn’t Make It
Jenkins Security,
Installing Jenkins
–
Adding the Build Steps to Jenkins
(see also continuous integration (CI))
adding required plugins,
Adding Required Plugins
configuring,
Configuring Jenkins Security
installing,
Installing Jenkins
jQuery,
Using jQuery and the Fixtures Div
–
Using jQuery and the Fixtures Div
,
Columbo Says: Onload Boilerplate and Namespacing
,
A Few Things That Didn’t Make It
JSON fixtures,
Skipping the Login Process by Pre-creating a Session
,
Wrap-Up
jumbotron,
Jumbotron!
L
layout and style,
Prettification: Layout and Styling, and What to Test About It
–
A Few Things That Didn’t Make It
Bootstrap for (see Bootstrap)
functional tests (FT) for,
Splitting Functional Tests out into Many Files
large inputs,
Large Inputs
overview,
A Few Things That Didn’t Make It
rows and columns,
Rows and Columns
static files,
Static Files in Django
,
What We Glossed Over: collectstatic and Other Static Directories
–
What We Glossed Over: collectstatic and Other Static Directories
table styling,
Table Styling
using a CSS framework for,
Prettification: Using a CSS Framework
(see also Bootstrap)
using our own CSS in,
Using Our Own CSS
what to functionally test for,
What to Functionally Test About Layout and Style
list comprehension,
Using Selenium to Test User Interactions
LiveServerTestCase,
Ensuring Test Isolation in Functional Tests
log messages,
Wrap-Up
logging,
Setting Up Logging
,
Wrap-Up
logging configuration,
Using Hierarchical Logging Config
–
Wrap-Up
M
manage.py,
Getting Django Up and Running
,
Unit Testing in Django
,
Our First Database Migration
,
Creating Our Production Database with migrate
,
What We Glossed Over: collectstatic and Other Static Directories
Meta,
Switching to a Django ModelForm
meta-comments,
Implementing the New Design Using TDD
migrate,
Creating the Database with migrate
migrations,
Our First Database Migration
–
A New Field Means a New Migration
,
Creating Our Production Database with migrate
–
Creating Our Production Database with migrate
,
A Foreign Key Relationship
,
Deploying Our New Code
,
What to Do If You See a Database Error
(see also data migrations)
database,
Testing Database Migrations
–
Conclusions
deleting,
A Foreign Key Relationship
testing,
Testing Database Migrations
–
Conclusions
minimum viable application,
Using a Functional Test to Scope Out a Minimum Viable App
–
Using a Functional Test to Scope Out a Minimum Viable App
,
Small Design When Necessary
MockMyID,
De-spiking
mocks/mocking
callbacks,
More Nested Callbacks! Testing Asynchronous Code
–
More Nested Callbacks! Testing Asynchronous Code
checking call arguments,
Checking Call Arguments
implicit contracts,
Identifying Implicit Contracts
in JavaScript,
User Authentication, Integrating Third-Party Plugins, and Mocking with JavaScript
,
Mocking: Who, Why, What?
–
More Nested Callbacks! Testing Asynchronous Code
initialize function test,
A Simple Mock to Unit Tests Our initialize Function
–
A Simple Mock to Unit Tests Our initialize Function
Internet requests,
De-spiking Our Custom Authentication Backend: Mocking Out an Internet Request
–
The get_user Method
for isolation,
A First Attempt at Using Mocks for Isolation
–
Using Mock side_effects to Check the Sequence of Events
mock library,
Finishing Off Our FT, Testing Logout
Mock side_effects,
Using Mock side_effects to Check the Sequence of Events
namespacing,
Namespacing
in Outside-In TDD,
A Decision Point: Whether to Proceed to the Next Layer with a Failing Test
in Python,
Mocking in Python
–
Checking the View Actually Logs the User In
risks,
The Moment of Truth (and the Risks of Mocking)
sinon.js,
Using a sinon.js mock to check we call the API correctly
testing Django login,
Checking the View Actually Logs the User In
model-layer validation,
Using Model-Layer Validation
–
Enforcing Model Validation in view_list
changes to test,
Rewriting the Old Model Test
enforcing,
Enforcing Model Validation in view_list
errors in View,
Surfacing Model Validation Errors in the View
–
Checking Invalid Input Isn’t Saved to the Database
integrity errors,
Some Integrity Errors Do Show Up on Save
POST requests,
Django Pattern: Processing POST Requests in the Same View as Renders the Form
–
Enforcing Model Validation in view_list
preventing duplicates,
Preventing Duplicates at the Model Layer
refactoring,
Refactoring Unit Tests into Several Files
,
Refactor: Transferring the new_item Functionality into view_list
–
Refactor: Transferring the new_item Functionality into view_list
unit testing,
Unit Testing Model Validation and the self.assertRaises Context Manager
–
A Django Quirk: Model Save Doesn’t Run Validation
at views level,
Experimenting with Duplicate Item Validation at the Views Layer
Model-View-Controller (MVC),
Django’s MVC, URLs, and View Functions
,
JavaScript MVC Frameworks
ModelForm,
Switching to a Django ModelForm
Mozilla Persona,
Mozilla Persona (BrowserID)
MVC frameworks,
Django’s MVC, URLs, and View Functions
,
JavaScript MVC Frameworks
N
namespacing,
Namespacing
Nginx,
Installing Nginx
,
Simple Nginx Configuration
–
Simple Nginx Configuration
,
Getting Nginx to Serve Static Files
,
Nginx and Gunicorn Config Using sed
,
Installing System Packages and Nginx
nonroot user creation,
User Accounts, SSH, and Privileges
notifications,
Notifications—Both on the Site and by Email
O
ORM (Object-Relational Mapper),
The Django ORM and Our First Model
–
A New Field Means a New Migration
Outside-In TDD,
Finishing “My Lists”: Outside-In TDD
–
Final Step: Feeding Through the .name API from the Template
advantages,
Why Prefer “Outside-In”?
controller layer,
Moving Down One Layer to View Functions (the Controller)
defined,
Final Step: Feeding Through the .name API from the Template
vs. Inside-Out,
The Alternative: “Inside Out”
model layer,
The Next “Requirement” from the Views Layer: New Lists Should Record Owner
–
Moving Down to the Model Layer
pitfalls,
Final Step: Feeding Through the .name API from the Template
presentation layer,
The Outside Layer: Presentation and Templates
template hierarchy,
A Quick Restructure of the Template Inheritance Hierarchy
–
Moving Down to the Next Layer: What the View Passes to the Template
views layer,
Moving Down One Layer to View Functions (the Controller)
–
The Next “Requirement” from the Views Layer: New Lists Should Record Owner
,
Moving Down to the Model Layer
P
PaaS (Platform-as-a-Service),
Choosing Where to Host Our Site
Page pattern,
The Page Pattern
–
The Page Pattern
,
An Exercise for the Reader
patch decorator,
Testing Our View by Mocking Out authenticate
,
Finishing Off Our FT, Testing Logout
patching,
Patching at the Class Level
payment systems, testing for,
De-spiking
performance testing,
Caching and Performance Testing
Persona,
Mozilla Persona (BrowserID)
,
De-spiking
,
Setting Up Logging
–
Fixing the Persona Bug
,
Test for Graceful Degradation
PhantomJS,
Running Our QUnit JavaScript Tests in Jenkins with PhantomJS
–
Adding the Build Steps to Jenkins
,
Run Your Tests Against Different Browsers
Platform-as-a-Service (PaaS),
Choosing Where to Host Our Site
POST requests,
Using the Form in a View That Takes POST Requests
processing,
Processing a POST Request on the Server
,
Django Pattern: Processing POST Requests in the Same View as Renders the Form
–
Enforcing Model Validation in view_list
redirect after,
Redirect After a POST
saving to database,
Saving the POST to the Database
–
Saving the POST to the Database
sending,
Wiring Up Our Form to Send a POST Request
–
Wiring Up Our Form to Send a POST Request
,
A Separate Template for Viewing Lists
Postgres,
Switch to Postgres
private key authentication,
User Accounts, SSH, and Privileges
programming by wishful thinking,
Designing Our API Using the Template
,
Final Step: Feeding Through the .name API from the Template
(see also Outside-In TDD)
property Decorator,
Final Step: Feeding Through the .name API from the Template
provisioning,
Manually Provisioning a Server to Host Our Site
–
Using the FT to Confirm the Domain Works and Nginx Is Running
with Ansible,
Provisioning with Ansible
–
Move Deployment out of Fabric and into Ansible
automation in,
Further Reading
functional tests (FT) in,
Using the FT to Confirm the Domain Works and Nginx Is Running
overview,
Automating
vs. deployment,
Deploying Our Code Manually
pure unit tests (see isolated tests)
py.test,
Switch to Using py.test
Python
adding to Jenkins,
Telling Jenkins where to find Python 3 and Xvfb
PythonAnywhere,
Choosing Where to Host Our Site
,
PythonAnywhere
Q
QuerySet,
The Django ORM and Our First Model
,
A Little Digression on Queryset Ordering and String Representations
–
A Little Digression on Queryset Ordering and String Representations
QUnit,
Setting Up a Basic JavaScript Test Runner
,
A Few Things That Didn’t Make It
,
A Simple Mock to Unit Tests Our initialize Function
,
QUnit setup and teardown, Testing Ajax
R
race conditions,
Setting Up a Virtual Display so the FTs Can Run Headless
,
Implementing the Selenium Interact/Wait Pattern
Red, Green, Refactor,
Passing Python Variables to Be Rendered in the Template
,
Green? Refactor
,
Skipping a Test
redirects,
Redirect After a POST
,
Using get_absolute_url for Redirects
refactoring,
Refactoring to Use a Template
–
On Refactoring
at application level,
Django Pattern: Processing POST Requests in the Same View as Renders the Form
–
Refactor: Transferring the new_item Functionality into view_list
Red, Green, Refactor,
Passing Python Variables to Be Rendered in the Template
,
Green? Refactor
,
Skipping a Test
removing hard-coded URLs,
Refactor: Removing Hardcoded URLs
and test isolation,
Listen to Your Tests: Ugly Tests Signal a Need to Refactor
,
Conclusions: When to Write Isolated Versus Integrated Tests
tips,
Using get_absolute_url for Redirects
unit tests,
Refactoring Unit Tests into Several Files
Refactoring Cat,
On Refactoring
,
A Final Refactor Using URL includes
relative import,
Breakdown of a Fabric Script for Our Deployment
,
Splitting Functional Tests out into Many Files
render to string,
Passing Python Variables to Be Rendered in the Template
REST (Representational Site Transfer),
REST
S
screenshots,
Screenshots
scripts, automated,
TDD and the Danger Areas of Deployment
secret key,
Breakdown of a Fabric Script for Our Deployment
Security Engineering (Anderson),
Wiring Up Our Form to Send a POST Request
security tests,
Write Some Security Tests
sed (stream editor),
Nginx and Gunicorn Config Using sed
Selenium,
Obey the Testing Goat! Do Nothing Until You Have a Test
and JavaScript,
A Few Things That Didn’t Make It
best practices,
More Things to Do with a CI Server
in continuous integration,
A Common Selenium Problem: Race Conditions
–
A Common Selenium Problem: Race Conditions
in continuous integration,
First Build!
race conditions,
Implementing the Selenium Interact/Wait Pattern
race conditions in,
A Common Selenium Problem: Race Conditions
–
A Common Selenium Problem: Race Conditions
upgrading,
Implementing the New Design Using TDD
for user interaction testing,
Using Selenium to Test User Interactions
–
The “Don’t Test Constants” Rule, and Templates to the Rescue
wait patterns,
Implicit waits
,
A Common Selenium Technique: Explicit Waits
,
The Token Social Bit, the Page Pattern, and an Exercise for the Reader
,
Implementing the Selenium Interact/Wait Pattern
waits in,
A Common Selenium Problem: Race Conditions
–
A Common Selenium Problem: Race Conditions
,
More Things to Do with a CI Server
server configuration,
Automating
server options,
Spinning Up a Server
servers,
Manually Provisioning a Server to Host Our Site
–
Using the FT to Confirm the Domain Works and Nginx Is Running
(see also staging server)
session key,
Skipping the Login Process by Pre-creating a Session
sessions,
Checking the View Actually Logs the User In
Shining Panda,
Telling Jenkins where to find Python 3 and Xvfb
sinon.js,
Using a sinon.js mock to check we call the API correctly
,
QUnit setup and teardown, Testing Ajax
,
More Nested Callbacks! Testing Asynchronous Code
skips,
Skipping a Test
spiking,
Exploratory Coding, aka “Spiking”
–
Reverting Our Spiked Code
,
More Nested Callbacks! Testing Asynchronous Code
browser-ID protocol,
The Browser-ID Protocol
de-spiking,
De-spiking
frontend and JavaScript code,
Frontend and JavaScript Code
logging,
The Server Side: Custom Authentication
server-side authentication,
The Server Side: Custom Authentication
–
The Server Side: Custom Authentication
with JavaScript,
Exploratory Coding, aka “Spiking”
SQLite,
Switch to Postgres
staging server
creating sessions,
A Django Management Command to Create Sessions
debugging in,
The Proof Is in the Pudding: Using Staging to Catch Final Bugs
–
Fixing the Persona Bug
managing database on,
Managing the Test Database on Staging
–
Checking It Works
test automation with CI,
More Things to Do with a CI Server
staging sites,
TDD and the Danger Areas of Deployment
,
As Always, Start with a Test
,
Getting a Domain Name
static files,
What to Functionally Test About Layout and Style
,
Static Files in Django
,
TDD and the Danger Areas of Deployment
,
Getting Nginx to Serve Static Files
static folder, site-wide,
Housekeeping: A Site-Wide Static Files Folder
static live server case,
Switching to StaticLiveServerTestCase
string representation,
A Little Digression on Queryset Ordering and String Representations
string substitutions,
Each List Should Have Its Own URL
style (see layout and style)
superlists,
Starting a Git Repository
system boundaries,
Ports and Adapters/Hexagonal/Clean Architecture
system tests,
Fast Tests, Slow Tests, and Hot Lava
T
table styling,
Table Styling
template inheritance,
Django Template Inheritance
–
Django Template Inheritance
template inheritance hierarchy,
A Quick Restructure of the Template Inheritance Hierarchy
template tag,
Wiring Up Our Form to Send a POST Request
templates,
Refactoring to Use a Template
,
Passing Python Variables to Be Rendered in the Template
rendering items in,
Rendering Items in the Template
–
Rendering Items in the Template
separate,
A Separate Template for Viewing Lists
test fixtures,
Skipping the Login Process by Pre-creating a Session
,
Wrap-Up
test isolation,
A Final Refactor Using URL includes
,
Test Isolation, and “Listening to Your Tests”
–
Onwards!
cleanup after,
Tidy Up: What to Keep from Our Integrated Test Suite
–
Removing Redundant Code at the Forms Layer
collaborators,
Thinking in Terms of Collaborators
–
Thinking in Terms of Collaborators
complexity in,
Let Complexity Be Your Guide
forms layer,
Moving Down to the Forms Layer
–
Keep Listening to Your Tests: Removing ORM Code from Our Application
full isolation,
Rewriting Our Tests for the View to Be Fully Isolated
interactions between layers,
Thinking of Interactions Between Layers as “Contracts”
isolated vs. integrated tests,
Conclusions: When to Write Isolated Versus Integrated Tests
mocks/mocking for,
A First Attempt at Using Mocks for Isolation
–
Using Mock side_effects to Check the Sequence of Events
models layer,
Finally, Moving Down to the Models Layer
–
Finally, Moving Down to the Models Layer
ORM code,
Moving Down to the Forms Layer
–
Keep Listening to Your Tests: Removing ORM Code from Our Application
,
Onwards!
refactoring in,
Listen to Your Tests: Ugly Tests Signal a Need to Refactor
,
Conclusions: When to Write Isolated Versus Integrated Tests
views layer,
Revisiting Our Decision Point: The Views Layer Depends on Unwritten Models Code
,
A First Attempt at Using Mocks for Isolation
–
Thinking in Terms of Collaborators
,
Back to Views
test methods,
The Python Standard Library’s unittest Module
test organisation,
Using get_absolute_url for Redirects
test skips,
Skipping a Test
test types,
Onwards!
,
Fast Tests, Slow Tests, and Hot Lava
test-driven development (TDD)
advanced considerations in,
Fast Tests, Slow Tests, and Hot Lava
–
Conclusion
and developer stupidity,
Preventing Duplicates at the Model Layer
double-loop,
Recap: The TDD Process
,
Finishing “My Lists”: Outside-In TDD
further reading on,
Conclusion
Inside-Out,
The Alternative: “Inside Out”
iterating towards new design,
Iterating Towards the New Design
Java testing in,
Javascript Testing in the TDD Cycle
justifications for,
What Are We Doing with All These Tests?
–
Programming Is like Pulling a Bucket of Water up from a Well
new design implementation with,
Implementing the New Design Using TDD
–
Implementing the New Design Using TDD
Outside-In,
Finishing “My Lists”: Outside-In TDD
–
Final Step: Feeding Through the .name API from the Template
(see also Outside-In TDD)
process flowchart,
Implementing the New Design Using TDD
process recap,
Recap: The TDD Process
–
Recap: The TDD Process
trivial tests,
Programming Is like Pulling a Bucket of Water up from a Well
–
Programming Is like Pulling a Bucket of Water up from a Well
Working state to working state,
Iterating Towards the New Design
,
But How to Use That URL in the Form?
,
A Final Refactor Using URL includes
testing best practices,
Fast Tests, Slow Tests, and Hot Lava
Testing Goat,
Obey the Testing Goat! Do Nothing Until You Have a Test
,
But How to Use That URL in the Form?
,
A Final Refactor Using URL includes
,
Testing Is Hard
tests, as documentation,
Tests as Documentation
thin views,
Using the Form’s Own Save Method
time.sleep,
Wiring Up Our Form to Send a POST Request
tracebacks,
At Last! We Actually Write Some Application Code!
,
Passing Python Variables to Be Rendered in the Template
triangulation,
Passing Python Variables to Be Rendered in the Template
U
Ubuntu,
Spinning Up a Server
unit tests
architectural solutions for,
Architectural Solutions
context manager,
Unit Testing Model Validation and the self.assertRaises Context Manager
desired features of,
Synthesis: What Do We Want from Our Tests, Anyway?
in Django,
Unit Testing in Django
for simple home page,
Testing a Simple Home Page with Unit Tests
–
The Unit-Test/Code Cycle
vs. functional tests,
Test Fixtures, Logging, and Server-Side Debugging
vs. functional tests (FT),
Unit Tests, and How They Differ from Functional Tests
vs. integrated tests,
The Django ORM and Our First Model
pros and cons of,
Thesis: Unit Tests Are Superfast and Good Besides That
–
But All These Problems Can Be Overcome
refactoring,
Refactoring Unit Tests into Several Files
unit-test/code cycle,
The Unit-Test/Code Cycle
–
The Unit-Test/Code Cycle
unittest,
As Always, Start with a Test
Unix sockets,
Switching to Using Unix Sockets
Upstart,
Using Upstart to Make Sure Gunicorn Starts on Boot
URLs
capturing parameters in,
Capturing Parameters from URLs
distinct,
Each List Should Have Its Own URL
in Django,
Django’s MVC, URLs, and View Functions
–
urls.py
,
A New URL
,
A URL and View for New List Creation
,
Pointing Our Forms at the New URL
,
Each List Should Have Its Own URL
,
The Last New URL
,
But How to Use That URL in the Form?
pointing forms to,
Pointing Our Forms at the New URL
urls.py,
urls.py
–
urls.py
user authentication (see authentication)
user creation,
Creating a User if Necessary
user input, saving,
Saving User Input
–
Creating Our Production Database with migrate
user interaction testing,
Using Selenium to Test User Interactions
–
The “Don’t Test Constants” Rule, and Templates to the Rescue
user stories,
Commit
,
Validation FT: Preventing Blank Items
V
Vagrant,
Use Vagrant to Spin Up a Local VM
validation,
Validation FT: Preventing Blank Items
(see also functional tests/testing (FT))
model-layer,
Using Model-Layer Validation
–
Enforcing Model Validation in view_list
(see also model-layer validation)
VCS (version control system),
Starting a Git Repository
–
Starting a Git Repository
view functions, in Django,
Django’s MVC, URLs, and View Functions
,
A New View Function
,
A URL and View for New List Creation
,
One More View to Handle Adding Items to an Existing List
–
The Last New View
views layer,
Revisiting Our Decision Point: The Views Layer Depends on Unwritten Models Code
,
A First Attempt at Using Mocks for Isolation
–
Thinking in Terms of Collaborators
,
Back to Views
model validation errors in,
Surfacing Model Validation Errors in the View
–
Checking Invalid Input Isn’t Saved to the Database
views, what to test in,
Using the Existing List Item Form in the List View
virtual displays,
Setting Up a Virtual Display so the FTs Can Run Headless
Virtualbox,
Use Vagrant to Spin Up a Local VM
virtualenvs,
TDD and the Danger Areas of Deployment
,
Creating a Virtualenv
–
Creating a Virtualenv
W
waits,
Implicit waits
,
A Common Selenium Technique: Explicit Waits
,
A Common Selenium Problem: Race Conditions
–
A Common Selenium Problem: Race Conditions
,
More Things to Do with a CI Server
,
The Token Social Bit, the Page Pattern, and an Exercise for the Reader
,
Implementing the Selenium Interact/Wait Pattern
warnings,
The Python Standard Library’s unittest Module
watch function,
More Advanced Mocking
websockets,
Async and Websockets
widgets,
Exploring the Forms API with a Unit Test
,
Switching to a Django ModelForm
X
Xvfb,
Telling Jenkins where to find Python 3 and Xvfb
,
Setting Up a Virtual Display so the FTs Can Run Headless
,
Running Firefox Selenium Sessions with Xvfb
Y
YAGNI,
YAGNI!
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset