Se moquant EF DbContext Moq

Merci Gaui pour votre grande idée =)

J'ai ajouté quelques améliorations à votre solution et que vous souhaitez partager.

1. Mon FakeDbSet aussi inherents de DbSet pour obtenir d'autres méthodes
   comme AddRange()
2. J'ai remplacé le ObservableCollection<T> avec List<T> pour passer tous les
   la déjà mis en œuvre des méthodes de List<> jusqu'à mon FakeDbSet

Mon FakeDbSet:

    public class FakeDbSet<T> : DbSet<T>, IDbSet<T> where T : class {
List<T> _data;
public FakeDbSet() {
_data = new List<T>();
}
public override T Find(params object[] keyValues) {
throw new NotImplementedException("Derive from FakeDbSet<T> and override Find");
}
public override T Add(T item) {
_data.Add(item);
return item;
}
public override T Remove(T item) {
_data.Remove(item);
return item;
}
public override T Attach(T item) {
return null;
}
public T Detach(T item) {
_data.Remove(item);
return item;
}
public override T Create() {
return Activator.CreateInstance<T>();
}
public TDerivedEntity Create<TDerivedEntity>() where TDerivedEntity : class, T {
return Activator.CreateInstance<TDerivedEntity>();
}
public List<T> Local {
get { return _data; }
}
public override IEnumerable<T> AddRange(IEnumerable<T> entities) {
_data.AddRange(entities);
return _data;
}
public override IEnumerable<T> RemoveRange(IEnumerable<T> entities) {
for (int i = entities.Count() - 1; i >= 0; i--) {
T entity = entities.ElementAt(i);
if (_data.Contains(entity)) {
Remove(entity);
}
}
return this;
}
Type IQueryable.ElementType {
get { return _data.AsQueryable().ElementType; }
}
Expression IQueryable.Expression {
get { return _data.AsQueryable().Expression; }
}
IQueryProvider IQueryable.Provider {
get { return _data.AsQueryable().Provider; }
}
IEnumerator IEnumerable.GetEnumerator() {
return _data.GetEnumerator();
}
IEnumerator<T> IEnumerable<T>.GetEnumerator() {
return _data.GetEnumerator();
}
}

Il est très facile de modifier les dbSet et se moquent de l'EF Objet de Contexte:

    var userDbSet = new FakeDbSet<User>();
userDbSet.Add(new User());
userDbSet.Add(new User());
var contextMock = new Mock<MySuperCoolDbContext>();
contextMock.Setup(dbContext => dbContext.Users).Returns(userDbSet);

Maintenant, il est possible d'exécuter des requêtes Linq, mais il faut être conscient que la clé étrangère références peuvent ne pas être créés automatiquement:

    var user = contextMock.Object.Users.SingeOrDefault(userItem => userItem.Id == 42);

Parce que l'objet de contexte est moqué de la Context.SaveChanges() de ne pas faire n'importe quoi et des changements de propriété de votre entités peuvent ne pas être renseignés pour votre dbSet. J'ai résolu ce problème en se moquant de mon SetModifed() méthode pour remplir les modifications.

Si quelqu'un est toujours à la recherche de réponses que j'ai mis en place un petite bibliothèque pour permettre moqueur DbContext.

étape 1

Installer Coderful.EntityFramework.Les tests nuget package:

Install-Package Coderful.EntityFramework.Testing

étape 2

Ensuite créer une classe comme ceci:

internal static class MyMoqUtilities
{
public static MockedDbContext<MyDbContext> MockDbContext(
IList<Contract> contracts = null,
IList<User> users = null)
{
var mockContext = new Mock<MyDbContext>();
//Create the DbSet objects.
var dbSets = new object[]
{
MoqUtilities.MockDbSet(contracts, (objects, contract) => contract.ContractId == (int)objects[0] && contract.AmendmentId == (int)objects[1]),
MoqUtilities.MockDbSet(users, (objects, user) => user.Id == (int)objects[0])
};
return new MockedDbContext<SourcingDbContext>(mockContext, dbSets); 
}
}

étape 3

Maintenant, vous pouvez créer des simulacres super facilement:

//Create test data.
var contracts = new List<Contract>
{
new Contract("#1"),
new Contract("#2")
};
var users = new List<User>
{
new User("John"),
new User("Jane")
};
//Create DbContext with the predefined test data.
var dbContext = MyMoqUtilities.MockDbContext(
contracts: contracts,
users: users).DbContext.Object;

Et ensuite utiliser votre maquette:

//Create.
var newUser = dbContext.Users.Create();
//Add.
dbContext.Users.Add(newUser);
//Remove.
dbContext.Users.Remove(someUser);
//Query.
var john = dbContext.Users.Where(u => u.Name == "John");
//Save changes won't actually do anything, since all the data is kept in memory.
//This should be ideal for unit-testing purposes.
dbContext.SaveChanges();

Article complet: http://www.22bugs.co/post/Mocking-DbContext/

Je suis en retard, mais trouvé cet article utile: Test avec InMemory MSDN (Docs).

Il explique comment utiliser une mémoire DB contexte (ce qui n'est pas une base de données) avec l'avantage de très peu de codage et la possibilité de réellement tester votre DBContext mise en œuvre.