Comment vérifier si-déclaration de la méthode, à l'aide de Mockito et JUnit?

J'ai la méthode que je dois tester. Code (bien sûr, certaines parties ont été coupées):

public class FilterDataController {

    public static final String DATE_FORMAT = "yyyy-MM-dd";

    @Autowired
    private FilterDataProvider filterDataProvider;

    @ApiOperation(value = "Get possible filter data",response = ResponseEntity.class)
    @ApiResponses(value = {
            @ApiResponse(...),
            @ApiResponse(...)})
    @RequestMapping(path = "...", method = RequestMethod.GET)
    public ResponseEntity<Object> getPossibleFilterData(
            @RequestParam(value = "startDate") @DateTimeFormat(pattern=DATE_FORMAT) final Date startDate,
            @RequestParam(value = "endDate") @DateTimeFormat(pattern=DATE_FORMAT) final Date endDate) {
        if (endDate.compareTo(startDate) == -1){
            throw new ValueNotAllowedException("End date should be after or equal start date");
        }
        else {
            Date newEndDate = endDate;
            if (startDate.equals(endDate)){
                newEndDate = new Date(endDate.getTime() + TimeUnit.DAYS.toMillis(1) - 1);
            }

            List<String> possibleCountries = Lists.newArrayList(filterDataProvider.getPossibleCountries(startDate, newEndDate));

            return new ResponseEntity<>(new FilterResponse(possibleCountries),HttpStatus.OK);
        }
    }   
}

Question: comment faire pour vérifier si l'instruction dans la méthode getPossibleFilterData à l'aide de Mockito et JUnit? Je veux passer à l'égalité des dates à la méthode, puis vérifier que mon if fonctionne correctement.

  • Comme mentionné dans beaucoup de réponses ci-dessous, vos tests ne devriez pas supposer que votre mise en œuvre: que faire si vous refactoriser la méthode afin qu'il renvoie des valeurs correctes, mais n'utilise pas de if instruction à tous? Au lieu de supposer que, transmettre des valeurs erronées et passer le test uniquement lorsque vous attraper le bon d'exception.
  • merci pour les conseils.
InformationsquelleAutor Woland | 2016-10-11
  1. 2

    Si vous voulez vraiment un pur unité de test pas de test d'intégration, vous pouvez compter sur l'annotation @Mock à se moquer de votre service FilterDataProvider et @InjectMocks afin d'injecter votre fantaisie dans votre instance de FilterDataController.

    Ensuite, vous pouvez proposer des 3 tests:

    1. Un test où les dates sont correctes, mais différent,
    2. Autre où les dates sont correctes, mais l'égalité
    3. Et le dernier où les dates sont erronées qui aura jeté un ValueNotAllowedException qui pourraient être testés hors de la zone à l'aide @Test(expected = ValueNotAllowedException.class).

    Si vous avez besoin pour vous assurer que filterDataProvider.getPossibleCountries(startDate, newEndDate) a été appelé avec les arguments attendus, vous devez utiliser verify.

    Le code serait alors quelque chose comme ça:

    @RunWith(MockitoJUnitRunner.class)
