Agile testing is a useful book, a decent introduction to somewhat neglected aspect of agile software development. It is also a book that could have benefitted from a sharper focus and more editing.
There are plenty of books on agile for project managers and programmers, testers are not so fortunate. Strange when you think about it. Testing is more profoundly affected than programming. Good programmers have been doing programming and unit and integration testing in parallel for ages, since long before agile became a buzzword. Testers in good organisations might have been involved from the start of the project even in staged projects, but their work was clearly divided into distinct planning and execution phases, and they had at best an arms-length relationship to the programmers. In agile they work closely with the programmers in cross-functional teams, concurrently designing and executing tests. They are no longer the gatekeepers to production, the quality police. Indeed, there is no strict delineation between the role of programmers and testers. Programmers test, testers pair with programmers in behaviour and test-driven development,
The agile and lean processes also have other profound implications for how testing is done. They prescribe frequent delivery of working software, in lean even on continuous delivery. That cannot be done without automation. Doing comprehensive regression testing manually will just take too long.
So, a book on agile testing is absolutely called for. This contains a lot of useful information. The most useful part of the book, is the division of testing into a two-by-two matrix. Along one axis you divide tests into those that support development and those that critique the product, along the other into those that are technology-facing and those that are business-facing.
In Quadrant 1, technology-facing tests that support development, you find unit, component and integration tests, the tests of test-driven development, the tests that usually are automated using frameworks such as JUnit. More often than not these are done by programmers, but on agile teams testers should not be shy to help.
In Quadrant 2, business-facing tests that support development, you find system-level functional tests, but also prototypes of various fidelities for user experience testing. The functional tests in this quadrant should be stated in the language of the users. The test serve as functional design artifacts for the system. These are the tests of behaviour- or example-driven development that can be automated using frameworks such as Fit, Fitnesse or Cucumber. Most of these tests should be done below the GUI layer, as the GUI usually is more fluid and GUI tests brittle. These tests should also be automated. Quite a departure for testers used to manually test against specification through the GUI.
In Quadrant 3, business-facing tests that critique the product, you find among other things exploratory testing, demonstrations, user-acceptance testing and usability testing. Exploratory testing is not the same as ad-hoc testing, it is a process of concurrent test design and execution, testing based on hypotheses ("smells") and learning. It can be highly effective in finding those insidious bugs, but without automation in the first two quadrants, there will rarely be enough time for this. Demonstrations, user-acceptance testing and usability testing are different in that they often involve people from outside the team.
In Quadrant 4, technology-facing tests that critique the product, you find tests of the -ilities, non-functional attributes such as performance and security. Interestingly the authors here include static analysis, which is not really a form of testing, but rather automated variants of that other family of quality control techniques, inspections. Manual inspections, in agile often done as pair-programming, is only lightly touched on in the book.
The authors stress that the four quadrants says nothing about when the different types of tests should be performed. If feasible and productive, they are all done in the sprints, but sometimes it can only be done later in the end game of the release.
The book also include parts on what testers should do in the various stages of an agile project such as release planning, sprint planning, during the sprint, after the sprint and at the end of the release; and how to handle the change from staged to incremental development - both organisational change and changes to the test of legacy software. These parts are unfortunately not as to-the-point as the part on the test quadrants. The authors seem to be repeating themselves and also rehashing a lot of non-test-specific material on agile. The book could have done with a sharper focus on testing and more editing, dare I say it -- yes, refactoring. As it is, it is a bit lengthy and somewhat trite. A final note, this is a book that will start showing its age as the tool landscape is changing rapidly, but this is not a major problem as the book is not handbook in using the various tools.