mustFailHandshakePromiseIfResumeClientTrustedThrows() — netty Function Reference

Source Code

handler/src/test/java/io/netty/handler/ssl/SSLEngineTest.java lines 4011–4075

    @Timeout(value = 60, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
    @MethodSource("newTestParams")
    @ParameterizedTest
    void mustFailHandshakePromiseIfResumeClientTrustedThrows(SSLEngineTestParam param) throws Exception {
        final AtomicInteger checkClientTrustedCount = new AtomicInteger();
        SelfSignedCertificate ssc = CachedSelfSignedCertificate.getCachedCertificate();
        SessionValueSettingTrustManager clientTm = new SessionValueSettingTrustManager("key", "client");
        SessionValueSettingTrustManager serverTm = new SessionValueSettingTrustManager("key", "server") {
            @Override
            public void checkClientTrusted(
                    java.security.cert.X509Certificate[] chain, String authType, SSLEngine engine)
                    throws CertificateException {
                checkClientTrustedCount.incrementAndGet();
                super.checkClientTrusted(chain, authType, engine);
            }

            @Override
            public void resumeClientTrusted(java.security.cert.X509Certificate[] chain, SSLEngine engine)
                    throws CertificateException {
                throw new CertificateException("Test exception");
            }
        };
        buildClientSslContextForMTLS(param, ssc, clientTm);
        buildServerSslContextForMTLS(param, ssc, serverTm);
        OnNextMessage checkServer = new OnNextMessage() {
            @Override
            public void messageReceived(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
                ctx.writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
            }
        };

        setupServer(param.type(), param.delegate());
        InetSocketAddress addr = (InetSocketAddress) serverChannel.localAddress();
        setupClient(param.type(), param.delegate(), "a.netty.io", addr.getPort());
        Future<Channel> handshakeFuture = null;

        for (int i = 0; i < 2; i++) {
            serverReceiver.onNextMessages.offer(checkServer);
            ChannelFuture ccf = cb.connect(addr);
            assertTrue(ccf.syncUninterruptibly().isSuccess());
            clientChannel = ccf.channel();

            clientChannel.writeAndFlush(clientChannel.alloc().buffer().writeInt(42)).await();
            clientChannel.closeFuture().sync();
            handshakeFuture = serverSslHandshakeFuture;
        }

        int checkClientTrustedCalls = checkClientTrustedCount.get();
        if (checkClientTrustedCalls == 1) {
            do {
                serverChannel.eventLoop().submit(NOOP).await(); // Wait for exception to propagate.
            } while (serverException == null);
            assertEquals("Test exception", serverException.getMessage());
            assertNotNull(handshakeFuture);
            assertTrue(handshakeFuture.isDone());
            assertFalse(handshakeFuture.isSuccess());
            assertEquals("Test exception", handshakeFuture.cause().getMessage());
        } else {
            assertEquals(2, checkClientTrustedCalls);
        }
        ByteBuf byteBuf;
        while ((byteBuf = clientReceiver.messages.poll()) != null) {
            byteBuf.release();
        }
    }