It was fun to have a virtual audience.

I uploaded the code and slides to the presentations page.

Any feedback would be appreciated! Feel free to ask any questions.

Enjoy!

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!

One of the features that I miss when I work in .net is a tool to retrieve my dependencies (i.e. assemblies, tools) from a centralized server to avoid copying them again and again from project to project.

In the java world Maven does that (and much more) for you, and in the Rails world a utility called Gems (a gem is a ruby library) exists that will download and install the dependencies of your project for you.

To illustrate the point, let’s look at the .NET Media Library project. The project file structure looks something like this:

+—Media Library

+—Main: main source, all the projects are in here.

+—Test: Testing source, all the testing projects are in here.

+—Lib: Dependencies for the projects.

+—Tools: Tools to be used to build, test, deploy, etc.

I have to potential candidates to store external resources (actually I’m using SVN externals, but is giving me lots of grief), lib and tools.

Under lib I have the libraries like:

• Castle Core
• Castle Windsor
• Open Rasta
• MavenThought Commons
• MavenThought Testing
• SharpTestEx
• NHibernate
• SQLite

And under tools I have

• SVN
• MsBuild Community Tasks
• Gallio
• FxCop
• StyleCop

Every library and every tool has a particular version, even some of them have dependencies on their own that I have to compile, store and copy every single time I start a project or I want to upgrade.

What to do? What to do indeed….

A new project is born

What to do? Create my own, of course.

Disclaimer: I don’t want to reinvent the wheel, so, if you know of a similar project, please let me know ASAP!

My goal is to build a tool that will use a configuration file in which I can declare my dependencies and will download them from a known host.

Similar to Gems I’d like to use a DSL (Domain Specific Language) to be declarative and have a clear syntax to describe, versions, sources, targets, aliases, etc.

However, I’d like to take advantage of another language that I can build on top, to have lots of features out of the box that otherwise I need to implement on my own.

Don’t be scared, BOO is here!

What better candidate than Boo? Quoting the site:

Boo Boo is a new object oriented statically typed programming language for the Common Language Infrastructure with a python inspired syntax and a special focus on language and compiler extensibility.

After using Binsor in a few projects I was convinced that Boo is an excellent choice to build the tool. So my first step was to buy the book DSLs in Boo: Domain-Specific Languages in .NET, and start reading.

First Draft DSL Syntax

Let’s imagine that we want to declare dependencies for the .NET Media Library, here is my idea so far:

lib_folder lib
source http://MavenThought.com/nass

# Testing libraries
lib MavenThought.Commons, 0.2
lib MavenThought.Testing, 0.2
lib nunit, 2.5
lib SharpTestEx, 1.0
lib SpecFlow, 1.2

# Castle Stack
lib Castle.Core, 1.1
lib Castle.Windsor, 2.0

# ORM
lib NHibernate, 2.1
lib SQLite, 2.1

# Web framework
lib OpenRasta, 2.0.3
lib JSon.NET, 3.5

The lib keyword declares the dependency and the version and we can see at the top the configuration for the destination folder and the source to get the dependencies. Because we are using Boo we can use the comments, etc…

Any feedback?

Ruby content

• Introduction to scripting languages
• Introduction to unit testing, functional testing, BDD
• Great Ruby and Rails free resources
• Basic git usage (distribute version control system), github
• IRB, rubygems
• Basic Ruby syntax
• Classes and inheritance in Ruby
• Ruby blocks, closures, iterators, examples of use
• Basic usage of Ruby standard library
• Modules, mixins, multiple inheritance in Ruby
• RSpec, Cucumber

Ruby on Rails content

• Introduction to MVC for web frameworks, Rails history, comparison with other frameworks
• Serving static content
• Rails ORM (ActiveRecord), migrations, database backends Joins, validations, associations, named_scopes
• Controllers, information sharing, filters, permissions Helpers, idioms, code smells
• Routing, REST, nested resources Login, logout, sessions, attachments
• Gem management, plugins, git submodules
• Advanced forms, custom form builders haml, sass will_paginate, paperclip, authlogic, formtastic
• Rspec-rails, cucumber-rails, other test gems
• Rails console, Rails runner Scripted deployment
• Testing web applications, modern Rails testing

Each day will consist of an explanation of the subjects, practical examples illustrating the concepts and hands on time to implement a series of exercises using the topics presented during the day.

Any questions please contact me!

The course would take place at New Media Manitoba and if you’d like to attend here is the link to register.

Why you should attend?

RoR is a full MVC web development framework that would show you that developing web applications can be intuitive, professional, secure, easy and fun!

What is so great about Rails? Here are some reasons:

• It’s based on ruby, so you get all the power of a dynamic language.
• Automatic dependencies and library management using Gems
• Automatic relational mapping to databases
• Behaviour Driven Development
• Test Driven Development
• Database versioning, migrations and seeding
• Automatic REST implementation
• Rake DSL
• Support for multiple view engines (like haml)
• Huge base of libraries (gems) and users around the world

Who should attend?

Any developer with basic knowledge of a programming language can learn RoR.

What do I get?

In this course you will build the confidence and real hands on knowledge to start developing high quality RoR applications. You will learn:

• Ruby scripting
• Rails MVC architecture.
• Package management with Gems.
• How to apply Behaviour Driven Development, and Test Driven Development.
• Persistence mapping with ActiveRecord.
• RESTful services.
• Manage source versioning with Git.
• Automated deployment with Capistrano.

Are you sure it’s a course for me?

Of course, it does not matter if you are a .NET, Java or Eiffel developer, RoR would open your mind to new concepts, technologies and tools that would complement and improve your daily tasks.

Any more questions, please contact me at amir@barylko.com.

