Dan Crevier's Blog : PageModel

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

dancre — 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.

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

dancre — Thu, 26 Jul 2007 07:16:49 GMT

In this post, I'm going to give an example of the pattern in action, built on the classes described in the last post. For the example, I've chosen something similar to the rename page on Live Folders. Here's how it should work:

The Url should be of the form http://<server>/rename.aspx?path=<path to item>.
If the item does not exist or the user does not have access, a 404 error should be returned.
If there is any error talking to the back end storage, a 500 error should be returned.
The page should have a text box for the name, prepopulated with the current item name.
There should be a submit button.
On submit, it should rename the item.
- If successful, it should redirect to another page (in my example, I just redirect to the rename page with the new path)
- If the new name has illegal characters, it should show an error inline.

Let's start by looking at the .aspx. Note: The page actually looks horrible. I made no attempt to make it look pretty!

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Rename.aspx.cs" Inherits="PageModelPattern.RenamePage" %>
<%@ Import Namespace="Microsoft.Security.Application" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Rename</title>
</head>
<body>
    <form id="form1" runat="server">
        <asp:Panel runat="server" Visible="<%# !string.IsNullOrEmpty(this.PageModel.ErrorString) %>">
            <span style="color: Red"><%# this.PageModel.ErrorString %></span>
        </asp:Panel>
    
        <div>Name: <input name="name" value="<%# AntiXss.HtmlAttributeEncode(this.PageModel.Name) %>" /></div>
        <div><asp:Button runat="server" Text="Submit" /></div>
    </form>
</body>
</html>

Notice that the page uses the <%# %> binding syntax. For more information about this, see my previous post. Basically, the expression inside will be evaluated when the page is data bound. This happens after the model has been loaded by PageModelBasedPage. In these expressions, we can access public properties exposed by the mode. We use two properties here. The first it the error string. We have an <asp:Panel> that's visible when the error string is non empty or null. In that case, it will render as a div. There is also an <input> field for the name which is populated from this.PageModel.Name. Since the name will untrusted input, we need to escape it to avoid cross site scripting attacks. I chose to use the Microsoft AntiXss Library.

Now, let's look at the code behind.

    public partial class RenamePage : PageModelBasedPage<RenamePageModel>
    {
        /// <summary>
        /// Create a RenamePageModel.
        /// </summary>
        /// <returns>RenamePageModel.</returns>
        protected override RenamePageModel CreateModel()
        {
            return new RenamePageModel(new DataAccess(), this.Request.QueryString["path"]);
        }

        /// <summary>
        /// Collect data about a post back.
        /// </summary>
        protected override void CollectPostData()
        {
            base.CollectPostData();

            this.PageModel.Name = this.Request.Form["name"];
        }
    }

It's very simple, but that's the point! This is the code we can't unit test. CreateModel creates the RenamePageModel. I'll go into the DataAccess part in a moment. The other thing it passes in is the path, which it grabs from the query string. The other thing it does is populate the name property in the model on a postback from the form value.

To abstract the access to the data layer, I created a simple interface for the purpose of this demo:

    public interface IDataAccess
    {
        /// <summary>
        /// Get the name of an item from its path.
        /// </summary>
        /// <param name="path">The path to the item.</param>
        /// <returns>The item name.</returns>
        /// <exception cref="FileNotFoundExcetion">If the item does not exist.</exception>
        /// <exception cref="UnauthorizedAccessException">If the user does not have read access to the item.</exception>
        /// <exception cref="IOException">General i/o exception.</exception>
        string GetItemName(string path);

        /// <summary>
        /// Sets the name of an item.
        /// </summary>
        /// <param name="path">The path to the item.</param>
        /// <param name="newName">The new name.</param>
        /// <returns>The new path.</returns>
        /// <exception cref="FileNotFoundExcetion">If the item does not exist.</exception>
        /// <exception cref="ArgumentException">If the new name is invalid.</exception>
        /// <exception cref="UnauthorizedAccessException">If the user does not have write access to the item.</exception>
        /// <exception cref="IOException">General i/o exception.</exception>
        string SetItemName(string path, string newName);
    }

The functions should be pretty self explanatory based on the comments above. The most important part is the exceptions they can throw because the model depends on these. It's abstracted through an interface so that it can be mocked out when unit testing the page model. DataAccess is a placeholder implementation I created for this sample. I won't include the source for it here, but I'll include it in the project that I'll post when I finish the series.

