Setting up StructureMap and The Unit Of Work ActionFilter

UnitOfWork ActionFilter

In my previous post I had created the repository implementations along with unit of work. But how do we use this unit of work in our application. ASP.NET MVC has a concept of ActionFilters. These could be applied to an action or a controller in general. The two main methods that concern us are OnActionExecuting and the OnActionExecuted. As seen in the code below we call the initialize method of the unit of work which would create a new transaction for us and this is held until the action is complete after which we commit the transaction. We are getting a new instance of _unitOfWork through an IoC container which I will talk about in a bit.

namespace MPBlog.Web.UI.ActionFilters
{
    using System;
    using System.Web.Mvc;
    using Core.BaseClasses;
    using StructureMap;
 
    public class UseUnitOfWOrkAttribute : ActionFilterAttribute
    {
        private readonly IUnitOfWork _unitOfWork;
 
        public UseUnitOfWOrkAttribute()
        {
            _unitOfWork = ObjectFactory.GetInstance<IUnitOfWork>();
        }
 
        public UseUnitOfWOrkAttribute( IUnitOfWork unitOfWork )
        {
            _unitOfWork = unitOfWork;
        }
 
        public override void OnActionExecuting( ActionExecutingContext filterContext )
        {
            _unitOfWork.Initialize();
        }
 
        public override void OnActionExecuted( ActionExecutedContext filterContext )
        {
            try
            {
                _unitOfWork.Commit();
            }
            catch( Exception )
            {
                _unitOfWork.Rollback();
                throw;
            }
            finally
            {
                _unitOfWork.Dispose();
            }
        }
    }
}

We use this action filter either by decoration individual action with the attribute or if we want all actions to use the unit of work, then we can decorate the class itself with the attribute. In the following code I am using the UseUnitOfWork filter on the Index action.

namespace MPBlog.Web.UI.Controllers
{
    using System.Web.Mvc;
    using ActionFilters;
    using Core.Services;
 
    [HandleError]
    public class HomeController : Controller
    {
        private readonly IBlogService _blogService;
 
        public HomeController(IBlogService blogService)
        {
            _blogService = blogService;
        }
 
        [UseUnitOfWOrk]
        public ActionResult Index()
        {
            var posts = _blogService.GetAllPosts();
            return View(posts);
        }
    }
}

Attributes may look a bit intrusive (atleast for me). I like how FubuMVC handles this. In FubuMVC, we have something called behaviors and this can be configured in the application start. So if we want all our actions to use the unit of work, then we can set the behavior as shown below and that's it, no more attributes on the action or controller. In the following code the access_the_database_through_a_unit_of_work has the same implementation as the filter we created.

ControllerConfig.Configure = x =>
{
    // Default Behaviors for all actions -- ordered as they're executed
    /////////////////////////////////////////////////
    x.ByDefault.EveryControllerAction(d => d
        .Will<access_the_database_through_a_unit_of_work>()
        );
};

Services

Instead of accessing the repository directly from the controllers, I have created a separate service which delegates the work to the repository to the operations related. Following is an example of a blog service. I have kept the methods to be minimal for brevity.

namespace MPBlog.Core.Services
{
    using System.Collections.Generic;
    using Domain;
 
    public interface IBlogService
    {
        IEnumerable<Post> GetAllPosts();
        IEnumerable<Post> GetPostsByTag(string tag);
        Post GetPostById( int postID );
        Post GetPostBySlug( string slug );
 
        void SavePost( Post post );
        void UpdatePost( Post post );
        void DeletePost( Post post );
    }
}

namespace MPBlog.Core.Services
{
    using System.Collections.Generic;
    using System.Linq;
    using BaseClasses;
    using Domain;
 
    public class BlogService : IBlogService
    {
        private readonly IRepository _repository;
 
        public BlogService( IRepository repository )
        {
            _repository = repository;
        }
 
        public IEnumerable<Post> GetAllPosts()
        {
            return _repository.Query<Post>().AsEnumerable();
        }
 
