Most Ruby programmers know about Ruby’s interactive console, IRB. (If you don’t, stop right here, open up a command window and run irb. Type some Ruby code. See how it returns the result of each line right away.) IRB is great for poking around with unfamiliar libraries.

Suppose you’re using Capybara with Cucumber for the first time. It would be nice to use IRB to experiment with what Capybara can do on a particular page. You could launch an IRB session and duplicate all the Capybara setup from your Cucumber support/env.rb file. But wouldn’t it be nice if you could just fire up IRB in the context of a step definition so you know everything in your IRB session matches what you’d get in the step def? Turns out you can. Here’s how…

Install the ruby-debug gem. If you’re using Ruby 1.9 like me, you need the ruby-debug19 gem. In Rails 3, just add gem ruby-debug19 to your Gemfile, probably in the test group, and run bundle install.

Require ruby-debug in support/env.rb.

Add breakpoint where you want to jump into IRB. For example:

(Note the extra line after breakpoint with 0 on it. breakpoint breaks before executing the next line, so if it’s the last thing in a block, you won’t jump into the debugger in the context you expect; 0 is a dummy line to keep us in the right context.)

Run Cucumber like normal. When it reaches breakpoint, ruby-debug will take over, and you’ll see a prompt like this: (rdb:1).

You can do a lot of different things at this prompt, but we only care about one right now: type irb and hit Enter. Now you should see a an IRB prompt. You’re in the context of a Cucumber step definition. Type self and hit Enter. You’ll see that self is an instance of Cucumber’s World with various things mixed in. From here, you can do anything you would do inside that step definition.

When you’re done, run quit to get out of IRB and continue to get out of the debugger. Cucumber execution will continue like normal. Keep in mind, though, that if you change the state of your system from IRB, you might not get the test results you expect.

Enhancements and variations for you to explore:

• Make IRB nicer to use with gems such as irbtools
• Create a step definition just for launching the debugger
• Create a tagged scenario just for launching the debugger

Related posts:

1. Debugging Cuke4Nuke Step Definitions
2. Getting Started with Ruby, Cucumber, and Capybara on Windows
3. Cucumber Tip: Key-Value Tables

You may not realize this: Tables in Cucumber steps don’t have to have a header row. Sometimes it can work really well to use a headerless table of key-value pairs.

Let’s look at an example. Suppose we have a scenario that fills out an advanced search form to search for medical providers matching certain criteria. A mockup of the form looks something like this:

If we were using the recently deprecated web steps generated by cucumber-rails, we might write steps to perform a search like these:

But we know better than to do that, right? After all, we’re trying to describe how the search logic should work, not how the form should look. So we try to write our own steps to do these same thing without talking about the implementation so much, but it’s really hard to get away from the implementation. Even if we drive out words like select, fill in, and click, we still have a step per form element.

Suppose we try to combine them into a single step for the domain concept of performing a search. We might get something like:

The implementation details are gone, but it’s long and hard to read. Enter the key-value table:

In the step definition, we can use the rows_hash method on the table object to convert that key-value table to a single hash. There’s no need to iterate through the rows ourselves. For example, assuming a helper method called provider_search that actually performs the search,

You may have noticed the call to to_bool. This uses a helper method like the following to allow us to use yes and no instead of true and false to make more readable scenarios. Put this somewhere in the support directory.

The call to to_i on the search radius takes advantage of Ruby’s string to integer conversion behavior—if a string starts with an integer but has other text after the integer, the other text is stripped off during the conversion. Try it: Fire up irb (the interactive Ruby console) in a command window and run "5 miles".to_i.

These key-value tables can get long for a complex entity. Not all the details will matter each time. We can make the step read better by introducing a concept of a default provider search. Maybe we have to supply a ZIP code and search radius, but the scenario we’re working on is really about specialties and insurance. We could say,

In the step definition, we’ll declare the default values in a hash and merge it with the supplied values.

If the defaults are well known, this is enough. If they need to be documented, one way I like to do it is as executable documentation with a scenario like this:

If you do this, you’ll want to move the default criteria hash into a helper method or constant to make sure it’s the same hash used in the real scenario and the documentation scenario.

We could make the step definition read better by separating the key and value conversions from the use of the data. Cucumber’s table object has map_headers! and map_column!. Unfortunately, those don’t work for rows_hash at this time. I recently submitted a pull request to make it work. Hopefully, we’ll see that in a Cucumber release soon.

Related posts:

