"Blogs" via Headspring in Google Reader

Party with Palermo: PDC ‘09 edition – 6 days and counting

2009-11-09T20:55:55Z

That’s right, folks! For those of your coming to Microsoft’s Professional Developers’ Conference (PDC), Party with Palermo is going to kick the week off right. The conference starts on Tuesday, so Monday night, we are going to get down and party to the turntables of DJ Craig. If you were at the Party with Palermo at Tech Ed, you remember this DJ and how he had the uncanny ability to get folks like Ted Neward and Sara Ford dancing like it was 199. . . 2009!

Here is the skinny: Monday night – 7pm-10pm before PDC. Come to The Mayan, 6 blocks from the convention center in downtown L.A. Party with Palermo. RSVP now!

November 16, 2009 - Los Angeles, CA - 7:00PM - 10:00PM

The Mayan (map, website)
1038 South Hill St., Los Angeles, CA 90015
Ph: (213) 746-4287 - (six blocks from the convention center)
Cover charge is 1 business card. This will get you in the door and register you for the grand prize drawings.

Entertainment provided by:

DJ Craig

Free to attend
Free drinks
Free swag
Eat before you come

Sponsors: (find out how to become a sponsor)

KEEP TABS ON HTTP://www.PartyWithPalermo.com --- THIS IS WHERE THE INFORMATION WILL BE POSTED.

Subscribe to the Party with Palermo newsletter

Feel free to blog and link back to this site.

Fields and virtual members

2009-11-09T14:40:25Z

It seems like the sillier the bug, the more time you’ll spend debugging it, simply because it’s in functionality you just knew that worked correctly (and had the tests to back it up). One problem we hit recently was code that used fields to back virtual properties:

public abstract class Enumeration : IComparable
{
    private readonly int _value;

    protected Enumeration() { }

    protected Enumeration(int value)
    {
        _value = value;
    }

    public virtual int Value
    {
        get { return _value; }
    }

    public virtual int CompareTo(object other)
    {
        return _value.CompareTo(((Enumeration)other).Value);
    }
}

This isn’t a problem in and of itself, except in the behavior of that last method. Notice its logic uses the field and not the property. I can then define a derived type:

public class PercentDiscount : Enumeration
{
    public override int Value
    {
        get { return 5; }
    }
}

But now my CompareTo method breaks because it isn’t using the correct value. It uses the uninitialized field, causing all sorts of bizarre behavior. When you have logic errors in places like GetHashCode, Equals or CompareTo, I can guarantee your application will break in the most hair-pulling ways imaginable.

Let’s fix it

So what’s a better option? We could just “make sure” that we don’t use the private field, and only use the virtual property. But I hate conventions that rely on my memory to not make a mistake, I want to fall into the pit of success. One way to do so is to use automatic properties:

public abstract class Enumeration : IComparable
{
    protected Enumeration() { }

    protected Enumeration(int value)
    {
        Value = value;
    }

    public virtual int Value
    { 
        get;
        private set;
    }

    public virtual int CompareTo(object other)
    {
        return Value.CompareTo(((Enumeration)other).Value);
    }
}

Instead of a backing field, we’ll use an automatic property, making it impossible to use a non-virtual backing field. We still get the same access modifiers (a virtual, overridable getter, a private setter), plus the benefits of automatic properties. So now I’m curious: are there any valid reasons to keep using fields for holding state?

ASP.Net MVC Portable Area – Part 4 IoC framework support.

2009-11-04T05:00:00Z

Part 1 – Introduction
Part 2 – Sample Portable Area
Part 3 – Using of a Portable Area
Part 4 – Using an Inversion of Control Framework. (this post)

Using an Inversion of Control Container is a common scenario that would be needed by a Message Handler. The Bus has an extensibility point to create the handlers. The model for this should feel similar to the ControllerFactory extension point in the ASP.Net MVC framework. The sample below shows how to create a Message Handler factory for the StructureMap framework.

The SetMessageHandlerFactory method should be called once at application startup. Other than that … this is a pretty simple way to add a Dependency Injection Framework support to the Portable Area infrastructure.

This makes it pretty simple for your message handlers to use constructor injection to manage their dependencies.

Using MSDeploy to automate your Enterprise Application remote deployments.

2009-11-06T17:00:00Z

MsDeploy is a newish technology that is a bit schizophrenic. What I mean is that it is a tool that is useful to both Developers and Administrators but it is not clear from the documentation how to best use the technology and how to approach it. I believe it stated as a Server Administrator tool and the team was able to work in an integration with Visual Studio which made it into a more robust framework, but at the same time left is command line interface with so many options that it is challenging to get a grasp on. To top that off the Web Platform Installer uses the MsDeploy packages as a way to distribute packages through that tool. After working through some various ways to use the technology I have settled into some commands that work well for our projects.

Let me set the context of how we are using the tool and what we already had in place so that you can better understand if my use of MsDeploy will work for you. At Headspring we use Continuous Integration on all of our projects and as a result, once our software is built by our build server the next logical step is to deploy our software to a server and than run User Interface tests against the application. Most of our projects are web applications running on ASP.Net MVC using Sql Server as the back end. We install our software using a lightweight zipfile that contains the web application files, database migration scripts and a deployment script which can poke config files and execute our database migration tool. We already have all the pieces in place to deploy our application on a local machine.

Up until know we have used two methods to deploy instances to remote machines. The first methods was to install Cruise Control.Net on the server and have it monitor our source control repository for a new installation package being committed to the repository. Once it sees a new package CCNet will pull down the package, install it locally and go on its merry way. The second method, is to kick off the deployment from the build server and connect over the network to the target database to run upgrades and then xcopy the files to a unc share. Both of these methods require setting up some configuration on our target servers. My goal with our deployments is to reduce the amount of per server configuration we do on each server and use some conventions to make each server look similar to one from a different project.

Using MSDeploy allows us to do the following.

1. Remove the need to install cruise control on the target server and update the configuration for cruise control on each target server. We do have to install MSDeploy on each server but we do not have to mess with any configuration after that.

