Skip to main content

异步多语种单元测试.

Introduction

Vertx单元旨在使用Polyglot API编写异步单元测试,并在JVM中运行这些测试. Vertx Unit Api借鉴了现有的测试框架(如JUnitQUnit)并遵循Vert.x的实践.

因此,Vertx Unit是测试Vert.x应用程序的自然选择.

要使用vert.x单元,请将以下依赖项添加到构建描述符的" dependencies"部分:

  • Maven(在您的pom.xml ):

<dependency>
 <groupId>io.vertx</groupId>
 <artifactId>vertx-unit</artifactId>
 <version>3.9.2</version>
 <scope>test</scope>
</dependency>
  • Gradle(在build.gradle文件中):

testCompile ${io.vertx}:${vertx-unit}:3.9.2

Vert.x单元可以以不同的方式使用,并且可以在代码运行的任何地方运行,这只是以正确的方式报告结果的问题,此示例显示了最低限度的测试套件:

var TestSuite = require("vertx-unit-js/test_suite");
var suite = TestSuite.create("the_test_suite");
suite.test("my_test_case", function (context) {
  var s = "value";
  context.assertEquals("value", s);
});
suite.run();

run方法将执行套件并通过套件的所有测试. 该套件可以失败或通过,如果外部环境不知道测试结果,则无所谓.

var TestSuite = require("vertx-unit-js/test_suite");
var suite = TestSuite.create("the_test_suite");
suite.test("my_test_case", function (context) {
  var s = "value";
  context.assertEquals("value", s);
});
suite.run({
  "reporters" : [
    {
      "to" : "console"
    }
  ]
});

执行后,测试套件现在会向控制台报告测试套件的步骤:

Begin test suite the_test_suite
Begin test my_test
Passed my_test
End test suite the_test_suite , run: 1, Failures: 0, Errors: 0

reporters选项可配置套件运行程序用于报告测试执行情况的报告程序,有关更多信息,请参见报告部分.

Writing a test suite

测试套件是测试用例的命名集合,测试用例是要执行的直接回调. 该套件可以具有生命周期回调,以用于初始化或处置该测试套件所使用的服务的测试用例或测试套件之前和/或之后执行.

var TestSuite = require("vertx-unit-js/test_suite");
var suite = TestSuite.create("the_test_suite");
suite.test("my_test_case_1", function (context) {
  // Test 1
});
suite.test("my_test_case_2", function (context) {
  // Test 2
});
suite.test("my_test_case_3", function (context) {
  // Test 3
});

该API很流畅,因此可以将测试用例链接起来:

var TestSuite = require("vertx-unit-js/test_suite");
var suite = TestSuite.create("the_test_suite");
suite.test("my_test_case_1", function (context) {
  // Test 1
}).test("my_test_case_2", function (context) {
  // Test 2
}).test("my_test_case_3", function (context) {
  // Test 3
});

无法保证测试用例的声明顺序,因此测试用例不应依赖于另一个测试用例的执行来运行. 这种做法被认为是不好的.

Vertx Unit提供了用于全局设置或清理的回调之前之后

var TestSuite = require("vertx-unit-js/test_suite");
var suite = TestSuite.create("the_test_suite");
suite.before(function (context) {
  // Test suite setup
}).test("my_test_case_1", function (context) {
  // Test 1
}).test("my_test_case_2", function (context) {
  // Test 2
}).test("my_test_case_3", function (context) {
  // Test 3
}).after(function (context) {
  // Test suite cleanup
});

方法的声明顺序无关紧要,该示例在测试用例之前声明before回调,在测试用例之后声明after回调,但是可以在任何地方声明,只要在运行测试套件之前完成即可.

执行任何测试之前,将执行before回调,如果该回调失败,则测试套件执行将停止并报告失败. after回调是测试套件执行的最后一个回调,除非before回调报告程序失败.

同样,Vertx Unit提供了beforeEachafterEach回调,它们执行相同的操作,但针对每个测试用例执行:

var TestSuite = require("vertx-unit-js/test_suite");
var suite = TestSuite.create("the_test_suite");
suite.beforeEach(function (context) {
  // Test case setup
}).test("my_test_case_1", function (context) {
  // Test 1
}).test("my_test_case_2", function (context) {
  // Test 2
}).test("my_test_case_3", function (context) {
  // Test 3
}).afterEach(function (context) {
  // Test case cleanup
});

