out >> m_Conscientia; » TDD

When dependency injection meets IDisposable

Alex Peck — Sun, 21 Jun 2009 21:50:58 +0000

What follows is a solution which should really have been obvious to me the first time I faced the problem: how do you decouple logic and instantiation of collaborating objects when faced with an IDisposable class? Consider this:

public class NiceClass
{
    private DependentClass injectedDependency;
 
    public NiceClass(DependentClass injectedDependency)
    {
        this.injectedDependency = injectedDependency;
    }
 
    public void CoupledMethod()
    {
        using (IFace c = new Face(injectedDependency))
        {
            // do something with c
        }
    }
}

We can see that injectedDependency is not coupled, but what about the local instance of Face in CoupledMethod? To decouple it use a delegate to return the IFace instance instead of calling new directly. If the coupling had been to a concrete type (Face), we could refactor to an abstract type (IFace) or wrapper first.

public class NiceClass
{
    public delegate IFace IFaceCreatorDelegate(DependentClass injectedDependency);
 
    private DependentClass injectedDependency;
    private IFaceCreatorDelegate iFaceCreator;
 
    public NiceClass(DependentClass injectedDependency, IFaceCreatorDelegate iFaceCreator)
    {
        this.injectedDependency = injectedDependency;
        this.iFaceCreator = iFaceCreator;
    }
 
    public void CoupledMethod()
    {
        using (IFace c = iFaceCreator(injectedDependency))
        {
            // do something with c
        }
    }
}

This is an additional three lines of code, which arguably makes the control flow harder to read statically. It does, however, improve testability. I think of this as equivalent to the classic tradeoff between abstract and concrete parameters.

Instantiating NiceClass is not too arduous either with a lambda expression (although it is still a little verbose).

NiceClass nice = new NiceClass(
   dependency, 
   (DependentClass d) => new Face(d));

Dependency Injection & Testability

Alex Peck — Wed, 17 Jun 2009 19:01:06 +0000

When objects have no (or few) collaborators it’s relatively easy to get high unit test code coverage. As the number and complexity of collaborators increases, so too does the difficulty in obtaining decent coverage. This talk illustrates why dependency injection principles improve the testability of your code, and ease mock/stub based unit testing.

BDD: Behaviour Driven Development

Alex Peck — Sat, 16 May 2009 23:03:16 +0000

Since this talk was three years ago it is now clear BDD didn’t set the world on fire. That said, I like the focus here on the mindset of the developer. My interpretation of BDD is that the terminology you use affects your development process. It’s not fundamentally different to TDD, rather there is a change in terminology which subtely influences your design process.

TDD: An empirical study at Microsoft

Alex Peck — Mon, 05 Jan 2009 23:49:01 +0000

In my experience, TDD focuses you on writing testable code with good edge case and error handling. Most TDD discussions revolve around this kind of anecdotal evidence of improvement.

Microsoft research have published a paper exploring the effect of TDD on various quality metrics. You can check out a short Channel 9 overview here.