Java 对Vertx.io应用程序进行单元测试

我正在玩Vertx.io（版本3.4.2）。写下一些代码，现在我想测试它，所以我写了几个单元测试。当我分别运行每个测试时，它们都完成得很好，但当我执行mvn清洁测试时，它们都失败，并显示以下消息：

java.net.BindException: Address already in use: bind
at sun.nio.ch.Net.bind0(Native Method)
at sun.nio.ch.Net.bind(Unknown Source)
at sun.nio.ch.Net.bind(Unknown Source)
at sun.nio.ch.ServerSocketChannelImpl.bind(Unknown Source)
at io.netty.channel.socket.nio.NioServerSocketChannel.doBind(NioServerSocketChannel.java:128)
at io.netty.channel.AbstractChannel$AbstractUnsafe.bind(AbstractChannel.java:554)
at io.netty.channel.DefaultChannelPipeline$HeadContext.bind(DefaultChannelPipeline.java:1258)
at io.netty.channel.AbstractChannelHandlerContext.invokeBind(AbstractChannelHandlerContext.java:502)
at io.netty.channel.AbstractChannelHandlerContext.bind(AbstractChannelHandlerContext.java:487)
at io.netty.channel.DefaultChannelPipeline.bind(DefaultChannelPipeline.java:980)
at io.netty.channel.AbstractChannel.bind(AbstractChannel.java:250)
at io.netty.bootstrap.AbstractBootstrap$2.run(AbstractBootstrap.java:365)
at io.netty.util.concurrent.AbstractEventExecutor.safeExecute(AbstractEventExecutor.java:163)
at io.netty.util.concurrent.SingleThreadEventExecutor.runAllTasksFrom(SingleThreadEventExecutor.java:379)
at io.netty.util.concurrent.SingleThreadEventExecutor.runAllTasks(SingleThreadEventExecutor.java:354)
at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:436)
at io.netty.util.concurrent.SingleThreadEventExecutor$5.run(SingleThreadEventExecutor.java:858)
at java.lang.Thread.run(Unknown Source)

测试完成后，verticle似乎不会关闭。以下是测试：

@RunWith(VertxUnitRunner.class)
public class SomeApiTest {

private ObjectMapper objectMapper;
private Vertx vertx;
private Integer port;
private static Logger log;

@BeforeClass
public static void initTests() {
log = Logger.getLogger("SomeApiTest");
}

@Before
public void setUp(TestContext context) {
log.info("start up test.");
vertx = Vertx.vertx();
objectMapper = new ObjectMapper();
port = 8080;
DeploymentOptions options = new DeploymentOptions();
options.setConfig(new JsonObject());
options.getConfig().put("api.port", port);
vertx.deployVerticle("SomeApi", options, context.asyncAssertSuccess());
}

@After
public void tearDown(TestContext context) {
log.info("shutting down test.");
vertx.close(h -> {
    if (h.failed()) {
    log.error(h.cause());
    }
});
}

@Test
public void whenRequestHitsVerticleItReturnsRecipes(TestContext context) throws Exception {
final Async async = context.async();
List<Integer> votes = new ArrayList<>();
votes.add(new Integer(6));
votes.add(new Integer(4));
votes.add(new Integer(8));
vertx.eventBus().consumer("persistence", h -> {
    h.reply(Json.encode(votes));
});
vertx.createHttpClient().getNow(port, "localhost", "/votes?qty=3", response -> {
    response.handler(body -> {
    Integer[] xvotes;
    try {
        xvotes = objectMapper.readValue(body.toString(), Integer[].class);
        int expected = 3;
        int actual = xvotes.length;
        Assert.assertEquals(expected, actual);
        async.complete();
    } catch (Exception e) {
        log.error(e);
        Assert.fail(e.getMessage());
    }
    });
});
}

@Test
public void fiveDishesRequestAgainsTenRecipesApi(TestContext context) throws Exception {
  final Async async = context.async();
  List<Integer> votes = new ArrayList<>();
  votes.add(new Integer(3));
  votes.add(new Integer(4));
  votes.add(new Integer(7));
  votes.add(new Integer(7));
  votes.add(new Integer(6));
  vertx.eventBus().consumer("persistence", h -> {
    h.reply(Json.encode(votes));
  });
  vertx.createHttpClient().getNow(port, "localhost", "/votes?qty=5", response -> {
    response.handler(body -> {
    Integer[] xvotes;
    try {
        xvotes = objectMapper.readValue(body.toString(), Integer[].class);
        int expected = 5;
        int actual = xvotes.length;
        Assert.assertEquals(expected, actual);
        async.complete();
    } catch (Exception e) {
        log.error(e);
        Assert.fail(e.getMessage());
    }
    });
    });
  }
}

@RunWith（VertxUnitRunner.class）
公共类测试{
私有对象映射器对象映射器；
私有Vertx-Vertx；
专用整数端口；
专用静态记录器日志；
@课前
公共静态void initTests（）{
log=Logger.getLogger（“SomeApiTest”）；
}
@以前
公共无效设置（TestContext上下文）{
log.info（“启动测试”）；
vertx=vertx.vertx（）；
objectMapper=新的objectMapper（）；
端口=8080；
DeploymentOptions=新的DeploymentOptions（）；
setConfig（新的JsonObject（））；
options.getConfig（）.put（“api.port”，port）；
deployVerticle（“SomeApi”，选项，context.asyncAssertSuccess（））；
}
@之后
公共void拆卸（TestContext上下文）{
log.info（“关闭测试”）；
垂直关闭（h->{
if（h.failed（））{
log.error（h.cause（））；
}
});
}
@试验
当nRequestHitsVerticletReturnsRecipes（TestContext上下文）引发异常时，公共无效{
final Async Async=context.Async（）；
列表投票=新的ArrayList（）；
增加（新的整数（6））；
添加（新的整数（4））；
增加（新的整数（8））；
vertx.eventBus（）.consumer（“持久性”，h->{
h、 回复（Json.encode（投票））；
});
vertx.createHttpClient（）.getNow（端口，“localhost”，“/vots？qty=3”，响应->{
handler（body->{
整数[]x投票；
试一试{
xvoces=objectMapper.readValue（body.toString（），Integer[].class）；
int预期=3；
int实际值=x.length；
Assert.assertEquals（预期、实际）；
async.complete（）；
}捕获（例外e）{
日志错误（e）；
Assert.fail（如getMessage（））；
}
});
});
}
@试验
public void FiveDiskRequestStageInSteneRecipesAPI（TestContext上下文）引发异常{
final Async Async=context.Async（）；
列表投票=新的ArrayList（）；
增加（新的整数（3））；
添加（新的整数（4））；
增加（新的整数（7））；
增加（新的整数（7））；
增加（新的整数（6））；
vertx.eventBus（）.consumer（“持久性”，h->{
h、 回复（Json.encode（投票））；
});
vertx.createHttpClient（）.getNow（端口，“localhost”，“/vots？qty=5”，响应->{
handler（body->{
整数[]x投票；
试一试{
xvoces=objectMapper.readValue（body.toString（），Integer[].class）；
int预期为5；
int实际值=x.length；
Assert.assertEquals（预期、实际）；
async.complete（）；
}捕获（例外e）{
日志错误（e）；
Assert.fail（如getMessage（））；
}
});
});
}
}

---

测试很简单，其目的是了解如何使用Vertx进行单元测试。我希望在测试结束后，每个垂直体都将被取消部署。我遗漏了什么？

尝试等待，直到关闭

vertx

。以下是一个例子：

@After
public void tearDown(TestContext context) {
log.info("shutting down test.");
Async async = context.async();
vertx.close(h -> {
    if (h.failed()) {
      log.error(h.cause());
    }
    async.success();
});
}