Dan Crevier's Blog

Using the yield pattern with HealthVault on Windows Phone 7 (part 2)

Dan Crevier — Thu, 29 Dec 2011 06:21:55 GMT

In part 1, I described the overall design of the HealthVaultTask class. Now, I’ll go through the implementation. First, I’ll get some of the helper classes. Out of the way. The first is the exception type for errors from HealthVault that captures the error code and error text. Note: this implementation doesn’t make the exception serializable, but that would be straightforward to do if needed.

public class HealthVaultException : Exception
{
    public HealthVaultException(int errorCode, string errorText)
    : base(errorText)
    {
        this.ErrorCode = errorCode;
    }

    public int ErrorCode { get; set; }
}

Next, is the HealthVaultOperation class. The pattern with this class is that DoOperations yields one of these with the information about the HealthVaultRequest, and when control returns after the yield, the response data will be filled out. It also has a helper function to throw a HealthVaultException in the case of an error. But, it’s up to the DoOperations implementation to call ThrowOnError.

public class HealthVaultOperation
{
    public HealthVaultOperation(string methodName, string methodVersion, XElement info)
    {
        this.MethodName = methodName;
        this.MethodVersion = methodVersion;
        this.Info = info;
    }

    public string MethodName { get; private set; }
    public string MethodVersion { get; private set; }
    public XElement Info { get; private set; }

    public HealthVaultResponseEventArgs Response { get; set; }

    public void ThrowOnError()
    {
        if (this.Response.HasError)
        {
            throw new HealthVaultException(this.Response.ErrorCode, this.Response.ErrorText);
        }
    }
}

Finally, here is the HealthVaultTask class. The only really interesting code is in RunEnumerator, which enumerates through the HealthVaultOperations returned by DoOperation, creating a HealthVaultRequest for it and executing it. At first glance, this function may look recursive, but the other RunEnumerator call is actually in a lamda function that will be called from the request callback. It also has the code to marshal the result (in case of success or failure) to the right callback function on the UI thread.

public abstract class HealthVaultTask
{
    public HealthVaultTask(HealthVaultService service)
    {
        this.Service = service;
    }

    public void Run(Dispatcher dispatcher, Action successCallback, Action<Exception> errorCallback)
    {
        RunEnumerator(dispatcher, successCallback, errorCallback, DoOperations().GetEnumerator());
    }

    private void RunEnumerator(Dispatcher dispatcher, Action successCallback, Action<Exception> errorCallback,
                               IEnumerator<HealthVaultOperation> operations)
    {
        try
        {
            if (operations.MoveNext())
            {
                HealthVaultOperation operation = operations.Current;
                HealthVaultRequest request = new HealthVaultRequest(operation.MethodName, operation.MethodVersion,
                                                     operation.Info, (o, e) =>
                    {
                        operation.Response = e;
                        RunEnumerator(dispatcher, successCallback, errorCallback, operations);
                    });
                this.Service.BeginSendRequest(request);
            }
            else
            {
                dispatcher.BeginInvoke(() => successCallback());
            }
        }
        catch (Exception e)
        {
            dispatcher.BeginInvoke(() => errorCallback(e));
        }
    }

    protected abstract IEnumerable<HealthVaultOperation> DoOperations();

    protected HealthVaultService Service { get; private set; }
}

If this doesn’t make sense, please let me know and I’ll explain further.

There’s one design consideration I didn’t think about until after I’d implemented it. One problem with this implementation is that you can’t compose HealthVaultTasks with other HealthVaultTasks. It would be nice if you could build up layers of reusable service code. This could be accomplished by having a common base class between HealthVaultTask and HealthVaultOperation where HealthVaultTask.DoOperation would be an IEnumerable of the base class. That would let you yield either operations or tasks. This addition is left as an exercise to the reader

Finally, a note on unit testing. This framework actually makes the HealthVaultTasks you write very easily unit tested. All you have to do is call GetEnumerator on your task, then call MoveNext/Current to simulate running the task. After you call MoveNext, you can make sure you get the expected operation in Current and you can push whatever results you want into the HealthVaultOperation. What’s great is that the HealthVaultService is completely out of the picture.

I hope this is useful!

Using the yield pattern with HealthVault on Windows Phone 7 (part 1)

Dan Crevier — Thu, 29 Dec 2011 06:00:22 GMT

I’ve written a Windows Phone 7 application called Weight4Me that lets you track your weight, syncing the data to HealthVault. The first version just fetched all of the weight data from HealthVault on each launch. I’m one of the developers Eric Gunnerson is referring to in this post. I’ve just posted an updated release that does a sync with HealthVault (not following exactly what Eric suggests, maybe I’ll post more details about that next). Doing sync, required doing more complex series of operations with HealthVault.

The HealthVault SDK for Windows Phone 7 provides a HealthVaultRequest class for making calls to HealthVault, calling into a callback when done. Using lambda expressions, you can make fairly readable code for simple calls as follows:

service.BeginSendRequest(new HealthVaultRequest(methodName, methodVersion, xml,
                         (object sender, HealthVaultResponseEventArgs e) =>
{
    dispatcher.BeginInvoke(() =>
    {
        if (e.HasError)
        {
            // Handle error.
        }

        // Parse results.
    });
}));

But, I needed to do some more complex things like do multiple requests in a loop, have branching based on sync state, and so on. This turns into incredibly messy and hard to follow code with callback functions and/or lambdas. A common trick for making asynchronous code read more like synchronous code is to use the yield keyword in C# so that the compiler will build the state machine for you. Jeffrey Richter has a series of articles about using it with the standard async pattern which you can read here. I decided to apply this technique to the HealthVaultService and HealthVaultRequests, which I present here. I hope people will find it useful with HealthVault on Windows Phone 7, or will see how to apply it to similar problems.

My basic approach is to create a HealthVaultTask class, which runs a series of HealthVaultRequests. This is done by implementing an IEnumerable function that returns a series of HealthVaultOperations. HealthVaultOperation is a new class I am using to encapsulate a HealthVaultRequest and response. So, the way you implement a task looks something like:

protected override IEnumerable<HealthVaultOperation> DoOperations()
{
    HealthVaultOperation myOperation = new HealthVaultOperation(methodName, methodVersion, xml);
    yield return myOperation;
    myOperation.ThrowOnError(); // See discussion below.
    // Parse response from myOperation.Response
}

The magic of this pattern is that you can have loops, if branches, etc in DoOperations so that the code in DoOperations looks like serial code. But, under the covers it will all be asynchronous.

There are a couple of design decisions I had to make up front. The first was about how to handle errors. There can be errors returned from the operations, and exceptions could be thrown from DoOperations itself. One approach would be to put an error code in HealthVaultOperationTask and have the caller check for the error. However, I prefer having all errors just be thrown from DoOperations method and wrapped up by the code that runs the task. To make it simple, HealthVaultOperation has a helper function called ThrowOnError() that throws an exception if there is an error returned from the HealthVault service (wrapped in a new HealthVaultException class).

The other design decision was around the threading model and how the results are communicated to the caller. I considered two basic approaches:

DoOperations is always called on the UI thread and can update models/UI as necessary.
DoOperations is not called on the UI thread, bundles up its results into properties on the task class, and is marshaled to the UI thread when complete.

I opted for #2. It eliminates potentially unnecessary thread context switching and keeps the code that does the network operation separated from any model/UI code. As a result, the signature of the method to run the task is as follows:

public void Run(Dispatcher dispatcher, Action successCallback, Action<Exception> errorCallback)

When the task is run, either the successCallback will be called or the errorCallback will be called. The call will be dispatched to the UI thread. Here’s an example:

MyHealthVaultTaskTask task = new MyHealthVaultTaskTask (service, ...);
task(dispatcher,
() => {
    // pull results off task and update model/UI.
},
(e) => {
    // Handle updating model/UI with exception e.
});

In part 2, I’ll share the code that implements HealthVaultTask.

Resetting the Live Tile in Windows Phone 7

Dan Crevier — Wed, 19 Oct 2011 16:15:34 GMT

The ability to update the Live Tile in Mango is a really great feature. I have an application where I’m generating dynamic images and setting the live tile to an isostore:/Shared/ShellContent url. But, I have a setting that the user can use to turn on/off live tile updates. When turning it off, I initially couldn’t figure out how to reset the tile.

The trick is to use an appdata: url to refer to your original image. For example, if your standard tile image is called “background.png”, then you can use the following to reset it:

        public static void ResetTile()
        {
            StandardTileData newTileData = new StandardTileData();
            newTileData.BackgroundImage = new Uri("appdata:background.png");

            ShellTile appTile = ShellTile.ActiveTiles.First();
            appTile.Update(newTileData);

        }

Note: If you have changed any other properties like the BackContent, you will want to reset them by setting them to “”. Passing in null will leave the values unchanged.

Windows Phone 7 WebBrowser control and target=”_blank”

Dan Crevier — Tue, 13 Sep 2011 01:54:26 GMT

I recently ran into a problem where I was hosting some content in a WebBrowser in a Windows Phone 7 app and found that some of the links on the page didn’t work. After a bit of debugging and binging, I found that it was because the links had target=”_blank”. In a regular web browser, this opens up the page in a new tab/window. In the WebBrowser control, it silently does nothing – there are no events you can hook into or anything.

I wanted to share the workaround I used. It’s pretty ugly, but the basic idea is that after the page loads, it injects some JavaScript to go remove the target on any links with target=”_blank”. For this to work, you need to have IsScriptEnabled=true on the control. And, it’s possible that some pages might block eval or otherwise block this from working. But, it worked in my case.

First, you need to hook up the LoadCompleted event on the web browser control. This fires after a page loads:

        public MyPagel()
        {
            InitializeComponent();

            _webBrowser.LoadCompleted += OnWebBrowserLoadCompleted;
        }

