Menyuntikkan Mockito mengolok-olok kacang Spring

Saya ingin menyuntikkan objek mockito mock ke dalam pegas (3+) kacang untuk keperluan pengujian unit dengan JUnit. Ketergantungan kacang saya saat ini disuntikkan dengan menggunakan @Autowiredanotasi pada bidang anggota pribadi.

Saya telah mempertimbangkan untuk menggunakan ReflectionTestUtils.setFieldtetapi contoh kacang yang ingin saya suntikkan sebenarnya adalah proxy dan karenanya tidak menyatakan bidang anggota pribadi dari kelas target. Saya tidak ingin membuat setter publik untuk dependensi karena saya kemudian akan memodifikasi antarmuka saya murni untuk keperluan pengujian.

Saya telah mengikuti beberapa saran yang diberikan oleh komunitas Spring tetapi mock tidak dibuat dan kabel otomatis gagal:

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

Kesalahan yang saya temui saat ini adalah sebagai berikut:

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

Jika saya menetapkan constructor-argnilai ke sesuatu yang tidak valid tidak ada kesalahan terjadi ketika memulai konteks aplikasi.

Cara terbaik adalah:

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

Pembaruan
Dalam file konteks mock ini harus didaftar sebelum bidang yang diotomasi otomatis tergantung pada yang dinyatakan.

@InjectMocks
private MyTestObject testObject;

@Mock
private MyDependentObject mockedObject;

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

Ini akan menyuntikkan benda yang diejek ke dalam kelas tes. Dalam hal ini akan menyuntikkan mockedObject ke dalam testObject. Ini disebutkan di atas tetapi di sini adalah kode.

Saya punya solusi yang sangat sederhana menggunakan Spring Java Config dan 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;
    }
}

Diberikan:

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

    // etc
}

Anda dapat memiliki kelas yang sedang diuji dimuat melalui autowiring, mengejek ketergantungan dengan Mockito, dan kemudian menggunakan Spring's ReflectionTestUtils untuk menyuntikkan mock ke dalam kelas yang diuji.

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

Harap dicatat bahwa sebelum Musim Semi 4.3.1, metode ini tidak akan berfungsi dengan layanan di belakang proxy (dijelaskan dengan @Transactional, atau Cacheable, misalnya). Ini telah diperbaiki oleh SPR-14050 .

Untuk versi sebelumnya, solusinya adalah membuka bungkusan proksi, seperti dijelaskan di sana: Anotasi transaksional menghindari layanan yang diejek (yang secara ReflectionTestUtils.setFielddefault sekarang)

Jika Anda menggunakan Spring Boot 1.4, ia memiliki cara yang luar biasa untuk melakukan ini. Cukup gunakan merek baru @SpringBootTestdi kelas Anda dan @MockBeandi lapangan dan Spring Boot akan membuat tiruan jenis ini dan itu akan menyuntikkannya ke dalam konteks (alih-alih menyuntikkan yang asli):

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

}

Di sisi lain, jika Anda tidak menggunakan Spring Boot atau Anda menggunakan versi sebelumnya, Anda harus melakukan lebih banyak pekerjaan:

Buat @Configurationkacang yang menyuntikkan tiruan Anda ke dalam konteks Spring:

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

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

Dengan menggunakan @Primaryanotasi, Anda memberi tahu pegas bahwa kacang ini memiliki prioritas jika tidak ada kualifikasi yang ditentukan.

Pastikan Anda membubuhi keterangan kelas @Profile("useMocks")untuk mengontrol kelas mana yang akan menggunakan tiruan dan yang mana yang akan menggunakan kacang asli.

Terakhir, dalam pengujian Anda, aktifkan 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() {
        ....
    }
}

Jika Anda tidak ingin menggunakan tiruan tetapi kacang asli, jangan aktifkan 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() {
        ....
    }
}