        public IEnumerable<Post> GetPostsByTag( string tag )
        {
            return
                _repository.Query<Tag>( t => t.Description.Equals( tag ) ).
                    SingleOrDefault().Posts;
        }
 
        public Post GetPostById( int postId )
        {
            return _repository.Load<Post>( postId );
        }
 
        public Post GetPostBySlug( string slug )
        {
            return _repository.Query<Post>( p => p.PostSlug.Equals( slug ) ).SingleOrDefault();
        }
 
        public void SavePost( Post post )
        {
            _repository.Save( post );
        }
 
        public void UpdatePost( Post post )
        {
            _repository.Save( post );
        }
 
        public void DeletePost( Post post )
        {
            _repository.Delete( post );
        }
    }
}

Dependency Injection using StructureMap

If we look at the all the code that has been shown till now, we see that, there is almost always an interface declared and we can nowhere see a direct instantiation of the object that is required. So how do we get a new instance of an object. This is where an Inversion Of Control (IoC/DI)  container comes into play. Basically what it does is to give you a concrete objects whenever we require.

I have used constructor injection where ever possible. How it works is, by defining our own ControllerFactory and create the controller ourselves instead of ASP.NET MVC doing it for us. In the below code I have a StrucutreMapControllerFactory from where I am getting an instance of the controller. This factory inherits from the DefaultControllerFactory for ASP.NET MVC and we override the controller building method.

namespace MPBlog.Web.UI.Controllers
{
    using System;
    using System.Web.Mvc;
    using StructureMap;
 
    public class StructureMapControllerFactory : DefaultControllerFactory
    {
        protected override IController GetControllerInstance(Type controllerType)
        {
            IController result = null;
            if (controllerType != null)
            {
                try
                {
                    result = ObjectFactory.GetInstance(controllerType) as Controller;
 
                }
                catch (StructureMapException)
                {
                    System.Diagnostics.Debug.WriteLine(ObjectFactory.WhatDoIHave());
                    throw;
                }
            }
            return result;
        }
    }
}

We set this controller factory in our Application_Start method in the global.asax file like so.

RegisterRoutes( RouteTable.Routes );
Bootstrapper.Bootstrap();
ControllerBuilder.Current.SetControllerFactory(
    new StructureMapControllerFactory());

namespace MPBlog.Web.UI
{
    using StructureMap;
 
    public class Bootstrapper : IBootstrapper
    {
        public void BootstrapStructureMap()
        {
            ObjectFactory.Initialize( x => x.AddRegistry( new MPBlogRegistry() ));
        }
 
        public static void Bootstrap()
        {
            new Bootstrapper().BootstrapStructureMap();
        }
    }
}

using System.Configuration;
 
namespace MPBlog.Web.UI
{
    using Core.BaseClasses;
    using Core.Services;
    using FluentNHibernate;
    using Persistence;
    using Persistence.Config;
    using Persistence.RepositoryImpl;
    using Persistence.UnitOfWork;
    using StructureMap.Attributes;
    using StructureMap.Configuration.DSL;
 
    public class MPBlogRegistry : Registry
    {
        public MPBlogRegistry()
        {
            ForRequestedType<ISessionSource>().AsSingletons()
                .TheDefault.Is.ConstructedBy( context =>
                    context.GetInstance<ISessionSourceConfiguration>()
                    .CreateSessionSource( new MPBlogPersistenceModel() ) );
 
            ForRequestedType<ISessionSourceConfiguration>().AsSingletons()
                .TheDefault.Is.OfConcreteType<SQLSessionSourceConfiguration>()
                .WithCtorArg( "connectionString" )
                    .EqualTo( ConfigurationManager.ConnectionStrings["MPBlog"].ConnectionString )
                .WithCtorArg( "resetDb" )
                    .EqualToAppSetting( "reset" );
 
            ForRequestedType<IUnitOfWork>()
                .TheDefault.Is.ConstructedBy( context => context.GetInstance<INHibernateUnitOfWork>() );
 
            ForRequestedType<INHibernateUnitOfWork>().CacheBy( InstanceScope.Hybrid )
                .TheDefault.Is.OfConcreteType<NHibernateUnitOfWork>();
 
            ForRequestedType<IRepository>().AsSingletons()
                .TheDefault.Is.OfConcreteType<NHRepository>();
 
            ForRequestedType<IBlogService>().AsSingletons()
                .TheDefault.Is.OfConcreteType<BlogService>();
        }
    }
}

