如何在 @Configuration/@Bean 使用的单元测试中禁用 Spring 自动装配

Question

我想使用 spring-test 配置内部类 (@Configuration) 配置组件测试。测试的组件有一些我想为测试模拟的服务。这些服务是类（不使用接口），并在其中包含 spring 注释 (@Autowired)。 Mockito 可以轻松地模拟它们，但是，我发现无法禁用弹簧自动装配。

我如何轻松复制的示例：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SomeTest.Beans.class)
public class SomeTest {

    // configured in component-config.xml, using ThirdPartyService
    @Autowired
    private TestedBean entryPoint;

    @Test
    public void test() {
    }

    @Configuration
    @ImportResource("/spring/component-config.xml")
    static class Beans {
        @Bean
        ThirdPartyService createThirdPartyService() {
            return mock(ThirdPartyService.class);
        }
    }
}

public class ThirdPartyService {
    @Autowired
    Foo bar;
}

public class TestedBean {
    @Autowired
    private ThirdPartyService service;
}

在本例中，“TestBean”代表要模拟的服务。我不希望在春天注入“酒吧”！ @Bean(autowire = NO) 没有帮助（事实上，这是默认值）。 （请把我从“使用接口！”cmets 中拯救出来——模拟的服务可以是我无法做任何事情的第 3 方。）

更新

Springockito 部分解决了这个问题，只要您不需要配置其他任何东西（因此您不能将配置类与 Springockito 一起使用 - 它不支持它），但只能使用模拟。 还在寻找纯弹簧解决方案，如果有的话……

Answer 1

这是我对您的问题的解决方案：

import static org.mockito.Mockito.mockingDetails;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MockitoSkipAutowireConfiguration {

@Bean MockBeanFactory mockBeanFactory() {
    return new MockBeanFactory();
}

private static class MockBeanFactory extends InstantiationAwareBeanPostProcessorAdapter {
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return !mockingDetails(bean).isMock();
    }
}

} 

然后只是

@Import(MockitoSkipAutowireConfiguration.class)

在你的测试中@Configuration 并且你已经准备好了

Answer 2

我通过为我的 bean 创建 FactoryBean 而不仅仅是模拟 bean 来解决它。这样 Spring 就不会尝试自动装配字段。

工厂 bean 帮助类：

public class MockitoFactoryBean<T> implements FactoryBean<T> {
    private final Class<T> clazz;

    public MockitoFactoryBean(Class<T> clazz) {
        this.clazz = clazz;
    }

    @Override public T getObject() throws Exception {
        return mock(clazz);
    }

    @Override public Class<T> getObjectType() {
        return clazz;
    }

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

实际测试上下文部分：

@Configuration
public class TestContext {

    @Bean
    public FactoryBean<MockingService> mockingService() {
        return new MockitoFactoryBean<>(MockingService.class);
    }
}

Answer 3

检查Spring profiles。您不需要禁用自动连接，您需要为不同的配置注入不同的 bean。

Answer 4

您可以通过 org.springframework.beans.factory.config.SingletonBeanRegistry#registerSingleton 手动将模拟服务添加到 Spring 应用程序上下文。这样，spring 不会对 mock 进行后处理，并且 spring 不会尝试自动装配 mock。模拟本身将被注入到您测试的 bean 中。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SomeTest.Beans.class)
public class SomeTest {

    // configured in component-config.xml, using ThirdPartyService
    @Autowired
    private TestedBean entryPoint;

    @Autowired
    private ThirdPartyService thirdPartyServiceMock;

    @Test
    public void test() {
    }

    @Configuration
    static class Beans {

        @Autowired
        private GenericApplicationContext ctx;

        @Bean
        TestedBean testedBean() {
            ctx.getBeanFactory().registerSingleton("thirdPartyService", mock(ThirdPartyService.class));
            return new TestedBean();
        }
    }

    public static class ThirdPartyService {
        @Autowired
        Object bar;
    }

    public static class TestedBean {
        @Autowired
        private ThirdPartyService service;

    }
}

Answer 5

我的情况完全一样。

我发现如果你没有在你的测试类上通过@ContextConfiguration注解设置上下文加载器，就会使用默认的上下文加载器，它派生自AbstractGenericContextLoader。我查看了它的源代码，结果发现它注册了所有负责读取 @Autowired 等注释的 bean 后处理器。换句话说，默认情况下启用注释配置。

所以主要问题是有两个配置冲突：在 java 配置中我们说不需要自动装配，而自动装配注解则相反。真正的问题是如何禁用注释处理以消除不需要的配置。

据我所知，没有这样的 ContextLoader spring 实现不会从 AbstractGenericContextLoader 派生，所以我想我们唯一能做的就是编写我们自己的。应该是这样的：

public static class SimpleContextLoader implements ContextLoader {

    @Override
    public String[] processLocations(Class<?> type, String... locations) {
        return strings;
    }

    @Override
    public ApplicationContext loadContext(String... locations) throws Exception {
        // in case of xml configuration
        return new ClassPathXmlApplicationContext(strings);
        // in case of java configuration (but its name is quite misleading)
        // return new AnnotationConfigApplicationContext(TestConfig.class);
    }

}

当然值得花更多时间了解如何正确实现 ContextLoader。

干杯，
罗伯特

Answer 6

有很多方法可以做到这一点，我很确定这个答案是不完整的，但这里有一些选择......

目前似乎是推荐的做法，为您的服务使用构造函数注入，而不是直接自动装配字段。这使得像这样 so 的测试变得更加容易。

public class SomeTest {

    @Mock
    private ThirdPartyService mockedBean;

    @Before
    public void init() {
        initMocks(this);
    }

    @Test
    public void test() {
        BeanUnderTest bean = new BeanUnderTest(mockedBean);
        // ...
    }

}

public class BeanUnderTest{
    private ThirdPartyService service;
    @Autowired
    public BeanUnderTest(ThirdPartyService ThirdPartyService) {
        this.thirdPartyService = thirdPartyService;
    }
}

通过这样做，您还可以通过自动装配到测试本身来混合自动装配和模拟服务，然后使用最有用的自动装配和模拟 bean 组合构建被测 bean。

一个合理的替代方法是使用 Spring 配置文件来定义存根服务。当希望在多个测试中使用相同的存根功能时，这特别有用：

@Service
@Primary
@Profile("test")
public class MyServiceStub implements MyService {
    // ...
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SomeTest.Beans.class) 
@ActiveProfiles({"test"})
public class SomeTest {
    // ...
}

通过使用@Primary 注释，它确保将使用这个存根bean，而不是任何其他实现MyService 接口的bean。我倾向于将这种方法用于电子邮件服务之类的事情，通过更改配置文件，我可以在真正的邮件服务器和 Wiser 之间切换。