登录
当前位置： 首页 > 知识库问答 >
问题：

未为BeforeAll方法中的参数注册ParameterResolver

靳祺然
2023-03-14

我试图用测试将我的项目从使用JUnit4升级到JUnit5。升级后:
@RunWith(VertXUnitRunner.Class)-->@ExtendWith(VertXExtension.Class)
@BeforeClass-->@BeforeAll等
我的一个类在setUp方法中开始崩溃。

与此类似：没有为参数[io.vertx.ext.unit.testContext arg0]注册ParameterResolver
阅读该文档几次，但我不明白“您没有”用vertx信息包装“文本”是什么意思。尝试传递VertxTestContext而不是TestContext，但没有异步方法。
我将非常感谢有关问题的帮助

这里是我的课：

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

共有1个答案

景宏富
2023-03-14

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

 类似资料：
  • BeforeAll方法未被触发

    我使用的是spring boot、kotlin和junit5。我有一个测试类，当我在未触发所有函数之前使用RunWith（SpringRunner：：class）@时，但当我删除该类时，它会给lateinit字段带来错误。

  • 没有为参数[io.vertx.ext.unit.testcontext arg0]注册ParameterResolver

    我正在尝试为vertx相关的东西写一个测试用例。 获取以下错误： 请帮助解决这个问题。

  • Junit 5-没有为参数注册ParameterResolver

    我可以在没有任何特殊测试框架的情况下编写和执行Selenium脚本，但我希望使用JUnit5（因为我们依赖于其他工具），并且在使用JUnit4时从未见过这样的错误。 目前它是JUnit5，我在谷歌上搜索了一些想法，但不能解决这个问题。 使用、和的测试脚本：

  • GCM注册（）方法

    我已经从中看到了“GCM体系结构概述”http://developer.android.com/guide/google/gcm/gcm.html.文档说，当android应用程序注册GCM时，会调用onRegistered（上下文c，字符串regId），其中包含regId，然后用户将该regId发送到其服务器。该文件称“谷歌可能会定期刷新注册ID”。我的问题是，我怎么知道谷歌已经为用户刷新了re

  • 12.2 OAuth参数注册表

    本规范建立OAuth参数注册表。 在oauth-ext-review@ietf.org邮件列表上的两周的审查期后，根据一位或多位指定的专家的建议下，按规范需求（RFC5226）注册列入授权端点请求、授权端点响应、令牌端点请求或令牌端点响应的其他参数。然而，为允许发表之前的值的分配，指定的专家（们）一旦他们对这样的规范即将发布感到满意可以同意注册。 注册请求必须使用正确的主题（例如，参数“examp

  • 1.11 注册中心参考手册

    注册中心参考手册 推荐使用 Zookeeper 注册中心

相关问答

注册时出现未定义的方法错误未注释的参数重写@NotNull参数无参数方法上的@Cacheble批注在方法参数中使用NotNull注释Kafka架构注册表无法注册架构-注册架构请求失败，因为主机未知

相关文章

序数参数未绑定：@Query注释中的2javascript中函数作为参数调用的方法C#操作windows注册表的方法Java传递方法参考作为其他方法的参数定义为null的bean'metaDataSourceAdvisor'无法注册

相关阅读

AngularJS 参考手册批处理注册表如何注册域名GitLab容器注册表Google Guice 方法注入

相关工具

CSS参考手册《CGDB中文手册》Erlang/OTP中文手册jQuery API 2.2.0 中文手册CoreMotion各项参数测试

相关文档

FreeMarker 中文官方参考手册MySQL 中文参考手册Ruby 参考手册Git 参考手册Debian 参考手册
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.