Wie kann ich die Set <entity> Methode von DbContext verspotten?

Question

I Unit-Tests für die generischen Repository-Muster tun will, ich habe es auf verschiedene Weise versucht, und ich kann sie nicht, die nächste Sache, hier zu tun ist, das lasse ich die Implementierung, die ich getan habe

public abstract class Repository<TEntity, TKey> : IRepository<TEntity, TKey> where TEntity : Entity<TKey> 
{ 
    private readonly ValcalContext _context; 

    private readonly IUnitOfWork _unitOfWork; 

    public IUnitOfWork UnitOfWork => _unitOfWork; 

    public Repository(IUnitOfWork uow) 
    { 
     _context = uow.Context as ValcalContext; 
     _unitOfWork = uow; 
    } 

    public List<TEntity> All => _context.Set<TEntity>().ToList(); 

    public List<TEntity> AllEager(params Expression<Func<TEntity, object>>[] includes) 
    { 
     IQueryable<TEntity> query = _context.Set<TEntity>(); 
     foreach (var include in includes) 
     { 
      query = query.Include(include); 
     } 
     return query.ToList(); 
    } 

    public TEntity Find(TKey id) 
    { 
     return _context.Set<TEntity>().Find(id); 
    } 

    public IEnumerable<TEntity> GetAll() 
    { 
     return _context.Set<TEntity>().ToList(); 
    } 

    public void Insert(TEntity item) 
    { 
     _context.Entry(item).State = EntityState.Added; 
    } 

    public void Delete(TEntity entity) 
    { 
     var item = _context.Set<TEntity>().Find(entity.Id); 
     _context.Set<TEntity>().Remove(item); 
    } 

    public void Delete(TKey id) 
    { 
     var item = _context.Set<TEntity>().Find(id); 
     _context.Set<TEntity>().Remove(item); 
    } 

    public void Update(TEntity item) 
    { 
     _context.Set<TEntity>().Attach(item); 
     _context.Entry(item).State = EntityState.Modified; 
    } 

    public void Dispose() 
    { 
     if (_context != null) 
      _context.Dispose(); 
    } 
} 

Das ist mein DbContext

public class ValcalContext : DbContext,IValcalContext 
{ 
    public ValcalContext() : base("ValcalConnection") 
    { 
    } 

    public static ValcalContext Create() 
    { 
     return new ValcalContext(); 

    } 

    protected override void OnModelCreating(DbModelBuilder modelBuilder) 
    { 
     AddConventions(modelBuilder); 

     var typesToRegister = TypesToRegister(); 

     AddConfigurationsMapping(modelBuilder, typesToRegister); 

     base.OnModelCreating(modelBuilder); 
    } 

    #region Private Methods 

    /// <summary> 
    /// /Agrega las convenciones de mapeo a la base de dato 
    /// </summary> 
    /// <param name="modelBuilder"></param> 
    private void AddConventions(DbModelBuilder modelBuilder) 
    { 
     modelBuilder.Types().Configure(entity => entity.ToTable(entity.ClrType.Name.ToLowerUnderscored())); 
     modelBuilder.Conventions.Add(new UnderScoredLowerCaseConvention()); 
    } 


    private static IEnumerable<Type> TypesToRegister() 
    { 
     var typesToRegister = Assembly.GetExecutingAssembly().GetTypes() 
      .Where(type => !string.IsNullOrEmpty(type.Namespace)) 
      .Where(type => type.BaseType != null && type.BaseType.IsGenericType 
          && type.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration<>)); 
     return typesToRegister; 
    } 


    private static void AddConfigurationsMapping(DbModelBuilder modelBuilder, IEnumerable<Type> typesToRegister) 
    { 
     foreach (var configurationInstance in typesToRegister.Select(Activator.CreateInstance)) 
     { 
      modelBuilder.Configurations.Add((dynamic)configurationInstance); 
     } 
    } 
    #endregion 
} 

I Unit-Tests für die generischen Repository-Muster tun wollen, denn jetzt habe ich diesen

[TestClass] 
public class RepositoryUnitTest 
{ 


