Entity Framework 6 Mocking-Include-Methode auf dbset

Question

Googling für eine Lösung für das Problem, wie die Include-Methode auf dbset in EF6 gespottet werden. Das Problem dokumentiert ist auch hier: -

http://entityframework.codeplex.com/discussions/461731

Leider obwohl es keine gültige Lösung in dort zu sein scheint.

Hat jemand einen Workaround gefunden?

Ich verstehe, dass wir den EF6-Kontext nicht wirklich verspotten sollten, aber der Projektleiter hat darauf bestanden.

Vielen Dank im Voraus.

Answer 1

Also, das ist möglich, wenn ein bisschen ein faff!

Im Folgenden habe ich den Mock-Kontext und die Sets eingerichtet und kann erfolgreich Include aufrufen. Ich denke, dass die geheime Soße darin besteht, die Aufrufe an Provider, Expression und GetEnumerator auszugeben und die DbSet-Eigenschaften für den stubbed-Kontext auf die stubbed-Sets zu setzen und den Kontext nicht zu stubben, um sie zurückzugeben.

A runnable example is available on GitHub

[Test] 
    public void CanUseIncludeWithMocks() 
    { 
     var child = new Child(); 
     var parent = new Parent(); 
     parent.Children.Add(child); 

     var parents = new List<Parent> 
      { 
       parent 
      }.AsQueryable(); 

     var children = new List<Child> 
      { 
       child 
      }.AsQueryable(); 

     var mockContext = MockRepository.GenerateStub<TestContext>(); 

     var mockParentSet = MockRepository.GenerateStub<IDbSet<Parent>>(); 
     var mockChildSet = MockRepository.GenerateStub<IDbSet<Child>>(); 

     mockParentSet.Stub(m => m.Provider).Return(parents.Provider); 
     mockParentSet.Stub(m => m.Expression).Return(parents.Expression); 
     mockParentSet.Stub(m => m.GetEnumerator()).Return(parents.GetEnumerator()); 

     mockChildSet.Stub(m => m.Provider).Return(children.Provider); 
     mockChildSet.Stub(m => m.Expression).Return(children.Expression); 
     mockChildSet.Stub(m => m.GetEnumerator()).Return(children.GetEnumerator()); 

     mockContext.Parents = mockParentSet; 
     mockContext.Children = mockChildSet; 

     mockContext.Parents.Should().HaveCount(1); 
     mockContext.Children.Should().HaveCount(1); 

     mockContext.Parents.First().Children.FirstOrDefault().Should().NotBeNull(); 

     var query = mockContext.Parents.Include(p=>p.Children).Select(pc => pc); 

     query.Should().NotBeNull().And.HaveCount(1); 
     query.First().Children.Should().NotBeEmpty().And.HaveCount(1); 

    } 

Answer 2

hatte ich das gleiche Drama wie @GetFuzzy oben - es, dass, egal schien, was ich mich nicht die Nullreferenceexception vermeiden haben könnte, wenn ein Anruf Include() auf einem Moq DbSet gemacht wurde. Das Github-Beispiel in der anderen Antwort funktionierte leider nicht: Set.Include() gibt immer null zurück.

Nachdem ich eine Weile herumgespielt habe, habe ich mir einen Workaround ausgedacht.

[Test] 
public void CanUseIncludeWithMocks() 
{ 
    var child = new Child(); 
    var parent = new Parent(); 
    parent.Children.Add(child); 

    var parents = new List<Parent> { parent }; 
    var children = new List<Child> { child }; 

    var parentsDbSet1 = new FakeDbSet<Parent>(); 
    parentsDbSet1.SetData(parents); 

    var parentsDbSet2 = new FakeDbSet<Parent>(); 
    parentsDbSet2.SetData(parents); 

    parentsDbSet1.Setup(x => x.Include(It.IsAny<string>())).Returns(parentsDbSet2.Object); 

    // Can now test a method that does something like: context.Set<Parent>().Include("Children") etc 
} 


public class FakeDbSet<T> : Mock<DbSet<T>> where T : class 
{ 
    public void SetData(IEnumerable<T> data) 
    { 
     var mockDataQueryable = data.AsQueryable(); 

     As<IQueryable<T>>().Setup(x => x.Provider).Returns(mockDataQueryable.Provider); 
     As<IQueryable<T>>().Setup(x => x.Expression).Returns(mockDataQueryable.Expression); 
     As<IQueryable<T>>().Setup(x => x.ElementType).Returns(mockDataQueryable.ElementType); 
     As<IQueryable<T>>().Setup(x => x.GetEnumerator()).Returns(mockDataQueryable.GetEnumerator()); 
    } 
} 

Ich mag es nicht wirklich die Ungeschicklichkeit von zwei gefälschte DbSets zu haben, die aber aus irgendeinem Grund nicht funktioniert:

parentsDbSet1.Setup(x => x.Include(It.IsAny<string>())).Returns(parentsDbSet1.Object); 

jemand dafür eine Erklärung?

Answer 3

mit Moq-Framework funktioniert diese Methode mit allem, was ich es werfen.

public static Mock<DbSet<T>> GetMockSet<T>(this ObservableCollection<T> list) where T : class 
    { 
     var queryable = list.AsQueryable(); 
     var mockList = new Mock<DbSet<T>>(MockBehavior.Loose); 

     mockList.As<IQueryable<T>>().Setup(m => m.Provider).Returns(queryable.Provider); 
     mockList.As<IQueryable<T>>().Setup(m => m.Expression).Returns(queryable.Expression); 
     mockList.As<IQueryable<T>>().Setup(m => m.ElementType).Returns(queryable.ElementType); 
     mockList.As<IQueryable<T>>().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator()); 
     mockList.Setup(m => m.Include(It.IsAny<string>())).Returns(mockList.Object); 
     mockList.Setup(m => m.Local).Returns(list); 
     mockList.Setup(m => m.Add(It.IsAny<T>())).Returns((T a) => { list.Add(a); return a; }); 
     mockList.Setup(m => m.AddRange(It.IsAny<IEnumerable<T>>())).Returns((IEnumerable<T> a) => { foreach (var item in a.ToArray()) list.Add(item); return a; }); 
     mockList.Setup(m => m.Remove(It.IsAny<T>())).Returns((T a) => { list.Remove(a); return a; }); 
     mockList.Setup(m => m.RemoveRange(It.IsAny<IEnumerable<T>>())).Returns((IEnumerable<T> a) => { foreach (var item in a.ToArray()) list.Remove(item); return a; }); 

     return mockList; 
    } 

es zu tun benutzen Sie einfach:

mockContext.Setup(p => p.<DbSetToMock>).Returns(<observableCollection to use as data>.GetMockSet().Object);` 

Dies funktioniert Rost, wenn der Kontext ein Interface implementiert, wie Sie nie mit EF, etwas zu tun haben.

EDIT:

Der Grund für die zusätzlichen Bits ist, dass wir das Ergebnis auf dem Test überprüfen können, wenn wir hinzufügen oder entfernen wir die übergebene Sammlung überprüfen und es wird das Ergebnis nach dem Test haben.