Adventures of an aspiring agile developer in a not-quite agile world

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.)

Can you take the single responsibility principle too far?

casper — Fri, 28 Mar 2008 12:21:00 GMT

This morning, I had a conversation with a colleague of mine who has recently started using EDD about "exposing things just for the purpose of testing." Although I have run across the odd occasion where I may need to add a get property to a class in order to verify a value, usually I find this means that the class is doing too much.

Here's the scenario:

Imagine a command-line application that needs to perform several actions. Each action is responsible for parsing and validating the parameters for itself. One possible structure looks like this:

public class PourWaterAction : IAction 
{
  PourWaterAction(string[] args)
  {
  }
 
  public bool ValidateParamters() 
  {
     // throws if invalid 
  } 

  public void Perform() 
  { 
    // do real stuff here 
  }
}

Now we've got tests that will assert if ValidateParameters throws, but how do we write a test that determines if the parameters are properly parsed when ValidateParameters doesn't throw?

This is where the interesting conversation starts: my feeling was that the PourWaterAction class shouldn't be doing two things, and validation should be delegated to a different class. Perhaps something like this:

public static class PourWaterActionValidator
{
  public static PourWaterData Validate()  
  {
    // Either throw or return a populated structure
  }
}

public class PourWaterActionValidator : IActionValidator
{
  public PourWaterData Validate()  
  {
    // Either throw or return a populated structure
  }
}

Now we can move the validation tests to the new class, and easily write a test for passing conditions as well as failing ones. Straightforward enough, right?

Possibly not. My colleague was of the opinion that:

This was creating extra classes unnecessarily which, when taken to the extreme, would mean tons of different files in the project.
Even if another class was created, it should be visible only to PourWaterAction which means it wouldn't be possible to test either.

This means that the only way to test it was to add get properties to PourWaterAction so the tests could verify that the parsing had been performed correctly — "adding things just for the sake of testing"

So, what would you do in this situation? And do you believe that classes should always strive to do one thing and one thing only?

Gatineau Beta upgrade goes live!

casper — Tue, 04 Mar 2008 10:06:00 GMT

The main reason for my lack of blogs posts recently has been the final push to get Gatineau (adCenter Analytics) out the door and I'm happy to say that it's gone live :) I'll try to get a few screenshots up next week. You'll need an adCenter account to see our stuff, but the main site is here: http://adcenter.microsoft.com.

Note: The $5 sign-up fee has been removed! You can find details on how to enlist here: http://adcenterblog.spaces.live.com/default.aspx?wa=wsignin1.0

Le Web 3 (Day one)

casper — Tue, 11 Dec 2007 18:18:50 GMT

Dark Side of the Web

Panel with Jaewoong Lee (Daum), Dan Rose (Facebook), Chris Alden (SixApart) and a lawyer.

Anonymity allows people to be expressive/rude; if you're rude in real life you probably will be online too. South Korea developed government-run program for Internet identity which is used by top 35 websites. However, 80,000 identities were stolen earlier this year. Keeping history on a site-by-site basis is probably the best way for people to 'behave' and still maintain privacy as it's decentralized. Strangely enough, Korea is outsourcing its community moderation (censorship?) to China.
Facebook's value comes from using your real identity. There isn't really any spam on Facebook either because your friends won't spam you.
Having said that, Facebook messed up with Beacon. They didn't respond quickly enough to give users control, and users expected it because everything previously had been controllable. There was also a lack of communication about the project initially (they claim it wasn't to do with advertising, but just coincidence it was launched simultaneously.)
Targeted advertising: obviously no PII, but more social advertising. Friends can 'advertise' to each other. Ads should appear the same way as content, and not be intrusive.
90% of UGC (user-generated content) is crap, but 99% of TV is crap. Internet is winning; content is usually relevant to *someone*.

Persistent Communication

Talk from Evan Williams (Twitter)

Everyone is using Twitter. Well, at least everyone at this conference is using it.
Adding constraint to a product can help users. (Obviously, look at Apple)
What can we take away to create something new?
Twitter = Blogger MINUS comments MINUS post titles MINUS pictures MINUS template MINUS formatting PLUS 140 character limit.
Twitter actually started with the mobile interface first, which forced the web UI to maintain simplicity.
API was also kept simple, and so people built apps to fill in the gaps.
Human interface cognitive load is proportional to the number of clicks/keystrokes/gestures. The usability of an interface is inversely geometrically proportional to its cognitive load. - Tantek Celik