beforeEach回调在每个测试用例之前执行,如果失败,则不执行测试用例并报告失败. afterEach回调是在测试用例回调之后立即执行的,除非beforeEach回调报告失败.

Asserting

Vertx单元提供TestContext对象,用于在测试用例中进行断言. 上下文对象提供了处理断言时的常用方法.

assertEquals

断言两个对象相等,适用于基本类型或json类型.

suite.test("my_test_case", function (context) {
  context.assertEquals(10, callbackCount);
});

还有一个用于提供消息的重载版本:

suite.test("my_test_case", function (context) {
  context.assertEquals(10, callbackCount, "Should have been 10 instead of " + callbackCount);
});

通常,每个断言都提供一个重载版本.

assertNotEquals

assertEquals的对应部分.

suite.test("my_test_case", function (context) {
  context.assertNotEquals(10, callbackCount);
});

assertNull

断言一个对象为null,适用于基本类型或json类型.

suite.test("my_test_case", function (context) {
  context.assertNull(null);
});

assertNotNull

assertNull的计数器部分.

suite.test("my_test_case", function (context) {
  context.assertNotNull("not null!");
});

assertInRange

assertInRange以实数为目标.

suite.test("my_test_case", function (context) {

  // Assert that 0.1 is equals to 0.2 +/- 0.5

  context.assertInRange(0.1, 0.2, 0.5);
});

assertTrue and assertFalse

声明布尔表达式的值.

suite.test("my_test_case", function (context) {
  context.assertTrue(var);
  context.assertFalse(value > 10);
});

Failing

最后但并非最不重要的一点是, test提供了一个fail方法,该方法将引发断言错误:

suite.test("my_test_case", function (context) {
  context.fail("That should never happen");
  // Following statements won't be executed
});

失败可以是前面看到的字符串 ,也可以是错误 . 错误对象取决于目标语言,对于Java或Groovy,它可以是扩展Throwable-的任何类;对于JavaScript,则是_error ;对于Ruby,则是Exception .

Using third-party assertion framework

也可以使用任何其他断言框架,例如流行的hamcrestassertj . 推荐的方法是使用verify并在提供的Handler中执行断言. 这样,异步测试终止将得到正确处理.

suite.test("my_test_case", function (context) {
  context.verify(function (v) {
    // Using here Assert from junit, could be assertj, hamcrest or any other
    // Even manually throwing an AssertionError.
    Java.type("org.junit.Assert").assertNotNull("not null!");
    Java.type("org.junit.Assert").assertEquals(10, callbackCount);
  });
});

Asynchronous testing

前面的示例假定测试用例在各自的回调之后终止,这是测试用例回调的默认行为. 通常希望在测试用例回调之后终止测试,例如:

Async对象异步完成测试用例
suite.test("my_test_case", function (context) {
  var async = context.async();
  eventBus.consumer("the-address", function (msg) {
    (2)
    async.complete();
  });
  (1)
});
  1. 回调退出,但测试用例未终止

  2. 总线上的事件回调终止测试

使用async方法创建Async对象async执行的测试用例标记为未终止. 当调用complete方法时,测试用例终止.

Note
如果未调用complete回调,则测试用例在一定的超时后失败.

可以在同一测试用例中创建几个Async对象,必须完成所有这些对象才能终止测试.

几个异步对象提供协调
suite.test("my_test_case", function (context) {

  var async1 = context.async();
  var client = vertx.createHttpClient();
  var req = client.get(8080, "localhost", "/");
  req.exceptionHandler(function (err) {
    context.fail(err.getMessage());
  });
  req.handler(function (resp) {
    context.assertEquals(200, resp.statusCode());
    async1.complete();
  });
  req.end();

  var async2 = context.async();
  vertx.eventBus().consumer("the-address", function (msg) {
    async2.complete();
  });
});

异步对象也可以回调之前之后使用, before回调中实现依赖于一个或多个异步结果的设置非常方便:

异步在测试用例之前启动http服务器
suite.before(function (context) {
  var async = context.async();
  var server = vertx.createHttpServer();
  server.requestHandler(requestHandler);
  server.listen(8080, function (ar, ar_err) {
    context.assertTrue(ar_err == null);
    async.complete();
  });
});

可以等到特定的Async完成,类似于Java的倒计时闩锁:

等待完成
var async = context.async();
var server = vertx.createHttpServer();
server.requestHandler(requestHandler);
server.listen(8080, function (ar, ar_err) {
  context.assertTrue(ar_err == null);
  async.complete();
});