public class FilterDataControllerTest {
@Mock
FilterDataProvider filterDataProvider;
@InjectMocks
FilterDataController controller;
@Test(expected = ValueNotAllowedException.class)
public void testGetPossibleFilterDataIncorrectDates() {
controller.getPossibleFilterData(new Date(1L), new Date(0L));
}
@Test
public void testGetPossibleFilterDataCorrectDates() {
//Make the mock returns a list of fake possibilities
Mockito.when(
filterDataProvider.getPossibleCountries(
Mockito.anyObject(), Mockito.anyObject()
)
).thenReturn(Arrays.asList("foo", "bar"));
ResponseEntity<Object> response = controller.getPossibleFilterData(
new Date(0L), new Date(1L)
);
Assert.assertEquals(HttpStatus.OK, response.getStatusCode());
//Make sure that 
//filterDataProvider.getPossibleCountries(new Date(0L), new Date(1L))
//has been called as expected
Mockito.verify(filterDataProvider).getPossibleCountries(
new Date(0L), new Date(1L)
);
//Test response.getBody() here
}
@Test
public void testGetPossibleFilterDataEqualDates() {
//Make the mock returns a list of fake possibilities
Mockito.when(
filterDataProvider.getPossibleCountries(
Mockito.anyObject(), Mockito.anyObject()
)
).thenReturn(Arrays.asList("foo", "bar"));
//Call the controller with the same dates
ResponseEntity<Object> response = controller.getPossibleFilterData(
new Date(1L), new Date(1L)
);
Assert.assertEquals(HttpStatus.OK, response.getStatusCode());
Mockito.verify(filterDataProvider).getPossibleCountries(
new Date(1L), new Date(TimeUnit.DAYS.toMillis(1))
);
//Test response.getBody() here
}
}
    • merci pour le code. Mais comment vérifier que filterDataProvider a été appelé avec la date correcte? Je veux envoyé à getPossibleFilterData l'égalité des dates et vérifiez que filterDataProvider.getPossibleCountries(startDate, newEndDate) appelé avec la correction des dates.
    InformationsquelleAutor Nicolas Filotto
  2. 1

    Vous aurez à se moquer de FilterDataProvider et puis à l'injecter dans votre classe de test à l'aide de InjectMocks.

    getPossibleFilterData à la méthode en cours de test, afin de choisir une date donnée (utiliser Calendar.set(...), puis Calendar.getTime()) et l'envoyer à cette même date que les deux startDate et endDate.

    Maintenant, après getPossibleFilterData est terminée, vous pouvez vérifier si filterDataProvider.getPossibleCountries a été appelé avec une Date de fin qui est une milliseconde plus que la date de départ. Cela peut être fait par Calendar.getTimeInMillis() à l'intérieur de la classe factices de la méthode, ou en vérifiant avec Mockito avec une Date d'une milliseconde plus de la date initialement spécifié.

    Edit: exemple de Code fourni:

    public class FilterDataControllerTest {
@Test
public void testSameDate() {
FilterDataProvider provider = Mockito.mock(FilterDataProvider.class);
FilterDataController controller = new FilterDataController(provider);
Date startDate = new GregorianCalendar(2016, Calendar.JANUARY, 11).getTime();
Date endDate = new GregorianCalendar(2016, Calendar.JANUARY, 11).getTime();
Date expectedEndDate = new Date(endDate.getTime() + TimeUnit.DAYS.toMillis(1) - 1);
controller.getPossibleFilterData(startDate, endDate);
Mockito.verify(provider).getPossibleCountries(Mockito.eq(startDate), Mockito.eq(expectedEndDate));
}
}
    • "ou en vérifiant avec Mockito" - pouvez-vous expliquer comment le faire? Ma question initiale était d'en parler (comment vérifier que date de fin a été modifiée dans le cas endDate==startDate. Ce cas correspond intérieure if).
    • Ive a ajouté un exemple de code pour vous
    • Votre code nécessite d'écrire constructeur de FilterDataController , mais dans ma situation, il est incongrue.Mais merci pour cette approche. Je vais le rappeler. +1
    InformationsquelleAutor mdewit
  3. 0

    Je vois deux approches principales.

    1. À l'aide de Mockito fonctionnalité: si vous injectez votre contrôleur avec un faux FilterDataProvider (qui est l'approche standard, en utilisant par exemple MockitoJUnitRunner et @InjectMocks) , alors vous pouvez utiliser Mockito de la "vérité" option pour vous assurer qu'il a obtenu à la date de fin correcte. Voir la discussion: http://www.vogella.com/tutorials/Mockito/article.html#mockito_verify
    2. Évidemment, il existe d'autres approches qui s'appuient sur la logique plutôt que sur les aspects techniques. Par exemple: refactoring de la "si" une partie à un separateMethod "correctEndDate", ou lors du remplissage de vos données, de sorte qu'une autre liste de pays est retourné basé sur la date de fin.
    • merci pour verify. Il y a des exemples verify(test).testing(Matchers.eq(12));. Mais dans mon cas, je veux vérifier que la méthode dans ma méthode a été appelée avec la correction des dates. Peut-être qch comme ça newEndDate = ...; verify(FilterDataController).getPossibleFilterData().getPossibleCountries(Matchers.eq(startDate, newEndDate));
    InformationsquelleAutor Pelit Mamani