Fix IPv6 address encoding in HTTP requests (issue #10)

Feign's template engine percent-encodes colons in path parameters,
converting IPv6 addresses like 2001:4860:4860::8888 to
2001%3A4860%3A4860%3A%3A8888. This breaks requests to the ipdata API.

Add Ipv6SafeClient wrapper that decodes %3A back to literal colons
before sending requests, since colons are valid in URI paths per
RFC 3986 section 3.3. Also switch the default HTTP client from
ApacheHttpClient (which further re-encodes via URIBuilder) to Feign's
built-in Client.Default.

https://claude.ai/code/session_01KxvyXRVVZaLrgTZshvsZY6

Author: claude

src/main/java/io/ipdata/client/service/IpdataServiceBuilder.java

@@ -9,7 +9,6 @@
 import com.google.common.cache.CacheLoader;
 import feign.Client;
 import feign.Feign;
-import feign.httpclient.ApacheHttpClient;
 import feign.jackson.JacksonDecoder;
 import feign.jackson.JacksonEncoder;
 import io.ipdata.client.model.*;
@@ -42,15 +41,15 @@ public IpdataService build() {
     final ApiErrorDecoder apiErrorDecoder = new ApiErrorDecoder(mapper, customLogger);
 
     final IpdataInternalClient client = Feign.builder()
-      .client(httpClient == null ? new ApacheHttpClient() : httpClient)
+      .client(new Ipv6SafeClient(httpClient == null ? new Client.Default(null, null) : httpClient))
       .decoder(new JacksonDecoder(mapper))
       .encoder(new JacksonEncoder(mapper))
       .requestInterceptor(keyRequestInterceptor)
       .errorDecoder(apiErrorDecoder)
       .target(IpdataInternalClient.class, url.toString());
 
     final IpdataInternalSingleFieldClient singleFieldClient = Feign.builder()
-      .client(httpClient == null ? new ApacheHttpClient() : httpClient)
+      .client(new Ipv6SafeClient(httpClient == null ? new Client.Default(null, null) : httpClient))
       .decoder(new FieldDecoder(mapper))
       .encoder(new JacksonEncoder(mapper))
       .requestInterceptor(keyRequestInterceptor)

src/main/java/io/ipdata/client/service/Ipv6SafeClient.java

@@ -0,0 +1,44 @@
+package io.ipdata.client.service;
+
+import feign.Client;
+import feign.Request;
+import feign.Response;
+
+import java.io.IOException;
+
+/**
+ * A Feign Client wrapper that prevents percent-encoding of colons in the request path.
+ * <p>
+ * Feign's template engine may percent-encode colons in path parameters (e.g., IPv6 addresses),
+ * converting {@code 2001:4860:4860::8888} to {@code 2001%3A4860%3A4860%3A%3A8888}.
+ * Colons are valid in URI path segments per RFC 3986 section 3.3, so this wrapper
+ * decodes them before forwarding to the underlying HTTP client.
+ *
+ * @see <a href="https://github.com/ipdata/java/issues/10">Issue #10</a>
+ */
+class Ipv6SafeClient implements Client {
+
+  private final Client delegate;
+
+  Ipv6SafeClient(Client delegate) {
+    this.delegate = delegate;
+  }
+
+  @Override
+  public Response execute(Request request, Request.Options options) throws IOException {
+    String url = request.url();
+    int queryIndex = url.indexOf('?');
+    String path = queryIndex >= 0 ? url.substring(0, queryIndex) : url;
+
+    if (path.contains("%3A") || path.contains("%3a")) {
+      String fixedPath = path.replace("%3A", ":").replace("%3a", ":");
+      String query = queryIndex >= 0 ? url.substring(queryIndex) : "";
+      String fixedUrl = fixedPath + query;
+      request = Request.create(
+        request.httpMethod(), fixedUrl, request.headers(),
+        request.body(), request.charset()
+      );
+    }
+    return delegate.execute(request, options);
+  }
+}

src/test/java/io/ipdata/client/Ipv6EncodingTest.java

@@ -0,0 +1,36 @@
+package io.ipdata.client;
+
+import io.ipdata.client.model.IpdataModel;
+import io.ipdata.client.service.IpdataService;
+import lombok.SneakyThrows;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Regression test for https://github.com/ipdata/java/issues/10
+ * Verifies that IPv6 colons are not percent-encoded (%3A) in HTTP requests.
+ */
+public class Ipv6EncodingTest {
+
+  private static final MockIpdataServer MOCK = MockIpdataServer.getInstance();
+  private static final TestContext TEST_CONTEXT = new TestContext(MockIpdataServer.API_KEY, MOCK.getUrl());
+
+  @Test
+  @SneakyThrows
+  public void testIpv6ColonsAreNotEncoded() {
+    String ipv6 = "2001:4860:4860::8888";
+    IpdataService service = TEST_CONTEXT.ipdataService();
+    IpdataModel model = service.ipdata(ipv6);
+    Assert.assertNotNull(model);
+
+    String rawPath = MOCK.getLastRawPath();
+    Assert.assertFalse(
+      "IPv6 colons should not be percent-encoded in the request path, but got: " + rawPath,
+      rawPath.contains("%3A")
+    );
+    Assert.assertTrue(
+      "Request path should contain the IPv6 address with literal colons",
+      rawPath.contains(ipv6)
+    );
+  }
+}

src/test/java/io/ipdata/client/MockIpdataServer.java

@@ -29,6 +29,7 @@ public class MockIpdataServer {
   private final String url;
   private final Map<String, JsonNode> fixtures = new HashMap<>();
   private final ObjectMapper mapper = new ObjectMapper();
+  private volatile String lastRawPath;
 
   private MockIpdataServer() {
     try {
@@ -54,6 +55,10 @@ public String getUrl() {
     return url;
   }
 
+  public String getLastRawPath() {
+    return lastRawPath;
+  }
+
   private void loadFixtures() {
     String[] ips = {"8.8.8.8", "2001:4860:4860::8888", "1.1.1.1", "2001:4860:4860::8844", "41.128.21.123"};
     for (String ip : ips) {
@@ -72,6 +77,7 @@ private void handleRequest(HttpExchange exchange) throws IOException {
     try {
       String method = exchange.getRequestMethod();
       String path = exchange.getRequestURI().getPath();
+      lastRawPath = exchange.getRequestURI().getRawPath();
       String rawQuery = exchange.getRequestURI().getRawQuery();
       Map<String, String> params = parseQuery(rawQuery);
 

src/test/java/io/ipdata/client/TestContext.java

@@ -5,7 +5,6 @@
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.io.CharStreams;
-import feign.httpclient.ApacheHttpClient;
 import io.ipdata.client.service.IpdataService;
 import lombok.Getter;
 import lombok.SneakyThrows;
@@ -17,7 +16,6 @@
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.client.utils.URIBuilder;
-import org.apache.http.conn.ssl.NoopHostnameVerifier;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.HttpClientBuilder;
 
@@ -56,17 +54,11 @@ public TestContext(String key, String url) {
     mapper.setPropertyNamingStrategy(CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);
     mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true);
     mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
-    httpClient = HttpClientBuilder.create().setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
+    httpClient = HttpClientBuilder.create().build();
     ipdataService = Ipdata.builder().url(this.url).key(this.key)
       .noCache()
-      .feignClient(new ApacheHttpClient(HttpClientBuilder.create()
-        .setSSLHostnameVerifier(new NoopHostnameVerifier())
-        .build())
-      ).get();
+      .get();
     cachingIpdataService = Ipdata.builder().url(this.url)
-      .feignClient(new ApacheHttpClient(HttpClientBuilder.create()
-        .setSSLHostnameVerifier(new NoopHostnameVerifier())
-        .build()))
       .withDefaultCache().key(key).get();
   }