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 b9926516f3e Add more test cases on
PostgreSQLDatabasePrivilegeCheckerTest (#38138)
b9926516f3e is described below
commit b9926516f3e85186bcff2401ad15e97677229db0
Author: Liang Zhang <[email protected]>
AuthorDate: Sun Feb 22 15:41:38 2026 +0800
Add more test cases on PostgreSQLDatabasePrivilegeCheckerTest (#38138)
---
.../PostgreSQLDatabasePrivilegeCheckerTest.java | 96 ++++++++++++++--------
1 file changed, 60 insertions(+), 36 deletions(-)
diff --git
a/database/connector/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/connector/postgresql/checker/PostgreSQLDatabasePrivilegeCheckerTest.java
b/database/connector/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/connector/postgresql/checker/PostgreSQLDatabasePrivilegeCheckerTest.java
index 88cce2ec73f..96d148f8527 100644
---
a/database/connector/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/connector/postgresql/checker/PostgreSQLDatabasePrivilegeCheckerTest.java
+++
b/database/connector/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/connector/postgresql/checker/PostgreSQLDatabasePrivilegeCheckerTest.java
@@ -17,38 +17,46 @@
package org.apache.shardingsphere.database.connector.postgresql.checker;
+import
org.apache.shardingsphere.database.connector.core.checker.DialectDatabasePrivilegeChecker;
import
org.apache.shardingsphere.database.connector.core.checker.PrivilegeCheckType;
+import
org.apache.shardingsphere.database.connector.core.exception.CheckDatabaseEnvironmentFailedException;
import
org.apache.shardingsphere.database.connector.core.exception.MissingRequiredPrivilegeException;
-import org.junit.jupiter.api.BeforeEach;
+import
org.apache.shardingsphere.database.connector.core.exception.MissingRequiredUserException;
+import
org.apache.shardingsphere.database.connector.core.spi.DatabaseTypedSPILoader;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
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.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import javax.sql.DataSource;
import java.sql.Connection;
-import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
+import java.util.stream.Stream;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class PostgreSQLDatabasePrivilegeCheckerTest {
- @Mock
- private DataSource dataSource;
+ private final DatabaseType databaseType =
TypedSPILoader.getService(DatabaseType.class, "PostgreSQL");
- @Mock
- private Connection connection;
+ private final DialectDatabasePrivilegeChecker checker =
DatabaseTypedSPILoader.getService(DialectDatabasePrivilegeChecker.class,
databaseType);
@Mock
- private DatabaseMetaData metaData;
+ private DataSource dataSource;
@Mock
private PreparedStatement preparedStatement;
@@ -56,40 +64,56 @@ class PostgreSQLDatabasePrivilegeCheckerTest {
@Mock
private ResultSet resultSet;
- @BeforeEach
- void setUp() throws SQLException {
- when(dataSource.getConnection()).thenReturn(connection);
- when(connection.getMetaData()).thenReturn(metaData);
- when(metaData.getUserName()).thenReturn("postgres");
-
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
- when(preparedStatement.executeQuery()).thenReturn(resultSet);
- when(resultSet.next()).thenReturn(true, false);
+ @Test
+ void assertCheckWithNoneType() {
+ assertDoesNotThrow(() -> checker.check(dataSource,
PrivilegeCheckType.NONE));
+ verifyNoInteractions(dataSource);
}
- @Test
- void assertCheckRolReplication() throws SQLException {
- PostgreSQLDatabasePrivilegeChecker dataSourceChecker = new
PostgreSQLDatabasePrivilegeChecker();
- when(resultSet.getString("rolreplication")).thenReturn("t");
- when(resultSet.getString("rolsuper")).thenReturn("f");
- dataSourceChecker.check(dataSource, PrivilegeCheckType.PIPELINE);
- verify(resultSet, atLeastOnce()).getString("rolsuper");
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("checkPipelinePrivilegeArguments")
+ void assertCheckWithPipelinePrivilege(final String name, final String
isSuperRole, final String isReplicationRole, final Class<? extends Throwable>
expectedException) throws SQLException {
+ mockShowGrantsQuery();
+ mockPipelineResultSet(isSuperRole, isReplicationRole);
+ if (null == expectedException) {
+ assertDoesNotThrow(() -> checker.check(dataSource,
PrivilegeCheckType.PIPELINE));
+ } else {
+ assertThrows(expectedException, () -> checker.check(dataSource,
PrivilegeCheckType.PIPELINE));
+ }
+ verify(preparedStatement).executeQuery();
+ }
+
+ private void mockPipelineResultSet(final String isSuperRole, final String
isReplicationRole) throws SQLException {
+ when(resultSet.next()).thenReturn(true);
+ when(resultSet.getString("rolsuper")).thenReturn(isSuperRole);
+
when(resultSet.getString("rolreplication")).thenReturn(isReplicationRole);
}
@Test
- void assertCheckRolSuper() throws SQLException {
- PostgreSQLDatabasePrivilegeChecker dataSourceChecker = new
PostgreSQLDatabasePrivilegeChecker();
- when(resultSet.getString("rolsuper")).thenReturn("t");
- when(resultSet.getString("rolreplication")).thenReturn("f");
- dataSourceChecker.check(dataSource, PrivilegeCheckType.PIPELINE);
- verify(resultSet, atLeastOnce()).getString("rolreplication");
+ void assertCheckWhenUserMissing() throws SQLException {
+ mockShowGrantsQuery();
+ assertThrows(MissingRequiredUserException.class, () ->
checker.check(dataSource, PrivilegeCheckType.PIPELINE));
}
@Test
- void assertCheckNoPrivilege() throws SQLException {
- PostgreSQLDatabasePrivilegeChecker dataSourceChecker = new
PostgreSQLDatabasePrivilegeChecker();
- when(resultSet.getString("rolsuper")).thenReturn("f");
- when(resultSet.getString("rolreplication")).thenReturn("f");
- assertThrows(MissingRequiredPrivilegeException.class, () ->
dataSourceChecker.check(dataSource, PrivilegeCheckType.PIPELINE));
- verify(resultSet, atLeastOnce()).getString("rolreplication");
+ void assertCheckWhenSQLExceptionThrown() throws SQLException {
+ mockShowGrantsQuery();
+ when(preparedStatement.executeQuery()).thenThrow(SQLException.class);
+ assertThrows(CheckDatabaseEnvironmentFailedException.class, () ->
checker.check(dataSource, PrivilegeCheckType.PIPELINE));
+ }
+
+ private void mockShowGrantsQuery() throws SQLException {
+ Connection connection = mock(Connection.class, RETURNS_DEEP_STUBS);
+ when(dataSource.getConnection()).thenReturn(connection);
+ when(connection.getMetaData().getUserName()).thenReturn("postgres");
+ when(connection.prepareStatement("SELECT * FROM pg_roles WHERE rolname
= ?")).thenReturn(preparedStatement);
+ when(preparedStatement.executeQuery()).thenReturn(resultSet);
+ }
+
+ private static Stream<Arguments> checkPipelinePrivilegeArguments() {
+ return Stream.of(
+ Arguments.of("pipeline with super role", "t", "f", null),
+ Arguments.of("pipeline with replication role", "f", "t", null),
+ Arguments.of("pipeline without required privilege", "f", "f",
MissingRequiredPrivilegeException.class));
}
}
