Polishing.

Revise buffer release in tests to avoid resource leaks.

[pgjdbc#458]

Signed-off-by: Mark Paluch <[email protected]>

Author: mp911de

src/test/java/io/r2dbc/postgresql/client/ReactorNettyClientIntegrationTests.java

@@ -113,9 +113,9 @@ void concurrentConsumptionShouldComplete() {
 
         this.client
             .exchange(Mono.just(new Query("SELECT value FROM test")))
+            .doOnNext(ReferenceCountUtil::release)
             .limitRate(1)
             .publishOn(Schedulers.parallel())
-            .doOnNext(ReferenceCountUtil::release)
             .as(StepVerifier::create)
             .thenConsumeWhile((t) -> true)
             .verifyComplete();

src/test/java/io/r2dbc/postgresql/message/backend/BackendMessageAssert.java

@@ -17,11 +17,14 @@
 package io.r2dbc.postgresql.message.backend;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.util.ReferenceCountUtil;
 import org.assertj.core.api.AbstractObjectAssert;
 import org.assertj.core.api.ObjectAssert;
 import org.springframework.util.ReflectionUtils;
 
 import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
 import java.util.function.Function;
 
@@ -32,6 +35,8 @@
  */
 final class BackendMessageAssert extends AbstractObjectAssert<BackendMessageAssert, Class<? extends BackendMessage>> {
 
+    private Cleaner cleaner = new Cleaner();
+
     private BackendMessageAssert(Class<? extends BackendMessage> actual) {
         super(actual, BackendMessageAssert.class);
     }
@@ -40,6 +45,11 @@ static BackendMessageAssert assertThat(Class<? extends BackendMessage> actual) {
         return new BackendMessageAssert(actual);
     }
 
+    BackendMessageAssert cleaner(Cleaner cleaner) {
+        this.cleaner = cleaner;
+        return this;
+    }
+
     @SuppressWarnings("unchecked")
     <T extends BackendMessage> ObjectAssert<T> decoded(Function<ByteBuf, ByteBuf> decoded) {
         Method method = ReflectionUtils.findMethod(this.actual, "decode", ByteBuf.class);
@@ -51,7 +61,28 @@ <T extends BackendMessage> ObjectAssert<T> decoded(Function<ByteBuf, ByteBuf> de
         ReflectionUtils.makeAccessible(method);
         T actual = (T) ReflectionUtils.invokeMethod(method, null, decoded.apply(TEST.buffer()));
 
-        return new ObjectAssert<>(actual);
+        return new ObjectAssert<>(this.cleaner.capture(actual));
+    }
+
+    public Cleaner cleaner() {
+        return this.cleaner;
+    }
+
+    static class Cleaner {
+
+        private final List<Object> objects = new ArrayList<>();
+
+        public void clean() {
+            this.objects.forEach(ReferenceCountUtil::release);
+            this.objects.clear();
+        }
+
+        public <T> T capture(T object) {
+            this.objects.add(object);
+
+            return object;
+        }
+
     }
 
 }

src/test/java/io/r2dbc/postgresql/message/backend/DataRowUnitTests.java

@@ -17,8 +17,10 @@
 package io.r2dbc.postgresql.message.backend;
 
 import io.netty.buffer.ByteBuf;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 
+import static io.r2dbc.postgresql.message.backend.BackendMessageAssert.Cleaner;
 import static io.r2dbc.postgresql.message.backend.BackendMessageAssert.assertThat;
 import static io.r2dbc.postgresql.util.TestByteBufAllocator.TEST;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
@@ -28,6 +30,13 @@
  */
 final class DataRowUnitTests {
 
+    private final Cleaner cleaner = new Cleaner();
+
+    @AfterEach
+    void tearDown() {
+        this.cleaner.clean();
+    }
+
     @Test
     void constructorNoColumns() {
         assertThatIllegalArgumentException().isThrownBy(() -> new DataRow((ByteBuf[]) null))
@@ -37,20 +46,22 @@ void constructorNoColumns() {
     @Test
     void decode() {
         assertThat(DataRow.class)
+            .cleaner(this.cleaner)
             .decoded(buffer -> buffer
                 .writeShort(1)
                 .writeInt(4)
                 .writeInt(100))
-            .isEqualTo(new DataRow(TEST.buffer(4).writeInt(100)));
+            .isEqualTo(this.cleaner.capture(new DataRow(TEST.buffer(4).writeInt(100))));
     }
 
     @Test
     void decodeNullColumn() {
         assertThat(DataRow.class)
+            .cleaner(this.cleaner)
             .decoded(buffer -> buffer
                 .writeShort(1)
                 .writeInt(-1))
-            .isEqualTo(new DataRow(new ByteBuf[]{null}));
+            .isEqualTo(this.cleaner.capture(new DataRow(new ByteBuf[]{null})));
     }
 
 }