Once this is done whenever we ask for a instance of an object, the IoC toll will lookup and give us the concerned concrete object.

Thats it for now.

In my previous post we looked at the domain model and the class maps associated with it. In this post lets look at the Repository and Unit Of Work implementations.

Note: The following is based on the FubuMVC contrib project.

IRepository

A repository is an abstraction layer which gives your application an in memory domain object collection. This layer helps in making you application agnostic about where the data is coming from or where it is persisted into. It could well be a flat file or any other RDBMS. Preferably each of your domain object would have its own repository. But for the sake of keeping it simple, I am using a generic repository in the following code.

namespace MPBlog.Core.BaseClasses
{
    using System;
    using System.Linq;
    using System.Linq.Expressions;
 
    public interface IRepository
    {
        T Load<T>( int id ) where T : Entity<T>;
        void Delete<T>( T target );
        void Save<T>( T target );
        IQueryable<T> Query<T>() where T : Entity<T>;
        IQueryable<T> Query<T>( Expression<Func<T, bool>> whereQuery ) where T : Entity<T>;
    }
}

The Query methods here will be implemented using Linq to NHibernate. Now that we have the interface, lets look at the implementation.

NHRepository

namespace MPBlog.Persistence.RepositoryImpl
{
    using System;
    using System.Linq;
    using System.Linq.Expressions;
    using Core.BaseClasses;
    using NHibernate.Linq;
    using UnitOfWork;
 
    public class NHRepository : IRepository
    {
        private INHibernateUnitOfWork _unitOfWork;
 
        public NHRepository( INHibernateUnitOfWork unitOfWork )
        {
            _unitOfWork = unitOfWork;
        }
 
        public T Load<T>( int id ) where T : Entity<T>
        {
            return _unitOfWork.Session.Load<T>( id );
        }
 
        public void Delete<T>(T target)
        {
            _unitOfWork.Session.Delete( target );
        }
 
        public void Save<T>(T target)
        {
            _unitOfWork.Session.Save( target );
        }
 
        public IQueryable<T> Query<T>() where T : Entity<T>
        {
            return _unitOfWork.Session.Linq<T>();
        }
 
        public IQueryable<T> Query<T>(Expression<Func<T, bool>> whereQuery) where T : Entity<T>
        {
            return _unitOfWork.Session.Linq<T>().Where( whereQuery );
        }
    }
}

If you notice the above code, we are accessing the session through the unitofwork. A unit of work helps in keeping track of all the objects that are affect by a business transaction. Following is the implementation of the UnitOfWork.

IUnitOfWork and INHibernateUnitOfWork

namespace MPBlog.Core.BaseClasses
{
    using System;
 
    public interface IUnitOfWork : IDisposable
    {
        void Initialize();
        void Commit();
        void Rollback();
    }
}

namespace MPBlog.Persistence.UnitOfWork
{
    using Core.BaseClasses;
    using NHibernate;
 
    public interface INHibernateUnitOfWork : IUnitOfWork
    {
        ISession Session { get; }
    }
}

NHibernateUnitOfWork

namespace MPBlog.Persistence.UnitOfWork
{
    using System;
    using FluentNHibernate;
    using NHibernate;
 
    public class NHibernateUnitOfWork : INHibernateUnitOfWork
    {
        private ITransaction _transaction;
        private readonly ISessionSource _source;
        private bool _isDisposed;
        private bool _isInitialized;
 
        public ISession Session { get; private set; }
 
