Over the last couple of years, I've occasionally written Ruby programs using RSpec and (more recently) Cucumber. These two tools are inspired by Test Driven Development (TDD), a school of thought which says you should write unit tests before implementing a feature.
When doing TDD, you work inwards from the interface to the implementation. You start by writing a test case against the interface you wish you had, and then you make that test case work. This is a subtle shift in how you approach a design problem, but it frequently results in beautiful APIs. (And you also get a fully automated test suite for your software, liberating you to make much larger changes without fear of breaking things.)
The problem with the word "test"
Unfortunately, the name "Test Driven Development" is misleading. Most folks think of "testing" as something you do after development is complete. But TDD is really more of a design activity---you're specifying how your APIs should work before you actually start coding.
Dan North spent some time struggling to teach developers about TDD. After a while, he decided that the main barrier to understanding was the word "test." He proposed replacing TDD with Behavior Driven Development (BDD), and he started referring to unit tests as "specifications."
In the Ruby community, the most popular BDD tool is RSpec. Using RSpec, you might specify an API something like this:
describe "simplify_name" do it "should convert all letters to lowercase" do simplify_name("AbC").should == "abc" end it "should remove everything but letters and spaces" do simplify_name(" Joe Smith 3 -+\n").should == "joe smith" end end
After writing this specification, you would then go ahead and implement
simplify_name. And from then on, whenever you changed your program, you could automatically check it against this specification.
Using specifications to communicate with clients and users
By itself, RSpec is mostly useful for programmers. Sure, a specification looks a lot like English. But would you really want to show it to an end user?
Cucumber goes one step further. Instead of using code to specify how an API should work, it uses plain text to describe how a user interface should work. For example:
Feature: Log in and out As an administrator I want to restrict access to certain portions of my site In order to prevent users from changing the content Scenario: Logging in Given I am not logged in as an administrator When I go to the administrative page And I fill in the fields | Username | admin | | Password | secret | And I press "Log in" Then I should be on the administrative page And I should see "Log out" Scenario: Logging out ...
Here's the neat part: This specification is actually an executable program. Each line of text corresponds to a "step", which is defined in another file. Here's an example from the standard
Then /^I should see "([^\"]*)"$/ do |text| response.should contain(text) end
Cucumber encourages you to think at a very high level, and to specify how different users will actually use your software. It's particularly helpful if you need to communicate between programmers and end-users.
My experiences with RSpec and Cucumber
I've been using RSpec on and off for a couple of years now, and Cucumber since late last year. Initially, I found both tools fascinating, but also a bit frustrating. Both RSpec and Cucumber have very strong opinions about how you should write software. Now, I found those opinions very interesting, and I was quite happy to be influenced by the assumptions built into the tools. But every now and then, I would need to do something that the authors of RSpec and Cucumber hadn't anticipated, and I would inevitably wind up struggling to make things work.
But recent versions of RSpec and Cucumber are richer and more flexible. They cover more important cases straight out of the box, and they're easier to customize. So I can finally recommend both tools for real-world projects: They'll still guide your thinking, but they should give you enough flexibility to handle the corner-cases.
The RSpec (and Cucumber) book
Unfortunately, the documentation for RSpec and Cucumber is scattered around the web, and there aren't enough online guides showing the best way to solve common problems.
But the Pragmatic Press is working on The RSpec Book, which contains a large section on Cucumber, and a walkthrough of a typical development session using Cucumber and RSpec.
Currently, the RSpec book is available as a "beta book". This is a downloadable, DRM-free PDF, with periodic updates throughout the publishing process. Right now, between one-third and one-half of the chapters have been roughed in, and the book is already very useful.