Customer Reviews

Python Testing: Beginner's Guide

5 star:		(2)
4 star:		(4)
3 star:		(0)
2 star:		(0)
1 star:		(0)

 

 

I received this book for review from Packt Publishing due to the fact that I have a blog about Python and Bioinformatics. Test driven development preaches that most of the code (ideally all of it) should be wrapped in test functions that will show if your code is producing the right output or not. And this book gives a very nice introduction to the topic if you are using Python as your language of choice. PTBG is a very well written book, with detailed explanations of the major Python tools for test driven development: doctests, unittest, nose, among others.

The book gives short introduction about the topic, but jumps right into the action in the first chapters. One thing that I liked is that the book does not have a introduction to Python section, like many other books that are supposed to be about an specific topic, so you don't waste space and time. Also, PTBG is unique among Python-related books, as there are not many published options about this subject. Of course there's ample material online about test driven development, but if you need a good (introductory) reference book about it, this is the book to buy.

Disclaimer: I received a review copy of this book from the publisher, Packt Publishing.

I have been actively using test-driven development methodology for a few years already so I am probably not exactly in the intended target market of the book. I still managed to pick a few valuable nuggets of information from it, though. As stated in the book description, it is essential that you have already basic knowledge of Python. It's definitely needed.

The book uses extremely practical approach in the expense of theory. It walks the reader through various coding tasks with clear prose. There were times when I felt that the examples were a little bit overwhelming. This should not be much of a problem as long as you are prepared to spend the time on them. In addition to the walkthroughs the book contains some reference information and useful quizzes that can be used to check your knowledge.

It would have been useful to have some background information on testing (ie. history, taxonomy of tools and approaches) as appendices. The book covers the basic testing methodology well but I would have appreciated at least some discussion on advanced approaches (ie. BDD, ATDD, refactoring, fuzz testing, etc.).

All things considered if you decide to pick up the book, it might be a good idea to look into additional material focusing on theory of testing, testing patterns and agile methodologies for enhanced understanding of the subject matter.

I've recently had the pleasure of reading "Python Testing: An easy and convenient approach to testing your python projects" from Packt Publishing. It's been a quick read but a solid set of instructions on the different methods for the subject.

The book starts out very quickly with details about the various methods that are available, the means of automation for testing, and of course the environment you'd want to be in for working on the subjects that the book covers. It then, in the second chapter, moves into the guts of testing by describing the basics of doctest via syntax and some simple examples, and then moves on to a real world example via the AVL tree. It's all very basic testing until chapter three where the author gets into unit testing, which is probably the most useful method in my opinion, and he goes to prove it's usefulness with examples of it's use in different parts and stages of the development process. Later in the book the python mocker is used to separate unit sections, and then the actual unittest framework is discussed with more examples and a enough details that if you don't understand it by then, you may never. By chapter six we are into the Nose app that drives the unittest, which is very useful of course.

The most useful part of the book comes toward the end where the author discusses and the walks through the method used to create a test-driven application and then even shows examples via the whole chapter dedicated towards making a testable web application frontend. Very impressive for such a quick read. Integration testing and System testing is also covered, thankfully. The final chapter covers some useful tools and techniques of which I particularly enjoyed the section on version control hooks. If you are not using version control in your development process you need to start now, as such the hooks for integration with the test framework are rather useful to know.

Overall this is a very nice book that discusses python application testing from the ground up. It's perfect for a beginner or an intermediate python programmer that has little to no experience in automated testing methods. More advanced programmers that have already used these methods will probably not find the book too useful except for the last chapter that covers extra tools and techniques that they might not have seen before. If I didn't have this book and needed to learn about python testing, it would be my first choice and my only recommendation so far. Well written and very useful.

If there is one thing I do not like about the book, it would be the reliance on the python CLI for running commands. I am a CLI kind of person and I keep lots of terminals open at the same time, so I prefer to write my code in an editor or IDE in one term tab, then switch to another and execute the script; I do not use the python command line to do much of anything. So following some of the steps in the book require that you follow the CLI method and that gets old for me. It's a personal preference but one worth noting as there is a lot of it in the book. That's the only thing I did not enjoy in a book that was otherwise basically perfect for the subject.

First of all, let me say that this review will be rather long and comprehensive, so if you want a short summary: **Buy this book if you are a python programmer, who is interested in best-practices and test driven development.**