What can we create by taking away?

Only post one photo per day (fotolog). Ended up with average of 11 comments/photo (very high) and very high quality. Compare to flickr.
Only upload a picture and add a yes/no button. Compare to most dating sites.
Restrict social network to 20 friends. Compare to myspace. (Actually, this is what the 'top friends' application does on Facebook, and it's the most popular application)

Why books and school lectures still exist

Hans Rosling (the man behind Gapminder)

He actually wanted to present remotely, but they wouldn't let him.

Does some very nice real-time presentations using Gapminder. He made two striking points about Africa

Africa has advanced extremely quickly. He used a graph of life expectancy vs GDP. Below is the current situation vs. Sweden throughout the years.

The current state of advancement within African countries is massive (~200 years). You cannot treat them as all being in the same range.

Sierra Leone	Sweden 1709
Mozambique	Sweden 1810
Uganda	Sweden 1877
India	Sweden 1910
Guatemala	Sweden 1933
Brazil	Sweden 1953
South Korea	Sweden 1983
Japan	Sweden 2004 (equal)

Another illustration is Singapore vs. France in terms of Mortality Rate and GDP compared from 1931 to 2007. In 1931 Singapore was far behind in both areas, now it has completely overtaken France.
Having said all that, none of these facts & figures work without having storytellers. And watching Rosling, it's obviously true.

What is social about design

Philippe Starck. Very interesting guy but difficult talk to summarize. His main points revolve around responsible products and responsible business. Creating products that solve problems rather than (just) make money is important. Other topics covered with eco-friendliness, organic products, and ubiquitous/miniaturization of computers.

Perhaps the best part was at the end when Scoble got up on stage and asked him to review the Kindle. "It's almost modern" was his response.

Technology impact on corporate culture (Google)

Drivers of change: ubiquitous connectivity, democratization of the tools of production, falling cost of storage/increase of processing power. We double storage capability every 13 months; by 2020 a device the size of an iPod could store all the content ever created.
At Google, revenue and profitability are an afterthought. First they try to identify customer needs and address them as fast as possible.
Cultural innovation - Dublin (reliability), London (apps for mobile), Zurich (search, geo infrastructure), Munich (apps for mobile), Trondheim (infrastructure, news), Haifa (localisation, ads, search quality)
Empowerment: 20% slack time. Small teams.
Speed - Fast is better than slow. Don't waste time making 2-year business plans. Release early, release often. Get feedback from customers. It's not about big beating small, but rather who is faster. Change your development approach to bring things to market as quickly as possible. (emphasis added)

Storytelling and technology - evolution of society

June Cohen from TED. Good talk. Basically pointing out that technology is returning us to the traditional (old) ways of communication. TV, newspaper, etc. and mass media are actually _new_ ways, not old. Big media is due to become smaller.

Personalization .. 2.0 .. 3.0

Jonathan Medved - Vringo

Mobile content will become richer and needs to catch up to the web quickly
Look for video, animations, avatars, and photos to become more prominent
UGC will also take off just like it did on the web
Visual ringtones: need to be symmetrical and it plays on the called party's phone. Needs to be frequently changed as video gets old quickly. Could be purchased or uploaded by users.
The future of mobile personalization will be around straddling a call or SMS

Before call: viral ad, avatar, photo, licensed or UGC content
During call: enterprise ad, yellow pages, consumer-pushed content, ad-supported calls
After call: branding ad, e-commerce, call to action, voting game

XAML : XAMLPad :: LINQ : ?

casper — Mon, 19 Nov 2007 09:31:04 GMT

One of my teammates just sent a link to LINQPad, a small application written by the authors of C# 3.0 in a Nutshell. Looks like a great tool for anyone that wants to learn LINQ or needs to execute queries on a regular basis.

Now you can fool your xUnit tests

casper — Mon, 12 Nov 2007 11:27:52 GMT

Back in the 'early days' of xUnit, I posted an example of how to use the BeforeAfterTestAttribute to modify a test's current identity. Now that there is an official xUnit.net Extensions project, I've cleaned it up and submitted the code in change set 7569.

I'm looking forward to seeing what the community will contribute to this project - I'm sure we can get some really handy extensions written.

Task Parallel Library goes public

casper — Thu, 18 Oct 2007 13:23:11 GMT

If you're interested in taking advantage of multiple processors and code in .NET with a minimal amount of effort then this is the library for you. The introductory MSDN article is here.

Long live Parallel.For() :)

