fix(test): close three latent OkHttp-port gaps flagged in review

- OBPReq.toOkHttpRequest: dedupe headers by name (case-insensitive)
  before sending, keeping the last value. reqHeaders accumulated via
  <:</addHeader without removing same-named entries, so a caller-set
  header plus a helper default (e.g. makePostRequest's Content-Type)
  would be sent twice on the wire instead of the helper default
  overriding, as the pre-port Map-based header merge did.

- OBPReq./ path-segment encoding: percent-encode '%' itself (first,
  before the other reserved characters). Without it, a literal '%' in
  a test id/label either makes HttpUrl.parse reject the segment as an
  invalid escape, or — if it happens to look like a valid escape (e.g.
  "%2F") — gets silently decoded server-side into the wrong resource.

- SendServerRequests.getAPIResponse: restore the retry-once-on-IOException
  the old dispatch-based client had for a corrupted pooled connection
  (one test's error response polluting a connection OkHttp's own
  RetryAndFollowUpInterceptor won't recover from). Broadened from the
  old code's single string-matched exception to java.io.IOException
  generally, since OkHttp surfaces this as various IOException subtypes
  rather than one specific message.

All three are additive/defensive — none change behaviour for any
currently-passing test. Verified with two full local runs
(run_tests_parallel.sh, JDK 25): 2921 tests, 0 failures, 0 errors.

Author: hongwei1

obp-api/src/test/scala/code/setup/OBPReq.scala

@@ -25,8 +25,12 @@ case class OBPReq(
     // Percent-encode characters that must not appear unencoded in a URI path segment.
     // '/' is the path delimiter — encoding it prevents a URL-valued provider string
     // (e.g. "http://localhost:8016") from being split into multiple path segments.
-    // This replicates dispatch's addPathPart percent-encoding behaviour.
-    val encodedSeg = seg.replace("/", "%2F").replace("?", "%3F").replace("#", "%23")
+    // '%' must be encoded FIRST — otherwise a literal '%' in a test id/label (e.g. a
+    // view name "50%") would either make HttpUrl.parse reject the segment as an invalid
+    // escape, or — if it happens to look like a valid escape (e.g. "%2F") — get silently
+    // decoded server-side into the character it "escapes", resolving to the wrong
+    // resource. This replicates dispatch's addPathPart percent-encoding behaviour.
+    val encodedSeg = seg.replace("%", "%25").replace("/", "%2F").replace("?", "%3F").replace("#", "%23")
     copy(baseUrl = s"$cleanBase/$encodedSeg")
   }
 
@@ -87,7 +91,19 @@ case class OBPReq(
       .url(urlBuilder.build())
       .method(method.toUpperCase, requestBody)
 
-    reqHeaders.foreach { case (k, v) => builder.addHeader(k, v) }
+    // Dedupe by header name (HTTP header names are case-insensitive), keeping the LAST
+    // value for a given name. reqHeaders accumulates via <:</addHeader without removing
+    // same-named entries, so e.g. makePostRequest's own Content-Type default appended
+    // after a caller-set Content-Type would otherwise be sent twice on the wire. "Last
+    // wins" matches the Content-Type lookup above (reqHeaders.toMap already takes the
+    // last occurrence) and restores the override semantics the old Map-based header
+    // merge had before the OkHttp port.
+    val dedupedHeaders = {
+      val seen = scala.collection.mutable.LinkedHashMap[String, (String, String)]()
+      reqHeaders.foreach { case (k, v) => seen(k.toLowerCase) = (k, v) }
+      seen.values
+    }
+    dedupedHeaders.foreach { case (k, v) => builder.addHeader(k, v) }
     builder.build()
   }
 }

obp-api/src/test/scala/code/setup/SendServerRequests.scala

@@ -116,7 +116,20 @@ trait SendServerRequests {
         }
       }.toOption
 
-  private def getAPIResponse(req: OBPReq): APIResponse = executeRequest(req)
+  private def getAPIResponse(req: OBPReq): APIResponse =
+    try {
+      executeRequest(req)
+    } catch {
+      case _: java.io.IOException =>
+        // Concurrent shards/tests share OBPReq.client's connection pool; one test's error
+        // response can corrupt a pooled connection, surfacing as a broken status line on
+        // the next request that reuses it. OkHttp does not retry this itself
+        // (RetryAndFollowUpInterceptor.recover() refuses to recover a ProtocolException).
+        // Retry once with a fresh connection after a brief delay — the same recovery the
+        // old dispatch-based client had for the same "invalid version format" symptom.
+        Thread.sleep(100)
+        executeRequest(req)
+    }
 
   private def getAPIResponseAsync(req: OBPReq): Future[APIResponse] =
     Future { scala.concurrent.blocking { getAPIResponse(req) } }(ExecutionContext.global)