Testing Python: Applying Unit Testing, Tdd, BDD and Acceptance Testing

ISBN-13: 9781118901229 / Angielski / Miękka / 2014 / 240 str.

D Sale

Opis

Fundamental testing methodologies applied to the popular Python language Testing Python; Applying Unit Testing, TDD, BDD and Acceptance Testing is the most comprehensive book available on testing for one of the top software programming languages in the world. Python is a natural choice for new and experienced developers, and this hands-on resource is a much needed guide to enterprise-level testing development methodologies. The book will show you why Unit Testing and TDD can lead to cleaner, more flexible programs. Unit Testing and Test-Driven Development (TDD) are increasingly must-have skills for software developers, no matter what language they work in. In enterprise settings, it's critical for developers to ensure they always have working code, and that's what makes testing methodologies so attractive. This book will teach you the most widely used testing strategies and will introduce to you to still others, covering performance testing, continuous testing, and more.

• Learn Unit Testing and TDD--important development methodologies that lie at the heart of Agile development
• Enhance your ability to work with Python to develop powerful, flexible applications with clean code
• Draw on the expertise of author David Sale, a leading UK developer and tech commentator
• Get ahead of the crowd by mastering the underappreciated world of Python testing

Knowledge of software testing in Python could set you apart from Python developers using outmoded methodologies. Python is a natural fit for TDD and Testing Python is a must-read text for anyone who wants to develop expertise in Python programming.

Spis treści

Introduction 1

CHAPTER 1 A History of Testing 5

You Do Test, Don t You? 7

Fundamentals and Best Practices 7

Python Installation 8

Linux 8

Mac 8

Windows 8

Pip 9

Virtualenv 9

Source Control (SVN, Git) 10

Interactive Development Environment (IDE) 11

Summary 12

CHAPTER 2 Writing Unit Tests 15

What Is Unit Testing? 15

What Should You Test? 17

Writing Your First Unit Test 17

Checking Values with the assertEquals Method 18

Checking Exception Handling with assertRaises 20

Following the PEP–8 Standard 22

Unit Test Structure 23

Additional Unit Test Examples 24

Getting Clever with assertRaises 24

Making Your Life Easier with setUp 25

Useful Methods in Unit Testing 27

assertEqual(x, y, msg=None) 27

assertAlmostEqual(x, y, places=None, msg=None, delta=None) 27

assertRaises(exception, method, arguments, msg=None) 28

assertDictContainsSubset(expected, actual, msg=None) 28

assertDictEqual(d1, d2, msg=None) 28

assertTrue(expr, msg=None) 28

assertFalse(expr, msg=None) 29

assertGreater(a, b, msg=None) 29

assertGreaterEqual(a, b, msg=None) 29

assertIn(member, container, msg=None) 30

assertIs(expr1, expr2) 30

assertIsInstance(obj, class, msg=None) 30

assertNotIsInstance(obj, class, msg=None) 30

assertIsNone(obj, msg=None) 30

assertIsNot(expr1, expr2, msg=None) 31

assertIsNotNone(obj, msg=None) 31

assertLess(a, b, msg=None) 31

assertLessEqual(a, b, msg=None) 31

assertItemsEqual(a, b, msg=None) 31

assertRaises(excClass, callableObj, ∗args, ∗∗kwargs, msg=None) 32

Summary 32

CHAPTER 3 Utilizing Unit Test Tools 33

Using Python s Nose 33

Installing Nose 34

Using Nose s Best Features 35

Running Specifi c Test Files 35

Getting More Detail with Verbose 35

Debugging Support with PDB 36

Checking Your Coverage 38

Coloring your tests with Rednose 39

PyTest: An Alternative Test Runner 40

Installing PyTest 40

PyTest s Best Features 41

Running Specifi c Tests 41

Viewing Detail with Verbose and Summary 42

Debugging with PDB 43

Checking Your Coverage with PyTest 45

Choosing Between Nose and PyTest 46

Mock and Patch Tricky Situations 46

Installing the Mock Library 47

Mocking a Class and Method Response 47

When Mock Won t Do, Patch! 50

The Requests Library 50

Patch in Action 50

Advanced Mocking 52

Summary 53

CHAPTER 4 Writing Testable Documentation 55

Writing Your First Doctest 56

Th e Python Shell 56

Adding Doctests to a Method 57

Running Your Doctests 58

Handling Error Cases 59

Advanced Doctest Usage 61

Improving Doctests with Nose Integration 62

Summary 65

Resources 65

CHAPTER 5 Driving Your Development with Tests 67

Agile Development 67

Adopting the Agile Process Now 68

Ethos of Test Driven Development 70

Advantages of Test Driven Development 72

Ping–Pong Programming 72

Test Driving Your Problem 73

Writing Your Failing Test 74

Making Your Test Pass 75

Driving More Features with Tests 75

Wrapping Up the Task 77

Summary 82

Resources 83

CHAPTER 6 Writing Acceptance Tests 85

What Is Acceptance Testing? 85

