Kazi Manzur Rashid's Blog : C#

Shrinkr - Url Shrinking Service Developed with Entity Framework 4.0, Unity, ASP.NET MVC And jQuery (Part 3)

kazimanzurrashid — Tue, 15 Sep 2009 09:57:54 GMT

In the previous post, we have created our initial repositories, in this post I will show how you can use the compiled query of Entity Framework in our repository. To use the compiled query we will put each query of our repositories into its own class and create some common interfaces that we can use in our repositories.

IQuery

namespace Shrinkr.Infrastructure.EntityFramework
{
    public interface IQuery<TResult>
    {
        TResult Execute(Database database);
    }
}

IQueryFactory

namespace Shrinkr.Infrastructure.EntityFramework
{
    using System.Collections.Generic;

    public interface IQueryFactory
    {
        bool UseCompiled
        {
            get;
        }

        IQuery<User> CreateUserById(long userId);

        IQuery<User> CreateUserByName(string userName);

        IQuery<User> CreateUserByApiKey(string apiKey);

        IQuery<ShortUrl> CreateShortUrlById(long shortUrlId);

        IQuery<ShortUrl> CreateShortUrlByHash(string urlHash);

        IQuery<ShortUrl> CreateShortUrlByAlias(string alias);

        IQuery<int> CreateShortUrlCountByUserId(long userId);

        IQuery<IEnumerable<ShortUrl>> CreateShortUrlsByUserId(long userId, int start, int max);
    }
}

Now we will modify our RepositoryBase, so that we can pass the IQuaryFactory in its constructor.

RepositoryBase

namespace Shrinkr.Infrastructure.EntityFramework
{
    public abstract class RepositoryBase<TEntity> where TEntity : class, IEntity
    {
        protected RepositoryBase(Database database, IQueryFactory queryFactory)
        {
            Check.Argument.IsNotNull(database, "database");
            Check.Argument.IsNotNull(queryFactory, "queryFactory");

            Database = database;
            QueryFactory = queryFactory;
        }

        protected Database Database
        {
            get;
            private set;
        }

        protected IQueryFactory QueryFactory
        {
            get;
            private set;
        }

        public virtual void Add(TEntity entity)
        {
            Check.Argument.IsNotNull(entity, "entity");

            Database.ObjectSet<TEntity>().AddObject(entity);
        }

        public virtual void Delete(TEntity entity)
        {
            Check.Argument.IsNotNull(entity, "entity");

            Database.ObjectSet<TEntity>().DeleteObject(entity);
        }
    }
}

We can now use the query factory in our repository, for example, in UserRepository we will be able to use:

public User GetById(long id)
{
    IQuery<User> query = QueryFactory.CreateUserById(id);

    return query.Execute(Database);
}

Now, lets check how the query is constructed, first the base class which implements the IQuery<T> interface:

QueryBase

namespace Shrinkr.Infrastructure.EntityFramework
{
    public abstract class QueryBase<TResult> : IQuery<TResult>
    {
        protected QueryBase(bool useCompiled)
        {
            UseCompiled = useCompiled;
        }

        protected bool UseCompiled
        {
            get;
            private set;
        }

        public abstract TResult Execute(Database database);
    }
}

as mentioned that each query will have its own class, for example, for the above user by id query, we will have the following:

namespace Shrinkr.Infrastructure.EntityFramework
{
    using System;
    using System.Data.Objects;
    using System.Linq;
    using System.Linq.Expressions;

    public class UserByIdQuery : QueryBase<User>
    {
        private static readonly Expression<Func<Database, long, User>> expression = (Database database, long id) => database.Users.SingleOrDefault(user => user.Id == id);
        private static readonly Func<Database, long, User> plainQuery = expression.Compile();
        private static readonly Func<Database, long, User> compiledQuery = CompiledQuery.Compile(expression);

        private readonly long userId;

        public UserByIdQuery(bool useCompiled, long userId) : base(useCompiled)
        {
            Check.Argument.IsNotNegative(userId, "userId");

            this.userId = userId;
        }

        public override User Execute(Database database)
        {
            Check.Argument.IsNotNull(database, "database");

            return UseCompiled ?
                   compiledQuery(database, userId) :
                   plainQuery(database, userId);
        }
    }
}

and the implementation of QueryFactory

namespace Shrinkr.Infrastructure.EntityFramework
{
    using System.Collections.Generic;

    public class QueryFactory : IQueryFactory
    {
        public QueryFactory(bool useCompiled)
        {
            UseCompiled = useCompiled;
        }

        public bool UseCompiled
        {
            get;
            private set;
        }

        public IQuery<User> CreateUserById(long userId)
        {
            return new UserByIdQuery(UseCompiled, userId);
        }
    }
}

Now, when unit testing the Repositories we will be using the plain queries, for example the UserRepository will be constructed like the following in unit tests:

public UserRepositoryTests()
{
    database = new Mock<Database>(configurationManager.Object, "Dummy");
    var queryFactory = new QueryFactory(false); // plain query

    repository = new UserRepository(database.Object, queryFactory);
}

and that’s it. But for the data access layer, I would highly recommend to have the integration tests as well. The reasons are:

It will ensure the underlying Linq Providers does support the Linq queries that we have in your repositories, although the Linq queries we have written here are very simple.
By using the SQL Profiler we can ensure the generated SQLs are really optimized.

But to start writing the integration tests, we have one more important thing to do, the UnitOfWork, which persist the changes in our database.

UnitOfWork

namespace Shrinkr.Infrastructure.EntityFramework
{
    public class UnitOfWork : IUnitOfWork
    {
        private readonly Database database;

        public UnitOfWork(Database database)
        {
            Check.Argument.IsNotNull(database, "database");

            this.database = database;
        }

        public void Commit()
        {
            database.Commit();
        }
    }
}

Now, lets write our first integration test:

namespace Shrinkr.IntegrationTests
{
    using System;

    using Xunit;
    using Xunit.Extensions;

    using IoC = global::Microsoft.Practices.ServiceLocation.ServiceLocator;

    public class UserRepositoryTests : TestBase
    {
        private const string Name = "http://kazimanzurrashid.myopenid.com";

        private readonly IUnitOfWork unitOfWork;
        private readonly IUserRepository repository;

        public UserRepositoryTests()
        {
            unitOfWork = IoC.Current.GetInstance<IUnitOfWork>();
            repository = IoC.Current.GetInstance<IUserRepository>();
        }

        [Fact, AutoRollback]
        public void Should_be_able_to_add_user()
        {
            var user = CreateUser();

            Assert.NotEqual(0, user.Id);
        }

        [Fact, AutoRollback]
        public void Should_be_able_to_update_user()
        {
            var user = CreateUser();

            user.Email = "kazimanzurrashid@gmail.com";

            unitOfWork.Commit();

            var updatedUser = repository.GetById(user.Id);

            Assert.Equal("kazimanzurrashid@gmail.com", updatedUser.Email);
        }

        [Fact, AutoRollback]
        public void Should_be_able_to_delete_user()
        {
            var userId = CreateUser().Id;
            var user = repository.GetById(userId);

            repository.Delete(user);
            unitOfWork.Commit();

            user = repository.GetById(userId);

            Assert.Null(user);
        }

        [Fact, AutoRollback]
        public void Should_be_able_to_get_user_by_id()
        {
            var userId = CreateUser().Id;
            var user = repository.GetById(userId);

            Assert.NotNull(user);
        }

        [Fact, AutoRollback]
        public void Should_be_able_to_get_user_by_name()
        {
            CreateUser();

            var user = repository.GetByName(Name);

            Assert.NotNull(user);
        }

        [Fact, AutoRollback]
        public void Should_be_able_to_get_user_by_api_key()
        {
            var apiKey = CreateUser().ApiSetting.Key;
            var user = repository.GetByApiKey(apiKey);

            Assert.NotNull(user);
        }

        private User CreateUser()
        {
            var user = new User { Name = Name };

            user.ApiSetting.Allowed = true;
            user.ApiSetting.DailyLimit = 1000;
            user.ApiSetting.Key = Guid.NewGuid().ToString().ToUpperInvariant();

            repository.Add(user);
            unitOfWork.Commit();

            return user;
        }
    }
}

When we run the above test, it will generate the following SQL statements, which I think is pretty much optimized:

GetById

exec sp_executesql N'SELECT 
[Limit1].[Id] AS [Id], 
[Limit1].[Name] AS [Name], 
[Limit1].[Email] AS [Email], 
[Limit1].[IsLockedOut] AS [IsLockedOut], 
[Limit1].[CreatedAt] AS [CreatedAt], 
[Limit1].[Role] AS [Role], 
[Limit1].[LastActivityAt] AS [LastActivityAt], 
[Limit1].[C1] AS [C1], 
[Limit1].[ApiKey] AS [ApiKey], 
[Limit1].[ApiAllowed] AS [ApiAllowed], 
[Limit1].[DailyLimit] AS [DailyLimit]
FROM ( SELECT TOP (2) 
	[Extent1].[Id] AS [Id], 
	[Extent1].[Name] AS [Name], 
	[Extent1].[Email] AS [Email], 
	[Extent1].[IsLockedOut] AS [IsLockedOut], 
	[Extent1].[CreatedAt] AS [CreatedAt], 
	[Extent1].[Role] AS [Role], 
	[Extent1].[ApiKey] AS [ApiKey], 
	[Extent1].[ApiAllowed] AS [ApiAllowed], 
	[Extent1].[DailyLimit] AS [DailyLimit], 
	[Extent1].[LastActivityAt] AS [LastActivityAt], 
	1 AS [C1]
	FROM [dbo].[User] AS [Extent1]
	WHERE [Extent1].[Id] = @p__linq__0
)  AS [Limit1]',N'@p__linq__0 bigint',@p__linq__0=125

