Examples with DEFAULT_HTTP_PORT io.vertx.core.http.HttpTestBase.DEFAULT_HTTP_PORT used on opensource projects

Example 11 with DEFAULT_HTTP_PORT

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

the class WebSocketTest method testAsyncAccept.

@Test
public void testAsyncAccept() {
    AtomicBoolean resolved = new AtomicBoolean();
    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).webSocketHandler(ws -> {
        Promise<Integer> promise = Promise.promise();
        ws.setHandshake(promise.future());
        try {
            ws.accept();
            fail();
        } catch (IllegalStateException ignore) {
        // Expected
        }
        try {
            ws.writeTextMessage("hello");
            fail();
        } catch (IllegalStateException ignore) {
        // Expected
        }
        vertx.setTimer(500, id -> {
            resolved.set(true);
            promise.complete(101);
        });
    });
    server.listen(onSuccess(s -> {
        client = vertx.createHttpClient();
        client.webSocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/some/path", onSuccess(ws -> {
            assertTrue(resolved.get());
            testComplete();
        }));
    }));
    await();
}

Example 12 with DEFAULT_HTTP_PORT

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

the class WebSocketTest method testPausedDuringClose.

@Test
public void testPausedDuringClose() {
    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).webSocketHandler(ws -> {
        AtomicBoolean paused = new AtomicBoolean(true);
        ws.pause();
        ws.closeHandler(v1 -> {
            paused.set(false);
            vertx.runOnContext(v2 -> {
                ws.resume();
            });
        });
        ws.endHandler(v -> {
            assertFalse(paused.get());
            testComplete();
        });
    }).listen(onSuccess(v -> {
        client = vertx.createHttpClient();
        client.webSocket(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", onSuccess(ws -> {
            ws.close();
        }));
    }));
    await();
}

Example 13 with DEFAULT_HTTP_PORT

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

the class WebSocketTest method testNormalWSDeflateFrameCompressionNegotiation.

@Test
public // Test normal negotiation of WebSocket compression
void testNormalWSDeflateFrameCompressionNegotiation() throws Exception {
    String path = "/some/path";
    Buffer buff = Buffer.buffer("AAA");
    // Server should have basic compression enabled by default,
    // client needs to ask for it
    server = vertx.createHttpServer(new HttpServerOptions().setPort(HttpTestBase.DEFAULT_HTTP_PORT)).webSocketHandler(ws -> {
        assertEquals("upgrade", ws.headers().get("Connection"));
        assertEquals("deflate-frame", ws.headers().get("sec-websocket-extensions"));
        ws.writeFrame(WebSocketFrame.binaryFrame(buff, true));
    });
    server.listen(ar -> {
        assertTrue(ar.succeeded());
        HttpClientOptions options = new HttpClientOptions();
        options.setTryUsePerFrameWebSocketCompression(true);
        client = vertx.createHttpClient(options);
        client.webSocket(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, path, onSuccess(ws -> {
            final Buffer received = Buffer.buffer();
            ws.handler(data -> {
                received.appendBuffer(data);
                if (received.length() == buff.length()) {
                    assertEquals(buff, received);
                    ws.close();
                    testComplete();
                }
            });
        }));
    });
    await();
}

Example 14 with DEFAULT_HTTP_PORT

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

the class WebSocketTest method testWriteMessage.

private void testWriteMessage(int size, WebsocketVersion version) {
    client = vertx.createHttpClient();
    waitFor(2);
    String path = "/some/path";
    byte[] expected = TestUtils.randomByteArray(size);
    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).webSocketHandler(ws -> {
        AtomicInteger count = new AtomicInteger();
        ws.writeBinaryMessage(Buffer.buffer(expected), onSuccess(v -> {
            assertEquals(1, count.incrementAndGet());
            complete();
        }));
        ws.close();
    });
    server.listen(onSuccess(s -> {
        WebSocketConnectOptions options = new WebSocketConnectOptions().setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT).setURI(path).setVersion(version);
        client.webSocket(options, onSuccess(ws -> {
            Buffer actual = Buffer.buffer();
            ws.handler(actual::appendBuffer);
            ws.closeHandler(v -> {
                assertArrayEquals(expected, actual.getBytes(0, actual.length()));
                complete();
            });
        }));
    }));
    await();
}

Example 15 with DEFAULT_HTTP_PORT

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

the class WebSocketTest method testWriteFinalFrame.

private void testWriteFinalFrame(boolean binary) throws Exception {
    waitFor(2);
    String text = TestUtils.randomUnicodeString(100);
    Buffer data = TestUtils.randomBuffer(100);
    Consumer<WebSocketFrame> frameConsumer = frame -> {
        if (binary) {
            assertTrue(frame.isBinary());
            assertFalse(frame.isText());
            assertEquals(data, frame.binaryData());
        } else {
            assertFalse(frame.isBinary());
            assertTrue(frame.isText());
            assertEquals(text, frame.textData());
        }
        assertTrue(frame.isFinal());
    };
    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).webSocketHandler(ws -> ws.frameHandler(frame -> {
        if (frame.isClose()) {
            complete();
        } else {
            frameConsumer.accept(frame);
            if (binary) {
                ws.writeFinalBinaryFrame(frame.binaryData());
            } else {
                ws.writeFinalTextFrame(frame.textData());
            }
        }
    }));
    server.listen(onSuccess(s -> {
        client = vertx.createHttpClient();
        client.webSocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", onSuccess(ws -> {
            ws.frameHandler(frame -> {
                if (frame.isClose()) {
                    complete();
                } else {
                    frameConsumer.accept(frame);
                    ws.close();
                }
            });
            if (binary) {
                ws.writeFinalBinaryFrame(data);
            } else {
                ws.writeFinalTextFrame(text);
            }
        }));
    }));
    await();
}