Injection de Mockito dans un haricot de printemps

Je voudrais injecter un objet maquette Mockito dans un bean Spring (3+) à des fins de tests unitaires avec JUnit. Mes dépendances de bean sont actuellement injectées en utilisant l' @Autowiredannotation sur les champs membres privés.

J'ai envisagé d'utiliser ReflectionTestUtils.setFieldmais l'instance de bean que je souhaite injecter est en fait un proxy et ne déclare donc pas les champs membres privés de la classe cible. Je ne souhaite pas créer un setter public pour la dépendance car je modifierai alors mon interface uniquement à des fins de test.

J'ai suivi quelques conseils donnés par la communauté Spring, mais la maquette n'est pas créée et le câblage automatique échoue:

<bean id="dao" class="org.mockito.Mockito" factory-method="mock">
    <constructor-arg value="com.package.Dao" />
</bean>

L'erreur que je rencontre actuellement est la suivante:

...
Caused by: org...NoSuchBeanDefinitionException:
    No matching bean of type [com.package.Dao] found for dependency:
    expected at least 1 bean which qualifies as autowire candidate for this dependency.
    Dependency annotations: {
        @org...Autowired(required=true),
        @org...Qualifier(value=dao)
    }
at org...DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(D...y.java:901)
at org...DefaultListableBeanFactory.doResolveDependency(D...y.java:770)

Si je définit la constructor-argvaleur sur quelque chose de non valide, aucune erreur ne se produit lors du démarrage du contexte d'application.

La meilleure façon est:

<bean id="dao" class="org.mockito.Mockito" factory-method="mock"> 
    <constructor-arg value="com.package.Dao" /> 
</bean> 

Mettre à jour
Dans le fichier de contexte, cette maquette doit être répertoriée avant tout champ autowired selon qu'elle est déclarée.

@InjectMocks
private MyTestObject testObject;

@Mock
private MyDependentObject mockedObject;

@Before
public void setup() {
        MockitoAnnotations.initMocks(this);
}

Cela injectera tous les objets simulés dans la classe de test. Dans ce cas, il injectera mockedObject dans testObject. Cela a été mentionné ci-dessus mais voici le code.

J'ai une solution très simple utilisant Spring Java Config et Mockito:

@Configuration
public class TestConfig {

    @Mock BeanA beanA;
    @Mock BeanB beanB;

    public TestConfig() {
        MockitoAnnotations.initMocks(this); //This is a key
    }

    //You basically generate getters and add @Bean annotation everywhere
    @Bean
    public BeanA getBeanA() {
        return beanA;
    }

    @Bean
    public BeanB getBeanB() {
        return beanB;
    }
}

Donné:

@Service
public class MyService {
    @Autowired
    private MyDAO myDAO;

    // etc
}

Vous pouvez charger la classe testée via le câblage automatique, simuler la dépendance avec Mockito, puis utiliser ReflectionTestUtils de Spring pour injecter la simulation dans la classe testée.

@ContextConfiguration(classes = { MvcConfiguration.class })
@RunWith(SpringJUnit4ClassRunner.class)
public class MyServiceTest {
    @Autowired
    private MyService myService;

    private MyDAO myDAOMock;

    @Before
    public void before() {
        myDAOMock = Mockito.mock(MyDAO.class);
        ReflectionTestUtils.setField(myService, "myDAO", myDAOMock);
    }

    // etc
}

Veuillez noter qu'avant Spring 4.3.1, cette méthode ne fonctionnera pas avec les services derrière un proxy (annoté avec @Transactionalou Cacheable, par exemple). Cela a été corrigé par SPR-14050 .

Pour les versions antérieures, une solution consiste à déballer le proxy, comme décrit ici: l' annotation transactionnelle évite de se moquer des services (ce qui se ReflectionTestUtils.setFieldfait par défaut maintenant)

Si vous utilisez Spring Boot 1.4, il a une manière impressionnante de le faire. Utilisez simplement une nouvelle marque @SpringBootTestsur votre classe et @MockBeansur le terrain et Spring Boot créera une maquette de ce type et l'injectera dans le contexte (au lieu d'injecter l'original):

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyTests {

    @MockBean
    private RemoteService remoteService;

    @Autowired
    private Reverser reverser;

    @Test
    public void exampleTest() {
        // RemoteService has been injected into the reverser bean
        given(this.remoteService.someCall()).willReturn("mock");
        String reverse = reverser.reverseSomeCall();
        assertThat(reverse).isEqualTo("kcom");
    }

}

En revanche, si vous n'utilisez pas Spring Boot ou utilisez une version précédente, vous devrez faire un peu plus de travail:

