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/03/14 04:43:07 UTC

(shardingsphere) branch master updated: Add more test cases on OpenGaussErrorResponsePacketTest (#38423)

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 f8ed8016a57 Add more test cases on OpenGaussErrorResponsePacketTest (#38423)
f8ed8016a57 is described below

commit f8ed8016a5791758b5f85d96a1211b1ef18b1dd6
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Sat Mar 14 12:43:01 2026 +0800

    Add more test cases on OpenGaussErrorResponsePacketTest (#38423)
---
 .../generic/OpenGaussErrorResponsePacketTest.java  | 146 ++++++++++++++-------
 1 file changed, 100 insertions(+), 46 deletions(-)

diff --git a/database/protocol/dialect/opengauss/src/test/java/org/apache/shardingsphere/database/protocol/opengauss/packet/command/generic/OpenGaussErrorResponsePacketTest.java b/database/protocol/dialect/opengauss/src/test/java/org/apache/shardingsphere/database/protocol/opengauss/packet/command/generic/OpenGaussErrorResponsePacketTest.java
index a6a1d597e4b..52fcf33b941 100644
--- a/database/protocol/dialect/opengauss/src/test/java/org/apache/shardingsphere/database/protocol/opengauss/packet/command/generic/OpenGaussErrorResponsePacketTest.java
+++ b/database/protocol/dialect/opengauss/src/test/java/org/apache/shardingsphere/database/protocol/opengauss/packet/command/generic/OpenGaussErrorResponsePacketTest.java
@@ -17,66 +17,120 @@
 
 package org.apache.shardingsphere.database.protocol.opengauss.packet.command.generic;
 
+import org.apache.shardingsphere.database.protocol.payload.PacketPayload;
 import org.apache.shardingsphere.database.protocol.postgresql.packet.identifier.PostgreSQLMessagePacketType;
 import org.apache.shardingsphere.database.protocol.postgresql.payload.PostgreSQLPacketPayload;
 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.opengauss.util.ServerErrorMessage;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Stream;
 
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
 
+@ExtendWith(MockitoExtension.class)
 class OpenGaussErrorResponsePacketTest {
     
-    @Test
-    void assertWritePacketFromServerErrorMessage() {
-        String encodedMessage = "SFATAL\0C3D000\0Mdatabase \"test\" does not exist\0c-1\0Ddetail\0Hhint\0P1\0p2\0qinternal query\0Wwhere\0Ffile\0L3\0Rroutine\0a0.0.0.0:1";
-        OpenGaussErrorResponsePacket packet = new OpenGaussErrorResponsePacket(new ServerErrorMessage(encodedMessage));
-        PostgreSQLPacketPayload payload = mock(PostgreSQLPacketPayload.class);
-        packet.write(payload);
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_SEVERITY);
-        verify(payload).writeStringNul("FATAL");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_CODE);
-        verify(payload).writeStringNul("3D000");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_MESSAGE);
-        verify(payload).writeStringNul("database \"test\" does not exist");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_ERROR_CODE);
-        verify(payload).writeStringNul("-1");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_DETAIL);
-        verify(payload).writeStringNul("detail");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_HINT);
-        verify(payload).writeStringNul("hint");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_POSITION);
-        verify(payload).writeStringNul("1");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_INTERNAL_POSITION);
-        verify(payload).writeStringNul("2");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_INTERNAL_QUERY);
-        verify(payload).writeStringNul("internal query");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_WHERE);
-        verify(payload).writeStringNul("where");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_FILE);
-        verify(payload).writeStringNul("file");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_LINE);
-        verify(payload).writeStringNul("3");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_ROUTINE);
-        verify(payload).writeStringNul("routine");
-        verify(payload).writeInt1(0);
-        assertThat(packet.getIdentifier(), is(PostgreSQLMessagePacketType.ERROR_RESPONSE));
+    @Mock
+    private PostgreSQLPacketPayload payload;
+    
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("constructWithServerErrorMessageArguments")
+    void assertConstructWithServerErrorMessage(final String name, final ServerErrorMessage serverErrorMessage, final List<Integer> expectedFieldTypes, final List<String> expectedFieldValues) {
+        new OpenGaussErrorResponsePacket(serverErrorMessage).write((PacketPayload) payload);
+        assertWrittenFields(expectedFieldTypes, expectedFieldValues);
     }
     
     @Test
