The Agile Testing & BDD eXchange 2011

Check out these videos taken from the recent The Agile Testing & BDD eXchange. You'll find talks on topics such as:

- BDD
- Living Documentation
- Testing

I know what I'll be watching tonight :) (Coffee? (Check), Biscuits? (Check), Slippers? (Check))

KnockoutJS 1.3 Almost Here

For those of you who are fans of Steve Sanderson’s excellent MVVM (Model View View Model) framework KnockoutJS, you'll be pleased to hear that the release candidate for version 1.3 is now available. There are a number of improvements including better syntax for defining event handling (a popular fix for many people who felt that the current method of event binding was a bit messy).

Check out this blog article by Steve, which talks about the upcoming changes.

Using MSpec.Fakes–Part 2

Next example I’d like to show is how to force a method to return a specific value:

public class example_when_told_to : WithFakes
{
    private static int result;
    private static IHelper sut;

    private Establish context = () =>
        {
            sut = An<IHelper>();
            sut.WhenToldTo(s => s.OK(Arg<int>.Is.Anything)).Return(4567);
        };

    private Because of = () => result = sut.OK(1);

    private It should_be_4567 = () => result.ShouldEqual(4567);
}

Here I use ‘WhenToldTo()’ in order to control the return value of ‘OK()’. I could also do this:

public class example_when_told_to : WithFakes
{
    private static int result;
    private static IHelper sut;

    private Establish context = () =>
        {
            sut = An<IHelper>();
            sut.WhenToldTo(s => s.OK(23)).Return(4567);
        };

    private Because of = () => result = sut.OK(23);

    private It should_be_4567 = () => result.ShouldEqual(4567);
}

So when ‘OK()’ is called with a specific argument, in this case 23, I want to return the value 4567. OK, so let’s have a look at using the ‘WithSubject’ parent class. First, we need the code for the salary calculator which Helper is using:

public interface ISalaryCalculator
{
    double CalculateSalary(double baseSalary, double bonus);

    int GetValue();
}

public class SalaryCalculator : ISalaryCalculator
{
    public double CalculateSalary(double baseSalary, double bonus)
    {
        return baseSalary + bonus;
    }

    public int GetValue()
    {
        return 34;
    }
}

Now here is the example test class we’ll be referencing:

public class example_using_WithSubject_1 : WithSubject<Helper>
{
    private static int result;

    private Establish context = () => The<ISalaryCalculator>().WhenToldTo(x => x.GetValue()).Return(1);

    private Because of = () => result = Subject.OK(1);

    private It should_be_1 = () => result.ShouldEqual(1);
}

We’re using WithSubject and passing it the type of Helper. What this give us is a .Subject property that we can use to access the SUT (i.e. the instance of Helper). The other cool thing is that since Helper requires an implementation of ISalaryCalculator in it’s constructor, an instance of ISalaryCalculator will be created for us. Not only that, but we can control the behaviour of the ISalaryCalculator instance via the ‘The<>’ method.

In the above example I’m stating that when ISalaryCalculator.GetValue() is called, it should return 1. We can also verify calls against the ISalaryCalculator like this:

public class example_using_WithSubject_2 : WithSubject<Helper>
{
    private static int result;

    private Because of = () => result = Subject.OK(1);

    private It should_be_1 = () => The<ISalaryCalculator>().WasToldTo(x => x.GetValue());
}

That’s all for now. I might write a bit more about using Stubs in your MSpec.Fakes tests for part 3.

Using MSpec.Fakes–Part 1

I decided to try out MSpec.Fakes, just to see how it works and to write a very quick guide on how to use it. First, in Visual Studio 2010, I added a reference to MSpec.Fakes via NuGet:

I chose the RhinoMocks flavour mainly as I had dabbled with both it and Moq in the past and felt that RhinoMock annoyed me less (Note: I’m a TypeMock user by heart, but I often have to use an open source mocking framework, in order that all devs on the team can run the tests. TypeMock does have it’s critics, but it’s by far my choice of isolation framework, but that’s for another post.)

OK, once installed, I created a couple of nonsense classes and interfaces in order to help me get up and running:

public interface IHelper
{
    int OK(int number);
}

public class Helper : IHelper
{
    private readonly ISalaryCalculator salaryCalculator;

    public Helper(ISalaryCalculator salaryCalculator)
    {
        this.salaryCalculator = salaryCalculator;
    }

    public int OK(int number)
    {
        return this.salaryCalculator.GetValue();
    }
}

Here’s my MSpec test, I’ll explain what’s going on next:

public class when_given_a_number : WithFakes
{
    private static int result;
    private static IHelper sut;

    private Establish context = () => { sut = An<IHelper>(); };

    private Because of = () => result = sut.OK(1);

    private It should_have_been_passed_a_number = () => sut.WasToldTo(s => s.OK(Arg<int>.Is.Anything));
}

Notice that the test class inherits WithFakes, this parent class has the support for the faking implementation. The cool thing is that, regardless of the underlying mocking framework you choose to use (Moq, RhinoMock) the MSpec.Fakes API is the same. I really like this approach. Next thing to look at is how we create an instance of the Subject Under Test (SUT)

private Establish context = () => { sut = An<IHelper>(); };

The An<>(); method takes care of calling the RhinoMock equivalent of

var mockRepository = new MockRepository();
var helperMock = mockRepository.CreateMock<IHelper>();

After calling the .OK() method, the assertion for this test is that sut.OK() was called with any number:

private It should_be_1 = () => sut.WasToldTo(s => s.OK(Arg<int>.Is.Anything));

Here we see the .WasToldTo() method which takes care of verifying that .OK() was indeed called with any number. Simples.

In my next post I will show some more examples.

Using Jing To Record Videos

For the past few weeks I have been using Jing, a screencast tool available from TechSmith. Jing comes in two flavours: Free and Pro. I use the free edition. If you purchase the Pro version you do get the ability to save videos in MPEG-4 format (the free edition only allows you to create SWF files).

I learnt about Jing after reading this blog article on the Telerik site. They use Jing to record the progress of features completed by developers. This provides instant feedback to the team on how a feature has been implemented. I really like that idea and started to use it at work, though I’ve been recording videos to help document how I resolved some customer issues which are reported to us. I’ve also recorded videos which show how to configure IIS for client who wanted 301 redirects for certain url’s on their site. The videos have proved really useful, no to mention the amount of time saved when compared to writing out documentation by hand!

Getting Ready For Windows 8

It doesn’t feel all that long ago when Windows 7 was released. Now, Microsoft are getting ready to introduce the world to Windows 8. Check out the Building Windows 8 blog where MS will be posting allsorts about the next OS. Back in 2008 MS began writing about Windows 7 using the same blog, which proved very popular, so they have decided to repeat this idea. Considering the lack of detail MS have thus far released about Windows 8, I’m sure many people will regularly keeping an eye on the new blog!

When Are The Letters “F” and “G” Are Considered Equal

A friend of mine noticed an unusual anomaly whilst writing a .NET app which was using the Welsh (cy-GB) culture. Here’s a snippet:

public class Program
{
    static void Main(string[] args)
    {
        var cultureInfo = new CultureInfo("cy-GB");

        Thread.CurrentThread.CurrentCulture = cultureInfo;
        Thread.CurrentThread.CurrentUICulture = cultureInfo;

        Console.WriteLine(String.Equals("f", "g", StringComparison.CurrentCultureIgnoreCase));
        Console.ReadLine();
    }
}

You would expect “f” and “g” to be different, however in this universe they are considered the same! A quick rummage around the Google attic revealed this Microsoft Connect report where someone else has reported the same problem. Microsoft have acknowledged this to be a bug in the framework, which will be resolved in the next version. In the meantime, I’m not aware of any straightforward workarounds other then having to specifically cater for the letter’s “f” and “g” in your code when doing any comparisons. That’s a bit crap

A Tip For Writing Entity Framework Queries Using DateTime Values

Today I found a nice utility method for working with DateTime values in Entity Framework LINQ queries. I wanted a list of Events which fell between a date range, but my query needed to ignore the time portion of the DateTime values. My first attempt was this:

var events = this.coreDomainContext.Events.Where(
    e => e.EventDate.Value.Date >= DateTime.Today
      && e.EventDate.Value.Date <= endPeriod.Date)
    .OrderByDescending(e => e.EventDate)
    .ToList();

But when I ran the code, I got an exception because I was using the .Date property of DateTime - basically EF did not know what to do here to convert this into a query. So after some research I found EntityFunctions.TruncateTime. This worked like a charm:

var events = this.coreDomainContext.Events.Where(
    e => EntityFunctions.TruncateTime(e.EventDate.Value) >= DateTime.Today
      && EntityFunctions.TruncateTime(e.EventDate.Value) <= EntityFunctions.TruncateTime(endPeriod))
    .OrderByDescending(e => e.EventDate)
    .ToList();

EntityFunctions contains a ton of methods for working with EF entities, have a look through what’s on offer as it could save you from rolling your own EF hacks!

.NET DLL’s Duplicated In Memory–Update

A couple of years ago, I blogged about my findings after analysing the memory usage of RSS Bandit using VMMap. I found that numerous .NET assemblies were appearing twice in the virtual memory region of RSS Bandit and that this behaviour was a known issue to Microsoft. Well if you have a look at the Microsoft Connect page for this issue, you’ll spot that as of .NET 4.0 this issue has been resolved. I’m yet to perform any analysis myself on .NET 4.0 applications, to check if duplication of assemblies has been eradicated, but still, it’s nice to see that this has been resolved.

ASP NET MVC 3 Futures

If you're curious about some of the ideas that could come up in future versions of ASP NET MVC, then check this page. You will find examples of ideas such as:

- dynamic view pages.
- New ActionResults like AtomFeedActionResult.
- HTML helpers such as HTML.Button() and HTML.SubmitButton() (Finally :)

There is a ton of information available on that page, well worth a look.

Remember, there is a roadmap page for ASP NET MVC 4 which illustrates what the team are officially planning for the next release. If you would like to suggest a feature/improvement, then visit the ASP NET user voice page.

The Death of .NET Reflector?

A few weeks ago, the software company Red Gate made the announcement that they will soon be ending the free availability of .NET Reflector. A summary of that can be found here. As you can imagine, many developers were unhappy at this decision. There were numerous calls of “traitors” and “liars” targeted towards the company, whom many thought had made a promise never to charge for .NET Reflector for editions other then the “Pro”. It is still in debate as to whether they actually did promise that, but’s that another story.

Not surprisingly, a few people have taken advantage of this situation. For example, a new tool named ILSpy has made an appearance. This is an open source project which is very early days, but could provide enough functionality for those looking for a lighter .NET assembly browser and decompiler – but most importantly, it’s free. By far the most heavy-weight competitor is Jetbrains who this evening gave details about their own .NET browser and decompiler. Their announcement can be found here. Their strategy is to include powerful .NET browsing and decompiling via their Resharper tool (version 6, which is currently in beta). Though the company have mentioned they intend to release a stand alone .NET assembly browser application in the future, which will be free. And they do mean “free”.

This leaves us with the question of just how are Red Gate going to get people to pay for .NET Reflector? What features could they implement which will make people think - “actually, I’m willing to pay £xx for that bit of functionality”. That’s a very good question. One cool feature in the Pro edition is the Visual Studio integration, where you can use .NET Reflector’s Visual Studio addin to debug compiled .NET framework assembly’s in the VS IDE. So if you wanted to know how String.IsNullOrEmpty worked, then you could step into that actual source code for that method. This is very cool, but as many will have spotted, the ability to debug .NET framework assemblies has been around for a few years now and is not difficult to setup, and is free.

I think .NET Reflector’s future is in trouble. To be fair, Red Gate’s reason to start charging is due to the resources required in order to maintain and build .NET Reflector. Anyone can understand that a company can’t just have a money-loosing product in their portfolio which offset by the profits made by other products. In the long term that does not make much sense. However, surely Red Gate is big enough to actually pull off that model? Else, why on earth would they want .NET Reflector in the first place? They knew it was free, they knew how much of a following it had. They knew how pissed off developers would be if they started charging for .NET Reflector. So why did they buy the rights to it….?

Wow! That’s A Lot Of Money

Apparently, Windows Vista cost Microsoft about $6 billion to develop. Check out the full article here.

Another Long Wait

A while ago, I blogged about an Apress book on Apple Mac OS X that was due to be released in Aug 2020. Looks like there is another book on the way which we will have to wait with baited breath for:

Wow, only another 10 years to go before this badboy is unleashed on the public. Can’t wait. :)

