You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by zh...@apache.org on 2026/02/25 12:56:23 UTC

(shardingsphere) branch master updated: Add more test cases on OpenGaussComBatchBindPacketTest and PostgreSQLPacketCodecEngineTest (#38198)

This is an automated email from the ASF dual-hosted git repository.

zhangliang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git


The following commit(s) were added to refs/heads/master by this push:
     new 2e8a68403eb Add more test cases on OpenGaussComBatchBindPacketTest and PostgreSQLPacketCodecEngineTest (#38198)
2e8a68403eb is described below

commit 2e8a68403eb1aebe223064867450773a7f1b0f98
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Wed Feb 25 20:56:17 2026 +0800

    Add more test cases on OpenGaussComBatchBindPacketTest and PostgreSQLPacketCodecEngineTest (#38198)
---
 .../codec/PostgreSQLPacketCodecEngineTest.java     | 221 ++++++++++++++++-----
 1 file changed, 169 insertions(+), 52 deletions(-)

diff --git a/database/protocol/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/protocol/postgresql/codec/PostgreSQLPacketCodecEngineTest.java b/database/protocol/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/protocol/postgresql/codec/PostgreSQLPacketCodecEngineTest.java
index a39da0a421d..41efb596afd 100644
--- a/database/protocol/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/protocol/postgresql/codec/PostgreSQLPacketCodecEngineTest.java
+++ b/database/protocol/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/protocol/postgresql/codec/PostgreSQLPacketCodecEngineTest.java
@@ -18,30 +18,38 @@
 package org.apache.shardingsphere.database.protocol.postgresql.codec;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.CompositeByteBuf;
+import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelHandlerContext;
-import io.netty.util.AttributeKey;
-import org.apache.shardingsphere.database.protocol.postgresql.packet.PostgreSQLPacket;
+import lombok.SneakyThrows;
+import org.apache.shardingsphere.database.protocol.constant.CommonConstants;
+import org.apache.shardingsphere.database.protocol.packet.DatabasePacket;
+import org.apache.shardingsphere.database.protocol.postgresql.packet.command.PostgreSQLCommandPacketType;
 import org.apache.shardingsphere.database.protocol.postgresql.packet.identifier.PostgreSQLIdentifierPacket;
 import org.apache.shardingsphere.database.protocol.postgresql.packet.identifier.PostgreSQLMessagePacketType;
 import org.apache.shardingsphere.database.protocol.postgresql.payload.PostgreSQLPacketPayload;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.Answers;
 import org.mockito.Mock;
+import org.mockito.internal.configuration.plugins.Plugins;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.mockito.junit.jupiter.MockitoSettings;
 import org.mockito.quality.Strictness;
 
-import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.stream.Stream;
 
-import static org.hamcrest.Matchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.hamcrest.Matchers.is;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
@@ -51,76 +59,185 @@ import static org.mockito.Mockito.when;
 @MockitoSettings(strictness = Strictness.LENIENT)
 class PostgreSQLPacketCodecEngineTest {
     
+    private static final int SSL_REQUEST_PAYLOAD_LENGTH = 8;
+    
+    private static final int SSL_REQUEST_CODE = (1234 << 16) + 5679;
+    
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private ChannelHandlerContext context;
     
-    @Mock
-    private ByteBuf byteBuf;
-    
     @BeforeEach
-    void setup() {
-        when(context.channel().attr(AttributeKey.<Charset>valueOf(Charset.class.getName())).get()).thenReturn(StandardCharsets.UTF_8);
+    void setUp() {
+        when(context.channel().attr(CommonConstants.CHARSET_ATTRIBUTE_KEY).get()).thenReturn(StandardCharsets.UTF_8);
+        when(context.alloc().compositeBuffer(anyInt())).thenAnswer(invocation -> Unpooled.compositeBuffer(invocation.getArgument(0)));
     }
     
-    @Test
-    void assertIsValidHeader() {
-        assertTrue(new PostgreSQLPacketCodecEngine().isValidHeader(50));
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("validHeaderCases")
+    void assertIsValidHeader(final String name, final int readableBytes, final boolean expectedValid) {
+        PostgreSQLPacketCodecEngine codecEngine = new PostgreSQLPacketCodecEngine();
+        assertThat(codecEngine.isValidHeader(readableBytes), is(expectedValid));
     }
     
-    @Test
-    void assertIsInvalidHeader() {
-        assertTrue(new PostgreSQLPacketCodecEngine().isValidHeader(4));
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("validHeaderWhenStartupCompletedCases")
+    void assertIsValidHeaderWhenStartupCompleted(final String name, final int readableBytes, final boolean expectedValid) {
+        PostgreSQLPacketCodecEngine codecEngine = new PostgreSQLPacketCodecEngine();
+        setStartupPhase(codecEngine, false);
+        assertThat(codecEngine.isValidHeader(readableBytes), is(expectedValid));
     }
     
-    @Test
-    void assertDecode() {
-        when(byteBuf.readableBytes()).thenReturn(51, 47, 0);
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("decodeStartupPhaseCases")
+    void assertDecodeStartupPhase(final String name, final ByteBuf packet, final int expectedOutSize, final boolean expectedStartupPhase) {
+        PostgreSQLPacketCodecEngine codecEngine = new PostgreSQLPacketCodecEngine();
+        List<Object> out = new LinkedList<>();
+        codecEngine.decode(context, packet, out);
+        assertThat(out.size(), is(expectedOutSize));
+        assertThat(getStartupPhase(codecEngine), is(expectedStartupPhase));
+    }
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("decodeWithoutPendingMessagesCases")
+    void assertDecodeWithoutPendingMessages(final String name, final char commandType) {
+        PostgreSQLPacketCodecEngine codecEngine = new PostgreSQLPacketCodecEngine();
+        setStartupPhase(codecEngine, false);
         List<Object> out = new LinkedList<>();
-        new PostgreSQLPacketCodecEngine().decode(context, byteBuf, out);
+        codecEngine.decode(context, createCommandPacket(commandType, 4), out);
         assertThat(out.size(), is(1));
+        assertThat(((ByteBuf) out.get(0)).readableBytes(), is(5));
     }
     
-    @Test
-    void assertDecodeWithStickyPacket() {
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("decodeWithPreparedStateCases")
+    void assertDecodeWithPreparedState(final String name, final ByteBuf packet, final int initialPendingMessages, final int expectedOutSize,
+                                       final int expectedPendingMessages, final boolean expectedComposite, final int expectedResultReadableBytes) {
+        PostgreSQLPacketCodecEngine codecEngine = new PostgreSQLPacketCodecEngine();
+        setStartupPhase(codecEngine, false);
+        for (int i = 0; i < initialPendingMessages; i++) {
+            getPendingMessages(codecEngine).add(createCommandPacket(PostgreSQLCommandPacketType.PARSE_COMMAND.getValue(), 4));
+        }
         List<Object> out = new LinkedList<>();
-        new PostgreSQLPacketCodecEngine().decode(context, byteBuf, out);
-        assertTrue(out.isEmpty());
+        codecEngine.decode(context, packet, out);
+        assertThat(out.size(), is(expectedOutSize));
+        assertThat(getPendingMessages(codecEngine).size(), is(expectedPendingMessages));
+        if (0 < expectedOutSize) {
+            assertThat(out.get(0) instanceof CompositeByteBuf, is(expectedComposite));
+            assertThat(((ByteBuf) out.get(0)).readableBytes(), is(expectedResultReadableBytes));
+        }
     }
     
-    @Test
-    void assertEncodePostgreSQLPacket() {
-        PostgreSQLPacket packet = mock(PostgreSQLPacket.class);
-        new PostgreSQLPacketCodecEngine().encode(context, packet, byteBuf);
-        verify(packet).write(any(PostgreSQLPacketPayload.class));
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("encodeCases")
+    void assertEncode(final String name, final boolean identifierPacket, final boolean writeException, final boolean expectedHeader, final char expectedIdentifier) {
+        PostgreSQLPacketCodecEngine codecEngine = new PostgreSQLPacketCodecEngine();
+        DatabasePacket message = createPacket(identifierPacket);
+        if (writeException) {
+            doThrow(new RuntimeException("Error")).when(message).write(any(PostgreSQLPacketPayload.class));
+        }
+        ByteBuf out = Unpooled.buffer();
+        codecEngine.encode(context, message, out);
+        verify(message).write(any(PostgreSQLPacketPayload.class));
+        assertThat(out.readableBytes() > 0, is(expectedHeader));
+        if (expectedHeader) {
+            assertThat((char) out.getByte(0), is(expectedIdentifier));
+            assertThat(out.getInt(1), is(out.readableBytes() - 1));
+        }
     }
     
     @Test
-    void assertEncodePostgreSQLIdentifierPacket() {
-        PostgreSQLIdentifierPacket packet = mock(PostgreSQLIdentifierPacket.class);
-        when(packet.getIdentifier()).thenReturn(PostgreSQLMessagePacketType.AUTHENTICATION_REQUEST);
-        when(byteBuf.readableBytes()).thenReturn(9);
-        new PostgreSQLPacketCodecEngine().encode(context, packet, byteBuf);
-        verify(byteBuf).writeByte(PostgreSQLMessagePacketType.AUTHENTICATION_REQUEST.getValue());
-        verify(byteBuf).writeInt(0);
-        verify(packet).write(any(PostgreSQLPacketPayload.class));
-        verify(byteBuf).setInt(1, 8);
+    void assertCreatePacketPayload() {
+        PostgreSQLPacketCodecEngine codecEngine = new PostgreSQLPacketCodecEngine();
+        ByteBuf message = Unpooled.buffer();
+        assertThat(codecEngine.createPacketPayload(message, StandardCharsets.UTF_8).getByteBuf(), is(message));
     }
     
-    @Test
-    void assertEncodeOccursException() {
-        PostgreSQLPacket packet = mock(PostgreSQLPacket.class);
-        RuntimeException ex = mock(RuntimeException.class);
-        when(ex.getMessage()).thenReturn("Error");
-        doThrow(ex).when(packet).write(any(PostgreSQLPacketPayload.class));
-        when(byteBuf.readableBytes()).thenReturn(9);
-        new PostgreSQLPacketCodecEngine().encode(context, packet, byteBuf);
-        verify(byteBuf).resetWriterIndex();
-        verify(byteBuf).writeByte(PostgreSQLMessagePacketType.ERROR_RESPONSE.getValue());
-        verify(byteBuf).setInt(1, 8);
+    private DatabasePacket createPacket(final boolean identifierPacket) {
+        if (identifierPacket) {
+            PostgreSQLIdentifierPacket result = mock(PostgreSQLIdentifierPacket.class);
+            when(result.getIdentifier()).thenReturn(PostgreSQLMessagePacketType.AUTHENTICATION_REQUEST);
+            return result;
+        }
+        return mock(DatabasePacket.class);
     }
     
-    @Test
-    void assertCreatePacketPayload() {
-        assertThat(new PostgreSQLPacketCodecEngine().createPacketPayload(byteBuf, StandardCharsets.UTF_8).getByteBuf(), is(byteBuf));
+    @SneakyThrows(ReflectiveOperationException.class)
+    private void setStartupPhase(final PostgreSQLPacketCodecEngine codecEngine, final boolean startupPhase) {
+        Plugins.getMemberAccessor().set(PostgreSQLPacketCodecEngine.class.getDeclaredField("startupPhase"), codecEngine, startupPhase);
+    }
+    
+    @SneakyThrows(ReflectiveOperationException.class)
+    private boolean getStartupPhase(final PostgreSQLPacketCodecEngine codecEngine) {
+        return (boolean) Plugins.getMemberAccessor().get(PostgreSQLPacketCodecEngine.class.getDeclaredField("startupPhase"), codecEngine);
+    }
+    
+    @SuppressWarnings("unchecked")
+    @SneakyThrows(ReflectiveOperationException.class)
+    private List<ByteBuf> getPendingMessages(final PostgreSQLPacketCodecEngine codecEngine) {
+        return (List<ByteBuf>) Plugins.getMemberAccessor().get(PostgreSQLPacketCodecEngine.class.getDeclaredField("pendingMessages"), codecEngine);
+    }
+    
+    private static ByteBuf createStartupPacket(final int length, final int code) {
+        ByteBuf result = Unpooled.buffer(SSL_REQUEST_PAYLOAD_LENGTH);
+        result.writeInt(length);
+        result.writeInt(code);
+        return result;
+    }
+    
+    private static ByteBuf createStartupPacketWithAdditionalByte(final int length, final int code) {
+        ByteBuf result = createStartupPacket(length, code);
+        result.writeByte(0);
+        return result;
+    }
+    
+    private static ByteBuf createCommandPacket(final char commandType, final int payloadLength) {
+        ByteBuf result = Unpooled.buffer(1 + Integer.BYTES);
+        result.writeByte(commandType);
+        result.writeInt(payloadLength);
+        return result;
+    }
+    
+    private static Stream<Arguments> validHeaderCases() {
+        return Stream.of(
+                Arguments.of("startup phase: less than minimum header", 3, false),
+                Arguments.of("startup phase: equal minimum header", 4, true),
+                Arguments.of("startup phase: greater than minimum header", 8, true));
+    }
+    
+    private static Stream<Arguments> validHeaderWhenStartupCompletedCases() {
+        return Stream.of(
+                Arguments.of("non-startup phase: less than minimum header", 4, false),
+                Arguments.of("non-startup phase: equal minimum header", 5, true),
+                Arguments.of("non-startup phase: greater than minimum header", 9, true));
+    }
+    
+    private static Stream<Arguments> decodeStartupPhaseCases() {
+        return Stream.of(
+                Arguments.of("decode ssl request packet", createStartupPacket(SSL_REQUEST_PAYLOAD_LENGTH, SSL_REQUEST_CODE), 1, true),
+                Arguments.of("decode startup packet and enter command phase", createStartupPacket(SSL_REQUEST_PAYLOAD_LENGTH, 1), 1, false),
+                Arguments.of("decode startup packet with mismatched declared length", createStartupPacket(SSL_REQUEST_PAYLOAD_LENGTH - 1, 1), 0, true),
+                Arguments.of("decode startup packet with additional payload byte", createStartupPacketWithAdditionalByte(SSL_REQUEST_PAYLOAD_LENGTH + 1, 1), 1, false));
+    }
+    
+    private static Stream<Arguments> decodeWithoutPendingMessagesCases() {
+        return Stream.of(
+                Arguments.of("decode simple query command", PostgreSQLCommandPacketType.SIMPLE_QUERY.getValue()),
+                Arguments.of("decode sync command", PostgreSQLCommandPacketType.SYNC_COMMAND.getValue()),
+                Arguments.of("decode flush command", PostgreSQLCommandPacketType.FLUSH_COMMAND.getValue()));
+    }
+    
+    private static Stream<Arguments> decodeWithPreparedStateCases() {
+        return Stream.of(
+                Arguments.of("decode with invalid header", Unpooled.wrappedBuffer(new byte[4]), 0, 0, 0, false, 0),
+                Arguments.of("decode with incomplete payload", createCommandPacket(PostgreSQLCommandPacketType.SIMPLE_QUERY.getValue(), 8), 0, 0, 0, false, 0),
+                Arguments.of("decode with aggregation command", createCommandPacket(PostgreSQLCommandPacketType.PARSE_COMMAND.getValue(), 4), 0, 0, 1, false, 0),
+                Arguments.of("decode with pending messages", createCommandPacket(PostgreSQLCommandPacketType.SIMPLE_QUERY.getValue(), 4), 1, 1, 0, true, 10));
+    }
+    
+    private static Stream<Arguments> encodeCases() {
+        return Stream.of(
+                Arguments.of("encode non identifier packet", false, false, false, '\0'),
+                Arguments.of("encode identifier packet", true, false, true, PostgreSQLMessagePacketType.AUTHENTICATION_REQUEST.getValue()),
+                Arguments.of("encode packet with write exception", false, true, true, PostgreSQLMessagePacketType.ERROR_RESPONSE.getValue()));
     }
 }