GetByName

exec sp_executesql N'SELECT 
[Limit1].[Id] AS [Id], 
[Limit1].[Name] AS [Name], 
[Limit1].[Email] AS [Email], 
[Limit1].[IsLockedOut] AS [IsLockedOut], 
[Limit1].[CreatedAt] AS [CreatedAt], 
[Limit1].[Role] AS [Role], 
[Limit1].[LastActivityAt] AS [LastActivityAt], 
[Limit1].[C1] AS [C1], 
[Limit1].[ApiKey] AS [ApiKey], 
[Limit1].[ApiAllowed] AS [ApiAllowed], 
[Limit1].[DailyLimit] AS [DailyLimit]
FROM ( SELECT TOP (2) 
	[Extent1].[Id] AS [Id], 
	[Extent1].[Name] AS [Name], 
	[Extent1].[Email] AS [Email], 
	[Extent1].[IsLockedOut] AS [IsLockedOut], 
	[Extent1].[CreatedAt] AS [CreatedAt], 
	[Extent1].[Role] AS [Role], 
	[Extent1].[ApiKey] AS [ApiKey], 
	[Extent1].[ApiAllowed] AS [ApiAllowed], 
	[Extent1].[DailyLimit] AS [DailyLimit], 
	[Extent1].[LastActivityAt] AS [LastActivityAt], 
	1 AS [C1]
	FROM [dbo].[User] AS [Extent1]
	WHERE [Extent1].[Name] = @p__linq__0
)  AS [Limit1]',N'@p__linq__0 nvarchar(4000)',@p__linq__0=N'http://kazimanzurrashid.myopenid.com/'

GetByApiKey

exec sp_executesql N'SELECT 
[Limit1].[Id] AS [Id], 
[Limit1].[Name] AS [Name], 
[Limit1].[Email] AS [Email], 
[Limit1].[IsLockedOut] AS [IsLockedOut], 
[Limit1].[CreatedAt] AS [CreatedAt], 
[Limit1].[Role] AS [Role], 
[Limit1].[LastActivityAt] AS [LastActivityAt], 
[Limit1].[C1] AS [C1], 
[Limit1].[ApiKey] AS [ApiKey], 
[Limit1].[ApiAllowed] AS [ApiAllowed], 
[Limit1].[DailyLimit] AS [DailyLimit]
FROM ( SELECT TOP (2) 
	[Extent1].[Id] AS [Id], 
	[Extent1].[Name] AS [Name], 
	[Extent1].[Email] AS [Email], 
	[Extent1].[IsLockedOut] AS [IsLockedOut], 
	[Extent1].[CreatedAt] AS [CreatedAt], 
	[Extent1].[Role] AS [Role], 
	[Extent1].[ApiKey] AS [ApiKey], 
	[Extent1].[ApiAllowed] AS [ApiAllowed], 
	[Extent1].[DailyLimit] AS [DailyLimit], 
	[Extent1].[LastActivityAt] AS [LastActivityAt], 
	1 AS [C1]
	FROM [dbo].[User] AS [Extent1]
	WHERE [Extent1].[ApiKey] = @p__linq__0
)  AS [Limit1]',N'@p__linq__0 nvarchar(4000)',@p__linq__0=N'9C1A8F98-9CC6-4967-8B48-269CA92833E5'

Insert

exec sp_executesql N'insert [dbo].[User]([Name], [Email], [IsLockedOut], [CreatedAt], [Role], [ApiKey], [ApiAllowed], [DailyLimit], [LastActivityAt])
values (@0, null, @1, @2, @3, @4, @5, @6, @7)
select [Id]
from [dbo].[User]
where @@ROWCOUNT > 0 and [Id] = scope_identity()',N'@0 nvarchar(256),@1 bit,@2 datetime,@3 int,@4 nchar(36),@5 bit,@6 int,@7 datetime',@0=N'http://kazimanzurrashid.myopenid.com',@1=0,@2='2009-08-02 22:04:17:067',@3=0,@4=N'9C1A8F98-9CC6-4967-8B48-269CA92833E5',@5=1,@6=1000,@7='2009-08-02 22:04:17:067'

Update

exec sp_executesql N'update [dbo].[User]
set [Email] = @0
where ([Id] = @1)
',N'@0 nvarchar(256),@1 bigint',@0=N'kazimanzurrashid@gmail.com',@1=142

Delete

exec sp_executesql N'delete [dbo].[User]
where ([Id] = @0)',N'@0 bigint',@0=125

You will find other tests in the integration test project.

That is it for this post, in the next post we will discuss on other infrastructural item such shrinking logic, http content, IoC etc etc.

Stay tuned!!!

Shrinkr - Url Shrinking Service Developed with Entity Framework 4.0, Unity, ASP.NET MVC And jQuery (Part 2)

kazimanzurrashid — Sun, 13 Sep 2009 09:02:36 GMT

In the previous post we have created our initial domain model, in this post I will show you how the domain model is mapped to database with Entity Framework 4.0. But before that I would like to discuss how I usually structure the Visual Studio Projects. Most often I prefer to have a one class library and one web project where each has its own unit test project and only one integration test project, for example:

Shrinkr.Core
Shrinkr.Core.UnitTest
Shrinkr.Web
Shrinkr.Web.UnitTest
Shrinkr.IntegrationTest

The Core Project is then further divided into following folders:

Shrink.Core
- Common (Utility, Invariant etc etc)
- EntityObjects (Contains both domain objects and DTOs)
- Extensions (Extension methods)
- Repositories (Contains both interface and implementation)
- Services (Contains both interface and implementation)
- Infrastructure
  - Caching
  - Database
  - Email
  - FileSystem
  - Http
  - IoC
  - Logging
  - etc etc etc.

But since it is an open source project, I should give privilege to community to replace any part of if with the their preferred technology. for example, replacing Entity Framework with NHibernate or may be Azure Storage, Unity with StructureMap or NInject etc etc. So I decided to structure it based upon the component dependency.

As you can understand that the Shrinkr.Infrastructure.Microsoft.Practices will contain the Unity and other EntLib related codes and Shrinkr.Infrastructure.EntityFramework for the concrete repositories and other data access codes. Although Entity Framework Team has released few more add-ons (known as Features CTP1), but for the time being we will not use those. The first thing we will do is create a new class which inherits from the ObjectContext, lets name it as Database.

Database

namespace Shrinkr.Infrastructure.EntityFramework
{
    using System.Data.Objects;
    using System.Diagnostics;

    public class Database : ObjectContext
    {
        private IObjectSet<User> users;
        private IObjectSet<ShortUrl> shortUrls;
        private IObjectSet<Alias> aliases;
        private IObjectSet<Visit> visits;

        public Database(IConfigurationManager configurationManager, string connectionStringName) : base(GetConnectionString(configurationManager, connectionStringName), "ShrinkrEntities")
        {
            ContextOptions.DeferredLoadingEnabled = true;
        }

        public IObjectSet<User> Users
        {
            [DebuggerStepThrough]
            get
            {
                if (users == null)
                {
                    users = ObjectSet<User>();
                }

                return users;
            }
        }

        public IObjectSet<ShortUrl> ShortUrls
        {
            [DebuggerStepThrough]
            get
            {
                if (shortUrls == null)
                {
                    shortUrls = ObjectSet<ShortUrl>();
                }

                return shortUrls;
            }
        }

        public IObjectSet<Alias> Aliases
        {
            [DebuggerStepThrough]
            get
            {
                if (aliases == null)
                {
                    aliases = ObjectSet<Alias>();
                }

                return aliases;
            }
        }

        public IObjectSet<Visit> Visits
        {
            [DebuggerStepThrough]
            get
            {
                if (visits == null)
                {
                    visits = ObjectSet<Visit>();
                }

                return visits;
            }
        }

        public virtual IObjectSet<TEntity> ObjectSet<TEntity>() where TEntity : class, IEntity
        {
            return CreateObjectSet<TEntity>();
        }

        public virtual void Commit()
        {
            SaveChanges();
        }

        private static string GetConnectionString(IConfigurationManager configurationManager, string connectionStringName)
        {
            Check.Argument.IsNotNull(configurationManager, "configurationManager");
            Check.Argument.IsNotNullOrEmpty(connectionStringName, "connectionStringName");

            string connectionString = configurationManager.ConnectionString(connectionStringName);

            return connectionString;
        }
    }
}