Good Blog Series On Using MSpec

Over on the Elegant Code blog there are some nice articles on MSpec which may be of interested to some of you. For those of you not familiar with MSpec, it’s a great open source BDD (Behaviour Driven Development) framework for .NET. Check it out.

Time To Embrace The Cloud

You can’t help but notice the big increase in coverage for cloud computing both in IT news sites and developer blogs/forums. With the economic climate having been given a real beating the last couple of years, IT shops are looking into ways to reduce costs (hopefully by avoiding redundancies). Enter cloud computing. It’s a great idea and, frankly, one that is probably going to change the face of IT in the coming years.

As a developer, I accept that it’s only a matter of time before I will need to learn about developing for a cloud architecture. So rather then wait until that moment arrives, I’ve been doing a little bit of reading here and there about Windows Azure, Microsoft’s cloud offering which was made live a few weeks ago. I thought I’d post some links here to help out (both as notes for myself and to aid other people who might land on this blog).

Channel 9
Channel 9 - Cloud Cover Episode 1

PDC09 Videos
Lap Around The Windows Azure Platform
Development Best Practices and Patterns for Using Microsoft SQL Azure Databases
Scaling out Web Applications with Microsoft SQL Azure Databases
Patterns for Building Scalable and Reliable Applications with Windows Azure
Windows Azure Tables and Queues Deep Dive
Microsoft SQL Azure Database: Under the Hood
Windows Azure Present and Future
Windows Azure Blob and Drive Deep Dive
Windows Azure Monitoring, Logging, and Management APIs
Developing Advanced Applications with Windows Azure
Enabling Single Sign-On to Windows Azure Applications
Building Hybrid Cloud Applications with Windows Azure and the Service Bus
Lessons Learned: Migrating Applications to the Windows Azure Platform
Automating the Application Lifecycle with Windows Azure
The Future of Database Development with SQL Azure
Lessons Learned: Building On-Premises and Cloud Applications with the Service Bus and Windows Azure
Lessons Learned: Building Scalable Applications with the Windows Azure Platform
Lessons Learned: Building Multi-Tenant Applications with the Windows Azure Platform
Introduction to Building Applications with Windows Azure
SQL Azure Database: Present and Future
Tips and Tricks for Using Visual Studio 2010 to Build Applications that Run on Windows Azure
The Business of Windows Azure: What you should know about Windows Azure Platform pricing and SLAs

Misc
Windows Azure Tools for Microsoft Visual Studio 1.1 (February 2010)
Windows Azure Platform Training Kit - December Update
Migrating an Existing ASP.NET App to run on Windows Azure
Seven things that may surprise you about the Windows Azure Platform
OakLeaf Systems

Nice BDD Naming Convention For MSTest

If you like to use Behaviour Driven Development (like me :) then I assume you are using a naming convention for your tests, maybe like this:

- Given an empty shopping cart
- When I add an item
- Then shopping item count should be 1

I really like using the above naming convention due to it expressiveness – I can instantly see what a test is actually testing and the context under which that test is running. I’ve been doing some research into the best practise for using BDD naming for MSTest unit tests and found this blog post. The author has given a very neat example of how to use a base context class which you can then include in your tests. The idea is that you have the following class which sets out the basic structure of a test:

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace UnitTest
{
    public abstract class ContextSpecification
    {
        public TestContext TestContext { get; set; }

        [TestInitialize]
        public void TestInitialize()
        {
            Context();
            BecauseOf();
        }

        [TestCleanup]
        public void TestCleanup()
        {
            Cleanup();
        }

        protected virtual void Context()
        {
        }

        protected virtual void BecauseOf()
        {
        }

        protected virtual void Cleanup()
        {
        }
    }
}

Those of you who have used frameworks such as MSpec will find the above very familiar (I’m a big fan of MSpec and use it for some of my projects at work, but none of my colleagues us it, hence my need for finding an MSTest way of BDD’ing my unit tests). You have the usual MSTest related code (TestContext, TestInitialize, etc) declared in this class, but notice the Context, BecauseOf and Cleanup methods. We’ll take a look at how those are used now. Check out the following unit test:

namespace UnitTest
{
    public static class GetPersonNameSpecs
    {
        public class GetPersonNameSpecsContext : ContextSpecification
        {
            protected Person sut;
            protected string actual = String.Empty;
        }