Now, here's the page model. It has the real business logic that we'll be able to unit test:

    public class RenamePageModel : PageModel
    {
        public RenamePageModel(IDataAccess dataAccess, string path)
        {
            _dataAccess = dataAccess;
            _path = path;
        }

        /// <summary>
        /// Gets the name to display in the UI or sets the name to rename to.
        /// </summary>
        public string Name
        {
            get { return _nameToDisplay; }
            set { _newName = value; }
        }

        /// <summary>
        /// The error string to display (or null)
        /// </summary>
        public string ErrorString
        {
            get { return _errorString; }
        }

        /// <summary>
        /// Called when the page loads.
        /// </summary>
        protected override void OnLoaded()
        {
            if (this.PageContext.IsPost)
            {
                HandlePost();

            }
            else
            {
                try
                {
                    // Get the name of the item.
                    _originalName = _dataAccess.GetItemName(_path);
                }
                catch (FileNotFoundException)
                {
                    // The item does not exist.
                    this.PageContext.ThrowPageNotFound();
                }
                catch (UnauthorizedAccessException)
                {
                    // The user does not have access.
                    this.PageContext.ThrowPageNotFound();
                }
                catch (IOException)
                {
                    // Some other error.
                    this.PageContext.ThrowServerError();
                }

                _nameToDisplay = _originalName;
            }
        }

        /// <summary>
        /// Handle a post by renaming the item.
        /// </summary>
        private void HandlePost()
        {
            try
            {
                string newPath = _dataAccess.SetItemName(_path, _newName);
                // Redirect to next page - just back to the rename page with the new path
                // for the purpose of this example.
                this.PageContext.Redirect("rename.aspx?path=" + AntiXss.UrlEncode(newPath));
            }
            catch (FileNotFoundException)
            {
                // The item does not exist.
                this.PageContext.ThrowPageNotFound();
            }
            catch (UnauthorizedAccessException)
            {
                // The user does not have access.
                this.PageContext.ThrowPageNotFound();
            }
            catch (IOException)
            {
                // There was some other error.
                this.PageContext.ThrowServerError();
            }
            catch (ArgumentException)
            {
                // The new name has illegal characters.
                _errorString = "The name has illegal characters.";
                _nameToDisplay = _newName;
            }
        }

        private IDataAccess _dataAccess;
        private string _path;
        private string _newName;
        private string _originalName;
        private string _nameToDisplay;
        private string _errorString;
    }

Hopefully the code is pretty straightforward to read. It basically follows the requirements I outlined at the beginning of the post.

The result is that we have straightforward data binding in the .aspx and .aspx.cs which we can't unit test, and a model that only depends on IPageContext and IDataAccess which we can easily mock out for unit testing. The next post will wrap things up by showing some unit tests.

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

dancre — Tue, 24 Jul 2007 07:13:56 GMT

In part 1, I gave an overview of the pattern. In this part, I will describe some of the core classes. Let's start off with the PageModel itself. It's the most simple. It is an abstract class. Subclasses must implement OnLoaded. It has an associated IPageContext (see below) that the model will use to interface with the page.

    public abstract class PageModel
    {
        /// <summary>
        /// The context associated with the model.
        /// </summary>
        protected IPageContext PageContext
        {
            get { return _pageContext; }
        }

        /// <summary>
        /// Called to load the page model.
        /// </summary>
        /// <param name="pageContext">The page context.</param>
        public void Load(IPageContext pageContext)
        {
            _pageContext = pageContext;
            OnLoaded();
        }

        /// <summary>
        /// Override to provide behavior for the model.
        /// </summary>
        protected abstract void OnLoaded();

        private IPageContext _pageContext;
    }

The IPageContext will allow the model to get some Asp.net specific information about the page and to do some Asp.net specific operations. When unit testing, a mock implementation of IPageContext can be used to test the model in isolation. IPageContext looks like this:

    public interface IPageContext
    {
        /// <summary>
        /// Gets if the connection is secure.
        /// </summary>
        bool IsSecureConnection { get; }

        /// <summary>
        /// Gets if this is a post.
        /// </summary>
        bool IsPost { get; }

        /// <summary>
        /// Throws a page not found exception.
        /// </summary>
        void ThrowPageNotFound();

        /// <summary>
        /// Throws a server error.
        /// </summary>
        void ThrowServerError();

        /// <summary>
        /// Redirects to another page. Note: Execution continues after this call.
        /// </summary>
        /// <param name="destination">Page to redirect to.</param>
        void Redirect(string destination);

        /// <summary>
        /// Has a redirect taken place?
        /// </summary>
        bool HasRedirected { get; }
    }

Note: This interface can be extended as needed. The interface here is a simple starting point.

