使用Effort和dbContext使用Entity Framework创建的数据库进行单元测试

Question

I am trying to create fake database instance using Effort, but I encountered to a problem. ObjectContextFactory has a CreateTransistent generic method which expects an ObjectContext type to be defined:

public static T CreateTransient<T>( ) where T : ObjectContext;

So as far as I understand generic types I can define:

class MyObjectContextClass : ObjectContext
{
   //Entity definition here
}

So I can do following in unit test class:

var effortContext = ObjectContextFactory.CreateTransient<MyObjectContextClass>()

So far so good, right? But my context class inherits from dbContext class:

class MyRealDbContextClass : DbContext
{
    // Entity definition here
}

I found that DbContext is a wrapper class and it consist of ObjectContext

So my question is: how can I retrieve type of my custom ObjectContext so I can use it in effort static method? I need something like:

var type = MyRealDbContextClass.GetObjectContextType();

So I can:

var effortContext = ObjectContextFactory.CreateTransient<type>()

Answer 1

What I have done in the past is that I define a method in my Base test class (since this method will be required by all tests) to generate my dbset like:

public static IDbSet<T> GenerateSet<T>(IList<T> data) where T : class
    {
        IQueryable<T> queryable = data.AsQueryable();
        IDbSet<T> dbSet = MockRepository.GenerateMock<IDbSet<T>, IQueryable>();
        dbSet.Stub(x => x.Provider).Return(queryable.Provider);
        dbSet.Stub(x => x.Expression).Return(queryable.Expression);
        dbSet.Stub(x => x.ElementType).Return(queryable.ElementType);
        dbSet.Stub(x => x.GetEnumerator()).Return(null).WhenCalled(x => queryable.GetEnumerator());

        return dbSet;
    }

And then in my Test classes i can do something like:

[TestClass()]
public class ConcreteText: TestBase
{    
    private IMyDbContext _context;

    [TestInitialize]
    public new void Initialize()
    {
        base.Initialize();
        _context = MockRepository.GenerateMock<IMyDbContext>();
        _context.Stub(x => x.DbSetName).PropertyBehavior(); // Name of your dbset
        _context.DbSetName = GenerateSet(DbSetCollection); // Define a mock dbset collection
    }
 }

Answer 2

Instead of using:

var effortContext = ObjectContextFactory.CreateTransient<MyObjectContextClass>()

I used:

var con = Effort.EntityConnectionFactory.CreatePersistent(connectionString);

Then I can use the effort DB connection in my DbContext class

using System.Data.Common;
using System.Data.Entity;

namespace MC.ClientApi.CompanyProfile.Repository
{
    public partial class MyDBCoreDBEntities : DbContext
    {
        public MyDBCoreDBEntities(string connectionString)
            : base(connectionString)
        {
        }
        public MyDBCoreDBEntities(DbConnection connection) : base(connection, true) { }
    }
}

Full example of how I am doing my unit testing:

My repository method uses a factory to create the context

Repository:

public class OrganizationOptionsRepository : BaseEFRepository, IOrganizationOptionsRepository
    {
        private readonly IContextFactory ContextFactory;

        public OrganizationOptionsRepository(IContextFactory contextFactory)
        {
            ContextFactory = contextFactory;
        }

        public Result<IList<Country>> GetAllCountries()
        {
            using (var context = ContextFactory.CreateNew())
            {
                IQueryable<Country> query = context.Countries.OrderBy(x => x.NiceName);
                IList<Country> resultList = query.FromCache().ToList();
                return Result.Ok(resultList);
            }
        }
    }

Factory:

public class ContextFactory : IContextFactory
    {
        public string ConnectionString { get; set; }
        public ContextFactory(string connectionString)
        {
            ConnectionString = CreateEFConnectionString(connectionString, RepositoryConst.EdmxName);
        }

        public MyDBCoreDBEntities CreateNew()
        {
            return new MyDBCoreDBEntities(ConnectionString);
        }
    }

My unit test inherits from my factory and returns the effort context instead of the real context

public class TestContextFactory : IContextFactory
    {
        public MyDBCoreDBEntities CreateNew()
        {
            var connectionString = "sampleConnString";
            var con = Effort.EntityConnectionFactory.CreatePersistent(connectionString);
            return new MyDBCoreDBEntities(con);
        }


    }

My test initialize method:

   [TestInitialize]
        public void Initialize()
        {
            ContextFactory = new TestContextFactory();
            _Context = ContextFactory.CreateNew();
            Repository = new NyDBRepository(ContextFactory);
        }