-    void assertWritePacketFromSeverityAndMessage() {
-        OpenGaussErrorResponsePacket packet = new OpenGaussErrorResponsePacket("FATAL", "3D000", "database \"test\" does not exist");
-        PostgreSQLPacketPayload payload = mock(PostgreSQLPacketPayload.class);
-        packet.write(payload);
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_SEVERITY);
-        verify(payload).writeStringNul("FATAL");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_CODE);
-        verify(payload).writeStringNul("3D000");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_MESSAGE);
-        verify(payload).writeStringNul("database \"test\" does not exist");
-        verify(payload).writeInt1(OpenGaussErrorResponsePacket.FIELD_TYPE_ERROR_CODE);
-        verify(payload).writeStringNul("0");
+    void assertConstructWithSeverityAndMessage() {
+        OpenGaussErrorResponsePacket actual = new OpenGaussErrorResponsePacket("FATAL", "3D000", "database \"test\" does not exist");
+        actual.write((PacketPayload) payload);
+        assertWrittenFields(Arrays.asList(
+                (int) OpenGaussErrorResponsePacket.FIELD_TYPE_SEVERITY,
+                (int) OpenGaussErrorResponsePacket.FIELD_TYPE_CODE,
+                (int) OpenGaussErrorResponsePacket.FIELD_TYPE_MESSAGE,
+                (int) OpenGaussErrorResponsePacket.FIELD_TYPE_ERROR_CODE,
+                0), Arrays.asList("FATAL", "3D000", "database \"test\" does not exist", "0"));
+        assertThat(actual.getIdentifier(), is(PostgreSQLMessagePacketType.ERROR_RESPONSE));
+    }
+    
+    private void assertWrittenFields(final List<Integer> expectedFieldTypes, final List<String> expectedFieldValues) {
+        ArgumentCaptor<Integer> actualFieldTypes = ArgumentCaptor.forClass(Integer.class);
+        ArgumentCaptor<String> actualFieldValues = ArgumentCaptor.forClass(String.class);
+        verify(payload, times(expectedFieldTypes.size())).writeInt1(actualFieldTypes.capture());
+        verify(payload, times(expectedFieldValues.size())).writeStringNul(actualFieldValues.capture());
+        assertThat(actualFieldTypes.getAllValues(), is(expectedFieldTypes));
+        assertThat(actualFieldValues.getAllValues(), is(expectedFieldValues));
+        verifyNoMoreInteractions(payload);
+    }
+    
+    private static Stream<Arguments> constructWithServerErrorMessageArguments() {
+        return Stream.of(
+                Arguments.of("all_fields_present", createFullServerErrorMessage(), Arrays.asList(
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_SEVERITY,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_CODE,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_MESSAGE,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_ERROR_CODE,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_DETAIL,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_HINT,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_POSITION,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_INTERNAL_POSITION,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_INTERNAL_QUERY,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_WHERE,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_FILE,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_LINE,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_ROUTINE,
+                        0), Arrays.asList("FATAL", "3D000", "database \"test\" does not exist", "-1", "detail", "hint", "1", "2", "internal query", "where", "file", "3", "routine")),
+                Arguments.of("missing_optional_fields", mock(ServerErrorMessage.class), Arrays.asList(
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_ERROR_CODE,
+                        0), Collections.singletonList("0")),
+                Arguments.of("required_fields_and_error_code_only", createRequiredAndErrorCodeServerErrorMessage(), Arrays.asList(
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_SEVERITY,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_CODE,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_MESSAGE,
+                        (int) OpenGaussErrorResponsePacket.FIELD_TYPE_ERROR_CODE,
+                        0), Arrays.asList("FATAL", "3D000", "database \"test\" does not exist", "42")));
+    }
+    
+    private static ServerErrorMessage createFullServerErrorMessage() {
+        ServerErrorMessage result = mock(ServerErrorMessage.class);
+        when(result.getSeverity()).thenReturn("FATAL");
+        when(result.getSQLState()).thenReturn("3D000");
+        when(result.getMessage()).thenReturn("database \"test\" does not exist");
+        when(result.getERRORCODE()).thenReturn("-1");
+        when(result.getDetail()).thenReturn("detail");
+        when(result.getHint()).thenReturn("hint");
+        when(result.getPosition()).thenReturn(1);
+        when(result.getInternalPosition()).thenReturn(2);
+        when(result.getInternalQuery()).thenReturn("internal query");
+        when(result.getWhere()).thenReturn("where");
+        when(result.getFile()).thenReturn("file");
+        when(result.getLine()).thenReturn(3);
+        when(result.getRoutine()).thenReturn("routine");
+        return result;
+    }
+    
+    private static ServerErrorMessage createRequiredAndErrorCodeServerErrorMessage() {
+        ServerErrorMessage result = mock(ServerErrorMessage.class);
+        when(result.getSeverity()).thenReturn("FATAL");
+        when(result.getSQLState()).thenReturn("3D000");
+        when(result.getMessage()).thenReturn("database \"test\" does not exist");
+        when(result.getERRORCODE()).thenReturn("42");
+        return result;
     }
 }