    [TestMethod] 
    public void Sample() 
    { 
     //arrange 
     var mockEntityTest = new Mock<DbSet<EntityTest>>(); 

     var unitOfWork = new Mock<IUnitOfWork>(); 
     var valcalContext = new Mock<ValcalContext>(); 

     valcalContext.Setup(vc => vc.Set<EntityTest>()).Returns(mockEntityTest.Object); 
     var mock = valcalContext.Object; 

     unitOfWork.Setup(uow => uow.Context).Returns(mock); 

     var repository = new RepositoryTest(unitOfWork.Object); 

     //act 
     var entityTests = repository.All; 
     //assert 
     Assert.AreEqual(entityTests.ToList().Count,0); 
    } 

} 

public class RepositoryTest : Repository<EntityTest, int> 
{ 
    public RepositoryTest(IUnitOfWork uow) : base(uow) 
    { 
    } 
} 
public class EntityTest : Entity<int> 
{ 

} 

, aber ich bekomme diese Fehlermeldung

Ich hoffe, dass Sie mir helfen können, ich habe für zwei Stunden hier

Das Mitglied 'IEnumerable.GetEnumerator' hat nicht wurde bei Typ 'DbSet 1Proxy' which inherits from 'DbSet 1' implementiert. Test Doppel für 'DbSet`1' muss Implementierungen von Methoden und Eigenschaften, die verwendet werden, bereitstellen.

Dieser Fehler unterscheidet sich von diesem Beitrag Moq DbSet NotImplementedException

Ich habe gerade versucht, dass die Lösung, und ich bin immer noch in der gleichen

Answer 1

wirklich das, was ich tat, war folgendes klar

machen

1. Ich habe die Moq-Version für 4,8 hochgeladen

2. Ich ändere th

   ist

   [TestMethod] 
   public void Sample() 
   { 
       //arrange 
       var mockEntityTest = new Mock<DbSet<EntityTest>>(); 
   
       var unitOfWork = new Mock<IUnitOfWork>(); 
       var valcalContext = new Mock<ValcalContext>(); 
   
       valcalContext.Setup(vc => vc.Set<EntityTest>()).Returns(mockEntityTest.Object); 
       var mock = valcalContext.Object; 
   
       unitOfWork.Setup(uow => uow.Context).Returns(mock); 
   
       var repository = new RepositoryTest(unitOfWork.Object); 
   
       //act 
       var entityTests = repository.All; 
       //assert 
       Assert.AreEqual(entityTests.ToList().Count,0); 
   } 
   

für dieses

[TestMethod] 
public void Sample() 
{ 
    //arrange 
    var mockEntityTest = new Mock<DbSet<EntityTest>>(); 
    var list = new List<EntityTest>(); 
    var queryable = list.AsQueryable(); 
    mockEntityTest.As<IQueryable<EntityTest>>().Setup(m => m.Provider).Returns(queryable.Provider); 
    mockEntityTest.As<IQueryable<EntityTest>>().Setup(m => m.Expression).Returns(queryable.Expression); 
    mockEntityTest.As<IQueryable<EntityTest>>().Setup(m => m.ElementType).Returns(queryable.ElementType); 
    mockEntityTest.As<IQueryable<EntityTest>>().Setup(m => m.GetEnumerator()).Returns(() => queryable.GetEnumerator()); 

    var unitOfWork = new Mock<IUnitOfWork>(); 
    var valcalContext = new Mock<ValcalContext>(); 

    valcalContext.Setup(vc => vc.Set<EntityTest>()).Returns(mockEntityTest.Object); 
    var mock = valcalContext.Object; 

    unitOfWork.Setup(uow => uow.Context).Returns(mock); 

    var repository = new RepositoryTest(unitOfWork.Object); 

    //act 
    var entityTests = repository.All; 
    //assert 
    Assert.AreEqual(entityTests.ToList().Count,0); 
} 

und es hat funktioniert, kann man erkennen, allgemein als erklärt in diesem Beitrag How do I go about unit testing with Entity Framework and Moq? 45558663 # 45558663

getan werden, aber die Essenz dessen, was ich tat, war Das.