Chapter 9. Acceptance TDD explained

In the spacecraft business no design can survive the review process, without first answering the question—how are we going to test this thing?

Glen B. Alleman, Director Strategic Consulting for Lewis & Fowler

In the previous chapters, we have explored the developer-oriented practice of test-driven development, covering the fundamental process itself as well as a host of techniques for employing TDD on a variety of Java technologies. In this chapter, we’ll take the core idea of TDD and apply it to the overall product development process.

TDD helps software developers produce working, high-quality code that’s maintainable and, most of all, reliable. Our customers are rarely, however, interested in buying code. Our customers want software that helps them to be more productive, make more money, maintain or improve operational capability, take over a market, and so forth. This is what we need to deliver with our software—functionality to support business function or market needs. Acceptance test-driven development (acceptance TDD) is what helps developers build high-quality software that fulfills the business’s needs as reliably as TDD helps ensure the software’s technical quality.

Acceptance TDD helps coordinate software projects in a way that helps us deliver exactly what the customer wants when they want it, and that doesn’t let us implement the required functionality only half way. In this chapter, we will learn what acceptance test-driven development is, why we should consider doing it, what these mysterious acceptance tests are, and how acceptance TDD integrates with TDD.

Acceptance test-driven development as a name sounds similar to test-driven development, doesn’t it? So, what’s the difference between the two? Surely it has something to do with the word acceptance prefixed onto TDD, but is there something else beneath the surface that differentiates the two techniques? What exactly are these acceptance tests? And what are we accepting with our tests in the first place? These are the questions we’re going to find answers to as we start our journey into the world of acceptance tests and acceptance test-driven development.

We’ll begin by describing a lightweight and extremely flexible requirements format called user stories. After all, we need to know how our system should behave, and that’s exactly what user stories tell us. From there, we’ll continue by exploring what acceptance tests are and what kinds of properties they should exhibit. By then, we will know what our requirements—the user stories—might look like, and we will know how our acceptance tests should look, which means we’ll be ready to figure out how we work with these artifacts or what the process of acceptance TDD looks like.

An essential property of acceptance TDD is that it’s a team activity and a team process, which is why we’ll also discuss team-related topics such as the roles involved and who might occupy these roles. We’ll also ask ourselves why we should do this and respond by identifying a number of benefits of acceptance TDD. Finally, we’ll talk about what exactly we are testing with our acceptance tests and what kind of tools we have at our disposal.

But now, let us introduce ourselves with a handy requirements format we call user stories.

9.1. Introduction to user stories

User stories are an extremely simple way to express requirements. In its classic form, a user story is a short sentence stating who does what and why. In practice, most stories just tell us who and what, with the underlying motivation considered apparent from the context. The reason a story is typically only one sentence long (or, in some cases, just one or two words that convey meaning to the customer and developers) is that the story is not intended to document the requirement. The story is intended to represent the requirement, acting as a promise of a future conversation between the customer and the developer.

9.1.1. Format of a story

A number of people have suggested writing user stories that follow an agreed format such as “As a (role) I want (functionality) so that (benefit).” However, I and a number of other proponents of user stories for requirements management recommend not fixing the format as such but focusing on the user story staying on a level of detail that makes sense, using terms that make sense to the customer. This is not to say that such a template would be a bad idea—which it isn’t; it’s just that one size doesn’t fit all, and the people in your organization might feel differently about the format than I do.^[1]

¹ Ron Jeffries, “Essential XP: Card, Conversation, Confirmation,” XP Magazine, August 30, 2001.

9.1.2. Power of storytelling

Hannah Arendt, a German political scientist, has said, “storytelling reveals meaning without committing the error of defining it.”^[2] This particular quote eloquently communicates how user stories focus on meaning without stumbling on nitty-gritty details.

² Hannah Arendt, Men in Dark Times (Harvest Books, 1970).

User stories are in many ways a form of storytelling, which is an effective medium for transferring knowledge. For one, people like listening to stories. Storytellers are good at keeping our attention—a lot more so than, say, structured documents of equal volume—and it’s not just audible stories that have this advantage; prose with a storyline and context is far more interesting reading than a seemingly unconnected sequence of statements.

Let’s see how much this property shows through in practice by looking at a couple of examples of user stories.

9.1.3. Examples of user stories

To get a better idea of what user stories look like, here are some examples of the kinds of user stories I personally tend to write:

These user stories express just enough for the customer to be able to prioritize the feature in relation to other features and for the developer to be able to come up with a rough effort estimate for the story. Yet these stories don’t burden the developer by prescribing the implementation, and they don’t drown the team with excessive detail.

The first story about a technical-support application doesn’t tell us what the screen will look like; and the second story doesn’t talk about desktop shortcuts, scanning process listings, and so on. They convey what provides value to the customer—not how the system should provide that value. The third story is a bit different. It’s clearly a technical user story, not having much to do with business functionality. It does, however, have enabling value, and it expresses that need in a clear manner. Furthermore, although harder to quantify, some technical stories might create value for the customer through lower total cost of ownership.

That’s about all we’re going to say about user stories for now. For a more in-depth description of user stories as a requirements management and planning tool, a great pick would be Mike Cohn’s book User Stories Applied (Addison-Wesley, 2004).

As we already mentioned, the format of a user story doesn’t matter all that much as long as it communicates the necessary information—who, what, why—to all involved parties, either explicitly or implicitly. In fact, just like the format of a story isn’t one-size-fits-all, using stories as a requirements-management or planning tool isn’t in any way a requirement for doing acceptance test-driven development—it’s a natural fit.

Now that we know what the mysterious stories are (or what they can be), let’s figure out what we mean by acceptance tests.

9.2. Acceptance tests

Acceptance tests are specifications for the desired behavior and functionality of a system. They tell us, for a given user story, how the system handles certain conditions and inputs and with what kinds of outcomes. There are a number of properties that an acceptance test should exhibit; but before taking a closer look, let’s see an example.

9.2.1. Example tests for a story

Let’s consider the following example of a user story and see what our acceptance tests for that particular story might look like. I present you figure with 9.1.

The functionality that we’re interested in is for the system to obtain and display the customer’s history of records when a call comes through the customer support system. I might, for example, think of the tests for this story that are scribbled down as figure 9.2.

These three tests would essentially tell us whether the system behaves correctly from the perspective of a user—conditions of satisfaction. They tell us nothing about how the system implements that behavior.

Now, with these example tests in mind, let’s look at some essential properties of acceptance tests, starting with who owns them and who writes them.

9.2.2. Properties of acceptance tests

So far, you’ve probably deduced that acceptance tests are typically short and somewhat informal. There’s more to the nature of acceptance tests, however, and next we’re going to look at some general properties.

To make a long story short, acceptance tests are

Let’s expand these sound bites one by one and see what they mean.

Owned by the customer

Acceptance tests should be owned by the customer because their main purpose is to specify acceptance criteria for the user story, and it’s the customer—the business expert—who is best positioned to spell out those criteria. This also leads to the customer being the one who should ideally be writing the acceptance tests.

Having the customer write the acceptance tests helps us avoid a common problem with acceptance tests written by developers: Developers often fall into the pit of specifying technical aspects of the implementation rather than specifying the feature itself. And, after all, acceptance tests are largely a specification of functionality rather than tests for technical details (although sometimes they’re that, too).

Written together

Even though the customer should be the one who owns the acceptance tests, they don’t need to be the only one to write them. Especially when we’re new to user stories and acceptance tests, it is important to provide help and support so that nobody ends up isolating themselves from the process due to lack of understanding and, thus, being uncomfortable with the tools and techniques. By writing tests together, we can encourage the communication that inevitably happens when the customer and developer work together to specify the acceptance criteria for a story.