// Wait until completion
async.awaitSuccess();

// Do something else
Warning
这不应该从事件循环中执行!

异步也可以使用初始计数值创建,当使用countDown进行countDown计数到零时,它将完成:

等到完全倒数达到零
var async = context.async(2);
var server = vertx.createHttpServer();
server.requestHandler(requestHandler);
server.listen(8080, function (ar, ar_err) {
  context.assertTrue(ar_err == null);
  async.countDown();
});

vertx.setTimer(1000, function (id) {
  async.complete();
});

// Wait until completion of the timer and the http request
async.awaitSuccess();

// Do something else

在异步上调用complete()照常完成异步,实际上将值设置为0 .

Asynchronous assertions

TestContext提供了有用的方法,这些方法为异步测试提供了强大的结构:

asyncAssertSuccess方法返回一个类似于Async的{@literal Handler <AsyncResult <T >>}实例,成功解析Async并通过失败原因对失败进行测试.

Async async = context.async();
vertx.deployVerticle("my.verticle", ar -> {
  if (ar.succeeded()) {
    async.complete();
  } else {
    context.fail(ar.cause());
  }
});

// Can be replaced by

vertx.deployVerticle("my.verticle", context.asyncAssertSuccess());

asyncAssertSuccess方法返回一个类似于Async的{@literal Handler <AsyncResult <T >>}实例,在成功时调用委派的{@literal Handler <T>},并在失败失败的测试中失败,并指出失败的原因.

AtomicBoolean started = new AtomicBoolean();
Async async = context.async();
vertx.deployVerticle(new AbstractVerticle() {
  public void start() throws Exception {
    started.set(true);
  }
}, ar -> {
  if (ar.succeeded()) {
    context.assertTrue(started.get());
    async.complete();
  } else {
    context.fail(ar.cause());
  }
});

// Can be replaced by

vertx.deployVerticle("my.verticle", context.asyncAssertSuccess(id -> {
  context.assertTrue(started.get());
}));

Handler退出时,异步将完成,除非在调用期间创建了新的异步,这可以方便地链接异步行为:

Async async = context.async();
vertx.deployVerticle("my.verticle", ar1 -> {
  if (ar1.succeeded()) {
    vertx.deployVerticle("my.otherverticle", ar2 -> {
      if (ar2.succeeded()) {
        async.complete();
      } else {
        context.fail(ar2.cause());
      }
    });
  } else {
    context.fail(ar1.cause());
  }
});

// Can be replaced by

vertx.deployVerticle("my.verticle", context.asyncAssertSuccess(id ->
        vertx.deployVerticle("my_otherverticle", context.asyncAssertSuccess())
));

asyncAssertFailure方法返回一个类似于Async的{@literal Handler <AsyncResult <T >>}实例,解决失败时的Async并成功进行测试的失败.

Async async = context.async();
vertx.deployVerticle("my.verticle", ar -> {
  if (ar.succeeded()) {
    context.fail();
  } else {
    async.complete();
  }
});

// Can be replaced by

vertx.deployVerticle("my.verticle", context.asyncAssertFailure());

asyncAssertFailure方法返回一个类似于Async的{@literal Handler <AsyncResult <T >>}实例,在失败时调用委托的{@literal Handler <Throwable>},并在成功通过测试时失败.

Async async = context.async();
vertx.deployVerticle("my.verticle", ar -> {
  if (ar.succeeded()) {
    context.fail();
  } else {
    context.assertTrue(ar.cause() instanceof IllegalArgumentException);
    async.complete();
  }
});

// Can be replaced by

vertx.deployVerticle("my.verticle", context.asyncAssertFailure(cause -> {
  context.assertTrue(cause instanceof IllegalArgumentException);
}));

Handler退出时,异步将完成,除非在调用期间创建了新的异步.

Repeating test

当测试随机或不经常失败时,例如在竞赛条件下,多次运行同一测试很方便,以增加测试失败的可能性.

重复测试
var TestSuite = require("vertx-unit-js/test_suite");
TestSuite.create("my_suite").test("my_test", 1000, function (context) {
  // This will be executed 1000 times
});

声明后, beforeEachafterEach回调将与测试执行次数一样多.

Note
测试重复按顺序执行

Sharing objects

TestContext具有get / put / remove操作以在回调之间共享状态.