Nothing complex, we are just exposing our Domain Entities as properties like Users, ShortUrls, Aliases etc. One important thing you should check in the above code is that instead of using the CreateObjectSet<T>() in the properties, I have created a virtual method ObjectSet<T>() which in turns calls the CreateObjectSet<T>. The reasons behind creating this new virtual method are:

CreateObjectSet<T> does not return IObjectSet<T>, instead it returns the concrete ObjectSet<T>.
CreateObjectSet<T> is not a virtual method, which means we cannot mock it the unit tests (Although it is debatable whether to write unit tests over any Linq provider, but that is an another story).

I am not sure why the Entity Framework team decided to return the concrete class instead of the interface also not making the method virtual, if they did, we do not have to write this workarounds and I am pretty sure many people will call it a design smell and finds it frustrating. Next, we will create the base repository which the UserRepository and ShortUrlRepository inherits. Although it is a common practise specially in the NHibernate world to have only one Repository<T> instead of individual repository for each aggregate root which I will discuss in my next post.

RepositoryBase

namespace Shrinkr.Infrastructure.EntityFramework
{
    public abstract class RepositoryBase<TEntity> where TEntity : class, IEntity
    {
        protected RepositoryBase(Database database)
        {
            Check.Argument.IsNotNull(database, "database");

            Database = database;
        }

        protected Database Database
        {
            get;
            private set;
        }

        public virtual void Add(TEntity entity)
        {
            Check.Argument.IsNotNull(entity, "entity");

            Database.ObjectSet<TEntity>().AddObject(entity);
        }

        public virtual void Delete(TEntity entity)
        {
            Check.Argument.IsNotNull(entity, "entity");

            Database.ObjectSet<TEntity>().DeleteObject(entity);
        }
    }
}

Check that we have marked both Add and Delete method as virtual so that the concrete repository can override if it has some extra logic. Now, lets create the Unit Test for it.

RepositoryBaseTests

namespace Shrinkr.Infrastructure.EntityFramework.UnitTests
{
    using System.Collections.Generic;

    using Moq;
    using Xunit;

    public class RepositoryBaseTests
    {
        private readonly Mock<FakeObjectSet<Dummy>> objectSet;
        private readonly Mock<Database> database;
        private readonly DummyRepository repository;

        public RepositoryBaseTests()
        {
            var objects = new List<Dummy> {
                                            new Dummy { Id = 1},
                                            new Dummy { Id = 2},
                                            new Dummy { Id = 3}
                                          };

            objectSet = new Mock<FakeObjectSet<Dummy>>(objects);

            var configurationManager = new Mock<IConfigurationManager>();
            configurationManager.Setup(mgr => mgr.ConnectionString(It.IsAny<string>())).Returns("Dummy Connection String");

            database = new Mock<Database>(configurationManager.Object, "Dummy");
            database.Setup(db => db.ObjectSet<Dummy>()).Returns(objectSet.Object);

            repository = new DummyRepository(database.Object);
        }

        [Fact]
        public void Should_be_able_to_add()
        {
            objectSet.Setup(set => set.AddObject(It.IsAny<Dummy>())).Verifiable();

            repository.Add(new Dummy());

            objectSet.Verify();
        }

        [Fact]
        public void Should_be_able_to_delete()
        {
            objectSet.Setup(set => set.DeleteObject(It.IsAny<Dummy>())).Verifiable();

            repository.Delete(new Dummy());

            objectSet.Verify();
        }
   } 

    public class Dummy : IEntity
    {
        public long Id
        {
            get;
            set;
        }
    }

    public class DummyRepository : RepositoryBase<Dummy>
    {
        public DummyRepository(Database database) : base(database)
        {
        }
    }
}

To test the RepositoryBase we have to create few fake classes and in the unit test we are using those. The reason is, if we create mock of RepositoryBase which methods are virtual the mock framework(Moq) will replace those, so the codes of Add and Delete will not be executed. By using the DummyRepository we are making sure the RepositoryBase methods are called. Another important thing you might have noticed that when setting up expectations on the database.ObjectSet (line 28) method we are using another new class FakeObjectSet. This is the another frustrating part of Entity Framework, you cannot pass/set collection of objects in the ObjectSet<T>. This is what the FakeObjectSet does, allowing us to pass the collection of objects so that our unit test can run properly.

FakeObjectSet

namespace Shrinkr.Infrastructure.EntityFramework.UnitTests
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Data.Objects;
    using System.Linq;
    using System.Linq.Expressions;

    public abstract class FakeObjectSet<T> : IObjectSet<T> where T : class
    {
        private readonly IEnumerable<T> objects;

        protected FakeObjectSet(IEnumerable<T> objects)
        {
            this.objects = objects;
        }

        public Expression Expression
        {
            get
            {
                return objects.AsQueryable().Expression;
            }
        }

        public IQueryProvider Provider
        {
            get
            {
                return objects.AsQueryable().Provider;
            }
        }

        public Type ElementType
        {
            get
            {
                return typeof(T);
            }
        }

        public abstract void AddObject(T entity);

        public abstract void Attach(T entity);

        public abstract void DeleteObject(T entity);

        public IEnumerator<T> GetEnumerator()
        {
            return objects.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
    }
}

Now, creating the concrete repositories are plain and simple.

UserRepository

namespace Shrinkr.Infrastructure.EntityFramework
{
    using System.Linq;

    public class UserRepository : RepositoryBase<User>, IUserRepository
    {
        public UserRepository(Database database) : base(database)
        {
        }

        public User GetById(long id)
        {
            Check.Argument.IsNotZeroOrNegative(id, "id");

            return Database.Users.SingleOrDefault(user => user.Id == id);
        }

        public User GetByName(string name)
        {
            Check.Argument.IsNotNullOrEmpty(name, "name");

            return Database.Users.SingleOrDefault(user => user.Name == name);
        }

        public User GetByApiKey(string apiKey)
        {
            Check.Argument.IsNotNullOrEmpty(apiKey, "apiKey");

            return Database.Users.SingleOrDefault(user => user.ApiSetting.Key == apiKey);
        }
    }
}

UserRepositoryTests

namespace Shrinkr.Infrastructure.EntityFramework.UnitTests
{
    using System;
    using System.Collections.Generic;

    using Moq;
    using Xunit;

    public class UserRepositoryTests
    {
        private const long UserId = 1;
        private const string UserName = "http://kazimanzurrashid.myopenid.com";
        private readonly static string ApiKey = Guid.NewGuid().ToString().ToUpperInvariant();

        private readonly Mock<Database> database;
        private readonly UserRepository repository;

        public UserRepositoryTests()
        {
            var users = new List<User> { new User { Id = UserId, Name = UserName } };

            users[0].ApiSetting.Key = ApiKey;

            var userSet = new Mock<FakeObjectSet<User>>(users);

            var configurationManager = new Mock<IConfigurationManager>();
            configurationManager.Setup(mgr => mgr.ConnectionString(It.IsAny<string>())).Returns("Dummy Connection String");

            database = new Mock<Database>(configurationManager.Object, "Dummy");

            database.Setup(db => db.ObjectSet<User>()).Returns(userSet.Object);

            repository = new UserRepository(database.Object, queryFactory);
        }

        [Fact]
        public void Should_be_able_to_get_by_id()
        {
            var user = repository.GetById(UserId);

            Assert.Equal(UserName, user.Name);
        }

        [Fact]
        public void Should_be_able_to_get_by_name()
        {
            var user = repository.GetByName(UserName);

            Assert.Equal(UserId, user.Id);
        }

        [Fact]
        public void Should_be_able_to_get_by_api_key()
        {
            var user = repository.GetByApiKey(ApiKey);

            Assert.Equal(UserId, user.Id);
        }
    }
}

ShortUrlRepository

namespace Shrinkr.Infrastructure.EntityFramework
{
    using System.Collections.Generic;
    using System.Linq;

    public class ShortUrlRepository : RepositoryBase<ShortUrl>, IShortUrlRepository
    {
        public ShortUrlRepository(Database database) : base(database)
        {
        }

        public ShortUrl GetById(long id)
        {
            Check.Argument.IsNotZeroOrNegative(id, "id");

            return Database.ShortUrls.SingleOrDefault(shortUrl => shortUrl.Id == id);
        }

        public ShortUrl GetByHash(string hash)
        {
            Check.Argument.IsNotNullOrEmpty(hash, "hash");

            return Database.ShortUrls.SingleOrDefault(shortUrl => shortUrl.Hash == hash);
        }

        public ShortUrl GetByAliasName(string aliasName)
        {
            Check.Argument.IsNotNullOrEmpty(aliasName, "aliasName");

            return Database.ShortUrls.SingleOrDefault(shortUrl => shortUrl.Aliases.Any(alias => alias.Name == aliasName));
        }

        public PagedResult<ShortUrl> FindByUserId(long userId, int start, int max)
        {
            Check.Argument.IsNotZeroOrNegative(userId, "userId");
            Check.Argument.IsNotNegative(start, "start");
            Check.Argument.IsNotNegative(max, "max");

            int total = Database.Aliases.Count(alias => alias.User.Id == userId);

            IQueryable<ShortUrl> result = Database.Aliases.Where(alias => alias.User.Id == userId)
                                                  .OrderByDescending(alias => alias.CreatedAt)
                                                  .Select(alias => alias.ShortUrl)
                                                  .Skip(start)
                                                  .Take(max);

            return new PagedResult<ShortUrl>(result, total);
        }
    }
}

