Comment résoudre l'exception de stubbing inutile

Mon code est comme ci-dessous,

@RunWith(MockitoJUnitRunner.class)
public class MyClass {

    private static final String code ="Test";

    @Mock
     private MyClassDAO dao;

    @InjectMocks
     private MyClassService Service = new MyClassServiceImpl();

    @Test
     public void testDoSearch() throws Exception {
         final String METHOD_NAME = logger.getName().concat(".testDoSearchEcRcfInspections()");
         CriteriaDTO dto = new CriteriaDTO();
         dto.setCode(code);
         inspectionService.searchEcRcfInspections(dto);
         List<SearchCriteriaDTO> summaryList = new ArrayList<SearchCriteriaDTO>();
         inspectionsSummaryList.add(dto);
         when(dao.doSearch(dto)).thenReturn(inspectionsSummaryList);//got error in this line
         verify(dao).doSearchInspections(dto);

      }
}

Je suis en dessous de l'exception

org.mockito.exceptions.misusing.UnnecessaryStubbingException: 
Unnecessary stubbings detected in test class: Test
Clean & maintainable test code requires zero unnecessary code.
Following stubbings are unnecessary (click to navigate to relevant line of code):
  1. -> at service.Test.testDoSearch(Test.java:72)
Please remove unnecessary stubbings or use 'silent' option. More info: javadoc for UnnecessaryStubbingException class.
  at org.mockito.internal.exceptions.Reporter.formatUnncessaryStubbingException(Reporter.java:838)
  at org.mockito.internal.junit.UnnecessaryStubbingsReporter.validateUnusedStubs(UnnecessaryStubbingsReporter.java:34)
  at org.mockito.internal.runners.StrictRunner.run(StrictRunner.java:49)
  at org.mockito.junit.MockitoJUnitRunner.run(MockitoJUnitRunner.java:103)
  at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:86)
  at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
  at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)
  at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)
  at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)
  at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)

S'il vous plaît, aidez-moi à résoudre

Remplacez @RunWith(MockitoJUnitRunner.class)par @RunWith(MockitoJUnitRunner.Silent.class).

Au début, vous devez vérifier votre logique de test. Il y a généralement 3 cas. Tout d'abord, vous vous moquez d'une mauvaise méthode (vous avez fait une faute de frappe ou quelqu'un a changé le code testé pour que la méthode simulée ne soit plus utilisée). Deuxièmement, votre test échoue avant que cette méthode ne soit appelée. Troisièmement, votre logique tombe dans une mauvaise branche if / switch quelque part dans le code, de sorte que la méthode simulée n'est pas appelée.

Si c'est le premier cas, vous voulez toujours changer la méthode fictive pour celle utilisée dans le code. Avec le deuxième et le troisième cela dépend. Habituellement, vous devez simplement supprimer cette maquette si elle ne sert à rien. Mais parfois, il y a certains cas dans les tests paramétrés, qui devraient emprunter ce chemin différent ou échouer plus tôt. Ensuite, vous pouvez diviser ce test en deux ou plusieurs tests distincts, mais ce n'est pas toujours beau. 3 méthodes de test avec éventuellement 3 fournisseurs d'arguments peuvent vous donner l'impression que le test est illisible. Dans ce cas pour JUnit 4, vous mettez cette exception en silence avec soit

@RunWith(MockitoJUnitRunner.Silent.class) 

annotation ou si vous utilisez l'approche par règles

@Rule
public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.LENIENT);

ou (le même comportement)

@Rule
public MockitoRule rule = MockitoJUnit.rule().silent();

Pour les tests JUnit 5, vous pouvez désactiver cette exception à l'aide de l'annotation fournie dans le mockito-junit-jupiterpackage.

@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class JUnit5MockitoTest {
}

Le silence n'est pas une solution. Vous devez corriger votre maquette dans votre test. Voir la documentation officielle ici .

Les stubs inutiles sont des appels de méthode stub qui n'ont jamais été réalisés lors de l'exécution du test (voir aussi MockitoHint), exemple:

//code under test:
 ...
 String result = translator.translate("one")
 ...

 //test:
 ...
 when(translator.translate("one")).thenReturn("jeden"); // <- stubbing realized during code execution
 when(translator.translate("two")).thenReturn("dwa"); // <- stubbing never realized
 ...

Notez que l'une des méthodes stubbed n'a jamais été réalisée dans le code sous test, lors de l'exécution du test. Le stubbing errant peut être une erreur du développeur, l'artefact du copier-coller ou l'effet de ne pas comprendre le test / code. Dans tous les cas, le développeur se retrouve avec un code de test inutile. Afin de garder la base de code propre et maintenable, il est nécessaire de supprimer le code inutile. Sinon, les tests sont plus difficiles à lire et à raisonner.

Pour en savoir plus sur la détection des stubbings inutilisés, consultez MockitoHint.

Pour moi, @Ruleni les @RunWith(MockitoJUnitRunner.Silent.class)suggestions ni les suggestions n'ont fonctionné. C'était un projet hérité où nous avons mis à niveau vers mockito-core 2.23.0.

Nous pourrions nous en débarrasser UnnecessaryStubbingExceptionen utilisant:

Mockito.lenient().when(mockedService.getUserById(any())).thenReturn(new User());

au lieu de:

when(mockedService.getUserById(any())).thenReturn(new User());

Inutile de dire que vous devriez plutôt regarder le code de test, mais nous devions tout d'abord faire compiler le contenu et exécuter les tests;)

 when(dao.doSearch(dto)).thenReturn(inspectionsSummaryList);//got error in this line
 verify(dao).doSearchInspections(dto);

