Skip to content

Commit 29ebcb1

Browse files
vietjvietj
committed
Improve a few things in the HTTP tls tests
- creation of base options should be achieved in create base options methods for each protocol - SSL options update tests are actually not configured for HTTP/2
1 parent 433d282 commit 29ebcb1

File tree

3 files changed

+72
-57
lines changed

3 files changed

+72
-57
lines changed

‎src/test/java/io/vertx/core/http/Http1xTLSTest.java‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -13,9 +13,7 @@
1313

1414
import io.netty.buffer.ByteBufUtil;
1515
import io.vertx.core.AbstractVerticle;
16-
import io.vertx.core.CompositeFuture;
1716
import io.vertx.core.DeploymentOptions;
18-
import io.vertx.core.Future;
1917
import io.vertx.core.Promise;
2018
import io.vertx.core.VertxOptions;
2119
import io.vertx.test.tls.Cert;
@@ -29,7 +27,6 @@
2927
import java.util.HashSet;
3028
import java.util.List;
3129
import java.util.concurrent.CountDownLatch;
32-
import java.util.concurrent.TimeUnit;
3330
import java.util.concurrent.atomic.AtomicInteger;
3431
import java.util.stream.Collectors;
3532

@@ -39,17 +36,20 @@
3936
public class Http1xTLSTest extends HttpTLSTest {
4037

4138
@Override
42-
HttpServer createHttpServer(HttpServerOptions options) {
43-
return vertx.createHttpServer(options);
44-
}
39+
protected HttpServerOptions createBaseServerOptions() {
40+
return new HttpServerOptions()
41+
.setPort(HttpTestBase.DEFAULT_HTTPS_PORT)
42+
.setSsl(true);
43+
};
4544

4645
@Override
47-
HttpClient createHttpClient(HttpClientOptions options) {
48-
return vertx.createHttpClient(options);
46+
protected HttpClientOptions createBaseClientOptions() {
47+
return new HttpClientOptions()
48+
.setSsl(true)
49+
.setProtocolVersion(HttpVersion.HTTP_1_1);
4950
}
5051

51-
52-
// ALPN tests
52+
// ALPN tests
5353

5454
@Test
5555
// Client and server uses ALPN

‎src/test/java/io/vertx/core/http/Http2TLSTest.java‎

Lines changed: 10 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -20,13 +20,19 @@
2020
public class Http2TLSTest extends HttpTLSTest {
2121

2222
@Override
23-
HttpServer createHttpServer(HttpServerOptions options) {
24-
return vertx.createHttpServer(options.setUseAlpn(true));
23+
protected HttpServerOptions createBaseServerOptions() {
24+
return new HttpServerOptions()
25+
.setPort(HttpTestBase.DEFAULT_HTTPS_PORT)
26+
.setUseAlpn(true)
27+
.setSsl(true);
2528
}
2629

2730
@Override
28-
HttpClient createHttpClient(HttpClientOptions options) {
29-
return vertx.createHttpClient(options.setUseAlpn(true));
31+
protected HttpClientOptions createBaseClientOptions() {
32+
return new HttpClientOptions()
33+
.setUseAlpn(true)
34+
.setSsl(true)
35+
.setProtocolVersion(HttpVersion.HTTP_2);
3036
}
3137

3238
@Override

‎src/test/java/io/vertx/core/http/HttpTLSTest.java‎

Lines changed: 52 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -978,7 +978,7 @@ class TLSTest {
978978
TrustOptions serverTrust;
979979
boolean serverUsesCrl;
980980
boolean serverOpenSSL;
981-
boolean serverUsesAlpn;
981+
Boolean serverUsesAlpn;
982982
boolean serverSSL = true;
983983
boolean serverUsesProxyProtocol = false;
984984
ProxyType proxyType;
@@ -1175,8 +1175,7 @@ TLSTest run(boolean shouldPass) {
11751175
// The test with proxy that fails will not connect
11761176
waitFor(2);
11771177
}
1178-
server.close();
1179-
HttpClientOptions options = new HttpClientOptions();
1178+
HttpClientOptions options = createBaseClientOptions();
11801179
options.setProtocolVersion(version);
11811180
options.setSsl(clientSSL);
11821181
options.setForceSni(clientForceSNI);
@@ -1218,8 +1217,8 @@ TLSTest run(boolean shouldPass) {
12181217
}
12191218
options.setProxyOptions(proxyOptions);
12201219
}
1221-
client = createHttpClient(options);
1222-
HttpServerOptions serverOptions = new HttpServerOptions();
1220+
client = vertx.createHttpClient(options);
1221+
HttpServerOptions serverOptions = createBaseServerOptions();
12231222
serverOptions.setTrustOptions(serverTrust);
12241223
serverOptions.setKeyCertOptions(serverCert);
12251224
if (requiresClientAuth) {
@@ -1231,7 +1230,9 @@ TLSTest run(boolean shouldPass) {
12311230
if (serverOpenSSL) {
12321231
serverOptions.setOpenSslEngineOptions(new OpenSSLEngineOptions());
12331232
}
1234-
serverOptions.setUseAlpn(serverUsesAlpn);
1233+
if (serverUsesAlpn == Boolean.TRUE) {
1234+
serverOptions.setUseAlpn(serverUsesAlpn);
1235+
}
12351236
serverOptions.setSsl(serverSSL);
12361237
serverOptions.setSni(serverSNI);
12371238
serverOptions.setUseProxyProtocol(serverUsesProxyProtocol);
@@ -1244,7 +1245,8 @@ TLSTest run(boolean shouldPass) {
12441245
for (String protocol : serverEnabledSecureTransportProtocol) {
12451246
serverOptions.addEnabledSecureTransportProtocol(protocol);
12461247
}
1247-
server = createHttpServer(serverOptions.setPort(4043));
1248+
server.close();
1249+
server = vertx.createHttpServer(serverOptions.setPort(4043));
12481250
server.connectionHandler(conn -> complete());
12491251
AtomicInteger count = new AtomicInteger();
12501252
server.exceptionHandler(err -> {
@@ -1318,10 +1320,6 @@ TLSTest run(boolean shouldPass) {
13181320
}
13191321
}
13201322

1321-
abstract HttpServer createHttpServer(HttpServerOptions options);
1322-
1323-
abstract HttpClient createHttpClient(HttpClientOptions options);
1324-
13251323
protected TLSTest testTLS(Cert<?> clientCert, Trust<?> clientTrust,
13261324
Cert<?> serverCert, Trust<?> serverTrust) throws Exception {
13271325
return new TLSTest(clientCert, clientTrust, serverCert, serverTrust);
@@ -1502,7 +1500,7 @@ private void testStore(HttpServerOptions serverOptions, List<String> expectedPos
15021500

15031501
@Test
15041502
public void testCrlInvalidPath() {
1505-
HttpClientOptions clientOptions = new HttpClientOptions();
1503+
HttpClientOptions clientOptions = createBaseClientOptions();
15061504
clientOptions.setTrustOptions(Trust.SERVER_PEM_ROOT_CA.get());
15071505
clientOptions.setSsl(true);
15081506
clientOptions.addCrlPath("/invalid.pem");
@@ -1648,7 +1646,7 @@ public void testUpdateSSLOptionsWithScaledServer() throws Exception {
16481646
}
16491647

16501648
private void testUpdateSSLOptions(boolean scaled) throws Exception {
1651-
server = createHttpServer(createBaseServerOptions().setSsl(true).setKeyCertOptions(Cert.SERVER_JKS.get()))
1649+
server = vertx.createHttpServer(createBaseServerOptions().setSsl(true).setKeyCertOptions(Cert.SERVER_JKS.get()))
16521650
.requestHandler(req -> {
16531651
req.response().end("Hello World");
16541652
});
@@ -1659,7 +1657,7 @@ private void testUpdateSSLOptions(boolean scaled) throws Exception {
16591657
private HttpServer server;
16601658
@Override
16611659
public void start(Promise<Void> startPromise) {
1662-
server = createHttpServer(createBaseServerOptions().setSsl(true).setKeyCertOptions(Cert.SERVER_JKS.get()))
1660+
server = vertx.createHttpServer(createBaseServerOptions().setKeyCertOptions(Cert.SERVER_JKS.get()))
16631661
.requestHandler(req -> {
16641662
req.response().end("Hello World");
16651663
});
@@ -1671,14 +1669,15 @@ public void start(Promise<Void> startPromise) {
16711669
}).onComplete(onSuccess(v -> latch.countDown()));
16721670
awaitLatch(latch);
16731671
}
1674-
Supplier<Future<Buffer>> request = () -> client.request(requestOptions).compose(req -> req.send().compose(HttpClientResponse::body));
1675-
client = createHttpClient(new HttpClientOptions().setKeepAlive(false).setSsl(true).setTrustOptions(Trust.SERVER_JKS.get()));
1676-
request.get().onComplete(onSuccess(body1 -> {
1672+
Function<HttpClient, Future<Buffer>> request = client -> client.request(requestOptions).compose(req -> req.send().compose(HttpClientResponse::body));
1673+
HttpClient client1 = vertx.createHttpClient(createBaseClientOptions().setVerifyHost(false).setTrustOptions(Trust.SERVER_JKS.get()));
1674+
HttpClient client2 = vertx.createHttpClient(createBaseClientOptions().setVerifyHost(false).setTrustOptions(Trust.SERVER_JKS.get()));
1675+
request.apply(client1).onComplete(onSuccess(body1 -> {
16771676
assertEquals("Hello World", body1.toString());
1678-
server.updateSSLOptions(new SSLOptions().setKeyCertOptions(Cert.SERVER_JKS_ROOT_CA.get()), onSuccess(v -> {
1679-
request.get().onComplete(onFailure(err -> {
1680-
client.updateSSLOptions(new SSLOptions().setTrustOptions(Trust.SERVER_JKS_ROOT_CA.get()), onSuccess(v2 -> {
1681-
request.get().onComplete(onSuccess(body2 -> {
1677+
server.updateSSLOptions(createBaseServerOptions().setKeyCertOptions(Cert.SERVER_JKS_ROOT_CA.get()).getSslOptions()).onComplete(onSuccess(v -> {
1678+
request.apply(client2).onComplete(onFailure(err -> {
1679+
client2.updateSSLOptions(createBaseClientOptions().setTrustOptions(Trust.SERVER_JKS_ROOT_CA.get()).getSslOptions()).onComplete(onSuccess(v2 -> {
1680+
request.apply(client2).onComplete(onSuccess(body2 -> {
16821681
assertEquals("Hello World", body2.toString());
16831682
testComplete();
16841683
}));
@@ -1691,13 +1690,15 @@ public void start(Promise<Void> startPromise) {
16911690

16921691
@Test
16931692
public void testUpdateWithInvalidSSLOptions() throws Exception {
1694-
server = createHttpServer(createBaseServerOptions().setSsl(true).setKeyCertOptions(Cert.SERVER_JKS.get()))
1693+
server = vertx.createHttpServer(createBaseServerOptions().setKeyCertOptions(Cert.SERVER_JKS.get()))
16951694
.requestHandler(req -> {
16961695
req.response().end("Hello World");
16971696
});
16981697
startServer(testAddress);
1699-
client = createHttpClient(new HttpClientOptions().setKeepAlive(false).setSsl(true).setTrustOptions(Trust.SERVER_JKS.get()));
1700-
Future<Void> last = server.updateSSLOptions(new SSLOptions().setKeyCertOptions(new JksOptions().setValue(TestUtils.randomBuffer(20)).setPassword("invalid")));
1698+
client = vertx.createHttpClient(createBaseClientOptions().setVerifyHost(false).setTrustOptions(Trust.SERVER_JKS.get()));
1699+
Future<Void> last = server.updateSSLOptions(createBaseServerOptions()
1700+
.setKeyCertOptions(new JksOptions().setValue(TestUtils.randomBuffer(20)).setPassword("invalid"))
1701+
.getSslOptions());
17011702
last.onComplete(onFailure(err -> {
17021703
client
17031704
.request(requestOptions)
@@ -1712,12 +1713,12 @@ public void testUpdateWithInvalidSSLOptions() throws Exception {
17121713

17131714
@Test
17141715
public void testConcurrentUpdateSSLOptions() throws Exception {
1715-
server = createHttpServer(createBaseServerOptions().setSsl(true).setKeyCertOptions(Cert.SERVER_JKS.get()))
1716+
server = vertx.createHttpServer(createBaseServerOptions().setKeyCertOptions(Cert.SERVER_JKS.get()))
17161717
.requestHandler(req -> {
17171718
req.response().end("Hello World");
17181719
});
17191720
startServer(testAddress);
1720-
client = createHttpClient(new HttpClientOptions().setKeepAlive(false).setSsl(true).setTrustOptions(Trust.SERVER_JKS_ROOT_CA.get()));
1721+
client = vertx.createHttpClient(createBaseClientOptions().setKeepAlive(false).setVerifyHost(false).setTrustOptions(Trust.SERVER_JKS_ROOT_CA.get()));
17211722
List<KeyCertOptions> list = Arrays.asList(
17221723
Cert.SERVER_PKCS12.get(),
17231724
Cert.SERVER_PEM.get(),
@@ -1727,7 +1728,7 @@ public void testConcurrentUpdateSSLOptions() throws Exception {
17271728
Future<Void> last = null;
17281729
for (int i = 0;i < list.size();i++) {
17291730
int val = i;
1730-
last = server.updateSSLOptions(new SSLOptions().setKeyCertOptions(list.get(i)));
1731+
last = server.updateSSLOptions(createBaseServerOptions().setKeyCertOptions(list.get(i)).getSslOptions());
17311732
last.onComplete(onSuccess(v -> {
17321733
assertEquals(val, seq.getAndIncrement());
17331734
}));
@@ -1746,28 +1747,33 @@ public void testConcurrentUpdateSSLOptions() throws Exception {
17461747

17471748
@Test
17481749
public void testServerSharingUpdateSSLOptions() throws Exception {
1749-
int numServers = 4;
1750-
HttpServer[] servers = new HttpServer[numServers];
1751-
for (int i = 0;i < numServers;i++) {
1750+
int num = 4;
1751+
HttpServer[] servers = new HttpServer[num];
1752+
for (int i = 0;i < num;i++) {
17521753
String msg = "Hello World " + i;
1753-
servers[i] = createHttpServer(createBaseServerOptions().setSsl(true).setKeyCertOptions(Cert.SERVER_JKS.get()))
1754+
servers[i] = vertx.createHttpServer(createBaseServerOptions().setKeyCertOptions(Cert.SERVER_JKS.get()))
17541755
.requestHandler(req -> {
17551756
req.response().end(msg);
17561757
});
17571758
servers[i].listen(testAddress).toCompletionStage().toCompletableFuture().get();
17581759
}
1759-
client = createHttpClient(new HttpClientOptions().setKeepAlive(false).setSsl(true).setTrustOptions(Trust.SERVER_JKS.get()));
1760-
for (int i = 0;i < numServers;i++) {
1761-
Buffer body = client.request(requestOptions).compose(req -> req.send().compose(HttpClientResponse::body)).toCompletionStage().toCompletableFuture().get();
1760+
HttpClient[] clients = new HttpClient[num];
1761+
for (int i = 0;i < num;i++) {
1762+
clients[i] = vertx.createHttpClient(createBaseClientOptions().setVerifyHost(false).setTrustOptions(Trust.SERVER_JKS.get()));
1763+
}
1764+
for (int i = 0;i < num;i++) {
1765+
Buffer body = clients[i].request(requestOptions).compose(req -> req.send().compose(HttpClientResponse::body)).toCompletionStage().toCompletableFuture().get();
17621766
assertEquals("Hello World " + i, body.toString());
17631767
}
1764-
client.close();
1765-
for (int i = 0;i < numServers;i++) {
1766-
servers[i].updateSSLOptions(new SSLOptions().setKeyCertOptions(Cert.SERVER_PKCS12.get())).toCompletionStage().toCompletableFuture().get();
1768+
for (int i = 0;i < num;i++) {
1769+
servers[i].updateSSLOptions(createBaseServerOptions().setKeyCertOptions(Cert.SERVER_PKCS12.get()).getSslOptions()).toCompletionStage().toCompletableFuture().get();
1770+
}
1771+
for (int i = 0;i < num;i++) {
1772+
clients[i].close();
1773+
clients[i] = vertx.createHttpClient(createBaseClientOptions().setVerifyHost(false).setTrustOptions(Trust.SERVER_JKS.get()));
17671774
}
1768-
client = createHttpClient(new HttpClientOptions().setKeepAlive(false).setSsl(true).setTrustOptions(Trust.SERVER_PKCS12.get()));
1769-
for (int i = 0;i < numServers;i++) {
1770-
Buffer body = client.request(requestOptions).compose(req -> req.send().compose(HttpClientResponse::body)).toCompletionStage().toCompletableFuture().get();
1775+
for (int i = 0;i < num;i++) {
1776+
Buffer body = clients[i].request(requestOptions).compose(req -> req.send().compose(HttpClientResponse::body)).toCompletionStage().toCompletableFuture().get();
17711777
assertEquals("Hello World " + i, body.toString());
17721778
}
17731779
}
@@ -1977,9 +1983,8 @@ public PrivateKey getPrivateKey(String alias) {
19771983
}
19781984
};
19791985

1980-
server = createHttpServer(createBaseServerOptions()
1986+
server = vertx.createHttpServer(createBaseServerOptions()
19811987
.setJdkSslEngineOptions(new JdkSSLEngineOptions().setUseWorkerThread(useWorkerThreads))
1982-
.setSsl(true)
19831988
.setSni(useSni)
19841989
.setKeyCertOptions(testOptions)
19851990
)
@@ -1998,7 +2003,11 @@ public PrivateKey getPrivateKey(String alias) {
19982003
);
19992004
};
20002005
CountDownLatch latch = new CountDownLatch(1);
2001-
client = createHttpClient(new HttpClientOptions().setKeepAlive(false).setSsl(true).setTrustAll(true));
2006+
client = vertx.createHttpClient(createBaseClientOptions()
2007+
.setKeepAlive(false)
2008+
.setVerifyHost(false)
2009+
.setTrustAll(true)
2010+
);
20022011
request.get().onComplete(onSuccess(body1 -> {
20032012
assertEquals("Hello World", body1.toString());
20042013
latch.countDown();

0 commit comments

Comments
 (0)