如何为使用 Supplier 构建的重试机制编写 JUnit5 或 Mockito 测试<completablefuture>作为方法参数？ </completablefuture>

Question

有一个不是特定于服务器的通用框架，我们用它来导入和重用我们微服务中的对象，但可以用于支持 Java 的任何特定 Java 程序 8.

负责创建一个retry()机制，该机制将采用以下两个参数：

Supplier<CompletableFuture<R>> supplier
int numRetries

我需要它做的是制作一个通用组件，每次根据指定的numRetries出现异常时，该组件都会对CompletableFuture进行重试操作。

使用 Java 8，我编写了以下通用帮助程序 class，它使用供应商根据指定的重试次数重试方法。

一般来说，我是CompletableFuture的新手，所以我想知道如何为此方法编写 JUnit 5（如果 Mockito 更好）测试？ 我正在测试所有边缘情况，并已使其尽可能通用，以供其他人重复使用。

请注意，这是在一个内部通用框架内，该框架由其他微服务作为 Maven 依赖项导入，但目的是能够在 Java SE 级别重用它。

public class RetryUtility {

    private static final Logger log = 
                    LoggerFactory.getLogger(RetryUtility.class);

    public static <R> CompletableFuture<R> retry(
                                       Supplier<CompletableFuture<R>> supplier, 
                                       int numRetries) {
        CompletableFuture<R> completableFuture = supplier.get();
        if (numRetries > 0) {
            for (int i = 0; i < numRetries; i++) {
                completableFuture = 
                            completableFuture
                              .thenApply(CompletableFuture::completedFuture)
                              .exceptionally(
                                  t -> {
                                   log.info("Retrying for {}", t.getMessage());
                                   return supplier.get();
                                })
                              .thenCompose(Function.identity());
            }
        }
        return completableFuture;
    }
}

用法：假设这段代码可以编译和工作，我能够在client和 log.info 的配置文件中输入错误的log.info(Error getting orderResponse = {}); 通过grep针对app.log文件打印了两次。

这是将上述 class 导入为 Maven 依赖项的调用 class：

public class OrderServiceFuture {

    private CompletableFuture<OrderReponse> getOrderResponse(
                           OrderInput orderInput,BearerToken token) {
        int numRetries = 1;
        CompletableFuture<OrderReponse> orderResponse =
               RetryUtility.retry(() -> makeOrder(orderInput, token), numRetries);
        orderResponse.join();
        return orderResponse;
    }

    public CompletableFuture<OrderReponse> makeOrder() {
        return client.post(orderInput, token),
            orderReponse -> {
            log.info("Got orderReponse = {}", orderReponse);
        },
        throwable -> {
            log.error("Error getting orderResponse = {}", throwable.getMessage());
        }
    }
}

尽管此示例的调用 class 使用OrderSerice和HttpClient进行调用，但这是一个通用实用程序 class，它专门编写为可重复用于返回CompletableFuture<OrderReponse>的任何类型的方法调用。

问题）：

如何为此编写一个 JUnit 5 测试用例（或 Mockito）： public static <R> CompletableFuture<R> RetryUtility.retry(Supplier<CompletableFuture<R>> supplier, int numRetries)方法？
有人可以在其设计和/或实施中看到任何边缘情况或细微差别吗？

Answer 1

在您问“我如何测试方法 X？”之前它有助于澄清“X 实际上做了什么？”。 为了回答后一个问题，我个人喜欢以一种使各个步骤变得更加清晰的方式重写方法。

为您的retry方法这样做，我得到：

public static <R> CompletableFuture<R> retry(
        Supplier<CompletableFuture<R>> supplier,
        int numRetries
) {
    CompletableFuture<R> completableFuture = supplier.get();
    for (int i = 0; i < numRetries; i++) {
        Function<R, CompletableFuture<R>> function1 = CompletableFuture::completedFuture;
        CompletableFuture<CompletableFuture<R>> tmp1 = completableFuture.thenApply(function1);
        
        Function<Throwable, CompletableFuture<R>> function2 = t -> supplier.get();
        CompletableFuture<CompletableFuture<R>> tmp2 = tmp1.exceptionally(function2);
        
        Function<CompletableFuture<R>, CompletableFuture<R>> function3 = Function.identity();
        completableFuture = tmp2.thenCompose(function3);
    }
    return completableFuture;
}

请注意，我删除了不必要的if语句以及log.info调用。 后者不可测试，除非您将记录器实例作为方法参数传递（或者使retry成为非静态的，并将记录器作为通过构造函数传递的实例变量，或者可能使用一些肮脏的技巧，例如重定向记录器 output溪流）。

现在， retry实际上做了什么？

它调用supplier.get()一次并将值分配给completableFuture变量。
如果numRetries <= 0 ，则它返回completableFuture ，它与供应商的get方法返回的 CF 实例相同。
如果numRetries > 0 ，则它执行以下步骤numRetries次：
1. 它创建一个返回完整 CF 的 function function1 1。
2. 它将function1传递给completableFuture的thenApply方法，创建一个新的 CF tmp1 。
3. 它创建另一个 function function2 2，它是一个 function 忽略其输入参数但调用supplier.get() 。
4. 它将function2传递给tmp1的exceptionally方法，创建一个新的 CF tmp2 。
5. 它创建了第三个 function function3 3，即标识 function。
6. 它将function3传递给tmp2的thenCompose ，创建一个新的 CF 并将其分配给completableFuture变量。

清楚地分解 function 的作用可以让您了解可以测试的内容和无法测试的内容，因此可能需要重构。 步骤 1. 和 2. 非常容易测试：

对于第 1 步，您模拟一个Supplier并测试它的get方法是否被调用：

@Test
void testStep1() { // please use more descriptive names...
    Supplier<CompletableFuture<Object>> mock = Mockito.mock(Supplier.class);
    RetryUtility.retry(mock, 0);
    Mockito.verify(mock).get();
    Mockito.verifyNoMoreInteractions(mock);
}

对于第 2 步，您让供应商返回一些预定义的实例并检查retry是否返回相同的实例：

@Test
void testStep2() {
    CompletableFuture<Object> instance = CompletableFuture.completedFuture("");
    Supplier<CompletableFuture<Object>> supplier = () -> instance;
    CompletableFuture<Object> result = RetryUtility.retry(supplier, 0);
    Assertions.assertSame(instance, result);
}

棘手的部分当然是第 3 步。您应该注意的第一件事是哪些变量受我们的输入 arguments 影响。它们是： completableFuture 、 tmp1 、 function2和tmp2 。 相反， function1和function3实际上是常量，不受我们输入 arguments 的影响。

那么，我们如何影响上市的arguments呢？ 好吧， completableFuture是我们Supplier的get方法的返回值。 如果我们让get返回一个模拟，我们可以影响thenApply的返回值。 同样，如果我们让thenApply返回一个 mock，我们可以影响expectionally的返回值。 我们可以将相同的逻辑应用于thenCompose ，然后测试我们的方法是否以正确的顺序被调用了正确的次数：

@ParameterizedTest
@ValueSource(ints = {0, 1, 2, 3, 5, 10, 100})
void testStep3(int numRetries) {
    CompletableFuture<Object> completableFuture = mock(CompletableFuture.class);
    CompletableFuture<CompletableFuture<Object>> tmp1 = mock(CompletableFuture.class);
    CompletableFuture<CompletableFuture<Object>> tmp2 = mock(CompletableFuture.class);

    doReturn(tmp1).when(completableFuture).thenApply(any(Function.class));
    doReturn(tmp2).when(tmp1).exceptionally(any(Function.class));
    doReturn(completableFuture).when(tmp2).thenCompose(any(Function.class));

    CompletableFuture<Object> retry = RetryUtility.retry(
            () -> completableFuture, // here 'get' returns our mock
            numRetries
    );
    // While we're at it we also test that we get back our initial CF
    Assertions.assertSame(completableFuture, retry);

    InOrder inOrder = Mockito.inOrder(completableFuture, tmp1, tmp2);
    for (int i = 0; i < numRetries; i++) {
        inOrder.verify(completableFuture, times(1)).thenApply(any(Function.class));
        inOrder.verify(tmp1, times(1)).exceptionally(any(Function.class));
        inOrder.verify(tmp2, times(1)).thenCompose(any(Function.class));
    }
    inOrder.verifyNoMoreInteractions();
}

那么thenApply和thenCompose的方法 arguments 呢？ 无法测试这些方法是否已分别用function1和function3调用（除非您重构代码并将函数移出该方法调用），因为这些函数是我们方法的本地函数，不受我们的 arguments 的影响。但是function2呢？ 虽然我们无法测试以function2作为参数exceptionally调用，但我们可以测试function2调用supplier.get()恰好numRetries次。 它什么时候这样做？ 好吧，只有当 CF 失败时：

@ParameterizedTest
@ValueSource(ints = {0, 1, 2, 3, 5, 10, 100})
void testStep3_4(int numRetries) {
    CompletableFuture<Object> future = CompletableFuture.failedFuture(new RuntimeException());
    Supplier<CompletableFuture<Object>> supplier = mock(Supplier.class);
    doReturn(future).when(supplier).get();

    Assertions.assertThrows(
            CompletionException.class,
            () -> RetryUtility.retry(supplier, numRetries).join()
    );
    
    // remember: supplier.get() is also called once at the beginning 
    Mockito.verify(supplier, times(numRetries + 1)).get();
    Mockito.verifyNoMoreInteractions(supplier);
}

同样，您可以通过提供供应商来测试retry调用get方法n+1次，该供应商在调用n次后返回一个完整的未来。

我们仍然需要做的（以及我们可能应该做的第一步）是测试我们方法的返回值是否正确运行：

如果 CF 尝试numRetries失败，则 CF 应该异常完成。
如果 CF 失败次数少于numRetries尝试次数，则 CF 应该正常完成。

@ParameterizedTest
@ValueSource(ints = {0, 1, 2, 3, 5, 10})
void testFailingCf(int numRetries) {
    RuntimeException exception = new RuntimeException("");
    CompletableFuture<Object> future = CompletableFuture.failedFuture(exception);

    CompletionException completionException = Assertions.assertThrows(
            CompletionException.class,
            () -> RetryUtility.retry(() -> future, numRetries).join()
    );
    Assertions.assertSame(exception, completionException.getCause());
}

@ParameterizedTest
@ValueSource(ints = {0, 1, 2, 3, 5, 10})
void testSucceedingCf(int numRetries) {
    final AtomicInteger counter = new AtomicInteger();
    final String expected = "expected";

    Supplier<CompletableFuture<Object>> supplier =
            () -> (counter.getAndIncrement() < numRetries / 2)
                    ? CompletableFuture.failedFuture(new RuntimeException())
                    : CompletableFuture.completedFuture(expected);

    Object result = RetryUtility.retry(supplier, numRetries).join();

    Assertions.assertEquals(expected, result);
    Assertions.assertEquals(numRetries / 2 + 1, counter.get());
}

您可能要考虑测试和捕获的其他一些情况是，如果numRetries为负数或非常大，会发生什么情况？ 这样的方法调用应该抛出异常吗？

到目前为止我们还没有触及的另一个问题是：这是测试代码的正确方法吗？

有些人可能会说是，其他人会争辩说你不应该测试你的方法的内部结构，而应该只测试它的 output 给定一些输入（即基本上只有最后两个测试）。 这显然值得商bat，并且像大多数事情一样，取决于您的要求。 （例如，你会测试一些排序算法的内部结构，比如数组赋值等等吗？）。

如您所见，通过测试内部结构，测试变得相当复杂，涉及很多 mocking。测试内部结构也会使重构更加麻烦，因为您的测试可能会开始失败，即使您没有更改你的方法的逻辑。 就个人而言，在大多数情况下我不会编写这样的测试。 但是，如果很多人都依赖于我的代码的正确性，例如步骤执行的顺序，我可能会考虑。

不管怎样，如果你选择go那条路由，希望这些例子对你有用。

如何为使用 Supplier 构建的重试机制编写 JUnit5 或 Mockito 测试<completablefuture>作为方法参数？ </completablefuture>

问题描述

1 个解决方案

解决方案1
1 2023-01-15 02:29:22

如何为使用 Supplier 构建的重试机制编写 JUnit5 或 Mockito 测试<completablefuture>作为方法参数？ </completablefuture>

问题描述

1 个解决方案

解决方案1 1 2023-01-15 02:29:22

解决方案1
1 2023-01-15 02:29:22