With the customer in their role as domain expert, the developer in the role of a technical expert, and the tester in a role that combines a bit of both, we’ve got everything covered. Of course, there are times when the customer will write stories and acceptance tests by themselves—perhaps because they were having a meeting offsite or because they didn’t have time for a discussion about the stories and their accompanying tests.

The same goes for a developer or tester who occasionally has to write acceptance tests without access to the customer. On these occasions, we’ll have to make sure that the necessary conversation happens at some point. It’s not the end of the world if a story goes into the backlog with a test that’s not ideal. We’ll notice the problem and deal with it eventually. That’s the beauty of a simple requirement format like user stories!

Another essential property for good acceptance tests ties in closely with the customer being the one who’s writing the tests: the focus and perspective from which the tests are written.

Focus on the what, not the how

One of the key characteristics that make user stories so fitting for delivering value early and often is that they focus on describing the source of value to the customer instead of the mechanics of how that value is delivered. User stories strive to convey the needs and wants—the what and why—and give the implementation—the how—little attention. In the vast majority of cases, the customer doesn’t care how the business value is derived.^[3]

³ Well, they shouldn’t. Part of the reason many customers like to dictate the how is our lousy track record as an industry. It’s time to change that flawed perception by showing that we can deliver what the customer wants as long as we get constant feedback on how we’re doing.

Let’s look at an example to better illustrate this difference between what and why and how. Figure 9.3 shows an example of acceptance tests that go into too much detail about the solution rather than focusing on the problem—the customer’s need and requirement. All three tests shown on the card address the user interface—effectively suggesting an implementation, which isn’t what we want. While doing that, they’re also hiding the real information—“what are we actually testing here?”—behind the technology.

Instead, we should try to formulate our tests in terms of the problem and leave the solution up to the developers and the customer to decide and discuss at a later time when we’re implementing the tests and the story itself. Figure 9.4 illustrates a possible rewrite of the tests in figure 9.3 in a way that preserves the valuable information and omits the unnecessary details, which only clutter our intent.

Notice how, by reading these three lines, a developer is just as capable of figuring out what to test as they would be by reading the more solution-oriented tests from figure 9.3. Given these two alternatives, which would you consider easier to understand and parse? The volume and focus of the words we choose to write our tests with have a big effect on the effectiveness of our tests as a tool. We shouldn’t neglect that fact.

There’s more to words, though, than just volume and focus. We also have to watch for our language.

Use the language of the domain

An important property of acceptance tests is that they use the language of the domain and the customer instead of geek-speak only the programmer understands. This is the fundamental requirement for having the customer involved in the creation of acceptance tests and helps enormously with the job of validating that the tests are correct and sufficient. Scattering too much technical lingo into our tests makes us more vulnerable to having a requirement bug sneak into a production release—because the customer’s eyes glaze over when reading geek-speak and the developers are drawn to the technology rather than the real issue of specifying the right thing.

By using a domain language in specifying our tests, we are also not unnecessarily tied to the implementation, which is useful since we need to be able to refactor our system effectively. By using domain language, the changes we need to make to our existing tests when refactoring are typically non-existent or at most trivial.

Concise, precise, and unambiguous

Largely for the same reasons we write our acceptance tests using the domain’s own language, we want to keep our tests simple and concise. We write each of our acceptance tests to verify a single aspect or scenario relevant to the user story at hand. We keep our tests uncluttered, easy to understand, and easy to translate to executable tests. The less ambiguity involved, the better we are at avoiding mistakes and the working with our tests.

We might write our stories as simple reminders in the form of a bulleted list, or we might opt to spell them out as complete sentences describing the expected behavior. In either case, the goal is to provide just enough information for us to remember the important things we need to discuss and test for, rather than documenting those details beforehand. Card, conversation, confirmation—these are the three Cs that make up a user story. Those same three Cs could be applied to acceptance tests as well.

Remember the acceptance tests we saw earlier, for the story about a customer support system? Take another look at them, back in figure 9.2.

Would you say these tests are simple and concise? Perhaps you would. Perhaps you wouldn’t. Personally, I’d say there are some things in these tests that could be safely omitted while still preserving enough information to carry the original intent, and some things that shouldn’t be there. Figure 9.5 shows a revamp of the same tests shown in figure 9.2.

Notice the difference in conciseness? Notice how the developer would still know to test for the right things, provided they can ask the customer for the details, such as what kind of a message should be displayed for a non-existent account number or when the number is omitted altogether? The tests in figure 9.5 can be considered more accurate than the tests in figure 9.2 because they omit details that could change by the time we get around to implementing the story.

Obviously, some prefer to have more details written down for the acceptance tests than do others. Whether you’re into more text or less, or whether you prefer sketching little diagrams and UI designs as part of your user stories and the accompanying acceptance tests, it’s up to you and your team to decide. It’s all good as long as you remember to keep your acceptance tests simple and concise, and as long as you avoid writing down ambiguous things that can be interpreted wrongly at a later stage. Specifically, avoid writing down details that are easy to find out later and that don’t add crucial information for estimating the size of the story.

The last property of acceptance tests that we’ll list here has more to do with automating the tests than the way or form in which they’re written.

9.2.3. Implementing acceptance tests

Yet another common property of acceptance tests is that they might not be implemented (translation: automated) using the same programming language as the system they are testing. Whether this is the case depends on the technologies involved and on the overall architecture of the system under test. For example, some programming languages are easier to interoperate with than others. Similarly, it is easy to write acceptance tests for a web application through the HTTP protocol with practically any language we want, but it’s often impossible to run acceptance tests for embedded software written in any language other than that of the system itself.

The main reason for choosing a different programming language for implementing acceptance tests than the one we’re using for our production code (and, often, unit tests) is that the needs of acceptance tests are often radically different from the properties of the programming language we use for implementing our system. To give you an example, a particular real-time system might be feasible to implement only with native C code, whereas it would be rather verbose, slow, and error-prone to express tests for the same real-time system in C compared to, for example, a scripting language.

The ideal syntax for expressing our acceptance tests could be a declarative, tabular structure such as a spreadsheet, or it could be something closer to a sequence of higher-level actions written in plain English. If we want to have our customer collaborate with developers on our acceptance tests, a full-blown programming language such as Java, C/C++, or C# is likely not an option. “Best tool for the job” means more than technically best, because the programmer’s job description also includes collaborating with the customer.

Now that we know something about acceptance tests and we have an idea of who’s writing the tests in the first place, let’s see how we use them to drive our development. What does acceptance test-driven development look like on paper?

9.3. Understanding the process

Test-driven development gives a programmer the tools for evolving their software in small steps, always certain of the software working as expected. This certainty comes from the programmer expressing their expectations in the form of automated unit tests. In acceptance test-driven development, this certainty is gained not on the level of technical correctness but rather on the feature level of, “does the software do what I want it to do?”

In other words, although in TDD we’re first defining the specific behavior we want our code base to exhibit and only then implementing the said behavior, in acceptance TDD we first define the specific user- or customer-valued functionality we want our system as a whole to exhibit and only then implement the said behavior, most likely using TDD as our vehicle of choice.

Because we know what acceptance tests look like, how about if we take a quick tour through the overall process of acceptance test-driven development and then broaden our view and look at what happens on the scale of a whole iteration? After that, we can go back and zoom in on the details of the more interesting bits.

But now, I present you with the process of acceptance test-driven development, distilled into four small steps.

