congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
HttpClientResponse.statusCode
Code IndexAdd Tabnine to your IDE (free)

How to use
statusCode
method
in
io.vertx.core.http.HttpClientResponse

Best Java code snippets using io.vertx.core.http.HttpClientResponse.statusCode (Showing top 20 results out of 810)

origin: eclipse-vertx/vert.x

private void expectStatusError(int error, int responseStatus, String username, String url) throws Exception {
 proxyTest(error, username, url, onSuccess(resp -> {
  assertEquals(responseStatus, resp.statusCode());
  testComplete();
 }));
}
origin: eclipse-vertx/vert.x

 @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();
 }
}
origin: eclipse-vertx/vert.x

private void testHttpProxyRequest2(Function<Handler<AsyncResult<HttpClientResponse>>, HttpClientRequest> reqFact) throws Exception {
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = reqFact.apply(onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertNotNull("request did not go through proxy", proxy.getLastUri());
   assertEquals("Host header doesn't contain target host", "localhost:8080", proxy.getLastRequestHeaders().get("Host"));
   testComplete();
  }));
  req.exceptionHandler(this::fail);
  req.end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testServerOptionsCopiedBeforeUse() {
 server.close();
 HttpServerOptions options = new HttpServerOptions().setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT);
 HttpServer server = vertx.createHttpServer(options);
 // Now change something - but server should still listen at previous port
 options.setPort(DEFAULT_HTTP_PORT + 1);
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(ar -> {
  assertTrue(ar.succeeded());
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/uri", onSuccess(res -> {
   assertEquals(200, res.statusCode());
   testComplete();
  })).end();
 });
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testServerActualPortWhenSet() {
 server
   .requestHandler(request -> {
    request.response().end("hello");
   })
   .listen(ar -> {
    assertEquals(ar.result().actualPort(), DEFAULT_HTTP_PORT);
    vertx.createHttpClient(createBaseClientOptions()).getNow(ar.result().actualPort(), DEFAULT_HTTP_HOST, "/", onSuccess(response -> {
     assertEquals(response.statusCode(), 200);
     response.bodyHandler(body -> {
      assertEquals(body.toString("UTF-8"), "hello");
      testComplete();
     });
    }));
   });
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testClientOptionsCopiedBeforeUse() {
 client.close();
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(ar -> {
  assertTrue(ar.succeeded());
  HttpClientOptions options = new HttpClientOptions();
  client = vertx.createHttpClient(options);
  // Now change something - but server should ignore this
  options.setSsl(true);
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/uri", onSuccess(res -> {
   assertEquals(200, res.statusCode());
   testComplete();
  })).end();
 });
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testServerResponseWriteBufferFromOtherThread() throws Exception {
 server.requestHandler(req -> {
  runAsync(() -> {
   req.response().write("hello ").end("world");
  });
 }).listen(onSuccess(v -> {
  client.get(8080, "localhost", "/somepath", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   resp.bodyHandler(buff -> {
    assertEquals(Buffer.buffer("hello world"), buff);
    testComplete();
   });
  })).exceptionHandler(this::fail).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testServerActualPortWhenZero() {
 server = vertx.createHttpServer(createBaseServerOptions().setPort(0).setHost(DEFAULT_HTTP_HOST));
 server
   .requestHandler(request -> {
    request.response().end("hello");
   })
   .listen(ar -> {
    assertTrue(ar.result().actualPort() != 0);
    vertx.createHttpClient(createBaseClientOptions()).getNow(ar.result().actualPort(), DEFAULT_HTTP_HOST, "/", onSuccess(response -> {
     assertEquals(response.statusCode(), 200);
     response.bodyHandler(body -> {
      assertEquals(body.toString("UTF-8"), "hello");
      testComplete();
     });
    }));
   });
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testServerActualPortWhenZeroPassedInListen() {
 server = vertx.createHttpServer(new HttpServerOptions(createBaseServerOptions()).setHost(DEFAULT_HTTP_HOST));
 server
   .requestHandler(request -> {
    request.response().end("hello");
   })
   .listen(0, ar -> {
    assertTrue(ar.result().actualPort() != 0);
    vertx.createHttpClient(createBaseClientOptions()).getNow(ar.result().actualPort(), DEFAULT_HTTP_HOST, "/", onSuccess(response -> {
     assertEquals(response.statusCode(), 200);
     response.bodyHandler(body -> {
      assertEquals(body.toString("UTF-8"), "hello");
      testComplete();
     });
    }));
   });
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testSetWriteQueueMaxSize() throws Exception {
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  resp.setWriteQueueMaxSize(256 * 1024);
  // Now something bigger
  resp.setWriteQueueMaxSize(512 * 1024);
  // And something smaller again
  resp.setWriteQueueMaxSize(128 * 1024);
  resp.setWriteQueueMaxSize(129 * 1024);
  resp.end();
 }).listen(8080, onSuccess(s -> {
  client.getNow(8080, "localhost", "/", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   testComplete();
  }));
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testPutHeadersOnRequest() {
 server.requestHandler(req -> {
  assertEquals("bar", req.headers().get("foo"));
  assertEquals("bar", req.getHeader("foo"));
  req.response().end();
 });
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   testComplete();
  })).putHeader("foo", "bar").end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testHttpInvalidConnectResponseEnded() {
 waitFor(2);
 server.requestHandler(req -> {
  req.response().end();
  try {
   req.netSocket();
   fail();
  } catch (IllegalStateException e) {
   complete();
  }
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.CONNECT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   complete();
  })).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testClientMaxHeaderSizeOption() {
 String longHeader = TestUtils.randomAlphaString(9000);
 // min 9023 = 9000 for longHeader and 23 for "Content-Length: 0 t: "
 vertx.createHttpServer(new HttpServerOptions().setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT)).requestHandler(req -> {
  // Add longHeader
  req.response().putHeader("t", longHeader).end();
 }).listen(onSuccess(res -> {
  HttpClientRequest req = vertx.createHttpClient(new HttpClientOptions().setMaxHeaderSize(10000))
    .request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
     assertEquals(200, resp.statusCode());
     assertEquals(resp.getHeader("t"), longHeader);
     testComplete();
    }));
  req.end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

private void handshake(Handler<NetSocket> handler) {
 HttpClientRequest request = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/",
  onSuccess(resp -> {
   assertEquals(101, resp.statusCode());
   handler.handle(resp.netSocket());
  })
 );
 request
  .putHeader("Upgrade", "websocket")
  .putHeader("Connection", "Upgrade")
  .putHeader("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==")
  .putHeader("Sec-WebSocket-Protocol", "chat")
  .putHeader("Sec-WebSocket-Version", "13")
  .putHeader("Origin", "http://example.com");
 request.end();
}
origin: eclipse-vertx/vert.x

@Test
public void testClientLocalAddress() throws Exception {
 String expectedAddress = TestUtils.loopbackAddress();
 client.close();
 client = vertx.createHttpClient(createBaseClientOptions().setLocalAddress(expectedAddress));
 server.requestHandler(req -> {
  assertEquals(expectedAddress, req.remoteAddress().host());
  req.response().end();
 });
 startServer();
 client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
  assertEquals(200, resp.statusCode());
  testComplete();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testHttpInvalidConnectResponseChunked() {
 waitFor(2);
 server.requestHandler(req -> {
  req.response().setChunked(true).write("some-chunk");
  try {
   req.netSocket();
   fail();
  } catch (IllegalStateException e) {
   complete();
  }
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.CONNECT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   complete();
  })).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testRequestEntityTooLarge() {
 String path = "/some/path";
 server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> fail());
 server.listen(onSuccess(ar -> {
  client.get(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTPS_HOST, path, onSuccess(resp -> {
   assertEquals(413, resp.statusCode());
   resp.request().connection().closeHandler(v -> {
    testComplete();
   });
  })).putHeader("Upgrade", "Websocket")
   .putHeader("Connection", "Upgrade")
   .end(TestUtils.randomBuffer(8192 + 1));
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testHttpSocksProxyRequest() throws Exception {
 startProxy(null, ProxyType.SOCKS5);
 client.close();
 client = vertx.createHttpClient(new HttpClientOptions()
   .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS5).setHost("localhost").setPort(proxy.getPort())));
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertNotNull("request did not go through proxy", proxy.getLastUri());
   testComplete();
  })).exceptionHandler(th -> fail(th)).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testHttpSocksProxyRequestAuth() throws Exception {
 startProxy("user", ProxyType.SOCKS5);
 client.close();
 client = vertx.createHttpClient(new HttpClientOptions()
   .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS5).setHost("localhost").setPort(proxy.getPort())
     .setUsername("user").setPassword("user")));
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertNotNull("request did not go through proxy", proxy.getLastUri());
   testComplete();
  })).exceptionHandler(th -> fail(th)).end();
 }));
 await();
}
origin: eclipse-vertx/vert.x

@Test
public void testHttpProxyRequestAuth() throws Exception {
 startProxy("user", ProxyType.HTTP);
 client.close();
 client = vertx.createHttpClient(new HttpClientOptions()
   .setProxyOptions(new ProxyOptions().setType(ProxyType.HTTP).setHost("localhost").setPort(proxy.getPort())
     .setUsername("user").setPassword("user")));
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertNotNull("request did not go through proxy", proxy.getLastUri());
   assertEquals("Host header doesn't contain target host", "localhost:8080", proxy.getLastRequestHeaders().get("Host"));
   testComplete();
  })).exceptionHandler(th -> fail(th)).end();
 }));
 await();
}
io.vertx.core.httpHttpClientResponsestatusCode

Popular methods of HttpClientResponse

  • bodyHandler
    Convenience method for receiving the entire request body in one piece. This saves you having to manu
  • statusMessage
  • headers
  • exceptionHandler
  • endHandler
  • getHeader
    Return the first header value with the specified name
  • handler
  • pause
  • resume
  • request
  • cookies
  • netSocket
    Get a net socket for the underlying connection of this request. USE THIS WITH CAUTION! Writing to th
  • cookies,
  • netSocket,
  • version,
  • customFrameHandler,
  • getTrailer,
  • streamPriorityHandler,
  • trailers,
  • fetch

Popular in Java

  • Reading from database using SQL prepared statement
  • setContentView (Activity)
  • getApplicationContext (Context)
  • getSharedPreferences (Context)
  • KeyStore (java.security)
    KeyStore is responsible for maintaining cryptographic keys and their owners. The type of the syste
  • PriorityQueue (java.util)
    A PriorityQueue holds elements on a priority heap, which orders the elements according to their natu
  • UUID (java.util)
    UUID is an immutable representation of a 128-bit universally unique identifier (UUID). There are mul
  • Callable (java.util.concurrent)
    A task that returns a result and may throw an exception. Implementors define a single method with no
  • Scheduler (org.quartz)
    This is the main interface of a Quartz Scheduler. A Scheduler maintains a registry of org.quartz.Job
  • Location (org.springframework.beans.factory.parsing)
    Class that models an arbitrary location in a Resource.Typically used to track the location of proble
  • Best IntelliJ plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now