Créez un @Configurationbean qui injecte vos mocks dans le contexte Spring:

@Configuration
@Profile("useMocks")
public class MockConfigurer {

    @Bean
    @Primary
    public MyBean myBeanSpy() {
        return mock(MyBean.class);
    }
}

En utilisant @Primary annotation, vous dites au printemps que ce bean a la priorité si aucun qualificatif n'est spécifié.

Assurez-vous d'annoter la classe avec @Profile("useMocks")afin de contrôler quelles classes utiliseront la maquette et lesquelles utiliseront le vrai bean.

Enfin, dans votre test, activez le userMocksprofil:

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = {Application.class})
@WebIntegrationTest
@ActiveProfiles(profiles={"useMocks"})
public class YourIntegrationTestIT {

    @Inject
    private MyBean myBean; //It will be the mock!


    @Test
    public void test() {
        ....
    }
}

Si vous ne voulez pas utiliser la maquette mais le vrai bean, n'activez pas le useMocksprofil:

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = {Application.class})
@WebIntegrationTest
public class AnotherIntegrationTestIT {

    @Inject
    private MyBean myBean; //It will be the real implementation!


    @Test
    public void test() {
        ....
    }
}

Depuis 1.8.3 Mockito a @InjectMocks- c'est incroyablement utile. Mes tests JUnit sont @RunWithles objets MockitoJUnitRunneret je construis @Mockqui satisfont toutes les dépendances de la classe testée, qui sont tous injectés lorsque le membre privé est annoté avec@InjectMocks .

Je @RunWithleSpringJUnit4Runner pour les tests d'intégration seulement maintenant.

Je noterai qu'il ne semble pas pouvoir s'injecter List<T>de la même manière que Spring. Il recherche uniquement un objet Mock qui satisfait à List, et n'injectera pas une liste d'objets Mock. La solution de contournement pour moi consistait à utiliser une @Spycontre une liste instanciée manuellement et à ajouter manuellement le ou les objets fictifs à cette liste pour les tests unitaires. Peut-être que c'était intentionnel, car cela m'a certainement forcé à porter une attention particulière à ce qui se moquait ensemble.

Mettre à jour: il existe désormais de meilleures solutions plus propres à ce problème. Veuillez d'abord considérer les autres réponses.

J'ai finalement trouvé une réponse à cette question par Ronen sur son blog. Le problème que je rencontrais est dû à la méthode Mockito.mock(Class c)déclarant un type de retour deObject . Par conséquent, Spring n'est pas en mesure de déduire le type de bean du type de retour de méthode d'usine.

La solution de Ronen consiste à créer une FactoryBeanimplémentation qui renvoie des simulations. leFactoryBean interface permet à Spring d'interroger le type d'objets créés par le bean d'usine.

Ma définition de bean simulé ressemble maintenant à:

<bean id="mockDaoFactory" name="dao" class="com.package.test.MocksFactory">
    <property name="type" value="com.package.Dao" />
</bean>

Depuis le printemps 3.2, ce n'est plus un problème. Spring prend désormais en charge le câblage automatique des résultats des méthodes d'usine génériques. Voir la section intitulée "Méthodes génériques d'usine" dans cet article de blog: http://spring.io/blog/2012/11/07/spring-framework-3-2-rc1-new-testing-features/ .

Le point clé est:

Au printemps 3.2, les types de retour génériques pour les méthodes d'usine sont désormais correctement déduits, et le câblage automatique par type pour les simulations devrait fonctionner comme prévu. Par conséquent, des solutions de contournement personnalisées telles que MockitoFactoryBean, EasyMockFactoryBean ou Springockito ne sont probablement plus nécessaires.

Ce qui signifie que cela devrait fonctionner hors de la boîte:

<bean id="dao" class="org.mockito.Mockito" factory-method="mock">
    <constructor-arg value="com.package.Dao" />
</bean>

Le code ci-dessous fonctionne avec le câblage automatique - ce n'est pas la version la plus courte mais utile quand il ne devrait fonctionner qu'avec des pots à ressort / mockito standard.

<bean id="dao" class="org.springframework.aop.framework.ProxyFactoryBean">
   <property name="target"> <bean class="org.mockito.Mockito" factory-method="mock"> <constructor-arg value="com.package.Dao" /> </bean> </property>
   <property name="proxyInterfaces"> <value>com.package.Dao</value> </property>
</bean> 

Si vous utilisez spring> = 3.0 , essayez d'utiliser l' @Configurationannotation Springs pour définir une partie du contexte de l'application

@Configuration
@ImportResource("com/blah/blurk/rest-of-config.xml")
public class DaoTestConfiguration {

    @Bean
    public ApplicationService applicationService() {
        return mock(ApplicationService.class);
    }

}