Sejak 1.8.3 Mockito memiliki @InjectMocks- ini sangat berguna. Tes JUnit saya @RunWithyang MockitoJUnitRunnerdan saya membangun @Mockobjek yang memenuhi semua dependensi untuk kelas yang diuji, yang semuanya disuntikkan ketika anggota swasta dijelaskan dengan @InjectMocks.

Aku @RunWithyang SpringJUnit4Runneruntuk tes integrasi hanya sekarang.

Saya akan perhatikan bahwa sepertinya tidak bisa menyuntikkan List<T>dengan cara yang sama seperti Spring. Itu terlihat hanya untuk objek Mock yang memenuhi List, dan tidak akan menyuntikkan daftar objek Mock. Solusinya bagi saya adalah dengan menggunakan @Spyterhadap daftar instantiated secara manual, dan secara manual. Tambahkan objek tiruan ke daftar itu untuk pengujian unit. Mungkin itu disengaja, karena itu pasti memaksa saya untuk memperhatikan dengan seksama apa yang sedang diejek bersama.

Pembaruan: Sekarang ada solusi yang lebih baik dan lebih bersih untuk masalah ini. Harap pertimbangkan jawaban lain terlebih dahulu.

Saya akhirnya menemukan jawaban untuk ini oleh ronen di blog-nya. Masalah yang saya alami adalah karena metode yang Mockito.mock(Class c)menyatakan tipe pengembalian Object. Akibatnya Spring tidak dapat menyimpulkan jenis kacang dari jenis pengembalian metode pabrik.

Solusi Ronen adalah membuat FactoryBeanimplementasi yang mengembalikan ejekan. The FactoryBeanantarmuka memungkinkan musim semi untuk query jenis objek yang dibuat oleh kacang pabrik.

Definisi kacang tiruan saya sekarang terlihat seperti:

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

Pada Spring 3.2, ini tidak lagi menjadi masalah. Spring sekarang mendukung Autowiring dari hasil metode pabrik generik. Lihat bagian berjudul "Metode Pabrik Generik" di posting blog ini: http://spring.io/blog/2012/11/07/spring-framework-3-2-rc1-new-testing-features/ .

Poin kuncinya adalah:

Di Spring 3.2, tipe pengembalian generik untuk metode pabrik sekarang disimpulkan dengan benar, dan autowiring menurut jenis untuk mengejek harus bekerja seperti yang diharapkan. Akibatnya, solusi khusus seperti MockitoFactoryBean, EasyMockFactoryBean, atau Springockito kemungkinan tidak lagi diperlukan.

Yang berarti ini harus bekerja di luar kotak:

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

Kode di bawah ini berfungsi dengan autowiring - ini bukan versi terpendek tetapi berguna ketika seharusnya hanya bekerja dengan standar spring / mockito guci.

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

Jika Anda menggunakan pegas> = 3.0 , coba gunakan @Configurationanotasi Pegas untuk menentukan bagian dari konteks aplikasi

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

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

}

Jika Anda tidak ingin menggunakan @ImportResource, itu dapat dilakukan dengan cara sebaliknya:

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

Untuk informasi lebih lanjut, lihat referensi pegas-kerangka kerja: konfigurasi wadah berbasis Java

Mungkin bukan solusi yang sempurna, tetapi saya cenderung tidak menggunakan pegas untuk melakukan DI untuk unit test. dependensi untuk satu kacang (kelas yang diuji) biasanya tidak terlalu rumit jadi saya hanya melakukan injeksi langsung dalam kode tes.

Saya dapat melakukan hal berikut menggunakan Mockito:

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

Posting beberapa contoh berdasarkan pendekatan di atas

Dengan Musim Semi:

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

Tanpa Musim Semi:

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

Perbarui - jawaban baru di sini: https://stackoverflow.com/a/19454282/411229 . Jawaban ini hanya berlaku untuk orang-orang di versi Spring sebelum 3.2.

Saya sudah mencari beberapa saat untuk solusi yang lebih pasti untuk ini. Posting blog ini sepertinya mencakup semua kebutuhan saya dan tidak bergantung pada pemesanan pernyataan kacang. Semua pujian untuk Mattias Severson. http://www.jayway.com/2011/11/30/spring-integration-tests-part-i-creating-mock-objects/

Pada dasarnya, laksanakan 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;
    }
}

Selanjutnya perbarui konfigurasi pegas Anda dengan yang berikut:

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

Melihat laju perkembangan Springockito dan sejumlah masalah terbuka , saya akan sedikit khawatir untuk memperkenalkannya ke tumpukan test suite saya saat ini. Fakta bahwa rilis terakhir dilakukan sebelum rilis Spring 4 memunculkan pertanyaan seperti "Apakah mungkin untuk dengan mudah mengintegrasikannya dengan Spring 4?". Saya tidak tahu, karena saya tidak mencobanya. Saya lebih suka pendekatan Spring murni jika saya perlu mengejek kacang Spring dalam tes integrasi.

Ada opsi untuk memalsukan kacang Spring dengan fitur Musim Semi biasa. Anda perlu menggunakan @Primary, @Profiledan @ActiveProfilesanotasi untuk itu. Saya menulis posting blog tentang topik tersebut.

Saya menemukan jawaban yang sama seperti teko teh untuk membuat MockFactory yang menyediakan tiruan. Saya menggunakan contoh berikut untuk membuat pabrik tiruan (karena tautan ke narkisr sudah mati): 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>

Ini juga membantu mencegah Spring ingin menyelesaikan suntikan dari kacang tiruan.

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

^ ini berfungsi dengan baik jika dideklarasikan pertama / awal dalam file XML. Mockito 1.9.0 / Spring 3.0.5

Saya menggunakan kombinasi dari pendekatan yang digunakan dalam jawaban oleh Markus T dan implementasi pembantu sederhana ImportBeanDefinitionRegistraryang mencari penjelasan kustom ( @MockedBeans) di mana orang dapat menentukan kelas mana yang harus diejek. Saya percaya bahwa pendekatan ini menghasilkan unit test singkat dengan beberapa kode boilerplate terkait dengan ejekan dihapus.

Begini penampilan unit sampel dengan pendekatan itu:

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

Untuk mewujudkannya, Anda perlu mendefinisikan dua kelas pembantu sederhana - anotasi khusus ( @MockedBeans) dan ImportBeanDefinitionRegistrarimplementasi kustom . @MockedBeansdefinisi anotasi perlu dijelaskan dengan @Import(CustomImportBeanDefinitionRegistrar.class)dan ImportBeanDefinitionRgistrarkebutuhan untuk menambahkan definisi kacang tiruan untuk konfigurasi dalam registerBeanDefinitionsmetode itu.

Jika Anda menyukai pendekatan ini, Anda dapat menemukan contoh implementasi di blogpost saya .

Saya mengembangkan solusi berdasarkan proposal Kresimir Nesek. Saya menambahkan penjelasan baru @EnableMockedBean untuk membuat kode sedikit lebih bersih dan 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();
    }

}

Saya telah menulis posting yang menjelaskannya.

Saya akan menyarankan untuk memigrasi proyek Anda ke Spring Boot 1.4. Setelah itu Anda dapat menggunakan anotasi baru @MockBeanuntuk memalsukancom.package.Dao

Hari ini saya menemukan bahwa konteks musim semi di mana saya menyatakan sebelum kacang Mockito, gagal dimuat. Setelah menggerakkan SETELAH pengetikan, konteks aplikasi berhasil dimuat. Hati hati :)

Sebagai catatan, semua tes saya berfungsi dengan benar dengan hanya membuat fixture malas diinisialisasi, misalnya:

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

Saya kira alasannya adalah yang dijelaskan oleh Mattias di sini (di bagian bawah pos), bahwa solusinya adalah mengubah urutan biji dinyatakan - inisialisasi malas adalah "semacam" memiliki fixture yang diumumkan pada akhirnya.

Jika Anda menggunakan Injeksi Pengendali, pastikan variabel lokal Anda TIDAK "final"