2. We do not have to mess with setting up unc shares and deal with the mess. It sounds like a silly thing but by getting away from the unc share we can also test our deployments from any machine and msdeploy is actually firewall friendly. xcopy to a unc share is not firewall friendly which means that we cannot use it for all of our clients which means variations between our projects.

3. We use msdeploy as a mechanism to distribute our deployment packages and then remotely execute the packages. This means I can have a single instance of our Continuous Integration server which reduces the number of places to maintain configuration. That is a big win. This also means the log files for all of the deployments can be tracked in a single place.

4. Another benefit of using msdeploy to push our deployments means that I can easily setup new instances of a test configuration and push it to multiple servers without having to log into each machine.. This is good for efficiency.

Our use of MSDeploy now boils down to two steps. Distribute and Execute. We have some of our scripts in NAnt and we are in the process of migrating to PowerShell now that version 2.0 is available from the older operating systems. Below is a sample of executing msdeploy from a NAnt script.

Calling MsDeploy from Nant

The dirPath command tells MSDeploy to synchronize a directory from the source computer a target computer. This is a pretty easy command to understand.

The second command is the runCommand this command was added between the RC and 1.0 release of MSDeploy and I am so happy they added it. The run command is told to execute a command on the remote machine. Since we are running installation scripts, they do not execute instantly and as a result the waitInterval and waitAttempts need to be specified so that the command does not timeout before it has completed running. other than that the output of the console application is piped back to the source computer. The one caveat about the run command is that when it starts it runs from the C:\windows\system32 directory. In order to work around this issue I have found that passing the directory of the command into the batch file that I run allows my batch files to first cd to that directory as its first step. This is a pretty harmless thing to do and works pretty well.

This is what a sample deployment batch files looks like.

cd %1
rd ..\codeToDeploy\ /s /q
applicationNamePackage.exe -o..\CodeToDeploy\ -y
cd ..\CodeToDeploy\
cmd /c %systemroot%\system32\inetsrv\appcmd stop site applicationName_dev
iisreset
call dev.bat
cmd /c %systemroot%\system32\inetsrv\appcmd start site applicationName_dev

This is pretty basic and does some IIS commands as well.

I am sure I left some information out, but I wanted to get a brain dump of our use of MSDeploy.

Long term I would like to see the use of PowerShell driving msdeploy and adding some configuration around each Server Role in an application and tie it to the servers needed for each environment. I have started a project to put this together called psTrami but I have not put any of the code together yet, just some small spikes to prove it out.

More to come sometime soon…..

Automapper Auto Profile Registration.

2009-11-05T03:24:15Z

On some of our projects we have been experimenting with smaller AutoMapper profiles. The idea is that it is easier to digest a smaller profile. We have gone so far as creating a profile for each Domain object and handle all of the mappings to and from the domain object. We are also trying out a Profile per scenario. While these smaller profiles are easier to dig in and understand, the registration of them are a little painful. So I put together a quick way to auto register all the profiles for automapper. Below is the code to discover all the profiles in an assembly than register them with AutoMapper. There is nothing fancy here and I could certainly spend more time making it better performing, but realistically this is startup code that runs once at application start up. That being said I would rather focus performance optimization efforts on places that actually make a difference to the End User Experience.

Here is the sample.

It is important to know that we have full code coverage over our application including integration tests, so that if something were to break as a result of loading this in a non deterministic order, we would know before we commit our changes to source control.

Here is the code for the ForEach extension method, since I breezed over it.

This is a smaller post than I normally put together.. is this small of a post useful?

ASP.Net MVC Portable Areas – Part 3

2009-11-03T17:00:00Z

Using a Portable Area

This is the third part in a series about using a Portable Area (PA) using MvcContrib. This sample walks through the Host Application side of consuming the Login Portable area. This example demonstrates how a portable area such as a login can send messages and recieve responses from the host application. This allows the host application to control the core of the application and lets the Portable Area solve the User Interface portion of the Login. While this is a pretty simple example it is important to look at the concept of what a Portable Area could solve. A portable Area could just handling wiring up multiple user interface screens and deal with simple form validation while leaving a lot of from for the host application to control the parts that are important to the application. Or a Portable Area could provide an entire self contained piece of functionality like a Blog engine, or mulit-instance forum. There is a large spectrum for how much the Portable Area could provide. This example focuses on an example where the Portable Area provides the UI and lets the host application own the domain logic.

Part 1 – Introduction
Part 2 – Sample Portable Area
Part 3 – Using of a Portable Area (this post)
Part 4 – Using an Inversion of Control Framework.

In order to use a Portable Area (PA), the following references need to be added to your MVC project: MvcContrib & the assembly of the Portable Area.

Wiring up the Portable Area to the application is done at startup. Portable Areas use the message bus as a way to communicate between the PA and the application. The main method for integrating with a portable area is to register a Message Handler. The sample below demonstrates wiring up a LogAllMessagesObserver, LoginHandler, and a ForgotPassword Handler for the Login Portable Area.

The call to the InputBuilder.Bootstrap() is required to initialize the Embedded Resource view engine used by this Portable Area infrastructure.

Here is an example of an Observer message handler. This handler simply logs the message to the debugger. This could be used to collect metrics about the system, or log messages to a loggin framework. The idea of an observer is that it is looking at the base message and not modifying the state of the message.

The Login Message Handler receives the login request and than sets the result object which is part of the contract that is specified by the LoginPortableArea from Part 2.

In this example the main logic for login is still in a authentication service. The handler is just used to wire up the message and response of the portable area to the host applications domain services.

Whats Next?

The constructor of the LoginHandler takes an IAuthenticationService as a dependency and my next post will walk through how an Inversion of Control container can be connected to the Bus to allow the framework of your choice to put your pieces together.

ASP.Net MVC Portable Areas – Part 2

2009-11-02T17:00:00Z

Sample Portable Area