Hope to see you there!

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!!!

One of many great things about blogging is that you get feedback from other developers. My good friend Sebastian (@paraseba) suggested to use a Chain-of-Responsibility instead of a Composite to find the an active snapping strategy. If u have no idea what I’m talking about, please read the previous post about “Implementing a Snapping Strategy“.

CoR Pattern

In the Design Patterns book, the authors describe the Chain of Responsibility pattern like this:

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.

In our case this means that we should give the opportunity to each strategy to do the snapping and if no snapping is available should call the “chained” strategy to see if the point should be snapped.

The solution it’s working, good time to refactor (Red, Green, Refactor) to add more flexibility to our strategies.

Let’s explore what changes do we need to do in order to be able to chain the strategies.

Chained Strategies

I don’t think we should modify the interface, no one needs to know which pattern are we implemented, so I am going to create a new abstract class called ChainedSnappingStrategy.

This class will be the base implementation for all the other strategies with two responsibilities:

• Call the next strategy in the chain if no snapping was applied
• If it’s the end of the chain, return the same point.

Our hierarchy updated will look something like this:

I added a new abstract method called SnapImpl to implement in each concrete class the snapping (same as we have now).

The Snap method should call the implementation first and then check if the point was snapped or not, if not should go to the next strategy. Here is the code:

   1: public abstract class ChainedSnappingStrategy : ISnappingStrategy

   2: {

   3:     public ISnappingStrategy Next { get; set; }

   4:

   5:     public Point Snap(Point point, IDrawingContext context)

   6:     {

   7:         var result = this.SnapImpl(point, context);

   8:

   9:         if (this.Next != null && result == point)

  10:         {

  11:             result = this.Next.Snap(point, context);

  12:         }

  13:

  14:         return result;

  15:     }

  16:

  17:     protected abstract Point SnapImpl(Point point, IDrawingContext context);

  18: }

And voila, our strategies are chained!

For the past eight months I’ve been working on a WPF  desktop application that has a tool to draw. Very similar to most drawing application, you select the Drawing tool in the ribbon/toolbox and then you are able to draw on the canvas until you close the shape or cancel the tool.

The new requirement

Now, we need to draw using snapping. Snapping means that when you are drawing close to a particular point (considering a distance) the mouse will move but the drawing line not, will stay snapped to the point.

In this case we need to consider three cases:

1. Snapping on the X axis (horizontal axis)
2. Snapping on the Y axis (vertical axis)
3. Snapping when the line has an 90 degree angle with the previous line

The solution

Where should I add the snapping?

So I started by writing a test  (Yes, full TDD) that checks when I’m close to the X axis (3 pixels or less) then the drawing tool should snap. My test failed gloriously and I was ready to start my implementation in order to make the test pass… now… the question is… who is responsible for snapping?

The Drawing Tool

Let’s review the drawing tool interaction to understand how it works using MVVM.

• The Canvas receives a mouse move event and passes that information to the DrawingTool
• The DrawingTool raises a LineMoved event
• The view model receives the event and notifies the view
• The view shows the line ending on the new point

A sequence diagram should look something like this:

Who is responsible for snapping?

The DrawingTool does not know about snapping, but it should, because is raising the event… However considering the SRP (single responsibility principle) makes more sense to delegate this decision to another class, behold the ISnappingStrategy.

I decided to inject the strategy into the DrawingTool constructor (via IoC) and the DrawingTool will query the strategy for each point before raising the event, thus the event will contain the point decided by the strategy.

Let’s look at the new sequence diagram with the strategy added to the interaction:

Why a strategy? Is that the GOF pattern?

Indeed it is, why? Because I wanted to encapsulate the algorithm I’m going to use to snap, snapping to X axis has different rules than snapping to the previous line when having a 90 degree angle. Please refer to the GOF book “Design Patterns” or Google for more examples and diagrams.

Snapping Strategy Hierarchy

I have so far one interface ISnappingStrategy and three concrete strategies that implement the interface:

Each strategy when called will return the snapped point or, if no snapping is required the same point.

So far, so good…. now I have implemented them, and each one passes the unit tests. However I don’t want to use just one of the them, I want to use all of them combined. I’d like to use first SnapToX and if does not snap, then SnapToY, etc, etc.

Enters the Composite Strategy

The Composite pattern is another GOF pattern and the goal is to treat a group of objects like they where a single instance. In this case, I want to use multiple snapping strategies like they were just one strategy.

Here is the idea, let’s create the Composite with a collection of strategies, and when called the Composite will iterate thru them until it finds a new snapping point or, if no snapping should happen, return the same point.

So, with the Composite, the new hierarchy looks like:

And the code for the composite snapping would be:

   1: public Point Snap(Point point, IDrawingContext context)

   2: {

   3:     var found = this._strategies.Find(s => s.Snap(point, context) != point);

   4:

   5:     return found == null ? point : found.Snap(point, context);

   6: }

The cherry on top

Now we need to configure all this, luckily we can use Binsor to configure our Windsor container and it will look something like this:

   1: component "SnapToX", ISnappingStrategy, VectorSnappingStrategy:

   2:   x = 1

   3:   y = 0

   4:

   5: component "SnapToY", ISnappingStrategy, VectorSnappingStrategy:

   6:   x = 0

   7:   y = 1

   8:

   9: component "SnapToPrevious", ISnappingStrategy, PreviousLineSnappingStrategy

  10:

  11: component "SnappingStrategy", ISnappingStrategy, CompositeSnappingStrategy:

  12:   strategies = [@SnapToX, @SnapToY, @SnapToPrevious]

  13:

  14: component "DrawTool", IDrawTool, DrawTool:

  15:   snapping = @SnappingStrategy

Neat eh?

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!