        public NHibernateUnitOfWork( ISessionSource source )
        {
            _source = source;
        }
 
        public void Initialize()
        {
            CheckUoWSanity();
 
            Session = _source.CreateSession();
            StartNewTransaction();
 
            _isInitialized = true;
        }
 
        public void Commit()
        {
            CheckUoWSanity();
            CheckUoWInitialization();
 
            _transaction.Commit();
 
            StartNewTransaction();
        }
 
        public void Rollback()
        {
            CheckUoWSanity();
            CheckUoWInitialization();
 
            _transaction.Rollback();
 
            StartNewTransaction();
        }
 
        public void Dispose()
        {
            if( _isDisposed || !_isInitialized )
                return;
 
            _transaction.Dispose();
            Session.Dispose();
 
            _isDisposed = true;
        }
 
        private void CheckUoWSanity()
        {
            if( _isDisposed )
            {
                throw new ObjectDisposedException( "Trying to use disposed object" );
            }
        }
 
        private void CheckUoWInitialization()
        {
            if( !_isInitialized )
            {
                throw new InvalidOperationException( "NHibernateUnitOfWork is not initialized" );
            }
        }
 
        private void StartNewTransaction()
        {
            if( _transaction != null )
            {
                _transaction.Dispose();
            }
 
            _transaction = Session.BeginTransaction();
        }
    }
}

Tests

Following are the test that were written for both the repository and unitofwork. I am using MoQ as my mocking framework so that I don't have to connect to the actual database when testing.

namespace MPBlog.Tests.Persistence.Tests
{
    using System.Linq;
    using Core.Domain;
    using Moq;
    using MPBlog.Persistence.RepositoryImpl;
    using MPBlog.Persistence.UnitOfWork;
    using NHibernate;
    using Xunit;
 
    public class RepositoryTests
    {
        private Mock<ISession> _session;
        private Mock<INHibernateUnitOfWork> _uow;
        private Mock<NHRepository> _repo;
 
        public RepositoryTests()
        {
            _session = new Mock<ISession>();
            _uow = new Mock<INHibernateUnitOfWork>();
            _uow.Setup( u => u.Session ).Returns( _session.Object );
            _repo = new Mock<NHRepository>( _uow.Object );
        }
 
        [Fact]
        public void Call_to_load_should_load_object_from_the_session()
        {
            var postId = 1;
            _repo.Object.Load<Post>( postId );
            _session.Verify( s => s.Load<Post>( postId ), Times.AtLeastOnce() );
        }
 
        [Fact]
        public void Call_to_save_should_save_object_on_the_session()
        {
            var post = new Post();
            _repo.Object.Save( post );
            _session.Verify( s => s.SaveOrUpdate( post ), Times.AtLeastOnce() );
        }
 
        [Fact]
        public void Call_to_delete_should_delete_object_from_the_session()
        {
            var post = new Post();
            _repo.Object.Delete( post );
            _session.Verify( s => s.Delete( post ), Times.AtLeastOnce() );
        }
 
        [Fact]
        public void Call_to_query_on_session_should_return_an_IQueryable_object()
        {
            Assert.IsAssignableFrom( typeof( IQueryable<Post> ), _repo.Object.Query<Post>() );
        }
    }
}

namespace MPBlog.Tests.Persistence.Tests
{
    using FluentNHibernate;
    using Moq;
    using MPBlog.Persistence.UnitOfWork;
    using NHibernate;
    using Xunit;
 
    public class UnitOfWorkTests
    {
        protected Mock<ISession> _session;
        protected Mock<ITransaction> _transaction;
        protected Mock<ISessionSource> _sessionSource;
        protected Mock<NHibernateUnitOfWork> _uow;
 
        public UnitOfWorkTests()
        {
            _session = new Mock<ISession>();
            _transaction = new Mock<ITransaction>();
            _sessionSource = new Mock<ISessionSource>();
 
            _sessionSource.Setup( s => s.CreateSession() ).Returns( _session.Object );
            _session.Setup( s => s.BeginTransaction() ).Returns( _transaction.Object );
 
            _uow = new Mock<NHibernateUnitOfWork>( _sessionSource.Object );
            _uow.Object.Initialize();
        }
 
