Fix borrowObject timeout wrapping (#3666)

* Fix borrowObject timeout wrapping #3623

Override borrowObject(long borrowMaxWaitMillis) in GenericObjectPool
to apply connection wrapping when borrowing with timeout. This ensures
connections borrowed with timeout are properly returned to the pool
when closed via try-with-resources.

Without this fix, borrowObject(timeout) returns unwrapped connections
that don't auto-return to pool, causing connection leaks.

* Add borrowObject(Duration) override and test #3623

Override borrowObject(Duration) in GenericObjectPool to apply connection
wrapping, ensuring connections borrowed with Duration timeout are properly
returned to pool when closed via try-with-resources.

Add integration test following the same pattern as borrowObject(long) test.

* Rename test methods for clarity

Rename borrowObject test methods to be more explicit:
- genericPoolShouldWorkWithBorrowObjectTimeout -> TimeoutMillis
- genericPoolShouldWorkWithBorrowObjectDuration -> TimeoutDuration

This makes it clearer which parameter type each test covers.

* Fix tests

* Override only the Duration borrow method

---------

Co-authored-by: aleksandar.todorov <a_t_todorov@yahoo.com>

Author: JiHongKim98

src/main/java/io/lettuce/core/support/ConnectionPoolSupport.java

@@ -2,6 +2,7 @@
 
 import static io.lettuce.core.support.ConnectionWrapping.HasTargetConnection;
 
+import java.time.Duration;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.Lock;
@@ -62,6 +63,7 @@
  *
  * @author Mark Paluch
  * @author dae won
+ * @author JiHongKim98
  * @since 4.3
  */
 public abstract class ConnectionPoolSupport {
@@ -144,9 +146,10 @@ private ConnectionPoolSupport() {
                 new RedisPooledObjectFactory<>(connectionSupplier, validationPredicate), config) {
 
             @Override
-            public T borrowObject() throws Exception {
-                return wrapConnections ? ConnectionWrapping.wrapConnection(super.borrowObject(), poolRef.get())
-                        : super.borrowObject();
+            public T borrowObject(Duration borrowMaxWaitDuration) throws Exception {
+                return wrapConnections
+                        ? ConnectionWrapping.wrapConnection(super.borrowObject(borrowMaxWaitDuration), poolRef.get())
+                        : super.borrowObject(borrowMaxWaitDuration);
             }
 
             @Override

src/test/java/io/lettuce/core/support/ConnectionPoolSupportIntegrationTests.java

@@ -5,6 +5,7 @@
 import static org.assertj.core.api.Assertions.fail;
 
 import java.lang.reflect.Proxy;
+import java.time.Duration;
 import java.util.Set;
 
 import org.apache.commons.pool2.ObjectPool;
@@ -406,6 +407,38 @@ void tryWithResourcesReturnsSoftRefConnectionToPool() throws Exception {
         pool.close();
     }
 
+    @Test
+    void genericPoolShouldWorkWithBorrowObjectTimeoutMillis() throws Exception {
+
+        GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport
+                .createGenericObjectPool(() -> client.connect(), new GenericObjectPoolConfig<>());
+
+        try (StatefulRedisConnection<String, String> connection = pool.borrowObject(10_000)) {
+            RedisCommands<String, String> sync = connection.sync();
+            sync.ping();
+        }
+
+        assertThat(pool.getNumActive()).isEqualTo(0);
+
+        pool.close();
+    }
+
+    @Test
+    void genericPoolShouldWorkWithBorrowObjectTimeoutDuration() throws Exception {
+
+        GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport
+                .createGenericObjectPool(() -> client.connect(), new GenericObjectPoolConfig<>());
+
+        try (StatefulRedisConnection<String, String> connection = pool.borrowObject(Duration.ofSeconds(10))) {
+            RedisCommands<String, String> sync = connection.sync();
+            sync.ping();
+        }
+
+        assertThat(pool.getNumActive()).isEqualTo(0);
+
+        pool.close();
+    }
+
     private void borrowAndReturn(ObjectPool<StatefulRedisConnection<String, String>> pool) throws Exception {
 
         for (int i = 0; i < 10; i++) {