9.3.1. The acceptance TDD cycle

In its simplest form, the process of acceptance test-driven development can be expressed as the simple cycle illustrated by figure 9.6.

This cycle continues throughout the iteration as long as we have more stories to implement, starting over again from picking a user story; then writing tests for the chosen story, then turning those tests into automated, executable tests; and finally implementing the functionality to make our acceptance tests pass.

In practice, of course, things aren’t always that simple. We might not yet have user stories, the stories might be ambiguous or even contradictory, the stories might not have been prioritized, the stories might have dependencies that affect their scheduling, and so on. We’ll get to these complications later. For now, let’s keep our rose-tinted glasses on and continue thinking about the simple steps outlined previously. Speaking of steps, let’s take a closer look at what those steps consist of.

Step 1: Pick a user story

The first step is to decide which story to work on next. Not always an easy job; but, fortunately, most of the time we’ll already have some relative priorities in place for all the stories in our iteration’s work backlog. Assuming that we have such priorities, the simplest way to go is to always pick the story that’s on top of the stack—that is, the story that’s considered the most important of those remaining. Again, sometimes, it’s not that simple.

Generally speaking, the stories are coming from the various planning meetings held throughout the project where the customer informally describes new features, providing examples to illustrate how the system should work in each situation. In those meetings, the developers and testers typically ask questions about the features, making them a medium for intense learning and discussion. Some of that information gets documented on a story card (whether virtual or physical), and some of it remains as tacit knowledge. In those same planning meetings, the customer prioritizes the stack of user stories by their business value (including business risk) and technical risk (as estimated by the team).

What kinds of issues might we have when picking stories from this stack of user stories? There are times when the highest-priority story requires skills that we don’t possess, or we consider not having enough of. In those situations, we might want to skip to the next task to see whether it makes more sense for us to work on it. Teams that have adopted pair programming don’t suffer from this problem as often. When working in pairs, even the most cross-functional team can usually accommodate by adjusting their current pairs in a way that frees the necessary skills for picking the highest priority task from the pile.

There can be more issues to deal with regarding picking user stories, but most of the time the solution comes easily through judicious application of common sense. For now, let’s move on to the second step in our process: writing tests for the story we’ve just picked.

Step 2: Write tests for a story

With a story card in hand (or onscreen if you’ve opted for managing your stories online), our next step is to write tests for the story. If you paid attention earlier in this chapter, we just learned that it’s the customer who should be writing the tests. So how does this play out?

The first thing to do is, of course, get together with the customer. In practice, this means having a team member sit down with the customer (they’re the one who should own the tests, remember?) and start sketching out a list of tests for the story in question.

As usual, there are personal preferences for how to go about doing this, but my current preference (yes, it changes from time to time) is to quickly scram out a list of rough scenarios or aspects of the story we want to test in order to say that the feature has been implemented correctly. There’s time to elaborate on those rough scenarios later on when we’re implementing the story or implementing the acceptance tests. At this time, however, we’re only talking about coming up with a bulleted list of things we need to test—things that have to work in order for us to claim the story is done.

We already saw a couple of examples of the kind of tests we’re referring to when we discussed the properties of acceptance tests. For example, you might want to peek back at figure 9.4, showing three tests on the back of a story card. That is the kind of rough list we’re after in this step.

Once we have such a rough list, we start elaborating the tests, adding more detail and discussing about how this and that should work, whether there are any specifics about the user interface the customer would like to dictate, and so forth. Depending on the type of feature, the tests might be a set of interaction sequences or flows, or they might be a set of inputs and expected outputs. Often, especially with flow-style tests, the tests specify some kind of a starting state, a context the test assumes is part of the system.

Other than the level of detail and the sequence in which we work to add that detail, there’s a question of when—or whether—to start writing the tests into an executable format. Witness step 3 in our process: automating the tests.

Step 3: Automate the tests

The next step once we’ve got acceptance tests written down on the back of a story card, on a whiteboard, in some electronic format, or on pink napkins, is to turn those tests into something we can execute automatically and get back a simple pass-or-fail result. Whereas we’ve called the previous step writing tests, we might call this step implementing or automating those tests.

In an attempt to avoid potential confusion about how the executable acceptance tests differ from the acceptance tests we wrote in the previous step, let’s pull up an example. Remember the acceptance tests in figure 9.5? We might turn those tests into an executable format by using a variety of approaches and tools. The most popular category of tools (which we’ll survey later) these days seems to be what we call table-based tools. Their premise is that the tabular format of tables, rows, and columns makes it easy for us to specify our tests in a way that’s both human and machine readable. Figure 9.7 presents an example of how we might draft an executable test for the first test in figure 9.5, “Valid account number”.

In figure 9.7, we’ve outlined the steps we’re going to execute as part of our executable test in order to verify that the case of an incoming support call with a valid account number is handled as expected, displaying the customer’s information onscreen. Our test is already expressed in a format that’s easy to turn into a tabular table format using our tool of choice—for example, something that eats HTML tables and translates their content into a sequence of method invocations to Java code according to some documented rules.

Java code? Where did that come from? Weren’t we just talking about tabular formats? The inevitable fact is that most of the time, there is not such a tool available that would understand our domain language tests in our table format and be able to wire those tests into calls to the system under test. In practice, we’ll have to do that wiring ourselves anyway—most likely the developers or testers will do so using a programming language. To summarize this duality of turning acceptance tests into executable tests, we’re dealing with expressing the tests in a format that’s both human and machine readable and with writing the plumbing code to connect those tests to the system under test.

With regard to writing things down (and this is probably not coming as a surprise), there are variations on how different teams do this. Some start writing the tests right away into electronic format using a word processor; some even go so far as to write them directly in an executable syntax. Some teams run their tests as early as during the initial authoring session. Some people, myself included, prefer to work on the tests alongside the customer using a physical medium, leaving the running of the executable tests for a later time. For example, I like to sketch the executable tests on a whiteboard or a piece of paper first, and pick up the computerized tools only when I’ve got something I’m relatively sure won’t need to be changed right away.

The benefit is that we’re less likely to fall prey to the technology—I’ve noticed that tools often steal too much focus from the topic, which we don’t want. Using software also has this strange effect of the artifacts being worked on somehow seeming more formal, more final, and thus needing more polishing up. All that costs time and money, keeping us from the important work.

In projects where the customer’s availability is the bottleneck, especially in the beginning of an iteration (and this is the case more often than not), it makes a lot of sense to have a team member do the possibly laborious or uninteresting translation step on their own rather than keep the customer from working on elaborating tests for other stories. The downside to having the team member formulate the executable syntax alone is that the customer might feel less ownership in the acceptance tests in general—after all, it’s not the exact same piece they were working on. Furthermore, depending on the chosen test-automation tool and its syntax, the customer might even have difficulty reading the acceptance tests once they’ve been shoved into the executable format dictated by the tool.

Just for laughs, let’s consider a case where our test-automation tool is a framework for which we express our tests in a simple but powerful scripting language such as Ruby. Figure 9.8 highlights the issue with the customer likely not being as capable of feeling ownership of the implemented acceptance test compared to the sketch, which they have participated in writing. Although the executable snippet of Ruby code certainly reads nicely to a programmer, it’s not so trivial for a non-technical person to relate to.

Another aspect to take into consideration is whether we should make all tests executable to start with or whether we should automate one test at a time as we progress with the implementation. Some teams—and this is largely dependent on the level of certainty regarding the requirements—do fine by automating all known tests for a given story up front before moving on to implementing the story.

