book

Test-Driven Development with Python, 2nd Edition

Name: Test-Driven Development with Python, 2nd Edition
Author: Harry Percival
ISBN: 9781491958650

by Harry Percival

August 2017

Intermediate to advanced

624 pages

12h 18m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Preface
Why I Wrote a Book About Test-Driven DevelopmentAims of This BookOutlineConventions Used in This BookSubmitting ErrataUsing Code ExamplesO’Reilly SafariContacting O’Reilly
Prerequisites and Assumptions
Python 3 and ProgrammingHow HTML WorksDjangoJavaScriptRequired Software InstallationsGit’s Default Editor, and Other Basic Git ConfigInstalling Firefox and GeckodriverSetting Up Your VirtualenvActivating and Deactivating the VirtualenvInstalling Django and SeleniumSome Error Messages You’re Likely to See When You Inevitably Fail to Activate Your Virtualenv
Companion Video
Acknowledgments
Additional Thanks for the Second Edition
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 TestGetting Django Up and RunningStarting a Git Repository
2. Extending Our Functional Test Using the unittest Module
Using a Functional Test to Scope Out a Minimum Viable AppThe Python Standard Library’s unittest ModuleCommit
3. Testing a Simple Home Page with Unit Tests
Our First Django App, and Our First Unit TestUnit Tests, and How They Differ from Functional TestsUnit Testing in DjangoDjango’s MVC, URLs, and View FunctionsAt Last! We Actually Write Some Application Code!urls.pyUnit Testing a ViewThe Unit-Test/Code Cycle
4. What Are We Doing with All These Tests? (And, Refactoring)
Programming Is Like Pulling a Bucket of Water Up from a WellUsing Selenium to Test User InteractionsThe “Don’t Test Constants” Rule, and Templates to the RescueRefactoring to Use a TemplateThe Django Test ClientOn RefactoringA Little More of Our Front PageRecap: The TDD Process
5. Saving User Input: Testing the Database
Wiring Up Our Form to Send a POST RequestProcessing a POST Request on the ServerPassing Python Variables to Be Rendered in the TemplateAn Unexpected FailureThree Strikes and RefactorThe Django ORM and Our First ModelOur First Database MigrationThe Test Gets Surprisingly FarA New Field Means a New MigrationSaving the POST to the DatabaseRedirect After a POSTBetter Unit Testing Practice: Each Test Should Test One ThingRendering Items in the TemplateCreating Our Production Database with migrateRecap

