Mocking EF DbContext and DbContextTransaction with Proxy

Introduction

If you use DbContextTransaction through DbContext.Database.BeginTransaction() in your context, you can't mock it. Because DbContextTransaction has just internal constructors. Therefore, you will get this error System.NotSupportedException: Parent does not have a default constructor. The default constructor must be explicitly defined.

I have already published solution for this problem which uses adapter pattern. It gives you full control of DbContext.Database. But if you don't need full control of DbContext.Database, it's over-engineering.

I will solve the same problem with using proxy pattern.

Background

Proxy

Provide a surrogate or placeholder for another object to control access to it.

Using the Code

First, I will show you how to create a proxy for DbContextTransaction. Then, I will show you how we implement this proxy in our context. After that, I will show you usage with an example. At last, I will show you how to mock easily.

Create Proxy and Implement in DbContext

We create a proxy to access control of DbContextTransaction.

public interface IDbContextTransactionProxy : IDisposable
 {
     void Commit();

     void Rollback();
 }

 /// <summary>
 /// This is proxy. We want accessing control of DbContextTransaction class.
 /// Because we can't write unit test for BeginTransaction.
 /// DbContextTransaction does not have public constructors.
 /// </summary>
 public class DbContextTransactionProxy : IDbContextTransactionProxy
 {
     /// <summary>
     /// Real Class which we want to control.
     /// We can't mock it's because it does not have public constructors.
     /// </summary>
     private readonly DbContextTransaction _transaction;

     public DbContextTransactionProxy(DbContext context)
     {
         _transaction = context.Database.BeginTransaction();
     }

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

     public void Rollback()
     {
         _transaction.Rollback();
     }

     public void Dispose()
     {
         _transaction.Dispose();
     }
 }

When DbContextTransactionProxy is constructed, it creates a new DbContextTransaction and manages its control. Therefore, we can mock DbContextTransactionProxy beside of DbContextTransaction.

Let's implement this proxy in our context.

public interface IBrokerContext : IDisposable
{
    DbSet<Customer> Customers { get; set; }
    int SaveChanges();
    IDbContextTransactionProxy BeginTransaction();
    int ExecuteSqlCommand(string sql, params object[] parameters);
 }

public class BrokerContext : DbContext, IBrokerContext
{
 .
 .
 .

  public DbSet<Customer> Customers { get; set; }

  /// <summary>
  /// When we call begin transaction.
  /// Our proxy creates new Database.BeginTransaction and
  /// gives DbContextTransaction's control to proxy.
  /// We do this for unit test.
  /// </summary>
  /// <returns>Proxy which controls DbContextTransaction(Ef transaction class)
  /// </returns>
  public IDbContextTransactionProxy BeginTransaction()
  {
     return new DbContextTransactionProxy(this);
  }

  public int ExecuteSqlCommand(string sql, params object[] parameters)
  {
     return Database.ExecuteSqlCommand(sql, parameters);
  }
}

Using Proxy in Code

Here, we add balance to customer. Then, we execute a SQL command and we want both in a transaction.

public class CustomerService
 {
   private readonly IBrokerContext _context;

   public CustomerService(IBrokerContext context)
   {
     _context = context;
   }

   public void Give5DolarAndMakeCustomerHappy(string customerName)
   {
      //Here we begin a transaction through proxy.
      using (var transaction = _context.BeginTransaction())
      {
        try
          {
            var customer = _context.Customers.Single(x => x.Name == customerName);
            customer.Feels = "Happy";
            //Here we run execute sql command which context can't track.
            //That's why we use transaction.
            _context.ExecuteSqlCommand
            ("Update customers set balance=balance+5 where id=@p0", customer.Id);
            _context.SaveChanges();
            transaction.Commit();
           }
              catch (Exception e)
           {
                  transaction.Rollback();
           }
       }
    }
  }

Mocking DbContext and DbContextTransactionProxy

We will not get any error because now we mock DbContextTransactionProxy instead of DbContextTransaction.

var mockedBrokerContext = new Mock<IBrokerContext>();
var mockedDbTransaction = new Mock<IDbContextTransactionProxy>();
mockedBrokerContext.Setup
      (x => x.BeginTransaction()).Returns(mockedDbTransaction.Object);

Conclusion

I have showed here how to mock DbContextTransaction which is Entity Framework library. But you can apply this solution for all 3^rd libraries which you can't mock or it's very hard to mock.