Some teams prefer moving in baby steps like they do in regular test-driven development, implementing one test, implementing the respective slice of the story, implementing another test, and so forth. The downside to automating all tests up front is, of course, that we’re risking more unfinished work—inventory, if you will—than we would be if we’d implemented one slice at a time. My personal preference is strongly on the side of implementing acceptance tests one at a time rather than try getting them all done in one big burst.^[4]

⁴ It should be mentioned, though, that elaborating acceptance tests toward their executable form during planning sessions could help a team understand the complexity of the story better and, thus, aid in making better estimates.

Many of the decisions regarding physical versus electronic medium, translating to executable syntax together or not, and so forth also depend to a large degree on the people. Some customers have no trouble working on the tests directly in the executable format (especially if the tool supports developing a domain-specific language). Some customers don’t have trouble identifying with tests that have been translated from their writing. As in so many aspects of software development, it depends.

Regardless of our choice of how many tests to automate at a time, after finishing this step of the cycle we have at least one acceptance test turned into an executable format; and before we proceed to implementing the functionality in question, we will have also written the necessary plumbing code for letting the test-automation tool know what those funny words mean in terms of technology. That is, we will have identified what the system should do when we say “select a transaction” or “place a call”—in terms of the programming API or other interface exposed by the system under test.

To put it another way, once we’ve gotten this far, we have an acceptance test that we can execute and that tells us that the specified functionality is missing. The next step is naturally to make that test pass—that is, implement the functionality to satisfy the failing test.

Step 4: Implement the functionality

Next on our plate is to come up with the functionality that makes our newly minted acceptance test(s) pass. Acceptance test-driven development doesn’t say how we should implement the functionality; but, needless to say, it is generally considered best practice among practitioners of acceptance TDD to do the implementation using test-driven development—the same techniques we’ve been discussing in the previous parts of this book.

In general, a given story represents a piece of customer-valued functionality that is split—by the developers—into a set of tasks required for creating that functionality. It is these tasks that the developer then proceeds to tackle using whatever tools necessary, including TDD. When a given task is completed, the developer moves on to the next task, and so forth, until the story is completed—which is indicated by the acceptance tests executing successfully.

In practice, this process means plenty of small iterations within iterations. Figure 9.9 visualizes this transition to and from test-driven development inside the acceptance TDD process.

As we can see, the fourth step of the acceptance test-driven development cycle, implementing the necessary functionality to fix a failing acceptance test, can be expanded into a sequence of smaller TDD cycles of test-code-refactor, building up the missing functionality in a piecemeal fashion until the acceptance test passes.

The proportions in the figure should not be considered to reflect reality, however. Whereas the TDD cycle might range from one minute to a dozen, we might be chopping out code for a couple of hours or even the whole day before the acceptance test is passing.

While the developer is working on a story, frequently consulting with the customer on how this and that ought to work, there will undoubtedly be occasions when the developer comes up with a scenario—a test—that the system should probably handle in addition to the customer/developer writing those things down. Being rational creatures, we add those acceptance tests to our list, perhaps after asking the customer what they think of the test. After all, they might not assign as much value to the given aspect or functionality of the story as we the developers might.

At some point, we’ve iterated through all the tasks and all the tests we’ve identified for the story, and the acceptance tests are happily passing. At this point, depending on whether we opted for automating all tests up front (which I personally don’t recommend) or automating them just in time, we either go back to Step 3 to automate another test or to Step 1 to pick a brand-new story to work on.

It would probably not hurt to walk around a bit and maybe have a cup of coffee, possibly check out your email. Getting acceptance tests passing is intensive work. As soon as you’re back from the coffee machine, we’ll continue with a broader view of how this simple four-step cycle with its small steps fits into the bigger picture of a complete iteration within a project.

9.3.2. Acceptance TDD inside an iteration

A healthy iteration consists mostly of hard work. Spend too much time in meetings or planning ahead, and you’re soon behind the iteration schedule and need to de-scope (which might translate to another planning meeting...ugh!). Given a clear goal for the iteration, good user stories, and access to someone to answer our questions, most of the iteration should be spent in small cycles of a few hours to a couple of days writing acceptance tests, collaborating with the customer where necessary, making the tests executable, and implementing the missing functionality with our trusted workhorse, test-driven development.

As such, the four-step acceptance test-driven development cycle of picking a story, writing tests for the story, implementing the tests, and implementing the story is only a fraction of the larger continuum of a whole iteration made of multiple—even up to dozens—of user stories, depending on the size of your team and the size of your stories. In order to gain understanding of how the small four-step cycle for a single user story fits into the iteration, we’re going to touch the zoom dial and see what an iteration might look like on a time line with the acceptance TDD–related activities scattered over the duration of a single iteration.

Figure 9.10 is an attempt to describe what such a time line might look like for a single iteration with nine user stories to implement. Each of the bars represents a single user story moving through the steps of writing acceptance tests, implementing acceptance tests, and implementing the story itself. In practice, there could (and probably would) be more iterations within each story, because we generally don’t write and implement all acceptance tests in one go but rather proceed through tests one by one.

Notice how the stories get completed almost from the beginning of the iteration? That’s the secret ingredient that acceptance TDD packs to provide indication of real progress. Our two imaginary developers (or pairs of developers and/ or testers, if we’re pair programming) start working on the next-highest priority story as soon as they’re done with their current story. The developers don’t begin working on a new story before the current story is done. Thus, there are always two user stories getting worked on, and functionality gets completed throughout the iteration.

So, if the iteration doesn’t include writing the user stories, where are they coming from? As you may know if you’re familiar with agile methods, there is usually some kind of a planning meeting in the beginning of the iteration where the customer decides which stories get implemented in that iteration and which stories are left in the stack for the future. Because we’re scheduling the stories in that meeting, clearly we’ll have to have those stories written before the meeting, no?

That’s where continuous planning comes into the picture.

Continuous planning

Although an iteration should ideally be an autonomous, closed system that includes everything necessary to meet the iteration’s goal, it is often necessary—and useful—to prepare for the next iteration during the previous one by allocating some amount of time for pre-iteration planning activities.^[5] Otherwise, we’d have long-lasting planning meetings, and you’re probably not any more a friend of long-lasting meetings than I am.

⁵ Suggestions regarding the time we should allocate for this continuous planning range from 10–15% of the team’s total time available during the iteration. As usual, it’s good to start with something that has worked for others and, once we’ve got some experience doing things that way, begin zeroing in on a number that seems to work best in our particular context.

In practice, these pre-iteration planning activities might involve going through the backlog of user stories, identifying stories that are most likely to get scheduled for the next iteration, identifying stories that have been rendered obsolete, and so forth. This ongoing pre-iteration planning is also the context in which we carry out the writing of user stories and, to some extent, the writing of the first acceptance tests. The rationale here is to be prepared for the next iteration’s beginning when the backlog of stories is put on the table. At that point, the better we know our backlog, the more smoothly the planning session goes, and the faster we get back to work, crunching out valuable functionality for our customer.

By writing, estimating, splitting if necessary, and prioritizing user stories before the planning meeting, we ensure quick and productive planning meetings and are able to get back to delivering valuable features sooner.

The mid-iteration sanity check

I like to have an informal sanity check in the middle of an iteration. At that point, we should have approximately half of the stories scheduled for the iteration running and passing. This might not be the case for the first iteration, due to having to build up more infrastructure than in later iterations; but, especially as we get better at estimating our stories, it should always be in the remote vicinity of having 50% of the stories passing their tests.

