I created a repository on GitHub with the code so I can share my first attempt.

You can follow the commit comments to get an idea of the train of thought.

Or if u prefer, just keep reading

The Methodology

I used TDD and somehow BDD all the way. Started with an acceptance test and jumped in and out from the unit tests until the feature passed.

Why is a good idea to start with an acceptance test?

When you know where you want to go, what you want to achieve, is easier to keep the focus.

Having a way of identifying if the current feature is finished is a lot of power in your hands, so do the minimum necessary to make it work and then – once the test is passing – do refactoring as you see fit.

In the solution you will find three projects:

1. BowlingKata: Classes that implement the Kata
2. BowlingKata.Unit.Tests: Unit tests
3. BowlingKata.Acceptance.Test: Features that I’m looking for in a bowling game

Design Decisions (fast forward TDD)

As soon as I started to write a unit test for the BowlingGame class I wonder how am I going to design the solution.

My first test was for the method Roll(pins). And right there I had to assign responsibilities.

What should this method do? Do the “registration” only? Do the calculation as well? Is there any other class involved?

I decided on keep things simple and separate two clear responsibilities:

1. Keeping the number of pins knocked down on each ball (or frames later)
2. Calculating the score based on the information on each frame

I’ve been doing presentations a the WPG CC for the past three years, and is always a blast! Great sessions, lots of networking and great food is an awesome combination!

After my session, some of the attendes approached me and started to talk about CI, their gotchas about testing and woes .

One of them mentioned that he wasn’t sure about the way they were using “hardcoded” values with the tests. He felt that probably should be a better way of defining valid inputs that could avoid the “smell”.

My suggestions was to consider using auto generated values. Random values are a great tool to avoid hardcoding inputs. Using “factories” to create valid test values helps us to make sure we have better coverage of the domain of valid inputs for our tests.

How do I know what input is valid?

You may wonder “But, if the values are random, the test may pass once and then fail at runtime, that’s really, really, dangerous!!!”.

The answer is No, not at all. The key is to identify the domain that makes your test pass and use the random generation tools to get values that are part of that domain. How to do that? Keep reading …

When you write a unit test you may have more than one scenario. For each scenario you need to find a set of inputs that make it pass.

For example, let’s use a method that verifies if a string is a palindrome. Definition of palindrome in wikipedia:

A palindrome is a word, phrase, number or other sequence of units that can be read the same way in either direction

Our method may look something like this in C#:

bool IsPalindrome(string word)

So now, what should we do? Write one test that takes random strings as input, run it once and if we are lucky and passes then we are done? Woah, slow down your horses….. take a deep breath… maybe two….

Preconditions, postconditions and domains

The precondition of the method is the set of values that are valid in order to call the method. Valid means that we don’t get an exception when we use it, no matter what the result of the method is.

So, what are the values that are valid to use for IsPalindrome? It seems to me that any string should work, except null, therefore:

• Precondition: Any not null string instance.

Great! Now let’s think about the postcondition and discover our scenarios. The postcondition defines what are the expected results and under what conditions are calculated.

Following our definition of what the method does, we can have two possible outputs:

• True: if the input is palindrome
• False: if the input is not palindrome

Thus, we have two scenarios:

• When the word is palindrome it should return true
• When the word is not palindrome it should return false

Writing the test

We need to test two scenarios and the best way of doing that is to write one test per scenario.

The first test should check the first part of the postcondition, I want to get true as result, and to do that the domain I need to use would be all the words that actually are palindrome. Let’s write the scenario:

Given I have a palindrome phrase

When I check IsPalindrome

Then I should get true

I like to use the Given-When-Then syntax, it’s very descriptive. I’m using the MT Testing library that enforces GWT. Here is the scenario using C# and just one example:

protected override void GivenThat()
{
    this._phrase = "Madam Im adam";
}

protected override void WhenIRun()
{
   this.Actual = PalindromeChecker.IsPalindrome(this._phrase);
}

[It]
public void Should_validate_the_phrase_is_palindrome()
{
    this.Actual.Should().Be.True();
}

The test looks good, a bit of TDD and all green. Don’t worry about the implementation, you can download all the source and check it out at the later .

Using Factories

I’d like to make sure that for any palindrome phrase (that’s the domain we got from the pre and post condition) the test passes, no just for one example.

However, though generating all the palindrome words is a bit ambitious, we could settle for generating a collection of phrases that are palindrome and use that as input.