ShortUrlRepositoryTests

namespace Shrinkr.Infrastructure.EntityFramework.UnitTests
{
    using System.Collections.Generic;

    using Moq;
    using Xunit;

    public class ShortUrlRepositoryTests
    {
        private readonly Mock<Database> database;
        private readonly ShortUrlRepository repository;

        public ShortUrlRepositoryTests()
        {
            var shortUrls = new List<ShortUrl> {
                                                    new ShortUrl { Id = 1, Title = "Shrinkr.com",Url = "http://shrinkr.com", Hash = "http://shrinkr.com".Hash() },
                                                    new ShortUrl { Id = 2, Title = "DotNetShoutout.com", Url = "http://dotnetshoutout.com", Hash = "http://dotnetshoutout.com".Hash() }
                                               };

            shortUrls[1].Aliases.Add(new Alias { Name = "dtntshtt" });

            var shortUrlSet = new Mock<FakeObjectSet<ShortUrl>>(shortUrls);

            var user = new User { Id = 1 };

            var aliases = new List<Alias>{
                                            new Alias { Id = 1, User = user, ShortUrl = shortUrls[0] },
                                            new Alias { Id = 2, User = user, ShortUrl = shortUrls[1] },
                                         };

            var aliasSet = new Mock<FakeObjectSet<Alias>>(aliases);

            var configurationManager = new Mock<IConfigurationManager>();
            configurationManager.Setup(mgr => mgr.ConnectionString(It.IsAny<string>())).Returns("Dummy Connection String");

            database = new Mock<Database>(configurationManager.Object, "Dummy");
            database.Setup(db => db.ObjectSet<ShortUrl>()).Returns(shortUrlSet.Object);
            database.Setup(db => db.ObjectSet<Alias>()).Returns(aliasSet.Object);

            repository = new ShortUrlRepository(database.Object);
        }

        [Fact]
        public void Should_be_able_to_get_by_id()
        {
            var shortUrl = repository.GetById(1);

            Assert.Equal(1, shortUrl.Id);
        }

        [Fact]
        public void Should_be_able_to_get_by_hash()
        {
            var shortUrl = repository.GetByHash("http://shrinkr.com".Hash());

            Assert.Equal(1, shortUrl.Id);
        }

        [Fact]
        public void Should_be_able_to_get_by_alias_name()
        {
            var shortUrl = repository.GetByAliasName("dtntshtt");

            Assert.Equal(2, shortUrl.Id);
        }

        [Fact]
        public void Should_be_able_to_find_by_user_id()
        {
            var shortUrls = repository.FindByUserId(1, 0, 10);

            Assert.Equal(2, shortUrls.Total);
            Assert.Equal(2, shortUrls.Result.Count);
        }
    }
}

and that’s it, we have completed the initial implementation of our Repositories. What do you think, what it is currently lacking? Yes we are not taking the advantages of Compiled Queries. In the next post, I will show how you can use the both compiled and regular queries in your repositories.

Stay tuned!!!

Use Event Aggregator to make your application more extensible

kazimanzurrashid — Thu, 05 Mar 2009 14:35:28 GMT

Recently, in KiGG/DotNetShoutout we have integrated Twitter, nothing complex, very basic thing like when a story is submitted or appears in the front page it will broadcast in Twitter and like our feed it will post the short url of the original story (Cant resist to do some shameless marketing for DotNetShoutout).

Since it is a new requirement, initially I have modified the StoryService constructor to include the twitter client as a new argument and use it after the story is added in the database, the code is something like the following:

//Other codes

//Add it in database
_storyRepository.Add(story);

//Increase User Score
_userScoreService.StorySubmitted(byUser);

// Send Trackback
PingStory(content, story, detailUrl);

//Ping the Feed Servers
PingServers();

//Send Tweet
_twitter.UpdateStatus(story);

result = new StoryCreateResult { NewStory = story, DetailUrl = detailUrl };

return result;

As you can see there are quite a few things that I have do:

Increase the User Score.
Send Trackback (Thank you for submitting this cool story)
Ping Feedburner/Pingomatic/technorati servers.
Send Tweet.

So for this new requirement we have to modify it and will again have to do if we add more features in future and we do have a plan to implement the Spy/Log (don’t confuse it with the code logger, it is ajax view which shows what is happening currently in the application) and this obviously not a path we should follow. It violets the OCP completely, tie us to write some transactional script kind of code. We need to find a way where we can add new features without modifying the StoryService. One option would be to pass an array of IBackgroundService (As these are noting but some background services)in the StoryService constructor which these classes will implement and later on the StoryService will call the Execute method of each background service. But Story Submit, Story Publish is more like a system event which should be globally available.

Enter Event Aggregator

As per Martin Fowler “An Event Aggregator acts as a single source of events for many objects. It registers for all the events of the many objects allowing clients to register with just the aggregator.” Jeremy D Miller also used this pattern in his excellent Build your own CAB series. And recently I was browsing through the CompositeWpf/Prism code and found the EventAggregator which seems a perfect candidate for my situation. According to its documentation:

“The EventAggregator service is primarily a container for events that allow decoupling of publishers and subscribers so they can evolve independently.”

But it has some dependency on .NET WPF which I would like to remove, and after talking with Glen Block, he confirmed that since it is licensed under MS-PL, I can copy and modify it according to my need. Also most of the example you will find of Event Aggregator demonstrate the UI events, but it is a very powerful pattern and can be used in non UI events too which we will see next.

As mentioned in the above that UserScoreService, PingStory, PingServer, SendTweet is some kind of background task which can be run independently and it will act as subscriber in the above diagram, so lets create an interface:

public interface IBackgroundTask
{
    bool IsRunning
    {
        get;
    }

    void Start();

    void Stop();
}

Next we will create an abstract class which will implement this interface to reduce the duplicate codes:

public abstract class BaseBackgroundTask : IBackgroundTask
{
    private readonly IEventAggregator _eventAggregator;

    protected BaseBackgroundTask(IEventAggregator eventAggregator)
    {
        if (eventAggregator == null)
        {
            throw new ArgumentNullException("eventAggregator");
        }

        _eventAggregator = eventAggregator;
    }

    public bool IsRunning
    {
        get;
        private set;
    }

    protected IEventAggregator EventAggregator
    {
        get
        {
            return _eventAggregator;
        }
    }

    public void Start()
    {
        OnStart();
        IsRunning = true;
    }

    public void Stop()
    {
        OnStop();
        IsRunning = false;
    }

    protected abstract void OnStart();

    protected abstract void OnStop();

    protected SubscriptionToken Subscribe<TEvent, TEventArgs>(Action<TEventArgs> action) where TEvent : BaseEvent<TEventArgs> where TEventArgs : class
    {
        return EventAggregator.GetEvent<TEvent>().Subscribe(action, true);
    }

    protected void Unsubscribe<TEvent>(SubscriptionToken token) where TEvent : BaseEvent
    {
        EventAggregator.GetEvent<TEvent>().Unsubscribe(token);
    }
}

Now lets create some concrete implementation of these background tasks.

First, the Twitter:

public class SendTweet : BaseBackgroundTask
{
    private SubscriptionToken _storySubmitToken;

    public SendTweet(IEventAggregator eventAggregator) : base(eventAggregator)
    {
    }

    protected override void OnStart()
    {
        if (!IsRunning)
        {
            _storySubmitToken = Subscribe<StorySubmitEvent, StorySubmitEventArgs>(StorySubmitted);
        }
    }

    protected override void OnStop()
    {
        if (IsRunning)
        {
            Unsubscribe<StorySubmitEvent>(_storySubmitToken);
        }
    }

    private void StorySubmitted(StorySubmitEventArgs eventArgs)
    {
        UpdateStatus(eventArgs.Story);
    }

    private void UpdateStatus(Story story)
    {
        //Update Twitter status goes here
    }
}

Next the UserScoreService:

public class UserScoreService : BaseBackgroundTask
{
    private SubscriptionToken _storySubmitToken;

    public UserScoreService(IEventAggregator eventAggregator) : base(eventAggregator)
    {
    }

    protected override void OnStart()
    {
        if (!IsRunning)
        {
            _storySubmitToken = Subscribe<StorySubmitEvent, StorySubmitEventArgs>(StorySubmitted);
        }
    }

    protected override void OnStop()
    {
        if (IsRunning)
        {
            Unsubscribe<StorySubmitEvent>(_storySubmitToken);
        }
    }

    private void StorySubmitted(StorySubmitEventArgs eventArgs)
    {
        IncreaseUserScore(eventArgs.Story.PostedBy);
    }

    private void IncreaseUserScore(User user)
    {
        // Increase user score goes here
    }
}

I am skipping the PingStory and PingServer as they are very much same as above.

Next the published part, now the StoryService will forward the StorySubmit event to EventAggregator instead of calling these class individually.

//Other codes

//Add it in database
_storyRepository.Add(story);