Of course, we’ll be tracking story completion throughout the iteration. Sometimes we realize early on that our estimated burn rate was clearly off, and we must adjust the backlog immediately and accordingly. By the middle of an iteration, however, we should generally be pretty close to having half the stories for the iteration completed. If not, the chances are that there’s more work to do than the team’s capacity can sustain, or the stories are too big compared to the iteration length.

Learning from our mistakes, we’ve come to realize that a story’s burn-down rate is constantly more accurate a source of prediction than an inherently optimistic software developer. If it looks like we’re not going to live up to our planned iteration content, we decrease our load.

Decreasing the load

When it looks like we’re running out of time, we decrease the load. We don’t work harder (or smarter). We’re way past that illusion. We don’t want to sacrifice quality, because producing good quality guarantees the sustainability of our productivity, whereas bad quality only creates more rework and grinds our progress to a halt. We also don’t want to have our developers burn out from working overtime, especially when we know that working overtime doesn’t make any difference in the long run.^[6] Instead, we adjust the one thing we can: the iteration’s scope—to reality. In general, there are three ways to do that: swap, drop, and split.

⁶ Tom DeMarco and Timothy Lister have done a great favor to our industry with their best-selling books Slack (DeMarco; Broadway, 2001) and Peopleware (DeMarco, Lister; Dorset House, 1999), which explain how overtime reduces productivity.

Swapping stories is simple. We trade one story for another, smaller one, thereby decreasing our workload. Again, we must consult the customer in order to assure that we still have the best possible content for the current iteration, given our best knowledge of how much work we can complete.

Dropping user stories is almost as straightforward as swapping them. “This low-priority story right here, we won’t do in this iteration. We’ll put it back into the product backlog.” But dropping the lowest-priority story might not always be the best option, considering the overall value delivered by the iteration—that particular story might be of low priority in itself, but it might also be part of a bigger whole that our customer cares about. We don’t want to optimize locally. Instead, we want to make sure that what we deliver in the end of the iteration is a cohesive whole that makes sense and can stand on its own.

The third way to decrease our load, splitting, is a bit trickier compared to dropping and swapping—so tricky that we’d better give the topic its own little section.

Splitting stories

How do we split a story we already tried hard to keep as small as possible during the initial planning game? In general, we can split stories by function or by detail (or both). Consider a story such as “As a regular user of the online banking application, I want to optionally select the recipient information for a bank transfer from a list of most frequently and recently used accounts based on my history so that I don’t have to type in the details for the recipients every time.”

Splitting this story by function could mean dividing the story into “...from a list of recently used accounts” and “...from a list of most frequently used accounts.” Plus, depending on what the customer means by “most frequently and recently used,” we might end up adding another story along the lines of “...from a weighted list of most frequently and recently used accounts” where the weighted list uses an algorithm specified by the customer. Having these multiple smaller stories, we could then start by implementing a subset of the original, large story’s functionality and then add to it by implementing the other slices, building on what we have implemented for the earlier stories.

Splitting it by detail could result in separate stories for remembering only the account numbers, then also the recipient names, then the VAT numbers, and so forth. The usefulness of this approach is greatly dependent on the distribution of the overall effort between the details—if most of the work is in building the common infrastructure rather than in adding support for one more detail, then splitting by function might be a better option. On the other hand, if a significant part of the effort is in, for example, manually adding stuff to various places in the code base to support one new persistent field, splitting by detail might make sense.

Regardless of the chosen strategy, the most important thing to keep in mind is that, after the splitting, the resulting user stories should still represent something that makes sense—something valuable—to the customer.

Now that we have an idea of acceptance TDD as a process and about what’s in it for us, let’s talk about what powers that process: the team.

9.4. Acceptance TDD as a team activity

Because we’re talking about a process for software development, which is inherently a people business, we cannot bypass the topic of team structure. Regardless of your professional background, I’m sure you have questions about the kind of team a project employing acceptance test-driven development might have, what kinds of roles there would be, and who would be doing what. Let’s start from the single most important role a software project has: the role of the customer.

9.4.1. Defining the customer role

Having seen a variety of businesses, from big to small, from high-tech to brick-and-mortar, I’ve seen many variations on who the customer is for a software project. In some places, the customer is the one who pays, in some it’s the one who will be using the system, and in others it’s the one who will be selling the system. The customer may be the one who knows most about the application domain; or if management can’t come up with anything else for someone to do, they may make that person the customer.

With perhaps the exception of that last example, all of these are potentially valid, smart ways to decide who will act as the customer. Generally speaking, the customer should derive direct or indirect benefit from the end product, although, especially in commercial settings (and even more so when talking about shrink-wrap software products) the level of indirection is rather deep.

Note that we’re talking about customer as a role, not as an individual. Although the majority of projects might have a single person who acts as the customer, it doesn’t have to be so. Indeed, many systems span multiple domains that might be far too complex for one person to understand thoroughly. In such contexts a team of customers typically occupies the customer role. When dealing with such a setup, it is crucial that the customer team has the necessary mechanisms to make and negotiate decisions quickly.

To better describe the ideal customer for a software project, let’s look at some properties we would like to see in our customer(s).

Shared interest in success

The ideal customer shares the team’s interest in the overall success of the project. Sharing that interest is essential in making sure that the team and the customer are working toward the same goal. Without that shared interest, it is difficult to sustain the high-bandwidth communication and heavy involvement of the customer in the daily work of the project team—doubly so if the customer has other commitments in addition to your project. When we have the right customer, they’re an integral part of the team rather than an outsider expressing requests about what the team should be doing.

Authority to make decisions

Although getting empathy is better than facing cold ignorance, a customer without the authority to make decisions is not much more than a messenger between the team and the real customer. In an agile project relying on the ability to react to changes as they happen, having the authority to make decisions within the team (after all, the customer is part of the team) is essential. Decisions regarding prioritization and what a given user story entails must be made in a timely manner if we’re to keep up with our capacity of delivering working software—after all, we need to know what to build in order to build it.

Ability to understand implications

Making decisions is not enough. Those decisions must be—within certain limits—smart decisions based on the best knowledge at that time and considering the implications of such decisions. For a customer on a software project, this might require consulting the development team with regard to technical implications of present alternatives, including the estimated cost and effort associated with a given decision.

Ability to explain the domain

An important characteristic—and unfortunately an aspect often lacking the attention it warrants—of a customer is the ability to explain the application domain to the team. The team is expected to speak the customer’s language using the business domain’s own terms, but they should not be expected to learn the domain on their own. After all, it could take years to learn a domain well enough without continuous interaction with the customer. Having a customer that’s able to communicate effectively with the team is an essential building block for success.

We now have an idea of what is expected from the customer role. Earlier, we mentioned that the customer works with members of the development team in writing acceptance tests. This rather vague wording begs the question, who is this member of the development team that the customer collaborates with so closely in writing acceptance tests?

9.4.2. Who writes tests with the customer?

In some teams, it might be the customer and a tester who together create acceptance tests. In others, it might be the customer and a developer. In still others, it might be the customer and a group consisting of any combination of testers and developers. My personal experience has been with teams where developers take significant responsibility in testing their software beyond unit testing and TDD, so I’ve mostly seen teams where it’s the customer and a developer who write acceptance tests. There are certain advantages, however, in having testers work on the acceptance tests with the customer and developers.

Perhaps the main differentiator in having a tester versus having a developer write acceptance tests with the customer comes from the slightly different perspective these team members generally possess for the system being developed. The developers are intimately familiar with how the system is structured, what kinds of changes will be required to support a given story, and so forth. That helps enormously in formulating possible solutions to fulfill the customer’s need. The testers, on the other hand, are more familiar with the system as a whole and—typically—with the application domain in general. This makes testers ideal candidates for writing acceptance tests, because they already have the right perspective for defining how the system should work.