MbUnit provides an attribute named “Factory” that allows a static method to define a collection of values to be passed to the test, let’s look at the code:

        private readonly string _phrase;

        [Factory("PalindromeFactory")]
        public When_palindrome_checker_checks_a_palindrome_phrase(string phrase)
        {
            _phrase = phrase;
        }

        protected override void WhenIRun()
        {
            this.Actual = PalindromeChecker.IsPalindrome(this._phrase);
        }

        [It]
        public void Should_check_the_word_as_palindrome()
        {
            this.Actual.Should().Be.True();
        }

        protected static IEnumerable<string> PalindromeFactory()
        {
            yield return "Madam I'm adam";
            yield return "Draw pupil's lip upward";
            yield return ....
        }

Using the attribute, we indicate the runner that the test should be run for every value in the collection.

We run the test, and we can see in the result window something like:

### Step When_palindrome_checker_checks_a_palindrome_phrase("Madam I\’m adam"): passed ###
### Step When_palindrome_checker_checks_a_palindrome_phrase("Draw pupil\’s lip upward"): passed ###
### Step When_palindrome_checker_checks_a_palindrome_phrase("Gateman sees name, garageman sees name tag"): passed ###
### Step When_palindrome_checker_checks_a_palindrome_phrase("Go hang a salami; I\’m a lasagna hog"): passed ###
### Step When_palindrome_checker_checks_a_palindrome_phrase("I roamed under it as a tired, nude Maori"): passed ###
### Step When_palindrome_checker_checks_a_palindrome_phrase("Live not on evil"): passed ###

Using random strings

One case covered, one to go.

The second test should verify the second part of the postcondition. I want to get false as result, so the domain I need to use is all the words that are not palindrome. Let’s write the scenario:

Given I don’t have palindrome phrase

When I check IsPalindrome

Then I should get false

And the code:

        private string _phrase;

        protected override void GivenThat()
        {
            this._phrase = "This is not palindrome";
        }

        protected override void WhenIRun()
        {
            this.Actual = PalindromeChecker.IsPalindrome(this._phrase);
        }

        [It]
        public void Should_not_validate_the_phrase_as_palindrome()
        {
            this.Actual.Should().Be.False();
        }

The code works fine. However we have a similar situation as before, I’d like to have more values that belong to the domain that makes the method fail, that means any phrase that is not palindrome.

Factories are a good idea when we have a set of values that we want to use. In this case I don’t want to hardcode non palindrome phrases. I would prefer to have a way of creating those phrases without needing to enumerate all the examples.

Luckily MbUnit has another attribute that we can use to generate random strings. It’s called RandomStrings and it takes a regular expression to describe the string. Adding the attribute the code looks like this:

        private readonly string _phrase;

        public When_palindrome_checker_checks_a_non_palindrome_phrase(
            [RandomStrings(Count=10, Pattern=@"Weird [A-Z]{5,8} [0-9]{2}")]string phrase)
        {
            _phrase = phrase;
        }

        protected override void WhenIRun()
        {
            this.Actual = PalindromeChecker.IsPalindrome(this._phrase);
        }

        [It]
        public void Should_not_validate_the_phrase_as_palindrome()
        {
            this.Actual.Should().Be.False();
        }

I’m using a regular expression that uses numbers at the end to make sure the phrase is not palindrome.

We run the tests, and here is the output:

### Step When_palindrome_checker_checks_a_non_palindrome_phrase("Weird VGSKTTZ 64"): passed ###
### Step When_palindrome_checker_checks_a_non_palindrome_phrase("Weird VLMEWIJ 59"): passed ###
### Step When_palindrome_checker_checks_a_non_palindrome_phrase("Weird NDICJK 08"): passed ###
### Step When_palindrome_checker_checks_a_non_palindrome_phrase("Weird FEMBMSKK 88"): passed ###
### Step When_palindrome_checker_checks_a_non_palindrome_phrase("Weird IHOIOWN 38"): passed ###
### Step When_palindrome_checker_checks_a_non_palindrome_phrase("Weird ITIRCHAA 63"): passed ###

The moral of the story

Random values are a powerful tool, not dangerous per se. They are part of our toolbox as developers. Can we use it wrong? Sure, but that’s a completely different story ….

If you want to get the full code, download it from the examples in MT Testing. Check the Palindrome folder.

Do you have any other stories or comments about random values that you would like to share, please leave a comment, feedback is more than welcome.

Want to see an example with major complexity? Something that fits better your case? Tell me about it and I’ll add it to the MT Testing framework as an example of usage (and I’ll give you credit for it too!).

Next week I’ll be presenting at the PrairieDevCon in Regina and one of my presentations is about Behavior Driven Development, how to apply it using .NET tools like SpecFlow, Nunit, Watin, Cassini, MbUnit, etc.

