Examples with HttpClientRequest io.vertx.core.http.HttpClientRequest used on opensource projects

Example 86 with HttpClientRequest

use of io.vertx.core.http.HttpClientRequest in project vert.x by eclipse.

the class HttpTest method testSimpleRequest.

private void testSimpleRequest(String uri, HttpMethod method, boolean absolute, Handler<HttpClientResponse> handler) {
    HttpClientRequest req;
    if (absolute) {
        req = client.requestAbs(method, "http://" + DEFAULT_HTTP_HOST + ":" + DEFAULT_HTTP_PORT + uri, handler);
    } else {
        req = client.request(method, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, uri, handler);
    }
    testSimpleRequest(uri, method, req);
}

Example 87 with HttpClientRequest

use of io.vertx.core.http.HttpClientRequest in project vert.x by eclipse.

the class HttpTest method testRequestBodyWrite.

private void testRequestBodyWrite(boolean chunked) {
    Buffer body = Buffer.buffer();
    server.requestHandler(req -> {
        req.bodyHandler(buffer -> {
            assertEquals(body, buffer);
            req.response().end();
        });
    });
    server.listen(onSuccess(server -> {
        HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete());
        int numWrites = 10;
        int chunkSize = 100;
        if (chunked) {
            req.setChunked(true);
        } else {
            req.headers().set("Content-Length", String.valueOf(numWrites * chunkSize));
        }
        for (int i = 0; i < numWrites; i++) {
            Buffer b = TestUtils.randomBuffer(chunkSize);
            body.appendBuffer(b);
            req.write(b);
        }
        req.end();
    }));
    await();
}

Example 88 with HttpClientRequest

use of io.vertx.core.http.HttpClientRequest in project vert.x by eclipse.

the class HttpTest method testServerConnectionClose.

@Test
public void testServerConnectionClose() throws Exception {
    // Test server connection close + client close handler
    server.requestHandler(req -> {
        req.connection().close();
    });
    CountDownLatch listenLatch = new CountDownLatch(1);
    server.listen(onSuccess(s -> listenLatch.countDown()));
    awaitLatch(listenLatch);
    HttpClientRequest req = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> {
        fail();
    });
    req.connectionHandler(conn -> {
        conn.closeHandler(v -> {
            testComplete();
        });
    });
    req.sendHead();
    await();
}

Example 89 with HttpClientRequest

use of io.vertx.core.http.HttpClientRequest in project vert.x by eclipse.

the class HttpTest method testFollowRedirectWithRequestNotEnded.

private void testFollowRedirectWithRequestNotEnded(boolean expectFail) throws Exception {
    Buffer buff1 = Buffer.buffer(TestUtils.randomAlphaString(2048));
    Buffer buff2 = Buffer.buffer(TestUtils.randomAlphaString(2048));
    Buffer expected = Buffer.buffer().appendBuffer(buff1).appendBuffer(buff2);
    AtomicBoolean redirected = new AtomicBoolean();
    CountDownLatch latch = new CountDownLatch(1);
    server.requestHandler(req -> {
        boolean redirect = redirected.compareAndSet(false, true);
        if (redirect) {
            Buffer body = Buffer.buffer();
            req.handler(buff -> {
                if (body.length() == 0) {
                    HttpServerResponse resp = req.response();
                    resp.setStatusCode(307).putHeader(HttpHeaders.LOCATION, "http://localhost:8080/whatever");
                    if (expectFail) {
                        resp.setChunked(true).write("whatever");
                        vertx.runOnContext(v -> {
                            resp.close();
                        });
                    } else {
                        resp.end();
                    }
                    latch.countDown();
                }
                body.appendBuffer(buff);
            });
            req.endHandler(v -> {
                assertEquals(expected, body);
            });
        } else {
            req.response().end();
        }
    });
    startServer();
    AtomicBoolean called = new AtomicBoolean();
    HttpClientRequest req = client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> {
        assertEquals(200, resp.statusCode());
        testComplete();
    }).setFollowRedirects(true).exceptionHandler(err -> {
        if (expectFail) {
            if (called.compareAndSet(false, true)) {
                testComplete();
            }
        } else {
            fail(err);
        }
    }).setChunked(true).write(buff1);
    awaitLatch(latch);
    // Wait so we end the request while having received the server response (but we can't be notified)
    if (!expectFail) {
        Thread.sleep(500);
        req.end(buff2);
    }
    await();
}

Example 90 with HttpClientRequest

use of io.vertx.core.http.HttpClientRequest in project vert.x by eclipse.

the class HttpTest method testFoo.

private void testFoo(String location, String expected) throws Exception {
    int status = 301;
    Map<String, String> headers = Collections.singletonMap("Location", location);
    HttpMethod method = HttpMethod.GET;
    String baseURI = "https://localhost:8080";
    class MockReq implements HttpClientRequest {

        public HttpClientRequest exceptionHandler(Handler<Throwable> handler) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest write(Buffer data) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest setWriteQueueMaxSize(int maxSize) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest drainHandler(Handler<Void> handler) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest handler(Handler<HttpClientResponse> handler) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest pause() {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest resume() {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest endHandler(Handler<Void> endHandler) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest setFollowRedirects(boolean followRedirects) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest setChunked(boolean chunked) {
            throw new UnsupportedOperationException();
        }

        public boolean isChunked() {
            return false;
        }

        public HttpMethod method() {
            return method;
        }

        public String getRawMethod() {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest setRawMethod(String method) {
            throw new UnsupportedOperationException();
        }

        public String absoluteURI() {
            return baseURI;
        }

        public String uri() {
            throw new UnsupportedOperationException();
        }

        public String path() {
            throw new UnsupportedOperationException();
        }

        public String query() {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest setHost(String host) {
            throw new UnsupportedOperationException();
        }

        public String getHost() {
            throw new UnsupportedOperationException();
        }

        public MultiMap headers() {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest putHeader(String name, String value) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest putHeader(CharSequence name, CharSequence value) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest putHeader(String name, Iterable<String> values) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest putHeader(CharSequence name, Iterable<CharSequence> values) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest write(String chunk) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest write(String chunk, String enc) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest continueHandler(@Nullable Handler<Void> handler) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest sendHead() {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest sendHead(Handler<HttpVersion> completionHandler) {
            throw new UnsupportedOperationException();
        }

        public void end(String chunk) {
            throw new UnsupportedOperationException();
        }

        public void end(String chunk, String enc) {
            throw new UnsupportedOperationException();
        }

        public void end(Buffer chunk) {
            throw new UnsupportedOperationException();
        }

        public void end() {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest setTimeout(long timeoutMs) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest pushHandler(Handler<HttpClientRequest> handler) {
            throw new UnsupportedOperationException();
        }

        public boolean reset(long code) {
            return false;
        }

        public HttpConnection connection() {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest connectionHandler(@Nullable Handler<HttpConnection> handler) {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest writeCustomFrame(int type, int flags, Buffer payload) {
            throw new UnsupportedOperationException();
        }

        public boolean writeQueueFull() {
            throw new UnsupportedOperationException();
        }
    }
    HttpClientRequest req = new MockReq();
    class MockResp implements HttpClientResponse {

        public HttpClientResponse resume() {
            throw new UnsupportedOperationException();
        }

        public HttpClientResponse exceptionHandler(Handler<Throwable> handler) {
            throw new UnsupportedOperationException();
        }

        public HttpClientResponse handler(Handler<Buffer> handler) {
            throw new UnsupportedOperationException();
        }

        public HttpClientResponse pause() {
            throw new UnsupportedOperationException();
        }

        public HttpClientResponse endHandler(Handler<Void> endHandler) {
            throw new UnsupportedOperationException();
        }

        public HttpVersion version() {
            throw new UnsupportedOperationException();
        }

        public int statusCode() {
            return status;
        }

        public String statusMessage() {
            throw new UnsupportedOperationException();
        }

        public MultiMap headers() {
            throw new UnsupportedOperationException();
        }

        public String getHeader(String headerName) {
            return headers.get(headerName);
        }

        public String getHeader(CharSequence headerName) {
            return getHeader(headerName.toString());
        }

        public String getTrailer(String trailerName) {
            throw new UnsupportedOperationException();
        }

        public MultiMap trailers() {
            throw new UnsupportedOperationException();
        }

        public List<String> cookies() {
            throw new UnsupportedOperationException();
        }

        public HttpClientResponse bodyHandler(Handler<Buffer> bodyHandler) {
            throw new UnsupportedOperationException();
        }

        public HttpClientResponse customFrameHandler(Handler<HttpFrame> handler) {
            throw new UnsupportedOperationException();
        }

        public NetSocket netSocket() {
            throw new UnsupportedOperationException();
        }

        public HttpClientRequest request() {
            return req;
        }
    }
    MockResp resp = new MockResp();
    Function<HttpClientResponse, Future<HttpClientRequest>> handler = client.redirectHandler();
    Future<HttpClientRequest> redirection = handler.apply(resp);
    if (expected != null) {
        assertEquals(location, redirection.result().absoluteURI());
    } else {
        assertTrue(redirection == null || redirection.failed());
    }
}