In practice, however, there is no hard and fast rule here either. In most cases, it seems, the ideal would be to have the whole team participate in writing acceptance tests. The benefits from doing so include not just spreading the knowledge but also the building of relationships between individual team members and the customer. The more people work together, the more fluent their collaboration becomes, and again that’s essential in determining how well the team is able to build the features the customer wants.

9.4.3. How many testers do we need?

Some organizations—Microsoft being probably the best known—have established a practice of pairing a dedicated tester for each developer. Whether this is a good idea for your organization or not, I don’t know. According to my experience, most teams do well with one tester per two developers or so, and most teams fare OK with even fewer testers as long as the developers are good at wearing the tester hat. (This isn’t that easy, really: Professional testers often have a different mindset than most professional programmers.) In short, I’d suggest starting out with one tester per two to three developers and scaling up or down from there as you gain experience in your particular environment.

By now we know acceptance TDD is a team-level process that affects the way a whole team produces software together. We haven’t talked about the benefits of acceptance TDD, however, beyond a passing mention of “better software faster.” I think it’s about time to discuss those benefits in more detail now that we have an idea of the process in general.

9.5. Benefits of acceptance TDD

Why were we doing this acceptance test-driven thing again? The reason is simple—it helps us write better software, the right software, and it helps us do that without spending our precious time and money on things of secondary importance. It sounds good all right. How about a closer look at how this support realizes itself?

To a large degree, the benefits of acceptance TDD could be seen as a direct extension of many of the benefits of user stories—being able to focus on the right things, getting the important stuff done while minimizing the waste in the process, and maximizing the value our customer gets out of the whole process. With that in mind, let’s see how acceptance TDD expands on that already huge potential.

9.5.1. Definition of “done”

In a class about project management, one of the first things we learn is that projects have a beginning and an end. Otherwise, they’re not projects. Quite likely, in the same class we’re told about Parkinson’s Law, which says, “Work expands to fill the time available for its completion.” What do these two teachings have to do with acceptance TDD, you may ask? The key issue here is, knowing where we are and knowing when to stop. We need a definition of done, and acceptance TDD gives us a simple binary criterion that does just that: “Do all tests for the story pass?”

With our acceptance criteria expressed as automated (or automatable) acceptance tests, we have a lot of the means necessary to set ourselves up for productive software development as far as knowing when we’re done is concerned. Not all acceptance criteria are written down as automated acceptance tests, however. Some of them remain as the result of objective manual testing and evaluation by the customer. A good example is user interfaces.

Whatever the means of determining when we’re done, the important thing is for everyone to know and agree to the way of determining when a given task is considered completed—whether it’s a matter of all acceptance tests passing or a more complicated scenario involving subjective evaluations. In any case, acceptance TDD puts the act of thinking about and specifying those tests and evaluations in the beginning of the development cycle of implementing a user story. It makes it a heck of a lot easier to work effectively when we know how to tell when we’re done.

And this feeds back to our two key issues: knowing where we are and knowing when to stop.

Knowing where we are

Acceptance tests don’t drive development quite as the unit tests in TDD do. Instead, they drive development by giving us a concrete goal to aim at and the means to know when we’ve accomplished that goal. Similarly to unit tests in TDD, our acceptance tests keep us honest about what’s needed and thus help us avoid scope creep and gold plating. Acceptance tests tell us exactly what we need to do, and they tell us when we’re done leaving no room for ambiguity. But that’s not all there is to knowing where we are—it’s also about the customer knowing where we are.

With acceptance TDD, the customer can always tell where the development is going. As acceptance tests are added to the continuous build results and, as acceptance tests start passing, the customer gets valuable and trustworthy information about the progress the team is making. All they need to do is look at which acceptance tests are passing and which are not.

Knowing when to stop

Having our acceptance criteria clearly spelled out in the form of acceptance tests not only helps us know when we’re done, but it also helps us avoid the classic gold-plating disease to which we developers often are subjected. It’s a lot more difficult to “quickly add this little cool UI feature” when we have a set of tests passing, effectively shouting “you’re done—have the customer look at it so we can move on!”

Then again, sometimes we’re not done even though the tests say so. In these situations, when it’s clear that the tests are lacking some essential aspect of the story, we see that the missing aspect gets implemented. Sometimes, that means consulting the customer about the details of how that missing part of the story should work. Sometimes, that leads to adding new acceptance tests as well, before we eventually implement the missing aspect.

Again, the mere existence of a set of acceptance tests aids us a great deal in stopping when we should. Not a moment too soon. Not a moment too late.

9.5.2. Cooperative work

One less obvious benefit of acceptance TDD is that it creates a more cooperative environment because everyone is working with the same goal at the same time. If testing is carried out after the development (and by a tester), then it often happens that the developer is already doing other stuff when the tester finds a bug. The goals of the developer and tester then conflict in a way.

Contrast this with a scenario where developers and test engineers are working together for a common goal of producing high-quality software that solves the right problem. This is a much more effective way to work, especially considering how each individual brings their unique knowledge and skill set into solving the problem.

9.5.3. Trust and commitment

In acceptance TDD, we write acceptance tests to specify what it means when that given user story has been implemented correctly. Having the customer write those acceptance tests together with the development team significantly solidifies the meaning of user stories. This is because there’s a direct connection between what the customer specifies and what they get.

Part of this solidified meaning of user stories is also coming from the association of the customer seeing the development team implementing exactly what they ask for without holding them hostage to things they’ve said before or things they wrote down as requirements earlier. Part of it is coming from the developers seeing the customer write the acceptance tests, which clearly communicates the value coming out of completed code.

In short, the customer sees that their needs are indeed being met, and the developers see that the work they’re doing is valued by the customer. Demonstrating the implemented user stories to the customer together with running (and passing!) acceptance tests is by far the best way I know to accomplish just that.

The ways in which tests are written in acceptance TDD do have significance. So much significance, in fact, that the next benefit of acceptance TDD on our list is specification by example.

9.5.4. Specification by example

An important aspect of acceptance tests is that they represent specification by example, a way to express requirements by the way of comprehensible examples rather than complex formulas and ambiguous prose. This brings us a number of advantages.

Generic descriptions that are full of ambiguity and subject to interpretation are an order of magnitude harder to translate into executable tests. Furthermore, for the customer it is much more difficult to validate whether a test is correct when they need to interpret the original intent among the ambiguities.

In short, tests expressed with concrete examples are easier to read, easier to understand, and easier to validate—not to mention easier to write in the first place! That last advantage becomes critical when our goal is to have the customer involved in specifying and writing tests for our system.

9.5.5. Filling the gap

Regardless of how well our unit tests cover our production code, they are not testing our system. They are testing our code and components in isolation. To put it another way, unit tests give us a good indication of whether our code works; but without some additional testing, we don’t know whether our software as a whole works as it should work. In fact, in most cases our unit tests don’t even tell us whether the individual components we’re testing work together, although judicious use of contracts and interaction-based tests help close this gap. Although unit testing—especially in the form of test-first programming—is an enormously helpful practice in producing quality software, we often need something more to put our whole system under an automated test harness.

Some have even questioned the need for unit tests in the presence of a thorough acceptance test suite. Some successful programmers rely solely on automated acceptance tests to give them feedback and guard for regression during development. Personally, I feel that even though automated acceptance tests can indeed provide good enough protection for regression in some situations, the other benefits of writing unit tests to support TDD are more than enough to justify writing them. Generally speaking, one size does not fit all.