before回调期间添加的任何对象在任何其他回调中均可用. 每个测试用例都将在共享状态的副本上进行操作,因此更新仅对一个测试用例可见.

在回调之间共享状态
var TestSuite = require("vertx-unit-js/test_suite");
TestSuite.create("my_suite").before(function (context) {

  // host is available for all test cases
  context.put("host", "localhost");

}).beforeEach(function (context) {

  // Generate a random port for each test
  var port = helper.randomPort();

  // Get host
  var host = context.get("host");

  // Setup server
  var async = context.async();
  var server = vertx.createHttpServer();
  server.requestHandler(function (req) {
    req.response().setStatusCode(200).end();
  });
  server.listen(port, host, function (ar, ar_err) {
    context.assertTrue(ar_err == null);
    context.put("port", port);
    async.complete();
  });

}).test("my_test", function (context) {

  // Get the shared state
  var port = context.get("port");
  var host = context.get("host");

  // Do request
  var client = vertx.createHttpClient();
  var req = client.get(port, host, "/resource");
  var async = context.async();
  req.handler(function (resp) {
    context.assertEquals(200, resp.statusCode());
    async.complete();
  });
  req.end();
});
Warning
共享任何对象仅在Java中受支持,其他语言只能共享基本或json类型. 其他对象应使用该语言的功能共享.

Running

创建测试套件后,在调用run方法之前,它不会执行.

Running a test suite
suite.run();

该测试套件也可以与指定的Vertx实例一起运行:

提供一个Vertx实例来运行测试套件
suite.run(vertx);

当使用Vertx实例运行时,将使用Vertx事件循环执行测试套件,有关更多详细信息,请参阅" 事件循环"部分.

可以使用Vert.x命令行界面和vertx test命令运行测试套件:

使用Vert.x CLI运行测试套件
> vertx test the_test_suite.js
Begin test suite the_test_suite
Succeeded in deploying verticle
Begin test my_test_case
Passed my_test_case
End test suite my_suite , run: 1, Failures: 0, Errors: 0

此类测试套件仅需要通过run命令执行, vertx test命令负责配置报告,超时等……,非常类似于此示例:

var TestSuite = require("vertx-unit-js/test_suite");
var suite = TestSuite.create("the_test_suite");
suite.test("my_test_case", function (context) {
  var s = "value";
  context.assertEquals("value", s);
});
suite.run();

vertx test命令扩展了vertx run命令. JVM的退出行为已更改,执行测试套件并提供返回值指示测试成功(0)或失败(1)时,JVM退出.

Note
several test suites can executed in the same verticle, Vert.x Unit waits until completion of all suite executed.

Test suite completion

无法对何时完成测试套件进行任何假设,并且如果需要在测试套件之后执行某些代码,则这些代码应该回调位于测试套件中或作为Completion回调:

测试套件执行回调
var completion = suite.run(vertx);

// Simple completion callback
completion.handler(function (ar, ar_err) {
  if (ar_err == null) {
    console.log("Test suite passed!");
  } else {
    console.log("Test suite failed:");
    ar_err.printStackTrace();
  }
});

Completion对象还提供一个采用Promise对象的resolve方法,该Promise将在测试套件执行时得到通知:

使用测试套件解决启动Promise
var completion = suite.run();

// When the suite completes, the promise is resolved
completion.resolve(startPromise);

这使得可以轻松地创建一个以测试套件执行为部署方式的测试 Verticle,从而使部署它的代码可以轻松了解成功或失败.

完成对象也可以像闩锁一样用于阻塞,直到测试套件完成. 当运行测试套件的线程与当前线程不同时,应使用此方法:

阻塞直到测试套件完成
var completion = suite.run();

// Wait until the test suite completes
completion.await();

线程中断或触发超时时, await将引发异常.

awaitSuccess是一种变体,当测试套件失败时会引发异常.

Blocking until the test suite succeeds
var completion = suite.run();

// Wait until the test suite succeeds otherwise throw an exception
completion.awaitSuccess();

Time out

测试套件的每个测试用例必须在达到特定超时之前执行. 默认超时为2分钟 ,可以使用测试选项进行更改:

设置测试套件超时
var options = {
  "timeout" : 10000
};

// Run with a 10 seconds time out
suite.run(options);

Event loop

Vertx单元执行是要执行的任务的列表,每个任务的执行由上一个任务的完成来驱动. 这些任务应尽可能利用Vert.x事件循环,但这取决于当前的执行上下文(即测试套件是在main Verticle执行还是在Verticle嵌入),并且是否配置了Vertx实例.

