A New BDD Framework in .NET: NetSpec => Aubergine

Just a quick update!! After thinking a bit more about the problems mentioned by Aaron in my previous post, and taking a look at Cucumber (in ruby), I decided to give it another go. Since I have to be in the shop within half an hour 20 mins, I can only give you a sample of what the current spec looks like; explanations will come in later posts... I'm also considering a rename, since netspec already seemed to exist as a .NET spec platform...

Since Cucumber was my inspiration, I'm currently thinking about Aubergine/Eggplant. Suggestions are welcome.

I'm not really fond of the implementation yet, but I'll have to think about that a little bit more... As you might notice, there has been a slight shift towards the Cucumber method of doing things.

Here we go:

    class TransferFundsBetweenAccounts : Story
    {
        AsAn AccountUser;
        IWant ToTransferMoneyBetweenAccounts;
        SoThat ICanHaveRealUseForMyMoney;

        class Transfer1MBetweenTwoAccounts : Scenario<Context> 
        {
            Given AccountAHas1M;
            Given AccountBHas1M;
            When Transfering1MFromAccountAToAccountB;
            Then ShouldHave0MOnAccountA;
            Then ShouldHave2MOnAccountB;
        }

        class TransferTooMuch : Scenario<Context>
        {
            Given AccountAHas1M;
            Given AccountBHas1M;
            When Transfering3MFromAccountAToAccountB;
            Then ShouldHave1MOnAccountA;
            Then ShouldHave1MOnAccountB;
            Then ShouldFailWithError;
        }

        class Context
        {
            public Account AccountA = new Account();
            public Account AccountB = new Account();
        }

        class Contextimpl : ContextImplementation<Context>
        {

            public bool Get(string name,Context ctx)
            {
                return
                    Implement(@"(Account[AB])Has(\d+)M", (c, e) =>
                        {
                            e.ByName<Account>(0,c).Balance = e.Get<int>(1) * 1m;
                        }).Run(name, ctx) &&
                    Implement(@"ShouldHave(\d+)MOn(Account[AB])", (c, e) =>
                        {
                            e.ByName<Account>(1,c).Balance.ShouldEqual(e.Get<int>(0) * 1m);
                        }).Run(name, ctx) &&
                    Implement(@"Transfering(\d+)MFrom(Account[AB])To(Account[AB])", 
                           (c, e) =>
                        {
                            e.ByName<Account>(1,c).Transfer(e.Get<decimal>(0) * 1m, 
                               e.ByName<Account>(2,c));
                        }).Run(name, ctx);
            }
        }
    }

As you might notice, the biggest advantage is that multiple test scenarios can now be implemented since we have created some kind of a context-specific DSL... I'm not very fond of the way you Specify the DSL however; I'll probably need to rethink it.

As always, I'll keep you posted on any progress I make.