Mock AsNoTracking Entity Framework

Question

Come si simula il metodo AsNoTracking?
Nell'esempio seguente, DbContext si è iniettato nella classe di servizio. Funziona correttamente se rimuovo il metodo di estensione AsNoTracking dal metodo GetOrderedProducts, ma con il test AsNoTracking non riesce perché restituisce null. Ho anche provato a prendere in giro AsNoTracking per restituire il valore corretto ma non ha funzionato.

rendimenti

public interface IUnitOfWork 
{ 
    IDbSet<TEntity> Set<TEntity>() where TEntity : class; 
    int SaveAllChanges(); 
} 

public class Entites : DbContext, IUnitOfWork 
{ 
    public virtual DbSet<Product> Products { get; set; } // This is virtual because Moq needs to override the behaviour 

    public new virtual IDbSet<TEntity> Set<TEntity>() where TEntity : class // This is virtual because Moq needs to override the behaviour 
    { 
     return base.Set<TEntity>(); 
    } 

    public int SaveAllChanges() 
    { 
     return base.SaveChanges(); 
    } 
} 

    public class ProductService 
{ 
    private readonly IDbSet<Product> _products; 
    private readonly IUnitOfWork _uow; 

    public ProductService(IUnitOfWork uow) 
    { 
     _uow = uow; 
     _products = _uow.Set<Product>(); 
    } 
    public IEnumerable<Product> GetOrderedProducts() 
    { 
     return _products.AsNoTracking().OrderBy(x => x.Name).ToList(); 
    } 
} 

    [TestFixture] 
public class ProductServiceTest 
{ 
    private readonly ProductService _productService; 

    public ProductServiceTest() 
    { 
     IQueryable<Product> data = GetRoadNetworks().AsQueryable(); 
     var mockSet = new Mock<DbSet<Product>>(); 
     mockSet.As<IQueryable<Product>>().Setup(m => m.Provider).Returns(data.Provider); 
     mockSet.As<IQueryable<Product>>().Setup(m => m.Expression).Returns(data.Expression); 
     mockSet.As<IQueryable<Product>>().Setup(m => m.ElementType).Returns(data.ElementType); 
     mockSet.As<IQueryable<Product>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator()); 
     var context = new Mock<Entites>(); 
     context.Setup(c => c.Products).Returns(mockSet.Object); 
     context.Setup(m => m.Set<Product>()).Returns(mockSet.Object); 
     context.Setup(c => c.Products.AsNoTracking()).Returns(mockSet.Object); 
     _productService = new ProductService(context.Object); 
    } 

    private IEnumerable<Product> GetRoadNetworks() 
    { 
     return new List<Product> 
     { 
      new Product 
      { 
       Id = 1, 
       Name = "A" 
      }, 
      new Product 
      { 
       Id = 2, 
       Name = "B" 
      }, 
      new Product 
      { 
       Id = 1, 
       Name = "C" 
      } 
     }; 
    } 

    [Test] 
    public void GetOrderedProductTest() 
    { 
     IEnumerable<Product> products = _productService.GetOrderedProducts(); 
     List<string> names = products.Select(x => x.Name).ToList(); 
     var expected = new List<string> {"A", "B", "C"}; 
     CollectionAssert.AreEqual(names, expected); 
    } 
} 

Il problema è AsNoTracking NULL nella prova di unità

Answer 1

Guardando il source code del metodo AsNoTracking() estensione:

public static IQueryable AsNoTracking(this IQueryable source) 
{ 
    var asDbQuery = source as DbQuery; 
    return asDbQuery != null ? asDbQuery.AsNoTracking() : CommonAsNoTracking(source); 
} 

Dal source (il vostro DbSet<Product> si sta cercando di prendere in giro) è davvero un DbQuery (perché DbSet è derivante dalla DbQuery), si tenta di richiamare il metodo "reale" (non deriso) AsNoTracking() che giustamente restituisce null.

Provare a deridere il metodo AsNoTracking() così:

mockSet.Setup(x => x.AsNoTracking()).Returns(mockSet.Object); 

Answer 2

Hai:

context.Setup(c => c.Products).Returns(mockSet.Object); 
context.Setup(m => m.Set<Product>()).Returns(mockSet.Object); 
context.Setup(c => c.Products.AsNoTracking()).Returns(mockSet.Object); 

ma ricordate che i metodi di estensione sono solo zucchero sintattico. Quindi:

c.Products.AsNoTracking() 

è in realtà solo:

System.Data.Entity.DbExtensions.AsNoTracking(c.Products) 

quindi la configurazione finto sopra è privo di significato.

La domanda è ciò che lo statico DbExtensions.AsNoTracking(source) method effettivamente fa al suo argomento. Vedi anche the thread What difference does .AsNoTracking() make?

Cosa succede se si rimuove il Setup che interessa AsNoTracking dalla classe di test?

Potrebbe essere utile dare a tutti i tuoi scherzi MockBehavior.Strict. In tal caso scoprirai se i membri che il metodo statico invoca su di essi, sono raggirabili da Moq (cioè metodi/proprietà virtuali in senso generale). Forse si può prendere in giro il non-statico method DbQuery.AsNoTracking se necessario.