1. How to Remove Duplication in Cucumber Tests Using Scenario Outlines
2. Cuke4Nuke: Cucumber for .NET Teams
3. Just Enough Regular Expressions for Cucumber

Beginning just over two years ago, I worked with some great developers to create Cuke4Nuke as a way to bring Cucumber to .NET. Shortly after the first releases of Cuke4Nuke, TechTalk released SpecFlow, a native .NET tool inspired by Cucumber. As a pure .NET solution without Ruby dependencies, SpecFlow seemed to be easier for Microsoft shops to adopt. But Cuke4Nuke had (to me) enough advantages that I kept it going.

By this summer, however, it was clear that SpecFlow had made up for most of Cuke4Nuke’s advantages and had more momentum in the .NET community and was under much more active development. There were just a few gaps SpecFlow needed to overcome (in my opinion), mostly related to better harmonization with the other Cucumber projects. (With the pure Java Cucumber-JVM under active development as a Cuke4Duke replacement, there was no longer as compelling an argument for shared code between Cucumber versions, Cuke4Nuke’s biggest remaining advantage.)

At AA-FTT and later in the week at Agile 2011, my colleague Paul Rayner and I met with Christian Hassa and Gaspar Nagy from the SpecFlow team. We discussed the few things that needed to change in SpecFlow to make it behave more like the other Cucumbers.

This week, most of those changes were released as part of SpecFlow 1.8. With that release, I’m letting Cuke4Nuke die. I won’t be maintaining or extending Cuke4Nuke. My Cucumber classes and book will cover SpecFlow rather than Cuke4Nuke.

I’ve had a great time getting to know the SpecFlow guys, and I look forward to collaborating with them in the future to help bring Cucumber to more and more teams in the Microsoft world.

Related posts:

1. Cuke4Nuke Needs Your Help
2. Cuke4Nuke: Cucumber for .NET Teams
3. The Latest on Cuke4Nuke

Regular expressions are a big part of what makes Cucumber tests both expressive in English and DRY on the automation side. To make the most of that power, you have to know something about regular expressions.

I’ve created a cheat sheet for my Cucumber class workbook based on last year’s “Just Enough Regular Expressions for Cucumber” post. Download and print a copy to post by your computer until regular expressions become natural for you:

Cucumber Regular Expressions Cheat Sheet

Related posts:

1. Just Enough Regular Expressions for Cucumber
2. Getting Started with Ruby, Cucumber, and Capybara on Windows
3. Resources from our Agile 2009 Presentation

The Ruby version of Cucumber isn’t just for Rails developers. If you have a .NET or Java web or service app, Ruby can be a great language for testing. With libraries like Capybara for driving web apps and JSON, RestClient, SOAP, and others for interacting with service apps, you’ll find testing in Ruby requires much less code than in C# or Java.

It can be hard to find instructions for setting up Ruby and Cucumber on Windows, though, so I’ve compiled these to help my clients get started, and I thought they might be useful to others. I’ve tested this on a clean Windows 7 VM, and everything works. Your mileage may vary, but let me know if you have any issues.

1. You’re going to be working in a command window quite a bit with Cucumber. You may want to customize your command window to make it more pleasant to use. I like the following settings (right click on the top left corner of the command window and choose Properties to set these):
   Font: Consolas, 20pt
   Screen Buffer: 120×3000
   Window Size: 120×60

   On a smaller screen, you’ll of course want a smaller window size and screen buffer. If you’re on an earlier version of Windows, you won’t be able to choose Consolas for the font, but Lucida Console is still better than the default.

   I also like to set a PROMPT environment variable to $P$_$+$G (right click on My Computer and choose Properties, then Advanced, then Environment Variables).