        [TestClass]
        public class when_name_has_not_been_given : GetPersonNameSpecsContext
        {
            protected override void Context()
            {
                sut = new Person();
            }

            protected override void BecauseOf()
            {
                actual = sut.GetFullName();
            }

            [TestMethod]
            public void returned_name_should_be_empty()
            {
                Assert.AreEqual(String.Empty, actual);
            }
        }

        [TestClass]
        public class when_name_has_been_given : GetPersonNameSpecsContext
        {
            protected override void Context()
            {
                sut = new Person("Jim");
            }

            protected override void BecauseOf()
            {
                actual = sut.GetFullName();
            }

            [TestMethod]
            public void returned_name_should_be_Jim()
            {
                Assert.AreEqual("Jim", actual);
            }
        }
    }
}

As per the suggestion of the blog author, I have a static class named GetPersonNameSpecs and inside that class is the real meat and bones – two test classes which contain the unit tests. See how I make use of the Context and BecauseOf methods - with Context I can do my pre-test initialisation (creating class instances, or if I was using a mock framework, creating mock objects), then in the BecauseOf method I invoke the code to be tested. The final phase of the test, the assertion, is what’s declared with a [TestMethod] attribute. Since in ContextSpecification both Context and BecauseOf are called during TestInitialize, there is no need for us to apply any attributes to our version of those methods.

The advantage of this structure is it’s readability, take a look at how the above tests look like in my test viewer window:

and in the results window:

Now, I don’t know about you, but I know that if I had to return to these tests in 6 months time, I will find it much easier to deal with.

Fancy Having A Go at .NET 4.0 Exams?

Just spotted this page which has some details about upcoming .NET 4.0 beta exams. You can register for these exams, with the best part being that they're free to take. Here is a list of the available exams:

• 70-511 TS: Microsoft .NET Framework 4, Windows Application Development
• 70-513 TS: Microsoft .NET Framework 4, Windows Communication Foundation Development
• 70-515 TS: Microsoft .NET Framework 4, Web Applications Development
• 70-516 TS: Microsoft .NET Framework 4, Accessing Data with ADO.NET
• 70-518 Pro: Designing and Developing Windows Applications Using Microsoft .NET 4
• 70-519 Pro: Designing and Developing Web Applications Using Microsoft .NET Framework 4

As mentioned here, there is an absence of any workflow based exams. It’s thought that uptake of windows workflow foundation hasn’t been that great (I can count on one hand the number of workflows I’ve written) and, as a result, there are no planned workflow exams.

CLR via C#, 3rd Edition Out Now

I’m very happy to see that the newest edition of Jeffrey Richter's awesome book about the internals of the .NET CLR is now available. If you have read the 2nd edition then you will already know what a fantastic resource that book is for improving your understanding of how the CLR works. The new edition targets C# 4.0 and .NET 4.0, which is coming just around the corner. (In fact, the RC for VS2010 is out now for MSDN customers, and will be available to the public on Feb 10. Check out this Channel9 video for more details)

“The Dark” Comic Signing Event

A very good friend of mine, Chris Lynch, will be at Ace Comics in London on March 20th to sign copies of “The Dark”, which is an exciting new comic book series written by Chris with amazing artwork provided by Rick Lundeen. Festivities start at 12pm. This is your chance to get a signed copy of a great series in the making – a chance not to be missed, so c’mon! :)

Improve Readability of !GCRoot Command

One of the most powerful command available in the SOS.dll is !gcroot. It can help you figure out why an object is stuck in memory and what object(s) is referencing it and keeping it alive. The one problem with !gcroot is that it’s output can be very difficult to navigate through. I remember when I first used this command to try and debug an issue for an application at work, at first I was excited at getting the chance to use this command on a “real world” issue. However, that excitement turned to bewilderment when I saw the output of !gcroot and I just sat there for a few moments whilst I tried to work out what exactly the output was trying to tell me.

Well that was then, and since those days I’ve learned a little bit more about how to read !gcroot’s output. Studying blogs such as this one has helped a lot. Today I was reading John Robbins' blog and I saw a link to this tool, which is an object graph visualizer which runs in VS 2010. The author has created a video to demonstrate this tool and I must say, it looks very interesting! I suggest you check it out.