How to use

endHandler

method

in

io.vertx.core.http.HttpClientResponse

@Test
public void testHttpClientResponseThrowsExceptionInEndHandler() throws Exception {
 testHttpClientResponseThrowsExceptionInHandler(null, (resp, latch) -> {
  resp.endHandler(v -> {
   latch.countDown();
   throw new RuntimeException();
  });
 });
}

@Test
public void testHttpClientResponsePauseIsIgnoredAtRequestEnd() throws Exception {
 testHttpClientResponsePause(resp -> {
  resp.endHandler(v -> {
   // Pausing the request in end handler should be a no-op
   resp.pause();
  });
 });
}

@Test
public void testDefaultHttpVersion() {
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_1, req.version());
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> resp.endHandler(v -> testComplete()))).end();
 }));
 await();
}

@Test
public void testRemoteAddress() {
 server.requestHandler(req -> {
  assertEquals("127.0.0.1", req.remoteAddress().host());
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> resp.endHandler(v -> testComplete()))).end();
 }));
 await();
}

@Test
public void testGetAbsoluteURI() {
 server.requestHandler(req -> {
  assertEquals(req.scheme() + "://localhost:" + DEFAULT_HTTP_PORT + "/foo/bar", req.absoluteURI());
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/foo/bar", onSuccess(resp -> resp.endHandler(v -> testComplete()))).end();
 }));
 await();
}

 @Test
 public void testNoRequestHandler() throws Exception {
  CountDownLatch latch = new CountDownLatch(1);
  vertx.createHttpServer()
   .websocketHandler(ws -> fail())
   .listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v -> latch.countDown()));
  awaitLatch(latch);
  client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
   resp.endHandler(v -> {
    assertEquals(400, resp.statusCode());
    testComplete();
   });
  }));
  await();
 }
}

@Test
public void testSendHeadersCompletionHandler() throws Exception {
 AtomicInteger status = new AtomicInteger();
 server.requestHandler(req -> {
  req.response().end();
 });
 startServer();
 HttpClientRequest req = client.request(HttpMethod.CONNECT, DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
  assertEquals(1, status.getAndIncrement());
  resp.endHandler(v -> {
   assertEquals(2, status.getAndIncrement());
   testComplete();
  });
 }));
 req.sendHead(version -> {
  assertEquals(0, status.getAndIncrement());
  assertSame(HttpVersion.HTTP_2, version);
  req.end();
 });
 await();
}

private void testResponseBody(String expected) throws Exception {
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  resp.end(expected);
 });
 startServer();
 client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
  AtomicInteger count = new AtomicInteger();
  Buffer content = Buffer.buffer();
  resp.handler(buff -> {
   content.appendBuffer(buff);
   count.incrementAndGet();
  });
  resp.endHandler(v -> {
   assertTrue(count.get() > 0);
   assertEquals(expected, content.toString());
   testComplete();
  });
 }))
   .exceptionHandler(err -> fail())
   .end();
 await();
}

@Test
public void testHeadHasNoContentLengthByDefault() {
 server.requestHandler(req -> {
  assertEquals(HttpMethod.HEAD, req.method());
  // By default HEAD does not have a content-length header
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.HEAD, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertNull(resp.headers().get(HttpHeaders.CONTENT_LENGTH));
   resp.endHandler(v -> testComplete());
  })).end();
 }));
 await();
}

@Test
public void testResponseNoTrailers() {
 server.requestHandler(req -> {
  req.response().setChunked(true);
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertTrue(resp.trailers().isEmpty());
    testComplete();
   });
  })).end();
 }));
 await();
}

@Test
public void testHeadCanSetContentLength() {
 server.requestHandler(req -> {
  assertEquals(HttpMethod.HEAD, req.method());
  // Head never contains a body but it can contain a Content-Length header
  // Since headers from HEAD must correspond EXACTLY with corresponding headers for GET
  req.response().headers().set("Content-Length", String.valueOf(41));
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.HEAD, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals("41", resp.headers().get("Content-Length"));
   resp.endHandler(v -> testComplete());
  })).end();
 }));
 await();
}

@Test
public void testHeadButCanSetContentLength() {
 server.requestHandler(req -> {
  assertEquals(HttpMethod.HEAD, req.method());
  // By default HEAD does not have a content-length header but it can contain a content-length header
  // if explicitly set
  req.response().putHeader(HttpHeaders.CONTENT_LENGTH, "41").end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.HEAD, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals("41", resp.headers().get(HttpHeaders.CONTENT_LENGTH));
   resp.endHandler(v -> testComplete());
  })).end();
 }));
 await();
}

@Test
public void testNoExceptionHandlerCalledWhenResponseEnded() throws Exception {
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  req.exceptionHandler(this::fail);
  resp.exceptionHandler(err -> {
   err.printStackTrace();
  });
  resp.end();
 }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
  client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    vertx.setTimer(100, tid -> testComplete());
   });
   resp.exceptionHandler(t -> {
    fail("Should not be called");
   });
  })).exceptionHandler(t -> {
   fail("Should not be called");
  }).end();
 }));
 await();
}

@Test
public void testAccessNetSocket() throws Exception {
 Buffer toSend = TestUtils.randomBuffer(1000);
 server.requestHandler(req -> {
  req.response().headers().set("HTTP/1.1", "101 Upgrade");
  req.bodyHandler(data -> {
   assertEquals(toSend, data);
   req.response().end("somecontent");
  });
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertNotNull(resp.netSocket());
    testComplete();
   });
  }));
  req.headers().set("content-length", String.valueOf(toSend.length()));
  req.write(toSend);
 }));
 await();
}

private void testHttpClientResponsePause(Handler<HttpClientResponse> h) throws Exception {
 server.requestHandler(req -> req.response().end("ok"));
 startServer();
 client.close();
 client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setKeepAlive(true));
 client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp1 -> {
  h.handle(resp1);
  vertx.setTimer(10, timerId -> {
   // The connection should be resumed as it's ended
   client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp2 -> {
    assertSame(resp1.request().connection(), resp2.request().connection());
    resp2.endHandler(v -> testComplete());
   }));
  });
 }));
 await();
}

@Test
public void test100ContinueHandledAutomatically() throws Exception {
 Buffer toSend = TestUtils.randomBuffer(1000);
 server.requestHandler(req -> {
  req.bodyHandler(data -> {
   assertEquals(toSend, data);
   req.response().end();
  });
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> testComplete());
  }));
  req.headers().set("Expect", "100-continue");
  req.setChunked(true);
  req.continueHandler(v -> {
   req.write(toSend);
   req.end();
  });
  req.sendHead();
 }));
 await();
}

@Test
public void testHttp11NonPersistentConnectionClosed() throws Exception {
 client.close();
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_1, req.version());
  assertEquals(req.getHeader("Connection"), "close");
  req.response().end();
  assertTrue(req.response().closed());
 });
 server.listen(onSuccess(s -> {
  client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(false));
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertEquals(resp.getHeader("Connection"), "close");
    testComplete();
   });
  }));
  req.end();
 }));
 await();
}

@Test
public void testHttp10RequestNonKeepAliveConnectionClosed() throws Exception {
 client.close();
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_0, req.version());
  assertNull(req.getHeader("Connection"));
  req.response().end();
  assertTrue(req.response().closed());
 });
 server.listen(onSuccess(s -> {
  client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(false));
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertNull(resp.getHeader("Connection"));
    testComplete();
   });
  }));
  req.end();
 }));
 await();
}

@Test
public void testHttp11PersistentConnectionNotClosed() throws Exception {
 client.close();
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_1, req.version());
  assertNull(req.getHeader("Connection"));
  req.response().end();
  assertFalse(req.response().closed());
 });
 server.listen(onSuccess(s -> {
  client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(true));
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertNull(resp.getHeader("Connection"));
    assertEquals(resp.getHeader("Content-Length"), "0");
    testComplete();
   });
  }));
  req.end();
 }));
 await();
}

@Test
public void testHttp10KeepAliveConnectionNotClosed() throws Exception {
 client.close();
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_0, req.version());
  assertEquals(req.getHeader("Connection"), "keep-alive");
  req.response().end();
  assertFalse(req.response().closed());
 });
 server.listen(onSuccess(s -> {
  client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(true));
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertEquals(resp.getHeader("Connection"), "keep-alive");
    assertEquals(resp.getHeader("Content-Length"), "0");
    testComplete();
   });
  }));
  req.end();
 }));
 await();
}