L'injection de Mockito se moque d'une source de haricot

@InjectMocks
private MyTestObject testObject;

@Mock
private MyDependentObject mockedObject;

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

Ce qui permettra d'injecter tout se moquaient d'objets dans la classe de test. Dans ce cas, il va injecter mockedObject dans le testObject. Cela a été mentionné ci-dessus, mais voici le code.

Donné:

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

    //etc
}

Vous pouvez avoir la classe qui est en train d'être testé chargé par permettra à l'autowiring, se moquer de la dépendance avec Mockito, et ensuite utiliser le Printemps ReflectionTestUtils à injecter de la fantaisie 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 le Printemps 4.3.1, cette méthode ne fonctionne pas avec les services de derrière un proxy (annoté avec @Transactional, ou Cacheable, par exemple). Ce problème a été résolu par SPR-14050.

Pour les versions antérieures, une solution consiste à déballer le proxy, comme décrit ici: Transactionnelle annotation évite services être moqué (qui est ce que ReflectionTestUtils.setField n'maintenant par défaut)

Depuis 1.8.3 Mockito a @InjectMocks - ce est incroyablement utile. Mon JUnit tests sont annotation @RunWith la MockitoJUnitRunner et je de construire @Mock les objets qui satisfont à toutes les dépendances de la classe testée, qui sont tous injecté lorsque le membre privé est annotée avec @InjectMocks.

Je annotation @RunWith la SpringJUnit4Runner pour les tests d'intégration seulement maintenant.

Je note qu'il ne semble pas être en mesure d'injecter de la Liste de la même manière que le Printemps. Il semble que pour un objet Fantaisie qui satisfait à la Liste, et de ne pas injecter une liste d'objets Fantaisie. La solution pour moi a été d'utiliser un @Espionner un manuellement instancié liste, et manuellement .ajouter le simulacre de l'objet(s) à cette liste pour les tests unitaires. Peut-être que c'était intentionnel, parce que, certainement, cela m'a obligé à payer une attention particulière à ce qui était moqué d'ensemble.

Dès le Printemps 3.2, ce n'est plus un problème. Le printemps prend désormais en charge permettra à l'autowiring des résultats de générique de méthodes de fabrique. Voir la section intitulée "Générique de Méthodes de Fabrique" de ce blog: http://spring.io/blog/2012/11/07/spring-framework-3-2-rc1-new-testing-features/.

Le point clé est:

Au Printemps 3.2, générique types de retour de l'usine méthodes sont maintenant
correctement déduit, et permettra à l'autowiring par type pour les objets fantaisie, devrait fonctionner aussi
prévu. Comme un résultat, de la personnalisation des solutions de rechange comme un
MockitoFactoryBean, EasyMockFactoryBean, ou Springockito sont probablement pas
plus nécessaire.

Qui signifie que cela doit fonctionner hors de la boîte:

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

Si vous utilisez printemps >= 3.0, essayez d'utiliser des Ressorts @Configuration annotation à 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 voulez pas utiliser le @ImportResource, il peut être fait dans l'autre sens aussi:

<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, jetez un oeil au printemps-cadre de référence : Java configuration du conteneur

Je pouvez effectuer les opérations suivantes à l'aide de Mockito:

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

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

J'ai cherché un moment pour une solution définitive à cette. Ce blog semble couvrir tous mes besoins, et ne pas compter sur la commande de haricot déclarations. Tout le crédit à Mattias Severson. http://www.jayway.com/2011/11/30/spring-integration-tests-part-i-creating-mock-objects/

Fondamentalement, mettre en œuvre une interface 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;
    }
}

Prochaine mise à jour de votre printemps config 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>

J'ai trouvé une semblable réponse teabot pour créer un MockFactory qui fournit les simulacres. J'ai utilisé l'exemple suivant pour créer la maquette de l'usine (depuis le lien pour narkisr sont morts):
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 aide également à empêcher que le Printemps veut résoudre les injections de la moqué de haricot.

- Je utiliser une combinaison de l'approche utilisée dans les réponses par Markus T et un simple helper mise en œuvre de ImportBeanDefinitionRegistrar qui ressemble pour une mesure d'annotation (@MockedBeans) dans lequel on peut spécifier les classes sont se moque de lui. Je crois que cette approche aboutit à une description concise de l'unité de test avec certains du code réutilisable liées à moqueur supprimé.

Voici comment un échantillon de test de l'unité regarde avec cette approche: les

@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'aide - annotations personnalisées (@MockedBeans) et personnalisé
ImportBeanDefinitionRegistrar mise en œuvre. @MockedBeans annotation définition doit être annotée avec @Import(CustomImportBeanDefinitionRegistrar.class) et la ImportBeanDefinitionRgistrar besoin d'ajouter de la moqué de haricots définitions de la configuration du registerBeanDefinitions méthode.

Si vous aimez l'approche que vous pouvez trouver un exemple de implémentations sur mon article sur le blog.

Je vous propose de migrer votre projet pour le Printemps de Démarrage 1.4. Après cela, vous pouvez utiliser la nouvelle annotation @MockBean de truquer votre com.package.Dao

Pour l'enregistrement, tous mes tests de fonctionner correctement par juste faire de l'appareil paresseux-initialisé, 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 raison en est l'un Mattias explique ici (en bas du post), qu'une solution de contournement est de changer l'ordre les haricots sont déclarées - initialisation différée est "une sorte de" avoir l'appareil a déclaré à la fin.