Because is a Dojo/Code with me presentation I’m planning to do a BDD exercise with all the attendees to show them how to describe a new feature using BDD and implement it together.

We will start with a project that has one feature implemented, and will code together the second feature using full BDD and TDD.

So, what should I use to illustrate BDD? No other than my old friend the MediaLibrary example that I used quite a few times, but now including a full BDD implementation.

MediaLibrary

The MediaLibrary project is a web application that  allows the user to register and catalog his collection of movies, books, games, etc.

I’m using GitHub to publish the code we are going to use in the Dojo. Right now the latest version represents the code that I’m going to start with.

If you would like to check out the code I’m going to use please go to the PrairieDevCon page on my blog and get the code from GitHub, read the README file to verify you have the requirements installed and the application is working.

Do you have everything installed? Did you read the README file? Cool, open the solution and let’s move on!

Using BDD

Behavior Driven Development is a term used to describe (in our case) development that starts by writing the feature (or user story) that we want to implement. Once we have the feature, we will use a “story runner” that will run the feature we just wrote and show if the story is actually implemented as we wanted or not yet. If it is, good, everything should be “green”. If not, we get a “red”, and we have to add code and implement more functionality to make it pass.

To write the user story we are going to use a particular syntax from the Gherkin language. The Gherkin language has very few rules, please read the introduction for Cucumber from Aslak Hellesoy.

Let’s see the feature that it’s implemented in the code, Browse Movies:

Feature: Browse Movies
    As a User
    I want to Browse Movies
    So I can see the contents of the library

    Scenario: Browse available movies
        Given I have the following movies:
          | title           |
          | Blazing Saddles |
          | Space Balls     |
        When I go to Movies
        Then I should see in the listing:
          | title             |
          | Blazing Saddles   |
          | Space Balls       |

What is most important here is to look at the scenario. The scenario is describing that if you have movies A, B and C in the library, when you browse you should see the same movies on the Movies page.

Now if we want to check the feature manually, what would we do? Something like this:

1. Add the movies to the storage
2. Start the web application
3. Launch the browser
4. Go to the movies page
5. Check that all the movies in the storage are listed in the browser

The thing is that I don’t want to validate each feature (with many scenarios) manually, I’d like the scenario/feature runner to do that for me, add the movies, launch the browser and check, everything automated following the steps I wrote in my scenario.

Probable we could manage to write code that will do that for us, now, the question is how the scenario runner translates this feature into actual code? If we were using rails we could use Cucumber, but luckily for the .NET world we can use SpecFlow (IronRuby too, but that’s another post).

Given That I have the following movies

Specflow is a tool that understands Gherkin and generates an NUnit test for every feature that we use. Being an NUnit test, simplifies how we going to run the specification. Just run the NUnit test with your favorite test runner: ReSharper, NUnit (console or GUI), MbUnit, etc.

Each scenario is composed by a series of steps, each step is identified by a Gherkin keyword, in our feature we found Given, When and Then.

The NUnit test has code for each scenario and will invoke the steps indicated in the scenario.

In order to do so, Specflow uses the text that we write in the step, to match the code.

Let’s look at our first step “Given I have the following movies:”. In order to implement the step, in the code, you will find a method that looks like:

[Given(@"I have the following movies:")]
public void AddMovies(Table movies)
{
    movies.Rows.ForEach(row => AddMovieToStorage(row["title"]));
}

The Given attribute is used to match the text we wrote in the scenario, to indicate the the method AddMovies should be called when the step is invoked.

The step in the scenario indicates that the method receives a series of rows should be passed as parameter (first row is the title, every column separated by “|”), that is why it receives a Table.

In the implementation for each movie in the table, the title will be added to the storage. Check the method AddMoviesToStorage for more details.

Now that we setup our storage we are ready to move on and launch the browser.

When I go to Movies

The next step to implement implies opening the browser and going to the Movies page to see the listing.

Now, to do so we need two things, first the web application running and then to launch a browser to go the actual page.

To run the application I’m going to use Cassini web server. The setup of the features will start the web server and stop it when it’s not needed any more. We can see the implementation in the Browser class under Utililty.

static Browser()
{
    WebServer = new Server(Port, "/", GetPhysicalPath());
}

With the server running, we now need to launch the browser and automate the checking for all the movies.

For that we are going to use Watin. Watin (Web automation test in .NET) is a library that helps us to manipulate the browser (based on Watir) and also give us all the HTML for the page we are visiting.

We can see the use of the IE instance in the Browser class:

public static void InitializeBrowser()
{
    WebServer.Start();

    Instance = new IE(ApplicationURL);
}

