152 Speciication by Example

Although I’ve mostly presented web applications as examples when talking about user interfaces, the same advice is applicable to other types of user interfaces. Automating just below the skin of the application allows us to validate worklow and session constraints but still shorten the feedback time compared to running tests through the user interface. After looking into managing automation in general, it’s time to cover two speciic areas that caused automation problems for many teams: user interfaces and data management.

Automating user interfaces

When it comes to automation, dealing with user interfaces was the most challenging aspect of Speciication by Example for the teams covered by my research. Almost all the teams I interviewed made the same mistake early on. They speciied tests intended to be automated through user interfaces as series of technical steps, often directly writing user interface automation commands in their speciications.

User interface automation libraries work in the language of screen objects, essentially software design. Describing speciications in that language directly contradicts the key ideas of reining the speciication (see the “Scripts are not speciications” and “Speciications should be about business functionality, not software design” sections in chapter 8). In addition to making speciications hard to understand, this makes automated tests incredibly hard to maintain long term. Pierre Veragen worked on a team that had to throw away all the tests after a small change to the user interface:

User interface tests were task oriented (click, point) and therefore tightly coupled to the implementation of the GUI, rather than activity oriented. There was a lot of duplication in tests. FitNesse tests were organized according to the way UI was set up. When the UI was updated, all these tests had to be updated. The translation from conceptual to technical changed. A small change to the GUI, adding a ribbon control, broke everything. There was no way we could update the tests.

The investment they put into tests up to that point was wasted, because it was easier for them to throw away all those tests than to update them. The team decided to invest in restructuring the architecture of the application to enable easier testing.

If you decide to automate validation for some of your speciications through a user interface, managing that automation layer eficiently is probably going to be one of the key activities for your team. Here are some good ideas on how to automate tests through a user interface and still keep them easy to maintain.

Chapter 9 Automating validation without changing speciications 153

Specify user interface functionality at a higher level of abstraction

Pushing the translation from the business language to the language of user interface objects into the automation layer helps to avoid long-term maintenance problems. This essentially means specifying user interface tests at a higher level of abstraction. Aslak Hellesøy says that this was one of the key lessons he learned early on:

We realized that if we could write tests on a higher level, we could achieve a lot of beneits. This allowed us to change the implementation without having to change a lot of feature scripts. The tests were a lot easier to read, because they were shorter. We had hundreds of these tests, and just by glancing over them it was much easier to see where the things were. They were much more resilient to change.

Lance Walton had a similar experience, which resulted in creating classes in the integration layer that represented operations of user interface screens and then raising the level of abstraction to worklows and inally to higher-level activities. He explains:

We went through the predictable path of writing tests in “type this, click this button” style with lots of repetition between tests. We had a natural instinct to refactor and realized we needed a representation of the screens. I very much go with the early XP rules: If you have a small expression that has a meaning, refactor it to a method and give it a name. It was predictable that we’ll have to log in for every single test, and that should be reusable. I didn’t quite know how to do it, but I knew that was going to happen. So we came up with screen classes.

The next thing to realize was that we kept going through the same sequence of pages—it was a worklow. The next stage was to understand that the worklow still had to do with the solution we designed, so actually let’s forget about worklow and focus on what the user is trying to achieve.

So we had pages that contained the details, then we had the task level above that, then we had the whole worklow on top of that, and then we inally had the goal that the user is trying to achieve. When we got to that level, the tests could be composed very quickly, and they were robust against the changes.

Reorganizing the automation layer to handle activities—and focusing tests on speciications, not scripts—helped reduce the maintenance costs of automated tests signiicantly, Walton said: