@Test public void testVirtualHost() throws Exception { server.requestHandler(req -> { assertEquals("another-host:8080", req.host()); req.response().end(); }); startServer(); HttpRequest<Buffer> req = client.get("/test").virtualHost("another-host"); req.send(onSuccess(resp -> testComplete())); await(); }
private void testExpectation(boolean shouldFail, Consumer<HttpRequest<?>> modifier, Consumer<HttpServerResponse> bilto, Consumer<AsyncResult<?>> resultTest) throws Exception { server.requestHandler(request -> bilto.accept(request.response())); startServer(); HttpRequest<Buffer> request = client .get("/test"); modifier.accept(request); request.send(ar -> { if (ar.succeeded()) { assertFalse("Expected response success", shouldFail); } else { assertTrue("Expected response failure", shouldFail); } if (resultTest != null) resultTest.accept(ar); testComplete(); }); await(); } }
@Test public void testRequestPumpErrorNotYetConnected() throws Exception { HttpRequest<Buffer> post = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath"); server.requestHandler(req -> fail()); Throwable cause = new Throwable(); startServer(); post.sendStream(new ReadStream<Buffer>() { Handler<Throwable> exceptionHandler; return this; }, onFailure(err -> { assertSame(cause, err); testComplete(); })); await();
private void testRequest(Function<WebClient, HttpRequest<Buffer>> reqFactory, Consumer<HttpServerRequest> reqChecker) throws Exception { waitFor(4); server.requestHandler(req -> { try { reqChecker.accept(req); complete(); } finally { req.response().end(); } }); startServer(); HttpRequest<Buffer> builder = reqFactory.apply(client); builder.send(onSuccess(resp -> complete())); builder.send(onSuccess(resp -> complete())); await(); }
@Test public void testConnectError() throws Exception { HttpRequest<Buffer> get = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath"); get.send(onFailure(err -> { assertTrue(err instanceof ConnectException); complete(); })); await(); }
@Test public void testSendJsonObjectBody() throws Exception { JsonObject body = new JsonObject().put("wine", "Chateauneuf Du Pape").put("cheese", "roquefort"); testSendBody(body, (contentType, buff) -> { assertEquals("application/json", contentType); assertEquals(body, buff.toJsonObject()); }); }
@Test public void testInvalidRedirection() throws Exception { server.requestHandler(req -> { assertEquals(HttpMethod.POST, req.method()); assertEquals("/redirect", req.path()); req.response().setStatusCode(302).putHeader("Location", "http://www.google.com").end(); }); startServer(); HttpRequest<Buffer> builder = client .post("/redirect") .followRedirects(true); builder.send(onSuccess(resp -> { assertEquals(302, resp.statusCode()); assertEquals("http://www.google.com", resp.getHeader("Location")); assertNull(resp.body()); complete(); })); await(); }
f.deleteOnExit(); Files.write(f.toPath(), expected.getBytes()); waitFor(2); server.requestHandler(req -> req.bodyHandler(buff -> { assertEquals(method, req.method()); assertEquals(Buffer.buffer(expected), buff); complete(); req.response().end(); })); startServer(); vertx.runOnContext(v -> { AsyncFile asyncFile = vertx.fileSystem().openBlocking(f.getAbsolutePath(), new OpenOptions()); break; default: fail("Invalid HTTP method"); builder = builder.putHeader("Content-Length", "" + expected.length()); builder.sendStream(asyncFile, onSuccess(resp -> { assertEquals(200, resp.statusCode()); complete(); })); }); await();
latch.countDown(); }); startServer(); AtomicReference<Handler<Buffer>> dataHandler = new AtomicReference<>(); AtomicReference<Handler<Void>> endHandler = new AtomicReference<>(); return this; }, onFailure(err -> { assertNull(endHandler.get()); assertNull(dataHandler.get()); assertFalse(paused.get()); complete(); })); assertWaitUntil(() -> dataHandler.get() != null); dataHandler.get().handle(TestUtils.randomBuffer(1024)); awaitLatch(latch); while (!paused.get()) { dataHandler.get().handle(TestUtils.randomBuffer(1024)); await();
@Test public void testTimeout() throws Exception { AtomicInteger count = new AtomicInteger(); server.requestHandler(req -> count.incrementAndGet()); startServer(); HttpRequest<Buffer> get = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath"); get.timeout(50).send(onFailure(err -> { assertTrue(err instanceof TimeoutException); testComplete(); })); await(); }
@Test public void testRequestPumpError() throws Exception { waitFor(2); HttpRequest<Buffer> post = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath"); CompletableFuture<Void> done = new CompletableFuture<>(); server.requestHandler(req -> { req.response().closeHandler(v -> complete()); req.handler(buff -> done.complete(null)); }); Throwable cause = new Throwable(); startServer(); post.sendStream(new ReadStream<Buffer>() { @Override return this; }, onFailure(err -> { if (cause == err) { complete(); } else { fail(new Exception("Unexpected failure", err)); await();
@Test public void testHttpProxyFtpRequest() throws Exception { startProxy(null, ProxyType.HTTP); proxy.setForceUri("http://" + DEFAULT_HTTP_HOST + ":" + DEFAULT_HTTP_PORT); server.requestHandler(req -> req.response().setStatusCode(200).end()); startServer(); WebClientOptions options = new WebClientOptions(); options.setProxyOptions(new ProxyOptions().setPort(proxy.getPort())); WebClient client = WebClient.create(vertx, options); client .getAbs("ftp://ftp.gnu.org/gnu/") .send(ar -> { if (ar.succeeded()) { // Obtain response HttpResponse<Buffer> response = ar.result(); assertEquals(200, response.statusCode()); assertEquals("ftp://ftp.gnu.org/gnu/", proxy.getLastUri()); testComplete(); } else { fail(ar.cause()); } }); await(); }
@Test public void testQueryParam() throws Exception { testRequest(client -> client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/").addQueryParam("param", "param_value"), req -> { assertEquals("param=param_value", req.query()); assertEquals("param_value", req.getParam("param")); }); }
fail.thenAccept(v -> resp.close()); }); startServer(); AtomicInteger received = new AtomicInteger(); WriteStream<Buffer> stream = new WriteStream<Buffer>() { get .as(BodyCodec.pipe(stream)) .send(onFailure(err -> testComplete())); assertWaitUntil(() -> received.get() == 2048); fail.complete(null); await();
@Test public void testFileUploadWhenFileDoesNotExist() { HttpRequest<Buffer> builder = client.post("somepath"); MultipartForm form = MultipartForm.create() .textFileUpload("file", "nonexistentFilename", "nonexistentPathname", "text/plain"); builder.sendMultipartForm(form, onFailure(err -> { assertEquals(err.getClass(), HttpPostRequestEncoder.ErrorDataEncoderException.class); complete(); })); await(); }
@Test public void testExpectCustomException() throws Exception { ResponsePredicate predicate = ResponsePredicate.create(r -> ResponsePredicateResult.failure("boom"), result -> new CustomException(result.message())); testExpectation(true, req -> req.expect(predicate), HttpServerResponse::end, ar -> { Throwable cause = ar.cause(); assertThat(cause, instanceOf(CustomException.class)); CustomException customException = (CustomException) cause; assertEquals("boom", customException.getMessage()); }); }
private void testRequest(HttpMethod method) throws Exception { testRequest(client -> { switch (method) { case GET: return client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath"); case HEAD: return client.head(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath"); case DELETE: return client.delete(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath"); default: fail("Invalid HTTP method"); return null; } }, req -> assertEquals(method, req.method())); }
testResponseMissingBody(BodyCodec.pipe(stream)); assertTrue(ended.get()); assertEquals(0, length.get());
@Test public void testExpectFunctionThrowsException() throws Exception { ResponsePredicate predicate = ResponsePredicate.create(r -> { throw new IndexOutOfBoundsException("boom"); }); testExpectation(true, req -> req.expect(predicate), HttpServerResponse::end, ar -> { assertThat(ar.cause(), instanceOf(IndexOutOfBoundsException.class)); }); }
/** * Regression test for issue #563 (https://github.com/vert-x3/vertx-web/issues/563) * <p> * Only occurred when {@link WebClientOptions#isSsl()} was false for an SSL request. */ @Test public void testTLSQueryParametersIssue563() throws Exception { testTLS(false, true, client -> client.getAbs("https://" + DEFAULT_HTTPS_HOST + ":" + DEFAULT_HTTPS_PORT) .addQueryParam("query1", "value1") .addQueryParam("query2", "value2"), serverRequest -> assertEquals("query1=value1&query2=value2", serverRequest.query())); }