useEventLoop配置事件循环的用法:

表1.事件循环的用法
useEventLoop:null useEventLoop:true useEventLoop:false

Vertx instance

使用vertx事件循环

使用vertx事件循环

强制无事件循环

在一个Verticle

使用当前事件循环

使用当前事件循环

强制无事件循环

主要

不使用事件循环

引发错误

不使用事件循环

默认的useEventLoop值为null ,这意味着它将在可能的情况下使用事件循环,在没有人可用时回useEventLoop无事件循环.

Reporting

报告是测试套件的重要组成部分,可以将Vertx Unit配置为与其他类型的报告器一起运行.

默认情况下,没有配置报告程序,运行测试套件时,可以提供测试选项来配置一个或多个:

使用控制台报告程序并作为junit xml文件
// Report to console
var consoleReport = {
  "to" : "console"
};

// Report junit files to the current directory
var junitReport = {
  "to" : "file:.",
  "format" : "junit"
};

suite.run({
  "reporters" : [
    consoleReport,
    junitReport
  ]
});

Console reporting

报告给JVM System.outSystem.err

to

console

format

simple or junit

File reporting

报告到文件时,必须提供Vertx实例:

to

file : 目录名称

format

simple or junit

example

file:.

The file reporter will create files in the configured directory, the files will be named after the test suite name executed and the format (i.e simple creates txt files and junit creates xml files).

Log reporting

向记录器报告,必须提供一个Vertx实例:

to

log : 记录器名称

example

log:mylogger

Event bus reporting

向事件总线报告事件,必须提供一个Vertx实例:

to

bus : 事件总线地址

example

bus:the-address

它允许将测试套件的执行与报告分离.

通过事件总线发送的消息可以由EventBusCollector收集并实现自定义报告:

var EventBusCollector = require("vertx-unit-js/event_bus_collector");
var collector = EventBusCollector.create(vertx, {
  "reporters" : [
    {
      "to" : "file:report.xml",
      "format" : "junit"
    }
  ]
});

collector.register("the-address");

Vertx integration

默认情况下,必须在TestContext上进行断言和失败,并且仅当Vert.x Unit调用时,引发断言错误才有效:

suite.test("my_test_case", function (ctx) {

  // The failure will be reported by Vert.x Unit
  throw "it failed!";
});

在常规的Vert.x回调中,失败将被忽略:

suite.test("test-server", function (testContext) {
  var server = vertx.createHttpServer().requestHandler(function (req) {
    if (req.path() == "/somepath") {
      throw "Wrong path!";
    }
    req.response().end();
  });
});

从Vert.x 3.3开始,可以设置全局异常处理程序以报告事件循环中未捕获的异常:

suite.before(function (testContext) {

  // Report uncaught exceptions as Vert.x Unit failures
  vertx.exceptionHandler(testContext.exceptionHandler());
});

suite.test("test-server", function (testContext) {
  var server = vertx.createHttpServer().requestHandler(function (req) {
    if (req.path() == "/somepath") {
      throw "Wrong path!";
    }
    req.response().end();
  });
});

异常处理程序是在before阶段设置的, TestContextbeforetestafter阶段之间共享. 因此,在before阶段获得的异常处理程序是正确的.

Junit integration

尽管Vertx Unit是多语言的并且不基于JUnit,但是可以从JUnit运行Vertx Unit测试套件或测试用例,从而允许您将测试与JUnit和构建系统或IDE集成.

将Java类作为JUnit测试套件运行
@RunWith(VertxUnitRunner.class)
public class JUnitTestSuite {
  @Test
  public void testSomething(TestContext context) {
    context.assertFalse(false);
  }
}

VertxUnitRunner使用junit批注对类进行自省,并在类之后创建测试套件. 这些方法应该声明一个TestContext参数,如果没有,也可以. 但是, TestContext是检索执行异步测试的关联Vertx实例的唯一方法.

io.vertx.groovy.ext.unit.junit.VertxUnitRunner集成还可通过io.vertx.groovy.ext.unit.junit.VertxUnitRunner用于Groovy语言.

Running a test on a Vert.x context

默认情况下,调用测试方法的线程是JUnit线程. RunTestOnContext JUnit规则可用于更改此行为,以便通过Vert.x事件循环线程运行这些测试方法.