This is the second part in a series about creating a Portable Area (PA) using MvcContrib

Part 1 – Introduction
Part 2 – Sample Portable Area (this post)
Part 3 – Usage of a Portable Area
Part 4 - IoC Framework Support

To create a Portable Area, the first step is to create a separate class library project for the Portable Area. The output assembly is the single file needed to add this functionality to applications which wish to consumer it.

The minimal references required for the Portable Area are shown below:

While DataAnnotations is not required to build a PA, using DataAnnotations for Model validation makes distribution of the PA very easy, since the MVC2 DefaultModelBinder supports the DataAnnotations validation out of the box. If you choose a different validation framework than you would need to distribute those assemblies or possible IL Merge them into your PA.

The sample PA in the MvcContrib project is a Login Portable Area, this is a pretty simple example, but demonstrates how a PA and application can integrate. This is also a piece of functionality that most applications need.

Below is the code listing and structure for the project. It looks identical to a mulit-project ASP.Net MVC Area.

The first difference between creating a Portable Area and a standard area from the files perspective is how the Views are registered with the project. The views Build Action should be changed from content to an Embedded Resource. This allows the views to be embedded into the output assembly so that they view folders and files to not have to be manually copied into each application that uses it. Instead a special view engine will pull these views out of the assembly at run time and render them the same way that a physical view would be rendered.

The second item that is needed to create a Portable Area is a specialized registration class for the that inherits from PortableAreaRegistration. This class provides an extended RegisterArea method that sends in the MVC AreaRegistrationContext and a IApplicationBus object to the method. The IApplicationBus is the mechanism that a Portable Area uses to send messages to the hosting application during. The use of the bus during registration is not required, but it is available in case and specific start up logic is needed to correctly configure the Portable Area.

The last line of the method show how the Portable Area registers the embedded views with the view engine, using the call to the RegisterTheViewsInTheEmmeddedViewEngine method.

An important caveat around the setup of the Registration class is to make sure that the Registration class is sitting in the same Namespace as the controllers and views. If the Namespaces do not match the views will not be able to be located. Since the namespace for the Embedded Resource views cannot be specified declaratively they are created using the Assemblies Default Namespace and the folder structure that they are stored in. So keeping all of these properties consistent will make everything work. If you change the default namespace of the project, you will need to update the namespace of your registration and controller classes.

The first call in this registration method sends a message to the hosting application. This is a contrived example but it demonstrates sending a tracing message that can be used by an observer message handler to log the registration activity. This tracing can be useful since the Portable Areas use the built in MVC registration mechanism for auto discovery and there is not a lot of visibility into the built in registration process. This example shows how a message can be sent between the PA and the hosting application.

The LoginController demonstrates the functionality needed to handle displaying the login form and then handling the form post. There are two Actions in the controller, one to render a Login View and a second Action to process the form post and redirect the user on success or , in the case of a login failure, display the login error messages to the user.

The message bus is the main mechanism for communicating between a portable area and the hosting application. This is a very simplistic mechanism that allows the Portable Areas to communicate with the hosting application in a synchronous manner.

For some scenarios, like when the area should not implement its own database, the host application can own how the domain model is persisted in data storage and the Portable Area can worry about handling the multi-page user interface and other user interface concerns like validating simple data types.

The messages that are passed to the Bus are shown below.

The LoginInput represents the data that is collected from the Login screen. It is using the built in DataAnnotations attributes to handle the simple validation rules.

The result object is used to determine if the credentials were valid for the host application and are then used to either display the error message or redirect to a protected page. Since the LoginInputMessage is passed to the bus with a reference, the handlers in the host application can change the Result object's state and the portable area can than access the Result and determine the correct logic to perform given that result. The implementation for the handlers will be in the next post in this series.

The Index view for the login uses the MvcContrib Input Builders to render a standard form to the page. The use of the Input Builder allows an host application to override any of the html mark up using the Input Builder partials. This means that the Portable Area and Input Builders play very nicely with each other.

This is what the view looks like in a browser.

This is the validation errors that are handled by the Portable Area, using the MVC 2 default model binder.

This shows an error message that is passed back from the resulting application. Other rules could be applied as well.

This is the approach for creating a Portable Area (PA) using the MvcContrib Portable Area feature. Let me know what you think about this approach, we tried to stay with the simplest approach that could possible work, and focused on making it easy to both develop and consume the Portable Areas.

Please leave your comments on what you think of the approach.

ASP.Net MVC Portable Areas via MvcContrib

2009-11-01T18:00:00Z

This is a multi post series on ASP.Net MVC Portable Areas

What is a Portable Area?

A Portable Area is a set of reusable multi page functionality can be dropped into an application to provide rich functionality without having to custom build functionality that is literally the same in every application. This could be considered a plug-in or add-in type of functionality. The portable portion of this approach is that the area can be distributed as a single assembly rather than an assembly and a host of other files, like views or other html assets that need to be managed and maintained over time. By making a portable area totally self contained in a single assembly, this should allow for easier reuse and upgrades to the area. The challenge for doing something like this has been how do you allow enough control over the User Interface by the application yet still allow the actual views to be packaged with the logic.

Why Now?

There has been some discussion in the past on the MvcContrib mailing list about creating an plug-in framework and plugins but I do not think we had enough of the pieces in place to do this properly. I believe that with MVC 2 we have those missing pieces figured out. The first enabler is the inclusion of Areas into the MVC 2 feature set. This includes having the Area and Controller namespace become part of the route data which is used both for Controller/Action selection but this also flows down to the selection of a view. The second enabler is some of the work that came out of MvcContrib and the Input Builders. While implementing that feature we came up with a way to pull views from an assembly as an embedded resource. This with the ability to override the default view engine in a way that allows an application developer to place their own version of a view in a folder so that they have the option to change the view to their needs was huge. The last enabler really comes from what we have learned from all of the SOA greats and see how frameworks like nServiceBus and MassTransit have demonstrated that a messaging approach for integration can keep our concerns separated.

