Adventures of an aspiring agile developer in a not-quite agile world : xUnit.net

One step past Assert.Throws<>

casper — Tue, 29 Jul 2008 19:16:00 GMT

If you’re not using xUnit (and you should be), at least consider adopting the practices they have for dealing with exceptions in unit tests. From the very first release, they moved us from this:

[ExpectedException(typeof(InvalidOperationException))] 
public void WithdrawingMoreThanBalanceThrows() 
{ 
    Account account = new Account(); 
    account.Deposit(100); 

    account.Widthraw(200); 
}

to the far-better:

public void WithdrawingMoreThanBalanceThrows() { Account account = new Account(); account.Deposit(100); Assert.Throws<InvalidOperationException>(delegate { account.Widthraw(200); });}

But we’re still not following the 3 As pattern. Recently (not sure exactly when) they took us one step further to this (in 3.5 syntax):

public void WithdrawingMoreThanBalanceThrows() { Account account = new Account(); account.Deposit(100); Exception ex = Record.Exception(() => account.Widthraw(200)); ex.ShouldBeType<InvalidOperationException>();}

and now we are exactly where we should be :)

(I was just told that () => is called the ‘crotch operator’ today. Can’t wait to use that in a code review.)

ReSharper and xUnit.net

casper — Wed, 03 Oct 2007 10:10:00 GMT

Those of you who have switched over to xUnit.Net may have a received a nasty surprise with the 'type members layout' feature of ReSharper: it doesn't respect method attributes. Namely, you can tell it to not reorder methods in an NUnit fixture like this:

<Pattern>   
 <Match>   
    <HasAttribute CLRName="NUnit.Framework.TestFixture"/>   
  </Match>   
</Pattern>

But you cannot tell it to not reorder your xUnit methods like this:

<Pattern> 
       <Match> 
         <And Weight="100"> 
           <Kind Is="method"/> 
           <HasAttribute CLRName="Xunit.TestAttribute" Inherit="false"/> 
          </And> 
       </Match> 
</Pattern>

Apparently it will only look for attributes on classes and interfaces. In the meantime, I think the simplest solution is to just create a fake attribute you can add to your fixture.

public class ReSharperNoReorderAttribute : Attribute 
{ 
}

And the appropriate pattern match to ReSharper:

<Pattern>
       <Match> 
          <HasAttribute CLRName="ReSharperNoReorder"/> 
      </Match> 
</Pattern>

All should be well after that.

Weaving with xUnit.net

casper — Thu, 27 Sep 2007 13:00:00 GMT

There has been mixed reaction to the removal of [SetUp] and [TearDown] in xUnit.net. Personally, I think it's great as it helps to raise unit test 'smells', particularly around how classes interact with each another. Here's a small example of how we can use the BeforeAfterTestAttribute in xUnit to remove duplicate code. (It's based on the security workaround I talked about yesterday.)

Instead of repeating three lines of code in each unit test to update the current identity, we can just define an attribute like [AssumeIdentity] that will take care of things for us. Here's the little fixture I wrote to test it.

public class AssumeIdentityAttributeFixture 
{ 
    [Test] 
    public void CallingSecuredMethodWillThrow() 
    {  
        Assert.Throws<SecurityException>(delegate 
                                         { 
                                             SecuredMethod(); 
                                         }); 
    }
 
    [Test, AssumeIdentity("Munchkin")] 
    public void CallingSecuredMethodWithAssumedIdentityPasses() 
    {  
        Assert.DoesNotThrow(delegate 
                            { 
                                SecuredMethod(); 
                            }); 
    }
 
    [PrincipalPermission(SecurityAction.Demand, Role = "Munchkin")] 
    public void SecuredMethod() {} 
} 

public class AssumeIdentityAttribute : BeforeAfterTestAttribute 
{  
    public AssumeIdentityAttribute(string name) 
    { 
        this.name = name; 
    } 


    public override void Before(MethodInfo methodUnderTest) 
    { 
        originalPrincipal = Thread.CurrentPrincipal; 
        GenericIdentity identity = new GenericIdentity("boo"); 
        GenericPrincipal principal = 
                new GenericPrincipal(identity, new string[] { name }); 
        Thread.CurrentPrincipal = principal; 
    } 

    public override void After(MethodInfo methodUnderTest) 
    { 
        Thread.CurrentPrincipal = originalPrincipal; 
    } 

    readonly string name; 
    IPrincipal originalPrincipal; 
}

As you can see, before each test it executed, we update the current thread's identity, and then reset it after the test has run. It doesn't get much simpler than that :)

Faking out [PrincipalPermission]

casper — Wed, 26 Sep 2007 15:24:00 GMT

Depending on how your unit tests are setup, you may not be running as the proper user and won't have the necessary permissions to invoke a method. If this happens, you can easily alter the principle thread's identity with the following code.

For instance, if you user needs to belong to a certain role (or group) called 'DesiredGroup', this would emulate that fact.

GenericIdentity identity = new GenericIdentity("boo");      
GenericPrincipal principal =       
           new GenericPrincipal(identity, new string[] {"DesiredGroup"});       
      
Thread.CurrentPrincipal = principal;

xUnit.net goes live!

casper — Fri, 21 Sep 2007 09:07:00 GMT

NUnit is dead! Long live xUnit.net!

There are several cool features, including aspect-like extensibility for tests, but the two changes that will immediately make a difference in my day-to-day coding are:

[ExpectedException] is gone. In its place is Assert.Throws<T>( delegate ... ). Not only much easier to read, but no longer can a test throw in an unexpected place and still pass.
No more SetUp/TearDown. This makes maintaining state between tests a bit more difficult. Having to add static variables to a test fixture should probably signal warning flags about the code under test.

For anyone wondering if it actually works, the answer is a resounding 'Yes'. It's already been integrated into sections of the project I'm currently working on.

It's available for download here: http://codeplex.com/xunit

Also, be sure to read Jim Newkirk's official announcement.