2. Download and install Ruby. For Windows, http://rubyinstaller.org/ is the best option. Install the latest release of version 1.9.2. Make sure you check the option to “Add Ruby executables to your PATH.”
3. Also install the Ruby Development Kit from the same place, which will allow Ruby to build native extensions for libraries. Instructions are available here: https://github.com/oneclick/rubyinstaller/wiki/Development-Kit.
4. Confirm that the installation worked by opening a command window and running ruby -v. You should see a description of the Ruby version installed. If you see an error, something went wrong with the installation.
5. Make sure you have RubyGems installed by running gem -v on a command line. RubyGems is the package manager for Ruby and should come with the standard Ruby installation.
6. Run gem install cucumber to download and install Cucumber. Run cucumber --help to confirm that it worked.
7. Cucumber complains that you need ANSICON to get console colors because Windows doesn’t understand ANSI color escape sequences. Download ANSICON from http://adoxa.110mb.com/ansicon/index.html. Extract it somewhere (I put it in c:\utils\). In your command window, cd to either the x86 or x64 directory where you extracted ANSICON, depending on your OS, and run ansicon -i. Exit that command window and open a new one. Now, when you run cucumber --help, you should no longer see the message in the output about needing ANSICON.
8. Run gem install capybara to download and install the Capybara web automation library.
9. Run gem install rspec to download and install a nice library for readable assertions (among other things).
10. You’ll want Firefox with the Firebug plugin to do UI-related tests. If you haven’t already, install those.
11. You can edit Cucumber tests and automation code in Notepad, Visual Studio, or any other text editor. But I like having an editor that knows about Cucumber and provides Cucumber-oriented features, so I use JetBrains RubyMine to work with my Cucumber tests. There’s a free 30 day trial available.
12. To make sure Cucumber and Capybara are working nicely together, download and extract this Ruby, Cucumber, and Capybara Starter Project somewhere on your machine. Open a command window at the root of the folder (if you run dir or ls there, you should see a “features” folder). Run cucumber, and you should see all the tests run and pass.

Related posts:

1. The Latest on Cuke4Nuke

Almost 2 years ago, at the 2009 AA-FTT conference, I started Cuke4Nuke to bring Cucumber to the .NET world. Since then, thanks to some fantastic help from Aslak Hellesøy, Matt Wynne, Declan Whelan, Åsmund Eldhuset, and others, Cuke4Nuke supports almost all the features of Cucumber.

But there are still a few key features it needs, and I have too many projects going to keep up with it. Specifically, I’d most like to see:

• Support for VS2010 (.NET 4) and Mono
• Step definition config files
• Tagged hooks
• An all-in-one installer like RailsInstaller
• Better UTF-8 support
• Culture support to go with the current language support (e.g. for string to decimal or date conversions)
• Debugging for step definitions in Visual Studio
• A completely automated build and release process for Cuke4Nuke itself
• Updates to cuke4vs, which isn’t my project but which brings valuable Visual Studio integration to Cuke4Nuke

Are you a .NET and/or Ruby developer? Would you like to contribute? I’d love the help. Check out the instructions for contributing and jump in!

P.S. – Since someone always asks…Yes, I know about SpecFlow. I think it’s a great project. But I still believe there’s value in a .NET version of Cucumber that shares as much code and behavior as possible with the main Cucumber project.

Related posts:

1. Cuke4Nuke: Cucumber for .NET Teams
2. The Latest on Cuke4Nuke
3. Debugging Cuke4Nuke Step Definitions

Update: This course has been postponed until June or July. If you’re interested in attending, let me know and I’ll notify you when registration opens so you can take advantage of the early bird discount.

I’m hosting a public course on Acceptance Test Driven Development with Cucumber (mostly Java-focused) on March 7 and 8 in Denver. Register by February 7 for the 10% early bird discount.

The course is eligible for Colorado Workforce Investment Act funds; if you’re unemployed, you might be able to attend for free. Don’t waste any time getting started, though. It can take more than a month to get WIA training approved in some counties. Contact me for more info on this option.

Hope to see you there!

Related posts:

1. Free Agile Product Management Seminar – Nov 11, Denver

Jon Archer wrote last week about how Cucumber makes knowledge of regular expressions important. He’s right: Regular expressions are the key to Cucumber’s flexibility. Well-crafted regular expressions let you reuse step definitions, avoiding duplication and keeping your tests maintainable. But even experienced developers find them mysterious and overwhelming.

Fortunately, you don’t need regular expressions like this one to wield the power of Cucumber:

In fact, if you use regular expressions like this in your step definitions, you’ve gone too far. (This regular expression, in case you’re wondering, matches the official spec for valid email addresses.)

As with most things, the 80/20 rule applies. There are a handful of useful patterns that are sufficient to make you a Cucumber power user.

Anchors

The regular expression I'm logged in matches I'm logged in and I'm logged in as an admin. To avoid ambiguous matches, use ^I'm logged in$.

The caret at the beginning anchors to the beginning of the string. The dollar at the end does the same with the end of the string. Use these with all your step definitions and you won’t have surprise matches.

Wildcards and quantifiers

Matching specific words is fine. But you often want flexibility to match a variety of strings. Here are some common patterns for non-exact matches.

Capturing and not capturing