        [Fact]
        public void Can_create_new_transaction()
        {
            _session.Verify( s => s.BeginTransaction(), Times.AtLeastOnce() );
        }
 
        [Fact]
        public void Can_dispose_the_transaction()
        {
            _uow.Object.Dispose();
            _transaction.Verify( s => s.Dispose(), Times.Exactly( 1 ) );
        }
 
        [Fact]
        public void Can_dispose_the_session()
        {
            _uow.Object.Dispose();
            _session.Verify( s => s.Dispose(), Times.Exactly( 1 ) );
        }
 
        [Fact]
        public void Call_to_commit_should_commit_the_transaction()
        {
            _uow.Object.Commit();
            _transaction.Verify( t => t.Commit(), Times.AtLeastOnce() );
        }
 
        [Fact]
        public void Call_to_commit_should_dispose_the_transaction_and_start_a_new_transaction()
        {
            _uow.Object.Commit();
            _transaction.Verify( t => t.Dispose(), Times.Exactly( 1 ) );
            _session.Verify( s => s.BeginTransaction(), Times.Exactly( 2 ) );
        }
 
        [Fact]
        public void Call_to_rollback_should_rollback_the_transaction()
        {
            _uow.Object.Rollback();
            _transaction.Verify( t => t.Rollback(), Times.AtLeastOnce() );
        }
 
        [Fact]
        public void Call_to_rollback_should_dispose_the_transaction_and_start_a_new_transaction()
        {
            _uow.Object.Rollback();
            _transaction.Verify( t => t.Dispose(), Times.Exactly( 1 ) );
            _session.Verify( s => s.BeginTransaction(), Times.Exactly( 2 ) );
        }
    }
}

As mentioned in my previous post, this series will no longer be a talk about DDD as a blog app is too trivial to show ( learn ) the power of it. I will be using some of the patterns of DDD though. So I have changed the name of the app I am building. It will be called MyPersonalBlog ( MPBlog ) henceforth.

The project structure has changed a bit from what I had shown here. There is no longer separate layers for infrastructure and domain. I have clubbed these 2 layers into a single Core layer. The other layers are just the same.

Lets get started by creating our domain objects.

The domain objects

So far we have created a entity base class from which all our domain ( models ) will inherit from. In a blog application, we’ll have posts, tags and comments. So lets create classes for each of these. I have created these classes as shown in the class diagram below.

From the diagram you can see that there is a many-to-many relation between Tag and Post class..

Domain mappings

I am using Fluent NHibernate to configure the mappings of these classes to the database. Although you can map all the classes using the automapping feature which has a convention based API, I will use the mapping per class feature. Lets look at the mappings.

PostMap

namespace MPBlog.Persistence.DomainMap
{
    using Core.Domain;
    using FluentNHibernate.Mapping;
 
    public class PostMap : ClassMap<Post>
    {
        public PostMap()
        {
            WithTable( "Posts" );
 
            Id( p => p.Id, "PostId" )
                .WithUnsavedValue( 0 )
                .Access.AsReadOnlyPropertyThroughCamelCaseField()
                .GeneratedBy.Identity();
 
            Map( p => p.PostTitle ).Not.Nullable();
 
            //will be created as nvarchar(max)
            Map( p => p.PostText ).Not.Nullable()
                .WithLengthOf( 4001 );
 
            Map( p => p.ExcerptText ).Not.Nullable()
                .WithLengthOf( 1000 );
            Map( p => p.PostSlug ).Unique();
            Map( p => p.AddedBy ).Not.Nullable();
            Map( p => p.PublishDate );
 
            // Many to many with an intermediate table ( PostsToTags )
            HasManyToMany( p => p.Tags )
                .WithTableName( "PostsToTags" )
                .Cascade.SaveUpdate();
            HasMany( p => p.Comments )
                .WithTableName( "Comments" )
                .Cascade.All().Inverse();
        }
    }
}

