test.java

public class Http2NoTlsTest {

  @Test
  public void testHttp2NoTls() throws Exception {

    Vertx vertx = Vertx.vertx();

    HttpServer server =
        vertx.createHttpServer(new HttpServerOptions());

    CountDownLatch latch = new CountDownLatch(1);

    server
        .requestHandler(req -> {
          System.out.println("Received request: " + req);
          // Just echo back the body buffer
          req.handler(buff -> {
            req.response().write(buff);
          });
          req.endHandler(v -> {
            req.response().end();
          });
        })
        .exceptionHandler(Throwable::printStackTrace)
        .listen(8080, ar -> {
          if (ar.succeeded()) {
            latch.countDown();
          } else {
            ar.cause().printStackTrace();
          }
        });

    assertTrue(latch.await(10, TimeUnit.SECONDS));

    WebClient webClient = WebClient.create(vertx, new WebClientOptions().setProtocolVersion(
        HttpVersion.HTTP_2));

    AtomicReference<HttpResponse<Buffer>> atomicReference = new AtomicReference<>();

    CountDownLatch latch2 = new CountDownLatch(1);

    Buffer body = Buffer.buffer("whatever\n");

    TestReadStream sendStream = new TestReadStream(body);

    webClient.post(8080, "localhost", "/inserts-stream")
        .sendStream(sendStream, ar -> {
          if (ar.succeeded()) {
            atomicReference.set(ar.result());
            latch2.countDown();
          } else {
            ar.cause().printStackTrace();
          }
        });

    assertTrue(latch2.await(10, TimeUnit.SECONDS));

    HttpResponse<Buffer> resp = atomicReference.get();
    assertEquals(200, resp.statusCode());
    assertEquals(body.toString(), resp.bodyAsString());

  }


  class TestReadStream implements ReadStream<Buffer> {

    private Handler<Throwable> exceptionHandler;
    private Handler<Buffer> handler;
    private Handler<Void> endHandler;

    private final Buffer toSend;

    public TestReadStream(final Buffer toSend) {
      this.toSend = toSend;
    }

    @Override
    public ReadStream<Buffer> exceptionHandler(final Handler<Throwable> handler) {
      System.out.println("exceptionHandler set");
      this.exceptionHandler = handler;
      return this;
    }

    @Override
    public synchronized ReadStream<Buffer> handler(@Nullable final Handler<Buffer> handler) {
      System.out.println("handler set " + handler);
      this.handler = handler;
      return this;
    }

    @Override
    public ReadStream<Buffer> pause() {
      System.out.println("pause called");
      return this;
    }

    @Override
    public synchronized ReadStream<Buffer> resume() {
      System.out.println("Resume called");
      if (handler != null) {
        handler.handle(toSend);
      }
      return this;
    }

    @Override
    public ReadStream<Buffer> fetch(final long amount) {
      System.out.println("Fetch called");
      return this;
    }

    @Override
    public ReadStream<Buffer> endHandler(@Nullable final Handler<Void> endHandler) {
      System.out.println("endHandler called");
      this.endHandler = endHandler;
      return this;
    }
  }

}