When you put part of a regular expression in parentheses, whatever it matches gets captured for use later. This is known as a “capture group.” In Cucumber, captured strings become step definition parameters. Typically, if you’re using a wildcard, you probably want to capture the matching value for use in your step definition. Here’s a Cuke4Nuke example,

If your step is Given I'm logged in as an admin, then the step definition gets passed "admin" for role.

Cuke4Nuke converts captured strings to the step definition parameter type, which is handy for step definitions like this:

The step Given I have 42 cukes means the step definition gets called with 42 (as an integer) for cukeCount.

Sometimes, you have to use parentheses to get a regular expression to work, but you don’t want to capture the match.

For example, suppose I want to be able to match both When I log in as an admin and Given I'm logged in as an admin. After all, both step definitions do the same thing. There’s no reason to have duplicated automation code in my step definitions simply because one is a Given and one is a When.

I might write something like this:

The parentheses and pipe indicate a logical OR, just what I need to match two different strings.

This will fail to run, though. My regular expression is capturing two strings, but my step definition method only takes one. I need to designate the first group as non-capturing like this:

Now, with the addition of ?: at the beginning of the group, it will perform as I expect.

By the way: You may be wondering how the attribute can be When and still match Given I'm logged in as an admin. It turns out that in Cuke4Nuke, just like in Cucumber for Ruby, it doesn’t matter whether you use Given, When, or Then to define a step definition. They’re all step definitions and are interchangeable. It’s fairly common for today’s When to be tomorrow’s Given, so this is a nice feature.

Just enough

This is only the tip of the regular expression iceberg. Here’s a book and website if you’re interested in going deeper. But for day-to-day work with Cucumber, anchors, simple wildcards and quantifiers, and capturing and non-capturing groups are all you need.

Related posts:

1. Cuke4Nuke: Cucumber for .NET Teams
2. Debugging Cuke4Nuke Step Definitions
3. How to Remove Duplication in Cucumber Tests Using Scenario Outlines

At a client today, we were doing some tricky automation with WatiN (against Telerik controls) in Cuke4Nuke. We wanted to dig into what WatiN was finding in the browser. The obvious move was to fire up the debugger. But with Cuke4Nuke, this is trickier than you might think. The Cuke4Nuke gem includes a release build—no debug symbols. Plus, the process isn’t around long enough to attach to if you use the cuke4nuke executable. We probably could have figured it out, but it wasn’t worth the trouble.

Since we weren’t debugging the Cucumber side of things, we didn’t need all the Cucumber and Cuke4Nuke plumbing. We just needed to run the code using WatiN.

NUnit and Resharper to the rescue…Cuke4Nuke cares about Given, When, Then, Before, and After attributes on your methods. But that doesn’t mean those are the only attributes allowed.

We added a TestFixture attribute to the class. We put SetUp and TearDown attributes on the Before and After methods. We created a new method with a Test attribute that called the relevant step definition methods. Set a breakpoint, click the Resharper test icon and choose Debug, and next thing we knew we were debugging our way through the step definition code.

Next time you need to debug a tricky step definition, don’t bother trying to get Cuke4Nuke in the debugger. Just use your unit test framework to call your step definitions. It’s faster to set up and faster to run.

Related posts:

1. The Latest on Cuke4Nuke
2. Cuke4Nuke: Cucumber for .NET Teams
3. Screencast: Testing Web Applications in .NET with Cuke4Nuke and WatiN

Gojko Adzic has a new blog post demonstrating the new table parameter support in Cuke4Nuke. Table parameters are an important part of Cucumber. They’re great for setting up data and asserting that lists are what you expect. But I use them much less often than the other kind of table in Cucumber, scenario outlines.

Scenario outlines are the solution to repetitive Given-When-Then scenarios. Extending the WatiN example in my previous screencast, we might find ourselves writing scenarios like:

This kind of repetition gets old fast, both to write and to read. Scenario outlines allow us to separate the structure of the test, which doesn’t change, from the data, which does. Here are the same scenarios refactored:

Cucumber turns each example—each table row—into a concrete scenario before looking for matching step definitions in Cuke4Nuke, so nothing needs to change on the Cuke4Nuke side.

In most cases, I recommend starting with concrete scenarios and refactoring to scenario outlines once you have a few scenarios working with the correct step definitions.

Related posts:

1. The Latest on Cuke4Nuke
2. Cuke4Nuke: Cucumber for .NET Teams
3. Screencast: Testing Web Applications in .NET with Cuke4Nuke and WatiN