调用SomeObject怎么样?或者使用Robotiums Solo.waitForCondition(…)方法，或者使用我写的一个类来做到这一点(如何使用，请参阅注释和测试类)

假设你有这样的代码:

public void method() {
        CompletableFuture.runAsync(() -> {
            //logic
            //logic
            //logic
            //logic
        });
    }

试着把它重构成这样:

public void refactoredMethod() {
    CompletableFuture.runAsync(this::subMethod);
}

private void subMethod() {
    //logic
    //logic
    //logic
    //logic
}

之后，用下面的方法测试subMethod:

org.powermock.reflect.Whitebox.invokeMethod(classInstance, "subMethod"); 

这不是一个完美的解决方案，但它测试了异步执行中的所有逻辑。

如果你想测试逻辑，不要异步测试。

例如，测试这段代码，它对异步方法的结果起作用。

public class Example {
    private Dependency dependency;

    public Example(Dependency dependency) {
        this.dependency = dependency;            
    }

    public CompletableFuture<String> someAsyncMethod(){
        return dependency.asyncMethod()
                .handle((r,ex) -> {
                    if(ex != null) {
                        return "got exception";
                    } else {
                        return r.toString();
                    }
                });
    }
}

public class Dependency {
    public CompletableFuture<Integer> asyncMethod() {
        // do some async stuff       
    }
}

在测试中模拟使用同步实现的依赖关系。单元测试是完全同步的，运行时间为150毫秒。

public class DependencyTest {
    private Example sut;
    private Dependency dependency;

    public void setup() {
        dependency = Mockito.mock(Dependency.class);;
        sut = new Example(dependency);
    }

    @Test public void success() throws InterruptedException, ExecutionException {
        when(dependency.asyncMethod()).thenReturn(CompletableFuture.completedFuture(5));

        // When
        CompletableFuture<String> result = sut.someAsyncMethod();

        // Then
        assertThat(result.isCompletedExceptionally(), is(equalTo(false)));
        String value = result.get();
        assertThat(value, is(equalTo("5")));
    }

    @Test public void failed() throws InterruptedException, ExecutionException {
        // Given
        CompletableFuture<Integer> c = new CompletableFuture<Integer>();
        c.completeExceptionally(new RuntimeException("failed"));
        when(dependency.asyncMethod()).thenReturn(c);

        // When
        CompletableFuture<String> result = sut.someAsyncMethod();

        // Then
        assertThat(result.isCompletedExceptionally(), is(equalTo(false)));
        String value = result.get();
        assertThat(value, is(equalTo("got exception")));
    }
}

你不测试异步行为，但你可以测试逻辑是否正确。

尽可能避免使用并行线程进行测试(大多数时候都是这样)。这只会使您的测试不可靠(有时通过，有时失败)。

只有当你需要调用其他库/系统时，你可能不得不等待其他线程，在这种情况下，总是使用await库而不是Thread.sleep()。

永远不要在测试中只调用get()或join()，否则您的测试可能会在CI服务器上一直运行，以防将来永远无法完成。在调用get()之前，始终在测试中首先断言isDone()。对于CompletionStage，就是. tocompletablefuture (). isdone()。

当你像这样测试一个非阻塞方法时:

public static CompletionStage<String> createGreeting(CompletableFuture<String> future) {
    return future.thenApply(result -> "Hello " + result);
}

那么你不应该仅仅通过在测试中传递一个完整的Future来测试结果，你还应该确保你的方法doSomething()不会通过调用join()或get()来阻塞。如果使用非阻塞框架，这一点尤其重要。

要做到这一点，测试一个未完成的未来，你手动设置为完成:

@Test
public void testDoSomething() throws Exception {
    CompletableFuture<String> innerFuture = new CompletableFuture<>();
    CompletableFuture<String> futureResult = createGreeting(innerFuture).toCompletableFuture();
    assertFalse(futureResult.isDone());

    // this triggers the future to complete
    innerFuture.complete("world");
    assertTrue(futureResult.isDone());

    // futher asserts about fooResult here
    assertEquals(futureResult.get(), "Hello world");
}

这样，如果您将future.join()添加到doSomething()，测试将失败。

如果你的服务使用ExecutorService，比如applyasync(…， executorService)，然后在你的测试中注入一个单线程的executorService，比如来自guava的:

ExecutorService executorService = Executors.newSingleThreadExecutor();

如果你的代码使用forkJoinPool，比如applyasync(…)，重写代码使用ExecutorService(有很多好的理由)，或者使用await。

为了缩短示例，我将BarService设置为测试中作为Java8 lambda实现的方法参数，通常它将是您将模拟的注入引用。

TL,博士;不幸的是，目前还没有内置的解决方案(在撰写本文时，2022年)，因此您可以自由使用和/或实现任何适合您的情况。

例子

另一种方法是使用CountDownLatch类。

public class DatabaseTest {

    /**
     * Data limit
     */
    private static final int DATA_LIMIT = 5;

    /**
     * Countdown latch
     */
    private CountDownLatch lock = new CountDownLatch(1);

    /**
     * Received data
     */
    private List<Data> receiveddata;

    @Test
    public void testDataRetrieval() throws Exception {
        Database db = new MockDatabaseImpl();
        db.getData(DATA_LIMIT, new DataCallback() {
            @Override
            public void onSuccess(List<Data> data) {
                receiveddata = data;
                lock.countDown();
            }
        });

        lock.await(2000, TimeUnit.MILLISECONDS);

        assertNotNull(receiveddata);
        assertEquals(DATA_LIMIT, receiveddata.size());
    }
}

注意:不能只使用与常规对象同步的对象作为锁，因为快速回调可以在锁的wait方法被调用之前释放锁。请参阅Joe Walnes的博客文章。

由于@jtahlborn和@Ring的评论，删除了CountDownLatch周围的同步块

恕我直言，让单元测试创建或等待线程是一种糟糕的实践。您希望这些测试在瞬间运行。这就是为什么我想提出一个测试异步进程的两步方法。

测试您的异步进程是否正确提交。您可以模拟接受异步请求的对象，并确保提交的作业具有正确的属性，等等。 测试你的异步回调是否在做正确的事情。在这里，您可以模拟最初提交的作业，并假设它已正确初始化，并验证您的回调是否正确。