But, despite that, I’ve let code close to the data access be left untested. This has been due to the pain I thought it would be to create and maintain those tests. And also I’ve thought that those tests would be way to slow to have among my other unit tests (which we want to be fast, so that we run them often).

For the first two years of my career this was not a big problem. We rarely had bugs in our data access code as it mostly consisted of simple, straight forward code. So I hadn’t really given it much thought. Until lately that is.

Then we started to get performance issues as we got some really large organizations to use or software. To resolve the performance issues we made our data access smarter so it could make more efficient queries to the database. As smarter often means more code, or at least added complexity, I saw the need of automatic tests to guarantee the quality of the code.

So, I read some articles on using SQLite with NHibernate. After some pain setting it all up, I accomplished my goal of easy data access testing. So say that I want to test GetCustomerByName in the following class (in real life I wouldn’t test methods that are this simple, but it’s just to show the idea):

public class CustomerDao
{
    private readonly INHibernateManager _sessionManager;
 
    public CustomerDao(INHibernateManager sessionManager)
    {
        _sessionManager = sessionManager;
    }
 
    public Customer GetCustomerByName(string name)
    {
        var session = _sessionManager.CurrentSession;
 
        return session.CreateQuery("from Customer where Name = :name")
            .SetParameter("name", name)
            .UniqueResult<Customer>();
    }
}

Then I can write a test like this:

public class CustomerDaoTest : BaseTest
{
    [Test]
    public void CanGetCustomerByName()
    {
        Database.Init();
        var customerA = new Customer { Name = "A" };
        var customerB = new Customer { Name = "B" };              
        Database.Save(customerA, customerB);        
        var customerDao = new CustomerDao(Database);
 
        var result = customerDao.GetCustomerByName("B");
 
        Assert.That(result, Is.EqualTo(customerB));
    }
}

For this to work I have a class called TestDatabase with the following code:

public class TestDatabase : INHibernateManager
{
    private static ISessionFactory m_sessionFactory;        
    private static SchemaExport SchemaExport;
    private ISession m_session;
 
    public void Init()
    {
        if (m_sessionFactory == null)
        {
            Configuration config = CreateNHibernateConfig();
 
            m_sessionFactory = config.BuildSessionFactory();
 
            SchemaExport = new SchemaExport(config);
        }
        if (m_session != null)
        {
            m_session.Close();
        }
        m_session = m_sessionFactory.OpenSession();
        m_session.BeginTransaction();
 
        var connection = m_session.Connection;
        SchemaExport.Execute(false, true, false, false, connection, null);
    }
 
    private static Configuration CreateNHibernateConfig()
    {
        Configuration config = new Configuration();
        config.Properties.Clear();
 
        config.SetProperty("hibernate.connection.driver_class", 
            "NHibernate.Driver.SQLite20Driver");
        config.SetProperty("hibernate.dialect", "NHibernate.Dialect.SQLiteDialect");
        config.SetProperty("hibernate.connection.connection_string", 
            "Data Source=:memory:;Version=3;New=True;");
        config.SetProperty("hibernate.cache.use_second_level_cache", "false");
        config.SetProperty("hibernate.hbm2ddl.auto", "create");
 
        config.AddAssembly("MyAssembly"); // Change this to your assembly
 
        return config;
    }
 
    public ISession Session
    {
        get { return m_session; }
    }
 
    public void Save(params object[] entities)
    {
        foreach (var entity in entities)
        {
            Session.Save(entity);
        }
        Session.Flush();
    }
 
    ISession INHibernateManager.CurrentSession
    {
        get { return m_session; }
    }
}

And I’ve also added the following field to my BaseTest class:

[TestFixture]
public class BaseTest
{
    protected readonly TestDatabase Database = new TestDatabase();
 
    // More code here...
}

So, in summary, I’ve shown a pretty easy way of doing database testing. Even though the method under test was really simple in the example, the same technique could be used for much more complex scenarios.

Besides using the files from the NHibernate 1.2 release, I had to download the subversion source code for Castle.Facilities.NHibernateIntegration.dll. Then I had to make a few adjustments to the code for it to compile against NHibernate 1.2.

After I had upgraded the dll’s, the Cuyahoga compiled. But when I run it NHibernate complained on some things like missing virtuals and wrong mapping scheme (urn:nhibernate-mapping-2.0 instead of urn:nhibernate-mapping-2.2). After that it seems to be working nice.

You can download the patch for Cuyahoga 1.5 source code here. And for Cuyahoga’s latest trunk here.

Unfortunately, I’ve been having some problem applying the entire patches. It complains about some strange character in the beginning of some of the repository files, so you might have to manually edit some files. (The patch file is actually quite human-readable so it can be of help in the manual process). But for those that start from scratch I’ve also created a ready package of Cuyahoga 1.5 with patch applied. Download it here.