因此,在测试方法和Vert.x处理程序之间共享状态时必须格外小心,因为它们将不在同一线程中,例如,增加Vert.x处理程序中的计数器并在测试方法中声明该计数器. 解决此问题的一种方法是使用适当的同步,另一种方法是在Vert.x上下文中执行测试方法,该方法将传播到创建的处理程序中.

为此, RunTestOnContext规则需要一个Vertx实例. 可以提供这样的实例,否则规则将在后台管理一个实例. 测试运行时可以检索此类实例,这也使该规则成为管理Vertx实例的一种方式.

将Java类作为JUnit测试套件运行
@RunWith(VertxUnitRunner.class)
public class RunOnContextJUnitTestSuite {

  @Rule
  public RunTestOnContext rule = new RunTestOnContext();

  @Test
  public void testSomething(TestContext context) {
    // Use the underlying vertx instance
    Vertx vertx = rule.vertx();
  }
}

可以用{@literal @Rule}或{@literal @ClassRule}注释该规则,前者为每个测试管理一个Vert.x实例,后者为该类的测试方法管理一个Vert.x.

Warning
请记住,使用此规则时不能阻止事件循环. 必须谨慎使用CountDownLatch之类的类或类似的类.

Timeout

Vert.x单元2分钟超时可以用@Test批注的timeout成员覆盖:

在测试级别配置超时
public class JunitTestWithTimeout {

  @Test(timeout = 1000l)
  public void testSomething(TestContext context) {
    //...
  }

}

对于更全局的配置,可以使用" Timeout规则:

在课程级别配置超时
@RunWith(VertxUnitRunner.class)
public class TimeoutTestSuite {

  @Rule
  public Timeout rule = Timeout.seconds(1);

  @Test
  public void testSomething(TestContext context) {
    //...
  }
}
Note
@Test超时将覆盖" Timeout规则.

Parameterized tests

JUnit提供了有用的Parameterized测试,由于VertxUnitRunnerWithParametersFactory可以使用此特定运行程序运行Vert.x单元测试:

运行Vert.x单元参数化测试
@RunWith(Parameterized.class)
@Parameterized.UseParametersRunnerFactory(VertxUnitRunnerWithParametersFactory.class)
public class SimpleParameterizedTest {

  @Parameterized.Parameters
  public static Iterable<Integer> data() {
    return Arrays.asList(0, 1, 2);
  }

  public SimpleParameterizedTest(int value) {
    //...
  }

  @Test
  public void testSomething(TestContext context) {
    // Execute test with the current value
  }
}

也可以使用io.vertx.groovy.ext.unit.junit.VertxUnitRunnerWithParametersFactory在Groovy中进行参数化测试.

Repeating a test

当测试随机或不经常失败时,例如在竞争条件下,多次运行同一测试很方便,以增加测试失败的可能性.

使用JUnit,必须使用@Repeat注释测试才能重复进行. 测试还必须在其规则中定义RepeatRule .

用JUnit重复测试
@RunWith(VertxUnitRunner.class)
public class RepeatingTest {

  @Rule
  public RepeatRule rule = new RepeatRule();

  @Repeat(1000)
  @Test
  public void testSomething(TestContext context) {
    // This will be executed 1000 times
  }
}

声明后,生命周期前后将执行与执行测试一样多的次数.

Note
测试重复按顺序执行

Using with other assertion libraries

Vert.x在Vert.x 3.3中已大大提高了单位的可用性. 现在,您可以使用HamcrestAssertJRest Assured或所需的任何断言库编写测试. Vertx集成中描述的全局异常处理程序使这成为可能.

您可以在vertx-examples项目中找到将Vert.x Unit与Hamcrest和AssertJ一起使用的Java示例.

Java language integration

Test suite integration

Java语言提供了类,并且可以使用以下映射规则直接从Java类创建测试套件:

检查testSuiteObject参数方法,并保留带有TestContext参数的公共非静态方法,并通过方法名称映射到Vertx单元测试套件:

  • before :回调之前

  • after :回调后

  • beforeEach :beforeEach回调

  • afterEach :afterEach回调

  • 当名称以test开头时:以方法名称命名的测试用例回调

使用Java类编写的测试套件
public class MyTestSuite {

  public void testSomething(TestContext context) {
    context.assertFalse(false);
  }
}

该类可以轻松地转换为Vertx测试套件:

从Java对象创建测试套件
TestSuite suite = TestSuite.create(new MyTestSuite());

by  ICOPY.SITE