Inyectando Mockito en un frijol Spring

Me gustaría inyectar un objeto simulado de Mockito en un bean Spring (3+) con el fin de realizar pruebas unitarias con JUnit. Mis dependencias de frijol se inyectan actualmente mediante el uso de @Autowired anotación en campos de miembros privados.

He considerado usar ReflectionTestUtils.setField pero la instancia de bean que deseo inyectar es en realidad un proxy y, por lo tanto, no declara los campos de miembros privados de la clase de destino. No deseo crear un establecedor público para la dependencia, ya que luego modificaré mi interfaz únicamente con fines de prueba.

He seguido algunos asesoramiento dado por la comunidad de Spring, pero el simulacro no se crea y el cableado automático falla:

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

El error que encuentro actualmente es el siguiente:

...
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 configuro el constructor-arg valor a algo no válido no se produce ningún error al iniciar el contexto de la aplicación.

preguntado el 16 de marzo de 10 a las 15:03

Por favor, eche un vistazo a esta pequeña criatura: bitbucket.org/kubek2k/springockito/wiki/Inicio -

Este es un enfoque muy limpio, ¡me gusta! -

Me tenías en Springockito-anotaciones. -

Para aquellos que usan Spring 4. *, a partir de enero de 2015, esto no parece funcionar con la última versión de Spring Mockito y el proyecto parece estar inactivo. -

23 Respuestas

La mejor forma es:

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

Noticias
En el archivo de contexto, este simulacro debe aparecer antes de que se declare cualquier campo con cableado automático que dependa de él.

Respondido 22 ago 13, 10:08

Recibo un error: "Error al crear un bean con el nombre 'mockito': la definición del bean es abstracta" - ttppp

@amra: Spring no infiere el tipo de objeto devuelto en este caso ... stackoverflow.com/q/6976421/306488 - lisak

No sé por qué esta respuesta se vota tanto, el bean resultante no se puede conectar automáticamente porque tiene el tipo incorrecto. - Azerole

Se puede conectar automáticamente si aparece primero en el archivo de contexto (antes de que se declaren los campos conectados automáticamente que dependerían de él). ryan paredes

A partir de la primavera 3.2, el orden de los granos ya no importa. Consulte la sección titulada "Métodos genéricos de fábrica" ​​en esta publicación de blog: spring.io/blog/2012/11/07/… - ryan paredes

@InjectMocks
private MyTestObject testObject;

@Mock
private MyDependentObject mockedObject;

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

Esto inyectará cualquier objeto simulado en la clase de prueba. En este caso, inyectará mockedObject en testObject. Esto se mencionó anteriormente, pero aquí está el código.

Respondido el 23 de enero de 18 a las 22:01

¿Cómo apruebo un método particular de mockedObject? - jim holden

@Teinacher cuando (mockedObject.execute) .thenReturn (objToReturn); Puede poner eso en el método anterior o dentro de su método de prueba. - teoría del caos

Para su información: este enfoque no funcionará, si quiero Autowiring parcial y simulacro parcial en MyTestObject. - raksja

No sé por qué esto no se vota más alto. Si veo más respuestas que contengan XML, voy a lanzar. - MarcaDeHall

¿Por qué no usas Mockito.spy(...) en esto mockedObject ¿en lugar de? Y luego usa when(mockedObject.execute).thenReturn(objToReturn) or doReturn(objToReturn).when(mockedObject).execute(). El segundo no invoca el método real. Puedes consultar también Mockito.doCallRealMethod() documentación - Tomasz Przybylski

Tengo una solución muy simple usando Spring Java Config y 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;
    }
}

Respondido 20 ago 12, 14:08

Por alguna razón con este enfoque, Spring intenta crear el bean real de todos modos (en lugar de simularlo) y se ahoga con eso ... ¿Qué estoy haciendo mal? - Daniel Gruszczyk

Tengo el mismo problema - alex korobko

