Merge branch 'master' of https://github.com/JonCook/tutorials

libraries-http/README.md

@@ -0,0 +1,14 @@
+## HTTP
+
+This module contains articles about HTTP libraries.
+
+### Relevant Articles: 
+
+- [A Guide to OkHttp](https://www.baeldung.com/guide-to-okhttp)
+- [A Guide to Google-Http-Client](https://www.baeldung.com/google-http-client)
+- [Asynchronous HTTP with async-http-client in Java](https://www.baeldung.com/async-http-client)
+- [WebSockets with AsyncHttpClient](https://www.baeldung.com/async-http-client-websockets)
+- [Integrating Retrofit with RxJava](https://www.baeldung.com/retrofit-rxjava)
+- [Introduction to Retrofit](https://www.baeldung.com/retrofit)
+- [A Guide to Unirest](https://www.baeldung.com/unirest)
+- [Creating REST Microservices with Javalin](https://www.baeldung.com/javalin-rest-microservices)

libraries-http/pom.xml

@@ -0,0 +1,137 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+	<modelVersion>4.0.0</modelVersion>
+	<artifactId>libraries-http</artifactId>
+	<name>libraries-http</name>
+
+	<parent>
+		<groupId>com.baeldung</groupId>
+		<artifactId>parent-modules</artifactId>
+		<version>1.0.0-SNAPSHOT</version>
+	</parent>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.assertj</groupId>
+			<artifactId>assertj-core</artifactId>
+			<version>${assertj.version}</version>
+		</dependency>
+
+		<!-- Dependencies for response decoder with okhttp -->
+		<dependency>
+			<groupId>com.squareup.okhttp3</groupId>
+			<artifactId>okhttp</artifactId>
+            <version>${com.squareup.okhttp3.version}</version>
+		</dependency>
+
+        <!-- Dependencies for google http client -->
+        <dependency>
+            <groupId>com.google.http-client</groupId>
+            <artifactId>google-http-client</artifactId>
+            <version>${googleclient.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.http-client</groupId>
+            <artifactId>google-http-client-jackson2</artifactId>
+            <version>${googleclient.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.http-client</groupId>
+            <artifactId>google-http-client-gson</artifactId>
+            <version>${googleclient.version}</version>
+        </dependency>
+
+		<!-- Retrofit -->
+		<dependency>
+			<groupId>com.squareup.retrofit2</groupId>
+			<artifactId>retrofit</artifactId>
+			<version>${retrofit.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.squareup.retrofit2</groupId>
+			<artifactId>converter-gson</artifactId>
+			<version>${retrofit.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.squareup.retrofit2</groupId>
+			<artifactId>adapter-rxjava</artifactId>
+			<version>${retrofit.version}</version>
+		</dependency>
+
+        <!-- https://mvnrepository.com/artifact/org.asynchttpclient/async-http-client -->
+        <dependency>
+            <groupId>org.asynchttpclient</groupId>
+            <artifactId>async-http-client</artifactId>
+            <version>${async.http.client.version}</version>
+        </dependency>
+
+		<dependency>
+			<groupId>com.fasterxml.jackson.core</groupId>
+			<artifactId>jackson-databind</artifactId>
+			<version>${jackson.version}</version>
+		</dependency>
+
+		<dependency>
+			<groupId>com.google.code.gson</groupId>
+			<artifactId>gson</artifactId>
+			<version>2.8.5</version>
+		</dependency>
+
+		<dependency>
+			<groupId>com.squareup.okhttp3</groupId>
+			<artifactId>mockwebserver</artifactId>
+            <version>${com.squareup.okhttp3.version}</version>
+			<scope>test</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>com.mashape.unirest</groupId>
+			<artifactId>unirest-java</artifactId>
+			<version>${unirest.version}</version>
+		</dependency>
+		<!-- javalin -->
+		<dependency>
+			<groupId>io.javalin</groupId>
+			<artifactId>javalin</artifactId>
+			<version>${javalin.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.squareup.okhttp3</groupId>
+			<artifactId>logging-interceptor</artifactId>
+			<version>${logging-interceptor.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.fasterxml.jackson.core</groupId>
+			<artifactId>jackson-databind</artifactId>
+			<version>${jackson.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.httpcomponents</groupId>
+			<artifactId>httpclient</artifactId>
+			<version>${httpclient.version}</version>
+			<exclusions>
+				<exclusion>
+					<artifactId>commons-logging</artifactId>
+					<groupId>commons-logging</groupId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+          
+	</dependencies>
+
+	<properties>
+		<httpclient.version>4.5.3</httpclient.version>
+		<jackson.version>2.9.8</jackson.version>
+		<assertj.version>3.6.2</assertj.version>
+        <com.squareup.okhttp3.version>3.14.2</com.squareup.okhttp3.version>
+        <googleclient.version>1.23.0</googleclient.version>
+        <async.http.client.version>2.2.0</async.http.client.version>
+		<retrofit.version>2.3.0</retrofit.version>
+		<unirest.version>1.4.9</unirest.version>
+		<javalin.version>1.6.0</javalin.version>
+		<logging-interceptor.version>3.9.0</logging-interceptor.version>
+	</properties>
+</project>

libraries-http/src/main/java/com/baeldung/googlehttpclientguide/GitHubExample.java

@@ -0,0 +1,56 @@
+package com.baeldung.googlehttpclientguide;
+
+import com.google.api.client.http.HttpBackOffUnsuccessfulResponseHandler;
+import com.google.api.client.http.HttpRequest;
+import com.google.api.client.http.HttpRequestFactory;
+import com.google.api.client.http.HttpResponse;
+import com.google.api.client.http.HttpTransport;
+import com.google.api.client.http.javanet.NetHttpTransport;
+import com.google.api.client.json.JsonFactory;
+import com.google.api.client.json.JsonObjectParser;
+import com.google.api.client.json.jackson2.JacksonFactory;
+import com.google.api.client.util.ExponentialBackOff;
+import com.google.gson.reflect.TypeToken;
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+public class GitHubExample {
+    static final HttpTransport HTTP_TRANSPORT = new NetHttpTransport();
+    // static final HttpTransport HTTP_TRANSPORT = new ApacheHttpTransport();
+    static final JsonFactory JSON_FACTORY = new JacksonFactory();
+    // static final JsonFactory JSON_FACTORY = new GsonFactory();
+
+    private static void run() throws Exception {
+        HttpRequestFactory requestFactory = HTTP_TRANSPORT.createRequestFactory((HttpRequest request) -> {
+            request.setParser(new JsonObjectParser(JSON_FACTORY));
+        });
+        GitHubUrl url = new GitHubUrl("https://api.github.com/users");
+        url.per_page = 10;
+        url.page = 1;
+        HttpRequest request = requestFactory.buildGetRequest(url);
+        ExponentialBackOff backoff = new ExponentialBackOff.Builder().setInitialIntervalMillis(500).setMaxElapsedTimeMillis(900000).setMaxIntervalMillis(6000).setMultiplier(1.5).setRandomizationFactor(0.5).build();
+        request.setUnsuccessfulResponseHandler(new HttpBackOffUnsuccessfulResponseHandler(backoff));
+        Type type = new TypeToken<List<User>>() {
+        }.getType();
+        List<User> users = (List<User>) request.execute().parseAs(type);
+        System.out.println(users);
+        url.appendRawPath("/eugenp");
+        request = requestFactory.buildGetRequest(url);
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<HttpResponse> responseFuture = request.executeAsync(executor);
+        User eugen = responseFuture.get().parseAs(User.class);
+        System.out.println(eugen);
+        executor.shutdown();
+    }
+
+    public static void main(String[] args) {
+        try {
+            run();
+        } catch (Exception e) {
+            System.err.println(e.getMessage());
+        }
+    }
+}

libraries-http/src/main/java/com/baeldung/googlehttpclientguide/GitHubUrl.java

@@ -0,0 +1,18 @@
+package com.baeldung.googlehttpclientguide;
+
+import com.google.api.client.http.GenericUrl;
+import com.google.api.client.util.Key;
+
+public class GitHubUrl extends GenericUrl {
+
+    public GitHubUrl(String encodedUrl) {
+        super(encodedUrl);
+    }
+
+    @Key
+    public int per_page;
+
+    @Key
+    public int page;
+
+}

libraries-http/src/main/java/com/baeldung/googlehttpclientguide/User.java

@@ -0,0 +1,76 @@
+package com.baeldung.googlehttpclientguide;
+
+import com.google.api.client.json.GenericJson;
+import com.google.api.client.util.Key;
+
+public class User extends GenericJson {
+    @Key
+    private String login;
+    @Key
+    private long id;
+    @Key
+    private String url;
+    @Key
+    private String company;
+    @Key
+    private String blog;
+    @Key
+    private String email;
+
+    @Key("subscriptions_url")
+    private String subscriptionsUrl;
+
+    public String getLogin() {
+        return login;
+    }
+
+    public void setLogin(String login) {
+        this.login = login;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public String getCompany() {
+        return company;
+    }
+
+    public void setCompany(String company) {
+        this.company = company;
+    }
+
+    public String getBlog() {
+        return blog;
+    }
+
+    public void setBlog(String blog) {
+        this.blog = blog;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    @Override
+    public String toString() {
+        return "User{" + "login=" + login + ", id=" + id + ", url=" + url + ", company=" + company + ", blog=" + blog + ", email=" + email + '}';
+    }
+
+}

libraries-http/src/main/java/com/baeldung/googlehttpclientguide/logging.properties

@@ -0,0 +1,10 @@
+# Properties file which configures the operation of the JDK logging facility.
+# The system will look for this config file to be specified as a system property: 
+# -Djava.util.logging.config.file=${project_loc:dailymotion-simple-cmdline-sample}/logging.properties
+
+# Set up the console handler (uncomment "level" to show more fine-grained messages) 
+handlers = java.util.logging.ConsoleHandler
+java.util.logging.ConsoleHandler.level = ALL
+
+# Set up logging of HTTP requests and responses (uncomment "level" to show)
+com.google.api.client.http.level = ALL

libraries-http/src/main/java/com/baeldung/javalin/JavalinApp.java

@@ -0,0 +1,16 @@
+package com.baeldung.javalin;
+
+import com.baeldung.javalin.User.UserController;
+import io.javalin.Javalin;
+
+public class JavalinApp {
+    public static void main(String[] args) {
+        Javalin app = Javalin.create()
+                .port(7000)
+                .start();
+
+        app.get("/hello", ctx -> ctx.html("Hello, Javalin!"));
+        app.get("/users", UserController.fetchAllUsernames);
+        app.get("/users/:id", UserController.fetchById);
+    }
+}

libraries-http/src/main/java/com/baeldung/javalin/User/User.java

@@ -0,0 +1,11 @@
+package com.baeldung.javalin.User;
+
+public class User {
+    public final int id;
+    public final String name;
+
+    public User(int id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+}

libraries-http/src/main/java/com/baeldung/javalin/User/UserController.java

@@ -0,0 +1,24 @@
+package com.baeldung.javalin.User;
+
+import io.javalin.Handler;
+
+import java.util.Objects;
+
+public class UserController {
+    public static Handler fetchAllUsernames = ctx -> {
+        UserDao dao = UserDao.instance();
+        Iterable<String> allUsers = dao.getAllUsernames();
+        ctx.json(allUsers);
+    };
+
+    public static Handler fetchById = ctx -> {
+        int id = Integer.parseInt(Objects.requireNonNull(ctx.param("id")));
+        UserDao dao = UserDao.instance();
+        User user = dao.getUserById(id).get();
+        if (user == null) {
+            ctx.html("Not Found");
+        } else {
+            ctx.json(user);
+        }
+    };
+}

libraries-http/src/main/java/com/baeldung/javalin/User/UserDao.java

@@ -0,0 +1,33 @@
+package com.baeldung.javalin.User;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+class UserDao {
+
+    private final List<User> users = Arrays.asList(
+            new User(0, "Steve Rogers"),
+            new User(1, "Tony Stark"),
+            new User(2, "Carol Danvers")
+    );
+
+    private static UserDao userDao = null;
+
+    private UserDao() {
+    }
+
+    static UserDao instance() {
+        if (userDao == null) {
+            userDao = new UserDao();
+        }
+        return userDao;
+    }
+
+    Optional<User> getUserById(int id) { return users.stream().filter(u -> u.id == id).findFirst(); }
+
+    Iterable<String> getAllUsernames() {
+        return users.stream().map(user -> user.name).collect(Collectors.toList());
+    }
+}

libraries-http/src/main/java/com/baeldung/retrofit/basic/GitHubBasicApi.java

@@ -0,0 +1,31 @@
+package com.baeldung.retrofit.basic;
+
+import java.util.List;
+
+import com.baeldung.retrofit.models.Contributor;
+import com.baeldung.retrofit.models.Repository;
+
+import retrofit2.Call;
+import retrofit2.http.GET;
+import retrofit2.http.Path;
+
+public interface GitHubBasicApi {
+
+    /**
+     * List GitHub repositories of user
+     * @param user GitHub Account
+     * @return GitHub repositories
+     */
+    @GET("users/{user}/repos")
+    Call<List<Repository>> listRepos(@Path("user") String user);
+
+    /**
+     * List Contributors of a GitHub Repository
+     * @param user GitHub Account
+     * @param repo GitHub Repository
+     * @return GitHub Repository Contributors
+     */
+    @GET("repos/{user}/{repo}/contributors")
+    Call<List<Contributor>> listRepoContributors(@Path("user") String user, @Path("repo") String repo);
+
+}

libraries-http/src/main/java/com/baeldung/retrofit/basic/GitHubBasicApp.java

@@ -0,0 +1,13 @@
+package com.baeldung.retrofit.basic;
+
+import java.io.IOException;
+import java.util.List;
+
+public class GitHubBasicApp {
+
+    public static void main(String[] args) throws IOException {
+        String userName = "eugenp";
+        List<String> topContributors = new GitHubBasicService().getTopContributors(userName);
+        topContributors.forEach(System.out::println);
+    }
+}

libraries-http/src/main/java/com/baeldung/retrofit/basic/GitHubBasicService.java

@@ -0,0 +1,44 @@
+package com.baeldung.retrofit.basic;
+
+import com.baeldung.retrofit.models.Contributor;
+import com.baeldung.retrofit.models.Repository;
+import retrofit2.Retrofit;
+import retrofit2.converter.gson.GsonConverterFactory;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+class GitHubBasicService {
+
+    private GitHubBasicApi gitHubApi;
+
+    GitHubBasicService() {
+        Retrofit retrofit = new Retrofit.Builder().baseUrl("https://api.github.com/").addConverterFactory(GsonConverterFactory.create()).build();
+
+        gitHubApi = retrofit.create(GitHubBasicApi.class);
+    }
+
+    List<String> getTopContributors(String userName) throws IOException {
+        List<Repository> repos = gitHubApi.listRepos(userName).execute().body();
+
+        repos = repos != null ? repos : Collections.emptyList();
+
+        return repos.stream().flatMap(repo -> getContributors(userName, repo)).sorted((a, b) -> b.getContributions() - a.getContributions()).map(Contributor::getName).distinct().sorted().collect(Collectors.toList());
+    }
+
+    private Stream<Contributor> getContributors(String userName, Repository repo) {
+        List<Contributor> contributors = null;
+        try {
+            contributors = gitHubApi.listRepoContributors(userName, repo.getName()).execute().body();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        contributors = contributors != null ? contributors : Collections.emptyList();
+
+        return contributors.stream().filter(c -> c.getContributions() > 100);
+    }
+}

libraries-http/src/main/java/com/baeldung/retrofit/models/Contributor.java

@@ -0,0 +1,33 @@
+package com.baeldung.retrofit.models;
+
+import com.google.gson.annotations.SerializedName;
+
+public class Contributor {
+
+    @SerializedName("login")
+    private String name;
+
+    private Integer contributions;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Integer getContributions() {
+        return contributions;
+    }
+
+    public void setContributions(Integer contributions) {
+        this.contributions = contributions;
+    }
+
+    @Override
+    public String toString() {
+        return "Contributer [name=" + name + ", contributions=" + contributions + "]";
+    }
+
+}

libraries-http/src/main/java/com/baeldung/retrofit/models/Repository.java

@@ -0,0 +1,30 @@
+package com.baeldung.retrofit.models;
+
+public class Repository {
+
+    private String name;
+
+    private String description;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    @Override
+    public String toString() {
+        return "Repository [name=" + name + ", description=" + description + "]";
+    }
+
+}

libraries-http/src/main/java/com/baeldung/retrofit/rx/GitHubRxApi.java

@@ -0,0 +1,31 @@
+package com.baeldung.retrofit.rx;
+
+import java.util.List;
+
+import com.baeldung.retrofit.models.Contributor;
+import com.baeldung.retrofit.models.Repository;
+
+import retrofit2.http.GET;
+import retrofit2.http.Path;
+import rx.Observable;
+
+public interface GitHubRxApi {
+
+    /**
+     * List GitHub repositories of user
+     * @param user GitHub Account
+     * @return GitHub repositories
+     */
+    @GET("users/{user}/repos")
+    Observable<List<Repository>> listRepos(@Path("user") String user);
+
+    /**
+     * List Contributors of a GitHub Repository
+     * @param user GitHub Account
+     * @param repo GitHub Repository
+     * @return GitHub Repository Contributors
+     */
+    @GET("repos/{user}/{repo}/contributors")
+    Observable<List<Contributor>> listRepoContributors(@Path("user") String user, @Path("repo") String repo);
+
+}

libraries-http/src/main/java/com/baeldung/retrofit/rx/GitHubRxApp.java

@@ -0,0 +1,11 @@
+package com.baeldung.retrofit.rx;
+
+import java.io.IOException;
+
+public class GitHubRxApp {
+
+    public static void main(String[] args) throws IOException {
+        String userName = "eugenp";
+        new GitHubRxService().getTopContributors(userName).subscribe(System.out::println);
+    }
+}

libraries-http/src/main/java/com/baeldung/retrofit/rx/GitHubRxService.java

@@ -0,0 +1,23 @@
+package com.baeldung.retrofit.rx;
+
+import com.baeldung.retrofit.models.Contributor;
+import retrofit2.Retrofit;
+import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
+import retrofit2.converter.gson.GsonConverterFactory;
+import rx.Observable;
+
+class GitHubRxService {
+
+    private GitHubRxApi gitHubApi;
+
+    GitHubRxService() {
+        Retrofit retrofit = new Retrofit.Builder().baseUrl("https://api.github.com/").addConverterFactory(GsonConverterFactory.create()).addCallAdapterFactory(RxJavaCallAdapterFactory.create()).build();
+
+        gitHubApi = retrofit.create(GitHubRxApi.class);
+    }
+
+    Observable<String> getTopContributors(String userName) {
+        return gitHubApi.listRepos(userName).flatMapIterable(x -> x).flatMap(repo -> gitHubApi.listRepoContributors(userName, repo.getName())).flatMapIterable(x -> x).filter(c -> c.getContributions() > 100)
+                .sorted((a, b) -> b.getContributions() - a.getContributions()).map(Contributor::getName).distinct();
+    }
+}

libraries-http/src/main/java/com/baeldung/retrofitguide/GitHubServiceGenerator.java

@@ -0,0 +1,51 @@
+package com.baeldung.retrofitguide;
+
+import java.io.IOException;
+import okhttp3.Interceptor;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import okhttp3.logging.HttpLoggingInterceptor;
+import retrofit2.Retrofit;
+import retrofit2.converter.gson.GsonConverterFactory;
+
+public class GitHubServiceGenerator {
+
+    private static final String BASE_URL = "https://api.github.com/";
+
+    private static Retrofit.Builder builder = new Retrofit.Builder().baseUrl(BASE_URL).addConverterFactory(GsonConverterFactory.create());
+
+    private static Retrofit retrofit = builder.build();
+
+    private static OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
+
+    private static HttpLoggingInterceptor logging = new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BASIC);
+
+    public static <S> S createService(Class<S> serviceClass) {
+        if (!httpClient.interceptors().contains(logging)) {
+            httpClient.addInterceptor(logging);
+            builder.client(httpClient.build());
+            retrofit = builder.build();
+        }
+        return retrofit.create(serviceClass);
+    }
+
+    public static <S> S createService(Class<S> serviceClass, final String token) {
+        if (token != null) {
+            httpClient.interceptors().clear();
+            httpClient.addInterceptor(new Interceptor() {
+                @Override
+                public Response intercept(Interceptor.Chain chain) throws IOException {
+                    Request original = chain.request();
+                    Request.Builder builder = original.newBuilder().header("Authorization", token);
+                    Request request = builder.build();
+                    return chain.proceed(request);
+                }
+            });
+            builder.client(httpClient.build());
+            retrofit = builder.build();
+        }
+        return retrofit.create(serviceClass);
+    }
+
+}

libraries-http/src/main/java/com/baeldung/retrofitguide/Main.java

@@ -0,0 +1,45 @@
+package com.baeldung.retrofitguide;
+
+import java.io.IOException;
+import okhttp3.OkHttpClient;
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+import retrofit2.Retrofit;
+import retrofit2.converter.gson.GsonConverterFactory;
+
+public class Main {
+
+    public static void main(String[] args) {
+        // Manual creation
+        OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
+        Retrofit retrofit = new Retrofit.Builder().baseUrl("https://api.github.com/").addConverterFactory(GsonConverterFactory.create()).client(httpClient.build()).build();
+        UserService service = retrofit.create(UserService.class);
+        // Using GitHubServiceGenerator
+        service = GitHubServiceGenerator.createService(UserService.class);
+        Call<User> callSync = service.getUser("eugenp");
+        Call<User> callAsync = service.getUser("eugenp");
+
+        try {
+            Response<User> response = callSync.execute();
+            User user = response.body();
+            System.out.println(user);
+        } catch (IOException ex) {
+        }
+
+        // Execute the call asynchronously. Get a positive or negative callback.
+        callAsync.enqueue(new Callback<User>() {
+            @Override
+            public void onResponse(Call<User> call, Response<User> response) {
+                User user = response.body();
+                System.out.println(user);
+            }
+
+            @Override
+            public void onFailure(Call<User> call, Throwable throwable) {
+                System.out.println(throwable);
+            }
+        });
+
+    }
+}

libraries-http/src/main/java/com/baeldung/retrofitguide/User.java

@@ -0,0 +1,65 @@
+package com.baeldung.retrofitguide;
+
+public class User {
+
+    private String login;
+    private long id;
+    private String url;
+    private String company;
+    private String blog;
+    private String email;
+
+    public String getLogin() {
+        return login;
+    }
+
+    public void setLogin(String login) {
+        this.login = login;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public String getCompany() {
+        return company;
+    }
+
+    public void setCompany(String company) {
+        this.company = company;
+    }
+
+    public String getBlog() {
+        return blog;
+    }
+
+    public void setBlog(String blog) {
+        this.blog = blog;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    @Override
+    public String toString() {
+        return "User{" + "login=" + login + ", id=" + id + ", url=" + url + ", company=" + company + ", blog=" + blog + ", email=" + email + '}';
+    }
+
+}

libraries-http/src/main/java/com/baeldung/retrofitguide/UserService.java

@@ -0,0 +1,17 @@
+package com.baeldung.retrofitguide;
+
+import java.util.List;
+import retrofit2.Call;
+import retrofit2.http.GET;
+import retrofit2.http.Path;
+import retrofit2.http.Query;
+
+public interface UserService {
+
+    @GET("/users")
+    public Call<List<User>> getUsers(@Query("per_page") int per_page, @Query("page") int page);
+
+    @GET("/users/{username}")
+    public Call<User> getUser(@Path("username") String username);
+
+}

libraries-http/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

libraries-http/src/test/java/com/baeldung/asynchttpclient/AsyncHttpClientLiveTest.java

@@ -0,0 +1,204 @@
+package com.baeldung.asynchttpclient;
+
+import io.netty.handler.codec.http.HttpHeaders;
+import org.asynchttpclient.AsyncCompletionHandler;
+import org.asynchttpclient.AsyncHandler;
+import org.asynchttpclient.AsyncHttpClient;
+import org.asynchttpclient.AsyncHttpClientConfig;
+import org.asynchttpclient.BoundRequestBuilder;
+import org.asynchttpclient.Dsl;
+import org.asynchttpclient.HttpResponseBodyPart;
+import org.asynchttpclient.HttpResponseStatus;
+import org.asynchttpclient.ListenableFuture;
+import org.asynchttpclient.Request;
+import org.asynchttpclient.Response;
+import org.asynchttpclient.ws.WebSocket;
+import org.asynchttpclient.ws.WebSocketListener;
+import org.asynchttpclient.ws.WebSocketUpgradeHandler;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public class AsyncHttpClientLiveTest {
+
+    private static AsyncHttpClient HTTP_CLIENT;
+
+    @Before
+    public void setup() {
+        AsyncHttpClientConfig clientConfig = Dsl.config().setConnectTimeout(15000).setRequestTimeout(15000).build();
+        HTTP_CLIENT = Dsl.asyncHttpClient(clientConfig);
+    }
+
+    @Test
+    public void givenHttpClient_executeSyncGetRequest() {
+
+        BoundRequestBuilder boundGetRequest = HTTP_CLIENT.prepareGet("http://www.baeldung.com");
+
+        Future<Response> responseFuture = boundGetRequest.execute();
+        try {
+            Response response = responseFuture.get(5000, TimeUnit.MILLISECONDS);
+            assertNotNull(response);
+            assertEquals(200, response.getStatusCode());
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            e.printStackTrace();
+        }
+
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void givenHttpClient_executeAsyncGetRequest() {
+
+        // execute an unbound GET request
+        Request unboundGetRequest = Dsl.get("http://www.baeldung.com").build();
+
+        HTTP_CLIENT.executeRequest(unboundGetRequest, new AsyncCompletionHandler<Integer>() {
+            @Override
+            public Integer onCompleted(Response response) {
+
+                int resposeStatusCode = response.getStatusCode();
+                assertEquals(200, resposeStatusCode);
+                return resposeStatusCode;
+            }
+        });
+
+        // execute a bound GET request
+        BoundRequestBuilder boundGetRequest = HTTP_CLIENT.prepareGet("http://www.baeldung.com");
+
+        boundGetRequest.execute(new AsyncCompletionHandler<Integer>() {
+            @Override
+            public Integer onCompleted(Response response) {
+                int resposeStatusCode = response.getStatusCode();
+                assertEquals(200, resposeStatusCode);
+                return resposeStatusCode;
+            }
+        });
+
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void givenHttpClient_executeAsyncGetRequestWithAsyncHandler() {
+
+        // execute an unbound GET request
+        Request unboundGetRequest = Dsl.get("http://www.baeldung.com").build();
+
+        HTTP_CLIENT.executeRequest(unboundGetRequest, new AsyncHandler<Integer>() {
+
+            int responseStatusCode = -1;
+
+            @Override
+            public State onStatusReceived(HttpResponseStatus responseStatus) {
+                responseStatusCode = responseStatus.getStatusCode();
+                return State.CONTINUE;
+            }
+
+            @Override
+            public State onHeadersReceived(HttpHeaders headers) {
+                return State.CONTINUE;
+            }
+
+            @Override
+            public State onBodyPartReceived(HttpResponseBodyPart bodyPart) {
+                return State.CONTINUE;
+            }
+
+            @Override
+            public void onThrowable(Throwable t) {
+
+            }
+
+            @Override
+            public Integer onCompleted() {
+                assertEquals(200, responseStatusCode);
+                return responseStatusCode;
+            }
+        });
+
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void givenHttpClient_executeAsyncGetRequestWithListanableFuture() {
+        // execute an unbound GET request
+        Request unboundGetRequest = Dsl.get("http://www.baeldung.com").build();
+
+        ListenableFuture<Response> listenableFuture = HTTP_CLIENT.executeRequest(unboundGetRequest);
+        listenableFuture.addListener(() -> {
+            Response response;
+            try {
+                response = listenableFuture.get(5000, TimeUnit.MILLISECONDS);
+                assertEquals(200, response.getStatusCode());
+            } catch (InterruptedException | ExecutionException | TimeoutException e) {
+                e.printStackTrace();
+            }
+        }, Executors.newCachedThreadPool());
+
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void givenWebSocketClient_tryToConnect() {
+
+        WebSocketUpgradeHandler.Builder upgradeHandlerBuilder = new WebSocketUpgradeHandler.Builder();
+        WebSocketUpgradeHandler wsHandler = upgradeHandlerBuilder.addWebSocketListener(new WebSocketListener() {
+            @Override
+            public void onOpen(WebSocket websocket) {
+                // WebSocket connection opened
+            }
+
+            @Override
+            public void onClose(WebSocket websocket, int code, String reason) {
+                // WebSocket connection closed
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                // WebSocket connection error
+                assertTrue(t.getMessage().contains("Request timeout"));
+            }
+        }).build();
+
+        WebSocket WEBSOCKET_CLIENT = null;
+        try {
+            WEBSOCKET_CLIENT = Dsl.asyncHttpClient().prepareGet("ws://localhost:5590/websocket").addHeader("header_name", "header_value").addQueryParam("key", "value").setRequestTimeout(5000).execute(wsHandler).get();
+
+            if (WEBSOCKET_CLIENT.isOpen()) {
+                WEBSOCKET_CLIENT.sendPingFrame();
+                WEBSOCKET_CLIENT.sendTextFrame("test message");
+                WEBSOCKET_CLIENT.sendBinaryFrame(new byte[] { 't', 'e', 's', 't' });
+            }
+        } catch (InterruptedException | ExecutionException e) {
+            e.printStackTrace();
+        } finally {
+            if (WEBSOCKET_CLIENT != null && WEBSOCKET_CLIENT.isOpen()) {
+                WEBSOCKET_CLIENT.sendCloseFrame(200, "OK");
+            }
+        }
+    }
+}

libraries-http/src/test/java/com/baeldung/client/Consts.java

@@ -0,0 +1,5 @@
+package com.baeldung.client;
+
+public interface Consts {
+    int APPLICATION_PORT = 8082;
+}

libraries-http/src/test/java/com/baeldung/okhttp/DefaultContentTypeInterceptor.java

@@ -0,0 +1,24 @@
+package com.baeldung.okhttp;
+
+import java.io.IOException;
+
+import okhttp3.Interceptor;
+import okhttp3.Request;
+import okhttp3.Response;
+
+public class DefaultContentTypeInterceptor implements Interceptor {
+
+    private final String contentType;
+
+    public DefaultContentTypeInterceptor(String contentType) {
+        this.contentType = contentType;
+    }
+
+    public Response intercept(Interceptor.Chain chain) throws IOException {
+
+        Request originalRequest = chain.request();
+        Request requestWithUserAgent = originalRequest.newBuilder().header("Content-Type", contentType).build();
+
+        return chain.proceed(requestWithUserAgent);
+    }
+}

libraries-http/src/test/java/com/baeldung/okhttp/OkHttpFileUploadingLiveTest.java

@@ -0,0 +1,68 @@
+package com.baeldung.okhttp;
+
+import static com.baeldung.client.Consts.APPLICATION_PORT;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+
+import okhttp3.Call;
+import okhttp3.MediaType;
+import okhttp3.MultipartBody;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Execute <code>spring-rest</code> module before running this live test
+ */
+public class OkHttpFileUploadingLiveTest {
+
+    private static final String BASE_URL = "http://localhost:" + APPLICATION_PORT + "/spring-rest";
+
+    OkHttpClient client;
+
+    @Before
+    public void init() {
+        client = new OkHttpClient();
+    }
+
+    @Test
+    public void whenUploadFile_thenCorrect() throws IOException {
+
+        final RequestBody requestBody = new MultipartBody.Builder().setType(MultipartBody.FORM).addFormDataPart("file", "file.txt", RequestBody.create(MediaType.parse("application/octet-stream"), new File("src/test/resources/test.txt"))).build();
+
+        final Request request = new Request.Builder().url(BASE_URL + "/users/upload").post(requestBody).build();
+
+        final Call call = client.newCall(request);
+        final Response response = call.execute();
+
+        assertThat(response.code(), equalTo(200));
+    }
+
+    @Test
+    public void whenGetUploadFileProgress_thenCorrect() throws IOException {
+
+        final RequestBody requestBody = new MultipartBody.Builder().setType(MultipartBody.FORM).addFormDataPart("file", "file.txt", RequestBody.create(MediaType.parse("application/octet-stream"), new File("src/test/resources/test.txt"))).build();
+
+        final ProgressRequestWrapper countingBody = new ProgressRequestWrapper(requestBody, (long bytesWritten, long contentLength) -> {
+
+            final float percentage = (100f * bytesWritten) / contentLength;
+            assertFalse(Float.compare(percentage, 100) > 0);
+        });
+
+        final Request request = new Request.Builder().url(BASE_URL + "/users/upload").post(countingBody).build();
+
+        final Call call = client.newCall(request);
+        final Response response = call.execute();
+
+        assertThat(response.code(), equalTo(200));
+
+    }
+}

libraries-http/src/test/java/com/baeldung/okhttp/OkHttpGetLiveTest.java

@@ -0,0 +1,80 @@
+package com.baeldung.okhttp;
+
+import static com.baeldung.client.Consts.APPLICATION_PORT;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.HttpUrl;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Execute <code>spring-rest</code> module before running this live test
+ */
+public class OkHttpGetLiveTest {
+
+    private static final String BASE_URL = "http://localhost:" + APPLICATION_PORT + "/spring-rest";
+
+    OkHttpClient client;
+
+    @Before
+    public void init() {
+
+        client = new OkHttpClient();
+    }
+
+    @Test
+    public void whenGetRequest_thenCorrect() throws IOException {
+        final Request request = new Request.Builder().url(BASE_URL + "/date").build();
+
+        final Call call = client.newCall(request);
+        final Response response = call.execute();
+
+        assertThat(response.code(), equalTo(200));
+    }
+
+    @Test
+    public void whenGetRequestWithQueryParameter_thenCorrect() throws IOException {
+        final HttpUrl.Builder urlBuilder = HttpUrl.parse(BASE_URL + "/ex/bars").newBuilder();
+        urlBuilder.addQueryParameter("id", "1");
+
+        final String url = urlBuilder.build().toString();
+
+        final Request request = new Request.Builder().url(url).build();
+
+        final Call call = client.newCall(request);
+        final Response response = call.execute();
+
+        assertThat(response.code(), equalTo(200));
+    }
+
+    @Test
+    public void whenAsynchronousGetRequest_thenCorrect() throws InterruptedException {
+        final Request request = new Request.Builder().url(BASE_URL + "/date").build();
+
+        final Call call = client.newCall(request);
+
+        call.enqueue(new Callback() {
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                System.out.println("OK");
+            }
+
+            @Override
+            public void onFailure(Call call, IOException e) {
+                fail();
+            }
+        });
+
+        Thread.sleep(3000);
+    }
+}

libraries-http/src/test/java/com/baeldung/okhttp/OkHttpHeaderLiveTest.java

@@ -0,0 +1,45 @@
+package com.baeldung.okhttp;
+
+import java.io.IOException;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import okhttp3.Call;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+
+public class OkHttpHeaderLiveTest {
+
+    private static final String SAMPLE_URL = "http://www.github.com";
+
+    OkHttpClient client;
+
+    @Before
+    public void init() {
+
+        client = new OkHttpClient();
+    }
+
+    @Test
+    public void whenSetHeader_thenCorrect() throws IOException {
+        Request request = new Request.Builder().url(SAMPLE_URL).addHeader("Content-Type", "application/json").build();
+
+        Call call = client.newCall(request);
+        Response response = call.execute();
+        response.close();
+    }
+
+    @Test
+    public void whenSetDefaultHeader_thenCorrect() throws IOException {
+
+        OkHttpClient clientWithInterceptor = new OkHttpClient.Builder().addInterceptor(new DefaultContentTypeInterceptor("application/json")).build();
+
+        Request request = new Request.Builder().url(SAMPLE_URL).build();
+
+        Call call = clientWithInterceptor.newCall(request);
+        Response response = call.execute();
+        response.close();
+    }
+}

libraries-http/src/test/java/com/baeldung/okhttp/OkHttpMiscLiveTest.java

@@ -0,0 +1,102 @@
+package com.baeldung.okhttp;
+
+import static com.baeldung.client.Consts.APPLICATION_PORT;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.SocketTimeoutException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import okhttp3.Cache;
+import okhttp3.Call;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Execute <code>spring-rest</code> module before running this live test
+ */
+public class OkHttpMiscLiveTest {
+
+    private static final String BASE_URL = "http://localhost:" + APPLICATION_PORT + "/spring-rest";
+    private static Logger logger = LoggerFactory.getLogger(OkHttpMiscLiveTest.class);
+
+    OkHttpClient client;
+
+    @Before
+    public void init() {
+
+        client = new OkHttpClient();
+    }
+
+    @Test(expected = SocketTimeoutException.class)
+    public void whenSetRequestTimeout_thenFail() throws IOException {
+        final OkHttpClient clientWithTimeout = new OkHttpClient.Builder().readTimeout(1, TimeUnit.SECONDS).build();
+
+        final Request request = new Request.Builder().url(BASE_URL + "/delay/2") // This URL is served with a 2 second delay.
+                .build();
+
+        final Call call = clientWithTimeout.newCall(request);
+        final Response response = call.execute();
+        response.close();
+    }
+
+    @Test(expected = IOException.class)
+    public void whenCancelRequest_thenCorrect() throws IOException {
+        final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
+
+        final Request request = new Request.Builder().url(BASE_URL + "/delay/2") // This URL is served with a 2 second delay.
+                .build();
+
+        final int seconds = 1;
+        final long startNanos = System.nanoTime();
+
+        final Call call = client.newCall(request);
+
+        // Schedule a job to cancel the call in 1 second.
+        executor.schedule(() -> {
+
+            logger.debug("Canceling call: " + ((System.nanoTime() - startNanos) / 1e9f));
+            call.cancel();
+            logger.debug("Canceled call: " + ((System.nanoTime() - startNanos) / 1e9f));
+
+        }, seconds, TimeUnit.SECONDS);
+
+        logger.debug("Executing call: " + ((System.nanoTime() - startNanos) / 1e9f));
+        final Response response = call.execute();
+        logger.debug("Call completed: " + ((System.nanoTime() - startNanos) / 1e9f), response);
+    }
+
+    @Test
+    public void whenSetResponseCache_thenCorrect() throws IOException {
+
+        final int cacheSize = 10 * 1024 * 1024; // 10 MiB
+        final File cacheDirectory = new File("src/test/resources/cache");
+        final Cache cache = new Cache(cacheDirectory, cacheSize);
+
+        final OkHttpClient clientCached = new OkHttpClient.Builder().cache(cache).build();
+
+        final Request request = new Request.Builder().url("http://publicobject.com/helloworld.txt").build();
+
+        final Response response1 = clientCached.newCall(request).execute();
+        logResponse(response1);
+
+        final Response response2 = clientCached.newCall(request).execute();
+        logResponse(response2);
+    }
+
+    private void logResponse(Response response) throws IOException {
+
+        logger.debug("Response response:          " + response);
+        logger.debug("Response cache response:    " + response.cacheResponse());
+        logger.debug("Response network response:  " + response.networkResponse());
+        logger.debug("Response responseBody:      " + response.body().string());
+    }
+}

libraries-http/src/test/java/com/baeldung/okhttp/OkHttpPostingLiveTest.java

@@ -0,0 +1,88 @@
+package com.baeldung.okhttp;
+
+import static com.baeldung.client.Consts.APPLICATION_PORT;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+
+import okhttp3.Call;
+import okhttp3.Credentials;
+import okhttp3.FormBody;
+import okhttp3.MediaType;
+import okhttp3.MultipartBody;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Execute <code>spring-rest</code> module before running this live test
+ */
+public class OkHttpPostingLiveTest {
+
+    private static final String BASE_URL = "http://localhost:" + APPLICATION_PORT + "/spring-rest";
+    private static final String URL_SECURED_BY_BASIC_AUTHENTICATION = "http://browserspy.dk/password-ok.php";
+
+    OkHttpClient client;
+
+    @Before
+    public void init() {
+
+        client = new OkHttpClient();
+    }
+
+    @Test
+    public void whenSendPostRequest_thenCorrect() throws IOException {
+        final RequestBody formBody = new FormBody.Builder().add("username", "test").add("password", "test").build();
+
+        final Request request = new Request.Builder().url(BASE_URL + "/users").post(formBody).build();
+
+        final Call call = client.newCall(request);
+        final Response response = call.execute();
+
+        assertThat(response.code(), equalTo(200));
+    }
+
+    @Test
+    public void whenSendPostRequestWithAuthorization_thenCorrect() throws IOException {
+        final String postBody = "test post";
+
+        final Request request = new Request.Builder().url(URL_SECURED_BY_BASIC_AUTHENTICATION).addHeader("Authorization", Credentials.basic("test", "test")).post(RequestBody.create(MediaType.parse("text/x-markdown; charset=utf-8"), "test post")).build();
+
+        final Call call = client.newCall(request);
+        final Response response = call.execute();
+
+        assertThat(response.code(), equalTo(200));
+    }
+
+    @Test
+    public void whenPostJson_thenCorrect() throws IOException {
+        final String json = "{\"id\":1,\"name\":\"John\"}";
+
+        final RequestBody body = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), "{\"id\":1,\"name\":\"John\"}");
+        final Request request = new Request.Builder().url(BASE_URL + "/users/detail").post(body).build();
+
+        final Call call = client.newCall(request);
+        final Response response = call.execute();
+
+        assertThat(response.code(), equalTo(200));
+    }
+
+    @Test
+    public void whenSendMultipartRequest_thenCorrect() throws IOException {
+        final RequestBody requestBody = new MultipartBody.Builder().setType(MultipartBody.FORM).addFormDataPart("username", "test").addFormDataPart("password", "test")
+                .addFormDataPart("file", "file.txt", RequestBody.create(MediaType.parse("application/octet-stream"), new File("src/test/resources/test.txt"))).build();
+
+        final Request request = new Request.Builder().url(BASE_URL + "/users/multipart").post(requestBody).build();
+
+        final Call call = client.newCall(request);
+        final Response response = call.execute();
+
+        assertThat(response.code(), equalTo(200));
+    }
+}

libraries-http/src/test/java/com/baeldung/okhttp/OkHttpRedirectLiveTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.okhttp;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+import java.io.IOException;
+
+import org.junit.Test;
+
+import okhttp3.Call;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+
+public class OkHttpRedirectLiveTest {
+
+    @Test
+    public void whenSetFollowRedirects_thenNotRedirected() throws IOException {
+
+        OkHttpClient client = new OkHttpClient().newBuilder().followRedirects(false).build();
+
+        Request request = new Request.Builder().url("http://t.co/I5YYd9tddw").build();
+
+        Call call = client.newCall(request);
+        Response response = call.execute();
+
+        assertThat(response.code(), equalTo(301));
+    }
+}

libraries-http/src/test/java/com/baeldung/okhttp/ProgressRequestWrapper.java

@@ -0,0 +1,73 @@
+package com.baeldung.okhttp;
+
+import okhttp3.RequestBody;
+import okhttp3.MediaType;
+
+import java.io.IOException;
+
+import okio.Buffer;
+import okio.BufferedSink;
+import okio.ForwardingSink;
+import okio.Okio;
+import okio.Sink;
+
+public class ProgressRequestWrapper extends RequestBody {
+
+    protected RequestBody delegate;
+    protected ProgressListener listener;
+
+    protected CountingSink countingSink;
+
+    public ProgressRequestWrapper(RequestBody delegate, ProgressListener listener) {
+        this.delegate = delegate;
+        this.listener = listener;
+    }
+
+    @Override
+    public MediaType contentType() {
+        return delegate.contentType();
+    }
+
+    @Override
+    public long contentLength() throws IOException {
+        return delegate.contentLength();
+    }
+
+    @Override
+    public void writeTo(BufferedSink sink) throws IOException {
+
+        BufferedSink bufferedSink;
+
+        countingSink = new CountingSink(sink);
+        bufferedSink = Okio.buffer(countingSink);
+
+        delegate.writeTo(bufferedSink);
+
+        bufferedSink.flush();
+    }
+
+    protected final class CountingSink extends ForwardingSink {
+
+        private long bytesWritten = 0;
+
+        public CountingSink(Sink delegate) {
+            super(delegate);
+        }
+
+        @Override
+        public void write(Buffer source, long byteCount) throws IOException {
+
+            super.write(source, byteCount);
+
+            bytesWritten += byteCount;
+            listener.onRequestProgress(bytesWritten, contentLength());
+        }
+
+    }
+
+    public interface ProgressListener {
+
+        void onRequestProgress(long bytesWritten, long contentLength);
+
+    }
+}

libraries-http/src/test/java/com/baeldung/retrofit/basic/GitHubBasicApiLiveTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.retrofit.basic;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.baeldung.retrofit.basic.GitHubBasicApi;
+import com.baeldung.retrofit.models.Contributor;
+import com.baeldung.retrofit.models.Repository;
+
+import retrofit2.Retrofit;
+import retrofit2.converter.gson.GsonConverterFactory;
+
+public class GitHubBasicApiLiveTest {
+
+    GitHubBasicApi gitHub;
+
+    @Before
+    public void init() {
+        Retrofit retrofit = new Retrofit.Builder().baseUrl("https://api.github.com/").addConverterFactory(GsonConverterFactory.create()).build();
+
+        gitHub = retrofit.create(GitHubBasicApi.class);
+    }
+
+    @Test
+    public void whenListRepos_thenExpectReposThatContainTutorials() {
+        try {
+            List<Repository> repos = gitHub.listRepos("eugenp").execute().body();
+
+            assertThat(repos).isNotEmpty().extracting(Repository::getName).contains("tutorials");
+        } catch (IOException e) {
+            fail("Can not communicate with GitHub API");
+        }
+    }
+
+    @Test
+    public void whenListRepoContributers_thenExpectContributorsThatContainEugenp() {
+        try {
+            List<Contributor> contributors = gitHub.listRepoContributors("eugenp", "tutorials").execute().body();
+
+            assertThat(contributors).isNotEmpty().extracting(Contributor::getName).contains("eugenp");
+        } catch (IOException e) {
+            fail("Can not communicate with GitHub API");
+        }
+    }
+
+}

libraries-http/src/test/java/com/baeldung/retrofit/rx/GitHubRxLiveTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.retrofit.rx;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.baeldung.retrofit.models.Contributor;
+import com.baeldung.retrofit.models.Repository;
+import com.baeldung.retrofit.rx.GitHubRxApi;
+
+import retrofit2.Retrofit;
+import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
+import retrofit2.converter.gson.GsonConverterFactory;
+
+public class GitHubRxLiveTest {
+
+    GitHubRxApi gitHub;
+
+    @Before
+    public void init() {
+        Retrofit retrofit = new Retrofit.Builder().baseUrl("https://api.github.com/").addConverterFactory(GsonConverterFactory.create()).addCallAdapterFactory(RxJavaCallAdapterFactory.create()).build();
+
+        gitHub = retrofit.create(GitHubRxApi.class);
+    }
+
+    @Test
+    public void whenListRepos_thenExpectReposThatContainTutorials() {
+        gitHub.listRepos("eugenp").subscribe(repos -> {
+            assertThat(repos).isNotEmpty().extracting(Repository::getName).contains("tutorials");
+        });
+    }
+
+    @Test
+    public void whenListRepoContributers_thenExpectContributorsThatContainEugenp() {
+        gitHub.listRepoContributors("eugenp", "tutorials").subscribe(contributors -> {
+            assertThat(contributors).isNotEmpty().extracting(Contributor::getName).contains("eugenp");
+        });
+    }
+
+}

libraries-http/src/test/java/com/baeldung/unirest/Article.java

@@ -0,0 +1,39 @@
+package com.baeldung.unirest;
+
+public class Article {
+
+    private String id;
+    private String title;
+    private String author;
+
+    public Article(String id, String title, String author) {
+        super();
+        this.id = id;
+        this.title = title;
+        this.author = author;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public String getAuthor() {
+        return author;
+    }
+
+    public void setAuthor(String author) {
+        this.author = author;
+    }
+}

libraries-http/src/test/java/com/baeldung/unirest/HttpClientLiveTest.java

@@ -0,0 +1,174 @@
+package com.baeldung.unirest;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import org.apache.http.entity.ContentType;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import com.baeldung.unirest.Article;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.mashape.unirest.http.HttpResponse;
+import com.mashape.unirest.http.JsonNode;
+import com.mashape.unirest.http.ObjectMapper;
+import com.mashape.unirest.http.Unirest;
+import com.mashape.unirest.http.async.Callback;
+import com.mashape.unirest.http.exceptions.UnirestException;
+
+public class HttpClientLiveTest {
+
+    @BeforeClass
+    public static void setup() {
+        // Unirest.setProxy(new HttpHost("localhost", 8080));
+        Unirest.setTimeouts(20000, 15000);
+        Unirest.setDefaultHeader("X-app-name", "baeldung-unirest");
+        Unirest.setDefaultHeader("X-request-id", "100004f00ab5");
+        Unirest.setConcurrency(20, 5);
+        Unirest.setObjectMapper(new ObjectMapper() {
+            com.fasterxml.jackson.databind.ObjectMapper mapper = new com.fasterxml.jackson.databind.ObjectMapper();
+
+            public String writeValue(Object value) {
+                try {
+                    return mapper.writeValueAsString(value);
+                } catch (JsonProcessingException e) {
+                    throw new RuntimeException(e);
+                }
+
+            }
+
+            public <T> T readValue(String value, Class<T> valueType) {
+
+                try {
+                    return mapper.readValue(value, valueType);
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+
+            }
+        });
+    }
+
+    @AfterClass
+    public static void tearDown() throws IOException {
+        Unirest.clearDefaultHeaders();
+        Unirest.shutdown();
+    }
+
+    @Test
+    public void shouldReturnStatusOkay() throws UnirestException {
+        HttpResponse<JsonNode> jsonResponse = Unirest.get("http://www.mocky.io/v2/5a9ce37b3100004f00ab5154")
+            .header("accept", "application/json")
+            .queryString("apiKey", "123")
+            .asJson();
+        assertNotNull(jsonResponse.getBody());
+        assertEquals(200, jsonResponse.getStatus());
+    }
+
+    @Test
+    public void shouldReturnStatusAccepted() throws UnirestException {
+
+        Map<String, String> headers = new HashMap<String, String>();
+        headers.put("accept", "application/json");
+        headers.put("Authorization", "Bearer 5a9ce37b3100004f00ab5154");
+
+        Map<String, Object> fields = new HashMap<String, Object>();
+        fields.put("name", "Sam Baeldung");
+        fields.put("id", "PSP123");
+
+        HttpResponse<JsonNode> jsonResponse = Unirest.put("http://www.mocky.io/v2/5a9ce7853100002a00ab515e")
+            .headers(headers)
+            .fields(fields)
+            .asJson();
+        assertNotNull(jsonResponse.getBody());
+        assertEquals(202, jsonResponse.getStatus());
+    }
+
+    @Test
+    public void givenRequestBodyWhenCreatedThenCorrect() throws UnirestException {
+
+        HttpResponse<JsonNode> jsonResponse = Unirest.post("http://www.mocky.io/v2/5a9ce7663100006800ab515d")
+            .body("{\"name\":\"Sam Baeldung\", \"city\":\"viena\"}")
+            .asJson();
+        assertEquals(201, jsonResponse.getStatus());
+    }
+
+    @Test
+    @Ignore
+    public void whenAysncRequestShouldReturnOk() throws InterruptedException, ExecutionException {
+        Future<HttpResponse<JsonNode>> future = Unirest.post("http://www.mocky.io/v2/5a9ce37b3100004f00ab5154?mocky-delay=10000ms")
+            .header("accept", "application/json")
+            .asJsonAsync(new Callback<JsonNode>() {
+
+                public void failed(UnirestException e) {
+                    // Do something if the request failed
+                }
+
+                public void completed(HttpResponse<JsonNode> response) {
+                    // Do something if the request is successful
+                }
+
+                public void cancelled() {
+                    // Do something if the request is cancelled
+                }
+
+            });
+        assertEquals(200, future.get()
+            .getStatus());
+
+    }
+
+    @Test
+    public void givenArticleWhenCreatedThenCorrect() throws UnirestException {
+        Article article = new Article("ID1213", "Guide to Rest", "baeldung");
+        HttpResponse<JsonNode> jsonResponse = Unirest.post("http://www.mocky.io/v2/5a9ce7663100006800ab515d")
+            .body(article)
+            .asJson();
+        assertEquals(201, jsonResponse.getStatus());
+    }
+
+    // @Test
+    public void givenFileWhenUploadedThenCorrect() throws UnirestException {
+
+        HttpResponse<JsonNode> jsonResponse = Unirest.post("http://www.mocky.io/v2/5a9ce7663100006800ab515d")
+            .field("file", new File("/path/to/file"))
+            .asJson();
+        assertEquals(201, jsonResponse.getStatus());
+    }
+
+    // @Test
+    public void givenByteStreamWhenUploadedThenCorrect() throws IOException, UnirestException {
+        try (InputStream inputStream = new FileInputStream(new File("/path/to/file/artcile.txt"))) {
+            byte[] bytes = new byte[inputStream.available()];
+            inputStream.read(bytes);
+            HttpResponse<JsonNode> jsonResponse = Unirest.post("http://www.mocky.io/v2/5a9ce7663100006800ab515d")
+                .field("file", bytes, "article.txt")
+                .asJson();
+            assertEquals(201, jsonResponse.getStatus());
+        }
+
+    }
+
+    // @Test
+    public void givenInputStreamWhenUploadedThenCorrect() throws UnirestException, IOException {
+        try (InputStream inputStream = new FileInputStream(new File("/path/to/file/artcile.txt"))) {
+
+            HttpResponse<JsonNode> jsonResponse = Unirest.post("http://www.mocky.io/v2/5a9ce7663100006800ab515d")
+                .field("file", inputStream, ContentType.APPLICATION_OCTET_STREAM, "article.txt")
+                .asJson();
+            assertEquals(201, jsonResponse.getStatus());
+
+        }
+    }
+}