ASP.NET Testing DbContext a metodi locali

Question

Ho un progetto ASP.NET MVC, e sto scrivendo il mio servizio qualcosa sulla falsariga di questo:

public class UserService : IUserService 
{ 
    public void AddUser(UserModel userModel) 
    { 
     if (ModelState.IsValid){ 
      var user = new User 
      { 
       FirstName = userModel.FirstName, 
       LastName = userModel.LastName, 
       Email = userModel.Email, 
       Age = userModel.Age 
      }; 
      using (var context = new MyDbContext()) 
      { 
       context.Users.Add(user); 
      } 
     } 
    } 
    //... More code for service 
} 

E la mia classe DbContext:

public class MyDbContext : DbContext 
{ 
    public MyDbContext(): base("name=mydb"){} 

    public DbSet<User> Users {get; set;} 

    //.. More domain objects. 
} 

Questo funziona bene per la maggior parte, ma il problema sorge quando voglio provare e testarlo. Sto seguendo le linee guida generali here con derisione, ma solo se DbContext è dichiarato come istanza di classe, al contrario di una variabile funzionale. Voglio farlo in questo modo perché mi consente di avere il controllo sulla transazione e sullo smaltimento del contesto. Qualcuno ha qualche suggerimento su come farlo?

mie schernisce sono come questo:

public class UserServiceTest 
{ 
    [Fact] 
    public void TestAddUser() 
    { 
     var userSet = GetQueryableMockDbSet(userData.ToArray()); 
     var context = new MyDbContext 
     { 
      Users = userSet 
     }; 
     var userService = new UserService(); 
     userService.AddUser(); // HOW DO I GET CONTEXT IN HERE? 
    } 

    private static DbSet<T> GetQueryableMockDbSet<T>(params T[] sourceList) where T : class 
     { 
      var queryable = sourceList.AsQueryable(); 

      var dbSet = new Mock<DbSet<T>>(); 
      dbSet.As<IQueryable<T>>().Setup(m => m.Provider).Returns(queryable.Provider); 
      dbSet.As<IQueryable<T>>().Setup(m => m.Expression).Returns(queryable.Expression); 
      dbSet.As<IQueryable<T>>().Setup(m => m.ElementType).Returns(queryable.ElementType); 
      dbSet.As<IQueryable<T>>().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator()); 

      return dbSet.Object; 
     } 
} 

Answer 1

Un modo per raggiungere il tuo obiettivo di

voglio farlo in questo modo perché mi permette di avere il controllo sulla disposizione delle transazioni e il contesto.

sarebbe quella di fare qualcosa sulla falsariga di

public class UserService : IUserService { 
    private ContextFactory _ContextFactory; 

    public UserService(ContextFactory contextFactory) { 
     _ContextFactory = contextFactory; 
    } 

    public void AddUser(UserModel userModel) { 
     ... 
     using (var context = _ContextFactory.CreateInstance()) { 
      context.Users.Add(user); 
     } 
    } 

}

Ciò consentirebbe di iniettare diverse istanze di ContextFactory che provocherebbero la DbContext utilizzando la Falsa

Answer 2

è necessario passare la DbContext nel costruttore del servizio. Il modo più semplice per farlo è iniziare a utilizzare qualsiasi framework IoC (AutoFac, Unity, Ninject ecc.). Per simulare il database il modo più semplice è quello di iniziare a utilizzare qualsiasi libreria di derisione come Moq e RhinoMocks.

public class UserService : IUserService 
{ 
    private MyDbContext _context; 

    public UserService (MyDbContext dbContext) 
    { 
     _context = dbContext; 
    } 
} 

Answer 3

I preferirei sicuramente l'approccio IOC ma se vuoi una soluzione rapida senza riscrivere troppo codice puoi fare qualcosa del genere:

public class UserService : IUserService 
{ 
    public static Func<MyDbContext> CreateContext =() => new MyDbContext(); 

    public UserService() 
    { 
    } 

    public void AddUser(UserModel userModel) 
    { 
     ... 
     using (var context = CreateContext()) 
     { 
      context.Users.Add(user); 
     } 
    } 
} 

Non c'è bisogno di cambiare il vostro codice di produzione ma nel tuo TestMethod si può fare

var context = new MyDbContext 
    { 
     Users = userSet 
    }; 
    UserService.CreateContext =() => context;