//Publish the event
_eventAggregator.GetEvent<StorySubmitEvent>().Publish(new StorySubmitEventArgs(story, detailUrl));

result = new StoryCreateResult { NewStory = story, DetailUrl = detailUrl };

return result;

And now we have to ensure that these background services can start listing this event. So lets create a BootstrapperTask which I have shown in my previous post.

public class StartBackgroundTasks : IBootstrapperTask
{
    private readonly IBackgroundTask[] _tasks;

    public StartBackgroundTasks(IBackgroundTask[] tasks)
    {
        _tasks = tasks;
    }

    public void Execute()
    {
        foreach(IBackgroundTask task in _tasks)
        {
            task.Start();
        }
    }
}

And at last the wiring of Unity container, I am using the fluent version but you can also use the xml configuration if you want.

IUnityContainer container = new UnityContainer();

container.RegisterType<IBackgroundTask, UserScoreService>("userScore", new ContainerControlledLifetimeManager())
         .RegisterType<IBackgroundTask, SendTweet>("sendTweet", new ContainerControlledLifetimeManager())
         .RegisterType<IBackgroundTask, PingStory>("pingStory", new ContainerControlledLifetimeManager())
         .RegisterType<IBackgroundTask, PingServer>("pingServer", new ContainerControlledLifetimeManager())
         .RegisterType<IEventAggregator, EventAggregator>(new ContainerControlledLifetimeManager())
         .RegisterType<IControllerFactory, CommonServiceLocatorControllerFactory>(new ContainerControlledLifetimeManager())
         .RegisterType<IBootstrapperTask, RegisterRoutes>("route", new ContainerControlledLifetimeManager(), new InjectionConstructor(new [] { RouteTable.Routes}))
         .RegisterType<IBootstrapperTask, RegisterControllerFactory>("controllerFactory", new ContainerControlledLifetimeManager())
         .RegisterType<IBootstrapperTask, StartBackgroundTasks>("startBackgroundTasks", new ContainerControlledLifetimeManager())
         .RegisterType<IFormsAuthentication, FormsAuthenticationService>(new ContainerControlledLifetimeManager())
         .RegisterType<IMembershipService, AccountMembershipService>(new InjectionConstructor())
         .RegisterType<AccountController>()
         .RegisterType<HomeController>();

ServiceLocator.SetLocatorProvider(() => new UnityServiceLocator(container));

My initial plan was to refer you the KiGG/DotNetShoutout source code rather than posting a separate version, but as you know that ASP.NET MVC RC2 has released few days ago I would rather upgrade it to that version.

Further Reference:

Comments/Suggestions?

Download: EventAggregator.zip

Unit Testable Configuration Manager

kazimanzurrashid — Mon, 02 Mar 2009 22:45:52 GMT

If you are a TDD purist, you should know that accessing file system in Unit Test is violating the rule. But in our application, our infrastructural code often requires to access the configuration values form web.config/app.config. In this post, I will show you how can create a simple wrapper class which you can use in your unit tests without hitting the file system.

First, create a interface which will allow us to access the common sections of the configuration file:

public interface IConfigurationManager
{
    NameValueCollection AppSettings
    {
        get;
    }

    string ConnectionStrings(string name);

    T GetSection<T>(string sectionName);
}

Next, the implementation:

using System.Collections.Specialized;
using System.Configuration;

public class ConfigurationManagerWrapper : IConfigurationManager
{
    public NameValueCollection AppSettings
    {
        get
        {
            return ConfigurationManager.AppSettings;
        }
    }

    public string ConnectionStrings(string name)
    {
        return ConfigurationManager.ConnectionStrings[name].ConnectionString;
    }

    public T GetSection<T>(string sectionName)
    {
        return (T) ConfigurationManager.GetSection(sectionName);
    }
}

This is a very common pattern which you will find all over in the new ASP.NET 3.5 SP1 System.Web.Abstraction. The rule is whatever thing is not unit testable, create an interface with the exact same signature and create a wrapper class which internally calls the corresponding method/property.

Now lets say, we would like to do some processing with some configuration values like the following (By the way the Process() is a poor example):

public void Process()
{
    string appVersion = _configuration.AppSettings["version"];
    string connectionString = _configuration.ConnectionStrings("myDatabase");

    OutputCacheSettingsSection settings = _configuration.GetSection<OutputCacheSettingsSection>("system.web/caching/outputCacheSettings");
    int duration = 0;

    if (settings.OutputCacheProfiles.Count > 0)
    {
        OutputCacheProfile profile = settings.OutputCacheProfiles.Get("MyProfile");

        if (profile != null)
        {
            duration = profile.Duration;
        }
    }

    //Now perform operation with these values;
}

Now, we can write the unit test like the following which does not requires the web.config/app.config file:

[Fact]
public void Test_Process()
{
    _configuration.Expect(c => c.AppSettings).Returns(new NameValueCollection{ { "version", "1.0" } });
    _configuration.Expect(c => c.ConnectionStrings(It.IsAny<string>())).Returns(@"Data Source=.\SQLEXPRESS;Initial Catalog=Northwind;Integrated Security=True");

    OutputCacheProfile cacheProfile = new OutputCacheProfile("MyProfile") { Duration = 360 };
    OutputCacheSettingsSection cacheSection = new OutputCacheSettingsSection();
    cacheSection.OutputCacheProfiles.Add(cacheProfile);

    _configuration.Expect(c => c.GetSection<OutputCacheSettingsSection>(It.IsAny<string>())).Returns(cacheSection);

    _processor.Process();
}

Enjoy!!!

Download: UnitTestableConfiguration.zip

100% Unit Testable Linq To Sql Repository

kazimanzurrashid — Thu, 19 Feb 2009 16:32:51 GMT

In this post, I will show you how you can architect your Linq To Sql repository which will have 100% code coverage. I will use our favorite Northwind database along with my ongoing UnityCommonServiceLocatorMVC project. First, lets add a Linq To Sql diagram in our project and drag n drop the Category and Product table that will look something like following:

We are skipping the other tables as they are same that we are doing here, next we will create an interface which will abstract the Linq To Sql DataContext from our application.

public interface IDatabase : IDisposable
{
    IQueryable<Category> CategoryDataSource
    {
        get;
    }

    IQueryable<Product> ProductDataSource
    {
        get;
    }

    IQueryable<TEntity> GetQueryable<TEntity>() where TEntity : class;

    ITable GetEditable<TEntity>() where TEntity : class;

    void Insert<TEntity>(TEntity instance) where TEntity : class;

    void InsertAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class;

    void Delete<TEntity>(TEntity instance) where TEntity : class;

    void DeleteAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class;

    void SubmitChanges();
}

And now we will create a partial class for the DataContext that implements this interface:

public partial class Database : IDatabase
{
    public IQueryable<Category> CategoryDataSource
    {
        get
        {
            return GetQueryable<Category>();
        }
    }

    public IQueryable<Product> ProductDataSource
    {
        get
        {
            return GetQueryable<Product>();
        }
    }

    public virtual IQueryable<TEntity> GetQueryable<TEntity>() where TEntity : class
    {
        return GetTable<TEntity>();
    }

    public virtual ITable GetEditable<TEntity>() where TEntity : class
    {
        return GetTable<TEntity>();
    }

    public void Insert<TEntity>(TEntity instance) where TEntity : class
    {
        GetEditable<TEntity>().InsertOnSubmit(instance);
    }

    public void InsertAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class
    {
        GetEditable<TEntity>().InsertAllOnSubmit(instances);
    }

    public void Delete<TEntity>(TEntity instance) where TEntity : class
    {
        GetEditable<TEntity>().DeleteOnSubmit(instance);
    }

    public void DeleteAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class
    {
        GetEditable<TEntity>().DeleteAllOnSubmit(instances);
    }
}

By Default Linq To Sql exposes Sql Server tables as Table which is a sealed class, so we can not mock it. But Linq to Sql namespace has an interface ITable which the Table type implements and that is easy to mock, also this ITable exposes InsertOnSubmit, InsertAllOnSubmit, DeleteOnSubmit, DeleteAllOnSubmit. So in our interface we exposed the ITable instead of that concrete Table which makes this partial Database class completely unit testable. We will be using Moq and xUnit.net for our unit tests but you can also use RhinoMock, NUnit, MBUnit or MSTest.

public class DatabaseTest
{
    private readonly Mock<Database> _database;

    public DatabaseTest()
    {
        _database = new Mock<Database>("A dummy connection string");
    }

    [Fact]
    public void CategoryDataSource_Should_Call_GetQueryable()
    {
        _database.Expect(d => d.GetQueryable<Category>()).Returns(new List<Category>().AsQueryable()).Verifiable();

        Assert.NotNull(_database.Object.CategoryDataSource);

        _database.Verify();
    }

    [Fact]
    public void ProductDataSource_Should_Call_GetQueryable()
    {
        _database.Expect(d => d.GetQueryable<Product>()).Returns(new List<Product>().AsQueryable()).Verifiable();

        Assert.NotNull(_database.Object.ProductDataSource);

        _database.Verify();
    }

    [Fact]
    public void Insert_Should_Call_GetEditable_And_InsertOnSubmit()
    {
        var editable = new Mock<ITable>();
        var category = new Category();

        _database.Expect(d => d.GetEditable<Category>()).Returns(editable.Object).Verifiable();
        editable.Expect(e => e.InsertOnSubmit(category)).Verifiable();

        _database.Object.Insert(category);

        _database.Verify();
        editable.Verify();
    }

    [Fact]
    public void InsertAll_Should_Call_GetEditable_And_InsertAllOnSubmit()
    {
        var editable = new Mock<ITable>();
        var categories = new List<Category>();

        _database.Expect(d => d.GetEditable<Category>()).Returns(editable.Object).Verifiable();
        editable.Expect(e => e.InsertAllOnSubmit(categories)).Verifiable();

        _database.Object.InsertAll(categories);

        _database.Verify();
        editable.Verify();
    }

    [Fact]
    public void Delete_Should_Call_GetEditable_And_DeleteOnSubmit()
    {
        var editable = new Mock<ITable>();
        var category = new Category();

        _database.Expect(d => d.GetEditable<Category>()).Returns(editable.Object).Verifiable();
        editable.Expect(e => e.DeleteOnSubmit(category)).Verifiable();

        _database.Object.Delete(category);

        _database.Verify();
        editable.Verify();
    }

    [Fact]
    public void DeleteAll_Should_Call_GetEditable_And_DeleteAllOnSubmit()
    {
        var editable = new Mock<ITable>();
        var categories = new List<Category>();

        _database.Expect(d => d.GetEditable<Category>()).Returns(editable.Object).Verifiable();
        editable.Expect(e => e.DeleteAllOnSubmit(categories)).Verifiable();

        _database.Object.DeleteAll(categories);

        _database.Verify();
        editable.Verify();
    }
}

Now, lets create the repositories which uses this database:

public interface IProductRepository
{
    void Add(Product product);

    void Remove(Product product);

    Product FindById(int id);

    ICollection<Product> FindByCategoryId(int categoryId);

    ICollection<Product> FindAll();
}

public class ProductRepository : IProductRepository
{
    private readonly IDatabase _database;

    public ProductRepository(IDatabase database)
    {
        _database = database;
    }

    public void Add(Product product)
    {
        _database.Insert(product);
    }

    public void Remove(Product product)
    {
        _database.Delete(product);
    }

    public Product FindById(int id)
    {
        return _database.ProductDataSource.SingleOrDefault(p => p.ProductID == id);
    }

    public ICollection<Product> FindByCategoryId(int categoryId)
    {
        return _database.ProductDataSource.Where(p => p.CategoryID == categoryId).ToList().AsReadOnly();
    }

    public ICollection<Product> FindAll()
    {
        return _database.ProductDataSource.ToList().AsReadOnly();
    }
}

And the Unit Test for it:

public class ProductRepositoryTest
{
    private readonly Mock<IDatabase> _database;
    private readonly ProductRepository _repository;

    public ProductRepositoryTest()
    {
        _database = new Mock<IDatabase>();
        _repository = new ProductRepository(_database.Object);
    }

    [Fact]
    public void Add_Should_Use_Database()
    {
        _database.Expect(db => db.Insert(It.IsAny<Product>())).Verifiable();

        _repository.Add(new Product());

        _database.Verify();
    }

    [Fact]
    public void Remove_Should_Use_Database()
    {
        _database.Expect(db => db.Delete(It.IsAny<Product>())).Verifiable();

        _repository.Remove(new Product());

        _database.Verify();
    }

    [Fact]
    public void FindById_Should_Return_Correct_Product_For_The_Specified_Id()
    {
        SetupProductDataSource();

        var product = _repository.FindById(3);

        Assert.Equal(3, product.ProductID);
    }

    [Fact]
    public void FindByCategoryId_Should_Return_Correct_Products_For_The_Specified_CategoryId()
    {
        SetupProductDataSource();

        var products = _repository.FindByCategoryId(2);

        Assert.Equal(2, products.Count);
    }

    [Fact]
    public void FindAll_Should_All_Products()
    {
        SetupProductDataSource();

        var products = _repository.FindAll();

        Assert.Equal(5, products.Count);
    }

    private void SetupProductDataSource()
    {
        Category category1 = new Category{ CategoryID = 1, CategoryName = "Test 1" };
        Category category2 = new Category{ CategoryID = 2, CategoryName = "Test 2" };

        List<Product> products = new List<Product>
                                        {
                                            new Product{ ProductID = 1, ProductName = "Test 1", Category = category1},
                                            new Product{ ProductID = 2, ProductName = "Test 2", Category = category1},
                                            new Product{ ProductID = 3, ProductName = "Test 3", Category = category1},
                                            new Product{ ProductID = 4, ProductName = "Test 4", Category = category2},
                                            new Product{ ProductID = 5, ProductName = "Test 5", Category = category2}
                                        };

        _database.ExpectGet(db => db.ProductDataSource).Returns(products.AsQueryable());
    }
}

I am skipping the CategoryRepository as it almost identical, but you can check it in the attached source codes at the bottom of this post. If I run these unit tests with NCover, we will get the following picture:

As you can see that we have 100% coverage for both ProductRepository and CategoryRepository but 56% for the Database. But if you look it closely, you will find that we have 100% code coverage except the GetQueryable and GetEditable methods in the Database partial class .

Download: LinqTSqlCodeCoverage.zip

Domain Model (Developing KiGG v2.0 Part 1)

kazimanzurrashid — Thu, 12 Feb 2009 00:27:00 GMT

As mention in my previous post that I will be discussing the technical side of KiGG. So this is the beginning and it will be a multi-part series. I will try to put as much detail as possible, do let me know if I missed anything.

Just for a recap, KiGG is Web 2.0 style social news application where I am trying to exercise some of the best practice like TDD, DDD, SOLID etc with Microsoft supported tooling. If you want to see it in action just visit http://dotnetshoutout.com.

KiGG is already a fully functional application, but here I am starting from scratch, so the actual code might not look the same with following but it will show you how it is evolved as I am going to post more on it over the time.

Let us begin with the core functionalities:

User should be able to submit story.
- User will select a category and can specify multiple tags when submitting story.
- User should not be able to submit a story which already exists (based upon Url).
- The system will ensure the story is a .NET related story, otherwise it will need moderator approval prior make it visible to everyone.
User should be able to promote story.
- When the story has not been promoted by him/her.
- When the story has not been marked as spam by him/her.
User should be able to demote story.
- When the story has not been submitted by him/her.
- When the story has been previously promoted by him/her.
User should be able to mark story as spam.
- When the story has not been promoted by him/her.
- When the story has not been marked as spam by him/her.
- When story is not published.
User should be able to post comment.
- The system will ensure the comment is not a spam.
User should be able to subscribe/unsubscribe comments of a Story.
User should be able to Tag story.
User should be able to view the original story by clicking the link and the count should be maintained.
User Score should be increased/decreased based upon the above actions.
User should be able to view the story list by published/upcoming/category/tag/user etc.
Moderator should be able to Edit Story.
Moderator should be able to Delete Story.
Moderator should be able to Confirm a Story/Comment as Spam.
Moderator should be able to Approve a Story as not spam which was previously marked as spam.
Admin should be able to Lock/Unlock a User.
Admin should be able to change role of a User.
Admin should be able to Publish stories at periodic interval.

With the above functionalities we can come up with an object model which consists classes like User, Story, Tag, Category, Vote, MarkAsSpam, Comment:

Now, lets refine this domain model with TDD (I will skip the red part of red-green-refactor to save space of this post, but you should always exercise the red part while developing in this way).

Promoting

When promoting the story we have to check two things, user has not previously promoted it and not marked it as spam. Lets write the tests:

[Fact]
public void HasPromoted_Should_Return_False_When_User_Has_Not_Previously_Promoted()
{
    var user = new User();

    Assert.False(_story.HasPromoted(user));
}

[Fact]
public void HasMarkedAsSpam_Should_Return_False_When_User_Has_Not_Previously_MarkedAsSpam()
{
    var user = new User();

    Assert.False(_story.HasMarkedAsSpam(user));
}

And in Story:

public bool HasPromoted(User byUser)
{
    return Votes.Any(v => v.ByUser.Id == byUser.Id);
}

public bool HasMarkedAsSpam(User byUser)
{
    return MarkAsSpams.Any(m => m.ByUser.Id == byUser.Id);
}

Now, create a new method that internally calls these two methods, so that client can only call this single method instead of calling those, test:

[Fact]
public void CanPromote_Should_Return_True_When_Story_Has_Not_Been_Promoted()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.CanPromote(user));
}

[Fact]
public void CanPromote_Should_Return_True_When_Story_Has_Not_Been_MarkedAsSpam_By_The_User()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.CanPromote(user));
}

And in Story:

public bool CanPromote(User byUser)
{
    return !HasPromoted(byUser) && !HasMarkedAsSpam(byUser);
}

Now the actual promote, note that we have introduced a new property Timestamp in Vote, tests:

[Fact]
public void Promote_Should_Return_True_When_User_Can_Promote()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.Promote(DateTime.UtcNow, user));
}

