TOC

Injecter Mockito se moque des haricots de printemps

Injecter Mockito se moque des haricots de printemps

1. Vue d'ensemble

Cet article expliquera comment utiliser l’injection de dépendance pour insérer des prototypes Mockito dans Spring Beans à des fins de test unitaire.

Dans les applications réelles, où les composants dépendent souvent de l'accès à des systèmes externes, il est important de fournir une isolation de test appropriée afin que nous puissions nous concentrer sur le test de la fonctionnalité d'une unité donnée sans avoir à impliquer la hiérarchie de classe entière pour chaque test.

L'injection d'une maquette est un moyen propre d'introduire un tel isolement.

2. Dépendances Maven

Les dépendances Maven suivantes sont requises pour les tests unitaires et les objets fictifs: 


    org.springframework.boot
    spring-boot-starter
    1.3.1.RELEASE


    org.springframework.boot
    spring-boot-starter-test
    1.3.1.RELEASE
    test


    org.mockito
    mockito-core
    2.21.0

Nous avons décidé d'utiliser Spring Boot pour cet exemple, mais Spring classique fonctionnera également correctement.

3. Écrire le test

3.1. La logique métier

Tout d'abord, nous allons écrire la logique métier qui sera testée: 

@Service
public class NameService {
    public String getUserName(String id) {
        return "Real user name";
    }
}

La classeNameService sera injectée dans: 

@Service
public class UserService {

    private NameService nameService;

    @Autowired
    public UserService(NameService nameService) {
        this.nameService = nameService;
    }

    public String getUserName(String id) {
        return nameService.getUserName(id);
    }
}

Pour ce tutoriel, les classes données retournent un nom unique, quel que soit l'identifiant fourni. Ceci est fait pour que nous ne soyons pas distraits en testant une logique complexe.

Nous aurons également besoin d’une classe principale Spring Boot standard pour analyser les beans et initialiser l’application: 

@SpringBootApplication
public class MocksApplication {
    public static void main(String[] args) {
        SpringApplication.run(MocksApplication.class, args);
    }
}

3.2. Les tests

Passons maintenant à la logique de test. Tout d'abord, nous devons configurer le contexte d'application pour les tests: 

@Profile("test")
@Configuration
public class NameServiceTestConfiguration {
    @Bean
    @Primary
    public NameService nameService() {
        return Mockito.mock(NameService.class);
    }
}

L'annotation@Profile indique à Spring d'appliquer cette configuration uniquement lorsque le profil «test» est actif. L'annotation@Primary est là pour s'assurer que cette instance est utilisée au lieu d'une vraie pour le câblage automatique. La méthode elle-même crée et retourne une maquette Mockito de notre classeNameService.

Maintenant nous pouvons écrire le test unitaire: 

@ActiveProfiles("test")
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = MocksApplication.class)
public class UserServiceUnitTest {

    @Autowired
    private UserService userService;

    @Autowired
    private NameService nameService;

    @Test
    public void whenUserIdIsProvided_thenRetrievedNameIsCorrect() {
        Mockito.when(nameService.getUserName("SomeId")).thenReturn("Mock user name");
        String testName = userService.getUserName("SomeId");
        Assert.assertEquals("Mock user name", testName);
    }
}

Nous utilisons l'annotation@ActiveProfiles pour activer le profil «test» et activer la configuration fictive que nous avons écrite précédemment. Pour cette raison, Spring transfère automatiquement une instance réelle de la classeUserService, mais une simulation de la classeNameService. Le test lui-même est un test assez typique de JUnit + Mockito. Nous configurons le comportement souhaité de la maquette, puis appelons la méthode que nous voulons tester et affirmons qu'elle renvoie la valeur attendue.

Il est également possible (bien que cela ne soit pas recommandé) d'éviter d'utiliser des profils d'environnement dans de tels tests. Pour ce faire, supprimez les annotations@Profile and @ActiveProfiles et ajoutez une annotation@ContextConfiguration(classes = NameServiceTestConfiguration.class) à la classeUserServiceTest.

4. Conclusion

Le tutoriel a montré comment injecter Mockito dans des haricots de printemps. L'implémentation peut être trouvée dans lesexample GitHub project.

Related