No Spring, sino Mockito intenta crear una instancia de un bean real si te estás burlando de una clase. Si tiene beans que deben simularse en las pruebas, deben ser implementaciones de una interfaz e inyectarse a través de esa interfaz. Si luego simula la interfaz (en lugar de la clase), mockito no intentará crear una instancia de esa clase. - Daniel Gruszczyk

¿Cual es el punto? ¿Por qué agregar los campos anotados y el constructor con initMocks? Porque no solo return Mockito.mock(BeanA.class) in getBeanA ? De esta manera es más simple y hay menos código. ¿Qué me estoy perdiendo? - Oleg

@Oleg parece que tiene su propia solución, que probablemente debería publicar como respuesta, para que la comunidad pueda votarla. - Dawud ibn Karim

Dado:

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

    // etc
}

Puede hacer que la clase que se está probando se cargue a través del cableado automático, simular la dependencia con Mockito y luego usar Spring's ReflectionTestUtils para inyectar la simulación en la clase que se está probando.

@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
}

Tenga en cuenta que antes de Spring 4.3.1, este método no funcionará con servicios detrás de un proxy (anotado con @Transactional o el Cacheable, por ejemplo). Esto ha sido arreglado por SPR-14050.

Para versiones anteriores, una solución es desenvolver el proxy, como se describe allí: La anotación transaccional evita que se burlen de los servicios (Que es que ReflectionTestUtils.setField lo hace por defecto ahora)

respondido 24 mar '18, 20:03

Double @RunWith (SpringJUnit4ClassRunner.class) y utilizo diferentes anotaciones para la clase de prueba (mismo corredor) pero este enfoque funciona para mí, gracias. - user1317422

Me inspiré mucho en "Tenga en cuenta que antes de Spring 4.3.1, este método no funcionará con servicios detrás de un proxy (anotado con @Transactional o Cacheable, por ejemplo). Esto ha sido corregido por SPR-14050". Me encontré con este problema exactamente y no obtuve ninguna pista hasta que vi estas palabras. ¡MUCHAS GRACIAS! - zorro de nieve

Esta solución maneja cuando ha conectado un contexto de aplicación completo y, con fines de prueba, desea inyectar una simulación en un bean aleatorio en su contexto. Usé esta respuesta para simular un bean cliente fingido para evitar llamadas REST a otros módulos en una prueba de módulo. Solo conseguí que la anotación InjectMock funcionara cuando inyecta simulacros en un bean que está a punto de probar, no en un bean creado por la configuración de la aplicación Spring. - andreas lundgren

Casi un día entero tratando de que @MockBean funcione sin restablecer el contexto y luego me encuentro con esta joya. Exactamente lo que necesitaba, salud. - Matt R

Funciona, aunque tenga en cuenta que el campo reemplazado podría no restablecerse debido al almacenamiento en caché y algunas pruebas no relacionadas podrían fallar. Por ejemplo, en mi prueba reemplacé el codificador de contraseña con uno simulado y algunas otras pruebas se rompieron debido a fallas de autorización. - alextsil

Si está utilizando Spring Boot 1.4, tiene una forma increíble de hacer esto. Solo usa una nueva marca @SpringBootTest en tu clase y @MockBean en el campo y Spring Boot creará un simulacro de este tipo y lo inyectará en el contexto (en lugar de inyectar el 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");
    }

}

Por otro lado, si no está usando Spring Boot o está usando una versión anterior, tendrá que trabajar un poco más:

Crear un @Configuration bean que inyecta tus simulacros en el contexto de Spring:

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

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

Usar @Primary anotación que le está diciendo a Spring que este bean tiene prioridad si no se especifica ningún calificador.

Asegúrate de anotar la clase con @Profile("useMocks") para controlar qué clases usarán el simulacro y cuáles usarán el bean real.

Finalmente, en su prueba, active userMocks perfil:

@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 no desea usar el simulacro sino el bean real, simplemente no active useMocks perfil:

@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() {
        ....
    }
}

Respondido el 28 de Septiembre de 16 a las 14:09

