2

我正在使用Spring Boot1.4.0.RELEASE和spring-boot-starter-batchspring-boot-starter-aopspring-retry

我有一个@Service在运行时模拟的 Spring Integration 测试。我注意到，如果@Service该类在其方法上包含任何@Retryable注释，那么它似乎会干扰Mockito.verify()，我得到一个UnfinishedVerificationException. 我想这一定与此有关spring-aop？如果我注释掉所有@Retryable注释@Service然后验证再次正常工作。

我创建了一个github 项目来演示这个问题。

它失败sample.batch.MockBatchTestWithRetryVerificationFailures.batchTest()在validateMockitoUsage();

有类似的东西：

12:05:36.554 [main] DEBUG org.springframework.test.context.support.AbstractDirtiesContextTestExecutionListener - After test method: context [DefaultTestContext@5ec0a365 testClass = MockBatchTestWithRetryVerificationFailures, testInstance = sample.batch.MockBatchTestWithRetryVerificationFailures@5abca1e0, testMethod = batchTest@MockBatchTestWithRetryVerificationFailures, testException = org.mockito.exceptions.misusing.UnfinishedVerificationException: 
Missing method call for verify(mock) here:
-> at sample.batch.service.MyRetryService$$FastClassBySpringCGLIB$$7573ce2a.invoke(<generated>)

Example of correct verification:
    verify(mock).doSomething()

但是，我有另一个类 ( sample.batch.MockBatchTestWithNoRetryWorking.batchTest()) 带有一个@Service没有任何@Retryable注释的模拟类，并且验证工作正常。

我究竟做错了什么？

在我的 pom.xml 我有以下内容：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.0.RELEASE</version>
</parent>
...
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-batch</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.retry</groupId>
        <artifactId>spring-retry</artifactId>
    </dependency>
...

然后是所有相关的 Java 类

@SpringBootApplication
@EnableBatchProcessing
@Configuration
@EnableRetry
public class SampleBatchApplication {

    @Autowired
    private JobBuilderFactory jobs;

    @Autowired
    private StepBuilderFactory steps;

    @Autowired
    private MyRetryService myRetryService;

    @Autowired
    private MyServiceNoRetry myServiceNoRetry;

    @Bean
    protected Tasklet tasklet() {

        return new Tasklet() {
            @Override
            public RepeatStatus execute(StepContribution contribution,
                    ChunkContext context) {
                myServiceNoRetry.process();
                myRetryService.process();
                return RepeatStatus.FINISHED;
            }
        };

    }

    @Bean
    public Job job() throws Exception {
        return this.jobs.get("job").start(step1()).build();
    }

    @Bean
    protected Step step1() throws Exception {
        return this.steps.get("step1").tasklet(tasklet()).build();
    }


    public static void main(String[] args) throws Exception {
        // System.exit is common for Batch applications since the exit code can be used to
        // drive a workflow
        System.exit(SpringApplication
                .exit(SpringApplication.run(SampleBatchApplication.class, args)));
    }

    @Bean
    ResourcelessTransactionManager transactionManager() {
        return new ResourcelessTransactionManager();
    }

    @Bean
    public JobRepository getJobRepo() throws Exception {
        return new MapJobRepositoryFactoryBean(transactionManager()).getObject();
    }

}

@Service
public class MyRetryService {

    public static final Logger LOG = LoggerFactory.getLogger(MyRetryService.class);

    @Retryable(maxAttempts = 5, include = RuntimeException.class, backoff = @Backoff(delay = 100, multiplier = 2))
    public boolean process() {

        double random = Math.random();

        LOG.info("Running process, random value {}", random);

        if (random > 0.2d) {
            throw new RuntimeException("Random fail time!");
        }

        return true;
    }

}

@Service
public class MyServiceNoRetry {

    public static final Logger LOG = LoggerFactory.getLogger(MyServiceNoRetry.class);

    public boolean process() {

        LOG.info("Running process that doesn't do retry");

        return true;
    }

}

@ActiveProfiles("Test")
@ContextConfiguration(classes = {SampleBatchApplication.class, MockBatchTestWithNoRetryWorking.MockedRetryService.class}, loader = AnnotationConfigContextLoader.class)
@RunWith(SpringRunner.class)
public class MockBatchTestWithNoRetryWorking {

    @Autowired
    MyServiceNoRetry service;

    @Test
    public void batchTest() {
        service.process();

        verify(service).process();
        validateMockitoUsage();
    }

    public static class MockedRetryService {
        @Bean
        @Primary
        public MyServiceNoRetry myService() {
            return mock(MyServiceNoRetry.class);
        }
    }
}

@ActiveProfiles("Test")
@ContextConfiguration(classes = { SampleBatchApplication.class,
        MockBatchTestWithRetryVerificationFailures.MockedRetryService.class },
                      loader = AnnotationConfigContextLoader.class)
@RunWith(SpringRunner.class)
public class MockBatchTestWithRetryVerificationFailures {

    @Autowired
    MyRetryService service;

    @Test
    public void batchTest() {
        service.process();

        verify(service).process();
        validateMockitoUsage();
    }

    public static class MockedRetryService {
        @Bean
        @Primary
        public MyRetryService myRetryService() {
            return mock(MyRetryService.class);
        }
    }
}

编辑：根据我放在一起显示问题的示例项目更新了问题和代码。

4

2 回答 2

4

因此，在查看了类似的github 问题之后spring-boot

我发现有一个额外的代理妨碍了我。我通过手动解开 aop 类发现了一个讨厌的 hack，使验证工作，即：

@Test
public void batchTest() throws Exception {
    service.process();

    if (service instanceof Advised) {
        service = (MyRetryService) ((Advised) service).getTargetSource().getTarget();
    }

    verify(service).process();
    validateMockitoUsage();
}

希望这可以像上面的 github 问题一样得到解决。我会提出一个问题，看看我能走多远。

编辑：提出了github 问题

于 2016-09-07T03:25:42.563 回答
2

在我看到@Joel Pearsons的回答，尤其是链接的 GitHub 问题之后，我通过临时使用解包和验证的静态帮助器方法解决了这个问题：

public static <T> T unwrapAndVerify(T mock, VerificationMode mode) {
    return ((T) Mockito.verify(AopTestUtils.getTargetObject(mock), mode));
}

使用这种方法，测试用例的唯一区别是验证调用。除此之外没有其他开销：

unwrapAndVerify(service, times(2)).process();

代替

verify(service, times(2)).process();

实际上，甚至可以将辅助方法命名为实际的 Mockito 方法，这样您只需要替换导入即可，但我不喜欢随后的混乱。

@MockBean但是，如果使用而不是mock()创建模拟 bean，则不需要展开。Spring Boot 1.4 支持这个注解。

于 2016-11-07T10:50:50.277 回答