Trying out Behave#
One of the neat things I saw at the Agile conference was a short demo of RSpec and RBehave. Intrigued, I did a quick search and found the .NET equivalents: Behave# and NSpec.
Note: I'm not sure I completely understand the differences between xSpec and xBehave as they both quote Behaviour-Driven Design as their goal. I think that the Behave libraries are just a way to change the nomenclature of xUnit from 'test' to 'behaviour'. The Spec ones are about writing user stories in a sort of DSL that a product owner or PM could understand.
Since developer stories can be user stories, I thought it would fun to use Behave# to implement the Stack example from Jim Newkirk's Test-Driven Development in .NET book. Here's what I ended up with (apologies for the formatting - it's much easier to read inside VS):
Stack stack = null;
bool isEmpty = false;
object tempObject = null, tempObject2 = null, tempObject3 = null;
List<int> knownObjects = new List<int>();
knownObjects.Add(1);
knownObjects.Add(2);
knownObjects.Add(3);
Story stackStory = new Story("Basic stack operations");
stackStory
.AsA("developer")
.IWant("to peform operations with a stack")
.SoThat("I can save my data");
stackStory
.WithScenario("A brand new stack")
.Given("a stack I created", delegate { stack = new Stack(); })
.When("I query its state", delegate { isEmpty=stack.IsEmpty; })
.Then("it should be empty", delegate { Assert.True(isEmpty); })
.Given("a stack I created")
.When("I push a single object",
delegate { stack.Push(new object()); })
.And("I query its state")
.Then("it should not be empty",
delegate { Assert.False(isEmpty); })
.Given("a stack I created")
.When("I push a single object")
.And("pop the object", delegate {tempObject=stack.Pop(); })
.And("I query its state")
.Then("it should be empty")
.Given("a stack I created")
.When("I push a known object",
delegate { stack.Push(knownObjects[0]); })
.And("pop the object")
.Then("the two objects are equal",
delegate {
Assert.Equal<object>
(knownObjects[0], tempObject); })
.Given("a stack I created")
.When("I push three known objects",
delegate{knownObjects.ForEach(
delegate(int val){stack.Push(val);});})
.And("pop each one ",
delegate { tempObject = stack.Pop();
tempObject2 = stack.Pop();
tempObject3 = stack.Pop(); })
.Then("all three objects are the same",
delegate
{
Assert.Equal<object>(knownObjects[2], tempObject);
Assert.Equal<object>(knownObjects[1], tempObject2);
Assert.Equal<object>(knownObjects[0], tempObject3);
})
.Given("a stack I created")
.When("I pop an object it throws an exception",
typeof(InvalidOperationException),
delegate(Type type)
{ Assert.Throws(type, delegate { stack.Pop(); }); })
.Then("", delegate { ;})
.Given("a stack I created")
.When("I push a single object")
.And("call top", delegate { tempObject = stack.Top(); })
.And("I query its state")
.Then("it should not be empty")
.Given("a stack I created")
.When("I push a known object")
.And("call top")
.Then("the two objects are equal")
.Given("a stack I created")
.When("I push three known objects")
.And("call top")
.Then("the last item is equal to the top one",
delegate
{ Assert.Equal<object>(knownObjects[2], tempObject); })
.Given("a stack I created")
.When("I push a known object")
.And("call top repeatedly",
delegate
{
tempObject = stack.Top();
tempObject2 = stack.Top();
tempObject3 = stack.Top();
})
.Then("all objects are equal to what was pushed",
delegate
{
Assert.Equal<object>(knownObjects[0], tempObject);
Assert.Equal<object>(knownObjects[0], tempObject2);
Assert.Equal<object>(knownObjects[0], tempObject3);
})
.Given("a stack I created")
.When("I call top it throws an exception",
typeof(InvalidOperationException),
delegate(Type type)
{ Assert.Throws(type, delegate { stack.Top(); }); })
.Then("")
.Given("a stack I created")
.When("I push a null object", delegate { stack.Push(null); })
.And("I query its state")
.Then("it should not be empty")
.Given("a stack I created")
.When("I push a null object")
.And("pop the object")
.Then("the returned object is null",
delegate { Assert.Null(tempObject); })
.Given("a stack I created")
.When("I push a null object")
.And("call top")
.Then("the returned object is null");
}
and when I run the tests, this is the output:
Story: Basic stack operations
Narrative:
As a developer
I want to peform operations with a stack
So that I can save my data
Scenario 1: A brand new stack
Given a stack I created
When I query its state
Then it should be empty
Given a stack I created
When I push a single object
And I query its state
Then it should not be empty
Given a stack I created
When I push a single object
And pop the object
And I query its state
Then it should be empty
Given a stack I created
When I push a known object
And pop the object
Then the two objects are equal
Given a stack I created
When I push three known objects
And pop each one
Then all three objects are the same
Given a stack I created
When I pop an object it throws an exception: System.InvalidOperationException
Then
Given a stack I created
When I push a single object
And call top
And I query its state
Then it should not be empty
Given a stack I created
When I push a known object
And call top
Then the two objects are equal
Given a stack I created
When I push three known objects
And call top
Then the last item is equal to the top one
Given a stack I created
When I push a known object
And call top repeatedly
Then all objects are equal to what was pushed
Given a stack I created
When I call top it throws an exception: System.InvalidOperationException
Then
Given a stack I created
When I push a null object
And I query its state
Then it should not be empty
Given a stack I created
When I push a null object
And pop the object
Then the returned object is null
Given a stack I created
When I push a null object
And call top
Then the returned object is null
1 passed, 0 failed, 0 skipped, took 1.15 seconds.
So is it useful? Like most things, there are situations where it's appropriate and others where it's not. I'm starting with a contrived example to begin with, and so not demonstrating its full usefulness. Regardless, there are a few points I'd like to make after playing with it for a while:
- It's nice to repeat snippets of an English sentence instead of code, although I suspect the novelty would fade after a while :)
- If you want to specify Exceptions as part of your story, this forces you to move away from [ExpectedException]. Which is a Good Thing anyway. I'm using an Assert replacement from Codeplex to accomplish this.
- I'm a big fan of having very descriptive method names for unit tests - this is taking descriptive to the next level :)
On the (possibly) less good side of things:
If a story fails, then the rest of the test isn't executed. It doesn't make sense to only put one scenario per test either, because then you'll end up repeating the delegate code.
If a story fails, it's sometimes really awkward to figure out why. It's really annoying when you have to debug into the delegate.
The test/stories are dependent on each other. This is a very disconcerting concept coming from an EDD background.
It's very difficult to test loops, or perhaps I just haven't found a good way. If you look at the place where
Top()is called repeatedly (fifth last story) and we check to make sure it always returns the same value, I had to use named objects to accomplish this. The original test looked like this:[Test]public void PushTopNoStackStateChange(){ string pushed = "44"; stack.Push(pushed); for(int index = 0; index < 10; index++) { string topped = (string)stack.Top(); Assert.AreEqual(pushed, topped); }}and I would claim that's easier to read. There's some flexibility lost there.
I'd like to see some more real world examples of this being used; this could be a powerful tool in the right circumstances. And of course as the library is enhanced, some of the things I've talked about may become more feasable.