I’d go as far as warning you about the looming danger of using acceptance tests like unit tests in TDD—it might happen that we lose sight of the big picture of what’s needed for the story, or we might stop writing good unit tests, effectively chewing away at our ability to refactor efficiently as we no longer have as thick a safety net as we used to with TDD. Acceptance test-driven development accompanies test-driven development—it doesn’t replace it.

Now that we have an idea of the overall process of acceptance TDD and who’s doing what, I think it’s a good time to dig deeper into what exactly—technically speaking—we are testing with our acceptance tests.

9.6. What are we testing, exactly?

Just saying acceptance tests test user stories is often not enough to convey the idea of what exactly acceptance tests should test. Yes, acceptance tests are meant to verify that a user story is implemented correctly as specified. However, there are many ways to do that. We’ll explore these ways further in chapter 11, but let’s understand the fundamentals right now in order to create a crisp picture of what we should be testing with our acceptance tests.

9.6.1. Should we test against the UI?

Perhaps the most common question regarding acceptance tests is whether they should exercise the system under test through the real user interface (or the external interface of a machine-to-machine system) or some kind of an API beneath the user interface. The answer is, of course, “it depends.” In general, however, our goal is to gain as much confidence as possible with as little effort as possible. Whether this is best achieved by writing end-to-end tests or by a divide-and-conquer strategy of writing smaller, more isolated tests is very much context-dependent.

When trying to decide whether to write acceptance tests against the system’s real interface, against an abstract user interface (for example, when using the Presenter pattern described in chapter 8), or against some sort of a service layer exposing the business logic to the user interface, we might ask ourselves questions such as the following:

For some systems, and especially for machine-to-machine–style backend systems, testing against the external interface is the best option. This is because those interfaces are typically well defined and do not exhibit as much turbulence as user interfaces. In general, machine-to-machine interfaces are easy to test.

Graphical user interfaces (GUIs) are a much more difficult class of interfaces from a testing perspective. One of the reasons for this is that GUIs often change more frequently than machine-to-machine interfaces as new functionality is added. This problem can be mitigated to some degree with careful design of the GUI implementation as well as that of the implementation of the tests themselves. Most often, however, it’s not a question of technology that leans our decision in either direction.

Not a question of technology

With the tools available for the modern developer, moving a button on the screen or otherwise changing the basic layout is rarely a big issue for the maintainability of acceptance tests written against the GUI. Some extra care must be given, however, to avoid ending up with tests that are far more complex and verbose than the associated business logic would imply. In practice, it often makes sense to map a concise testing language on top of the technical interface to keep the complexity of tests in check. This way, we can keep the effort of writing acceptance tests against the GUI close to the effort of writing the same tests against an internal API.

Performance might matter

Sometimes, the motivation for having our acceptance tests bypass the real interface and go directly against the internal API is performance. The external interface could be a serial port with limited bandwidth, and we might have tens of megabytes of data to push through the thin pipe while executing our acceptance tests. In this type of scenario, it often makes sense to execute the tests without going through the bottleneck, effectively trading coverage for speed of feedback.

Even if we end up running our tests against an internal API, we still want to run at least some of our tests (although maybe not as often as the rest) against the real thing. Things are rarely either-or when talking about software development. In practice, we typically have acceptance tests operate on all available layers from the GUI, through internal APIs, and all the way down to isolated business logic.

A somewhat similar situation warranting testing against an internal API is the complete lack of access to the real thing. For example, we might not have the device with which our system is accessed. We might not have the exact hardware on which our system is supposed to be deployed. This leads us to the next question regarding what we’re testing, exactly.

9.6.2. Should we stub parts of our system?

For many of the same reasons as for writing our tests against an internal interface instead of the external one, there are certain situations where we feel like replacing some part of our system—not necessarily just the external interface—with a fake implementation.

For example, our tests might require that a database be set up with large datasets before each test, and the particular database could prove to be too slow to do this while still retaining a fast enough feedback cycle. In this situation, we might be tempted to have our application use an in-memory database instead of the real one in order to avoid the cost of hitting the wire every time our tests or the application itself touches the database. Or we might be tempted to use a local database running on the same machine as the application in order to at least minimize the cost of network I/O.

The question remains: Should we do that? Should we replace some parts of the system with fake or alternative implementations in the name of convenience or speed?

Sufficiently close to the real thing

Whether we should stub or not is a question for which the answer is mostly dependent on the degree of certainty we have in the specific replacement being close enough to the real thing from the tests’ perspective. In our example of replacing the real database with one that’s physically located on the same machine as the application instead of on a separate one, the difference between the real thing and the replacement is insignificant. Replacing the real database product with a different one—or sometimes even using the same database in in-memory mode instead of running it as a server—is already more complex decision to make.

Differences in the SQL syntax supported by different databases, differences in how each database product handles certain data types, and so forth can be big enough risks to bite the bullet and use the real thing—even if the acceptance tests run slower with it. Whether to stub or not is ultimately a subjective decision, and there’s no blanket answer that would be globally correct. We need to evaluate the trade-offs involved and make a decision case by case.

Sometimes a stub is our only option

Some situations remain where the stub is our only viable option, however. For example, some teams developing embedded or highly hardware-dependent software can be constrained because the sheer cost of a particular hardware chip or device is prohibitive. Another perhaps more common scenario is one where the constrained hardware is available infrequently and only for short periods of time. In situations like that, it’s often better to run your acceptance tests on top of a simulator instead of only being available to run your tests for three hours every two weeks.

The question of stubbing parts of our system when running acceptance tests is more complex than defining what’s close enough to the real thing, however. Acceptance tests are not all alike, and not all aspects of what our customer is interested in involve system-level properties. A good example of this is domain-specific business logic, which is a topic of its own.

9.6.3. Should we test business logic directly?

Just as traditional testing is not only about testing against functional requirements but also non-functional requirements, acceptance tests are written to cover a range of aspects of the system being developed. Perhaps the majority of acceptance tests are functionality-oriented, specifying correct behavior for a variety of different interaction sequences. Usually, a smaller portion of acceptance tests are those that specify systemic and non-functional requirements, such as the system’s ability to handle simultaneous connections or to survive a crashing database or network downtime. Yet another class of acceptance tests specifies the core business logic—the stuff that happens behind the curtains when we interact with the system.

Thinking from the customer’s perspective, testing domain-specific business logic directly makes a lot of sense. In many domains, the business logic involved is more than enough to warrant isolation and focus. It is much easier to wrap our heads around the logic when it’s no longer muddled with irrelevant information related to populating forms, for example. From the developer’s perspective, it’s the exact same outcome—by focusing on the business logic directly, we are much more able to understand what the system needs to do.

To summarize, if your particular domain involves non-trivial business logic, by all means, specify and test it directly rather than hide it behind a sequence of actions through an external interface.

Speaking of summaries, before we wrap up this chapter, let’s take a little tour through the various tools we have at our disposal for supporting the implementation of acceptance tests as part of acceptance TDD.

9.7. Brief overview of available tools

As in so many other aspects of software development, using the right tools can make the difference between night and day. What we are typically looking for in a tool for acceptance testing is support for:

Writing our tests refers to our need for a customer-friendly format that facilitates effective collaboration between developers, testers, and customers. The tool also needs to help us convert that customer-friendly format into something executable (if it isn’t already) and to execute them—after all, that’s what automated means. There is more to running our tests than that, though.

