11

我有一个流口水规则文件，它在规则中使用服务类。所以一个规则做这样的事情：

eval(countryService.getCountryById(1) != null)

在使用 @service 和 @Transactional(propagation=Propagation.SUPPORTS) 注释的验证服务中，drools 文件用于无状态知识库中，并添加了应在 drool 中使用的事实。一旦完成，将调用 session.execute(facts) 并启动规则引擎。

为了测试规则，我想存根 countryService.getCountryById()。使用 mockito 没有什么大问题。为其他使用 drools 设置的服务完成此操作，并且效果很好。但是在这种特殊情况下， countryService 没有被存根，我不知道为什么。在花了很多时间检查我的代码之后，我发现在服务上方使用 @Transactional 或缺少此注释会有所不同。缺少@Transaction 使得mockito 可以毫无问题地模拟countryservice，而使用@transactional 会导致mockito 失败（没有任何错误或提示）注入模拟，因此使用了原始的countryservice 对象。

我的问题是为什么这个注释会导致这个问题。为什么在设置@Transactional 时不能模拟注入模拟？我注意到，当我调试和检查 countryService 时，mockito 失败了，当它作为全局添加到 drools 会话时，当我在调试窗口中检查 countryservice 时，我看到以下差异：

  • 使用@transactional：countryService 的值为 CountryService$$EnhancerByCGLIB$$b80dbb7b

  • 没有 @transactional:countryService 的值为 CountryService$$EnhancerByMockitoWithCGLIB$$27f34dc1

除了@transactional，我在countryservice方法getCountryById中找到了断点，调试器在该断点处停止，但没有@transactional，我的断点被跳过，因为mockito绕过它。

验证服务：

@Service
@Transactional(propagation=Propagation.SUPPORTS)
public class ValidationService 
{
  @Autowired
  private CountryService countryService;

  public void validateFields(Collection<Object> facts)
  {
    KnowledgeBase knowledgeBase = (KnowledgeBase)AppContext.getApplicationContext().getBean(knowledgeBaseName); 
    StatelessKnowledgeSession session = knowledgeBase.newStatelessKnowledgeSession();
    session.setGlobal("countryService", countryService);
    session.execute(facts);

  }

和测试类：

public class TestForeignAddressPostalCode extends BaseTestDomainIntegration
{

  private final Collection<Object> postalCodeMinLength0 = new ArrayList<Object>();

  @Mock
  protected CountryService countryService;

  @InjectMocks
  private ValidationService level2ValidationService;


  @BeforeMethod(alwaysRun=true)
  protected void setup()
  {
    // Get the object under test (here the determination engine)
    level2ValidationService = (ValidationService) getAppContext().getBean("validationService");
    // and replace the services as documented above.
    MockitoAnnotations.initMocks(this);

    ForeignAddress foreignAddress = new ForeignAddress();
    foreignAddress.setCountryCode("7029");
    foreignAddress.setForeignPostalCode("foreign");

    // mock country to be able to return a fixed id
    Country country = mock(Country.class);
    foreignAddress.setLand(country);
    doReturn(Integer.valueOf(1)).when(country).getId();

    doReturn(country).when(countryService).getCountryById(anyInt());

    ContextualAddressBean context = new ContextualAddressBean(foreignAddress, "", AddressContext.CORRESPONDENCE_ADDRESS);
    postalCodeMinLength0.add(context);
  }

  @Test
  public void PostalCodeMinLength0_ExpectError()
  {
    // Execute
    level2ValidationService.validateFields(postalCodeMinLength0, null);

  }

如果我想保留这个 @transactional 注释但也能够存根 countryservice 方法，知道该怎么做吗？

问候，

迈克尔

4

5 回答 5

10

请注意，从 Spring 4.3.1 开始，ReflectionTestUtils应该自动解包代理。所以

ReflectionTestUtils.setField(validationService, "countryService", countryService);

即使您使用, ...countryService注释，现在也应该可以工作（也就是说，在运行时隐藏在代理后面）@Transactional@Cacheable

相关问题：SPR-14050

于 2016-07-13T06:23:12.187 回答
9

发生的事情是您的 ValidationService 被包装在 JdkDynamicAopProxy 中，因此当 Mockito 将模拟注入服务时，它看不到任何将它们注入的字段。您需要做以下两件事之一：