[Fact]
public void Promote_Should_Add_User_Vote_In_Votes()
{
    var user = new User { Id = Guid.NewGuid() };

    _story.Promote(DateTime.UtcNow, user);

    Assert.True(_story.Votes.Count(v => v.ByUser.Id == user.Id) > 0);
}

And in Story:

private readonly List<Vote> _votes = new List<Vote>();

public ICollection<Vote> Votes
{
    get
    {
        return _votes.AsReadOnly();
    }
}

public bool Promote(DateTime at, User byUser)
{
    if (CanPromote(byUser))
    {
        Vote vote = new Vote
                        {
                            ByUser = byUser,
                            ForStory = this,
                            Timestamp = at
                        };

        _votes.Add(vote);

        return true;
    }

    return false;
}

Notice that I have exposed the Votes as read only collection, though the ReadOnlyCollection<T> of ObjectModel namespace should be more appropriate, but I would like to stick with the interface instead of concrete class. So adding vote in Votes will raise exception, the client always have to use the Promote method.

Demoting

Demoting is similar to promoting, we have to check that the User has not submitted the story and the story has been previously promoted by the user(You can only demote if you previously promoted it), tests:

[Fact]
public void CanDemote_Should_Return_True_When_Story_Has_Been_Promoted_By_The_User()
{
    //Promote it first
    var user = new User { Id = Guid.NewGuid() };
    _story.Promote(DateTime.UtcNow, user);

    Assert.True(_story.CanDemote(user));
}

[Fact]
public void Demote_Should_Return_True_When_User_Can_Demote()
{
    //Promote it first
    var user = new User { Id = Guid.NewGuid() };
    _story.Promote(DateTime.UtcNow, user);

    Assert.True(_story.Demote(user));
}

[Fact]
public void Demote_Should_Remove_User_Vote_From_Votes()
{
    //Promote it first
    var user = new User { Id = Guid.NewGuid() };
    _story.Promote(DateTime.UtcNow, user);

    _story.Demote(user);

    Assert.True(_story.Votes.Count(v => v.ByUser.Id == user.Id) == 0);
}

And in Story:

public bool CanDemote(User byUser)
{
    return (PostedBy.Id != byUser.Id) && HasPromoted(byUser);
}

public bool Demote(User byUser)
{
    if (CanDemote(byUser))
    {
        Vote vote = _votes.Single(v => v.ByUser.Id == byUser.Id);

        _votes.Remove(vote);

        return true;
    }

    return false;
}

Marking as Spam

Marking as spam is also similar to story promoting, only a new checking that is if the story is published, so we will need a new property which will indicate whether the story is published, lets create a new property PublishedAt of nullable DateTime and create an extension method:

public static bool IsPublished(this Story story)
{
    return (story.PublishedAt.HasValue);
}

we also introduced a new property Timestamp for MarkAsSpam like vote, tests:

[Fact]
public void CanMarkAsSpam_Should_Return_True_When_Story_Has_Not_Been_Published()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.CanMarkAsSpam(user));
}

[Fact]
public void CanMarkAsSpam_Should_Return_True_When_Story_Has_Not_Been_Promoted_By_The_User()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.CanMarkAsSpam(user));
}

[Fact]
public void CanMarkAsSpam_Should_Return_True_When_Story_Has_Not_Been_MarkedAsSpam_By_The_User()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.CanMarkAsSpam(user));
}

[Fact]
public void MarkAsSpam_Should_Return_True_When_User_Can_Mark_As_Spam()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.MarkAsSpam(DateTime.UtcNow, user));
}

[Fact]
public void MarkAsSpam_Should_Add_User_Marking_In_MarkAsSpams()
{
    var user = new User { Id = Guid.NewGuid() };

    _story.MarkAsSpam(DateTime.UtcNow, user);

    Assert.True(_story.MarkAsSpams.Count(m => m.ByUser.Id == user.Id) > 0);
}

And in Story

private readonly List<MarkAsSpam> _markAsSpams = new List<MarkAsSpam>();

public ICollection<MarkAsSpam> MarkAsSpams
{
    get
    {
        return _markAsSpams.AsReadOnly();
    }
}

public bool CanMarkAsSpam(User byUser)
{
    return !this.IsPublished() && !HasPromoted(byUser) && !HasMarkedAsSpam(byUser);
}

public bool MarkAsSpam(DateTime at, User byUser)
{
    if (CanMarkAsSpam(byUser))
    {
        MarkAsSpam markAsSpam = new MarkAsSpam
                                    {
                                        ByUser = byUser,
                                        ForStory = this,
                                        Timestamp = at
                                    };

        _markAsSpams.Add(markAsSpam);

        return true;
    }

    return false;
}

Post Comment

For comment we have to introduce few new properties, Id, Content and CreatedAt. We will skip the spam checking part for the future post, tests:

[Fact]
public void PostComment_Should_Return_New_Comment()
{
    var user = new User{ Id = Guid.NewGuid() };

    var comment = _story.PostComment("This is a dummy content", DateTime.UtcNow, user);

    Assert.NotNull(comment);
}

[Fact]
public void PostComment_Should_Increase_Comments_Collection()
{
    var previousCount = _story.Comments.Count;

    var user = new User { Id = Guid.NewGuid() };

    _story.PostComment("This is a dummy content", DateTime.UtcNow, user);

    Assert.True(_story.Comments.Count > previousCount);
}

And in Story:

private readonly List<Comment> _comments = new List<Comment>();

public ICollection<Comment> Comments
{
    get
    {
        return _comments.AsReadOnly();
    }
}

public Comment PostComment(string content, DateTime at, User byUser)
{
    Comment comment = new Comment
                          {
                              Id = Guid.NewGuid(),
                              ByUser = byUser,
                              ForStory = this,
                              CreatedAt = at,
                              Content = content
                          };

    _comments.Add(comment);

    return comment;
}

Subscribing/Unsubscribing Comments

When subscribing comment we will check if the user has already subscribed, if not we will subscribe otherwise we will ignore it, tests:

[Fact]
public void ContainsCommentSubscriber_Should_Return_False_When_User_Does_Not_Exist_In_CommentSubscribers_Collection()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.False(_story.ContainsCommentSubscriber(user));
}

[Fact]
public void SubscribeComment_Should_Increase_CommentSubscribers_Collection()
{
    var user = new User { Id = Guid.NewGuid() };

    var previousCount = _story.CommentSubscribers.Count;

    _story.SubscribeComment(user);

    Assert.True(_story.CommentSubscribers.Count > previousCount);
}

[Fact]
public void SubscribeComment_Should_Not_Increase_CommentSubscribers_Collection_When_User_Already_Exists()
{
    var user = new User { Id = Guid.NewGuid() };

    _story.SubscribeComment(user);

    var previousCount = _story.CommentSubscribers.Count;

    _story.SubscribeComment(user);

    Assert.Equal(_story.CommentSubscribers.Count, previousCount);
}

[Fact]
public void UnsubscribeComment_Should_Decrease_CommentSubscribers_Collection()
{
    var user = new User { Id = Guid.NewGuid() };
    _story.SubscribeComment(user);

    var previousCount = _story.CommentSubscribers.Count;

    _story.UnSubscribeComment(user);

    Assert.True(_story.CommentSubscribers.Count < previousCount);
}

And in Story:

private readonly List<User> _commentSubscribers = new List<User>();

public ICollection<User> CommentSubscribers
{
    get
    {
        return _commentSubscribers.AsReadOnly();
    }
}

public bool ContainsCommentSubscriber(User byUser)
{
    return _commentSubscribers.Any(cs => cs.Id == byUser.Id);
}

public void SubscribeComment(User byUser)
{
    if (!ContainsCommentSubscriber(byUser))
    {
        _commentSubscribers.Add(byUser);
    }
}

public void UnSubscribeComment(User byUser)
{
    if (ContainsCommentSubscriber(byUser))
    {
        var s = _commentSubscribers.Single(cs => cs.Id == byUser.Id);
        _commentSubscribers.Remove(s);
    }
}

Viewing Story

We need the track how many times a story has been viewed, so let us introduce another property ViewCount, Test:

[Fact]
public void View_Should_Increase_ViewCount()
{
    var previousCount = _story.ViewCount;

    _story.View();

    Assert.True(_story.ViewCount > previousCount);
}

And in Story:

public int ViewCount
{
    get;
    private set;
}

public void View()
{
    ViewCount += 1;
}

Increasing/Decreasing User Score

User score should be increased/decreased based upon the action like submitting/promoting/demoting etc. So first let us create an Enum which will hold some predefined User Actions:

public enum UserAction
{
    None = 0,
    AccountActivated = 1,
    StorySubmitted = 2,
    StoryViewed = 3,
    StoryPromoted = 4,
    StoryCommented = 5,
    StoryMarkedAsSpam = 6,
    SpamStorySubmitted = 7
}

With increasing/decreasing user score we also need to have the support to know the current score and query score for a given time period, so lets add a new class which holds the date, score and user action when increasing/decreasing score, tests:

[Fact]
public void CurrentScore_Should_Be_Zero_When_User_Is_Created()
{
    Assert.Equal(0, _user.CurrentScore);
}

[Fact]
public void IncreaseScoreBy_Should_Increase_CurrentScore()
{
    decimal previousScore = _user.CurrentScore;

    _user.IncreaseScoreBy(5, UserAction.StorySubmitted);

    Assert.Equal(previousScore + 5, _user.CurrentScore);
}

[Fact]
public void DecreaseScoreBy_Should_Decrease_CurrentScore()
{
    decimal previousScore = _user.CurrentScore;

    _user.DecreaseScoreBy(50, UserAction.SpamStorySubmitted);

    Assert.Equal(previousScore - 50, _user.CurrentScore);
}

And in User:

public DateTime CreatedAt
{
    get;
    set;
}

public decimal CurrentScore
{
    get
    {
        return GetScoreBetween(CreatedAt, DateTime.UtcNow);
    }
}

private decimal GetScoreBetween(DateTime from, DateTime to)
{
    return _userScores.Where(us => us.Timestamp >= from && us.Timestamp <= to).Sum(us => us.Score);
}

public void IncreaseScoreBy(decimal score, UserAction reason)
{
    AddScore(score, reason);
}

public void DecreaseScoreBy(decimal score, UserAction reason)
{
    AddScore(-score, reason);
}

private void AddScore(decimal score, UserAction reason)
{
    _userScores.Add(
                        new UserScore
                        {
                            OfUser = this,
                            Reason = reason,
                            Score = score,
                            Timestamp = DateTime.UtcNow
                        });
}

Tag Story

When submitting story, user should be able to specify tags for story and later on can view the stories with that specified tags, so we need to associate tag with both User and Story. Since it is a common behavior, we can create an interface which both Story and User has to implement:

public interface ITagContainer
{
    ICollection<Tag> Tags
    {
        get;
    }

    void AddTag(Tag tag);

    void RemoveTag(Tag tag);

    void RemoveAllTags();

    bool ContainsTag(Tag tag);
}

Though composition is better than inheritance, but for the time being lets keep it this way. Since both is the same I am only showing the Story, tests:

[Fact]
public void Tags_Should_Be_Empty_When_Story_Is_Created()
{
    Assert.Empty(_story.Tags);
}

[Fact]
public void Contains_Should_Return_True_When_Tag_Exists_In_Tags()
{
    var tag = new Tag
                  {
                      Id = Guid.NewGuid(),
                      Name = "Dummy Tag"
                  };

    _story.AddTag(tag);

    Assert.True(_story.ContainsTag(new Tag { Name = "Dummy Tag" }));
}

[Fact]
public void AddTag_Should_Increase_Tags_Collection()
{
    int previousCount = _story.Tags.Count;

    var tag = new Tag
                  {
                      Id = Guid.NewGuid(),
                      Name = "Dummy Tag"
                  };

    _story.AddTag(tag);

    Assert.True(_story.Tags.Count > previousCount);
}

[Fact]
public void AddTag_Should_Not_Increase_Tags_Collection_For_Duplicate_Tag()
{
    var tag1 = new Tag
                   {
                       Id = Guid.NewGuid(),
                       Name = "Dummy Tag"
                   };

    _story.AddTag(tag1);

    int previousCount = _story.Tags.Count;

    var tag2 = new Tag
                   {
                       Id = Guid.NewGuid(),
                       Name = "Dummy Tag"
                   };

    _story.AddTag(tag2);

    Assert.Equal(previousCount, _story.Tags.Count);
}

[Fact]
public void RemoveTag_Should_Decrease_Tags_Collection()
{
    var tag = new Tag
                  {
                      Id = Guid.NewGuid(),
                      Name = "Dummy Tag"
                  };

    _story.AddTag(tag);

    int previousCount = _story.Tags.Count;

    _story.RemoveTag(new Tag { Name = "Dummy Tag" });

    Assert.True(_story.Tags.Count < previousCount);
}

[Fact]
public void RemoveAllTags_Should_Make_Tags_Collection_Empty()
{
    _story.AddTag(new Tag { Id = Guid.NewGuid(), Name = "Dummy Tag1" });
    _story.AddTag(new Tag { Id = Guid.NewGuid(), Name = "Dummy Tag2" });

    _story.RemoveAllTags();

    Assert.Empty(_story.Tags);
}

And in story:

private readonly List<Tag> _tags = new List<Tag>();

public ICollection<Tag> Tags
{
    get
    {
        return _tags.AsReadOnly();
    }
}

public void AddTag(Tag tag)
{
    if (!ContainsTag(tag))
    {
        _tags.Add(tag);
    }
}

public void RemoveTag(Tag tag)
{
    Tag sameNameTag = _tags.SingleOrDefault(t => t.Name == tag.Name);

    if (sameNameTag != null)
    {
        _tags.Remove(sameNameTag);
    }
}

public void RemoveAllTags()
{
    _tags.Clear();
}

public bool ContainsTag(Tag tag)
{
    return _tags.Any(t => t.Name == tag.Name);
}

Skipping few functionalities

We will skip story submit, edit, delete, confirm as spam, view story list for future post.

Changing Role of User

Admin should be able to change role of User. So we need to introduce another property in User. We will have some predefined role and the functionalities for each role should be static. First, let create an Enum

public enum Roles
{
    User = 0,
    Bot = 1,
    Moderator = 2,
    Administrator = 4
}

Next, the user will have a property Role and a method to change the role, we will skip the checking whether the caller is an admin for future when changing the role, test:

[Fact]
public void ChangeRole_Should_Update_Role()
{
    _user.ChangeRole(Roles.Administrator);

    Assert.Equal(Roles.Administrator, _user.Role);
}

and in User:

public Roles Role
{
    get;
    private set;
}

public void ChangeRole(Roles role)
{
    Role = role;
}

Lock/Unlock User

Admin should be able to lock/unlock user. It should be same as Role, we will again skip the admin calling checking for future, tests:

[Fact]
public void Lock_Should_Update_IsLocked()
{
    _user.Lock();

    Assert.True(_user.IsLocked);
}

[Fact]
public void Unlock_Should_Update_IsLocked()
{
    _user.Unlock();

    Assert.False(_user.IsLocked);
}

And in User:

public bool IsLocked
{
    get;
    private set;
}

public void Lock()
{
    IsLocked = true;
}

public void Unlock()
{
    IsLocked = false;
}

Approving Story

User can Mark story as spam if they think the story is not relevant, also our spam checkers can block a story from appearing if they detect it as spam. But the Moderator should be the final judge for confirming a story as spam, if the Moderator finds a story is not spam, s/he will approve the story which makes sure the story appearance. For marking the Story as approved we will introduce a new Property ApprovedAt, same as Story published, tests:

[Fact]
public void Approve_Should_Update_ApprovedAt()
{
    var now = DateTime.UtcNow;

    _story.Approve(now);

    Assert.Equal(now, _story.ApprovedAt);
}

And in Story:

public DateTime? ApprovedAt
{
    get;
    private set;
}

public void Approve(DateTime at)
{
    ApprovedAt = at;
}

Note that we are again skipping the checking if the caller is Moderator in Approve method for future.

Publishing Story

Story publish is a process where popular stories appears in the front page, certainly there should be different strategies for calculating the popularity of story, which we will again it skip for future post, for the time being we will only focus once a story is qualified to publish how do we mark it. As mentioned in the Marking as Spam section that once a Story is published we will update its PublishedAt property, but updating only the PublishedAt does not serves our purpose as we also have to know the Rank to order it in the list. Tests:

[Fact]
public void Publish_Should_Update_PublishedAt()
{
    var now = DateTime.UtcNow;

    _story.Publish(now, 1);

    Assert.Equal(now, _story.PublishedAt);
}

[Fact]
public void Publish_Should_Update_Rank()
{
    _story.Publish(DateTime.UtcNow, 1);

    Assert.Equal(1, _story.Rank);
}

And in story:

public DateTime? PublishedAt
{
    get;
    private set;
}

public int? Rank
{
    get;
    private set;
}

public void Publish(DateTime at, int rank)
{
    PublishedAt = at;
    Rank = rank;
}

The following is final object model of this part that we have done so far:

You can also download the complete code from the bottom of this post.

There are few points in the above which I like to highlight

Note that in above we are only focusing on the Domain Logic, we did not mentioned anything about database, UI or any other infrastructural stuffs.
Almost all of the code blocks are 3/4 lines long which is easy to understand and unit test.
There are certain functionalities in the above can be also achieved by using only properties instead of using method, for example in the User we can have IsLocked property with both getter and setter but instead we have created Lock, Unlock method and readonly property IsLocked which I think makes it more explicit and also expressive.

In the next post, we will check how to map this domain model into the database and create repository with LinqToSql with 100% code coverage.

Stay tuned!!!

Download: Source Code

Custom Linq Provider

kazimanzurrashid — Sat, 10 Nov 2007 22:05:47 GMT

My ex-partner of crime Mehfuz recently wrote an excellent article on how to develop a custom Linq Provider. In this article he shows how to interact with the popular photo sharing site Flickr with a custom Linq provider. Check it out.