Mockito se moquant de la valeur d'une méthode

Question

classe en cours de test:

class FruitQuality { 

    void testQuality() { 
    getfruits(); 
    //some code 
    } 

    List<Fruits> getfruits() { 
    return orange; 
    } 
} 

Ci-dessous le code de test. Je me suis moqué de la classe en cours de test et a remplacé une valeur de retour pour la méthode getfruits. Mais quand je cours le simulacre, je n'obtiens pas la valeur de retour moquée attendue. Easymock peut substituer des valeurs de retour pour les méthodes de classe à tester, si celles-ci sont explicitement mockées. Comment puis-je obtenir la valeur de retour mockée lorsque je me moque de la méthode de l'objet réel.

@Test 
public void test() { 
    Fruits fruit= new Fruits(); 
    fruit.setFruit("orange"); 
    List<Fruits> fruitsList = new ArrayList<Fruits>(); 
    fruitsList.add(fruit); 

    Fruits mock = Mockito.mock(FruitQuality.class) 
    classUnderTest = new FruitQuality(); 
    when(mock.getfruits()).thenReturn(fruitsList); 

    result= classUnderTest.getfruits(); 
    assertEquals(result, fruitsList); 
} 

Answer 1

En général, lors de l'écriture des tests unitaires, vous avez une classe testé contenant le code de mise en œuvre que vous testez, tout en se moquant de la Methode d'autres classes de votre classe en cours de test se fonde sur.

référenceurs à votre exemple, vous auriez une classe

public class FruitQuality { 
    private FruitProvider fruitProvider; 

    public List<Fruit> testQuality() { 
     List<Fruit> fruits = fruitProvider.getfruits(); 
     /* Some code doing something with fruits, e.g., filtering. */ 
     return fruits; 
    } 
} 

Et une deuxième classe

public class FruitProvider { 
    public List<Fruits> getfruits() { 
     /* Returning some fruits ... */ 
    } 
} 

Maintenant, vous pouvez railler votre fournisseur pour tester votre classe en cours de test:

@RunWith(MockitoJUnitRunner.class) 
public class FruitQualityUnitTest { 
    @InjectMocks 
    private FruitQuality fruitQuality; 
    @Mock 
    private FruitProvider fruitProvider; 

    @Test 
    public void testQuality() { 
     /* Mocking the provider. */ 
     Fruits fruit= new Fruits(); 
     fruit.setFruit("orange"); 
     List<Fruits> fruitsList = new ArrayList<Fruits>(); 
     fruitsList.add(fruit); 
     when(fruitProvider.getFruits()).thenReturn(fruitsList); 

     /* Invoke the method under test. */ 
     List<Fruits> result = fruitProvider.testQuality(); 

     /* Assert that some methods where called. */ 
     verify(fruitProvider, times(1)).getFruits(); 

     /* If the method would return a value, you can do some assertions based on the mocked method calls. */ 
     assertEquals(result, fruitsList); 
    } 
} 

Si vous souhaitez tester les méthodes du même objet que vous vous moquez, vous pouvez utiliser l'annotation @Spy à la place de f @Mock, en s'assurant que seules les méthodes que vous êtes explicitement moquaient en faisant d'autres choses que l'implémentation originale.