**** Moved ****

This project has been moved to gitorious: http://gitorious.org/netspec

Introduction

.NetSpec is a small test extension framework for the Visual Studio Testing Framework. Its main goals are:

• Allow users to write tests in an RSpec like syntax more in terms with Behaviour Driven Developement (BDD)
• Make tests easier to read
• Integrate with TFS team build and Visual Studio test view

Behaviour driven development (BDD)
BDD is a software development technique which in many ways is similar to Test Driven Development (TDD). Many people consider it an enhancement of TDD. The main goal in BDD is that tests should describe the behaviour of your classes, and thus provide documentation of your code using code. It also makes it easier to write tests, because the focus has switched from "what to test" to "how should this class behave in differnt scenarios". You can read more about BDD on Wikipedia or http://behaviour-driven.org/

News

2009-03-18: Fixed bug reported where "expected" and "actual" were reversed
2008-09-12: Adding ShouldBeOfType<T>() and Enumerable.ShouldBeEmpty()
2008-04-11: Trx-converter added to .NetSpecExporter
2007-11-12: Added an AgileDox-like exporter for Visual Studio tests. Does not require .NetSpec.
2007-11-12: Added special hadling for strings (ShouldContain, ShouldNotContain, ShouldMatch and ShouldNotMatch) and enumerables/lists (ShouldContain/ShouldNotContain)
2007-11-07: Added ShouldBeSameAs/ShouldNotBeSameAs + Strong naming
2007-10-31: First version

Version 3.5 - (for .NET Framework 3.5 only - requires Visual Studio 2008)

The new extension methods in .NET 3.5 allows for a really nice syntax:

[TestClass]
    public class StackDescription
    {
        Stack<String> stack = new Stack<String>();

        [TestMethod]
        public void ShouldReturnTopElementOnPop()
        {
            stack.Push("car");
            stack.Push("Elephant");
            stack.Pop().ShouldBe("Elephant");
        }
        [TestMethod]
        public void ShouldUpdateCountOnPush()
        {
            stack.Count.ShouldBe(0);
            stack.Push("s");
            stack.Count.ShouldBe(1);
            stack.Push("x");
            stack.Count.ShouldBe(2);
        }

As you can see you can now write the asserts using a method called ShouldBe(). Personally I think this makes the test a lot easier to read.

The syntax for expecting exceptions has also changed:

[TestMethod]
        public void ShouldThrowExceptionOnPoppingEmptyStack()
        {
            stack.Count.ShouldBe(0);
            Call.To(delegate { stack.Pop(); }).ShouldThrow<InvalidOperationException>();
        }

You write whatever code you expect to throw an exception inside a delegate block, and the ShouldThrow method checks that the exception was actually caught and was of correct type.

Note that the TestClass and TestMethod attributes are kept to allow the tests to be run using the Visual Studio test view and the TFS builds.

See Using version 3.5 for more information

Version 2.0 - (for .NET Framework versions >= 2.0 - discontinued)

Because .NET 2.0 does not support the extension methods, the syntax is a little different there:

[TestClass]
    public class StackDescription
    {
        Stack<string> stack = new Stack<String>();

        [TestMethod]
        public void ShouldReturnPushedElementOnPop()
        {
            stack.Push("car");
            stack.Push("Elephant");
            Result.Of(stack.Pop()).ShouldBe("Elephant");
        }
        [TestMethod]
        public void ShouldUpdateCountOnPush()
        {
            Result.Of(stack.Count).ShouldBe(0);
            stack.Push("s");
            Result.Of(stack.Count).ShouldBe(1);
            stack.Push("x");
            Result.Of(stack.Count).ShouldBe(2);
        }

You have to use the Result.Of() together with ShouldBe() here.

The syntax for expecting exceptions, is the same as above.

See Using version 2.0 for more information

Tools

What about NSpec and NSpecify?

NSpec and NSpecify are built around custom attributes and a custom testrunner. One of the goals for .NetSpec is to integrate fully with the Visual Studio test views and the TFS builds without requiring any changes.

License

You can freely use the DLLs as a tool when developing software, though you may not include the DLLs as a part of a product without consent from the .NetSpec developers. All derivative work of the .NetSpec source code, must also be open source (GPL).

Source code repository

https://boss.bekk.no/repos/projects/NetSpec

Download

Developers

• Erlend Oftedal

Got any good ideas and/or want to join? Please contact Erlend Oftedal

Contributors

• Thomas Eyde - Port for NUnit (Erlend is working on allowing these to coexist without dependency to dll and duplicated code)

Comments ( Hide | Add Comment )

Erlend Oftedal says: Ah, you are correct. Sorry for not spotting your comment earlier. Fixed now. Mar 18, 2009 10:58 ( Permalink )