6. Improving Functional Tests: Ensuring Isolation and Removing Voodoo Sleeps
Ensuring Test Isolation in Functional TestsRunning Just the Unit TestsAside: Upgrading Selenium and GeckodriverOn Implicit and Explicit Waits, and Voodoo time.sleeps
7. Working Incrementally
Small Design When NecessaryNot Big Design Up FrontYAGNI!REST (ish)Implementing the New Design Incrementally Using TDDEnsuring We Have a Regression TestIterating Towards the New DesignTaking a First, Self-Contained Step: One New URLA New URLA New View FunctionGreen? RefactorAnother Small Step: A Separate Template for Viewing ListsA Third Small Step: A URL for Adding List ItemsA Test Class for New List CreationA URL and View for New List CreationRemoving Now-Redundant Code and TestsA Regression! Pointing Our Forms at the New URLBiting the Bullet: Adjusting Our ModelsA Foreign Key RelationshipAdjusting the Rest of the World to Our New ModelsEach List Should Have Its Own URLCapturing Parameters from URLsAdjusting new_list to the New WorldThe Functional Tests Detect Another RegressionOne More View to Handle Adding Items to an Existing ListBeware of Greedy Regular Expressions!The Last New URLThe Last New ViewTesting the Response Context Objects DirectlyA 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 StylePrettification: Using a CSS FrameworkDjango Template InheritanceIntegrating BootstrapRows and ColumnsStatic Files in DjangoSwitching to StaticLiveServerTestCaseUsing Bootstrap Components to Improve the Look of the SiteJumbotron!Large InputsTable StylingUsing Our Own CSSWhat We Glossed Over: collectstatic and Other Static DirectoriesA Few Things That Didn’t Make It
9. Testing Deployment Using a Staging Site
TDD and the Danger Areas of DeploymentAs Always, Start with a TestGetting a Domain NameManually Provisioning a Server to Host Our SiteChoosing Where to Host Our SiteSpinning Up a ServerUser Accounts, SSH, and PrivilegesInstalling Python 3.6Configuring Domains for Staging and LiveDeploying Our Code ManuallyCreating a Virtualenv on the Server Using requirements.txtUsing the FT to Check That Our Deployment WorksDebugging a Deployment That Doesn’t Seem to Work at AllHacking ALLOWED_HOSTS in settings.pyCreating the Database with migrateSuccess! Our Hack Deployment Works
10. Getting to a Production-Ready Deployment
What We Need to DoSwitching to NginxInstallationThe FT Now Fails, But Show Nginx Is RunningSimple Nginx ConfigurationSwitching to GunicornGetting Nginx to Serve Static FilesSwitching to Using Unix SocketsUsing Environment Variables to Adjust Settings for ProductionEssential Googling the Error MessageFixing ALLOWED_HOSTS with Nginx: passing on the Host headerUsing a .env File to Store Our Environment VariablesGenerating a secure SECRET_KEYUsing Systemd to Make Sure Gunicorn Starts on BootSaving Our Changes: Adding Gunicorn to Our requirements.txtThinking About AutomatingSaving Templates for Our Provisioning Config FilesSaving Our Progress
11. Automating Deployment with Fabric
Breakdown of a Fabric Script for Our DeploymentPulling Down Our Source Code with GitUpdating the VirtualenvCreating a New .env File if NecessaryUpdating Static FilesMigrating the Database If NecessaryTrying It OutDeploying to LiveProvisioning: Nginx and Gunicorn Config Using sedGit Tag the ReleaseFurther ReadingAutomating Provisioning with Ansible
12. Splitting Our Tests into Multiple Files, and a Generic Wait Helper
Start on a Validation FT: Preventing Blank ItemsSkipping a TestSplitting Functional Tests Out into Many FilesRunning a Single Test FileA New Functional Test Tool: A Generic Explicit Wait HelperFinishing Off the FTRefactoring Unit Tests into Several Files
13. Validation at the Database Layer
Model-Layer ValidationThe self.assertRaises Context ManagerA Django Quirk: Model Save Doesn’t Run ValidationSurfacing Model Validation Errors in the ViewChecking That Invalid Input Isn’t Saved to the DatabaseDjango Pattern: Processing POST Requests in the Same View as Renders the FormRefactor: Transferring the new_item Functionality into view_listEnforcing Model Validation in view_listRefactor: Removing Hardcoded URLsThe {% url %} Template TagUsing get_absolute_url for Redirects
14. A Simple Form
Moving Validation Logic into a FormExploring the Forms API with a Unit TestSwitching to a Django ModelFormTesting and Customising Form ValidationUsing the Form in Our ViewsUsing the Form in a View with a GET RequestA Big Find and ReplaceUsing the Form in a View That Takes POST RequestsAdapting the Unit Tests for the new_list ViewUsing the Form in the ViewUsing the Form to Display Errors in the TemplateUsing the Form in the Other ViewA Helper Method for Several Short TestsAn Unexpected Benefit: Free Client-Side Validation from HTML5A Pat on the BackBut Have We Wasted a Lot of Time?Using the Form’s Own Save Method
15. More Advanced Forms
Another FT for Duplicate ItemsPreventing Duplicates at the Model LayerA Little Digression on Queryset Ordering and String RepresentationsRewriting the Old Model TestSome Integrity Errors Do Show Up on SaveExperimenting with Duplicate Item Validation at the Views LayerA More Complex Form to Handle Uniqueness ValidationUsing the Existing List Item Form in the List ViewWrapping Up: What We’ve Learned About Testing Django
16. Dipping Our Toes, Very Tentatively, into JavaScript
Starting with an FTSetting Up a Basic JavaScript Test RunnerUsing jQuery and the Fixtures DivBuilding a JavaScript Unit Test for Our Desired FunctionalityFixtures, Execution Order, and Global State: Key Challenges of JS Testingconsole.log for Debug PrintingUsing an Initialize Function for More Control Over Execution TimeColumbo Says: Onload Boilerplate and NamespacingJavaScript Testing in the TDD CycleA Few Things That Didn’t Make It
17. Deploying Our New Code
Staging DeployLive DeployWhat to Do If You See a Database ErrorWrap-Up: git tag the New Release
III. More Advanced Topics in Testing
18. User Authentication, Spiking, and De-Spiking
Passwordless AuthExploratory Coding, aka “Spiking”Starting a Branch for the SpikeFrontend Log in UISending Emails from DjangoAnother Secret, Another Environment VariableStoring Tokens in the DatabaseCustom Authentication ModelsFinishing the Custom Django AuthDe-spikingReverting Our Spiked CodeA Minimal Custom User ModelTests as DocumentationA 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 InMocking Manually, aka MonkeypatchingThe Python Mock LibraryUsing unittest.patchGetting the FT a Little Further AlongTesting the Django Messages FrameworkAdding Messages to Our HTMLStarting on the Login URLChecking That We Send the User a Link with a TokenDe-spiking Our Custom Authentication Backend1 if = 1 More TestThe get_user MethodUsing Our Auth Backend in the Login ViewAn Alternative Reason to Use Mocks: Reducing DuplicationUsing mock.return_valuePatching at the Class LevelThe Moment of Truth: Will the FT Pass?It Works in Theory! Does It Work in Practice?Using Our New Environment Variable, and Saving It to .envFinishing Off Our FT, Testing Logout
20. Test Fixtures and a Decorator for Explicit Waits
Skipping the Login Process by Pre-creating a SessionChecking That It WorksOur Final Explicit Wait Helper: A Wait Decorator
21. Server-Side Debugging
The Proof Is in the Pudding: Using Staging to Catch Final BugsInspecting Logs on the ServerAnother Environment VariableAdapting Our FT to Be Able to Test Real Emails via POP3Managing the Test Database on StagingA Django Management Command to Create SessionsGetting the FT to Run the Management Command on the ServerUsing Fabric Directly from PythonRecap: Creating Sessions Locally Versus StagingUpdating our Deploy ScriptWrap-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 TemplatesMoving Down One Layer to View Functions (the Controller)Another Pass, Outside-InA Quick Restructure of the Template Inheritance HierarchyDesigning Our API Using the TemplateMoving Down to the Next Layer: What the View Passes to the TemplateThe Next “Requirement” from the Views Layer: New Lists Should Record OwnerA Decision Point: Whether to Proceed to the Next Layer with a Failing TestMoving Down to the Model LayerFinal Step: Feeding Through the .name API from the Template
23. Test Isolation, and “Listening to Your Tests”
Revisiting Our Decision Point: The Views Layer Depends on Unwritten Models CodeA First Attempt at Using Mocks for IsolationUsing Mock side_effects to Check the Sequence of EventsListen to Your Tests: Ugly Tests Signal a Need to RefactorRewriting Our Tests for the View to Be Fully IsolatedKeep the Old Integrated Test Suite Around as a Sanity CheckA New Test Suite with Full IsolationThinking in Terms of CollaboratorsMoving Down to the Forms LayerKeep Listening to Your Tests: Removing ORM Code from Our ApplicationFinally, Moving Down to the Models LayerBack to ViewsThe Moment of Truth (and the Risks of Mocking)Thinking of Interactions Between Layers as “Contracts”Identifying Implicit ContractsFixing the OversightOne More TestTidy Up: What to Keep from Our Integrated Test SuiteRemoving Redundant Code at the Forms LayerRemoving the Old Implementation of the ViewRemoving Redundant Code at the Forms LayerConclusions: When to Write Isolated Versus Integrated TestsLet Complexity Be Your GuideShould You Do Both?Onwards!
24. Continuous Integration (CI)
Installing JenkinsConfiguring JenkinsInitial UnlockSuggested Plugins for NowConfiguring the Admin UserAdding PluginsTelling Jenkins Where to Find Python 3 and XvfbFinishing Off with HTTPSSetting Up Our ProjectFirst Build!Setting Up a Virtual Display So the FTs Can Run HeadlessTaking ScreenshotsIf in Doubt, Try Bumping the Timeout!Running Our QUnit JavaScript Tests in Jenkins with PhantomJSInstalling nodeAdding the Build Steps to JenkinsMore 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 addCleanupThe Page PatternExtend the FT to a Second User, and the “My Lists” PageAn Exercise for the Reader
26. Fast Tests, Slow Tests, and Hot Lava
Thesis: Unit Tests Are Superfast and Good Besides ThatFaster Tests Mean Faster DevelopmentThe Holy Flow StateSlow Tests Don’t Get Run as Often, Which Causes Bad CodeWe’re Fine Now, but Integrated Tests Get Slower Over TimeDon’t Take It from MeAnd Unit Tests Drive Good DesignThe Problems with “Pure” Unit TestsIsolated Tests Can Be Harder to Read and WriteIsolated Tests Don’t Automatically Test IntegrationUnit Tests Seldom Catch Unexpected BugsMocky Tests Can Become Closely Tied to ImplementationBut All These Problems Can Be OvercomeSynthesis: What Do We Want from Our Tests, Anyway?CorrectnessClean, Maintainable CodeProductive WorkflowEvaluate Your Tests Against the Benefits You Want from ThemArchitectural SolutionsPorts and Adapters/Hexagonal/Clean ArchitectureFunctional Core, Imperative ShellConclusionFurther Reading
Obey the Testing Goat!
Testing Is HardKeep Your CI Builds GreenTake Pride in Your Tests, as You Do in Your CodeRemember to Tip the Bar StaffDon’t Be a Stranger!
A. PythonAnywhere
Running Firefox Selenium Sessions with XvfbSetting Up Django as a PythonAnywhere Web AppCleaning Up /tmpScreenshotsThe Deployment Chapter
B. Django Class-Based Views
Class-Based Generic ViewsThe Home Page as a FormViewUsing form_valid to Customise a CreateViewA More Complex View to Handle Both Viewing and Adding to a ListThe Tests Guide Us, for a WhileUntil We’re Left with Trial and ErrorBack on TrackIs That Your Final Answer?Compare Old and NewBest Practices for Unit Testing CBGVs?Take-Home: Having Multiple, Isolated View Tests with Single Assertions Helps
C. Provisioning with Ansible
Installing System Packages and NginxConfiguring Gunicorn, and Using Handlers to Restart ServicesWhat to Do NextMove Deployment out of Fabric and into AnsibleUse Vagrant to Spin Up a Local VM
D. Testing Database Migrations
An Attempted Deploy to StagingRunning a Test Migration LocallyEntering Problematic DataCopying Test Data from the Live SiteConfirming the ErrorInserting a Data MigrationRe-creating the Old MigrationTesting the New Migrations TogetherConclusions
E. Behaviour-Driven Development (BDD)
What Is BDD?Basic HousekeepingWriting an FT as a “Feature” Using Gherkin SyntaxAs-a /I want to/So thatGiven/When/ThenNot Always a Perfect Fit!Coding the Step FunctionsGenerating Placeholder StepsFirst Step DefinitionsetUp and tearDown Equivalents in environment.pyAnother RunCapturing Parameters in StepsComparing the Inline-Style FTBDD Encourages Structured Test CodeThe Page Pattern as an AlternativeBDD Might Be Less Expressive than Inline CommentsWill Nonprogrammers Write Tests?Some Tentative Conclusions
F. Building a REST API: JSON, Ajax, and Mocking with JavaScript
Our Approach for This AppendixChoosing Our Test ApproachBasic PipingActually Responding with SomethingAdding POSTTesting the Client-Side Ajax with Sinon.jsSinon and Testing the Asynchronous Part of AjaxWiring It All Up in the Template to See If It Really WorksImplementing Ajax POST, Including the CSRF TokenMocking in JavaScriptFinishing the Refactor: Getting the Tests to Match the CodeData Validation: An Exercise for the Reader?
G. Django-Rest-Framework
InstallationSerializers (Well, ModelSerializers, Really)Viewsets (Well, ModelViewsets, Really) and RoutersA Different URL for POST ItemAdapting the Client SideWhat Django-Rest-Framework Gives YouConfiguration Instead of CodeFree Functionality
H. Cheat Sheet
Initial Project SetupThe Basic TDD WorkflowMoving Beyond Dev-Only TestingGeneral Testing Best PracticesSelenium/Functional Testing Best PracticesOutside-In, Test Isolation Versus Integrated Tests, and Mocking
I. What to Do Next
Notifications—Both on the Site and by EmailSwitch to PostgresRun Your Tests Against Different Browsers404 and 500 TestsThe Django Admin SiteWrite Some Security TestsTest for Graceful DegradationCaching and Performance TestingJavaScript MVC FrameworksAsync and WebsocketsSwitch to Using py.testCheck Out coverage.pyClient-Side EncryptionYour Suggestion Here
J. Source Code Examples
Full List of Links for Each ChapterUsing Git to Check Your ProgressDownloading a ZIP File for a ChapterDon’t Let it Become a Crutch!
Bibliography
Index

Overview

By taking you through the development of a real web application from beginning to end, the second edition of this hands-on guide demonstrates the practical advantages of test-driven development (TDD) with Python. You’ll learn how to write and run tests before building each part of your app, and then develop the minimum amount of code required to pass those tests. The result? Clean code that works.

In the process, you’ll learn the basics of Django, Selenium, Git, jQuery, and Mock, along with current web development techniques. If you’re ready to take your Python skills to the next level, this book—updated for Python 3.6—clearly demonstrates how TDD encourages simple designs and inspires confidence.

Dive into the TDD workflow, including the unit test/code cycle and refactoring
Use unit tests for classes and functions, and functional tests for user interactions within the browser
Learn when and how to use mock objects, and the pros and cons of isolated vs. integrated tests
Test and automate your deployments with a staging server
Apply tests to the third-party plugins you integrate into your site
Run tests automatically by using a Continuous Integration environment
Use TDD to build a REST API with a front-end Ajax interface

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Test-Driven Development with Python, 3rd Edition

Publisher Resources

ISBN: 9781491958698Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills