Update !! this has changed a lot
Check this post !!!
Introduction
During my exploration of BDD frameworks for .NET I only had one final runner-up as a BDD framework : Machine.Specifications . This is a very nice framework, but in my quest for the holy grail on BDD it got me started on thinking about an even better BDD framework. In this article I will layout my initial ideas about a BDD framework named Aubergine.
Likes and dislikes about MSpec
MSpec is in my personal opinion one of the best BDD frameworks available for .Net, due to the very nice syntax.
An example :
First I'll show you the account class :
public class Account
{
public Decimal Balance {get;set;}
public void Transfer(decimal amount,Account ToAccount)
{
if (Balance < amount)
{
throw new ArgumentOutOfRangeException("There is not enough money available on the account");
}
Balance-=amount;
ToAccount.Balance+=amount;
}
}
Next up I will show you the specs in Mspec :
using System;
namespace Machine.Specifications.Example
{
[Subject(typeof(Account), "Funds transfer")]
public class when_transferring_between_two_accounts
: with_from_account_and_to_account
{
Because of = () =>
fromAccount.Transfer(1m, toAccount);
It should_debit_the_from_account_by_the_amount_transferred = () =>
fromAccount.Balance.ShouldEqual(0m);
It should_credit_the_to_account_by_the_amount_transferred = () =>
toAccount.Balance.ShouldEqual(2m);
}
[Subject(typeof(Account), "Funds transfer"), Tags("failure")]
public class when_transferring_an_amount_larger_than_the_balance_of_the_from_account
: with_from_account_and_to_account
{
static Exception exception;
Because of =()=>
exception = Catch.Exception(()=>fromAccount.Transfer(2m, toAccount));
It should_not_allow_the_transfer =()=>
exception.ShouldBeOfType<Exception>();
}
public class failure {}
public abstract class with_from_account_and_to_account
{
protected static Account fromAccount;
protected static Account toAccount;
Establish context =()=>
{
fromAccount = new Account {Balance = 1m};
toAccount = new Account {Balance = 1m};
};
}
}
While this is a very keen and intelligent approach there are a few things that I am not very fond of :
- The "Subject" attribute : is really code litter, and not really acceptable IMHO
- The fact that we use classes and subclasses for each scenario; sometimes this becomes too much of a hassle; your code gets split up into several places, and this is not very transparent anymore...
- The lack of Story support
- The catching of expected exceptions should not need a try catch block but have some kind of other mechanism.
Edit: My bad;there is a mechanism in MSpec... However, I'm not a real fan of it, since it is in the because part. IMHO this should be an "it", not a "because"
- The fact that the context is intermixed with the class itself => this might be a subject of discussion, but it is certainly not my personal preference; I prefer a seperate context class per story and/or scenario
- Some definitions, i.e. "because of", "Establish","It" etc... are not good enough in my opinion
- The use of underscores; I am more of a PascalCasing fan
Edit: After the remark of Aaron, I decided to implement both
Based on my ideas I created a new BDD Framework : NetSpec
The Aubergine approach
Based on my findings I started coding this morning, and this is the spec defined in NetSpec :
class TransferFundsBetweenAccounts : Story
{
AsAn AccountUser;
IWant ToTransferMoneyBetweenAccounts;
SoThat ICanHaveRealUseForMyMoney;
class Transfer1MBetweenTwoAccounts : Scenario<Context>
{
Given BothAccountsHave1M = () => new Context(1m,1m);
When Transfering1MFromAToB = c => c.AccountA.Transfer(1m,c.AccountB);
ItShould Have0mOnAccountA = c => c.AccountA.Balance.ShouldEqual(0m);
ItShould Have2mOnAccountB = c => c.AccountB.Balance.ShouldEqual(2m);
}
class TransferTooMuch : Scenario<Context>
{
Given BothAccountsHave1M = () => new Context(1m, 1m);
When Transfering2MFromAToB = c => c.AccountA.Transfer(2m,c.AccountB);
ItShould Have1mOnAccountA = c => c.AccountA.Balance.ShouldEqual(1m);
ItShould Have1mOnAccountB = c => c.AccountB.Balance.ShouldEqual(1m);
ItShouldFailWithError AmountToLarge = e =>
e.ShouldBeOfType<ArgumentOutOfRangeException>();
}
public class Context
{
public Context(decimal amounta, decimal amountb)
{
AccountA.Balance = amounta;
AccountB.Balance = amountb;
}
public Account AccountA = new Account();
public Account AccountB = new Account();
}
}
Edit : After Aaron's remarks I replaced
ItShouldThrowException<ArgumentOutOfRangeException> AmountToHigh;
with
ItShouldFailWithError AmountToLarge = e => e.ShouldBeOfType<ArgumentOutOfRangeException>();
which is closer to the domain expert's language then the developer's.
Now, I do not know what You think, but in my opinion this is a lot more readable then the MSpec version.
While the code currently compiles, the testing itself is not implemented yet, but this should not be such a big hurdle. The automatic catching of the exception should only happen in the "When"-phase afaik, other exceptions should ALWAYS return a fail.
Conclusion
In my quest for the holy grail I have met a lot of hurdles but I do think I am getting closer to my target. I hope/think that a domain expert should be able to read the code I present in the specifications; In my opinion this should be a viable DSL-like human-readable text. While the current representation still has some constraints due to it's implementation language, most of the disturbing stuff has been left out.
Up next is the implementation of the testrunner, but I will have to take a look at my schedule when I will be able to complete this, since I sometimes have to do some work that pays the bills as well ;) ...
If you have any suggestions or remarks please do let me know in the comment section !!
Subscribe