Now, let's look at PageModelBasedPage, which is a base class for pages that will use PageModels. It's a generic class, parametized by the PageModel subclass. Subclasses of PageModelBasedPage must implement CreateModel to actually create the model. When the page is loaded, it will create the model with an AspPageContext. If it's a post, it will call a function CollectPostData() which can be overridden to collect post data. Finally, when the page load process is finished, it will do data binding on the page, unless there's been a redirect, in which case it will hide the controls on the page to avoid any unnecessary rendering.

    public abstract class PageModelBasedPage<ModelType> : Page where ModelType : PageModel
    {
        protected PageModelBasedPage()
        {
            this.LoadComplete += OnLoad;
            this.PreRenderComplete += OnPreRenderComplete;
        }

        /// <summary>
        /// Derived class must implement CreateModel and return the model.
        /// </summary>
        /// <returns>PageModel subclass.</returns>
        protected abstract ModelType CreateModel();

        /// <summary>
        /// Base classes can override for any special data binding.
        /// </summary>
        protected virtual void DoDataBinding()
        {
            if (_pageContext.HasRedirected)
            {
                // No need to render the page on a redirect.
                this.Visible = false;
            }
            else
            {
                this.DataBind();
            }
        }

        /// <summary>
        /// Derived class can do any manipulation of the Form values and set properties
        /// on the PageModel after a post.
        /// </summary>
        protected virtual void CollectPostData()
        {
        }

        /// <summary>
        /// The current page model for the page.
        /// </summary>
        protected ModelType PageModel
        {
            get { return _model; }
        }

        /// <summary>
        /// Called by Asp.net when the page loads.
        /// </summary>
        private void OnLoad(object sender, EventArgs e)
        {
            _model = CreateModel();
            _pageContext = new AspPageContext(this);

            if (_pageContext.IsPost)
            {
                // WARNING: You may be vulerable to cross site request forgery attacks
                // if you do not implement some sort of canary. For more info, see:
                // http://en.wikipedia.org/wiki/Csrf
                CollectPostData();
            }

            _model.Load(_pageContext);
        }

        /// <summary>
        /// Called by Asp.net when page loading is complete (including any asynchronous
        /// tasks)
        /// </summary>
        private void OnPreRenderComplete(object sender, EventArgs e)
        {
            DoDataBinding();
        }

        private ModelType _model;
        private AspPageContext _pageContext;
    }

As mentioned in the code, as written, this code is vulnerable to cross site request forgery attacks. The solution to this issue will depend on your application.

By using OnPreRenderComplete, our pattern is compatible with Asp.net's asynchronous pattern. I can write more about that if there is interest.

AspPageContext, the IPageContext used by PageModelBasedPage is as follows:

    public class AspPageContext : IPageContext
    {
        public AspPageContext(Page page)
        {
            _page = page;
        }

        public bool IsSecureConnection
        {
            get { return _page.Request.IsSecureConnection; }
        }

        public bool IsPost
        {
            get { return _page.IsPostBack; }
        }

        public void ThrowPageNotFound()
        {
            throw new HttpException(404, "Page not found.");
        }

        public void ThrowServerError()
        {
            throw new HttpException(500, "Server error.");
        }

        public void Redirect(string destination)
        {
            _page.Response.Redirect(destination);
            _hasRedirected = true;
        }

        public bool HasRedirected
        {
            get { return _hasRedirected; }
        }

        private Page _page;
        private bool _hasRedirected;
    }

That's it for the basics! To use the pattern, you need to:

Create a PageModel subclass with the business logic for the page.
Derive your Page from PageModelBasedPage.
Populate any data in the model at creation time or in CollectPostData.
Use databinding on the page to bind the results to the UI.

The next part will contain a full example.

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

dancre — Sat, 21 Jul 2007 07:35:02 GMT

I previously blogged about the pattern we used in our WPF application to separate business logic from the presentation, making the business logic view and data models highly unit testable. Now that I'm working on Asp.net code for Live Folders, we've worked to come up with a similar model that separates the business logic from the presentation. The model we use may not apply to everyone, but I thought I'd present it in a series of posts to hopefully help people out and to get some good feedback.

Live Folders is a pretty basic (Web 1.0!) type application that doesn't make heavy use of client-side JavaScript. It also doesn't use view state or any of the complex Asp.net controls. If your application model is significantly different, this pattern may not work for you.

This pattern breaks a page into two parts. The PageModel is the unit testable business logic for the page, which has no Asp.net dependencies. Then, there's the Page subclass, which collects data about the request (query parameters, form post values, etc), runs the model, and then binds data from the model into its controls. The Page subclass is not unit testable because of its Asp.net dependencies (the Asp.net code should tested with scenario tests that automate the browser).

The PageModel may need to do things like redirect the user or throw a page not found error. These sorts of Asp.net dependencies are abstracted out with an interface called IPageContext. A mock implementation is used for unit testing, and an Asp.net specific implementation is used in the real pages.

This series will consist of the following parts:

Part 2: The core classes (PageModel, PageModelBasedPage, IPageContext)

Part 3: An example

Part 4: Unit testing the example

The resulting code is available at http://folders.live.com/self.aspx/+drExD6aaB0/Blog/PageModelPattern.zip.