Java 15035 (#13421)

* [JAVA-15035] Created module httpclient4 and moved related code

* [JAVA-15035] Upgraded httpclient-simple to spring-boot-e

* [JAVA-15035] Moved modules to to right profiles

* [JAVA-15026] Upgraded headers code to apache 5.2 + moved code related to 4.5 to httpclient4 module

* [JAVA-14911] Final clean up for http-client module

---------

Co-authored-by: panagiotiskakos <panagiotis.kakos@libra-is.com>

httpclient-simple/src/main/java/com/baeldung/basic/MyBasicAuthenticationEntryPoint.java

@@ -3,8 +3,8 @@ package com.baeldung.basic;
 import java.io.IOException;
 import java.io.PrintWriter;
 
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 
 import org.springframework.security.core.AuthenticationException;
 import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint;

httpclient-simple/src/main/java/com/baeldung/client/HttpComponentsClientHttpRequestFactoryBasicAuth.java

@@ -2,13 +2,13 @@ package com.baeldung.client;
 
 import java.net.URI;
 
-import org.apache.http.HttpHost;
-import org.apache.http.client.AuthCache;
-import org.apache.http.client.protocol.HttpClientContext;
-import org.apache.http.impl.auth.BasicScheme;
-import org.apache.http.impl.client.BasicAuthCache;
-import org.apache.http.protocol.BasicHttpContext;
-import org.apache.http.protocol.HttpContext;
+import org.apache.hc.core5.http.HttpHost;
+import org.apache.hc.client5.http.auth.AuthCache;
+import org.apache.hc.client5.http.impl.auth.BasicAuthCache;
+import org.apache.hc.client5.http.impl.auth.BasicScheme;
+import org.apache.hc.client5.http.protocol.HttpClientContext;
+import org.apache.hc.core5.http.protocol.BasicHttpContext;
+import org.apache.hc.core5.http.protocol.HttpContext;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
 
@@ -21,6 +21,7 @@ public class HttpComponentsClientHttpRequestFactoryBasicAuth extends HttpCompone
         this.host = host;
     }
 
+    @Override
     protected HttpContext createHttpContext(HttpMethod httpMethod, URI uri) {
         return createHttpContext();
     }

httpclient-simple/src/main/java/com/baeldung/client/RestTemplateFactory.java

@@ -1,6 +1,6 @@
 package com.baeldung.client;
 
-import org.apache.http.HttpHost;
+import org.apache.hc.core5.http.HttpHost;
 import org.springframework.beans.factory.FactoryBean;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.http.client.ClientHttpRequestFactory;
@@ -35,7 +35,7 @@ public class RestTemplateFactory implements FactoryBean<RestTemplate>, Initializ
 
     @Override
     public void afterPropertiesSet() {
-        HttpHost host = new HttpHost("localhost", 8082, "http");
+        HttpHost host = new HttpHost("http", "localhost", 8082);
         final ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactoryBasicAuth(host);
         restTemplate = new RestTemplate(requestFactory);
         restTemplate.getInterceptors().add(new BasicAuthenticationInterceptor("user1", "user1Pass"));

httpclient-simple/src/main/java/com/baeldung/filter/CustomFilter.java

@@ -2,10 +2,10 @@ package com.baeldung.filter;
 
 import org.springframework.web.filter.GenericFilterBean;
 
-import javax.servlet.FilterChain;
-import javax.servlet.ServletException;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
 import java.io.IOException;
 
 public class CustomFilter extends GenericFilterBean {

httpclient-simple/src/main/java/com/baeldung/filter/CustomWebSecurityConfigurerAdapter.java

@@ -7,41 +7,38 @@ import org.springframework.context.annotation.Configuration;
 import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
-import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.SecurityFilterChain;
 import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
 
 @Configuration
 @EnableWebSecurity
-public class CustomWebSecurityConfigurerAdapter extends WebSecurityConfigurerAdapter {
+public class CustomWebSecurityConfigurerAdapter{
 
     @Autowired private RestAuthenticationEntryPoint authenticationEntryPoint;
 
     @Autowired
     public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
         auth
-          .inMemoryAuthentication()
-          .withUser("user1")
-          .password(passwordEncoder().encode("user1Pass"))
-          .authorities("ROLE_USER");
+            .inMemoryAuthentication()
+            .withUser("user1")
+            .password(passwordEncoder().encode("user1Pass"))
+            .authorities("ROLE_USER");
     }
 
-    @Override
-    protected void configure(HttpSecurity http) throws Exception {
-        http
-          .authorizeRequests()
-          .antMatchers("/securityNone")
-          .permitAll()
-          .anyRequest()
-          .authenticated()
-          .and()
-          .httpBasic()
-          .authenticationEntryPoint(authenticationEntryPoint);
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+
+        http.authorizeHttpRequests((authorize) -> authorize.anyRequest()
+                .authenticated())
+            .httpBasic()
+            .authenticationEntryPoint(authenticationEntryPoint);
 
         http.addFilterAfter(new CustomFilter(), BasicAuthenticationFilter.class);
+        return  http.build();
     }
-    
+
     @Bean
     public PasswordEncoder passwordEncoder() {
         return new BCryptPasswordEncoder();

httpclient-simple/src/main/java/com/baeldung/security/MySavedRequestAwareAuthenticationSuccessHandler.java

@@ -2,9 +2,9 @@ package com.baeldung.security;
 
 import java.io.IOException;
 
-import javax.servlet.ServletException;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 
 import org.springframework.security.core.Authentication;
 import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;

httpclient-simple/src/main/java/com/baeldung/security/RestAuthenticationEntryPoint.java

@@ -2,8 +2,8 @@ package com.baeldung.security;
 
 import java.io.IOException;
 
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 
 import org.springframework.security.core.AuthenticationException;
 import org.springframework.security.web.AuthenticationEntryPoint;

httpclient-simple/src/main/java/com/baeldung/web/dto/Bar.java

@@ -2,7 +2,7 @@ package com.baeldung.web.dto;
 
 import java.io.Serializable;
 
-import javax.xml.bind.annotation.XmlRootElement;
+import jakarta.xml.bind.annotation.XmlRootElement;
 
 @XmlRootElement
 public class Bar implements Serializable {

httpclient-simple/src/main/java/com/baeldung/web/dto/Foo.java

@@ -2,7 +2,7 @@ package com.baeldung.web.dto;
 
 import java.io.Serializable;
 
-import javax.xml.bind.annotation.XmlRootElement;
+import jakarta.xml.bind.annotation.XmlRootElement;
 
 @XmlRootElement
 public class Foo implements Serializable {

httpclient-simple/src/test/java/com/baeldung/client/ClientLiveTest.java

@@ -1,25 +1,23 @@
 package com.baeldung.client;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
 
-import com.baeldung.client.spring.ClientConfig;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
 import com.baeldung.web.dto.Foo;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.ResponseEntity;
-import org.springframework.test.context.ContextConfiguration;
-import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
-import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
 import org.springframework.web.client.ResourceAccessException;
 import org.springframework.web.client.RestTemplate;
 
-@RunWith(SpringJUnit4ClassRunner.class)
-@ContextConfiguration(classes = { ClientConfig.class }, loader = AnnotationConfigContextLoader.class)
-public class ClientLiveTest {
+class ClientLiveTest {
 
     @Autowired
     private RestTemplate secureRestTemplate;
@@ -27,21 +25,24 @@ public class ClientLiveTest {
     // tests
 
     @Test
-    public final void whenContextIsBootstrapped_thenNoExceptions() {
+    void whenContextIsBootstrapped_thenNoExceptions() {
         //
     }
 
     @Test
-    public final void whenSecuredRestApiIsConsumed_then200OK() {
+    void whenSecuredRestApiIsConsumed_then200OK() {
         final ResponseEntity<Foo> responseEntity = secureRestTemplate.exchange("http://localhost:8082/httpclient-simple/api/foos/1", HttpMethod.GET, null, Foo.class);
         assertThat(responseEntity.getStatusCode().value(), is(200));
     }
 
-    @Test(expected = ResourceAccessException.class)
-    public final void whenHttpsUrlIsConsumed_thenException() {
+    @Test
+    void whenHttpsUrlIsConsumed_thenException() {
         final String urlOverHttps = "https://localhost:8443/httpclient-simple/api/bars/1";
-        final ResponseEntity<String> response = new RestTemplate().exchange(urlOverHttps, HttpMethod.GET, null, String.class);
-        assertThat(response.getStatusCode().value(), equalTo(200));
+        assertThrows(ResourceAccessException.class, () -> {
+            final ResponseEntity<String> response = new RestTemplate()
+                .exchange(urlOverHttps, HttpMethod.GET, null, String.class);
+            assertThat(response.getStatusCode().value(), equalTo(200));
+        });
     }
 
 }

httpclient-simple/src/test/java/com/baeldung/client/RestClientLiveManualTest.java

@@ -1,112 +1,78 @@
 package com.baeldung.client;
 
-import static org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;
 import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import java.io.IOException;
 import java.security.GeneralSecurityException;
 
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLPeerUnverifiedException;
 
-import org.apache.http.HttpResponse;
-import org.apache.http.client.ClientProtocolException;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.config.Registry;
-import org.apache.http.config.RegistryBuilder;
-import org.apache.http.conn.scheme.Scheme;
-import org.apache.http.conn.socket.ConnectionSocketFactory;
-import org.apache.http.conn.socket.PlainConnectionSocketFactory;
-import org.apache.http.conn.ssl.NoopHostnameVerifier;
-import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
-import org.apache.http.conn.ssl.SSLSocketFactory;
-import org.apache.http.conn.ssl.TrustStrategy;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.impl.client.HttpClients;
-import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
-import org.apache.http.ssl.SSLContexts;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.apache.hc.client5.http.classic.methods.HttpGet;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
+import org.apache.hc.client5.http.impl.io.BasicHttpClientConnectionManager;
+import org.apache.hc.client5.http.socket.ConnectionSocketFactory;
+import org.apache.hc.client5.http.socket.PlainConnectionSocketFactory;
+import org.apache.hc.client5.http.ssl.NoopHostnameVerifier;
+import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory;
+import org.apache.hc.core5.http.HttpResponse;
+import org.apache.hc.core5.http.config.Registry;
+import org.apache.hc.core5.http.config.RegistryBuilder;
+import org.apache.hc.core5.ssl.SSLContexts;
+import org.apache.hc.core5.ssl.TrustStrategy;
+import org.junit.jupiter.api.Test;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.ResponseEntity;
 import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
+import org.springframework.web.client.ResourceAccessException;
 import org.springframework.web.client.RestTemplate;
 
+import com.baeldung.handler.CustomHttpClientResponseHandler;
+
+
 /**
  * This test requires a localhost server over HTTPS <br>
  * It should only be manually run, not part of the automated build
  * */
-public class RestClientLiveManualTest {
+class RestClientLiveManualTest {
 
     final String urlOverHttps = "http://localhost:8082/httpclient-simple/api/bars/1";
 
-    // tests
 
-    // old httpClient will throw UnsupportedOperationException
-    @Ignore
-    @Test
-    public final void givenAcceptingAllCertificates_whenHttpsUrlIsConsumed_thenOk() throws GeneralSecurityException {
-        final HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
-        final CloseableHttpClient httpClient = (CloseableHttpClient) requestFactory.getHttpClient();
-
-        final TrustStrategy acceptingTrustStrategy = (cert, authType) -> true;
-
-        final SSLSocketFactory sf = new SSLSocketFactory(acceptingTrustStrategy, ALLOW_ALL_HOSTNAME_VERIFIER);
-        httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", 8443, sf));
-
-        final ResponseEntity<String> response = new RestTemplate(requestFactory).exchange(urlOverHttps, HttpMethod.GET, null, String.class);
-        assertThat(response.getStatusCode().value(), equalTo(200));
-    }
-    
     // new httpClient : 4.4 and above
     @Test
-    public final void givenAcceptingAllCertificates_whenHttpsUrlIsConsumed_thenOk_2() throws GeneralSecurityException {
+    void givenAcceptingAllCertificates_whenHttpsUrlIsConsumed_thenOk() throws GeneralSecurityException {
 
         final TrustStrategy acceptingTrustStrategy = (cert, authType) -> true;
         final SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
         final SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
         final Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create()
-                .register("https", sslsf)
-                .register("http", new PlainConnectionSocketFactory())
-                .build();
+            .register("https", sslsf)
+            .register("http", new PlainConnectionSocketFactory())
+            .build();
 
         final BasicHttpClientConnectionManager connectionManager = new BasicHttpClientConnectionManager(socketFactoryRegistry);
         final CloseableHttpClient httpClient = HttpClients.custom()
-                .setSSLSocketFactory(sslsf)
-                .setConnectionManager(connectionManager)
-                .build();
+            .setConnectionManager(connectionManager)
+            .build();
 
         final HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
         final ResponseEntity<String> response = new RestTemplate(requestFactory).exchange(urlOverHttps, HttpMethod.GET, null, String.class);
         assertThat(response.getStatusCode().value(), equalTo(200));
     }
 
-    @Test
-    public final void givenAcceptingAllCertificatesUsing4_4_whenHttpsUrlIsConsumed_thenCorrect() throws ClientProtocolException, IOException {
-        final CloseableHttpClient httpClient = HttpClients.custom().setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
 
-        final HttpGet getMethod = new HttpGet(urlOverHttps);
-        final HttpResponse response = httpClient.execute(getMethod);
-        assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
-    }
 
     @Test
-    public final void givenAcceptingAllCertificatesUsing4_4_whenUsingRestTemplate_thenCorrect() throws ClientProtocolException, IOException {
-        final CloseableHttpClient httpClient = HttpClients.custom().setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
-        final HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
-        requestFactory.setHttpClient(httpClient);
-
-        final ResponseEntity<String> response = new RestTemplate(requestFactory).exchange(urlOverHttps, HttpMethod.GET, null, String.class);
-        assertThat(response.getStatusCode().value(), equalTo(200));
-    }
-
-    @Test(expected = SSLPeerUnverifiedException.class)
-    public void whenHttpsUrlIsConsumed_thenException() throws ClientProtocolException, IOException {
-        CloseableHttpClient httpClient = HttpClients.createDefault();
+    void whenHttpsUrlIsConsumed_thenException() {
         String urlOverHttps = "https://localhost:8082/httpclient-simple";
         HttpGet getMethod = new HttpGet(urlOverHttps);
-        HttpResponse response = httpClient.execute(getMethod);
-        assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
+        assertThrows(SSLPeerUnverifiedException.class, () -> {
+            CloseableHttpClient httpClient = HttpClients.createDefault();
+            HttpResponse response = httpClient.execute(getMethod, new CustomHttpClientResponseHandler());
+            assertThat(response.getCode(), equalTo(200));
+        });
     }
 }

httpclient-simple/src/test/java/com/baeldung/httpclient/HttpClientHeadersLiveTest.java

@@ -1,100 +1,76 @@
 package com.baeldung.httpclient;
 
 import com.google.common.collect.Lists;
-import org.apache.http.Header;
-import org.apache.http.HttpHeaders;
-import org.apache.http.client.ClientProtocolException;
-import org.apache.http.client.methods.CloseableHttpResponse;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.client.methods.HttpUriRequest;
-import org.apache.http.client.methods.RequestBuilder;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.impl.client.HttpClientBuilder;
-import org.apache.http.impl.client.HttpClients;
-import org.apache.http.message.BasicHeader;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+
+import org.apache.hc.client5.http.classic.methods.HttpGet;
+import org.apache.hc.client5.http.impl.classic.BasicHttpClientResponseHandler;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
+import org.apache.hc.core5.http.Header;
+import org.apache.hc.core5.http.HttpHeaders;
+import org.apache.hc.core5.http.message.BasicHeader;
+
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 
 import java.io.IOException;
 import java.util.List;
 
-public class HttpClientHeadersLiveTest {
+class HttpClientHeadersLiveTest {
 
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
     private static final String SAMPLE_URL = "http://www.github.com";
 
-    private CloseableHttpClient client;
-
-    private CloseableHttpResponse response;
-
-    @Before
-    public final void before() {
-        client = HttpClientBuilder.create().build();
-    }
-
-    @After
-    public final void after() throws IllegalStateException, IOException {
-        ResponseUtil.closeResponse(response);
-    }
-
-    // tests - headers - deprecated
-
     @Test
-    public final void givenNewApi_whenClientUsesCustomUserAgent_thenCorrect() throws ClientProtocolException, IOException {
-        client = HttpClients.custom().setUserAgent("Mozilla/5.0 Firefox/26.0").build();
-
+    void whenClientUsesCustomUserAgent_thenCorrect() throws IOException {
         final HttpGet request = new HttpGet(SAMPLE_URL);
-        response = client.execute(request);
+
+        try (CloseableHttpClient client = HttpClients.custom()
+            .setUserAgent("Mozilla/5.0 Firefox/26.0")
+            .build()) {
+
+            String response = client.execute(request, new BasicHttpClientResponseHandler());
+            logger.info("Response -> {}", response);
+        }
     }
 
-    // tests - headers - user agent
-
     @Test
-    public final void givenConfigOnRequest_whenRequestHasCustomUserAgent_thenCorrect() throws ClientProtocolException, IOException {
-        client = HttpClients.custom().build();
+    void whenRequestHasCustomUserAgent_thenCorrect() throws IOException {
         final HttpGet request = new HttpGet(SAMPLE_URL);
         request.setHeader(HttpHeaders.USER_AGENT, "Mozilla/5.0 Firefox/26.0");
-        response = client.execute(request);
+
+        try (CloseableHttpClient client = HttpClients.createDefault()) {
+            String response = client.execute(request, new BasicHttpClientResponseHandler());
+            logger.info("Response -> {}", response);
+        }
     }
 
     @Test
-    public final void givenConfigOnClient_whenRequestHasCustomUserAgent_thenCorrect() throws ClientProtocolException, IOException {
-        client = HttpClients.custom().setUserAgent("Mozilla/5.0 Firefox/26.0").build();
-        response = client.execute(new HttpGet(SAMPLE_URL));
-    }
-
-    // tests - headers - content type
-
-    @Test
-    public final void givenUsingNewApi_whenRequestHasCustomContentType_thenCorrect() throws ClientProtocolException, IOException {
-        client = HttpClients.custom().build();
+    void whenRequestHasCustomContentType_thenCorrect() throws IOException {
         final HttpGet request = new HttpGet(SAMPLE_URL);
         request.setHeader(HttpHeaders.CONTENT_TYPE, "application/json");
-        response = client.execute(request);
+
+        try (CloseableHttpClient client = HttpClients.createDefault()) {
+            String response = client.execute(request, new BasicHttpClientResponseHandler());
+            logger.debug("Response -> {}", response);
+        }
     }
 
     @Test
-    public final void givenRequestBuildWithBuilderWithNewApi_whenRequestHasCustomContentType_thenCorrect() throws ClientProtocolException, IOException {
-        final CloseableHttpClient client2 = HttpClients.custom().build();
+    void givenConfigOnClient_whenRequestHasCustomContentType_thenCorrect() throws IOException {
         final HttpGet request = new HttpGet(SAMPLE_URL);
-        request.setHeader(HttpHeaders.CONTENT_TYPE, "application/json");
-        response = client2.execute(request);
-    }
-
-    @Test
-    public final void givenRequestBuildWithBuilder_whenRequestHasCustomContentType_thenCorrect() throws ClientProtocolException, IOException {
-        client = HttpClients.custom().build();
-        final HttpUriRequest request = RequestBuilder.get().setUri(SAMPLE_URL).setHeader(HttpHeaders.CONTENT_TYPE, "application/json").build();
-        response = client.execute(request);
-    }
-
-    @Test
-    public final void givenConfigOnClient_whenRequestHasCustomContentType_thenCorrect() throws ClientProtocolException, IOException {
         final Header header = new BasicHeader(HttpHeaders.CONTENT_TYPE, "application/json");
         final List<Header> headers = Lists.newArrayList(header);
-        client = HttpClients.custom().setDefaultHeaders(headers).build();
-        final HttpUriRequest request = RequestBuilder.get().setUri(SAMPLE_URL).build();
-        response = client.execute(request);
-    }
 
+
+        try (CloseableHttpClient client = HttpClients.custom()
+            .setDefaultHeaders(headers)
+            .build()) {
+
+            String response = client.execute(request, new BasicHttpClientResponseHandler());
+            logger.debug("Response -> {}", response);
+        }
+    }
 }

httpclient-simple/src/test/java/com/baeldung/httpclient/HttpClientParamsLiveTest.java

@@ -1,7 +1,8 @@
 package com.baeldung.httpclient;
 
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+
 
 import java.io.IOException;
 import java.net.URI;
@@ -14,28 +15,25 @@ import org.apache.hc.client5.http.classic.methods.HttpGet;
 import org.apache.hc.client5.http.classic.methods.HttpPost;
 import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
 import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
-import org.apache.hc.client5.http.impl.classic.HttpClientBuilder;
 import org.apache.hc.client5.http.ClientProtocolException;
 import org.apache.hc.client5.http.entity.UrlEncodedFormEntity;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
+import org.apache.hc.core5.http.HttpStatus;
 import org.apache.hc.core5.http.NameValuePair;
 import org.apache.hc.core5.http.message.BasicNameValuePair;
 import org.apache.hc.core5.net.URIBuilder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-import org.junit.Before;
-import org.junit.Test;
+import com.baeldung.handler.CustomHttpClientResponseHandler;
 
-public class HttpClientParamsLiveTest {
+class HttpClientParamsLiveTest {
 
-    private CloseableHttpClient client;
-
-    private CloseableHttpResponse response;
 
     private List<NameValuePair> nameValuePairs;
 
-    @Before
+    @BeforeEach
     public void setUp() {
-        client = HttpClientBuilder.create()
-            .build();
         nameValuePairs = new ArrayList<>();
         NameValuePair param1NameValuePair = new BasicNameValuePair("param1", "value1");
         NameValuePair param2NameValuePair = new BasicNameValuePair("param2", "value2");
@@ -44,63 +42,83 @@ public class HttpClientParamsLiveTest {
     }
 
     @Test
-    public void givenStringNameValuePairParams_whenGetRequest_thenResponseOk() throws URISyntaxException, ClientProtocolException, IOException {
+    void givenStringNameValuePairParams_whenGetRequest_thenResponseOk() throws URISyntaxException, ClientProtocolException, IOException {
         HttpGet httpGet = new HttpGet("https://postman-echo.com/get");
         URI uri = new URIBuilder(httpGet.getUri()).addParameter("param1", "value1")
             .addParameter("param2", "value2")
             .build();
         httpGet.setUri(uri);
 
-        response = client.execute(httpGet);
-        assertThat(response.getCode(), equalTo(200));
-        client.close();
+        try (CloseableHttpClient client = HttpClients.createDefault();
+            CloseableHttpResponse response = (CloseableHttpResponse) client
+                .execute(httpGet, new CustomHttpClientResponseHandler())) {
+
+            final int statusCode = response.getCode();
+            assertThat(statusCode, equalTo(HttpStatus.SC_OK));
+        }
     }
 
     @Test
-    public void givenStringNameValuePairParams_whenPostRequest_thenResponseOk() throws URISyntaxException, ClientProtocolException, IOException {
+    void givenStringNameValuePairParams_whenPostRequest_thenResponseOk() throws URISyntaxException, ClientProtocolException, IOException {
         HttpPost httpPost = new HttpPost("https://postman-echo.com/post");
         URI uri = new URIBuilder(httpPost.getUri()).addParameter("param1", "value1")
             .addParameter("param2", "value2")
             .build();
         httpPost.setUri(uri);
-        response = client.execute(httpPost);
 
-        assertThat(response.getCode(), equalTo(200));
-        client.close();
+        try (CloseableHttpClient client = HttpClients.createDefault();
+            CloseableHttpResponse response = (CloseableHttpResponse) client
+                .execute(httpPost, new CustomHttpClientResponseHandler())) {
+
+            final int statusCode = response.getCode();
+            assertThat(statusCode, equalTo(HttpStatus.SC_OK));
+        }
     }
 
     @Test
-    public void givenNameValuePairParams_whenGetRequest_thenResponseOk() throws URISyntaxException, ClientProtocolException, IOException {
+    void givenNameValuePairParams_whenGetRequest_thenResponseOk() throws URISyntaxException, ClientProtocolException, IOException {
         HttpGet httpGet = new HttpGet("https://postman-echo.com/get");
         URI uri = new URIBuilder(httpGet.getUri()).addParameters(nameValuePairs)
             .build();
         httpGet.setUri(uri);
-        response = client.execute(httpGet);
 
-        assertThat(response.getCode(), equalTo(200));
-        client.close();
+        try (CloseableHttpClient client = HttpClients.createDefault();
+            CloseableHttpResponse response = (CloseableHttpResponse) client
+                .execute(httpGet, new CustomHttpClientResponseHandler())) {
+
+            final int statusCode = response.getCode();
+            assertThat(statusCode, equalTo(HttpStatus.SC_OK));
+        }
     }
 
     @Test
-    public void givenNameValuePairsParams_whenPostRequest_thenResponseOk() throws URISyntaxException, ClientProtocolException, IOException {
+    void givenNameValuePairsParams_whenPostRequest_thenResponseOk() throws URISyntaxException, ClientProtocolException, IOException {
         HttpPost httpPost = new HttpPost("https://postman-echo.com/post");
         URI uri = new URIBuilder(httpPost.getUri()).addParameters(nameValuePairs)
             .build();
         httpPost.setUri(uri);
-        response = client.execute(httpPost);
 
-        assertThat(response.getCode(), equalTo(200));
-        client.close();
+        try (CloseableHttpClient client = HttpClients.createDefault();
+            CloseableHttpResponse response = (CloseableHttpResponse) client
+                .execute(httpPost, new CustomHttpClientResponseHandler())) {
+
+            final int statusCode = response.getCode();
+            assertThat(statusCode, equalTo(HttpStatus.SC_OK));
+        }
     }
 
     @Test
-    public void givenUrlEncodedEntityParams_whenPostRequest_thenResponseOk() throws URISyntaxException, ClientProtocolException, IOException {
+    void givenUrlEncodedEntityParams_whenPostRequest_thenResponseOk() throws URISyntaxException, ClientProtocolException, IOException {
         HttpPost httpPost = new HttpPost("https://postman-echo.com/post");
         httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs, StandardCharsets.UTF_8));
-        response = client.execute(httpPost);
 
-        assertThat(response.getCode(), equalTo(200));
-        client.close();
+        try (CloseableHttpClient client = HttpClients.createDefault();
+            CloseableHttpResponse response = (CloseableHttpResponse) client
+                .execute(httpPost, new CustomHttpClientResponseHandler())) {
+
+            final int statusCode = response.getCode();
+            assertThat(statusCode, equalTo(HttpStatus.SC_OK));
+        }
     }
 
 }

httpclient-simple/src/test/java/com/baeldung/httpclient/HttpClientTimeoutLiveTest.java

@@ -3,7 +3,6 @@ package com.baeldung.httpclient;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.Mockito.when;
 
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;

httpclient-simple/src/test/java/com/baeldung/httpclient/HttpClientTimeoutV4LiveTest.java

@@ -1,116 +0,0 @@
-package com.baeldung.httpclient;
-
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-import java.io.IOException;
-import java.util.Timer;
-import java.util.TimerTask;
-
-import org.apache.http.HttpResponse;
-import org.apache.http.client.config.RequestConfig;
-import org.apache.http.client.methods.CloseableHttpResponse;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.config.SocketConfig;
-import org.apache.http.conn.ConnectTimeoutException;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.impl.client.HttpClientBuilder;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-class HttpClientTimeoutV4LiveTest {
-
-    private CloseableHttpResponse response;
-
-    @AfterEach
-    public final void after() throws IllegalStateException, IOException {
-        ResponseUtil.closeResponse(response);
-    }
-
-
-    @Test
-    void givenUsingNewApi_whenSettingTimeoutViaRequestConfig_thenCorrect() throws IOException {
-        final int timeout = 2;
-        final RequestConfig config = RequestConfig.custom().setConnectTimeout(timeout * 1000).setConnectionRequestTimeout(timeout * 1000).setSocketTimeout(timeout * 1000).build();
-        final CloseableHttpClient client = HttpClientBuilder.create().setDefaultRequestConfig(config).build();
-        final HttpGet request = new HttpGet("http://www.github.com");
-
-        response = client.execute(request);
-
-        assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
-    }
-
-    @Test
-    void givenUsingNewApi_whenSettingTimeoutViaSocketConfig_thenCorrect() throws IOException {
-        final int timeout = 2;
-
-        final SocketConfig config = SocketConfig.custom().setSoTimeout(timeout * 1000).build();
-        final CloseableHttpClient client = HttpClientBuilder.create().setDefaultSocketConfig(config).build();
-
-        final HttpGet request = new HttpGet("http://www.github.com");
-
-        response = client.execute(request);
-
-        assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
-    }
-
-    @Test
-    void givenUsingNewApi_whenSettingTimeoutViaHighLevelApi_thenCorrect() throws IOException {
-        final int timeout = 5;
-
-        final RequestConfig config = RequestConfig.custom().setConnectTimeout(timeout * 1000).setConnectionRequestTimeout(timeout * 1000).setSocketTimeout(timeout * 1000).build();
-        final CloseableHttpClient client = HttpClientBuilder.create().setDefaultRequestConfig(config).build();
-
-        final HttpGet request = new HttpGet("http://www.github.com");
-
-        response = client.execute(request);
-
-        assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
-    }
-
-    /**
-     * This simulates a timeout against a domain with multiple routes/IPs to it (not a single raw IP)
-     */
-    @Test
-    @Disabled
-    public final void givenTimeoutIsConfigured_whenTimingOut_thenTimeoutException() throws IOException {
-        final int timeout = 3;
-
-        final RequestConfig config = RequestConfig.custom().setConnectTimeout(timeout * 1000).setConnectionRequestTimeout(timeout * 1000).setSocketTimeout(timeout * 1000).build();
-        final CloseableHttpClient client = HttpClientBuilder.create().setDefaultRequestConfig(config).build();
-
-        final HttpGet request = new HttpGet("http://www.google.com:81");
-
-        assertThrows(ConnectTimeoutException.class, () -> {
-            client.execute(request);
-        });
-
-    }
-
-    @Test
-    void whenSecuredRestApiIsConsumed_then200OK() throws IOException {
-        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
-
-        int timeout = 20; // seconds
-        RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(timeout * 1000)
-            .setConnectTimeout(timeout * 1000).setSocketTimeout(timeout * 1000).build();
-        HttpGet getMethod = new HttpGet("http://localhost:8082/httpclient-simple/api/bars/1");
-        getMethod.setConfig(requestConfig);
-
-        int hardTimeout = 5; // seconds
-        TimerTask task = new TimerTask() {
-            @Override
-            public void run() {
-                getMethod.abort();
-            }
-        };
-        new Timer(true).schedule(task, hardTimeout * 1000);
-
-        HttpResponse response = httpClient.execute(getMethod);
-        System.out.println("HTTP Status of response: " + response.getStatusLine().getStatusCode());
-    }
-
-}

httpclient-simple/src/test/java/com/baeldung/httpclient/HttpsClientSslLiveTest.java

@@ -1,7 +1,6 @@
 package com.baeldung.httpclient;
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.io.IOException;
 import java.security.GeneralSecurityException;
@@ -9,73 +8,50 @@ import java.security.GeneralSecurityException;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLHandshakeException;
 
-import org.apache.http.HttpResponse;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.config.Registry;
-import org.apache.http.config.RegistryBuilder;
-import org.apache.http.conn.socket.ConnectionSocketFactory;
-import org.apache.http.conn.ssl.NoopHostnameVerifier;
-import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
-import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
-import org.apache.http.conn.ssl.TrustStrategy;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.impl.client.HttpClientBuilder;
-import org.apache.http.impl.client.HttpClients;
-import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
-import org.apache.http.ssl.SSLContextBuilder;
-import org.apache.http.ssl.SSLContexts;
-import org.junit.Test;
+import org.apache.hc.client5.http.classic.methods.HttpGet;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
+import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
+import org.apache.hc.client5.http.io.HttpClientConnectionManager;
+import org.apache.hc.client5.http.ssl.NoopHostnameVerifier;
+import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory;
+import org.apache.hc.client5.http.ssl.TrustSelfSignedStrategy;
+import org.apache.hc.core5.http.HttpResponse;
+import org.apache.hc.core5.http.HttpStatus;
+import org.apache.hc.core5.ssl.SSLContextBuilder;
+import org.apache.hc.core5.ssl.SSLContexts;
+import org.apache.hc.core5.ssl.TrustStrategy;
+import org.hamcrest.MatcherAssert;
+import org.hamcrest.Matchers;
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.handler.CustomHttpClientResponseHandler;
 
 /**
  * This test requires a localhost server over HTTPS <br>
  * It should only be manually run, not part of the automated build
  * */
-public class HttpsClientSslLiveTest {
+class HttpsClientSslLiveTest {
 
     // "https://localhost:8443/spring-security-rest-basic-auth/api/bars/1" // local
     // "https://mms.nw.ru/" // hosted
     private static final String HOST_WITH_SSL = "https://mms.nw.ru/";
 
-    // tests
-
-    @Test(expected = SSLHandshakeException.class)
-    public final void whenHttpsUrlIsConsumed_thenException() throws IOException {
-        final CloseableHttpClient httpClient = HttpClientBuilder.create()
-            .build();
-
+    @Test
+    void whenHttpsUrlIsConsumed_thenException() {
         final HttpGet getMethod = new HttpGet(HOST_WITH_SSL);
-        final HttpResponse response = httpClient.execute(getMethod);
-        assertThat(response.getStatusLine()
-            .getStatusCode(), equalTo(200));
+
+        assertThrows(SSLHandshakeException.class, () -> {
+            CloseableHttpClient httpClient = HttpClients.createDefault();
+            HttpResponse response = httpClient.execute(getMethod, new CustomHttpClientResponseHandler());
+            MatcherAssert.assertThat(response.getCode(), Matchers.equalTo(200));
+        });
+
     }
 
     @Test
-    public final void givenHttpClientPre4_3_whenAcceptingAllCertificates_thenCanConsumeHttpsUriWithSelfSignedCertificate() throws IOException, GeneralSecurityException {
-        final TrustStrategy acceptingTrustStrategy = (certificate, authType) -> true;
-        
-        final SSLContext sslContext = SSLContexts.custom()
-                .loadTrustMaterial(null, acceptingTrustStrategy)
-                .build();
-
-        final SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
-        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create().register("https", sslsf).build();
-        PoolingHttpClientConnectionManager clientConnectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
-
-        final CloseableHttpClient httpClient = HttpClients.custom()
-                .setSSLSocketFactory(sslsf)
-                .setConnectionManager(clientConnectionManager)
-                .build();
-
-        final HttpGet getMethod = new HttpGet(HOST_WITH_SSL);
-        final HttpResponse response = httpClient.execute(getMethod);
-        assertThat(response.getStatusLine()
-            .getStatusCode(), equalTo(200));
-
-        httpClient.close();
-    }
-
-    @Test
-    public final void givenHttpClientAfter4_3_whenAcceptingAllCertificates_thenCanConsumeHttpsUriWithSelfSignedCertificate() throws IOException, GeneralSecurityException {
+    void whenAcceptingAllCertificates_thenCanConsumeHttpsUriWithSelfSignedCertificate() throws IOException, GeneralSecurityException {
         final TrustStrategy acceptingTrustStrategy = (certificate, authType) -> true;
         final SSLContext sslContext = SSLContexts.custom()
             .loadTrustMaterial(null, acceptingTrustStrategy)
@@ -83,55 +59,45 @@ public class HttpsClientSslLiveTest {
 
         final SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
 
-        final CloseableHttpClient httpClient = HttpClients.custom()
+        final HttpClientConnectionManager cm = PoolingHttpClientConnectionManagerBuilder.create()
             .setSSLSocketFactory(sslsf)
             .build();
 
         final HttpGet getMethod = new HttpGet(HOST_WITH_SSL);
-        final HttpResponse response = httpClient.execute(getMethod);
-        assertThat(response.getStatusLine()
-            .getStatusCode(), equalTo(200));
+        try (CloseableHttpClient client = HttpClients.custom()
+            .setConnectionManager(cm)
+            .build();
 
-        httpClient.close();
+            CloseableHttpResponse response = (CloseableHttpResponse) client
+                .execute(getMethod, new CustomHttpClientResponseHandler())) {
+
+            final int statusCode = response.getCode();
+            MatcherAssert.assertThat(statusCode, Matchers.equalTo(HttpStatus.SC_OK));
+        }
     }
 
     @Test
-    public final void givenHttpClientPost4_3_whenAcceptingAllCertificates_thenCanConsumeHttpsUriWithSelfSignedCertificate() throws IOException, GeneralSecurityException {
+    void usingBuilder_whenAcceptingAllCertificates_thenCanConsumeHttpsUriWithSelfSignedCertificate() throws IOException, GeneralSecurityException {
         final SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustSelfSignedStrategy())
             .build();
         final NoopHostnameVerifier hostnameVerifier = new NoopHostnameVerifier();
 
         final SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, hostnameVerifier);
-        final CloseableHttpClient httpClient = HttpClients.custom()
-            .setSSLHostnameVerifier(hostnameVerifier)
+        final HttpClientConnectionManager cm = PoolingHttpClientConnectionManagerBuilder.create()
             .setSSLSocketFactory(sslsf)
             .build();
 
-        // new
-
         final HttpGet getMethod = new HttpGet(HOST_WITH_SSL);
-        final HttpResponse response = httpClient.execute(getMethod);
-        assertThat(response.getStatusLine()
-            .getStatusCode(), equalTo(200));
-        httpClient.close();
-
-    }
-
-    @Test
-    public final void givenIgnoringCertificates_whenHttpsUrlIsConsumed_thenCorrect() throws Exception {
-        final SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, (certificate, authType) -> true)
+        try (CloseableHttpClient client = HttpClients.custom()
+            .setConnectionManager(cm)
             .build();
 
-        final CloseableHttpClient client = HttpClients.custom()
-            .setSSLContext(sslContext)
-            .setSSLHostnameVerifier(new NoopHostnameVerifier())
-            .build();
-        final HttpGet httpGet = new HttpGet(HOST_WITH_SSL);
-        httpGet.setHeader("Accept", "application/xml");
+            CloseableHttpResponse response = (CloseableHttpResponse) client
+                .execute(getMethod, new CustomHttpClientResponseHandler())) {
 
-        final HttpResponse response = client.execute(httpGet);
-        assertThat(response.getStatusLine()
-            .getStatusCode(), equalTo(200));
+            final int statusCode = response.getCode();
+            MatcherAssert.assertThat(statusCode, Matchers.equalTo(HttpStatus.SC_OK));
+        }
     }
 
 }

httpclient-simple/src/test/java/com/baeldung/httpclient/ResponseUtil.java

@@ -1,26 +0,0 @@
-package com.baeldung.httpclient;
-
-import org.apache.http.HttpEntity;
-import org.apache.http.client.methods.CloseableHttpResponse;
-
-import java.io.IOException;
-
-public final class ResponseUtil {
-    private ResponseUtil() {
-    }
-
-    public static void closeResponse(CloseableHttpResponse response) throws IOException {
-        if (response == null) {
-            return;
-        }
-
-        try {
-            final HttpEntity entity = response.getEntity();
-            if (entity != null) {
-                entity.getContent().close();
-            }
-        } finally {
-            response.close();
-        }
-    }
-}

httpclient-simple/src/test/java/com/baeldung/httpclient/base/HttpClientBasicLiveTest.java

@@ -19,12 +19,12 @@ import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.notNullValue;
 
 
-public class HttpClientBasicLiveTest {
+class HttpClientBasicLiveTest {
 
     private static final String SAMPLE_URL = "http://www.github.com";
 
     @Test
-    public final void whenExecutingBasicGetRequest_thenNoExceptions() throws IOException {
+    void whenExecutingBasicGetRequest_thenNoExceptions() throws IOException {
         final HttpGet request = new HttpGet(SAMPLE_URL);
 
         try (CloseableHttpClient client = HttpClientBuilder.create().build();
@@ -35,7 +35,7 @@ public class HttpClientBasicLiveTest {
     }
 
     @Test
-    public final void givenGetRequestExecuted_whenAnalyzingTheResponse_thenCorrectStatusCode() throws IOException {
+    void givenGetRequestExecuted_whenAnalyzingTheResponse_thenCorrectStatusCode() throws IOException {
         final HttpGet request = new HttpGet(SAMPLE_URL);
         try (CloseableHttpClient client = HttpClientBuilder.create().build();
 
@@ -48,7 +48,7 @@ public class HttpClientBasicLiveTest {
 
 
     @Test
-    public final void givenGetRequestExecuted_whenAnalyzingTheResponse_thenCorrectMimeType() throws IOException {
+    void givenGetRequestExecuted_whenAnalyzingTheResponse_thenCorrectMimeType() throws IOException {
         final HttpGet request = new HttpGet(SAMPLE_URL);
 
         try (CloseableHttpClient client = HttpClientBuilder.create().build();
@@ -63,7 +63,7 @@ public class HttpClientBasicLiveTest {
 
 
     @Test
-    public final void givenGetRequestExecuted_whenAnalyzingTheResponse_thenCorrectBody() throws IOException, ParseException {
+    void givenGetRequestExecuted_whenAnalyzingTheResponse_thenCorrectBody() throws IOException, ParseException {
         final HttpGet request = new HttpGet(SAMPLE_URL);
         try (CloseableHttpClient client = HttpClientBuilder.create().build();
 

httpclient-simple/src/test/java/com/baeldung/test/LiveTestSuite.java

@@ -1,16 +0,0 @@
-package com.baeldung.test;
-
-import com.baeldung.client.ClientLiveTest;
-import com.baeldung.client.RestClientLiveManualTest;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-
-@RunWith(Suite.class)
-@Suite.SuiteClasses({
-// @formatter:off
-    RestClientLiveManualTest.class
-    ,ClientLiveTest.class
-}) //
-public class LiveTestSuite {
-
-}