public static void ShutdownBrowser()
{
    Instance.Close();

    WebServer.Stop();
}

Now that we have our server running, and our IE instance, we only need to go to the right path. In this case we want to go to “/Movies”. For that let’s look at the NavigationSteps class:

[When(@"I go to (.*)")]
public void WhenIGoToPage(string pageName)
{
    Browser.GoTo(PathFor(pageName));
}

The step uses the browser to navigate to the right page. The page is passed as a parameter that we can see in the attribute as a regular expression.

So far, so good. Now, our last step is to check for the movies in the page to make sure that all of them are in the list.

Then I should see in the listing

To implement the last step in our scenario we are going to use the following implementation:

[Then(@"I should see in the listing:")]
public void AssertListingContains(Table movies)
{
    var expected = movies.Rows.Select(row => row["title"]);

    var listing = this.Page.Listing;

    listing.Should().Have.SameSequenceAs(expected);
}

Again we are using a step that takes a table as parameter, so we iterate thru the table and get the titles of all the movies that should be in the page.

The code has no mysteries except the Page property.

public ListingSteps()
{
    this.Page = new BrowseMoviesPage();
}

The Page property is initialized in the constructor and the goal of the BrowseMoviesPage is to abstract the internals of how the movies are listed in the page. For example, right now the view that implements the listing of movies uses a table for each movie, however it could use a DIV or some other tag. Here is the implementation:

public IEnumerable<string> Listing
{
    get
    {
        var elements = Browser.Instance.TableCells.Where(cell => cell.ClassName == "title");

        return elements.Select(e => e.InnerHtml.Trim());
    }
}

As we can see, the code is getting all the table cells where the CSS class is title and then getting the inner html and trimming it.

If we would have to use this code every time we want to check the listing we would have code duplication, plus if the implementation of the view changes, we would have to modify each piece of code that refers to this page. Using the PageObject pattern we avoid code duplication and it’s easy to change the implementation.

And voila! We got all our steps implemented.

What’s next?

If you join me next week on the Prairie Dev Con, we will implement the next feature together “Add Movies”.

What’s so cool about BDD? Please go ahead and run “rake test:features” on the command line, and you’ll see that the steps for the second feature are still pending, that means that they are not implemented yet.

Writing the feature first we manage to describe what we want, and implementing step by step we make sure that we are working towards make the feature pass. BDD on the outside and TDD on the inside.

Hope to see you all next week in the conference!

You can read about it at http://www.prairiedevcon.com/. It would be two complete days of sessions with four tracks and many cool speakers!!!!

I will do two presentations:

Real World Behaviour Driven Development

Behaviour Driven Development drives you process towards keeping the focus on the stakeholder’s goals while discovering new features to achieve those goals.
But… what does it mean in a .NET project to use BDD? What do I have to change? What tools are available? Can I use it for project with actual deadlines? How the quality will be improved?
We are going to see a real world example from start to finish using BDD and TDD while answering all those questions. After the session you will have the foundation to apply BDD with confidence on any .NET project.
Track: Developer Foundation
Style: Dojo (Bring your laptop and code with me!)

Test Driven Development Patterns for .NET Developers

Test Driven Development is a methodology that will help us to discover our model while improving the quality of our software.
We are going to see different patterns to help us deal with day to day problems like constructor initialization, exception testing, combinatorial tests, database testing, and many others.
Track: Developer Foundation
Style: Lecture

Hope to see you there!!!

I’m super excited! This year I have two presentations:

1. Real World BDD for .NET developers
2. Intro to TeamCity

I just finished the last changes to the presentations, enjoy!

2010-02-27 Code Camp

See u tomorrow!

Presentation Automocking PPT

Source Code AutoMocking Src

Enjoy!

This time we will talk about using StructureMap  to generate our dependencies for our System Under Test (SUT).

We will go over writing base specification for testing and how to generate dependencies and use them to stub or setup expectations.

See u soon!

Here is the complete source code with all the tests. Mock The Mock Source Code with AAA Syntax

Enjoy.

We started around 8 AM with breakfast and at 9 started the presentations.

I did mine around 10:30, I think it was pretty good (no one faint, or run from the room screaming).

The audience was great, made great questions and laughed (utter kindness) at my bad jokes.

I want to thank everyone that was there, and D’arcy for inviting me.

Here is the presentation PDF presentation, the source code Demo Code (start) and the source code complete with all the tests Demo Code with all the tests.

The video is still to come !

Comments are welcome!

I’m going to talk about mocking using Rhino Mocks.

Here is the presentation: PDF presentation download.

I’ll try to make a video later this week.

See you there!