We create a PostMap class which inherits from the ClassMap<T>. The constructor of this PostMap class is where all out mappings go. As can be seen, first we specify the table name for our Posts, Then we specify the Id property which is mapped to the PostId column in our database. The Id in our case is the id that we had declared in the Entity base class ( I have renamed the Key property to Id ). If you recall from my previous post, it had only the getter property. The value is assigned by NHibernate. We specify a many to many relation between posts and tags through an intermediate table PostToTags. We have also specified that a post has many comments thought the Comments table The other mappings are self explanatory.

Out Tag and Comment mapping classes look similar to the one above. Following are the two mapping files for these.

TagMap

namespace MPBlog.Persistence.DomainMap
{
    using Core.Domain;
    using FluentNHibernate.Mapping;
 
    public class TagMap : ClassMap<Tag>
    {
        public TagMap()
        {
            WithTable( "Tags" );
 
            Id( t => t.Id, "TagId" )
                .WithUnsavedValue( 0 )
                .Access.AsReadOnlyPropertyThroughCamelCaseField()
                .GeneratedBy.Identity();
 
            Map( t => t.Description ).Not.Nullable();
            Map( t => t.CreatedDate );
 
            HasManyToMany( t => t.Posts )
                .WithTableName( "PostsToTags" )
                .Cascade.SaveUpdate();
        }
    }
}

CommentMap

namespace MPBlog.Persistence.DomainMap
{
    using Core.Domain;
    using FluentNHibernate.Mapping;
 
    public class CommentMap : ClassMap<Comment>
    {
        public CommentMap()
        {
            WithTable( "Comments" );
 
            Id( c => c.Id )
                .WithUnsavedValue( 0 )
                .Access.AsReadOnlyPropertyThroughCamelCaseField()
                .GeneratedBy.Identity();
 
            Map( c => c.Body ).Not.Nullable();
            Map( c => c.AuthorName ).Not.Nullable();
            Map( c => c.AuthorIP ).Not.Nullable();
            Map( c => c.AuthorEmail ).Not.Nullable();
            Map( c => c.AuthorUrl ).Not.Nullable();
            Map( c => c.AddedDate ).Not.Nullable();
 
            References( c => c.Post )
                .Not.Nullable()
                .Cascade.All();
        }
    }
}

Now that our mappings are done, lets create a SessionSource to access the NHibernate Session.

We can create a session through the ISessionSource interface in Fluent NHibernate. Lets create an interface for the SessionSourceConfiguration.

Note: The following is based on the FubuMVC contrib project.

ISessionSourceConfiguration and SessionSourceConfiguration

namespace MPBlog.Persistence.Config
{
    using FluentNHibernate;
 
    public interface ISessionSourceConfiguration
    {
        bool ResetDatabase { get; }
        ISessionSource CreateSessionSource( PersistenceModel model );
    }
}

namespace MPBlog.Persistence.Config
{
    using System.Collections.Generic;
    using FluentNHibernate;
    using FluentNHibernate.Cfg.Db;
 
    public class SessionSourceConfiguration : ISessionSourceConfiguration
    {
        private readonly string _connectionString;
        public bool ResetDatabase { get; private set; }
 
        public SessionSourceConfiguration( string connectionString, bool resetDb )
        {
            _connectionString = connectionString;
            ResetDatabase = resetDb;
        }
 
        public ISessionSource CreateSessionSource( PersistenceModel model )
        {
            var properties = GetProperties( _connectionString );
            var source = new SessionSource( properties, model );
 
            CreateDbWithSchema( source );
 
            return source;
        }
 
        public IDictionary<string, string> GetProperties( string connectionString )
        {
            return MsSqlConfiguration
                .MsSql2005
                .ConnectionString( c => c.Is( connectionString ) )
                .UseOuterJoin()
                .ShowSql()
                .ToProperties();
        }
 
        private void CreateDbWithSchema( ISessionSource source )
        {
            if( ResetDatabase )
            {
                source.BuildSchema();
            }
        }
    }
}

The ResetDatabase property is used to either create a new database from our mappings or reset the database. We have a method called GetProperties from which we generate the connection properties.

As you can see in the CreateSessionSource method, we are passing a PersistenceModel object. This object is used to add the mapping from a specified assembly, in our case, where we have defined the Post, Tag and Comment maps. Lets call it MPBlogPersistenceModel. Here is what it looks like.

using FluentNHibernate;
 
namespace MPBlog.Persistence
{
    public class MPBlogPersistenceModel : PersistenceModel
    {
        public MPBlogPersistenceModel()
        {
            addMappingsFromThisAssembly();
        }
    }
}

The PresistenceModel object, connectionString, and resetDB parameters are injected using an IoC container which we’ll have a look in a later post.

Following are the tests I have written to check my mapping are correct. I am using an in memory SQLite database and the PersistenceSpecification<T> provided by Fluent NHibernate to check my mapping.

Mapping Tests

namespace MPBlog.Tests.Persistence.Tests
{
    using System;
    using Core.Domain;
    using FluentNHibernate;
    using FluentNHibernate.Cfg.Db;
    using FluentNHibernate.Testing;
    using MPBlog.Persistence;
    using NHibernate;
    using Xunit;
 
    public class PersistenceTests
    {
        private ISession session;
        public PersistenceTests()
        {
            var persistenceModel = new MPBlogPersistenceModel();
 
            var config = new SQLiteConfiguration()
                .InMemory()
                .ConnectionString( c => c.Is( "Data Source=:memory:;Version=3;New=True;" ) )
                .ShowSql();
 
            var sessionSource = new SessionSource( config.ToProperties(), persistenceModel );
            session = sessionSource.CreateSession();
            sessionSource.BuildSchema( session );
        }
 
 
        [Fact]
        public void Post_mapping_test()
        {
            new PersistenceSpecification<Post>( session )
                .CheckProperty( p => p.AddedBy, "vinay" )
                .CheckProperty( p => p.PostTitle, "title" )
                .CheckProperty( p => p.PostText, "text" )
                .CheckProperty( p => p.ExcerptText, "text" )
                .CheckProperty( p => p.PostSlug, "slug" )
                .CheckProperty( p => p.PublishDate, DateTime.Today )
                .VerifyTheMappings();
        }
 
        [Fact]
        public void Tag_mapping_test()
        {
            new PersistenceSpecification<Tag>( session )
                .CheckProperty( t => t.Description, "tag1" )
                .CheckProperty( t => t.CreatedDate, DateTime.Today )
                .VerifyTheMappings();
        }
 
        [Fact]
        public void Comment_mapping_test()
        {
            new PersistenceSpecification<Comment>( session )
                .CheckProperty( c => c.AuthorEmail, "vinay@simplyvinay.com" )
                .CheckProperty( c => c.AuthorIP, "127.0.0.1" )
                .CheckProperty( c => c.AuthorName, "vinay" )
                .CheckProperty( c => c.AuthorUrl, "www.simplyvinay.com" )
                .CheckProperty( c => c.Body, "comment" )
                .CheckProperty( c => c.AddedDate, DateTime.Today )
                .CheckReference( c => c.Post,
                                new Post
                                    {
                                        AddedBy = "vinay",
                                        PostTitle = "title",
                                        PostText = "text",
                                        ExcerptText = "text",
                                        PostSlug = "slug",
                                        PublishDate = DateTime.Today
                                    } )
                .VerifyTheMappings();
        }
    }
}

That's it for now. In my next post, I’ll discuss about the repository and the unit of work implementations. Any sort of feedback will be appreciated.

    1 public string BlogText
    2 {
    3     get 
    4     {
    5         if (blogText == null)
    6             blogText = SiteProvider.Blogs.GetBlogBody(Id);
    7         return blogText; 
    8     }
    9     set { blogText = value; }
   10 }