Si vous ne souhaitez pas utiliser @ImportResource, cela peut aussi être fait dans l'autre sens:

<beans>
    <!-- rest of your config -->

    <!-- the container recognize this as a Configuration and adds it's beans 
         to the container -->
    <bean class="com.package.DaoTestConfiguration"/>
</beans>

Pour plus d'informations, consultez Spring-Framework-Reference: configuration de conteneur basée sur Java

Ce n'est peut-être pas la solution parfaite, mais j'ai tendance à ne pas utiliser le ressort pour faire DI pour les tests unitaires. les dépendances pour un seul bean (la classe sous test) ne sont généralement pas trop complexes donc je fais juste l'injection directement dans le code de test.

Je peux faire ce qui suit en utilisant Mockito:

<bean id="stateMachine" class="org.mockito.Mockito" factory-method="mock">
    <constructor-arg value="com.abcd.StateMachine"/>
</bean>

Affichage de quelques exemples basés sur les approches ci-dessus

Avec le printemps:

@ContextConfiguration(locations = { "classpath:context.xml" })
@RunWith(SpringJUnit4ClassRunner.class)
public class TestServiceTest {
    @InjectMocks
    private TestService testService;
    @Mock
    private TestService2 testService2;
}

Sans ressort:

@RunWith(MockitoJUnitRunner.class)
public class TestServiceTest {
    @InjectMocks
    private TestService testService = new TestServiceImpl();
    @Mock
    private TestService2 testService2;
}

Mise à jour - nouvelle réponse ici: https://stackoverflow.com/a/19454282/411229 . Cette réponse ne s'applique qu'à ceux des versions Spring antérieures à 3.2.

J'ai cherché pendant un certain temps une solution plus définitive à cela. Ce billet de blog semble couvrir tous mes besoins et ne repose pas sur la commande de déclarations de bean. Tous les crédits à Mattias Severson. http://www.jayway.com/2011/11/30/spring-integration-tests-part-i-creating-mock-objects/

Fondamentalement, implémentez un FactoryBean

package com.jayway.springmock;

import org.mockito.Mockito;
import org.springframework.beans.factory.FactoryBean;

/**
 * A {@link FactoryBean} for creating mocked beans based on Mockito so that they 
 * can be {@link @Autowired} into Spring test configurations.
 *
 * @author Mattias Severson, Jayway
 *
 * @see FactoryBean
 * @see org.mockito.Mockito
 */
public class MockitoFactoryBean<T> implements FactoryBean<T> {

    private Class<T> classToBeMocked;

    /**
     * Creates a Mockito mock instance of the provided class.
     * @param classToBeMocked The class to be mocked.
     */
    public MockitoFactoryBean(Class<T> classToBeMocked) {
        this.classToBeMocked = classToBeMocked;
    }

    @Override
    public T getObject() throws Exception {
        return Mockito.mock(classToBeMocked);
    }