  • 放弃启动您的 Spring 应用程序上下文并仅测试验证服务，迫使您模拟每个依赖项。
  • 或者从 JdkDynamicAopProxy 中解开您的实现，并自己处理注入模拟。

代码示例：

@Before
public void setup() throws Exception {
    MockitoAnnotations.initMocks(this);
    ValidationService validationService = (ValidationService) unwrapProxy(level2ValidationService);
    ReflectionTestUtils.setField(validationService, "countryService", countryService);
}

public static final Object unwrapProxy(Object bean) throws Exception {
    /*
     * If the given object is a proxy, set the return value as the object
     * being proxied, otherwise return the given object.
     */
    if (AopUtils.isAopProxy(bean) && bean instanceof Advised) {
        Advised advised = (Advised) bean;
        bean = advised.getTargetSource().getTarget();
    }
    return bean;
}

关于这个问题的博客条目

于 2013-07-09T12:53:31.250 回答
6

基于SuperSaiyen 的回答，我创建了一个插入式实用程序类以使其更简单且类型安全：

import org.mockito.Mockito;
import org.springframework.aop.framework.Advised;
import org.springframework.aop.support.AopUtils;
import org.springframework.test.util.ReflectionTestUtils;

@SuppressWarnings("unchecked")
public class SpringBeanMockUtil {
  /**
   * If the given object is a proxy, set the return value as the object being proxied, otherwise return the given
   * object.
   */
  private static <T> T unwrapProxy(T bean) {
    try {
      if (AopUtils.isAopProxy(bean) && bean instanceof Advised) {
        Advised advised = (Advised) bean;
        bean = (T) advised.getTargetSource().getTarget();
      }
      return bean;
    }
    catch (Exception e) {
      throw new RuntimeException("Could not unwrap proxy!", e);
    }
  }

  public static <T> T mockFieldOnBean(Object beanToInjectMock, Class<T> classToMock) {
    T mocked = Mockito.mock(classToMock);
    ReflectionTestUtils.setField(unwrapProxy(beanToInjectMock), null, mocked, classToMock);
    return mocked;
  }
}

用法很简单，只需在测试方法的开头，mockFieldOnBean(Object beanToInjectMock, Class<T> classToMock)使用要在其上注入模拟的 bean 以及应该模拟的对象的类来调用该方法。例子：

假设您有一个类型为 的 bean，SomeService其中包含 的自动装配 bean SomeOtherService，例如；

@Component
public class SomeService {
  @Autowired
  private SomeOtherService someOtherService;

  // some other stuff
}

要模拟bean，someOtherService请SomeService使用以下命令：

@RunWith(SpringJUnit4ClassRunner.class)
public class TestClass {

  @Autowired
  private SomeService someService;

  @Test
  public void sampleTest() throws Exception {
    SomeOtherService someOtherServiceMock = SpringBeanMockUtil.mockFieldOnBean(someService, SomeOtherService.class);

    doNothing().when(someOtherServiceMock).someMethod();

    // some test method(s)

    verify(someOtherServiceMock).someMethod();
  }
}

一切都应该正常工作。

于 2015-12-27T03:50:00.657 回答
2

另一种解决方案是在 Spring 将所有内容连接在一起之前将模拟对象添加到 Spring 上下文中，以便在测试开始之前它已经被注入。修改后的测试可能如下所示：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { Application.class, MockConfiguration.class })
public class TestForeignAddressPostalCode extends BaseTestDomainIntegration
{

  public static class MockConfiguration {

      @Bean
      @Primary
      public CountryService mockCountryService() {
        return mock(CountryService.class);
      }

  }

  @Autowired
  protected CountryService mockCountryService;

  @Autowired
  private ValidationService level2ValidationService;

  @BeforeMethod(alwaysRun=true)
  protected void setup()
  {

    // set up you mock stubs here
    // ...

@Primary注释很重要，确保您的新模拟 CountryService 具有注入的最高优先级，替换正常的。但是，如果将类注入多个位置，这可能会产生意想不到的副作用。

于 2015-04-22T20:32:39.447 回答
0

在 Spring Test 模块中存在一个名为AopTestUtils的 Spring 实用程序。

public static <T> T getUltimateTargetObject(Object candidate)

获取提供的候选对象的最终目标对象，不仅展开顶级代理，还展开任意数量的嵌套代理。如果提供的候选是 Spring 代理，则返回所有嵌套代理的最终目标；否则，候选人将按原样返回。

您可以在测试期间注入模拟或间谍并取消代理类以安排模拟或验证

于 2020-06-01T17:04:27.260 回答