The other why now is that my company, Headspring, has found that in order to make our practice more successful, we need the ability to drop in some of the essentials for an application, we would prefer to do this in a binary form that is easy to upgrade and does not leave us with copy and pasted code between our various projects. We would like to see that if we learn something from one project that we have the potential to apply those learning's to projects that are still in flight. We all prefer that rather than waiting for the next project to start so that we can apply what we have learned to the new project. This approach will be much better for us as developers and our client will benefit as well. We could take the approach of working on this in a bubble but by putting this out for the community we can learn from every else and potentially help others in the process and raise the collective bar for the industry, in our own little way.

Logical View of a Portable Area

Below is a logic view of a Portable Area. It shows how the Green block is an application. Inside the application the blocks in dark blue are framework components in ASP.Net MVC 2 and MvcContrib. These blocks provide some minimal framework support for registration view resolution and communication between the application and the portable area. The light blue blocks represent code the developer create. The code in the Portable Area is created by the Portable Area developer. The code in the application block is coded by… you guessed it. The application developer.

Thanks for the Pictures but where is the code?

The code is currently available in the MvcContrib MVC 2 Branch. You can get the latest binary from our (TeamCity/CodeBetter) build server here: http://teamcity.codebetter.com/guestAuth/repository/download/bt83/.lastSuccessful/MVCContrib.release.zip

There is a sample application you can download here: http://teamcity.codebetter.com/guestAuth/repository/download/bt83/.lastSuccessful/MVCContrib.Extras.release.zip

or from the code repository on GitHub: Download the source as a zip. or Fork it on GitHub.

What I have been up to.

2009-10-30T03:36:02Z

I have been pretty busy over the last few weeks. I just wanted to document what I have been doing.

I co-presented a free Advanced ASP.Net MVC half day with Jeffrey Palermo in Austin. We had a good group of people show up to the Austin Microsoft office. As I was preparing and presenting the session, it has become very obvious how much

I co-presented with Jackson Harper from the Mono team at Monospace on Mono and the Web ASP .NET MVC, WebForms, Tools, and Servers. In preparation for this session I took the code camp server, codebase and got it running with Mono on openSuse… yeah that Linux, That means that ASP.Net MVC, StructureMap, NHibernate, Automapper, Castle Validators, and MvcContrib all work on mono and are binary compatible! I was able to compile the application in Visual Studio and using the MonoVS plugin deploy a vm. We also demonstrated ftping the bits to a Linode and Jackson showed how to get is all setup. He even made a Virtual Appliance that when you start it up in vmware it will be running the application on the web server.. You can get the slides, link to the mono version of the source code, download the virtual appliance from the mini site that was setup for the talk. http://MonoOnTheWeb.info . I thought it was pretty cool seeing all of this stuff work. It was a great way to prove out that the application stack that Headspring uses can be deployed on a wide range of platforms which ultimately opens up our potential customer base.

I had the chance to present Database Change Management as the InnoTech conference. It was pretty good to get out and see a group of people that I have not seen before. I sometimes feel like I am in the Austin .Net bubble so while I presented some code samples in .Net using SQL server I really tried to present the information as being agnositc of you database platform. Good development techniques can transcend technology and platforms.

MVC Best Practices

2009-10-28T12:45:26Z

Simone has a great post (as usual) on 12 ASP.NET MVC Best Practices:

Controller:

1 - Delete the AccountController

2 - Isolate controllers from the outside world

3 - Use an IoC Container

4 - So NO to “magic strings”

5 - Build your own personal conventions

6 - Pay attention to the verbs

Model:

7 – Domain Model != ViewModel

8 – Use ActionFilters for “shared” data

View:

9 – NEVER use code-behind

10 – Write HTML each time you can

11 – If there is an if, write an HtmlHelper extension

12 – Choose your ViewEngine carefully

This is a fantastic list, and of course I have my own additions/suggestions :) First, I’m not a fan of action filters for shared data. If we’re doing strongly-typed views, using action filters for shared data puts us back into the magic string land, where we have to either use inheritance in our ViewModels, or the dictionary part of ViewData. I don’t like either approach, I’d rather go with something like RenderAction to truly enforce SRP in my ViewModels. Not everyone appreciates the elegance of this approach, but I’m sure they’ll agree eventually.

I also don’t like writing an HtmlHelper extension just because I have logic in the view. For a half-decent view engine, it shouldn’t be that problematic to have view logic in the view. HtmlHelper extensions enforce the Helper object anti-pattern – a bunch of procedural logic hanging off one static class. Instead, we went the route of building intelligent input builders for input elements, and only really using HtmlHelper when we want to eliminate duplication between multiple views. I see these constructs:

HtmlHelper
Partials
Master Pages

All as means of eliminating duplication in our views, but not much more. If there’s logic in a view, that’s fine by me as long as it’s not duplicated. It’s not my fault that C# looks downright bizarre mixed in with HTML markup, but that’s what other view engines are for.

Finally, if there was an award for How Not to Design a Controller, the AccountController would be the runaway champ. I still can’t imagine why it’s necessary, and the idea of portable areas would be a better fit for its functionality than the Thing We Always Delete with Extreme Prejudice.

MVC Web Testing Strategies – verifying content

2009-10-28T01:51:46Z

Some of the questions during the C4MVC presentation concerned how I liked to locate data displayed in the rendered HTML for validation purposes. You have quite a few options for doing so, such as:

Traverse HTML directly through the DOM
Using existing semantic HTML information
Adding semantic HTML information
Wrapping data with specific HTML

I’ll dismiss the first option immediately, it’s quite brittle to traverse only the DOM to locate data on a screen. If I have to have intimate knowledge of the entire HTML document rendered, the test will become far too dependent on the layout on the screen. If I decide to move information out of a table and into a definition list, my test will likely break.

From there, I’m left with basically two options – semantic HTML, whether it’s existing or added, or wrapping each data piece with custom HTML. In the presentation, two questions came up:

When locating a piece of information in a row in a table, why not use something more meaningful, such as the underlying entity’s ID to tag the data?
Again in the table, why not use semantic information on the row, instead of adding meaningless HTML?

Before we look at the different ways to verify content, let’s first look at what we want to verify.

The original content

In the scenario I highlighted in the screencast, I walk though editing some information, then verifying that data was changed correctly. I still have tests for controllers, repositories and so on, but I want a high level scenario-based test to make sure the entire pipeline is working as expected. We try and pull the information out of the HTML content rendered, using some sort of UI testing tool. Without modifying the content, here’s what we have to work with:

<div id="main">
    <h2>Products</h2>
    <table>
        <thead>
            <tr>
                <td>Details</td>
                <td>Name</td>
                <td>Manufacturer</td>
                <td>Price</td>
            </tr>
        </thead>
        <tbody>
            <tr>
                <td><a href="/Product/Edit/1">Edit</a></td>
                <td>Insignia® - 26" Class / 720p / 60Hz / LCD HDTV DVD Combo</td>
                <td>Insignia</td>
                <td>359.99</td>
            </tr>
            <tr>
                <td><a href="/Product/Edit/2">Edit</a></td>
                <td>Insignia® - 19" Class / 720p / 60Hz / LCD HDTV</td>
                <td>Insignia</td>
                <td>189.99</td>
            </tr>
            <tr>
                <td><a href="/Product/Edit/3">Edit</a></td>
                <td>Dynex® - 15" Class / 720p / 60Hz / LCD HDTV</td>
                <td>Dynex</td>
                <td>159.99</td>
            </tr>
        </tbody>
    </table>

There’s more rendered than just this HTML, but this is the piece that really matters. We have some semantic CSS information, the DIV with an ID of “main”, but that’s about it. In our CSS, we style our tables based on an ID-Element selector, but we could have just have easily used a class name on the table. I’d like to verify that the price on the first product was changed correctly, but how do I verify this? How do I make sure that the value in that one cell is the new price?

Choosing a strategy

I don’t want false positives or false negatives. I don’t want to look for just any table or any table cell in the markup, I want really the piece just around “359.99”. A few options to do so include:

Locating the outer DIV, finding the table, the first row, last cell, etc.
Apply a special class to the TD just where that price is shown
Add markup only around data-bound elements

When I first started doing UI testing, I assumed that I wanted to be as semantic and pure as possible, and not try to change my markup just for tests. That idea lasted about an hour, and reality set in that in general, things not designed with testing in mind will be hard to test. Hard to write tests, hard to maintain tests.

My next idea was to add information as needed, perhaps a class name to an existing surrounding element that might double for styling. But I’ve moved completely away from that strategy as well, as styling and UI testing are two different concerns that should not mix.

Why keep these concerns separate? Frankly, because both concerns have two completely different reasons to change. Styling and behavior (such as IDs added for jQuery) are about design and interaction. UI testing is about verifying site behavior. Mixing the two concerns means my tests are more likely to break because I’ve changed the design. But design can change without behavior changing, so I don’t want to couple my tests to the visual design. Coupling UI tests to the site design is like unit testing using only the reflection API.

Instead, I’d rather couple my tests to something that better represents the view – and that would be the ViewModel.

Strongly-typed views, strongly-typed tests

We use strongly-typed views because using a dictionary just leads to brittleness and fear of change. Strongly-typed views, along with the concept of the Thunderdome Principle, let us move past the issues of broken views and broken model binding. Instead of writing black-box tests against our UI, we can take advantage of the strongly-typed views, and modify our HTML rendered to get access to the rendered ViewModel. If you look at views from the point of view of “how to render a ViewModel”, then your UI tests can now talk in the language of the ViewModel.

But to help our UI tests out, we need to be able to locate information rendered from a ViewModel. Looking at our original HTML, the most fool-proof, straightforward way to do this would be to add HTML as close to the rendered ViewModel as possible. Let’s look at our view to see where this might be:

    <h2>Products</h2>
    <% var products = Model; %>
    
    <table>
        <thead>
            <tr>
                <td>Details</td>
                <td>Name</td>
                <td>Manufacturer</td>
                <td>Price</td>
            </tr>
        </thead>
        <tbody>
        <% foreach (var product in products) { %>
            <tr>
                <td><%= Html.ActionLink("Edit", "Edit", new { id = product.Id }) %></td>
                <td><%= product.Name %></td>
                <td><%= product.ManufacturerName %></td>
                <td><%= product.Price %></td>
            </tr>
        <% } %>
        </tbody>
    </table>

So what’s the ideal spot here? On the table? The table body? Row? Cell? These are all possible…and all coupled to the design of the UI, rather than the shape of the ViewModel. Instead of coupling to the design of the HTML, we can instead change every spot where we render the ViewModel directly to have extra HTML used only for UI tests. In the presentation, I move towards this model:

<tbody>
<% var i = 0; %>
<% foreach (var product in products) { %>
    <tr>
        <td><%= Html.ActionLink("Edit", "Edit", new { id = product.Id }) %></td>
        <td><%= Html.Span(m => m.Name) %></td>
        <td><%= Html.Span(m => m.ManufacturerName) %></td>
        <td><%= Html.Span(m => m.Price) %></td>
    </tr>
<%
    i++;
} %>
</tbody>

In practice, I’ll use a similar concept to the Opinionated Input Builders Eric highlighted a while back. Instead of input elements, I’ll solely render at the core, span tags. Here is the rendered HTML:

<div id="main">
    <h2>Products</h2>
    <table>
        <thead>
            <tr>
                <td>Details</td>
                <td>Name</td>
                <td>Manufacturer</td>
                <td>Price</td>

            </tr>
        </thead>
        <tbody>
            <tr>
                <td><a href="/Product/Edit/1">Edit</a></td>
                <td><span id='_0__Name'>Insignia® - 26" Class / 720p / 60Hz / LCD HDTV DVD Combo</span></td>
                <td><span id='_0__ManufacturerName'>Insignia</span></td>
                <td><span id='_0__Price'>359.99</span></td>
            </tr>
            <tr>
                <td><a href="/Product/Edit/2">Edit</a></td>
                <td><span id='_1__Name'>Insignia® - 19" Class / 720p / 60Hz / LCD HDTV</span></td>
                <td><span id='_1__ManufacturerName'>Insignia</span></td>
                <td><span id='_1__Price'>189.99</span></td>
            </tr>
            <tr>
                <td><a href="/Product/Edit/3">Edit</a></td>
                <td><span id='_2__Name'>Dynex® - 15" Class / 720p / 60Hz / LCD HDTV</span></td>
                <td><span id='_2__ManufacturerName'>Dynex</span></td>
                <td><span id='_2__Price'>159.99</span></td>
            </tr>
        </tbody>
    </table>

Notice that each data-bound output is wrapped with a span tag – and a special span tag at that. The span tag has a unique ID that represents the expression used to render that piece of data. The first product name shown comes from the expression “m => m[0].Name”. Because I know the ViewModel used to render this view, I can use an expression combined with a UI testing tool to locate the rendering of any piece of information on the screen.

The downside of this strategy is the amount of HTML added to the final document render. But since we’ve separated HTML used for styling and behavior, and HTML rendered strictly for testing, we can put a switch in our application so that for environments not doing UI testing, the span tag isn’t ever rendered! We can then get the best of both worlds – non-obtrusive JavaScript on top of semantic HTML, and flip a switch to be able to get to any piece of information on the rendered HTML.

Because our UI tests also use the ViewModel types and expressions to locate the same rendered ViewModels that the views used to render, we no longer run into the issue where our UI tests become disconnected from the views rendered. If we delete a property on our ViewModel, guess what, the UI test no longer compiles!

Wrapping it up

Developing a UI testing strategy isn’t the easiest thing in the world. In our current project, I think we had three or four evolutions before we finally settled on a UI testing strategy we like. And it’s still not perfect – we’re still looking at ways to make UI testing easy, expressive, and more valuable. But gone are the days where a styling change broke our tests. When our UI tests fail now, it’s more along the lines of a new required field, changing business rules and so on.

I don’t like mixing styling and behavior with locating data-bound UI elements, simply because both have very different reasons for change. But by taking advantage of our strongly-typed views in our UI tests, we can render the ViewModel in such a way that makes it dirt-simple to locate individual pieces of our ViewModel on the final rendered page.

C4MVC UI Testing screencast posted

2009-10-23T01:37:41Z

Yesterday the C4MVC guys hosted a screencast with me on UI testing ASP.NET MVC. It was a lot of fun, but I actually forgot I was being videotaped (webcam’d?), so all those times I turned off my mic to catch a drink of water or cough uncontrollably are caught in glorious 370i. Anyway, check out the video here:

Unfortunately, I didn’t leave enough time for questions at the end, and I had some good ones from the audience. You can also find the complete code and slides here.

Thanks again to the C4MVC guys for hosting me! Since I didn’t have time to answer too many questions, feel free to ask them in the comments, or you can always use the Contact Me link.

C4MVC meeting on UI testing

2009-10-21T13:38:41Z

Today I’m showing giving a talk on UI testing MVC applications for the Community for MVC.Net folks. Those that went to my presentations in Arkansas and Houston have seen this talk already, so they’re off the hook on this one. I’ll be covering ways to create UI tests that don’t break when a butterfly flaps its wings in Japan, and how we can design our MVC applications for UI testability.

The presentation is done via LiveMeeting, (http://Meeting.c4mvc.net), so make sure you’ve hit that link before the start time, which is 12:00 PM CST today. For more details, check out the C4MVC site:

http://www.c4mvc.net/

In the WebForms world, it was quite difficult to create maintainable UI tests. But in ASP.NET MVC, we have far more control over the HTML generated, allowing us to design our UI for testability. It should be a good discussion, I’m looking forward to seeing everyone there!

Wharton on Dynamic Competitive Strategy

2009-10-21T01:51:00Z

I just began reading a new book, “Wharton on Dynamic Competitive Strategy” by George S. Day and David J. Reibstein. I can appreciate different points of view and approaches because I use what I consider to be the best from each school of thought in order to form “right fit” approach for me. In this case, I have a strong opposition with strategic development methodologies presented in this book. While I am sure I will get value from these concepts, I have a strong bias against approaches that seem to be hyper-focused on competitors – what they are doing, anticipating their reactions, their next moves, etc. versus internal innovation and value innovation for clients.

This book outlines 7 core areas of developing a “dynamic competitive strategy.” Of the 7 core areas, 1 is focused on actual custom feedback and interaction – which could be considered one of the most important, 3 are focus on competitors and what they are doing or might do, 1 is focused on how public policy might impact your strategy, and 2 are focused on the actual company’s strategy and alternatives.

I am a firm believer in being proactive in an approach to find and keep ones competitive advantage. To me this means paying less attention to what a competitor is doing or might do and focusing more on a client’s needs or unmet desires along with ways to create more value – or “value innovation”.

While I will continue to explore this view point on creating a dynamic strategy because I believe there will be value that will help me shape my own approach, I am hesitant based on the initial experience with this book. It is possible that this approach to strategic planning does not apply to me, with a business in our current revenue range or vertical market. It seems like this might apply better to a commoditized industry.

I would like to believe that there is a common, core approach to strategic planning and value innovation that is agnostic to a company’s “age” in their lifecycle.

Free ASP.NET MVC workshop tomorrow

2009-10-19T18:47:42Z

10/20/2009 - Advanced ASP.NET MVC for Enterprise Applications

Jeffrey Palermo and Eric Hexter are the instructors for an advanced MVC training at the Microsoft Technology Center. more

RSVP here: http://www.headspringsystems.com/community/presentations/

How not to implement a failing test

2009-10-19T13:45:30Z

One of the first things I change in ReSharper, along with one of my biggest pet peeves is a failing test that fails because of something like this:

public class CombinedStreetAddressResolver 
    : NullSafeValueResolver<Address, string>
{
    protected override string ResolveCore(Address model)
    {
        throw new NotImplementedException();
    }
}

In the Red-Green-Refactor progression, the Red of a failing test should come from an assertion failure not a “my code is stupid” failure. The Red part is intended to triangulate and calibrate your test, to make sure that your test can fail correctly. A NotImplementedException won’t cause a meaningful failure, and only serves the purpose of getting your code to compile.

Throwing exceptions means your assertions never get executed in RGR until you attempt to make a passing test, in which case you still haven’t proven your test to be correct. If you don’t know that your test is correct, you have two points of failure: your test, and code under test.

That’s why I’ve set ReSharper to return default values instead of throw exceptions. I want meaningful failures from a valid test, otherwise I’m better off skipping the Red step altogether.

More missing LINQ operators

2009-10-16T03:19:55Z

Continuing an old post on missing LINQ operators, the wonders of extension methods allow us as developers to fill potential holes in LINQ operators. Whether it’s a Zip method (now included in .NET 4.0), or better methods for IComparer-based operators, I find myself adding more and more helpful LINQ operators, I wish were already in the framework.

Alternate

Do you ever want to weave two collections together, like shuffling a deck of cards? Well I know I do! Suppose we have this collection:

[1, 3, 5]

And this collection:

[2, 4, 6]

I’d like to create new collection that is the alternating items from the first and second list:

[1, 2, 3, 4, 5, 6]

Here’s the code to do it:

public static IEnumerable<TSource> Alternate<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
{
    using (IEnumerator<TSource> e1 = first.GetEnumerator())
    using (IEnumerator<TSource> e2 = second.GetEnumerator())
        while (e1.MoveNext() && e2.MoveNext())
        {
            yield return e1.Current;
            yield return e2.Current;
        }
}

Very simple, I iterate both enumerables at the same time, yielding the first, then second collection’s current item. So how is this useful? How about this action:

[Test]
public void Word_play()
{
    var source = new[] {"The", "quick", "brown", "fox"};

    var result = source.Alternate(Spaces()).Aggregate(string.Empty, (a, b) => a + b);

    result.ShouldEqual("The quick brown fox ");
}

private IEnumerable<string> Spaces()
{
    while (true)
        yield return " ";
}

I cheated a little bit with an infinite sequence (the Spaces() method), but I found this method useful when I had to split, then reconstruct new sequences of strings.

Append

I really hate this syntax:

[Test]
public void Bad_concat_method()
{
    var ints = new[] {1, 2, 3};

    var oneToFour = ints.Concat(Enumerable.Repeat(4, 1));

    CollectionAssert.AreEqual(new[] { 1, 2, 3, 4 }, oneToFour.ToArray());
}

I want to just stick an item on the end of an existing collection, but I have to use this arcane Enumerable.Repeat method to do so. Instead, let’s create an operator that lets us tack an item on to the end of a collection:

public static IEnumerable<TSource> Append<TSource>(this IEnumerable<TSource> source, TSource element)
{
    using (IEnumerator<TSource> e1 = source.GetEnumerator())
        while (e1.MoveNext())
            yield return e1.Current;

    yield return element;
}

Now our code becomes much easier to understand:

[Test]
public void Easier_concat_with_append()
{
    var ints = new[] {1, 2, 3};

    var oneToFour = ints.Append(4);

    CollectionAssert.AreEqual(new[] { 1, 2, 3, 4 }, oneToFour.ToArray());
}

Prepend

Append wouldn’t be complete without the converse, Prepend, now would it?

public static IEnumerable<TSource> Prepend<TSource>(this IEnumerable<TSource> source, TSource element)
{
    yield return element;

    using (IEnumerator<TSource> e1 = source.GetEnumerator())
        while (e1.MoveNext())
            yield return e1.Current;
}

Now putting something on the beginning of a list is easier as well:

[Test]
public void Easier_concat_with_prepend()
{
    var ints = new[] {1, 2, 3};

    var zeroToThree = ints.Prepend(0);

    CollectionAssert.AreEqual(new[] { 0, 1, 2, 3 }, zeroToThree.ToArray());
}

Much more readable. I have a few more around replacing the IEqualityComparer<T> overloads, but those are a little bit more esoteric in their examples of crazy set-based logic. What’s really cool about all these methods is they still allow all sorts of fun chaining, allowing me to create very terse chains of operations on lists, with what would have taken a bazillion cryptic for..each loops. Cool stuff!

Thanks Arkansas!

2009-10-16T02:01:17Z

This week I made the drive from Austin to Fort Smith and Springdale, Arkansas to speak at the Fort Smith DNUG and the Northwest Arkansas DNUG on UI testing ASP.NET MVC. Although I showed tools such as WatiN and Gallio, I focused more on design for UI testability, and covered items such as:

Site navigation
Filling out forms
Verifying results

We stepped through a working, but horribly fragile UI test, and walked through how we can put in a few design techniques to share knowledge between view design and the UI test. Hopefully, my message of “ban test recorders” gets through to someone, as the UI test recorder is something that threw me off for years on creating maintainable UI tests.

You can find the slides and code here:

Testing the last mile in ASP.NET MVC

Thanks to all the guys in Arkansas for the great conversations, and I hope to see everyone soon! One parting shot from a trip to Devil’s Den:

My jeans were soaked up to my knees from that hike…

Diwali or Deepavali – The grand festival of India

2009-10-15T19:49:56Z

As the month of October proceed, 1 billion people from all around the world are busy preparing for their grand festival; The Diwali. It’s bit of misfortune for some of my friends here in America, that they have no idea about what 1 in every 6 person on the earth, is busy celebrating with. Why not to take this as opportunity to tell them about social as well as spiritual significance behind the festival? There is my 2 cents :)

