Click here to Skip to main content
12,881,671 members (32,419 online)
Click here to Skip to main content

Stats

98.4K views
293 downloads
176 bookmarked
Posted 23 May 2007

How design patterns can help you in developing unit testing-enabled applications

, 15 Nov 2007 CPOL
This article shows how you can mix together Model-View-Presenter, Domain Model, Services, ActiveRecord, and Repository patterns to create a testable application.
nunit.framework.dll
Northwind.DataAccess
Northwind.DataAccess.csproj.user
Properties
Query
Repository
Northwind.DataAccess.Test
Northwind.DataAccess.Test.csproj.user
Properties
Northwind.Domain
Dao
Model
Northwind.Domain.csproj.user
Presentation
Properties
Repository
TransferObjects
Northwind.Domain.Test
Northwind.Domain.Test.csproj.user
Properties
Northwind.Presentation
Northwind.Presentation.csproj.user
Properties
Northwind.Presentation.Test
Northwind.Presentation.Test.csproj.user
Properties
Northwind.Services
Northwind.Services.csproj.user
Properties
Northwind.Services.Test
Northwind.Services.Test.csproj.user
Properties
Northwind.TransferObjects
Model
Northwind.TransferObjects.csproj.user
Presentation
Properties
Northwind.TransferObjects.Test
Northwind.TransferObjects.Test.csproj.user
Properties
Northwind.UI
Northwind.UI.csproj.user
NorthWind.UI.suo
Properties
Northwind.UI.Controls
Northwind.UI.Controls.csproj.user
Properties
Castle.ActiveRecord.dll
Castle.Core.dll
Iesi.Collections.dll
log4net.dll
NHibernate.dll
NMock2.dll
using Castle.ActiveRecord;
using Castle.ActiveRecord.Framework;
using NHibernate;
using NHibernate.Expression;
using Northwind.DataAccess;
using Northwind.DataAccess.Query;
using Northwind.Domain;
using Northwind.Domain.Model;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Text;

namespace Northwind.DataAccess.Repository
{
    public abstract class InMemoryRepositoryBase<T, t> : IRepository<T, t> where T : DomainBase<t>
    {
        private Dictionary<t, T> inMemoryDictionary = new Dictionary<t, T>();
        protected static t lastId;

        public virtual T Load(t id)
        {
            T domainObject = null;

            if (inMemoryDictionary.TryGetValue(id, out domainObject))
            {
                domainObject.IsNew =
                domainObject.IsDirty = false;
                LoadChildren(domainObject);
                return domainObject;
            }

            throw new NotFoundException(typeof(T).Name + " not found for id " + id);
        }

        public void AddOrUpdate(ISession session, T domainObject)
        {
            if (domainObject.IsNew)
            {
                PropertyInfo[] props = domainObject.GetType().GetProperties();
                PropertyInfo pkInfo = null;
                foreach (PropertyInfo pi in props)
                {
                    if (pi.Name == "ID" && pi.DeclaringType.FullName == typeof(T).FullName)
                    {
                        pkInfo = pi;
                    }
                }
                
                foreach (Attribute att in pkInfo.GetCustomAttributes(true))
                {
                    if (att is PrimaryKeyAttribute)
                    {
                        if (((PrimaryKeyAttribute)att).Generator == PrimaryKeyType.Identity)
                        {
                            lastId = (t)GetNextID();
                            domainObject.ID = lastId;
                            break;
                        }
                    }
                }
                inMemoryDictionary.Add(domainObject.ID, domainObject);
                domainObject.IsNew = false;
                domainObject.IsDirty = false;
            }
            else
            {
                if (domainObject.IsDirty)
                {
                    inMemoryDictionary[domainObject.ID] = domainObject;
                    domainObject.IsDirty = false;
                }
            }
            AddOrUpdateChildren(session, domainObject);
        }

        public void Remove(ISession session, T domainObject)
        {
            RemoveChildren(session, domainObject);
            if (inMemoryDictionary.ContainsKey(domainObject.ID))
            {
                inMemoryDictionary.Remove(domainObject.ID);
            }
        }

        public virtual T[] FetchByExample(T example)
        {
            IList<T> result = new List<T>();
            foreach (object dictionaryItem in inMemoryDictionary.Values)
            {
                T domainObject = (T)dictionaryItem;

                bool match = true;

                //Try to match ID property
                if (example.ID != null)
                {
                    if (!domainObject.ID.Equals(example.ID))
                    {
                        match = false;
                    }
                }
                else //Try to match the other properties
                {
                    foreach (PropertyInfo pi in typeof(T).GetProperties())
                    {
                        bool canCompare = false;

                        foreach (object o in pi.GetCustomAttributes(true))
                        {
                            if (o is PrimaryKeyAttribute || o is PropertyAttribute)
                            {
                                canCompare = true;
                                break;
                            }
                        }

                        if (canCompare)
                        {
                            object exampleValue = pi.GetValue(example, null);
                            object dictionaryValue = pi.GetValue(domainObject, null);

                            if (exampleValue != null)
                            {
                                if (exampleValue != dictionaryValue)
                                {
                                    match = false;
                                    break;
                                }
                            }
                        }
                    }
                }

                if (match)
                {
                    result.Add(domainObject);
                }
            }

            T[] ret = new T[result.Count];
            int index = 0;
            foreach (T item in result)
            {
                ret[index] = item;
                index++;
            }

            return ret;
        }

        protected abstract object GetNextID();

        protected virtual void LoadChildren(T domainObject)
        {
        }

        protected virtual void AddOrUpdateChildren(ISession session, T domainModel)
        {
        }

        protected virtual void RemoveChildren(ISession session, T domainModel)
        {
        }
    }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author


You may also be interested in...

Pro
Pro
Permalink | Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.170422.1 | Last Updated 15 Nov 2007
Article Copyright 2007 by Marcelo Ricardo de Oliveira
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid