java - BeforeAll 方法中没有为参数注册 ParameterResolver

Question

我正在尝试通过测试将我的项目从使用 JUnit 4 升级到 JUnit5。升级后:
@RunWith(VertxUnitRunner.class) --> @ExtendWith(VertxExtension.class)
@BeforeClass --> @BeforeAll 等
我的一个类在setUp方法中开始崩溃。

看起来与此类似:No ParameterResolver registered for parameter [io.vertx.ext.unit.TestContext arg0]
多次阅读该文档，但我无法理解“您没有用顶点信息“包装”文本”是什么意思。尝试传递 VertxTestContext 而不是 TestContext，但没有异步方法。
我将感谢您对问题的帮助

这是我的类(class):

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yottaa.common.ta.alerts.AlertDefinitionsDao;
import com.yottaa.common.ta.alerts.model.AlertDefinition;
import com.yottaa.common.alerts.model.EventMatchCriteria;
import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.json.Json;
import io.vertx.ext.unit.Async;
import io.vertx.ext.unit.TestContext;
import io.vertx.ext.web.client.HttpRequest;
import io.vertx.ext.web.client.HttpResponse;
import io.vertx.ext.web.client.WebClient;
import io.vertx.ext.web.codec.BodyCodec;
import io.vertx.junit5.VertxExtension;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mockito;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;

import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

@ExtendWith(VertxExtension.class)
public class AlertsRestServiceTest {
    private static final Logger LOGGER = LoggerFactory.getLogger(AlertsRestServiceTest.class);
    private static final String HOST = "localhost";
    private static final int PORT = 8080;

    private static AlertDefinitionsDao mockedAlertDefinitionsDao = Mockito.mock(AlertDefinitionsDao.class);
    private static Vertx vertx;

    private int baseAlertDefinitionId = 10;
    private String siteKey = "testKey1";
    private int eventCountThreshold = 10;
    private int timeWindowSec = 60;
    private int baseMatchCriteriaId = 1;
    private String fieldToMatch = "ip";
    private String operator = "eq";
    private String matchExpr = "192.168.0.1";
    private static final String username = "ta";
    private static final String password = "ta";
    private static final int chunkSize = 3;

    @BeforeAll
    public static void setUp(TestContext context) {
        LOGGER.info("AlertsRestServiceTest: executing setUp()...");
        vertx = Vertx.vertx();
        AlertsRestService alertsRestService = new AlertsRestService();
        alertsRestService.setTaRestEndpointPort(PORT);
        alertsRestService.setAlertDefinitionsDao(mockedAlertDefinitionsDao);
        alertsRestService.setUsername(username);
        alertsRestService.setPassword(password);
        alertsRestService.setChunkSize(chunkSize);
        vertx.deployVerticle(alertsRestService, context.asyncAssertSuccess());
        LOGGER.info("AlertsRestServiceTest: finished setUp()...");
    }

    @AfterAll
    public static void tearDown(TestContext context) {
        vertx.close(context.asyncAssertSuccess());
    }

    @Test
    public void validate_health_check_return_200(TestContext context) {
        Async async = context.async();
        WebClient client = WebClient.create(vertx);
        HttpRequest<Buffer> request = client.get(PORT, HOST, "/alerts");
        request.basicAuthentication(username, password);

        request.send(asyncResult -> {
            if (asyncResult.succeeded()) {
                // Obtain response
                HttpResponse<Buffer> response = asyncResult.result();
                context.assertEquals(200, response.statusCode());
            } else {
                context.fail(asyncResult.cause());
            }
            async.complete();
            client.close();
        });
    }



    @Test
    public void validate_get_alert_definition_by_id_return_correct_alert(TestContext context) {
        int alertDefinitionId = 5;
        String alertDefinitionIdStr = alertDefinitionId + "";
        AlertDefinition expectedAlertDefinition = new AlertDefinition();
        expectedAlertDefinition.setId(alertDefinitionId);
        Mockito.when(mockedAlertDefinitionsDao.getAlertDefinitionById(alertDefinitionId)).thenReturn(expectedAlertDefinition);

        Async async = context.async();
        WebClient client = WebClient.create(vertx);
        HttpRequest<AlertDefinition> req = client.get(PORT, HOST, "/alerts/getAlertDefinitionById")
            .addQueryParam(AlertsRestService.ID_PARAM, alertDefinitionIdStr)
            .as(BodyCodec.json(AlertDefinition.class));
        req.basicAuthentication(username, password);
        req.send(asyncResult -> {
            if (asyncResult.succeeded()) {
                // Obtain response
                HttpResponse<AlertDefinition> response = asyncResult.result();
                AlertDefinition resultAlertDefinition = response.body();
                LOGGER.info("Received result: {}", resultAlertDefinition);
                context.assertEquals(expectedAlertDefinition, resultAlertDefinition);
            } else {
                Throwable cause = asyncResult.cause();
                LOGGER.error("FAILED", cause);
                context.fail(cause);
            }
            async.complete();
            client.close();
        });
    }

    @Test
    public void validate_get_all_alert_definitions_return_all_alerts_chunked(TestContext context) {
        int numberOfItems = 5;
        List<AlertDefinition> expectedAlertDefinitions = createTestAlertDefinitions(numberOfItems);
        String expectedJsonStringValue = Json.encodePrettily(expectedAlertDefinitions);
        LOGGER.info("Expected alertDefinitions as json string: {}", expectedJsonStringValue);
        Pageable pageable = new PageRequest(0, chunkSize);
        Mockito.when(mockedAlertDefinitionsDao.getAlertDefinitionsByPage(pageable))
            .thenReturn(new PageImpl<>(expectedAlertDefinitions.subList(0, chunkSize), pageable, numberOfItems));
        Pageable nextPageable = new PageRequest(1, chunkSize);
        Mockito.when(mockedAlertDefinitionsDao.getAlertDefinitionsByPage(nextPageable))
            .thenReturn(new PageImpl<>(expectedAlertDefinitions.subList(chunkSize, numberOfItems), nextPageable, numberOfItems));

        Async async = context.async();
        WebClient client = WebClient.create(vertx);
        HttpRequest<Buffer> req = client.get(PORT, HOST, "/alerts/getAllAlertDefinitions");
        req.basicAuthentication(username, password);
        req.send(asyncResult -> {
            if (asyncResult.succeeded()) {
                // Obtain response
                HttpResponse<Buffer> response = asyncResult.result();
                String encodingHeader = response.getHeader("Transfer-Encoding");
                context.assertNotNull(encodingHeader);
                context.assertEquals("chunked", encodingHeader);

                ObjectMapper mapper = new ObjectMapper();
                List<AlertDefinition> alertDefinitions = new ArrayList<>();
                String resultBuffer = response.bodyAsString();
                try {
                    alertDefinitions.addAll(mapper.readValue(resultBuffer, new TypeReference<List<AlertDefinition>>() {
                    }));
                } catch (IOException e) {
                    LOGGER.error("Unable to read json to objects", e);
                    context.fail(e);
                }

                context.assertTrue(!alertDefinitions.isEmpty());
                context.assertEquals(expectedAlertDefinitions, alertDefinitions);
            } else {
                Throwable cause = asyncResult.cause();
                LOGGER.error("FAILED", cause);
                context.fail(cause);
            }
            async.complete();
            client.close();
        });
    }

    @Test
    public void validate_get_alert_definitions_by_site_key_return_correct_alerts(TestContext context) {
        List<AlertDefinition> expectedAlertDefinitions = createTestAlertDefinitions(5);
        Mockito.when(mockedAlertDefinitionsDao.getAlertDefinitionsBySiteKey(siteKey)).thenReturn(expectedAlertDefinitions);

        Async async = context.async();
        WebClient client = WebClient.create(vertx);
        HttpRequest<Buffer> req = client.get(PORT, HOST, "/alerts/getAlertDefinitionsBySiteKey")
            .addQueryParam(AlertsRestService.SITE_KEY_PARAM, siteKey);
        req.basicAuthentication(username, password);
        req.send(asyncResult -> {
            if (asyncResult.succeeded()) {
                // Obtain response
                HttpResponse<Buffer> response = asyncResult.result();
                String resultAlertDefinitionsJsonString = response.bodyAsString();
                ObjectMapper mapper = new ObjectMapper();
                List<AlertDefinition> alertDefinitions = null;
                try {
                    alertDefinitions = mapper.readValue(resultAlertDefinitionsJsonString, new TypeReference<List<AlertDefinition>>() {
                    });
                } catch (IOException e) {
                    LOGGER.error("Unable to read json to objects", e);
                }
                context.assertNotNull(alertDefinitions);
                context.assertTrue(!alertDefinitions.isEmpty());
                context.assertEquals(expectedAlertDefinitions, alertDefinitions);
            } else {
                Throwable cause = asyncResult.cause();
                LOGGER.error("FAILED", cause);
                context.fail(cause);
            }
            async.complete();
            client.close();
        });
    }

    @Test
    public void validate_update_alert_definition_return_201(TestContext context) {
        AlertDefinition expectedAlertDefinition = AlertsTestUtil.generateAlertDefinitionWithParameters(
            baseAlertDefinitionId++, siteKey, eventCountThreshold, timeWindowSec,
            baseMatchCriteriaId++, fieldToMatch, operator, matchExpr);
        Mockito.when(mockedAlertDefinitionsDao.createOrUpdateAlertDefinition(expectedAlertDefinition, username)).thenReturn(expectedAlertDefinition.getId());

        Async async = context.async();
        WebClient client = WebClient.create(vertx);
        HttpRequest<Buffer> req = client.post(PORT, HOST, "/alerts/updateAlertDefinition");
        req.basicAuthentication(username, password);
        req.sendJson(expectedAlertDefinition, asyncResult -> {
            if (asyncResult.succeeded()) {
                HttpResponse<Buffer> response = asyncResult.result();
                context.assertEquals(201, response.statusCode());
                Integer returnedId = response.bodyAsJsonObject().getInteger("id");
                context.assertNotNull(returnedId);
                context.assertEquals(returnedId, expectedAlertDefinition.getId());
            } else {
                Throwable cause = asyncResult.cause();
                LOGGER.error("FAILED", cause);
                context.fail(cause);
            }
            async.complete();
            client.close();
        });
    }

    @Test
    public void validate_get_event_match_criteria_by_id_return_correct_criteria(TestContext context) {
        int id = 5;
        String idStr = id + "";
        EventMatchCriteria expectedEventMatchCriteria = AlertsTestUtil.generateEventMatchCriteriaWithParameters(id, 1, "", "", "");
        Mockito.when(mockedAlertDefinitionsDao.getEventMatchCriteriaById(id)).thenReturn(expectedEventMatchCriteria);

        Async async = context.async();
        WebClient client = WebClient.create(vertx);
        HttpRequest<EventMatchCriteria> req = client.get(PORT, HOST, "/alerts/getEventMatchCriteriaById")
            .addQueryParam(AlertsRestService.ID_PARAM, idStr)
            .as(BodyCodec.json(EventMatchCriteria.class));
        req.basicAuthentication(username, password);
        req.send(asyncResult -> {
            if (asyncResult.succeeded()) {
                // Obtain response
                HttpResponse<EventMatchCriteria> response = asyncResult.result();
                EventMatchCriteria resultEventMatchCriteria = response.body();
                LOGGER.info("Received result: {}", resultEventMatchCriteria);
                context.assertEquals(expectedEventMatchCriteria, resultEventMatchCriteria);
            } else {
                Throwable cause = asyncResult.cause();
                LOGGER.error("FAILED", cause);
                context.fail(cause);
            }
            async.complete();
            client.close();
        });
    }

    @Test
    public void validate_update_event_match_criteria_return_201(TestContext context) {
        EventMatchCriteria eventMatchCriteria = AlertsTestUtil.generateEventMatchCriteria(fieldToMatch, operator, matchExpr);
        Mockito.when(mockedAlertDefinitionsDao.createOrUpdateEventMatchCriteria(eventMatchCriteria, username)).thenReturn(eventMatchCriteria.getId());

        Async async = context.async();
        WebClient client = WebClient.create(vertx);
        HttpRequest<Buffer> req = client.post(PORT, HOST, "/alerts/updateEventMatchCriteria");
        req.basicAuthentication(username, password);
        req.sendJson(eventMatchCriteria, asyncResult -> {
            if (asyncResult.succeeded()) {
                HttpResponse<Buffer> response = asyncResult.result();
                context.assertEquals(201, response.statusCode());
                Integer returnedId = response.bodyAsJsonObject().getInteger("id");
                context.assertNotNull(returnedId);
                context.assertEquals(returnedId, eventMatchCriteria.getId());
            } else {
                Throwable cause = asyncResult.cause();
                LOGGER.error("FAILED", cause);
                context.fail();
            }
            async.complete();
            client.close();
        });
    }

    @Test
    public void validate_delete_alert_definition_return_204(TestContext context) {
        int id = 1;
        String idStr = id + "";
        Mockito.when(mockedAlertDefinitionsDao.deleteAlertDefinitionById(id, username)).thenReturn(1);

        Async async = context.async();
        WebClient client = WebClient.create(vertx);
        HttpRequest<Buffer> req = client.delete(PORT, HOST, "/alerts/deleteAlertDefinitionById")
            .addQueryParam(AlertsRestService.ID_PARAM, idStr);
        req.basicAuthentication(username, password);
        req.send(asyncResult -> {
            if (asyncResult.succeeded()) {
                HttpResponse<Buffer> response = asyncResult.result();
                context.assertEquals(204, response.statusCode());
            } else {
                Throwable cause = asyncResult.cause();
                LOGGER.error("FAILED", cause);
                context.fail(cause);
            }
            async.complete();
            client.close();
        });
    }

    @Test
    public void validate_delete_event_match_criteria_return_204(TestContext context) {
        int id = 1;
        String idStr = id + "";
        Mockito.when(mockedAlertDefinitionsDao.deleteEventMatchCriteriaById(id, username)).thenReturn(1);

        Async async = context.async();
        WebClient client = WebClient.create(vertx);
        HttpRequest<Buffer> req = client.delete(PORT, HOST, "/alerts/deleteEventMatchCriteriaById")
            .addQueryParam(AlertsRestService.ID_PARAM, idStr);
        req.basicAuthentication(username, password);
        req.send(asyncResult -> {
            if (asyncResult.succeeded()) {
                HttpResponse<Buffer> response = asyncResult.result();
                context.assertEquals(204, response.statusCode());
            } else {
                Throwable cause = asyncResult.cause();
                LOGGER.error("FAILED", cause);
                context.fail();
            }
            async.complete();
            client.close();
        });
    }

    @Test
    public void validate_unauthorized_user_return_401(TestContext context) {
        Async async = context.async();
        WebClient client = WebClient.create(vertx);
        HttpRequest<Buffer> request = client.get(PORT, HOST, "/alerts/getAllAlertDefinitions");

        request.send(asyncResult -> {
            if (asyncResult.succeeded()) {
                // Obtain response
                HttpResponse<Buffer> response = asyncResult.result();
                context.assertEquals(401, response.statusCode());
            } else {
                context.fail(asyncResult.cause());
            }
            async.complete();
            client.close();
        });
    }

    private List<AlertDefinition> createTestAlertDefinitions(int numberOfItems) {
        List<AlertDefinition> alertDefinitions = new LinkedList<>();
        for (int i = 0; i < numberOfItems; i++) {
            AlertDefinition alertDefinition = AlertsTestUtil.generateAlertDefinitionWithParameters(
                baseAlertDefinitionId++, siteKey, eventCountThreshold, timeWindowSec,
                baseMatchCriteriaId++, fieldToMatch, operator, matchExpr);
            alertDefinitions.add(alertDefinition);
        }
        return alertDefinitions;
    }
}

No ParameterResolver registered for parameter [io.vertx.ext.unit.TestContext arg0] in method [public static void com.yottaa.ta.alerts.AlertsRestServiceTest.setUp(io.vertx.ext.unit.TestContext)].
org.junit.jupiter.api.extension.ParameterResolutionException: No ParameterResolver registered for parameter [io.vertx.ext.unit.TestContext arg0] in method [public static void com.yottaa.ta.alerts.AlertsRestServiceTest.setUp(io.vertx.ext.unit.TestContext)].
    at org.junit.jupiter.engine.execution.ExecutableInvoker.resolveParameter(ExecutableInvoker.java:200)
    at org.junit.jupiter.engine.execution.ExecutableInvoker.resolveParameters(ExecutableInvoker.java:183)
    at org.junit.jupiter.engine.execution.ExecutableInvoker.resolveParameters(ExecutableInvoker.java:144)
    at org.junit.jupiter.engine.execution.ExecutableInvoker.invoke(ExecutableInvoker.java:96)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$invokeBeforeAllMethods$8(ClassBasedTestDescriptor.java:371)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.invokeBeforeAllMethods(ClassBasedTestDescriptor.java:369)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.before(ClassBasedTestDescriptor.java:193)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.before(ClassBasedTestDescriptor.java:77)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$5(NodeTestTask.java:132)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$7(NodeTestTask.java:125)
    at org.junit.platform.engine.support.hierarchical.Node.around(Node.java:135)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$8(NodeTestTask.java:123)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java:122)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:80)
    at java.util.ArrayList.forEach(ArrayList.java:1257)
    at org.junit.platform.engine.support.hierarchical.SameThreadHierarchicalTestExecutorService.invokeAll(SameThreadHierarchicalTestExecutorService.java:38)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$5(NodeTestTask.java:139)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$7(NodeTestTask.java:125)
    at org.junit.platform.engine.support.hierarchical.Node.around(Node.java:135)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$8(NodeTestTask.java:123)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java:122)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:80)
    at org.junit.platform.engine.support.hierarchical.SameThreadHierarchicalTestExecutorService.submit(SameThreadHierarchicalTestExecutorService.java:32)
    at org.junit.platform.engine.support.hierarchical.HierarchicalTestExecutor.execute(HierarchicalTestExecutor.java:57)
    at org.junit.platform.engine.support.hierarchical.HierarchicalTestEngine.execute(HierarchicalTestEngine.java:51)
    at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:170)
    at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:154)
    at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:90)
    at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor$CollectAllTestClassesExecutor.processAllTestClasses(JUnitPlatformTestClassProcessor.java:92)
    at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor$CollectAllTestClassesExecutor.access$100(JUnitPlatformTestClassProcessor.java:77)
    at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor.stop(JUnitPlatformTestClassProcessor.java:73)
    at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.stop(SuiteTestClassProcessor.java:61)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)
    at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)
    at org.gradle.internal.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:32)
    at org.gradle.internal.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:93)
    at com.sun.proxy.$Proxy2.stop(Unknown Source)
    at org.gradle.api.internal.tasks.testing.worker.TestWorker.stop(TestWorker.java:131)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)
    at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)
    at org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:155)
    at org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:137)
    at org.gradle.internal.remote.internal.hub.MessageHub$Handler.run(MessageHub.java:404)
    at org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:63)
    at org.gradle.internal.concurrent.ManagedExecutorImpl$1.run(ManagedExecutorImpl.java:46)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at org.gradle.internal.concurrent.ThreadFactoryImpl$ManagedThreadRunnable.run(ThreadFactoryImpl.java:55)
    at java.lang.Thread.run(Thread.java:748)
    Suppressed: org.junit.jupiter.api.extension.ParameterResolutionException: No ParameterResolver registered for parameter [io.vertx.ext.unit.TestContext arg0] in method [public static void com.yottaa.ta.alerts.AlertsRestServiceTest.tearDown(io.vertx.ext.unit.TestContext)].
        at org.junit.jupiter.engine.execution.ExecutableInvoker.resolveParameter(ExecutableInvoker.java:200)
        at org.junit.jupiter.engine.execution.ExecutableInvoker.resolveParameters(ExecutableInvoker.java:183)
        at org.junit.jupiter.engine.execution.ExecutableInvoker.resolveParameters(ExecutableInvoker.java:144)
        at org.junit.jupiter.engine.execution.ExecutableInvoker.invoke(ExecutableInvoker.java:96)
        at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$invokeAfterAllMethods$10(ClassBasedTestDescriptor.java:399)
        at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
        at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$invokeAfterAllMethods$11(ClassBasedTestDescriptor.java:397)
        at java.util.ArrayList.forEach(ArrayList.java:1257)
        at java.util.Collections$UnmodifiableCollection.forEach(Collections.java:1082)
        at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.invokeAfterAllMethods(ClassBasedTestDescriptor.java:397)
        at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.after(ClassBasedTestDescriptor.java:209)
        at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.after(ClassBasedTestDescriptor.java:77)
        at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$6(NodeTestTask.java:145)
        at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
        at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$7(NodeTestTask.java:145)
        ... 50 more

Answer 1

已解决。将 TestContext 更改为 VertxTestContext 并使用其方法。我还删除了 Async async = context.async()