LogoASPAlliance: Articles, reviews, and samples for .NET Developers
Building a Simple Blog Engine with ASP.NET MVC and LINQ - Part 4
by Keyvan Nayyeri
Average Rating: This article has not yet been rated.
Views (Total / Last 10 Days): 732915/ 867


In the first three parts of this series I talked about some major aspects of MVC pattern, ASP.NET MVC Framework and KBlog (the simple blog engine that is being created in this series as a showcase). So far, I discussed controller and data model as two of the three main components in Model View Controller (MVC) pattern.

The main reason for the popularity and demand for MVC pattern among web developers (not only ASP.NET developers) is the fact that MVC enables testing capabilities for developers to easily test their web applications. So MVC brings Test-Driven Development (TDD) to web applications, which is a very common and popular way to develop software these days.

Of course, there are some ways to unit test your traditional web applications, but things get much easier with MVC pattern.

The topic of this part and the next part is unit testing. In MVC pattern you can test your application easily and just by testing your controller classes. Here I show you how to unit test your MVC applications, but before that we need to get started with some theoretical concepts in this part.

Before digging into the main body of this part, let me point out that the first three parts of this article series were written based on the first public version and CTP of ASP.NET MVC Framework while this part is written based on the second CTP that you can download from here.

A Short Overview of Unit Testing

Test-Driven Development (aka TDD) is nowadays the most common way to develop software among architects and developers. Raise of Agile development methodologies and the growing number of small software teams is the main reason to choose TDD as the main option for developing software (of course there are some other reasons as well).

I suppose that you (as readers of this article) have a background in TDD and unit testing from the past because there is no doubt that I cannot teach you such stuff here, but a short related introduction to the topic of this article is mandatory.

The main and most common part of TDD is unit testing. Unit testing is a process and a set of techniques to divide an application into smaller (small) units that are independent from each other and can work isolated then test each unit to make sure it works as expected.

Unit testing works based on some principles. The first one is breaking the application into small pieces which lets you examine their working easily. The second principle is the fact that these units are isolated and work independently from others. This isolation lets you change a unit without having any effect on another unit.

Unit testing techniques test these pieces to see if each piece works as expected for different situations and input data. In this case, once you pass all tests, you can move on to the next stage in your development. But the good point is the fact that if you change other elements and units of the code then they would not break your existing code and if they do (which is not surprisingly unexpected) then your existing tests will fail and alert you about a problem.

So you can go back and forth and refractor your code without breaking existing code and consistency of your code and this is the main reason that many developers have chosen this as their primary process for development.

However, I cannot talk much about Test-Driven Development and unit testing here and I should not, of course. But I just want to say that there are various techniques for unit testing data layer, abstract code or web services. There are also some well-documented patterns and practices on how to write your code to make the unit testing process easier.

Why MVC and Why ASP.NET MVC?

Web development is a common development scenario which requires its own techniques and patterns. Since web development in many server technologies is strongly correlated with some stuff, like web server properties or client request details, then software developers had to find a way to reduce these dependencies. Regarding the above introduction, you would know why?

The reason is the isolation. We have to reduce these dependencies to improve the isolation level. So what was the solution? The solution was the introduction of new development patterns including Model View Controller (MVC). The most famous technology that is designed for MVC pattern is Ruby on Rails and one of its amazing popularity reasons is from here.

This evolvement in web development technologies forced Microsoft to think about an adaption of this pattern for its ASP.NET technology and the result was the introduction of ASP.NET MVC framework.

So in a nutshell:

·         Unit testing is great (and in my opinion is a mandatory part of development for today's software)!

·         Unit testing requires a high level of abstraction and isolation between different units of the application.

·         Unit testing also requires that you reduce the dependencies between your built-in platform objects to be able to create and raise them independently.

·         Traditional ASP.NET web form applications had some strong dependencies between some objects like HttpContext, HttpRequest and HttpRequest.

·         Microsoft had to adapt MVC for its web development technology.

·         Microsoft had to reduce all those dependencies and improve the isolation level.

·         So Microsoft had to build ASP.NET MVC pattern with new considerations for isolation and abstraction.

So ASP.NET MVC framework comes with new designs for some main ASP.NET classes like HttpContext, HttpResponse or HttpRequest and of course, follows MVC pattern.

Abstraction and Isolation in ASP.NET MVC

We need a good level of abstraction and isolation, but how we can achieve it in our design and code? This is possible via abstract base classes and interfaces because both these concepts provide some level of abstraction for us.

Unit testing is tight to abstract base classes and interfaces and there are lots of patterns and practices around these. I do not want to step into this topic here.

When you use abstract base classes and interfaces for abstraction then you are able to test instances of these classes easily because they all have some main methods that you need to call and use. This is very helpful when unit testing because it gives you much control on the classes that play a role in your testing units.

But how does one choose between abstract base classes and interfaces? Even though they both provide abstraction for us, each of them has some limitations for its own.

Phil Haack, my dear friend and a member of ASP.NET MVC team at Microsoft, has some blog posts that explain these limitations and what they faced with usage of interfaces in first CTP of ASP.NET MVC framework that forced them to switch to abstract base classes in the second CTP and most likely all the future versions.

·         Versioning Issues With Abstract Base Classes and Interfaces

·         Abstract Base Classes Have Versioning Problems Too

·         The Cost Of Breaking Changes

From an end user point of view, you may not care much about such stuff though!

But finally Microsoft applied abstract base classes for abstraction purposes in the second public release of ASP.NET MVC.

You see that these changes help you to unit test an ASP.NET MVC application in the next sections of this article.

Microsoft has moved all these abstractions and classes to a new assembly called System.Web.Abstractions so you can traverse through the classes in this assembly to see what is there.

Figure 1 shows all these classes with their hierarchy and structure which can give you some thoughts about this abstraction level.

Figure 1

As you see, here there are seven pairs of base classes and some classes that derive from them. All these abstract base classes are representing some traditional ASP.NET classes that had many dependencies. So this abstraction can help the unit testing process as you will notice this later in the next part.

But in a nutshell, we can group these classes into seven categories:

·         HttpSessionState

·         HttpServerUtility

·         HttpContext

·         HttpResponse

·         HttpRequest

·         HttpBrowserCapabilities

·         HttpCachePolicy

As you see, all these categories are strongly tight to server, client properties and characteristics, but this new abstraction helps to reduce these dependencies and improve the testability.

Testing Process in MVC Pattern

But what is the testing process in MVC pattern for ASP.NET MVC? Model View Controller pattern is designed in a way to simplify the testing process by dividing the architecture of the application into independent components (Model, View and Controller). The philosophy behind MVC is to break the application in these components to limit the unit testing to Controller component.

In other words, MVC is designed in a way that you only need to unit test your controller classes and this is all the point.

Controller is a pure programming class and nothing more. On the other hand, it is completely independent from data model and views (data layer and user interface) and here you notice the point. This independence helps you to test your application just by testing the controller as a programming class.

I will show you how to unit test controllers in the next part.

Improved Testing Features in ASP.NET MVC Preview 2

The new version of ASP.NET MVC framework (Preview 2) comes with some new major features that improve the testing capabilities for developers. One of these major changes is the ability to create an integrated unit test project for your ASP.NET MVC projects when you create them. Prior to this, you had to create an ASP.NET MVC project then create a unit test project for your code manually. But now Visual Studio asks you to choose if you want to create a new Visual Studio unit test project for your code.

This is shown in Figure 2. After creating an ASP.NET MVC project this dialog shows up to ask you whether you want to create the test project or not.

Figure 2

Of course you can ignore this and not create a unit test project.

On the other hand, Visual Studio test framework (known as MsTest) is not the only choice for you. There are many professional developers who like and prefer other testing frameworks like NUnit (adaption of xUnit for .NET) or MbUnit that are both very well-known among .NET developers and you can use them.

Other Parts

The fourth part of this article series was all about unit testing concepts to enable Test-Driven Development in your ASP.NET MVC applications, which is the primary benefit behind MVC pattern.

I started with an introduction to the importance of unit testing in MVC pattern and then gave a quick overview of unit testing and its main goals then stepped into the process that led to build ASP.NET MVC framework. After that I talked about the necessity of abstractness and isolation in MVC pattern and how this is achieved in ASP.NET MVC framework.

In this part I did not talk about anything related to KBlog and left all the applications of these theoretical concepts to the next part. Having a solid understanding of unit testing concepts should be an important part of your knowledge when working with MVC pattern and ASP.NET MVC framework.

In the next part of this series, I will unit test controllers in KBlog to see these theories in action.

Product Spotlight
Product Spotlight 

©Copyright 1998-2021  |  Page Processed at 2021-01-24 11:24:27 PM  AspAlliance Recent Articles RSS Feed
About ASPAlliance | Newsgroups | Advertise | Authors | Email Lists | Feedback | Link To Us | Privacy | Search