Diwali, which is also known as Deepavali, is a festival of lights. These light signifies enlightenment, joy of victory of Dharma(implies as truth or good) over Adharma (implies as darkness, bad or evil). The day of festival also mark end of year as per Vikram Samvat Calendar, one of the oldest calendar in the history of man kind.(The Vikram Samvat was founded by the emperor Vikramaditya of Ujjain^[1] following his victory over the Sakas in 56 BC. More accurately, this calendar is 56.7 years ahead (in count) of the solar calendar).

Deepavali is Sanskrit word which means “row of light” (Deep means light and Avali means row). It teach us to drive way darkness by spreading light of knowledge. Spiritually, it is the day when Lord Ram returned to Ayodhya after completing His 14 year of exile (referred as Vanvas in Indian literature) and His victory over Ravana. Full of joy, people of Ayodhya welcomed their king by lighting rows(avali) of lamps(deep) and hence the name Deepavali. Just as we celebrate birth of oneself, Deepavali is for celebration of inner light which outshines all darkness or ignorance and awakening us to know our true nature; far far away from just physical existence.

To celebrate the occasion, people light oil lamps in and around their house and set off firecrackers. People paint and clean their homes, buy new clothes and distribute sweets to their relatives and friends. By spreading light in every corner of our premises, we try to destroy the reign of darkness, on the night of Diwali. People decorate their premises with diyas, electric bulbs and other decorative electric lighting fixtures, to make their surroundings filled with colorful light and to make it bright and beautiful. Many interesting rituals and traditions have been attached to the celebrations of Diwali. Fire crackers are burst and people enjoy wearing new clothes, on the auspicious day.

Diwali is a five-day long festival, which is celebrated with fun and fervor.

The first day of Diwali is known as 'Dhanteras' which is the thirteenth lunar day of Krishna Paksha, of the Hindu month of Kartik. Lord Dhanwantari came out of the ocean with Ayurvedic on this day for the welfare of the mankind. People renovate, decorate their houses on this day and make traditional 'Rangoli' on the entrance, to welcome Goddess Lakshmi. Lamps and candles are lit throughout the night. It is considered auspicious to buy gold and silver on this day. Many people opt for buying new utensils on this day.

The second day of Diwali is Narak Chaturdashi.Lord Krishna killed the demon Narakasur on this day to make the mankind free from his fear. It is a tradition to massage the body with oil and to bathe on this day. According to an interesting saying it is believed that those who do not bathe on this day go to the Narak (hell).

The third day is the main day of the Diwali festival.On this day, people wear new clothes and share gifts and sweets with their friends and relatives. Women prepare delicacies and whole house is illuminated with 'diyas' and candles. Fireworks and crackers are the kids' favorites on this day. This day signifies end of year.

The forth day is new year day (as per Vikram Samvat). Day starts very early for all devotees as they get ready in their new cloths, visit temple, chant to the GOD, and then wish each other “Sal Mubarak” (i.e. happy new year)

The fifth day of the diwali is Bhai Dooj, the time to honour the brother-sister relationship. On this day, sisters invite their brothers and their family to their homes and treat them with delicacies. In turn, brothers offer them with gifts and sweets. Legends have it that in the Vedic era, Lord Yamaraj (the God of death) visited his sister Yamuna on this day and blessed her with a boon that if brothers visit their sisters on this day then they will be liberated from all their sins. Since then it is a tradition that brothers visit their sisters on this day and the sisters sweeten their mouths with variety of sweets. The celebration of the Bhai Dooj marks the end of the five days long festivities of Diwali.

For the benefit of my American brothers and sisters:

US President Barack Obama has joined the this grand movement by participating in ceremonial Diwali lamp at white house. Although it was Bush era back in 2003 when Diwali celebration began at white house, Obama was the first American president who had fortunate opportunity to personally inaugurate the ceremony.

Finally, for the geeks in Austin, there is great opportunity to personally attend the celebration and thereby know more about the festival. Barsanadham temple is celebrating grand festival on this Saturday, Oct, 17th 2009 beginning at 5:00 PM. Here is the published schedule:

5:00 pm Dinner prasad
6:00 pm Temple tour (in prayer hall)
7:00 pm Temple tour (in prayer hall)
7:30 pm Temple program – State Representatives & community leaders lighting the dias ceremony, kirtan, pravachan, arti
9:00 pm Grand fireworks display
9:30 pm Ras Garba – Live garba singers: Sur Sangam of Hurst, TX

Address: Barsana Dham
(SW of Austin on FM 1826, 7 miles from Hwy 290)
400 Barsana Rd.
Austin, TX 78737
(512)288-7180

I am there along with my friends and family. Be there and be part of “The Light”.

Response: "Agile is treating the symptoms, not the disease" by Ted Neward

2009-10-13T16:00:41Z

Ted Neward, whom I’ve known for about 4 years now, wrote a piece calling out all the complexity that is in the line of business software space these days.

This post is not to say that I agree or disagree, but it is a refreshing blog post to read. I love discussion like this. As the CTO of a consulting company that embraces Extreme Programming for project delivery, I’m continually trying to get better at delivering high-quality, maintainable software.

When reflecting on what Ted calls out that is necessary for my people to know, I’ll quickly add to the list:

· 7zip
· aspnetmvc
· AutoMapper
· cassini
· castle
· CruiseControl.NET
· exceptioneer
· FxCop
· gallio
· msdeploy
· mvccontrib
· naak
· nant
· nantcontrib-0.85
· nbehave
· ncover
· ndepend
· nhibernate
· nunit
· rhinomocks
· SourceMonitor
· structuremap
· subversion
· tarantino
· watin

The funny thing is, we are building tools to make delivering software easier, so we have other things added to the .Net framework. At some point, Microsoft and Oracle need to take a good look at .Net and Java and see how they can raise the abstraction level a bit so that the technical business analyst can have a hope of a small program.

Just like DRM in the music business has found (>80% of music pirates could not be forced to pay for the music), >80% of technical business analysts will not use .Net or Java for their small little app. They will walk away and not write the app. They will instead add just a few more macros to that huge Excel spreadsheet.