Because we will likely want to incorporate our acceptance tests into a continuous integration server to be run as a background job at configured intervals, the tools should support running the tests in batch mode—that is, without any manual intervention by whomever wants to run the tests. Finally, there’s little use in running tests if we don’t know whether they passed or not. Therefore, our toolset should also provide a way to report test results.

There are a variety of tools available for acceptance testing that all meet the previous requirements in one way or another. I’ll introduce some of the more common ones briefly before diving into one of them in more detail.

9.7.1. Table-based frameworks

The latest fad in acceptance-testing tools is to express the tests in the form of tables. The common use case is that the customer (usually together with the developer) creates a table consisting of rows and columns, which is then interpreted by the testing framework based on the semantics and data embedded into the table cells. The customer could, for example, author the test table with the same office productivity tools with which they’re already familiar and then save the document into a format that can be read and parsed by the testing framework—often either HTML (if using Microsoft Word) or XLS (if using Microsoft Excel).

Examples of tools in this category include Fit, FitNesse, and Selenium.

Fit: smart parsing for simple tables

Fit (Framework for Integrated Tests) was developed by Ward Cunningham to bridge the gap between the customer and the developer in the context of authoring acceptance tests. Fit essentially provides syntax for constructing test fixtures from HTML tables and a way to hook those fixtures into their implementations in various programming languages, such as Java, C#, Python, and so forth.

Given an HTML document, Fit parses the document looking for tables and, when it finds one, invokes the underlying code associated with the specific table. Finally, Fit renders the input document with all the table cells colored according to test results—a cell containing an assertion that failed would be colored red, and a cell containing an assertion that passed would be colored green. Anything that’s not a table is considered narrative and is not processed by Fit. Fit is currently rather popular among teams adopting agile methods and, especially, Extreme Programming.

FitNesse: Fit in a Wiki

The guys at ObjectMentor built FitNesse to make writing Fit tests easier. FitNesse is essentially a combination of a web server, Fit, and a wiki web application that lets users edit web pages online using a more compact wiki syntax instead of raw HTML (which is a pain to edit by hand without graphical tools). The lightweight and simple markup language used to structure tables, headings, bulleted lists, and so forth can be a remarkable boost in productivity when working on the acceptance tests because the tests are more malleable and readily editable.

Selenium: controlling a browser

Selenium is a tool focused on testing web applications through the real user interface. What makes Selenium relatively unique is the way it accomplishes this, however.

Selenium tests are written as HTML tables just like in Fit and FitNesse, but they are implemented under the hood in JavaScript and executed by the JavaScript engine of the real web browser, such as Internet Explorer or Mozilla Firefox. This provides certain advantages over tools and libraries that exercise a web application by simulating a browser—specifically because of the varying level of support for JavaScript by the libraries and because of the differences in JavaScript support by the various browsers.

It is worth noting that Selenium also includes a remote-control mode, which allows for writing the tests in a programming language like Java or a scripting language like Ruby, while still executing the tests through a live web browser.

9.7.2. Text-based frameworks

Although table-based frameworks might be the mainstream right now, they are not the only class of frameworks suitable for acceptance testing. Not everyone likes authoring tests as tables. The text written into the cells of test tables is often close to written English, but the table structure brings with it a degree of syntax. Fortunately, some tools exist that let us author our tests in plain text instead of structured documents such as HTML.

Exactor: simple keyword-driven testing

Brian Swan of Exoftware developed a framework named Exactor to aid the developers in writing automated acceptance tests in a concise manner while still not restricting the test implementation too much. Instead of structuring tests into cells in an HTML table, Exactor tests are expressed in plain text files following a couple of simple rules: Every line that’s empty or starts with the hash character is considered narrative, and all other lines represent a combination of an action and its parameters, separated by the tab character. The framework maps the names of actions into names of Java classes, and the parameters are passed to the execute method of an instance of the resolved class.

TextTest: testing with logs

Another testing framework based on raw text in contrast to structured documents is TextTest, written by Geoffrey Bache. TextTest’s approach is unique in that its tests are written as log files. The fundamental idea is that the customer can express tests in a plain text file using whatever language he wishes, and the developer then implements the tests by adding logging statements to appropriate places in the production code. TextTest then verifies the correct functionality by comparing the expected and log files after running a test.

9.7.3. Scripting language-based frameworks

There is another category of acceptance-testing tools that can offer a great deal of power through the flexibility and friendliness of a scripting language. These tools are typically frameworks that attempt to deliver the promise of a domain-specific language through a generic scripting language such as Python or Ruby.

The obvious downside of these tools is that they’re limited by the selected scripting language’s suitability in defining a custom vocabulary within the limits of the language syntax. On the other hand, if the more complex syntax is not an issue (for example, if the customer possesses enough programming skills to be able to deal with the syntax), these tools enable an enormous scale of possibilities in terms of implementing tests—a full-blown scripting language is available, after all.

A good example of this category of tools is Systir,^[7] which makes use of the Ruby scripting language’s malleable syntax for building reasonably good, custom-domain–specific languages.

⁷http://atomicobject.com/pages/System+Testing+in+Ruby.

9.7.4. Homegrown tools

One important class of testing tools is those that are created in-house according to a specific development team’s specific needs. Homegrown tools are in the core of the buy versus build dilemma. Writing our own testing framework does have its associated cost (both in building as well as maintaining it), and it might take some time to get started writing tests if we also need to implement a framework as you go.

The advantage of writing our own is, of course, that it will be tailor fit and will likely serve our needs better than a tool built by someone else on the other side of the globe. Also, the cost of writing our own testing framework is often less than we’d expect. I once wrote in one day a basic table-based testing framework for testing a web application according to a test script expressed as an Excel sheet. With that in mind, my suggestion would be to first evaluate whether it would be that costly to write your own instead of using a readily available framework that’s slightly awkward to use in your particular context.

There’s a thin line between homegrown and off-the-shelf testing tools or frameworks. In fact, most projects tend to grow some sort of a testing framework—sometimes from scratch and sometimes on top of an existing tool such as Fit. It’s a question of how much third-party software you leverage beneath your custom test automation assets, be it tests or tooling.

OK, enough talk about tools. Let’s wrap up the chapter with a quick summary.

9.8. Summary

By now, we know that user stories are a useful, lightweight technique for managing requirements. In this chapter, we discussed their connection with what we call acceptance tests—automated tests that can be used to drive development on the feature level a bit like we do on the code level with unit tests and test-driven development.

We started by clarifying to ourselves what acceptance tests are and what they should look like. From there, we continued to examine the process of acceptance test-driven development, getting familiar with the four steps involved: picking a story, writing acceptance tests for it, automating those tests, and implementing the functionality to make the tests pass. We also looked at how this four-step cycle fits into the bigger picture of a whole iteration of an agile process and the kinds of activities related to stories and acceptance tests that we perform throughout the iteration.

After discussing the benefits of acceptance TDD, we turned our attention to the team and some common questions related to acceptance TDD: specifically, the customer’s role in the process. Finally, we briefly talked about what we are testing with our acceptance tests and took a quick tour of available open source tools for implementing acceptance tests.

Now that we’re aware of this fascinating technique called acceptance test-driven development and how it works, it’s time to take a closer look at one specific tool for automating acceptance tests. In the next chapter, we’ll introduce Fit, one of the open source tools we mentioned earlier and possibly the most used acceptance testing framework today. Once we know how Fit works and how we can use it for authoring and automating acceptance tests, we’ll dedicate chapter 11 to discussing various strategies for implementing acceptance tests—that is, how to connect the test logic into the system under test.