The cool stuff is starting to surface (introducing Graffiti)

casper — Thu, 18 Oct 2007 09:53:27 GMT

It's been tough not being able to write about anything that we work on here in Dublin, but slowly the details are starting to come out. Ian's latest post on what we presented at e-Metrics includes a demo video of Graffiti, an automatic tagging module that's included in Gatineau Beta 2. It was completely designed, developed, and tested here and we're quite proud of it.

Come join us!

casper — Tue, 16 Oct 2007 08:52:00 GMT

Our team here in Dublin has launched a recruiting site at http://www.joinmicrosofteurope.com/. It's got information on what it's like to work here, some of the many benefits, and first-hand interviews with members of our team. As well, we're starting a MSDN blog at http://blogs.msdn.com/gpde. Go check them out!

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.

Dropping multiple tables in SQL Server 2005

casper — Wed, 19 Sep 2007 09:14:00 GMT

I'm currently working on a project that has a Cache database that stores query results, and so naturally there are times when I'm playing inside of Management Studio that I want to delete the cache. However, I don't want to drop the entire database (because then I'd have to re-run the create script), nor do I want to delete all the tables in it (there is one table that needs to remain).

In case it's of use to anyone, or I need to do this again, here's a snippet of T-SQL that will drop an arbitrary list of tables from a database.

DECLARE @id varchar(255) 
DECLARE @dropCommand varchar(255) 
DECLARE tableCursor CURSOR FOR 
    SELECT name FROM sys.tables WHERE name <> 'CacheManager' 
OPEN tableCursor 
FETCH next FROM tableCursor INTO @id 
WHILE @@fetch_status=0 
BEGIN 
    SET @dropcommand = N'drop table ' + @id 
    EXECUTE(@dropcommand) 
    FETCH next FROM tableCursor INTO @id 
END 
CLOSE tableCursor 
DEALLOCATE tableCursor

I wish there was a 'Copy as HTML' function or something similar I could use to get the nicely formatted text from Management Studio into a blog posting.

The one where Toby finds a dependency injection container

casper — Tue, 11 Sep 2007 00:20:00 GMT

Toby is less than happy. Due to some unforeseen circumstances, he recently lost all the code he'd been working on for the EDM project. For some unknown reason, he'd never bothered to setup a source control server and vows to not make the same mistake twice.

Desperate to kick-start his excitement on the project again, he remembers coming to the conclusion that he'd need some sort of dependency injection container. Although initially he was contemplating using CAB, he realised that what he really wanted was just part of the container functionality from WorkItem. After a bit of searching, he found that the current version of ObjectBuilder ships with the sample container from Codeplex. Deciding that it would be nice to shift gears for a while, he fires up Visual Studio and starts writing some tests.

[TestFixture]      
public class Injection       
{       
    [Test]       
    public void CanInjectService()       
    {       
        DependencyContainer container = new DependencyContainer();       
        container.RegisterSingletonInstance<IUserService>(new UserService()); 
        Project newProject = container.Get<Project>();
        Assert.NotNull(newProject.UserService);      
        Assert.Equal("casper", newProject.UserService.CurrentUser);       
    } 
    [Test]      
    public void InjectedServiceIsReallyTheSameOneWeThinkItIs()       
    {       
        DependencyContainer container = new DependencyContainer();       
        UserService userService = new UserService();       
        container.RegisterSingletonInstance<IUserService>(userService);       
        Project newProject = container.Get<Project>(); 
        userService.CurrentUser = "B-rad";    
        Assert.Equal("B-rad", newProject.UserService.CurrentUser);      
    } 
    class Project      
    {       
        [Dependency]       
        public IUserService UserService       
        {       
            get { return userService; }       
            set { userService = value; }       
        } 
        private IUserService userService;      
    } 
    interface IUserService      
    {       
        string CurrentUser { get; }       
    }
    class UserService : IUserService      
    {       
        public string CurrentUser       
        {       
            get { return currentUser; }       
            set { currentUser = value; }       
        } 
        private string currentUser = "casper";      
    }       
}

So, nothing too fancy, but the start of how we can separate concerns in the project. And Toby has learned his lesson, and will soon start posting code on Codeplex.