Esta respuesta debería ir a la parte superior: el soporte de @MockBean en spring boot también se puede usar sin spring-boot. ¡Puede usarlo solo en pruebas unitarias para que funcione para todas las aplicaciones de resorte! - Bedrin

@Anotación de perfil que puede establecer también en el método de definición de bean, para evitar crear una clase de configuración separada - Marcin

¡Gran respuesta! Hice algunos cambios para que funcionara con mi vieja escuela web.xml y configuración de AnnotationConfigWebApplicationContext. Tuve que usar @WebAppConfiguration en lugar de @WebIntegrationTest y @ContextHierarchy con @ContextConfiguration en lugar de @SpringApplicationConfiguration. - UTF_o_muerte

Tuve que agregar el @Primary anotación para mi caso, ya que hubo una llamada fallida dentro de un @PostConstruct que quería burlarme, pero el @PostConstructEl bean se creó antes de mi simulacro, por lo que no usó el simulacro (hasta que agregué @Primary). - cariño

@MockBean tiene un inconveniente importante: puede llevar a la recreación de su contexto Spring en su fase de prueba de compilación. (Ver stackoverflow.com/questions/45587213/… or el problema con @MockBean). Puedes usar @MockInBean como alternativa a @MockBean que no restablece el contexto. Ver mi respuesta - antonie meyer

Como 1.8.3 Mockito tiene @InjectMocks - esto es increíblemente útil. Mis pruebas JUnit son @RunWith La MockitoJUnitRunner y yo construyo @Mock objetos que satisfacen todas las dependencias de la clase que se está probando, que se inyectan cuando el miembro privado se anota con @InjectMocks.

I @RunWith La SpringJUnit4Runner para pruebas de integración solo ahora.

Notaré que no parece poder inyectar List<T> de la misma manera que Spring. Solo busca un objeto Mock que satisfaga el Listy no inyectará una lista de objetos simulados. La solución para mí fue usar un @Spy contra una lista instanciada manualmente, y agregue manualmente los objetos simulados a esa lista para la prueba unitaria. Tal vez eso fue intencional, porque ciertamente me obligó a prestar mucha atención a lo que se estaban burlando juntos.

Respondido 19 ago 19, 13:08

Sí, esta es la mejor manera. Springockito en realidad no inyecta las simulaciones por alguna razón en mi caso. - teoría del caos

Actualizar: Ahora existen soluciones mejores y más limpias para este problema. Considere primero las otras respuestas.

Finalmente encontré una respuesta a esto por ronen en su blog. El problema que estaba teniendo se debe al método Mockito.mock(Class c) declarando un tipo de retorno de Object. En consecuencia, Spring no puede inferir el tipo de bean del tipo de retorno del método de fábrica.

La solución de Ronen es crear un FactoryBean implementación que devuelve simulacros. La FactoryBean La interfaz permite a Spring consultar el tipo de objetos creados por el bean de fábrica.

Mi definición de frijol simulado ahora se ve así:

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

Respondido 25 Jul 11, 10:07

Enlace actualizado a la solución de Ronen: narkisr.com/blog/2008/2647754885089732945 - Jeff Martin

No entiendo eso, el método de fábrica tiene tipo de retorno Objeto ... Pero la solución de amra tiene un tipo de retorno genérico para que Spring debería reconocerlo ... Pero la solución de amra no funciona para mí - lisak

Tampoco esta solución, spring no infiere el tipo de bean que se devuelve desde el factoryBean, por lo tanto, no hay un bean coincidente de tipo [com.package.Dao] ... - lisak

Este enlace todavía funciona: javadesarrolloparalasmasas.blogspot.com/2008/07/… Simplemente desactive la redirección de enlaces en su navegador y lo verá, en lugar de verse obligado a mirar el 404 en su nuevo blog. - aproximadamente azul

A partir de Spring 3.2, esto ya no es un problema. Spring ahora admite el cableado automático de los resultados de los métodos genéricos de fábrica. Consulte la sección titulada "Métodos genéricos de fábrica" ​​en esta publicación de blog: http://spring.io/blog/2012/11/07/spring-framework-3-2-rc1-new-testing-features/.