Then, OnWebBrowserLoadCompleted injects JavaScript to fix up the links:

        private void OnWebBrowserLoadCompleted(object sender, NavigationEventArgs e)
        {
            try
            {
                _webBrowser.InvokeScript("eval",
@"
window.FixupAnchors=function()
{
    var elems=document.getElementsByTagName('a');
    for (var i=0;i<elems.length;i++)
    {
        if (elems[i].getAttribute('target')!=null && elems[i].getAttribute('target').indexOf('_blank')==0)
        {
            elems[i].removeAttribute('target');
        }
    }
}");
                _webBrowser.InvokeScript("FixupAnchors");
            }
            catch
            {
                // ignore exceptions.
            }
        }

It’s a bit ugly, and some of my coworkers will give me a hard time for swallowing all exceptions here. But, it is working for me and hopefully someone will find it useful.

Hello World

Dan Crevier — Tue, 13 Sep 2011 01:35:04 GMT

Is this thing on?

I am going to pick up blogging again. It’s been a while! First off, I want to give an update on what I’ve been up to for the last few years since my last post. I was the development lead on SkyDrive from its initial release up through our Wave 4 release about 4 years ago. It was a lot of fun helping SkyDrive grow from a small beta (Windows Live Folders) up to a major service that tightly integrates with several other properties in Microsoft including Office and Windows Phone 7.

As of a year ago, I’ve moved over to be the development manager in the Engineering Platform team in Windows Live. My team is in charge of the infrastructure that runs Windows Live. This includes:

Our build system including our automated test and builds to keep the team running efficiently.
Our system for packaging and deploying client builds, including Windows Live Essentials and the new Windows 8 applications.
The system we use to manage our services (Hotmail, Messenger, SkyDrive, etc) including deployment, monitoring and repair.
Our analytics system that is used to monitor service health and understand how users are using our clients and services.

There are lots of hard problems in these areas and I’ve been learning a lot over the last year.

I’ve also been doing some Windows Phone development in my free time and recently published my first application (WiFi Scale Tracker). I’m planning to do some blog posts both about Windows Phone development and what we are doing in Windows Live.

News on the upcoming SkyDrive release

Dan Crevier — Thu, 13 Nov 2008 08:12:41 GMT

We’ve posted some details of our upcoming SkyDrive release here. I’m really excited about what’s coming all across Windows Live with our wave 3 release and how well everything works together.

I’m sorry I haven’t been posting much lately There are a bunch of topics I want to write about, like ASP.NET MVC, PowerShell and Silverlight!

Font Smoothing with Remote Desktop and Windows Server 2003

Dan Crevier — Sat, 12 Jul 2008 06:42:51 GMT

I spend a lot of time time connected to Windows 2003 Server. I was really happy to come across this post which describes a KB article to turn on font smoothing to Windows 2003 Server. This makes a huge difference with Consolas

Helge Klein » Blog Archive » Finally! Font Smoothing Over RDP/ICA on Server 2003

Disappearing disk space on Vista

Dan Crevier — Mon, 09 Jun 2008 07:01:45 GMT

The hard drive space on my Vista machine recently dropped to almost nothing, and I was really confused what was going on. I used my favorite disk space visualizer (WinDirStat). However, I couldn’t figure it out. Finally, I found that the following steps cleared it up:

1. Run Disk Cleanup (search from Start menu)

2. Choose “Files from all users on this computer”

3. When it’s done scanning (which can take forever), select the More Options tab

4. Select Cleanup under System Restore and Shadow Copies

This freed over 40 GB for me! I think that what happened is that the Zune software touched all of my media, which created shadow copies of each file, using a bunch of space. Shadow copy space must not show up for utilities like WinDirStat.

There’s a useful article on My Digital Life on how to limit how much space will be used. My was set to unbounded space.

New updates to SkyDrive!

Dan Crevier — Thu, 22 May 2008 20:19:12 GMT

We’ve made some more updates to SkyDrive including some features like comments, captions and better iteration through items in a folder. For details, check out our team blog post:

Windows Live SkyDrive Team Blog: Hot new updates to SkyDrive!

Bootcamp 2.1 update available

Dan Crevier — Sat, 17 May 2008 04:51:13 GMT

Apple has an update of Bootcamp available, fixing some stability issues. I’ve had more than my fair share of crashes on my MacBook Pro, so I’m hoping it will help out. It was offered to me via Apple Software Update, but you can also grab it here:

Apple - Support - Bootcamp

Implications of the just in time nature of LINQ

Dan Crevier — Wed, 26 Mar 2008 05:30:56 GMT

I love LINQ! I’ve found that much of the code I write involves manipulating collections in ways that can be very naturally expressed in LINQ. One interesting aspect of LINQ is that things are evaluated just in time as you enumerate over them. This can have a few unexpected consequences. Here are a couple of examples. Take the following test class:

        private class Test
        {
            public int Value { get; set; }
        }

Now, think about the following code:

            IEnumerable<Test> tests = Enumerable.Range(1, 3).Select(i => new Test() { Value = i });

            foreach (Test test in tests)
            {
                test.Value += 100;
            }

            foreach (Test test in tests)
            {
                Console.WriteLine(test.Value);
            }

For those not familiar with LINQ, the Enumerable.Range(1, 3) creates an IEumerable that ranges from 1 to 3, and then the Select creates new Test objects with a Value equal to the current value, meaning the overall expression creates Tests with values that range from 1 to 3. So, what does this output? You might expect 101, 102, and 103 because the first foreach increments the values. However, it prints 1, 2, 3. The reason is that foreach calls tests.GetEnumerator which runs through the process of creating Test objects as MoveNext/Current is called through the foreach loop. So, the first time we go though the loop it creates 3 Test objects and we increment the value. However, those Test objects are just returned by the enumerator and don’t get stored anywhere. The second time we go through the loop we create 3 new Test objects with values 1-3. One way to get the expected behavior would be to replace the first line with:

            List<Test> tests = Enumerable.Range(1, 3).Select(i => new Test() { Value = i }).ToList();

This creates a list with the Test values once, and then the foreach statements will enumerate the same set of Test values in that list.

Another gotcha of the just in time evaluation is that values in the lambda functions are evaluated at the time of enumeration. So, in the following example:

            int x = 0;

            tests = Enumerable.Range(1, 3).Select(i => new Test() { Value = x + i });

            x = 100;

            foreach (Test test in tests)
            {
                Console.WriteLine(test.Value);
            }

You get 101, 102, and 103 output. That’s because the “x + i” expression is evaluated after x is set to 100. This sort of issue is more subtle when you return a LINQ expression from a function. Who knows when that will be evaluated and what will change by then. Using ToList() is a reasonable way to force the evaluation time.

Why does my computer need to tell me when I plug into the headphone jack?

Dan Crevier — Thu, 20 Mar 2008 23:16:25 GMT

And, why is the icon so ugly?

mstsc /console is now /admin in Vista SP1

Dan Crevier — Thu, 20 Mar 2008 05:37:10 GMT

I find it kind of annoying that Vista SP1 switches the /console switch to /admin. I don't understand why they had to break this and couldn't keep the old switch working. There's a bit more info at:

Nick MacKechnie : MSTSC /console switch in Windows Server 2008 and Windows Vista SP1

Yield and usings - your Dispose may not be called!

Dan Crevier — Sat, 15 Mar 2008 07:08:04 GMT

We ran into an interesting bug recently where a resource was being leaked because we weren't disposing of an IDisposable in some cases. Before I go any further I should state that the root bug is that the IDisposable hanging onto the resource should have implemented a finalizer, or even better, used SafeHandle. However it wasn't our code.

We tracked down the bug to some code that looked like:

    static IEnumerable<Foo> MyEnumerable()
    {
        using (new MyDisposable())
        {
            // code that calls yield
        }
    }

Then, someone called MyEnumerable().GetEnumerator().MoveNext() without disposing it or wrapping it in a foreach. The result was that Dispose was never called on the disposable. I usually think of using guaranteeing that Dispose() gets called, except in extreme cases like thread abort exceptions. It sparked my curiosity to dig and figure out how this all works.

First, a couple of words about Enumerables, Enumerators and yield. An IEnumerator provides a simple way to iterate through a collection, using MoveNext() to advance to the next element, and a property Current to get the value at the current position. MoveNext() returns false at the end of the collection. An IEnumerable is simply an object you can call GetEnumerator() on to get an IEnumerator you can use to enumerate it (for example, collections are IEnumerables).

The yield keyword is a handy way to implement an IEnumerable that exposes the result of a series of calculations or operations in such a way that you can write serial code. I could spend a whole post on how cool yield is, but you can find that elsewhere. For a cool example, you can see the Fibonacci series implemented using yield. Note: yield is not a feature of the CLR, it's magical syntactic sugar provided by C# 2.0.

Let's take a simple example:

    class MyDisposable : IDisposable
    {
        public void Dispose()
        {
            Console.WriteLine("Disposed");
        }
    }

and the function:

    static IEnumerable<int> MyEnumerable()
    {
        using (new MyDisposable())
        {
            yield return 1;
            yield return 2;
        }
        Console.WriteLine("complete");
    }

If you walk the collection with the following code:

    IEnumerator<int> enumerator = MyEnumerable().GetEnumerator();
    while (enumerator.MoveNext())
    {
        Console.WriteLine(enumerator.Current);
    }

It will print "1", "2", "Disposed", "complete". But, how does it work? If you were to implement this without yield, you'd probably have to create a gnarly state machine, with some special cases for cleanup. Well, that's exactly what the C# compiler does for you!

Using .NET Reflector, we can see what code is generated. The MyEnumerable() function returns a new instance of a compiler generated class. Leaving out some of the details, the core of MoveNext() looks like:

    switch (this.<>1__state)
    {
        case 0:
            this.<>1__state = -1;
            this.<>7__wrap1 = new MyDisposable();
            this.<>1__state = 1;
            this.<>2__current = 1;
            this.<>1__state = 2;
            return true;

        case 2:
            this.<>1__state = 1;
            this.<>2__current = 2;
            this.<>1__state = 3;
            return true;

        case 3:
            this.<>1__state = 1;
            this.<>m__Finally2();
            Console.WriteLine("complete");
            break;
    }
    return false;

With:

    private void <>m__Finally2()
    {
        this.<>1__state = -1;
        if (this.<>7__wrap1 != null)
        {
            this.<>7__wrap1.Dispose();
        }
    }

So, if you walk through the states, you can see in case 0, it creates the MyDisposable, sets current to 1 and returns true. When it's called again in state 2, it sets current to 2 and returns true. When it's called a third time, it calls the finally function that disposes of the MyDisposable and then writes out "complete".

But, what happens in a partial enumeration? If you use foreach, like:

    foreach (int i in MyEnumerable())
    {
        Console.WriteLine(i);
        break;
    }

You might not expect it to call dispose. But, what it outputs is "1", "Disposed". The reason that this works is that the generated IEnumerator class also implements IDisposable where Dispose() calls <>m__Finally2(). And, foreach calls Dispose on its enumerator if it is an IDisposable.

However, in the case of our bug, we weren't using a foreach, we were just using MoveNext/Current directly without enumerating through the entire list. In this case, the MyDisposable is never disposed, even when GC takes place. Is this a bug? I've gone back in forth in my mind. On the one hand, the Enumerable code has a using, and that's supposed to clean things up! The compiler could have implemented a finalizer for the temporary class to clean up. On the other hand, the IEnumerator it generated was an IDisposable, which we failed to dispose. I tend to land on the side that this isn't a bug (and I bet the C# team agrees). If you have something that's holding onto a critical resource, you should implement a finalizer or use a SafeHandle and not rely on Dispose being called. However, I did find it a bit surprising. Now I know!

Josh Zana's perf blog

Dan Crevier — Wed, 12 Mar 2008 07:34:02 GMT

One of my coworkers, Josh Zana, has started a perf blog. Josh has been the perf champion for the SkyDrive and FolderShare websites, and I've been really impressed by his passion about perf and the results. I hope to see lots of good posts coming up.

Speaking of which, I realized I haven't had any technical posts for far too long. I need to get back to it!

FolderShare updates

Dan Crevier — Wed, 12 Mar 2008 07:31:20 GMT

Yesterday, we released a new version of the FolderShare web site and client. My team worked on the web site, which you might guess from the similarity to SkyDrive. In case you aren't familiar with FolderShare, it's an application that lets you sync files from multiple machines, peer-to-peer. I've been a happy FolderShare user for many years (since before Microsoft acquired it), and am glad to be a part of making it better. We did extensive usability testing on the core FolderShare scenarios and are really happy with the improvements we've seen with the new site.

Before you ask, I can't comment on FolderShare future plans, but rest assured, it's not dead!

SkyDrive is out of beta

Dan Crevier — Thu, 21 Feb 2008 21:13:33 GMT

We released SkyDrive to 38 more regions, we're out of beta, and we now give everyone 5 GB of free storage. See the team post for details. We also made some significant performance enhancements that hopefully everyone should notice.

Why do iTunes updates keep making me reboot?

Dan Crevier — Tue, 15 Jan 2008 23:44:58 GMT

Very annoying...

A WPF Framework

Dan Crevier — Tue, 08 Jan 2008 07:31:53 GMT

Rob Eisenberg posted a new WPF Framework here. I haven't looked at it in detail, but it looks pretty interesting!

More SkyDrive goodness

Dan Crevier — Fri, 12 Oct 2007 01:35:36 GMT

We've updated SkyDrive with some nice new features. One of the biggest hassles with SkyDrive before that was that it was hard to invite new people or add new contacts to the list. We now allow you to add new contacts (whether or not they have Live IDs) and people will be sent invites. If they don't have a Live ID, they'll have the opportunity to set one up. This should make sharing much nicer.

Another thing we added is RSS feeds. For example, the feed to my public folder where I put blog related stuff is:

http://cid-f9dac4c43e9a681d.skydrive.live.com/feed.aspx/Blog

For more details on the new features, see the SkyDrive blog.

Frustrating error using Remote Desktop

Dan Crevier — Thu, 23 Aug 2007 07:22:08 GMT

Recently I've started hitting the error below when trying to connect to one of my Windows 2003 Server machines with the /console option:

(Error connecting to existing session for dancre (Id 0). The operation completed successfully.)

You've got to love an error explanation of "The operation completed successfully". Restarting the server box fixes it for a while, but then it starts happening again.

Has anyone else seen this? Any idea how to fix it?

Tafiti

Dan Crevier — Wed, 22 Aug 2007 06:58:19 GMT

Tafiti is an interesting search experience built on top of Windows Live Search and SilverLight. Be sure to click the tree view. It's pretty cool stuff, from some people I used to work with.

Windows Live SkyDrive/Spaces integration

Dan Crevier — Fri, 10 Aug 2007 07:05:01 GMT

Another feature that went live today is the ability to add a "Files" module to Spaces that shows the visitors to your Space the folders they have access to. LiveSide blogs about it here. Scott also has a nice plugin for Windows Live Writer that makes it easy to embed things in Writer. Nice work!

Windows Live Folders is now Windows Live SkyDrive!

Dan Crevier — Thu, 09 Aug 2007 20:22:05 GMT

We have updated Windows Live Folders and rebranded it as Windows Live SkyDrive. There are lots of cool new features. One of my favorites is the rich upload experience that lets you easily upload lots of files at once, including drag and drop. You can also view the home page for other users, see recent folders you been to, and you can embed thing into your blog. For example, here's where I'm putting blog related files:

Try it out!

A pattern for unit testable Asp.net pages: Part 4

Dan Crevier — Wed, 01 Aug 2007 06:52:19 GMT

Okay, now for unit tests of the code from part 3. The goal is to completely cover RenamePageModel. First we need mock implementations of IPageContext and IDataAccess. For IPageContext, we are going to use special exception types for page not found and server errors. And, we'll add an accessor to track redirects. It's all pretty straightforward.

    public class MockPageContext : IPageContext
    {
        public bool IsSecureConnection
        {
            get { return _isSecureConnection; }
            set { _isSecureConnection = value; }
        }

        public bool IsPost
        {
            get { return _isPost; }
            set { _isPost = value; }
        }

        public void ThrowPageNotFound()
        {
            throw new MockPageNotFoundException();
        }

        public void ThrowServerError()
        {
            throw new MockServerErrorException();
        }

        public void Redirect(string destination)
        {
            _redirectString = destination;
        }

        public bool HasRedirected
        {
            get { return _redirectString != null; }
        }

        public string RedirectUrl
        {
            get { return _redirectString; }
        }

        private bool _isSecureConnection;
        private bool _isPost;
        private string _redirectString;
    }

    public class MockPageNotFoundException : Exception
    {
    }

    public class MockServerErrorException : Exception
    {
    }

The IDataAccess mock is also pretty straightforward. It's simply got properties that can be used to set the return value for the function, or to throw exceptions if desired.

    class MockDataAccess : IDataAccess
    {
        public MockDataAccess(string getItemNameResult, Exception getItemNameException, string setItemNameResult, Exception setItemNameException)
        {
            _getItemNameResult = getItemNameResult;
            _getItemNameException = getItemNameException;
            _setItemNameResult = setItemNameResult;
            _setItemNameException = setItemNameException;
        }

        public string GetItemName(string path)
        {
            if (_getItemNameException != null)
            {
                throw _getItemNameException;
            }

            return _getItemNameResult;
        }

        public string SetItemName(string path, string newName)
        {
            if (_setItemNameException != null)
            {
                throw _setItemNameException;
            }

            return _setItemNameResult;
        }

        private string _getItemNameResult;
        private Exception _getItemNameException;
        private string _setItemNameResult;
        private Exception _setItemNameException;
    }

And, now for the actual unit tests. Basically there's a test for each code path on load or post.

    [TestClass]
    public class RenamePageModelTests
    {
        [TestMethod]
        public void TestLoadSuccess()
        {
            MockDataAccess mockDataAccess = new MockDataAccess("name", null, null, null);
            RenamePageModel model = new RenamePageModel(mockDataAccess, "foo");
            model.Load(new MockPageContext());
            Assert.AreEqual("name", model.Name, "Name not set from item name");
        }

        [TestMethod]
        [ExpectedException(typeof(MockPageNotFoundException))]
        public void TestLoadFileNotFoundException()
        {
            MockDataAccess mockDataAccess = new MockDataAccess("name", new FileNotFoundException(), null, null);
            RenamePageModel model = new RenamePageModel(mockDataAccess, "foo");
            model.Load(new MockPageContext());
        }

        [TestMethod]
        [ExpectedException(typeof(MockPageNotFoundException))]
        public void TestLoadUnauthorizedAccessException()
        {
            MockDataAccess mockDataAccess = new MockDataAccess("name", new UnauthorizedAccessException(), null, null);
            RenamePageModel model = new RenamePageModel(mockDataAccess, "foo");
            model.Load(new MockPageContext());
        }

        [TestMethod]
        [ExpectedException(typeof(MockServerErrorException))]
        public void TestLoadIOException()
        {
            MockDataAccess mockDataAccess = new MockDataAccess("name", new IOException(), null, null);
            RenamePageModel model = new RenamePageModel(mockDataAccess, "foo");
            model.Load(new MockPageContext());
        }

        [TestMethod]
        public void TestPostSuccess()
        {
            MockPageContext pageContext = new MockPageContext();
            pageContext.IsPost = true;
            MockDataAccess mockDataAccess = new MockDataAccess("name", null, "newpath", null);
            RenamePageModel model = new RenamePageModel(mockDataAccess, "foo");
            model.Load(pageContext);
            Assert.AreEqual("rename.aspx?path=newpath", pageContext.RedirectUrl, "Did not redirect to correct url");
        }

        [TestMethod]
        public void TestPostArgumentException()
        {
            MockPageContext pageContext = new MockPageContext();
            pageContext.IsPost = true;
            MockDataAccess mockDataAccess = new MockDataAccess("name", null, null, new ArgumentException());
            RenamePageModel model = new RenamePageModel(mockDataAccess, "foo");
            model.Name = "errorName";
            model.Load(pageContext);
            Assert.AreEqual("errorName", model.Name, "New name not returned in model.Name");
            Assert.IsNotNull(model.ErrorString, "Error string not set");
        }

        [TestMethod]
        [ExpectedException(typeof(MockPageNotFoundException))]
        public void TestPostFileNotFoundException()
        {
            MockPageContext pageContext = new MockPageContext();
            pageContext.IsPost = true;
            MockDataAccess mockDataAccess = new MockDataAccess("name", null, null, new FileNotFoundException());
            RenamePageModel model = new RenamePageModel(mockDataAccess, "foo");
            model.Load(pageContext);
        }

        [TestMethod]
        [ExpectedException(typeof(MockPageNotFoundException))]
        public void TestPostUnauthorizedAccessException()
        {
            MockPageContext pageContext = new MockPageContext();
            pageContext.IsPost = true;
            MockDataAccess mockDataAccess = new MockDataAccess("name", null, null, new UnauthorizedAccessException());
            RenamePageModel model = new RenamePageModel(mockDataAccess, "foo");
            model.Load(pageContext);
        }

        [TestMethod]
        [ExpectedException(typeof(MockServerErrorException))]
        public void TestPostIOException()
        {
            MockPageContext pageContext = new MockPageContext();
            pageContext.IsPost = true;
            MockDataAccess mockDataAccess = new MockDataAccess("name", null, null, new IOException());
            RenamePageModel model = new RenamePageModel(mockDataAccess, "foo");
            model.Load(pageContext);
        }

If you use Visual Studio .Net's handy code coverage coloring, you'll see that we are covering all the code in the model, except for some closing tags in exceptions that are never hit because of the IPageContext functions that throw exceptions.

Well, that's it! I've put the entire project on Windows Live SkyDrive:

Let me know if you have any questions on it. And, let me know if there are other areas you'd like me to write about, such as using the asynchronous model. I'm interested to hear feedback on how this model can be adapted for other types of web apps.