MockitoモックをSpring Beanに注入する

JUnitでのユニットテストの目的で、MockitoモックオブジェクトをSpring（3+）Beanに挿入したいと思います。現在、私のBeanの依存関係は@Autowired、プライベートメンバーフィールドのアノテーションを使用して注入されています。

使用を検討しましたReflectionTestUtils.setFieldが、注入したいBeanインスタンスは実際にはプロキシであるため、ターゲットクラスのプライベートメンバーフィールドを宣言していません。テストのためだけにインターフェイスを変更するため、依存関係へのパブリックセッターを作成したくありません。

私はSpringコミュニティからのアドバイスに従いましたが、モックが作成されず、自動配線が失敗します。

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

現在発生しているエラーは次のとおりです。

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

constructor-arg値を無効な値に設定しても、アプリケーションコンテキストの起動時にエラーは発生しません。

最善の方法は：

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

更新
コンテキストファイルでは、このモックは、それに依存する自動配線フィールドが宣言される前にリストされなければなりません。

@InjectMocks
private MyTestObject testObject;

@Mock
private MyDependentObject mockedObject;

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

これにより、モックされたオブジェクトがテストクラスに挿入されます。この場合、mockedObjectをtestObjectに挿入します。これは上で述べましたが、ここにコードがあります。

Spring Java Configと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;
    }
}

与えられた：

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

    // etc
}

自動配線を介してテスト対象のクラスをロードし、Mockitoで依存関係を模擬し、SpringのReflectionTestUtilsを使用してモックをテスト対象のクラスに挿入できます。

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

Spring 4.3.1より前のバージョンでは、このメソッドはプロキシの背後にあるサービスでは機能しないことに注意してください（たとえば@Transactional、またはCacheableで注釈が付けられます）。これはSPR-14050で修正されています。

そこに説明するように、以前のバージョンでは、解決策は、プロキシをアンラップすることです：トランザクション注釈ことを回避するサービスは嘲笑されている（何であるReflectionTestUtils.setFieldデフォルトで行います）

Spring Boot 1.4を使用している場合、これにはすばらしい方法があります。@SpringBootTestクラスと@MockBeanフィールドで新しいブランドを使用するだけで、Spring Bootがこのタイプのモックを作成し、それをコンテキストに挿入します（元のインジェクトではなく）。

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

}

一方、Spring Bootを使用していない場合、または以前のバージョンを使用している場合は、もう少し作業を行う必要があります。

@ConfigurationモックをSpringコンテキストに注入するBeanを作成します。

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

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

@Primaryアノテーションを使用して、修飾子が指定されていない場合、このBeanが優先されることをSpringに伝えます。

@Profile("useMocks")どのクラスがモックを使用し、どのクラスが実際のBeanを使用するかを制御するために、クラスに注釈を付けてください。

最後に、テストでuserMocksプロファイルをアクティブ化します。

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

モックではなく実際のBeanを使用したくない場合は、useMocksプロファイルをアクティブにしないでください。

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

1.8.3以降、Mockitoには@InjectMocks-非常に便利な機能があります。私のJUnitテストはで@RunWithありMockitoJUnitRunner、私@Mockがテストするクラスのすべての依存関係を満たすオブジェクトを構築します。これらはすべて、プライベートメンバーにで注釈が付けられたときに挿入され@InjectMocksます。

私だけ今統合テストのため。@RunWithSpringJUnit4Runner

List<T>春と同じように注入することはできないようです。これはList、を満たすMockオブジェクトのみを検索し、Mockオブジェクトのリストを挿入しません。私の回避策は@Spy、手動でインスタンス化されたリストに対してを使用し、ユニットテスト用にそのリストに手動でモックオブジェクトを追加することでした。たぶんそれは意図的なものだったのかもしれません。それは確かに、いじられているものに細心の注意を払わざるを得なかったからです。

更新：この問題の解決策が改善されました。最初に他の回答を検討してください。

私は最終的に彼のブログでローネンによってこれに対する答えを見つけました。私が抱えていた問題はMockito.mock(Class c)、戻り値の型を宣言するメソッドが原因ですObject。その結果、Springはファクトリメソッドの戻り値の型からBeanの型を推測できません。

Ronenのソリューションは、FactoryBeanモックを返す実装を作成することです。このFactoryBeanインターフェースにより、SpringはファクトリーBeanによって作成されたオブジェクトのタイプを照会できます。

私のモックビーンの定義は次のようになります。

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

Spring 3.2以降、これは問題ではなくなりました。Springは、ジェネリックファクトリメソッドの結果の自動配線をサポートするようになりました。このブログ投稿の「Generic Factory Methods」というタイトルのセクションを参照してください：http : //spring.io/blog/2012/11/07/spring-framework-3-2-rc1-new-testing-features/。

重要な点は次のとおりです。

Spring 3.2では、ファクトリメソッドの一般的な戻り値の型が正しく推論されるようになり、モックの型による自動配線は期待どおりに機能するはずです。その結果、MockitoFactoryBean、EasyMockFactoryBean、Springockitoなどのカスタムの回避策はおそらく不要になります。

つまり、これはそのまま使用できます。

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

以下のコードは自動配線で機能します。これは最短バージョンではありませんが、標準のSpring / mockito jarでのみ機能する場合に役立ちます。

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

Spring > = 3.0を使用している場合は、Springs @Configurationアノテーションを使用してアプリケーションコンテキストの一部を定義してみてください

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

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

}

@ImportResourceを使用したくない場合は、他の方法でも行うことができます。

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

詳細については、spring-framework-reference：Javaベースのコンテナー構成をご覧ください。

おそらく完璧な解決策ではないかもしれませんが、私は単体テストのDIを行うために春を使用しない傾向があります。単一のBean（テスト中のクラス）の依存関係は通常、それほど複雑ではないので、テストコードで直接インジェクションを行います。

Mockitoを使用して次のことができます。

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

上記のアプローチに基づいていくつかの例を投稿する

春で：

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

春なし：

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

更新 -ここでの新しい答え：https : //stackoverflow.com/a/19454282/411229。この回答は、3.2より前のSpringバージョンの回答にのみ適用されます。

これに対するより確実な解決策を探していました。このブログ投稿は私のすべてのニーズをカバーしているようで、Bean宣言の順序に依存していません。Mattias Severson氏の功績です。 http://www.jayway.com/2011/11/30/spring-integration-tests-part-i-creating-mock-objects/

基本的には、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;
    }
}

次に、次のようにSpring構成を更新します。

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

見てみると、開発のSpringockitoペースと未解決の問題の数、私は、今日私のテストスイートスタックにそれを導入するために少し心配されるだろう。前回のリリースがSpring 4のリリース前に行われたという事実から、「Spring 4と簡単に統合することは可能ですか？」という質問が出てきます。やってみなかったのでわかりません。統合テストでSpring Beanをモックする必要がある場合は、純粋なSpringアプローチを好みます。

プレーンなSpring機能だけを備えたSpring Beanを偽造するオプションがあります。あなたは使用する必要があり@Primary、@Profileそして@ActiveProfilesそれのための注釈。このトピックに関するブログ投稿を書きました。

モックを提供するMockFactoryを作成するために、ティーボットと同様の答えを見つけました。次の例を使用して、モックファクトリを作成しました（narkisrへのリンクが無効になっているため）：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>

これは、SpringがモックBeanからのインジェクションを解決しようとするのを防ぐのにも役立ちます。

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

この^は、XMLファイルで最初/早期に宣言された場合に完全に機能します。Mockito 1.9.0 / Spring 3.0.5

私は、Markus Tの回答で使用されているアプローチと、モックするクラスを指定できるImportBeanDefinitionRegistrarカスタムアノテーション（@MockedBeans）を探すシンプルなヘルパー実装の組み合わせを使用しています。このアプローチでは、モッキングに関連するボイラープレートコードの一部が削除された簡潔な単体テストが得られると思います。

そのアプローチでのサンプル単体テストの様子を次に示します。

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

これを実現するには、カスタムアノテーション（@MockedBeans）とカスタム ImportBeanDefinitionRegistrar実装の2つの単純なヘルパークラスを定義する必要があります。@MockedBeansアノテーション定義にはアノテーションを付ける必要が@Import(CustomImportBeanDefinitionRegistrar.class)あり、メソッドのImportBeanDefinitionRgistrar構成にモックBean定義を追加する必要がありますregisterBeanDefinitions。

このアプローチが気に入った場合は、ブログ記事でサンプル実装を見つけることができます。

Kresimir Nesekの提案に基づいてソリューションを開発しました。コードを少しすっきりさせてモジュール化するために、新しいアノテーション@EnableMockedBeanを追加しました。

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

}

それを説明する記事を書きました。

プロジェクトをSpring Boot 1.4に移行することをお勧めします。その後、新しいアノテーション@MockBeanを使用して偽のcom.package.Dao

今日、Mockito Beanの前に宣言した春のコンテキストがロードに失敗していることがわかりました。モックの後を移動した後、アプリコンテキストは正常に読み込まれました。気を付けて ：）

参考までに、フィクスチャを遅延初期化するだけで、すべてのテストが正しく機能します。例：

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

理由は、Mattiasがここ（投稿の下部）で説明しているものだと思います。回避策は、Beanが宣言される順序を変更することです。遅延初期化は、フィクスチャが最後に宣言される "一種の"ものです。

コントローラインジェクションを使用する場合は、ローカル変数が「最終」でないことを確認してください