I'm a professional programmer, and I use python as well as Django (one of the large python web frameworks) at work and for fun. I picked up this book immediately when I saw it on amazon because I've read tons of documents, articles, and books on test driven development, but have never had the pleasure of reading through a python-specific book for testing.

**Target Audience**

This book is written for developers who:

- Are comfortable with python programming.

- Are familiar with the concept of testing.

- Are interested in using industry standard best practices for development.

If you meet these requirements, read on.

**Approach**

The author, Daniel Arbuckle, takes a practical approach to testing. He starts with the basics, by converting human written program specifications into simple python doctests.

Then he discusses unit tests, mock objects, and continuous building tools.

Throughout the book, you will learn about each form of test, why it is useful, how it should be used and why. The author walks through several programs from start to finish, clearly breaking them down piece by piece, and explaining how they work, and why.

There is no shortage of examples.

**Good Parts**

I absolutely LOVED the writing style used throughout the book. It is brisk, conversational, and you can tell that the author has a lot of passion for the topic.

There are a lot of great examples used throughout the book. They are all clearly explained.

The organization of the content is great. The book starts our simple, and works up to complex topics.

**Bad Parts**

I'm not sure why--but the last chapter of the book seemed rushed. This is the chapter that contains continuous build systems and version control hooks. The author discusses buildbot, which is an amazingly powerful tool, but only spends a few pages talking about it, and doesn't include enough information about how it works, or how to configure it, to make it useful.

In the last chapter, the author is also inconsistent. When discussing version control test hooks, he shows full examples for a number of version control systems: bazaar, git, mercurial, and some others. But when he discusses buildbot integration, he *only* mentions bazaar, which I found odd.

**Conclusion**

This book is well worth the money, and is getting a 5 star review, even though the last chapter seemed rushed. I wouldn't recommend this book to a programmer who has never heard of testing before, but if they know the basics of testing, then this book is amazing. It will give them all the information they need to get started with test driven development, and the knowledge to automate their tests in an efficient manner.

You can't live without testing these days. It is easy, fun, and most importantly, successful. It will improve your design, reduce your bugs, and increase your confidence in your codebase.

Every programmer writing python code should read this book, and follow its practices for all of their projects.

From the perspective of a beginning python developer, having inherited a system that needs a lot more testing, spending the 2-3 days working through this book was a good investment of time. Python has this bewildering range of frameworks, and even the best non-testing framework documentation only give an overview of the process of building the QA suite from the ground up.

It covers the following frameworks, each in its own chapter.

-Doctest (the most simple and basic python tester, part of standard library)

-Unittest (more advanced testing framework easier to automate

-Mocker (using mock objects as stubs to isolate code that isn't by its nature isolated. This one was a complete revelation to me and worth the price of the book alone)

-Nose (test automation suite - a definite time-saver).

Plus several chapters that are a range of reused examples that gradually works up the testing stack from unit testing through integration testing to system testing, in bite-sized chunks and with a - to me - agreeably informal and motivating style.

It isn't perfect. Two minuses:

1. Python is a very dynamic area, and it is python 2.6 centric. 2.7 and 3.1 are already out there, and understandably not covered.

2. Check for the source code to avoid massive frustration. I was reading it electronically so cut-and-pasted, but the e-publisher had done some automatic formatting to remove leading blanks, insert lines for readability. Python, of course, needs those leading blanks. And doctest, too, treats blank lines as significant.

It is very rare to find a book that covers testing in the software world. Testing is something that authors will briefly mention on programming books and if you're lucky you may even find a couple of lines of code related to the subject. So it was with great excitement that I purchased "Python Testing: Beginner's Guide"by Daniel Arbuckle!.

For the longest time I have wanted to start wrapping my code in testing functions so to improve the quality and reliability of what I write here at work. This book does a pretty decent job at introducing the reader to several of the major Python tools for test driven development such as doctests, unittest, nose, etc. Contrary to the recurring method of going through chapter upon chapter of introductory background information, the author (much to my delight) chose to hit the ground running and get right to the point. All chapters are filled to the brim with detailed examples and sample code to follow along, though some of the use cases felt a bit too specific to a given area and not something the broader audience can relate to.

For good or bad, this book expects that the reader is well versed in Python and the generic idea behind why test driven development is a good thing. So if you're missing one of these "requirements", you should probably pick up some additional material (check out "Expert Python Programming" by Tarek Ziadé).

Overall, I recommend this book for the Python coder out there who takes pride in their code and want to start delivering quality over quantity.