Anatomy of an Acceptance Test 87

Using Gherkin Syntax 87

Th e Magic Is in the Step File 88

Goals of Acceptance Testing 89

Implementing Developer and QA Collaboration 90

Letting Behavior Drive Your Problem 90

Writing Your Failing Acceptance Test 90

Defining Your Steps 92

Implementing Your Code 94

Developing More of the Feature 95

bank—apppy 96

indexhtml 97

Delivering the Finished Article 98

Advanced Acceptance Test Techniques 102

Scenario Outline 102

Tables of Data in Scenarios 103

Summary 104

Resources 105

CHAPTER 7 Utilizing Acceptance Test Tools 107

Cucumber: The Acceptance Test Standard 107

Lettuce in Detail 108

Tagging 108

Fail Fast 112

Nosetest Integration 114

Robot: An Alternative Test Framework 115

Installing Robot 116

Writing a Test Case 116

Implementing Keywords 117

Running Robot Tests 119

Summary 123

Resources 123

CHAPTER 8 Maximizing Your Code s Performance 125

Understanding the Importance of Performance Testing 126

JMeter and Python 126

Installation 127

Configuring Your Test Plans 128

Utilizing Your Test Plans Effectively 135

Code Profiling with cProfile 135

Run a cProfile Session 136

Analyzing the cProfile Output 142

Summary 144

Resources 144

CHAPTER 9 Looking After Your Lint 145

Coming to Grips with Pylint 146

Installing Pylint 146

Using Pylint 146

Understanding the Pylint Report 149

The Module Block 149

The Messages by Category Section 149

The Messages Section 150

The Code Evaluation Score 150

The Raw Metrics Section 150

The Statistics by Type Section 150

Customizing Pylint s Output 150

Telling Pylint to Ignore Errors 153

Covering All Your Code with Unit Tests 154

Installing Coverage 155

Using Coverage 155

Advanced Coverage Options 157

Producing an HTML/XML Report 157

Setting a Minimum Coverage Threshold 159

Restricting Coverage to a Specific Package 159

Ignoring Coverage 160

Summary 161

Resources 162

CHAPTER 10 Automating Your Processes 163

Build Paver Tasks 164

Installing Paver 164

Creating a Paver Task 164

Executing Paver Tasks 165

Defi ning a Default Build 166

Setting Up Automated Builds 168

Installing Jenkins 169

Adding Coverage and PyLint Reports 175

Generating a PyLint Report 175

Generating a Coverage Report 176

Making Your Build Status Highly Visible 176

Summary 181

Resources 181

CHAPTER 11 Deploying Your Application 183

Deploying Your Application to Production 184

Creating a Deployable Artifact 185

Defining the Paver Tasks 185

Incorporating Packaging into the Build 187

Enabling Archiving on Jenkins 188

QA Environment 189

Implementing Stage and Production Environments 190

Implementing a Cloud Deployment 191

Creating a Heroku Account 192

Creating a Small Application 193

Setting up Git for Heroku 193

Deploying the Application to Heroku 194

Smoke Testing a Deployed Application 195

Example Application Stack 196

Smoke Test Scenarios 197

Implementing Smoke Tests 198

Summary 200

Resources 201

CHAPTER 12 The Future of Testing Python 203

Stub the Solution 203

Making Deployment Natural 205

Automating (Nearly) Everything 206

Working in Public 207

Collaborating on Step Definitions 208

Final Thoughts 209

Resources 210

Index 211

O autorze

David Sale is currently a software developer for British Sky Broadcasting (BSkyB), where he works predominantly with Python and Java. He quickly began making his presence known in the Python Community, having written web articles on various Python topics. David has also given talks on Behaviour Driven Development and Agile Development at the EuroPython conference. He writes about technology for Nettuts+ and Tech.Pro.

Blurb

• Clearly defines testing fundamentals and best practices
• Provides comprehensive overview of unit testing methods
• Explains how to implement Test Driven Development
• Covers acceptance testing and tools needed to perform acceptance tests

Apply Acceptance Testing, Test–Driven Development, Unit Testing, and Behavior–Driven Development to Python

Unit testing and test–driven development (TDD) are increasingly must–have skills for software developers, no matter what language they work in. In enterprise settings, it s critical for developers to ensure they always have working code, and that s what makes testing methodologies so attractive. More recently, behavior–driven development (BDD) has taken testing to a new level, and this book will introduce you to the practice and tools to take up this exciting modern style of testing your software. This book will teach you the most widely used testing strategies and will introduce to you to still others, covering performance testing, continuous testing, and more. Learn to:

• Get your hands dirty with the basic building blocks in testing: unit tests
• Effectively embed unit tests in your doc strings and have them run as tests
• Adopt the concepts and ethos of test–driven development (TDD)
• Deploy smoke testing and get to grips with Pylint
• Write and undertake acceptance testing with Cucumber, Lettuce, and Robot
• Analyse and find problem areas within your code using JMeter and cProfile
• Successfully implement continuous integration