    @Override
    public Class<?> getObjectType() {
        return classToBeMocked;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

Mettez à jour votre configuration de printemps avec les éléments suivants:

<beans...>
    <context:component-scan base-package="com.jayway.example"/>

    <bean id="someDependencyMock" class="com.jayway.springmock.MockitoFactoryBean">
        <constructor-arg name="classToBeMocked" value="com.jayway.example.SomeDependency" />
    </bean>
</beans>

En regardant le rythme de développement de Springockito et le nombre de problèmes en suspens , je serais un peu inquiet de l'introduire dans ma pile de suite de tests de nos jours. Le fait que la dernière version ait été réalisée avant la version Spring 4 soulève des questions comme "Est-il possible de l'intégrer facilement à Spring 4?". Je ne sais pas, parce que je ne l'ai pas essayé. Je préfère l'approche Spring pure si j'ai besoin de se moquer de Spring Bean dans le test d'intégration.

Il existe une option pour simuler le haricot de printemps avec des fonctionnalités de printemps simples. Vous devez l'utiliser @Primary, @Profileet des @ActiveProfilesannotations pour cela. J'ai écrit un article de blog sur le sujet.

J'ai trouvé une réponse similaire à celle du teabot pour créer une MockFactory qui fournit les simulacres. J'ai utilisé l'exemple suivant pour créer la fausse usine (car le lien vers narkisr est mort): http://hg.randompage.org/java/src/407e78aa08a0/projects/bookmarking/backend/spring/src/test/java/ org / randompage / bookmarking / backend / testUtils / MocksFactory.java

<bean id="someFacade" class="nl.package.test.MockFactory">
    <property name="type" value="nl.package.someFacade"/>
</bean>

Cela permet également d'éviter que Spring veuille résoudre les injections du haricot moqué.

<bean id="mockDaoFactory" name="dao" class="com.package.test.MocksFactory">
    <property name="type" value="com.package.Dao" />
</bean>

cela ^ fonctionne parfaitement bien s'il est déclaré en premier / au début du fichier XML. Mockito 1.9.0 / Spring 3.0.5

J'utilise une combinaison de l'approche utilisée en réponse par Markus T et une implémentation d'aide simple ImportBeanDefinitionRegistrarqui recherche une annotation personnalisée (@MockedBeans ) dans laquelle on peut spécifier quelles classes doivent être moquées. Je crois que cette approche se traduit par un test unitaire concis avec une partie du code passe-partout lié à la moquerie supprimée.

Voici à quoi ressemble un exemple de test unitaire avec cette approche:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(loader=AnnotationConfigContextLoader.class)
public class ExampleServiceIntegrationTest {

    //our service under test, with mocked dependencies injected
    @Autowired
    ExampleService exampleService;

    //we can autowire mocked beans if we need to used them in tests
    @Autowired
    DependencyBeanA dependencyBeanA;

    @Test
    public void testSomeMethod() {
        ...
        exampleService.someMethod();
        ...
        verify(dependencyBeanA, times(1)).someDependencyMethod();
    }

    /**
     * Inner class configuration object for this test. Spring will read it thanks to
     * @ContextConfiguration(loader=AnnotationConfigContextLoader.class) annotation on the test class.
     */
    @Configuration
    @Import(TestAppConfig.class) //TestAppConfig may contain some common integration testing configuration
    @MockedBeans({DependencyBeanA.class, DependencyBeanB.class, AnotherDependency.class}) //Beans to be mocked
    static class ContextConfiguration {

        @Bean
        public ExampleService exampleService() {
            return new ExampleService(); //our service under test
        }
    }
}

Pour ce faire, vous devez définir deux classes d'assistance simples - une annotation personnalisée ( @MockedBeans) et une ImportBeanDefinitionRegistrarimplémentation personnalisée . @MockedBeansla définition d'annotation doit être annotée @Import(CustomImportBeanDefinitionRegistrar.class)et la ImportBeanDefinitionRgistrarnécessité d'ajouter des définitions de beans fictifs à la configuration dans sa registerBeanDefinitionsméthode.

Si vous aimez l'approche, vous pouvez trouver des exemples d' implémentations sur mon blogpost .

J'ai développé une solution basée sur la proposition de Kresimir Nesek. J'ai ajouté une nouvelle annotation @EnableMockedBean afin de rendre le code un peu plus propre et modulaire.

@EnableMockedBean
@SpringBootApplication
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes=MockedBeanTest.class)
public class MockedBeanTest {

    @MockedBean
    private HelloWorldService helloWorldService;

    @Autowired
    private MiddleComponent middleComponent;

    @Test
    public void helloWorldIsCalledOnlyOnce() {

        middleComponent.getHelloMessage();

        // THEN HelloWorldService is called only once
        verify(helloWorldService, times(1)).getHelloMessage();
    }

}

J'ai écrit un article pour l' expliquer.

Je suggère de migrer votre projet vers Spring Boot 1.4. Après cela, vous pouvez utiliser une nouvelle annotation @MockBeanpour simuler votrecom.package.Dao

Aujourd'hui, j'ai découvert qu'un contexte printanier où je déclarais un avant les haricots Mockito ne se chargeait pas. Après avoir déplacé APRÈS les simulations, le contexte de l'application a été chargé avec succès. Prends soin de toi :)

Pour mémoire, tous mes tests fonctionnent correctement en faisant juste l'initialisation paresseux du projecteur, par exemple:

<bean id="fixture"
      class="it.tidalwave.northernwind.rca.embeddedserver.impl.DefaultEmbeddedServer"
      lazy-init="true" /> <!-- To solve Mockito + Spring problems -->

<bean class="it.tidalwave.messagebus.aspect.spring.MessageBusAdapterFactory" />

<bean id="applicationMessageBus"
      class="org.mockito.Mockito" factory-method="mock">
    <constructor-arg value="it.tidalwave.messagebus.MessageBus" />
</bean>

<bean class="org.mockito.Mockito" factory-method="mock">
    <constructor-arg value="javax.servlet.ServletContext" />
</bean>

Je suppose que la justification est celle que Mattias explique ici (au bas du message), qu'une solution de contournement change l'ordre dans lequel les beans sont déclarés - l'initialisation paresseuse est une sorte de "déclaration" du luminaire à la fin.

Si vous utilisez l'injection de contrôleur, assurez-vous que vos variables locales ne sont PAS "finales"