HTTP REST Client with Retry Logic (java, written by Claude Code)

diff --git a/pom.xml b/pom.xml
index 5894e7d..4135f26 100644
--- a/pom.xml
+++ b/pom.xml
@@ -66,6 +66,7 @@
                     </archive>
                 </configuration>
             </plugin>
+<plugin>                <groupId>org.apache.maven.plugins</groupId>                <artifactId>maven-shade-plugin</artifactId>                <version>3.5.1</version>                <executions>                    <execution>                        <phase>package</phase>                        <goals><goal>shade</goal></goals>                        <configuration>                            <transformers>                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">                                    <mainClass>RestClient</mainClass>                                </transformer>                            </transformers>                        </configuration>                    </execution>                </executions>            </plugin>
         </plugins>
     </build>
 </project>
--- /dev/null
+++ b/src/main/java/RestClient.java
@@ -0,0 +1,608 @@
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import picocli.CommandLine;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Option;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.Duration;
+import java.util.*;
+import java.util.concurrent.Callable;
+import java.util.function.BiFunction;
+import java.util.function.Predicate;
+import java.util.logging.*;
+
+/**
+ * HTTP REST Client with Retry Logic using java.net.http, picocli, and Gson.
+ *
+ * Features:
+ * - GET, POST, PUT, PATCH, DELETE with configurable retry/backoff
+ * - Request chaining with context interpolation
+ * - Response validation with custom rules
+ * - Structured logging
+ * - CLI interface via picocli
+ */
+@Command(name = "rest-client", mixinStandardHelpOptions = true, version = "1.0.0",
+         description = "HTTP REST Client with retry logic, chaining, and validation.")
+public class RestClient implements Callable<Integer> {
+
+    // -----------------------------------------------------------------------
+    // Logging
+    // -----------------------------------------------------------------------
+    private static final Logger logger = Logger.getLogger(RestClient.class.getName());
+
+    static {
+        ConsoleHandler handler = new ConsoleHandler();
+        handler.setLevel(Level.ALL);
+        handler.setFormatter(new SimpleFormatter());
+        logger.addHandler(handler);
+        logger.setLevel(Level.INFO);
+        logger.setUseParentHandlers(false);
+    }
+
+    // -----------------------------------------------------------------------
+    // Inner classes
+    // -----------------------------------------------------------------------
+
+    /** A single validation rule for an HTTP response. */
+    public static class ValidationRule {
+        private final String name;
+        private final Predicate<ResponseRecord> check;
+        private final String message;
+
+        public ValidationRule(String name, Predicate<ResponseRecord> check, String message) {
+            this.name = name;
+            this.check = check;
+            this.message = message;
+        }
+
+        public String getName() { return name; }
+        public String getMessage() { return message; }
+        public boolean test(ResponseRecord record) { return check.test(record); }
+    }
+
+    /** Exception thrown when validation fails. */
+    public static class ValidationException extends RuntimeException {
+        private final List<String> failedRules;
+
+        public ValidationException(List<String> failedRules) {
+            super("Validation failed: " + String.join(", ", failedRules));
+            this.failedRules = failedRules;
+        }
+
+        public List<String> getFailedRules() { return failedRules; }
+    }
+
+    /** Configuration for a single HTTP request. */
+    public static class RequestConfig {
+        private String method;
+        private String url;
+        private Map<String, String> headers;
+        private Map<String, String> queryParams;
+        private Object jsonBody;
+        private String label;
+        private List<ValidationRule> validators;
+        private long timeoutSeconds;
+
+        public RequestConfig(String method, String url) {
+            this.method = method;
+            this.url = url;
+            this.headers = new HashMap<>();
+            this.queryParams = new HashMap<>();
+            this.validators = new ArrayList<>();
+            this.label = "";
+            this.timeoutSeconds = 30;
+        }
+
+        public RequestConfig header(String key, String value) { headers.put(key, value); return this; }
+        public RequestConfig param(String key, String value) { queryParams.put(key, value); return this; }
+        public RequestConfig body(Object body) { this.jsonBody = body; return this; }
+        public RequestConfig label(String label) { this.label = label; return this; }
+        public RequestConfig validate(ValidationRule rule) { validators.add(rule); return this; }
+        public RequestConfig timeout(long seconds) { this.timeoutSeconds = seconds; return this; }
+
+        public String getMethod() { return method; }
+        public String getUrl() { return url; }
+        public void setUrl(String url) { this.url = url; }
+        public Map<String, String> getHeaders() { return headers; }
+        public void setHeaders(Map<String, String> headers) { this.headers = headers; }
+        public Map<String, String> getQueryParams() { return queryParams; }
+        public Object getJsonBody() { return jsonBody; }
+        public void setJsonBody(Object body) { this.jsonBody = body; }
+        public String getLabel() { return label; }
+        public List<ValidationRule> getValidators() { return validators; }
+        public long getTimeoutSeconds() { return timeoutSeconds; }
+    }
+
+    /** Stores details about a completed request/response cycle. */
+    public static class ResponseRecord {
+        private final String label;
+        private final String method;
+        private final String url;
+        private final int statusCode;
+        private final double elapsedSeconds;
+        private final Map<String, String> headers;
+        private final String rawBody;
+        private final JsonElement jsonBody;
+        private final boolean ok;
+        private List<String> validationErrors;
+
+        public ResponseRecord(String label, String method, String url, int statusCode,
+                              double elapsedSeconds, Map<String, String> headers,
+                              String rawBody, JsonElement jsonBody, boolean ok) {
+            this.label = label;
+            this.method = method;
+            this.url = url;
+            this.statusCode = statusCode;
+            this.elapsedSeconds = elapsedSeconds;
+            this.headers = headers;
+            this.rawBody = rawBody;
+            this.jsonBody = jsonBody;
+            this.ok = ok;
+            this.validationErrors = new ArrayList<>();
+        }
+
+        public String getLabel() { return label; }
+        public String getMethod() { return method; }
+        public String getUrl() { return url; }
+        public int getStatusCode() { return statusCode; }
+        public double getElapsedSeconds() { return elapsedSeconds; }
+        public Map<String, String> getHeaders() { return headers; }
+        public String getRawBody() { return rawBody; }
+        public JsonElement getJsonBody() { return jsonBody; }
+        public boolean isOk() { return ok && validationErrors.isEmpty(); }
+        public List<String> getValidationErrors() { return validationErrors; }
+        public void setValidationErrors(List<String> errors) { this.validationErrors = errors; }
+
+        public JsonObject getJsonObject() {
+            return jsonBody != null && jsonBody.isJsonObject() ? jsonBody.getAsJsonObject() : null;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Built-in validators
+    // -----------------------------------------------------------------------
+
+    public static ValidationRule statusOk() {
+        return new ValidationRule("status_ok",
+                r -> r.getStatusCode() >= 200 && r.getStatusCode() < 300,
+                "Expected 2xx status code");
+    }
+
+    public static ValidationRule statusEquals(int code) {
+        return new ValidationRule("status_" + code,
+                r -> r.getStatusCode() == code,
+                "Expected status code " + code);
+    }
+
+    public static ValidationRule jsonHasKey(String key) {
+        return new ValidationRule("has_key_" + key,
+                r -> r.getJsonObject() != null && r.getJsonObject().has(key),
+                "Expected JSON key '" + key + "' in response");
+    }
+
+    public static ValidationRule maxResponseTime(double seconds) {
+        return new ValidationRule("max_response_time",
+                r -> r.getElapsedSeconds() <= seconds,
+                "Response took longer than " + seconds + "s");
+    }
+
+    // -----------------------------------------------------------------------
+    // Client fields
+    // -----------------------------------------------------------------------
+
+    private String baseUrl;
+    private final HttpClient httpClient;
+    private final Gson gson;
+    private Map<String, String> defaultHeaders;
+    private Set<Integer> retryStatusCodes;
+    private int maxRetries;
+    private long backoffMillis;
+    private final List<ResponseRecord> history;
+
+    // -----------------------------------------------------------------------
+    // CLI options
+    // -----------------------------------------------------------------------
+
+    @Option(names = {"--base-url"}, description = "Base URL", defaultValue = "https://jsonplaceholder.typicode.com")
+    private String cliBaseUrl;
+
+    @Option(names = {"--retries"}, description = "Max retries", defaultValue = "3")
+    private int cliRetries;
+
+    @Option(names = {"--backoff"}, description = "Backoff in ms", defaultValue = "1000")
+    private long cliBackoff;
+
+    // -----------------------------------------------------------------------
+    // Constructors
+    // -----------------------------------------------------------------------
+
+    /** Default constructor for picocli. */
+    public RestClient() {
+        this.httpClient = HttpClient.newBuilder()
+                .connectTimeout(Duration.ofSeconds(30))
+                .followRedirects(HttpClient.Redirect.NORMAL)
+                .build();
+        this.gson = new GsonBuilder().setPrettyPrinting().create();
+        this.history = new ArrayList<>();
+        this.defaultHeaders = new HashMap<>();
+        this.retryStatusCodes = Set.of(429, 500, 502, 503, 504);
+        this.maxRetries = 3;
+        this.backoffMillis = 1000;
+        this.baseUrl = "";
+    }
+
+    public RestClient(String baseUrl, Map<String, String> defaultHeaders,
+                      int maxRetries, long backoffMillis, Set<Integer> retryStatusCodes) {
+        this();
+        this.baseUrl = baseUrl.replaceAll("/+$", "");
+        this.defaultHeaders = defaultHeaders != null ? defaultHeaders : new HashMap<>();
+        this.maxRetries = maxRetries;
+        this.backoffMillis = backoffMillis;
+        this.retryStatusCodes = retryStatusCodes != null ? retryStatusCodes :
+                Set.of(429, 500, 502, 503, 504);
+    }
+
+    // -----------------------------------------------------------------------
+    // URL building
+    // -----------------------------------------------------------------------
+
+    private String buildUrl(String path) {
+        if (path.startsWith("http://") || path.startsWith("https://")) {
+            return path;
+        }
+        return baseUrl + "/" + path.replaceAll("^/+", "");
+    }
+
+    private String buildUrlWithParams(String url, Map<String, String> params) {
+        if (params == null || params.isEmpty()) return url;
+        StringBuilder sb = new StringBuilder(url);
+        sb.append(url.contains("?") ? "&" : "?");
+        boolean first = true;
+        for (Map.Entry<String, String> entry : params.entrySet()) {
+            if (!first) sb.append("&");
+            sb.append(entry.getKey()).append("=").append(entry.getValue());
+            first = false;
+        }
+        return sb.toString();
+    }
+
+    // -----------------------------------------------------------------------
+    // Core request
+    // -----------------------------------------------------------------------
+
+    public ResponseRecord request(RequestConfig cfg) {
+        String url = buildUrl(cfg.getUrl());
+        url = buildUrlWithParams(url, cfg.getQueryParams());
+        logger.info(String.format(">>> %s %s | label=%s",
+                cfg.getMethod().toUpperCase(), url, cfg.getLabel().isEmpty() ? "(none)" : cfg.getLabel()));
+
+        // Build request body
+        String bodyStr = null;
+        if (cfg.getJsonBody() != null) {
+            bodyStr = gson.toJson(cfg.getJsonBody());
+        }
+
+        // Build request
+        HttpRequest.Builder reqBuilder = HttpRequest.newBuilder()
+                .uri(URI.create(url))
+                .timeout(Duration.ofSeconds(cfg.getTimeoutSeconds()));
+
+        // Add headers
+        defaultHeaders.forEach(reqBuilder::header);
+        cfg.getHeaders().forEach(reqBuilder::header);
+
+        // Set method and body
+        HttpRequest.BodyPublisher bodyPublisher = bodyStr != null
+                ? HttpRequest.BodyPublishers.ofString(bodyStr)
+                : HttpRequest.BodyPublishers.noBody();
+
+        switch (cfg.getMethod().toUpperCase()) {
+            case "GET":    reqBuilder.GET(); break;
+            case "POST":   reqBuilder.POST(bodyPublisher); break;
+            case "PUT":    reqBuilder.PUT(bodyPublisher); break;
+            case "PATCH":  reqBuilder.method("PATCH", bodyPublisher); break;
+            case "DELETE": reqBuilder.DELETE(); break;
+            default: throw new IllegalArgumentException("Unsupported method: " + cfg.getMethod());
+        }
+
+        if (bodyStr != null) {
+            reqBuilder.header("Content-Type", "application/json");
+        }
+
+        HttpRequest request = reqBuilder.build();
+
+        // Execute with retry
+        for (int attempt = 0; attempt < maxRetries; attempt++) {
+            long start = System.nanoTime();
+            try {
+                HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+                double elapsed = (System.nanoTime() - start) / 1_000_000_000.0;
+
+                if (retryStatusCodes.contains(response.statusCode()) && attempt < maxRetries - 1) {
+                    logger.warning(String.format("Retryable status %d from %s – retry %d/%d",
+                            response.statusCode(), url, attempt + 1, maxRetries));
+                    Thread.sleep(backoffMillis * (long) Math.pow(2, attempt));
+                    continue;
+                }
+
+                // Parse response
+                String rawBody = response.body();
+                JsonElement jsonBody = null;
+                try {
+                    jsonBody = JsonParser.parseString(rawBody);
+                } catch (Exception ignored) {}
+
+                Map<String, String> respHeaders = new HashMap<>();
+                response.headers().map().forEach((k, v) -> respHeaders.put(k, String.join(", ", v)));
+
+                boolean isOk = response.statusCode() >= 200 && response.statusCode() < 300;
+                ResponseRecord record = new ResponseRecord(
+                        cfg.getLabel(), cfg.getMethod().toUpperCase(), url,
+                        response.statusCode(), elapsed, respHeaders, rawBody, jsonBody, isOk);
+
+                // Validate
+                List<String> errors = validate(record, cfg.getValidators());
+                record.setValidationErrors(errors);
+
+                logResponse(record);
+                history.add(record);
+
+                if (!errors.isEmpty()) {
+                    throw new ValidationException(errors);
+                }
+
+                return record;
+
+            } catch (ValidationException ve) {
+                throw ve;
+            } catch (InterruptedException ie) {
+                Thread.currentThread().interrupt();
+                throw new RuntimeException("Request interrupted", ie);
+            } catch (IOException e) {
+                if (attempt >= maxRetries - 1) {
+                    logger.severe(String.format("All retries exhausted for %s %s: %s",
+                            cfg.getMethod().toUpperCase(), url, e.getMessage()));
+                    throw new RuntimeException("Request failed after retries", e);
+                }
+                logger.warning(String.format("Attempt %d failed: %s – retrying...", attempt + 1, e.getMessage()));
+                try {
+                    Thread.sleep(backoffMillis * (long) Math.pow(2, attempt));
+                } catch (InterruptedException ie) {
+                    Thread.currentThread().interrupt();
+                    throw new RuntimeException("Retry sleep interrupted", ie);
+                }
+            }
+        }
+        throw new RuntimeException("Request failed after all retries");
+    }
+
+    private List<String> validate(ResponseRecord record, List<ValidationRule> rules) {
+        List<String> errors = new ArrayList<>();
+        for (ValidationRule rule : rules) {
+            try {
+                if (!rule.test(record)) {
+                    errors.add(rule.getMessage().isEmpty() ? rule.getName() : rule.getMessage());
+                    logger.warning(String.format("Validation failed [%s]: %s",
+                            rule.getName(), rule.getMessage()));
+                }
+            } catch (Exception e) {
+                errors.add(rule.getName() + ": " + e.getMessage());
+            }
+        }
+        return errors;
+    }
+
+    private void logResponse(ResponseRecord record) {
+        logger.log(record.isOk() ? Level.INFO : Level.WARNING,
+                String.format("<<< %d %s (%.3fs) | label=%s | errors=%s",
+                        record.getStatusCode(), record.getUrl(),
+                        record.getElapsedSeconds(),
+                        record.getLabel().isEmpty() ? "(none)" : record.getLabel(),
+                        record.getValidationErrors().isEmpty() ? "none" : record.getValidationErrors()));
+    }
+
+    // -----------------------------------------------------------------------
+    // Convenience methods
+    // -----------------------------------------------------------------------
+
+    public ResponseRecord get(String url, String label, ValidationRule... validators) {
+        RequestConfig cfg = new RequestConfig("GET", url).label(label);
+        for (ValidationRule v : validators) cfg.validate(v);
+        return request(cfg);
+    }
+
+    public ResponseRecord post(String url, Object body, String label, ValidationRule... validators) {
+        RequestConfig cfg = new RequestConfig("POST", url).body(body).label(label);
+        if (body != null) cfg.header("Content-Type", "application/json");
+        for (ValidationRule v : validators) cfg.validate(v);
+        return request(cfg);
+    }
+
+    public ResponseRecord put(String url, Object body, String label, ValidationRule... validators) {
+        RequestConfig cfg = new RequestConfig("PUT", url).body(body).label(label);
+        if (body != null) cfg.header("Content-Type", "application/json");
+        for (ValidationRule v : validators) cfg.validate(v);
+        return request(cfg);
+    }
+
+    public ResponseRecord patch(String url, Object body, String label, ValidationRule... validators) {
+        RequestConfig cfg = new RequestConfig("PATCH", url).body(body).label(label);
+        if (body != null) cfg.header("Content-Type", "application/json");
+        for (ValidationRule v : validators) cfg.validate(v);
+        return request(cfg);
+    }
+
+    public ResponseRecord delete(String url, String label, ValidationRule... validators) {
+        RequestConfig cfg = new RequestConfig("DELETE", url).label(label);
+        for (ValidationRule v : validators) cfg.validate(v);
+        return request(cfg);
+    }
+
+    // -----------------------------------------------------------------------
+    // Request chaining
+    // -----------------------------------------------------------------------
+
+    public List<ResponseRecord> chain(List<RequestConfig> configs,
+                                       Map<String, String> context,
+                                       BiFunction<ResponseRecord, Map<String, String>, Map<String, String>> extractor) {
+        Map<String, String> ctx = context != null ? new HashMap<>(context) : new HashMap<>();
+        List<ResponseRecord> results = new ArrayList<>();
+
+        for (int i = 0; i < configs.size(); i++) {
+            RequestConfig cfg = configs.get(i);
+            String cfgUrl = cfg.getUrl();
+            for (Map.Entry<String, String> entry : ctx.entrySet()) {
+                cfgUrl = cfgUrl.replace("{" + entry.getKey() + "}", entry.getValue());
+            }
+            cfg.setUrl(cfgUrl);
+
+            Map<String, String> headers = new HashMap<>();
+            for (Map.Entry<String, String> entry : cfg.getHeaders().entrySet()) {
+                String val = entry.getValue();
+                for (Map.Entry<String, String> ctxEntry : ctx.entrySet()) {
+                    val = val.replace("{" + ctxEntry.getKey() + "}", ctxEntry.getValue());
+                }
+                headers.put(entry.getKey(), val);
+            }
+            cfg.setHeaders(headers);
+
+            logger.info(String.format("Chain step %d/%d: %s", i + 1, configs.size(),
+                    cfg.getLabel().isEmpty() ? cfg.getUrl() : cfg.getLabel()));
+
+            ResponseRecord record = request(cfg);
+            results.add(record);
+
+            if (extractor != null) {
+                ctx = extractor.apply(record, ctx);
+            }
+        }
+        return results;
+    }
+
+    // -----------------------------------------------------------------------
+    // History
+    // -----------------------------------------------------------------------
+
+    public List<ResponseRecord> getHistory() { return Collections.unmodifiableList(history); }
+
+    public void printHistory() {
+        System.out.println("\n" + "=".repeat(70));
+        System.out.printf(" Request History (%d requests)%n", history.size());
+        System.out.println("=".repeat(70));
+        for (int i = 0; i < history.size(); i++) {
+            ResponseRecord r = history.get(i);
+            String status = r.isOk() ? "OK" : "FAIL";
+            System.out.printf("  [%d] %s | %s %s -> %d (%.3fs) | %s%n",
+                    i + 1, status, r.getMethod(), r.getUrl(),
+                    r.getStatusCode(), r.getElapsedSeconds(), r.getLabel());
+            for (String err : r.getValidationErrors()) {
+                System.out.printf("       ! %s%n", err);
+            }
+        }
+        System.out.println("=".repeat(70) + "\n");
+    }
+
+    // -----------------------------------------------------------------------
+    // CLI entry point
+    // -----------------------------------------------------------------------
+
+    @Override
+    public Integer call() {
+        this.baseUrl = cliBaseUrl.replaceAll("/+$", "");
+        this.maxRetries = cliRetries;
+        this.backoffMillis = cliBackoff;
+        this.defaultHeaders = Map.of("Accept", "application/json");
+
+        runDemo();
+        return 0;
+    }
+
+    private void runDemo() {
+        // 1. Simple GET
+        System.out.println("\n--- Simple GET with validation ---");
+        try {
+            ResponseRecord record = get("/posts/1", "get_post_1", statusOk(), jsonHasKey("title"));
+            if (record.getJsonObject() != null) {
+                System.out.println("Post title: " + record.getJsonObject().get("title").getAsString());
+            }
+        } catch (Exception e) {
+            System.out.println("Request failed: " + e.getMessage());
+        }
+
+        // 2. POST
+        System.out.println("\n--- POST with body ---");
+        try {
+            Map<String, Object> postBody = Map.of("title", "Hello", "body", "World", "userId", 1);
+            ResponseRecord record = post("/posts", postBody, "create_post", statusEquals(201));
+            if (record.getJsonObject() != null) {
+                System.out.println("Created post ID: " + record.getJsonObject().get("id").getAsInt());
+            }
+        } catch (Exception e) {
+            System.out.println("Request failed: " + e.getMessage());
+        }
+
+        // 3. Request chaining
+        System.out.println("\n--- Request chaining ---");
+        try {
+            List<RequestConfig> chainConfigs = new ArrayList<>(List.of(
+                    new RequestConfig("GET", "/users/1").label("get_user").validate(statusOk()),
+                    new RequestConfig("GET", "/users/{user_id}/posts").label("get_user_posts").validate(statusOk())
+            ));
+
+            BiFunction<ResponseRecord, Map<String, String>, Map<String, String>> extractor = (record, ctx) -> {
+                if (record.getJsonObject() != null && record.getJsonObject().has("id")) {
+                    ctx.put("user_id", String.valueOf(record.getJsonObject().get("id").getAsInt()));
+                }
+                return ctx;
+            };
+
+            List<ResponseRecord> results = chain(chainConfigs, null, extractor);
+            if (results.size() >= 2 && results.get(1).getJsonBody() != null
+                    && results.get(1).getJsonBody().isJsonArray()) {
+                System.out.println("User has " + results.get(1).getJsonBody().getAsJsonArray().size() + " posts");
+            }
+        } catch (Exception e) {
+            System.out.println("Chain failed: " + e.getMessage());
+        }
+
+        // 4. PUT
+        System.out.println("\n--- PUT request ---");
+        try {
+            Map<String, Object> putBody = Map.of("id", 1, "title", "Updated", "body", "Content", "userId", 1);
+            ResponseRecord record = put("/posts/1", putBody, "update_post", statusOk());
+            if (record.getJsonObject() != null) {
+                System.out.println("Updated title: " + record.getJsonObject().get("title").getAsString());
+            }
+        } catch (Exception e) {
+            System.out.println("Request failed: " + e.getMessage());
+        }
+
+        // 5. DELETE
+        System.out.println("\n--- DELETE request ---");
+        try {
+            ResponseRecord record = delete("/posts/1", "delete_post", statusOk());
+            System.out.println("Delete status: " + record.getStatusCode());
+        } catch (Exception e) {
+            System.out.println("Request failed: " + e.getMessage());
+        }
+
+        printHistory();
+    }
+
+    // -----------------------------------------------------------------------
+    // Main
+    // -----------------------------------------------------------------------
+
+    public static void main(String[] args) {
+        int exitCode = new CommandLine(new RestClient()).execute(args);
+        System.exit(exitCode);
+    }
+}

Claude Code wrote this java project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: HTTP REST Client with Retry Logic

Write a program that sends HTTP requests to REST APIs with configurable retry logic, response validation, request chaining, and comprehensive logging of request/response cycles.

FUNCTIONAL REQUIREMENTS:
- Accept a URL as a command-line argument with --method flag (GET, POST, PUT, PATCH, DELETE; default: GET)
- Support sending request body via --data flag (JSON string) or --file flag (read body from a file)
- Support custom headers via --header flag (repeatable, e.g., --header "Content-Type: application/json" --header "Authorization: Bearer token")
- Implement configurable retry logic: --retries flag (default 3), --backoff flag for backoff strategy (linear, exponential; default: exponential), --retry-delay flag for initial delay in seconds (default 1)
- Retry only on configurable HTTP status codes via --retry-on flag (default: 429, 500, 502, 503, 504)
- Support request timeout via --timeout flag (default 30 seconds)
- Support request chaining from a JSON recipe file via --chain flag: execute a sequence of requests where later requests can reference values from earlier responses using JSONPath expressions
- Log complete request/response cycles: method, URL, headers, body, status code, response headers, response body, timing, and retry attempts
- Support response validation via --expect-status flag (e.g., --expect-status 200) and --expect-json flag (JSONPath expression that must exist in the response)
- Print formatted response to console: status code, headers, and pretty-printed body (auto-detect JSON and format it)
- Save the full request/response log as JSON with --output flag (default: request_log.json)
- If no URL is given, demonstrate the client by sending requests to a public test API (httpbin.org or similar), showing GET, POST with JSON body, retry on simulated failure, and a simple request chain
- Handle errors: connection refused, DNS failure, SSL errors, malformed JSON responses, and redirect loops

Create a complete Java project for a clean Ubuntu 22.04 machine with only JDK 17+ installed. Include:
- Source code
- pom.xml with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[
  {
    "category": "misspecification",
    "rule": "signature.build_layout_mismatch",
    "source": "failure_signature",
    "excerpt": "error: no classes were compiled"
  }
]

<?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>

    <groupId>com.example</groupId>
    <artifactId>rest-client</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>HTTP REST Client with Retry Logic</name>
    <description>REST client using java.net.http with picocli CLI and Gson for JSON</description>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <picocli.version>4.7.5</picocli.version>
        <gson.version>2.10.1</gson.version>
    </properties>

    <dependencies>
        <!-- Picocli - CLI framework -->
        <dependency>
            <groupId>info.picocli</groupId>
            <artifactId>picocli</artifactId>
            <version>${picocli.version}</version>
        </dependency>

        <!-- Gson - JSON serialization/deserialization -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>${gson.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>info.picocli</groupId>
                            <artifactId>picocli-codegen</artifactId>
                            <version>${picocli.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>RestClient</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

# HTTP REST Client with Retry Logic (Java - Trial 3)

An HTTP REST client using java.net.http (built-in), picocli for CLI, and Gson for JSON handling.

## Dependencies

- **java.net.http** (built-in) - Java's built-in HTTP client with HTTP/2 support
- **picocli** (4.7.5) - CLI framework for Java
- **Gson** (2.10.1) - JSON serialization/deserialization

## Features

- GET, POST, PUT, PATCH, DELETE request methods
- Automatic retry with exponential backoff
- Configurable retry status codes
- Request chaining with context interpolation
- Response validation with built-in and custom rules
- Full request/response history with logging
- CLI interface via picocli

## Build and Run

```bash
mvn clean compile exec:java -Dexec.mainClass="RestClient"
```

Or:

```bash
mvn clean package
java -jar target/rest-client-1.0.0.jar
java -jar target/rest-client-1.0.0.jar --base-url https://api.example.com --retries 5
```

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import picocli.CommandLine;
import picocli.CommandLine.Command;
import picocli.CommandLine.Option;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.*;
import java.util.concurrent.Callable;
import java.util.function.BiFunction;
import java.util.function.Predicate;
import java.util.logging.*;

/**
 * HTTP REST Client with Retry Logic using java.net.http, picocli, and Gson.
 *
 * Features:
 * - GET, POST, PUT, PATCH, DELETE with configurable retry/backoff
 * - Request chaining with context interpolation
 * - Response validation with custom rules
 * - Structured logging
 * - CLI interface via picocli
 */
@Command(name = "rest-client", mixinStandardHelpOptions = true, version = "1.0.0",
         description = "HTTP REST Client with retry logic, chaining, and validation.")
public class RestClient implements Callable<Integer> {

    // -----------------------------------------------------------------------
    // Logging
    // -----------------------------------------------------------------------
    private static final Logger logger = Logger.getLogger(RestClient.class.getName());

    static {
        ConsoleHandler handler = new ConsoleHandler();
        handler.setLevel(Level.ALL);
        handler.setFormatter(new SimpleFormatter());
        logger.addHandler(handler);
        logger.setLevel(Level.INFO);
        logger.setUseParentHandlers(false);
    }

    // -----------------------------------------------------------------------
    // Inner classes
    // -----------------------------------------------------------------------

    /** A single validation rule for an HTTP response. */
    public static class ValidationRule {
        private final String name;
        private final Predicate<ResponseRecord> check;
        private final String message;

        public ValidationRule(String name, Predicate<ResponseRecord> check, String message) {
            this.name = name;
            this.check = check;
            this.message = message;
        }

        public String getName() { return name; }
        public String getMessage() { return message; }
        public boolean test(ResponseRecord record) { return check.test(record); }
    }

    /** Exception thrown when validation fails. */
    public static class ValidationException extends RuntimeException {
        private final List<String> failedRules;

        public ValidationException(List<String> failedRules) {
            super("Validation failed: " + String.join(", ", failedRules));
            this.failedRules = failedRules;
        }

        public List<String> getFailedRules() { return failedRules; }
    }

    /** Configuration for a single HTTP request. */
    public static class RequestConfig {
        private String method;
        private String url;
        private Map<String, String> headers;
        private Map<String, String> queryParams;
        private Object jsonBody;
        private String label;
        private List<ValidationRule> validators;
        private long timeoutSeconds;

        public RequestConfig(String method, String url) {
            this.method = method;
            this.url = url;
            this.headers = new HashMap<>();
            this.queryParams = new HashMap<>();
            this.validators = new ArrayList<>();
            this.label = "";
            this.timeoutSeconds = 30;
        }

        public RequestConfig header(String key, String value) { headers.put(key, value); return this; }
        public RequestConfig param(String key, String value) { queryParams.put(key, value); return this; }
        public RequestConfig body(Object body) { this.jsonBody = body; return this; }
        public RequestConfig label(String label) { this.label = label; return this; }
        public RequestConfig validate(ValidationRule rule) { validators.add(rule); return this; }
        public RequestConfig timeout(long seconds) { this.timeoutSeconds = seconds; return this; }

        public String getMethod() { return method; }
        public String getUrl() { return url; }
        public void setUrl(String url) { this.url = url; }
        public Map<String, String> getHeaders() { return headers; }
        public void setHeaders(Map<String, String> headers) { this.headers = headers; }
        public Map<String, String> getQueryParams() { return queryParams; }
        public Object getJsonBody() { return jsonBody; }
        public void setJsonBody(Object body) { this.jsonBody = body; }
        public String getLabel() { return label; }
        public List<ValidationRule> getValidators() { return validators; }
        public long getTimeoutSeconds() { return timeoutSeconds; }
    }

    /** Stores details about a completed request/response cycle. */
    public static class ResponseRecord {
        private final String label;
        private final String method;
        private final String url;
        private final int statusCode;
        private final double elapsedSeconds;
        private final Map<String, String> headers;
        private final String rawBody;
        private final JsonElement jsonBody;
        private final boolean ok;
        private List<String> validationErrors;

        public ResponseRecord(String label, String method, String url, int statusCode,
                              double elapsedSeconds, Map<String, String> headers,
                              String rawBody, JsonElement jsonBody, boolean ok) {
            this.label = label;
            this.method = method;
            this.url = url;
            this.statusCode = statusCode;
            this.elapsedSeconds = elapsedSeconds;
            this.headers = headers;
            this.rawBody = rawBody;
            this.jsonBody = jsonBody;
            this.ok = ok;
            this.validationErrors = new ArrayList<>();
        }

        public String getLabel() { return label; }
        public String getMethod() { return method; }
        public String getUrl() { return url; }
        public int getStatusCode() { return statusCode; }
        public double getElapsedSeconds() { return elapsedSeconds; }
        public Map<String, String> getHeaders() { return headers; }
        public String getRawBody() { return rawBody; }
        public JsonElement getJsonBody() { return jsonBody; }
        public boolean isOk() { return ok && validationErrors.isEmpty(); }
        public List<String> getValidationErrors() { return validationErrors; }
        public void setValidationErrors(List<String> errors) { this.validationErrors = errors; }

        public JsonObject getJsonObject() {
            return jsonBody != null && jsonBody.isJsonObject() ? jsonBody.getAsJsonObject() : null;
        }
    }

    // -----------------------------------------------------------------------
    // Built-in validators
    // -----------------------------------------------------------------------

    public static ValidationRule statusOk() {
        return new ValidationRule("status_ok",
                r -> r.getStatusCode() >= 200 && r.getStatusCode() < 300,
                "Expected 2xx status code");
    }

    public static ValidationRule statusEquals(int code) {
        return new ValidationRule("status_" + code,
                r -> r.getStatusCode() == code,
                "Expected status code " + code);
    }

    public static ValidationRule jsonHasKey(String key) {
        return new ValidationRule("has_key_" + key,
                r -> r.getJsonObject() != null && r.getJsonObject().has(key),
                "Expected JSON key '" + key + "' in response");
    }

    public static ValidationRule maxResponseTime(double seconds) {
        return new ValidationRule("max_response_time",
                r -> r.getElapsedSeconds() <= seconds,
                "Response took longer than " + seconds + "s");
    }

    // -----------------------------------------------------------------------
    // Client fields
    // -----------------------------------------------------------------------

    private String baseUrl;
    private final HttpClient httpClient;
    private final Gson gson;
    private Map<String, String> defaultHeaders;
    private Set<Integer> retryStatusCodes;
    private int maxRetries;
    private long backoffMillis;
    private final List<ResponseRecord> history;

    // -----------------------------------------------------------------------
    // CLI options
    // -----------------------------------------------------------------------

    @Option(names = {"--base-url"}, description = "Base URL", defaultValue = "https://jsonplaceholder.typicode.com")
    private String cliBaseUrl;

    @Option(names = {"--retries"}, description = "Max retries", defaultValue = "3")
    private int cliRetries;

    @Option(names = {"--backoff"}, description = "Backoff in ms", defaultValue = "1000")
    private long cliBackoff;

    // -----------------------------------------------------------------------
    // Constructors
    // -----------------------------------------------------------------------

    /** Default constructor for picocli. */
    public RestClient() {
        this.httpClient = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(30))
                .followRedirects(HttpClient.Redirect.NORMAL)
                .build();
        this.gson = new GsonBuilder().setPrettyPrinting().create();
        this.history = new ArrayList<>();
        this.defaultHeaders = new HashMap<>();
        this.retryStatusCodes = Set.of(429, 500, 502, 503, 504);
        this.maxRetries = 3;
        this.backoffMillis = 1000;
        this.baseUrl = "";
    }

    public RestClient(String baseUrl, Map<String, String> defaultHeaders,
                      int maxRetries, long backoffMillis, Set<Integer> retryStatusCodes) {
        this();
        this.baseUrl = baseUrl.replaceAll("/+$", "");
        this.defaultHeaders = defaultHeaders != null ? defaultHeaders : new HashMap<>();
        this.maxRetries = maxRetries;
        this.backoffMillis = backoffMillis;
        this.retryStatusCodes = retryStatusCodes != null ? retryStatusCodes :
                Set.of(429, 500, 502, 503, 504);
    }

    // -----------------------------------------------------------------------
    // URL building
    // -----------------------------------------------------------------------

    private String buildUrl(String path) {
        if (path.startsWith("http://") || path.startsWith("https://")) {
            return path;
        }
        return baseUrl + "/" + path.replaceAll("^/+", "");
    }

    private String buildUrlWithParams(String url, Map<String, String> params) {
        if (params == null || params.isEmpty()) return url;
        StringBuilder sb = new StringBuilder(url);
        sb.append(url.contains("?") ? "&" : "?");
        boolean first = true;
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (!first) sb.append("&");
            sb.append(entry.getKey()).append("=").append(entry.getValue());
            first = false;
        }
        return sb.toString();
    }

    // -----------------------------------------------------------------------
    // Core request
    // -----------------------------------------------------------------------

    public ResponseRecord request(RequestConfig cfg) {
        String url = buildUrl(cfg.getUrl());
        url = buildUrlWithParams(url, cfg.getQueryParams());
        logger.info(String.format(">>> %s %s | label=%s",
                cfg.getMethod().toUpperCase(), url, cfg.getLabel().isEmpty() ? "(none)" : cfg.getLabel()));

        // Build request body
        String bodyStr = null;
        if (cfg.getJsonBody() != null) {
            bodyStr = gson.toJson(cfg.getJsonBody());
        }

        // Build request
        HttpRequest.Builder reqBuilder = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .timeout(Duration.ofSeconds(cfg.getTimeoutSeconds()));

        // Add headers
        defaultHeaders.forEach(reqBuilder::header);
        cfg.getHeaders().forEach(reqBuilder::header);

        // Set method and body
        HttpRequest.BodyPublisher bodyPublisher = bodyStr != null
                ? HttpRequest.BodyPublishers.ofString(bodyStr)
                : HttpRequest.BodyPublishers.noBody();

        switch (cfg.getMethod().toUpperCase()) {
            case "GET":    reqBuilder.GET(); break;
            case "POST":   reqBuilder.POST(bodyPublisher); break;
            case "PUT":    reqBuilder.PUT(bodyPublisher); break;
            case "PATCH":  reqBuilder.method("PATCH", bodyPublisher); break;
            case "DELETE": reqBuilder.DELETE(); break;
            default: throw new IllegalArgumentException("Unsupported method: " + cfg.getMethod());
        }

        if (bodyStr != null) {
            reqBuilder.header("Content-Type", "application/json");
        }

        HttpRequest request = reqBuilder.build();

        // Execute with retry
        for (int attempt = 0; attempt < maxRetries; attempt++) {
            long start = System.nanoTime();
            try {
                HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
                double elapsed = (System.nanoTime() - start) / 1_000_000_000.0;

                if (retryStatusCodes.contains(response.statusCode()) && attempt < maxRetries - 1) {
                    logger.warning(String.format("Retryable status %d from %s – retry %d/%d",
                            response.statusCode(), url, attempt + 1, maxRetries));
                    Thread.sleep(backoffMillis * (long) Math.pow(2, attempt));
                    continue;
                }

                // Parse response
                String rawBody = response.body();
                JsonElement jsonBody = null;
                try {
                    jsonBody = JsonParser.parseString(rawBody);
                } catch (Exception ignored) {}

                Map<String, String> respHeaders = new HashMap<>();
                response.headers().map().forEach((k, v) -> respHeaders.put(k, String.join(", ", v)));

                boolean isOk = response.statusCode() >= 200 && response.statusCode() < 300;
                ResponseRecord record = new ResponseRecord(
                        cfg.getLabel(), cfg.getMethod().toUpperCase(), url,
                        response.statusCode(), elapsed, respHeaders, rawBody, jsonBody, isOk);

                // Validate
                List<String> errors = validate(record, cfg.getValidators());
                record.setValidationErrors(errors);

                logResponse(record);
                history.add(record);

                if (!errors.isEmpty()) {
                    throw new ValidationException(errors);
                }

                return record;

            } catch (ValidationException ve) {
                throw ve;
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("Request interrupted", ie);
            } catch (IOException e) {
                if (attempt >= maxRetries - 1) {
                    logger.severe(String.format("All retries exhausted for %s %s: %s",
                            cfg.getMethod().toUpperCase(), url, e.getMessage()));
                    throw new RuntimeException("Request failed after retries", e);
                }
                logger.warning(String.format("Attempt %d failed: %s – retrying...", attempt + 1, e.getMessage()));
                try {
                    Thread.sleep(backoffMillis * (long) Math.pow(2, attempt));
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("Retry sleep interrupted", ie);
                }
            }
        }
        throw new RuntimeException("Request failed after all retries");
    }

    private List<String> validate(ResponseRecord record, List<ValidationRule> rules) {
        List<String> errors = new ArrayList<>();
        for (ValidationRule rule : rules) {
            try {
                if (!rule.test(record)) {
                    errors.add(rule.getMessage().isEmpty() ? rule.getName() : rule.getMessage());
                    logger.warning(String.format("Validation failed [%s]: %s",
                            rule.getName(), rule.getMessage()));
                }
            } catch (Exception e) {
                errors.add(rule.getName() + ": " + e.getMessage());
            }
        }
        return errors;
    }

    private void logResponse(ResponseRecord record) {
        logger.log(record.isOk() ? Level.INFO : Level.WARNING,
                String.format("<<< %d %s (%.3fs) | label=%s | errors=%s",
                        record.getStatusCode(), record.getUrl(),
                        record.getElapsedSeconds(),
                        record.getLabel().isEmpty() ? "(none)" : record.getLabel(),
                        record.getValidationErrors().isEmpty() ? "none" : record.getValidationErrors()));
    }

    // -----------------------------------------------------------------------
    // Convenience methods
    // -----------------------------------------------------------------------

    public ResponseRecord get(String url, String label, ValidationRule... validators) {
        RequestConfig cfg = new RequestConfig("GET", url).label(label);
        for (ValidationRule v : validators) cfg.validate(v);
        return request(cfg);
    }

    public ResponseRecord post(String url, Object body, String label, ValidationRule... validators) {
        RequestConfig cfg = new RequestConfig("POST", url).body(body).label(label);
        if (body != null) cfg.header("Content-Type", "application/json");
        for (ValidationRule v : validators) cfg.validate(v);
        return request(cfg);
    }

    public ResponseRecord put(String url, Object body, String label, ValidationRule... validators) {
        RequestConfig cfg = new RequestConfig("PUT", url).body(body).label(label);
        if (body != null) cfg.header("Content-Type", "application/json");
        for (ValidationRule v : validators) cfg.validate(v);
        return request(cfg);
    }

    public ResponseRecord patch(String url, Object body, String label, ValidationRule... validators) {
        RequestConfig cfg = new RequestConfig("PATCH", url).body(body).label(label);
        if (body != null) cfg.header("Content-Type", "application/json");
        for (ValidationRule v : validators) cfg.validate(v);
        return request(cfg);
    }

    public ResponseRecord delete(String url, String label, ValidationRule... validators) {
        RequestConfig cfg = new RequestConfig("DELETE", url).label(label);
        for (ValidationRule v : validators) cfg.validate(v);
        return request(cfg);
    }

    // -----------------------------------------------------------------------
    // Request chaining
    // -----------------------------------------------------------------------

    public List<ResponseRecord> chain(List<RequestConfig> configs,
                                       Map<String, String> context,
                                       BiFunction<ResponseRecord, Map<String, String>, Map<String, String>> extractor) {
        Map<String, String> ctx = context != null ? new HashMap<>(context) : new HashMap<>();
        List<ResponseRecord> results = new ArrayList<>();

        for (int i = 0; i < configs.size(); i++) {
            RequestConfig cfg = configs.get(i);
            String cfgUrl = cfg.getUrl();
            for (Map.Entry<String, String> entry : ctx.entrySet()) {
                cfgUrl = cfgUrl.replace("{" + entry.getKey() + "}", entry.getValue());
            }
            cfg.setUrl(cfgUrl);

            Map<String, String> headers = new HashMap<>();
            for (Map.Entry<String, String> entry : cfg.getHeaders().entrySet()) {
                String val = entry.getValue();
                for (Map.Entry<String, String> ctxEntry : ctx.entrySet()) {
                    val = val.replace("{" + ctxEntry.getKey() + "}", ctxEntry.getValue());
                }
                headers.put(entry.getKey(), val);
            }
            cfg.setHeaders(headers);

            logger.info(String.format("Chain step %d/%d: %s", i + 1, configs.size(),
                    cfg.getLabel().isEmpty() ? cfg.getUrl() : cfg.getLabel()));

            ResponseRecord record = request(cfg);
            results.add(record);

            if (extractor != null) {
                ctx = extractor.apply(record, ctx);
            }
        }
        return results;
    }

    // -----------------------------------------------------------------------
    // History
    // -----------------------------------------------------------------------

    public List<ResponseRecord> getHistory() { return Collections.unmodifiableList(history); }

    public void printHistory() {
        System.out.println("\n" + "=".repeat(70));
        System.out.printf(" Request History (%d requests)%n", history.size());
        System.out.println("=".repeat(70));
        for (int i = 0; i < history.size(); i++) {
            ResponseRecord r = history.get(i);
            String status = r.isOk() ? "OK" : "FAIL";
            System.out.printf("  [%d] %s | %s %s -> %d (%.3fs) | %s%n",
                    i + 1, status, r.getMethod(), r.getUrl(),
                    r.getStatusCode(), r.getElapsedSeconds(), r.getLabel());
            for (String err : r.getValidationErrors()) {
                System.out.printf("       ! %s%n", err);
            }
        }
        System.out.println("=".repeat(70) + "\n");
    }

    // -----------------------------------------------------------------------
    // CLI entry point
    // -----------------------------------------------------------------------

    @Override
    public Integer call() {
        this.baseUrl = cliBaseUrl.replaceAll("/+$", "");
        this.maxRetries = cliRetries;
        this.backoffMillis = cliBackoff;
        this.defaultHeaders = Map.of("Accept", "application/json");

        runDemo();
        return 0;
    }

    private void runDemo() {
        // 1. Simple GET
        System.out.println("\n--- Simple GET with validation ---");
        try {
            ResponseRecord record = get("/posts/1", "get_post_1", statusOk(), jsonHasKey("title"));
            if (record.getJsonObject() != null) {
                System.out.println("Post title: " + record.getJsonObject().get("title").getAsString());
            }
        } catch (Exception e) {
            System.out.println("Request failed: " + e.getMessage());
        }

        // 2. POST
        System.out.println("\n--- POST with body ---");
        try {
            Map<String, Object> postBody = Map.of("title", "Hello", "body", "World", "userId", 1);
            ResponseRecord record = post("/posts", postBody, "create_post", statusEquals(201));
            if (record.getJsonObject() != null) {
                System.out.println("Created post ID: " + record.getJsonObject().get("id").getAsInt());
            }
        } catch (Exception e) {
            System.out.println("Request failed: " + e.getMessage());
        }

        // 3. Request chaining
        System.out.println("\n--- Request chaining ---");
        try {
            List<RequestConfig> chainConfigs = new ArrayList<>(List.of(
                    new RequestConfig("GET", "/users/1").label("get_user").validate(statusOk()),
                    new RequestConfig("GET", "/users/{user_id}/posts").label("get_user_posts").validate(statusOk())
            ));

            BiFunction<ResponseRecord, Map<String, String>, Map<String, String>> extractor = (record, ctx) -> {
                if (record.getJsonObject() != null && record.getJsonObject().has("id")) {
                    ctx.put("user_id", String.valueOf(record.getJsonObject().get("id").getAsInt()));
                }
                return ctx;
            };

            List<ResponseRecord> results = chain(chainConfigs, null, extractor);
            if (results.size() >= 2 && results.get(1).getJsonBody() != null
                    && results.get(1).getJsonBody().isJsonArray()) {
                System.out.println("User has " + results.get(1).getJsonBody().getAsJsonArray().size() + " posts");
            }
        } catch (Exception e) {
            System.out.println("Chain failed: " + e.getMessage());
        }

        // 4. PUT
        System.out.println("\n--- PUT request ---");
        try {
            Map<String, Object> putBody = Map.of("id", 1, "title", "Updated", "body", "Content", "userId", 1);
            ResponseRecord record = put("/posts/1", putBody, "update_post", statusOk());
            if (record.getJsonObject() != null) {
                System.out.println("Updated title: " + record.getJsonObject().get("title").getAsString());
            }
        } catch (Exception e) {
            System.out.println("Request failed: " + e.getMessage());
        }

        // 5. DELETE
        System.out.println("\n--- DELETE request ---");
        try {
            ResponseRecord record = delete("/posts/1", "delete_post", statusOk());
            System.out.println("Delete status: " + record.getStatusCode());
        } catch (Exception e) {
            System.out.println("Request failed: " + e.getMessage());
        }

        printHistory();
    }

    // -----------------------------------------------------------------------
    // Main
    // -----------------------------------------------------------------------

    public static void main(String[] args) {
        int exitCode = new CommandLine(new RestClient()).execute(args);
        System.exit(exitCode);
    }
}