L' whenici configure votre maquette pour faire quelque chose. Cependant, vous n'utilisez plus ce simulacre de quelque manière que ce soit après cette ligne (à part faire a verify). Mockito vous prévient que la whenligne est donc inutile. Peut-être avez-vous fait une erreur de logique?

En regardant une partie de votre trace de pile, il semble que vous stubez l' dao.doSearch()ailleurs. Plus comme créer à plusieurs reprises les stubs de la même méthode.

Following stubbings are unnecessary (click to navigate to relevant line of code):
  1. -> at service.Test.testDoSearch(Test.java:72)
Please remove unnecessary stubbings or use 'silent' option. More info: javadoc for UnnecessaryStubbingException class.

Considérez la classe de test ci-dessous par exemple:

@RunWith(MockitoJUnitRunner.class)
public class SomeTest {
    @Mock
    Service1 svc1Mock1;

    @Mock
    Service2 svc2Mock2;

    @InjectMock
    TestClass class;

    //Assume you have many dependencies and you want to set up all the stubs 
    //in one place assuming that all your tests need these stubs.

    //I know that any initialization code for the test can/should be in a 
    //@Before method. Lets assume there is another method just to create 
    //your stubs.

    public void setUpRequiredStubs() {
        when(svc1Mock1.someMethod(any(), any())).thenReturn(something));
        when(svc2Mock2.someOtherMethod(any())).thenReturn(somethingElse);
    }

    @Test
    public void methodUnderTest_StateUnderTest_ExpectedBehavior() {
        // You forget that you defined the stub for svcMock1.someMethod or 
        //thought you could redefine it. Well you cannot. That's going to be 
        //a problem and would throw your UnnecessaryStubbingException.
       when(svc1Mock1.someMethod(any(),any())).thenReturn(anyThing);//ERROR!
       setUpRequiredStubs();
    }
}

Je préfère envisager de refactoriser vos tests en stub si nécessaire.

Si vous utilisez ce style à la place:

@Rule
public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);

remplacez-le par:

@Rule
public MockitoRule rule = MockitoJUnit.rule().silent();

J'avais UnnecessaryStubbingExceptionquand j'ai essayé d'utiliser les whenméthodes sur un objet Spy. Mockito.lenient()a fait taire l'exception mais les résultats des tests n'étaient pas corrects.

Dans le cas des objets Spy, il faut appeler les méthodes directement.

@ExtendWith(MockitoExtension.class)
@RunWith(JUnitPlatform.class)
class ArithmTest {

    @Spy
    private Arithm arithm;

    @Test
    void testAddition() {

        int res = arithm.add(2, 5);

        // doReturn(7).when(arithm).add(2, 5);
        assertEquals(res, 7);
    }
}

Eh bien, dans mon cas, l'erreur Mockito me disait d'appeler la méthode réelle après le whenouwhenever stub . Comme nous n'invoquions pas les conditions dont nous venons de nous moquer, Mockito signalait cela comme des stubs ou du code inutiles.

Voici ce que c'était quand l'erreur arrivait:

@Test
fun `should return error when item list is empty for getStockAvailability`() {
    doAnswer(
        Answer<Void> { invocation ->
            val callback =
                invocation.arguments[1] as GetStockApiCallback<StockResultViewState.Idle, StockResultViewState.Error>
            callback.onApiCallError(stockResultViewStateError)
            null
        }
    ).whenever(stockViewModelTest)
        .getStockAvailability(listOf(), getStocksApiCallBack)
}

alors je viens d'appeler la méthode réelle mentionnée dans l'instruction when pour se moquer de la méthode.

les changements effectués sont comme ci-dessous stockViewModelTest.getStockAvailability(listOf(), getStocksApiCallBack)

@Test
fun `should return error when item list is empty for getStockAvailability`() {
    doAnswer(
        Answer<Void> { invocation ->
            val callback =
                invocation.arguments[1] as GetStockApiCallback<StockResultViewState.Idle, StockResultViewState.Error>
            callback.onApiCallError(stockResultViewStateError)
            null
        }
    ).whenever(stockViewModelTest)
        .getStockAvailability(listOf(), getStocksApiCallBack)
    //called the actual method here
    stockViewModelTest.getStockAvailability(listOf(), getStocksApiCallBack)
}

ça marche maintenant.

Remplacer

@RunWith(MockitoJUnitRunner.class)

avec

@RunWith(MockitoJUnitRunner.Silent.class)

ou supprimer@RunWith(MockitoJUnitRunner.class)

ou tout simplement commenter les appels moqueurs indésirables (représentés comme des stubbing non autorisés).

Dans le cas d'un grand projet, il est difficile de corriger chacune de ces exceptions. Dans le même temps, l'utilisation Silentn'est pas conseillée. J'ai écrit un script pour supprimer tous les stubbings inutiles à partir d'une liste d'entre eux.

https://gist.github.com/cueo/da1ca49e92679ac49f808c7ef594e75b

Nous avons juste besoin de copier-coller la mvnsortie et d'écrire la liste de ces exceptions à l'aide de regex et de laisser le script s'occuper du reste.

Si vous utilisez any () lorsque vous vous moquez, vous devez réespacer @RunWith (MockitoJUnitRunner.class) avec @RunWith (MockitoJUnitRunner.Silent.class).

Lorsque vous créez une maquette et que cette maquette n'est pas utilisée, elle lève une exception de stubbing inutilisée. Dans votre cas, cette simulation n'est pas réellement appelée. Par conséquent, il jette cette erreur. Par conséquent, relpace @RunWith(MockitoJUnitRunner.class)avec @RunWith(MockitoJUnitRunner.Silent.class)lequel supprimerait l'erreur. Si vous souhaitez toujours utiliser, @RunWith(MockitoJUnitRunner.class)essayez de déboguer votre logique si la fonction que vous avez moquée est effectivement appelée ou non.