Jak sprawdzić, czy inna metoda w klasie została wywołana za pomocą Moq

Question

To wydaje się być czymś prostym, ale nie mogę sprawić, żeby zadziałało.

Mam klasę z metodą Save, która po prostu wywołuje inną metodę ShouldBeCalled(). Chcę sprawdzić, czy jeśli wywołasz Save(), to druga metoda ShouldBeCalled() jest wykonywana co najmniej raz. Myślałem, że mogę zrobić co następuje.

public class ClassA 
{ 
    public virtual void Save() 
    { 
     ShouldBeCalled(); 
    } 

    public virtual void ShouldBeCalled() 
    { 
     //This should get executed 
    } 
} 

[TestFixture] 
public class ClassA_Test 
{ 
    [Test] 
    public void Save_Should_Call_ShouldBeCalled() 
    { 
     var mockClassA = new Mock<ClassA>(); 
     mockClassA.Object.Save(); 

     mockClassA.Verify(x => x.ShouldBeCalled(), Times.AtLeastOnce()); 
    } 
} 

Ale pojawia się wyjątek „Oczekiwany wezwanie na mock co najmniej raz, ale nigdy nie została wykonana: x => x.ShouldBeCalled()”

To tylko przypuszczenie, ale jest Moq nadrzędnymi Metoda Save() z własną wersją, która ignoruje wszystko, co mam w metodzie Save object.

Answer 1

Masz ten problem, ponieważ kpisz z testowanego produktu. To nie ma sensu.

Masz rację, że Moq zastąpi implementację twojej metody własną. Powodem jest to, że używasz Moq do kpienia z klasy , którą testujesz, dzwoniąc pod numer, a nie od klasy, którą sam testujesz.

Badanie to byłoby właściwe, jeśli kod zostały zaprojektowane wygląda następująco:

public class ClassA 
{ 
    BusinessLogicClass bl; 
    public ClassA(BusinessLogicClass bl) 
    { 
     this.bl = bl; 
    } 

    public void Save() 
    { 
     bl.ShouldBeCalled(); 
    } 
} 

public class BusinessLogicClass 
{ 
    public virtual void ShouldBeCalled() 
    { 
     //This should get executed 
    } 
} 

I tu jest poprawny test tej metody teraz:

[TestFixture] 
public class ClassA_Test 
{ 
    [Test] 
    public void Save_ShouldCallShouldBeCalled() 
    { 
     //Arrange 
     var mockBLClass = new Mock<BusinessLogicClass>(); 
     mockBLClass.Setup(x => x.ShouldBeCalled()).Verifyable(); 

     //Act  
     ClassA classA = new ClassA(mockBLClass.Object); 
     classA.Save(); 

     //Assert 
     mockBLClass.VerifyAll(); 
    } 
} 

Kluczem lekcja jest to, że mock/Zauważ, co twój test musi uruchomić, a nie to, co sam testujesz.

Nadzieja to pomaga, Anderson

Answer 2

Tak, można to zrobić. Jednak musisz dodać linię kodu, aby śledzić Moq niezależnie od tego, czy rzeczywiście wywołano metodę ShouldBeCalled.

Coś jak poniżej będzie działać:

var mockClassA = new Mock<ClassA>(); 
mockClassA.Setup(x => x.ShouldBeCalled()).Verifiable();  
mockClassA.Object.Save();  
mockClassA.Verify(x => s.ShouldBeCalled(), Times.AtLeastOnce()); 

Sposób konfiguracji ustawia oczekiwania. Kiedy dzwonisz do Verify, pytasz Moq, aby zweryfikować te oczekiwania. Jeśli nie wykonasz wywołania Setup w celu stworzenia oczekiwań dla metody ShouldBeCalled, wówczas Moq nie uważa, że ​​jest on możliwy do śledzenia, a zatem nie powiedzie się, gdy spróbujesz go zweryfikować.

Answer 3

Spróbuj użyć CallBase = true, a następnie fałszywe. Uruchomiłem twój kod i działa.

var mockClassA = new Mock<ClassA>(); 
mockClassA.CallBase = true; 
mockClassA.Object.Save(); 
mockClassA.CallBase = false; 
mockClassA.Verify(x => x.ShouldBeCalled(), Times.AtLeastOnce()); 

Answer 4

Możesz stosować metody pośrednie w testowanym systemie, używając CallBase.

[TestFixture] 
public class ClassA_Test 
{ 
    [Test] 
    public void Save_Should_Call_ShouldBeCalled() 
    { 
     // Arrange 
     var mockClassA = new Mock<ClassA>(); 
     mockClassA.CallBase = true; // this will call real methods unless the method is mocked/stubbed. 
     mockClassA.Setup(a => a.ShouldBeCalled()); 

     // Act 
     mockClassA.Save(); 

     // Assert 
     mockClassA.Verify(a => a.ShouldBeCalled(), Times.Once()); 
    } 
}