El punto clave es:

En Spring 3.2, los tipos de retorno genéricos para los métodos de fábrica ahora se infieren correctamente, y el cableado automático por tipo para simulacros debería funcionar como se esperaba. Como resultado, es probable que ya no sean necesarias soluciones alternativas personalizadas como MockitoFactoryBean, EasyMockFactoryBean o Springockito.

Lo que significa que esto debería funcionar de inmediato:

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

Respondido 18 Oct 13, 17:10

El siguiente código funciona con cableado automático: no es la versión más corta, pero es útil cuando debería funcionar solo con frascos de resorte / mockito estándar.

<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> 

Respondido 07 ago 15, 03:08

Trabajó para mi. Tuve que desenvolver el proxy en mi prueba para verificarlo como se describe aquí: forum.spring.io/forum/spring-projects/aop/… - Holgzn

Si estás usando primavera> = 3.0, intente usar Springs @Configuration anotación para definir parte del contexto de la aplicación

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

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

}

Si no desea utilizar @ImportResource, también puede hacerlo al revés:

<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>

Para obtener más información, eche un vistazo a spring-framework-reference: Configuración de contenedor basada en Java

respondido 24 mar '18, 19:03

Bonita. Usé esto cuando la prueba que estoy probando es @Autowired en el caso de prueba real. - enkor

Quizás no sea la solución perfecta, pero tiendo a no usar el resorte para hacer DI para las pruebas unitarias. las dependencias para un solo bean (la clase bajo prueba) generalmente no son demasiado complejas, así que simplemente hago la inyección directamente en el código de prueba.

respondido 16 mar '10, 19:03

Entiendo tu enfoque. Sin embargo, me encuentro en esta situación en una gran base de código heredado que no permite esto fácilmente, todavía. - tetera

He encontrado que el combo Mockito / Spring es muy útil cuando necesito probar un código que depende en gran medida de los aspectos Spring / AOP (por ejemplo, al probar las reglas de seguridad de Spring). Aunque uno está perfectamente justificado al afirmar que tales pruebas deberían ser una prueba de integración. - Lars Tackman

@Lars - estuvo de acuerdo - lo mismo podría decirse de las pruebas con las que estoy lidiando. - tetera

Puedo hacer lo siguiente usando Mockito:

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

Respondido 19 Oct 14, 22:10

Gracias por la respuesta @Alexander. ¿Puedo preguntar: se conecta correctamente? Si es así, ¿qué versiones de Spring / Mockito estás usando? - tetera

Quiero un espía, no una burla. Como hacer eso ? - Antoniossss

Publicar algunos ejemplos basados ​​en los enfoques anteriores

Con primavera:

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

Sin resorte:

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

Respondido el 10 de Septiembre de 12 a las 14:09

Noticias - nueva respuesta aquí: https://stackoverflow.com/a/19454282/411229. Esta respuesta solo se aplica a aquellos en las versiones de Spring anteriores a 3.2.

He buscado durante un tiempo una solución más definitiva para esto. Esta publicación de blog parece cubrir todas mis necesidades y no se basa en el pedido de declaraciones de frijoles. Todo el mérito de Mattias Severson. http://www.jayway.com/2011/11/30/spring-integration-tests-part-i-creating-mock-objects/

Básicamente, implemente 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;
    }
}

A continuación, actualice su configuración de primavera con lo siguiente:

<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>

contestado el 23 de mayo de 17 a las 13:05

En cuanto a Ritmo de desarrollo de Springockito y número de problemas abiertos, Me preocuparía un poco introducirlo en mi pila de conjuntos de pruebas hoy en día. El hecho de que la última versión se realizó antes de la versión Spring 4 plantea preguntas como "¿Es posible integrarlo fácilmente con Spring 4?". No lo sé, porque no lo probé. Prefiero el enfoque puro de Spring si necesito simular Spring bean en la prueba de integración.

Hay una opción para falsificar Spring Bean con características simples de Spring. Necesitas usar @Primary, @Profile y @ActiveProfiles anotaciones para ello. Escribí una publicación de blog sobre el tema.

Respondido 09 Feb 21, 10:02

Enlace de publicación de blog 404s - Dibujado

Lo siento, hubo un error en la numeración de enlaces, solucionado ahora - luboskrnac

Encontré una respuesta similar a la de teabot para crear una MockFactory que proporciona las simulaciones. Usé el siguiente ejemplo para crear la fábrica simulada (ya que el enlace a narkisr está muerto): 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>

Esto también ayuda a evitar que Spring quiera resolver las inyecciones del frijol simulado.

Respondido 29 Feb 12, 13:02

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

esto ^ funciona perfectamente bien si se declara primero / temprano en el archivo XML. Mockito 1.9.0 / Spring 3.0.5

Respondido el 23 de diciembre de 12 a las 16:12

Utilizo una combinación del enfoque utilizado en respuesta por Markus T y una implementación de ayuda simple de ImportBeanDefinitionRegistrar que busca una anotación personalizada@MockedBeans) en el que se puede especificar qué clases se van a burlar. Creo que este enfoque da como resultado una prueba unitaria concisa con parte del código repetitivo relacionado con la burla eliminado.

Así es como se ve una prueba unitaria de muestra con ese enfoque:

@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
        }
    }
}

Para que esto suceda, debe definir dos clases auxiliares simples: anotación personalizada (@MockedBeans) y una costumbre ImportBeanDefinitionRegistrar puesta en práctica. @MockedBeans la definición de la anotación debe anotarse con @Import(CustomImportBeanDefinitionRegistrar.class) y ImportBeanDefinitionRgistrar necesita agregar definiciones de frijoles simulados a la configuración en su registerBeanDefinitions método.

Si te gusta el enfoque, puedes encontrar una muestra. implementaciones en mi blogpost.

Respondido el 06 de junio de 15 a las 11:06

Desarrollé una solución basada en la propuesta de Kresimir Nesek. Agregué una nueva anotación @EnableMockedBean para hacer el código un poco más limpio y modular.

@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();
    }

}

He escrito una post explicándolo.

Respondido el 06 de junio de 15 a las 21:06

Sugeriría migrar su proyecto a Spring Boot 1.4. Después de eso, puede usar una nueva anotación @MockBean para fingir tu com.package.Dao

Respondido el 05 de Septiembre de 16 a las 14:09

Hoy me enteré de que un contexto de primavera donde declaré un antes de los frijoles Mockito, no se estaba cargando. Después de mover DESPUÉS de los simulacros, el contexto de la aplicación se cargó correctamente. Cuídate :)

Respondido 27 Abr '11, 20:04

Hay algo que falta. 8-) ¿Te mudaste después de las burlas? - Hans Peter Störr

Para que conste, todas mis pruebas funcionan correctamente simplemente haciendo que el dispositivo se inicialice de forma diferida, por ejemplo:

<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>

Supongo que la razón es la que explica Mattias. aquí (en la parte inferior de la publicación), que una solución alternativa es cambiar el orden en que se declaran los beans; la inicialización diferida es "una especie de" tener el accesorio declarado al final.

Respondido 05 Jul 13, 00:07

Si está usando Spring Boot 2.2+, puede usar @MockInBean como alternativa a @MockBean y mantenga limpio su contexto de Spring:

@SpringBootTest
public class MyServiceTest {

    @MockInBean(MyService.class)
    private ServiceToMock serviceToMock;

    @Autowired
    private MyService myService;

    @Test
    public void test() {
        Mockito.when(serviceToMock.returnSomething()).thenReturn(new Object());
        myService.doSomething();
    }
}

descargo de responsabilidad: creé esta biblioteca para evitar la recreación de Spring Context causada por @ MockBean / @ SpringBean que conduce a fases de prueba de compilación lentas (ver El uso de @MockBean en las pruebas fuerza la recarga del contexto de la aplicación or el problema con @MockBean)

respondido 17 mar '21, 23:03

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.