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 d853fb88b33 Add more test cases on DatabaseTypeFactoryTest and
DatabaseTypeRegistryTest (#38112)
d853fb88b33 is described below
commit d853fb88b3335e1e7a104bc4812822b87b3a11e2
Author: Liang Zhang <[email protected]>
AuthorDate: Fri Feb 20 14:53:29 2026 +0800
Add more test cases on DatabaseTypeFactoryTest and DatabaseTypeRegistryTest
(#38112)
---
.../core/type/DatabaseTypeFactoryTest.java | 85 +++++++++++++++++++---
.../core/type/DatabaseTypeRegistryTest.java | 54 ++++++++++----
2 files changed, 116 insertions(+), 23 deletions(-)
diff --git
a/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/type/DatabaseTypeFactoryTest.java
b/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/type/DatabaseTypeFactoryTest.java
index 3976932b2dd..553a4202d96 100644
---
a/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/type/DatabaseTypeFactoryTest.java
+++
b/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/type/DatabaseTypeFactoryTest.java
@@ -18,26 +18,93 @@
package org.apache.shardingsphere.database.connector.core.type;
import
org.apache.shardingsphere.database.connector.core.exception.UnsupportedStorageTypeException;
+import org.apache.shardingsphere.infra.spi.ShardingSphereServiceLoader;
+import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
+import
org.apache.shardingsphere.test.infra.framework.extension.mock.AutoMockExtension;
+import
org.apache.shardingsphere.test.infra.framework.extension.mock.StaticMockSettings;
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.MockedStatic;
+
+import java.sql.DatabaseMetaData;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Optional;
+import java.util.stream.Stream;
-import static org.hamcrest.Matchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ShardingSphereServiceLoader.class)
class DatabaseTypeFactoryTest {
- @Test
- void assertGetDatabaseTypeWithTrunkURL() {
-
assertThat(DatabaseTypeFactory.get("jdbc:trunk://localhost:3306/test").getType(),
is("TRUNK"));
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("getDatabaseTypeWithRecognizedURLArguments")
+ void assertGetWithRecognizedURL(final String name, final String url, final
Collection<DatabaseType> databaseTypes, final DatabaseType
expectedDatabaseType) {
+
when(ShardingSphereServiceLoader.getServiceInstances(DatabaseType.class)).thenReturn(databaseTypes);
+ assertThat(DatabaseTypeFactory.get(url), is(expectedDatabaseType));
}
@Test
- void assertGetDatabaseTypeWithBranchURL() {
-
assertThat(DatabaseTypeFactory.get("jdbc:trunk:branch://localhost:3306/test?databaseType=BRANCH").getType(),
is("TRUNK"));
+ void assertGetWithUnrecognizedURL() {
+ DatabaseType databaseType = mock(DatabaseType.class);
+
when(databaseType.getJdbcUrlPrefixes()).thenReturn(Collections.singleton("jdbc:trunk:"));
+
when(ShardingSphereServiceLoader.getServiceInstances(DatabaseType.class)).thenReturn(Collections.singletonList(databaseType));
+ assertThrows(UnsupportedStorageTypeException.class, () ->
DatabaseTypeFactory.get("jdbc:not-existed:test"));
}
- @Test
- void assertGetDatabaseTypeWithUnrecognizedURL() {
- assertThrows(UnsupportedStorageTypeException.class, () ->
DatabaseTypeFactory.get("jdbc:not-existed:test"));
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("getDatabaseTypeWithDatabaseMetaDataArguments")
+ void assertGetWithDatabaseMetaData(final String name, final String
productName, final String url, final Collection<DatabaseType> databaseTypes,
+ final DatabaseType
expectedDatabaseType, final boolean isHive) throws SQLException {
+ DatabaseMetaData metaData = mock(DatabaseMetaData.class);
+ when(metaData.getDatabaseProductName()).thenReturn(productName);
+ if (isHive) {
+ DatabaseType hiveDatabaseType = mock(DatabaseType.class);
+ try (MockedStatic<TypedSPILoader> typedSPILoader =
mockStatic(TypedSPILoader.class)) {
+ typedSPILoader.when(() ->
TypedSPILoader.getService(DatabaseType.class,
"Hive")).thenReturn(hiveDatabaseType);
+ assertThat(DatabaseTypeFactory.get(metaData),
is(hiveDatabaseType));
+ }
+ return;
+ }
+ when(metaData.getURL()).thenReturn(url);
+
when(ShardingSphereServiceLoader.getServiceInstances(DatabaseType.class)).thenReturn(databaseTypes);
+ assertThat(DatabaseTypeFactory.get(metaData),
is(expectedDatabaseType));
+ }
+
+ private static Stream<Arguments>
getDatabaseTypeWithRecognizedURLArguments() {
+ DatabaseType trunkDatabaseType = mockDatabaseType("jdbc:trunk:", null);
+ DatabaseType branchDatabaseType =
mockDatabaseType("jdbc:trunk:branch:", trunkDatabaseType);
+ DatabaseType branchOnlyDatabaseType =
mockDatabaseType("jdbc:branch-only:", mock(DatabaseType.class));
+ return Stream.of(
+ Arguments.of("trunk url", "jdbc:trunk://localhost:3306/test",
Collections.singletonList(trunkDatabaseType), trunkDatabaseType),
+ Arguments.of("branch url",
"jdbc:trunk:branch://localhost:3306/test?databaseType=BRANCH",
Arrays.asList(trunkDatabaseType, branchDatabaseType), trunkDatabaseType),
+ Arguments.of("branch only url",
"jdbc:branch-only://localhost:3306/test",
Collections.singletonList(branchOnlyDatabaseType), branchOnlyDatabaseType));
+ }
+
+ private static Stream<Arguments>
getDatabaseTypeWithDatabaseMetaDataArguments() {
+ DatabaseType trunkDatabaseType = mockDatabaseType("jdbc:trunk:", null);
+ DatabaseType branchOnlyDatabaseType =
mockDatabaseType("jdbc:branch-only:", mock(DatabaseType.class));
+ return Stream.of(
+ Arguments.of("hive database product", "Apache Hive",
"jdbc:hive://localhost:3306/test", Collections.emptyList(), null, true),
+ Arguments.of("non hive with trunk url", "MySQL",
"jdbc:trunk://localhost:3306/test",
Collections.singletonList(trunkDatabaseType), trunkDatabaseType, false),
+ Arguments.of("non hive with branch only url", "MySQL",
"jdbc:branch-only://localhost:3306/test",
Collections.singletonList(branchOnlyDatabaseType), branchOnlyDatabaseType,
false));
+ }
+
+ private static DatabaseType mockDatabaseType(final String jdbcUrlPrefix,
final DatabaseType trunkDatabaseType) {
+ DatabaseType result = mock(DatabaseType.class);
+
when(result.getJdbcUrlPrefixes()).thenReturn(Collections.singleton(jdbcUrlPrefix));
+
when(result.getTrunkDatabaseType()).thenReturn(Optional.ofNullable(trunkDatabaseType));
+ return result;
}
}
diff --git
a/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/type/DatabaseTypeRegistryTest.java
b/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/type/DatabaseTypeRegistryTest.java
index b9a6a83a7b1..ae6b3e122e9 100644
---
a/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/type/DatabaseTypeRegistryTest.java
+++
b/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/type/DatabaseTypeRegistryTest.java
@@ -17,41 +17,67 @@
package org.apache.shardingsphere.database.connector.core.type;
+import
org.apache.shardingsphere.database.connector.core.metadata.database.metadata.DialectDatabaseMetaData;
+import
org.apache.shardingsphere.database.connector.core.metadata.database.metadata.option.IdentifierPatternType;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.internal.configuration.plugins.Plugins;
import java.util.Collections;
+import java.util.stream.Stream;
-import static org.hamcrest.Matchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.hamcrest.Matchers.is;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
class DatabaseTypeRegistryTest {
+ private final DatabaseType trunkDatabaseType =
TypedSPILoader.getService(DatabaseType.class, "TRUNK");
+
+ private final DatabaseType branchDatabaseType =
TypedSPILoader.getService(DatabaseType.class, "BRANCH");
+
@Test
void assertGetAllBranchDatabaseTypesWithTrunkType() {
- assertThat(new
DatabaseTypeRegistry(TypedSPILoader.getService(DatabaseType.class,
"TRUNK")).getAllBranchDatabaseTypes(),
-
is(Collections.singletonList(TypedSPILoader.getService(DatabaseType.class,
"BRANCH"))));
+ assertThat(new
DatabaseTypeRegistry(trunkDatabaseType).getAllBranchDatabaseTypes(),
is(Collections.singletonList(branchDatabaseType)));
}
@Test
void assertGetAllBranchDatabaseTypesWithBranchType() {
- assertTrue(new
DatabaseTypeRegistry(TypedSPILoader.getService(DatabaseType.class,
"BRANCH")).getAllBranchDatabaseTypes().isEmpty());
+ assertTrue(new
DatabaseTypeRegistry(branchDatabaseType).getAllBranchDatabaseTypes().isEmpty());
}
- @Test
- void assertGetDefaultSchemaNameWhenDatabaseTypeContainsDefaultSchema() {
- assertThat(new
DatabaseTypeRegistry(TypedSPILoader.getService(DatabaseType.class,
"TRUNK")).getDefaultSchemaName("FOO"), is("test"));
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("getDefaultSchemaNameArguments")
+ void assertGetDefaultSchemaName(final String name, final String
databaseType, final String databaseName, final String expectedSchemaName) {
+ assertThat(new
DatabaseTypeRegistry(TypedSPILoader.getService(DatabaseType.class,
databaseType)).getDefaultSchemaName(databaseName), is(expectedSchemaName));
}
- @Test
- void assertGetDefaultSchemaNameWhenDatabaseTypeNotContainsDefaultSchema() {
- assertThat(new
DatabaseTypeRegistry(TypedSPILoader.getService(DatabaseType.class,
"BRANCH")).getDefaultSchemaName("FOO"), is("FOO"));
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("formatIdentifierPatternArguments")
+ void assertFormatIdentifierPattern(final String name, final
IdentifierPatternType identifierPatternType, final String
expectedIdentifierPattern) throws ReflectiveOperationException {
+ DialectDatabaseMetaData dialectDatabaseMetaData =
mock(DialectDatabaseMetaData.class);
+
when(dialectDatabaseMetaData.getIdentifierPatternType()).thenReturn(identifierPatternType);
+ DatabaseTypeRegistry databaseTypeRegistry = new
DatabaseTypeRegistry(trunkDatabaseType);
+
Plugins.getMemberAccessor().set(DatabaseTypeRegistry.class.getDeclaredField("dialectDatabaseMetaData"),
databaseTypeRegistry, dialectDatabaseMetaData);
+ assertThat(databaseTypeRegistry.formatIdentifierPattern("Foo"),
is(expectedIdentifierPattern));
}
- @Test
- void
assertGetDefaultSchemaNameWhenDatabaseTypeNotContainsDefaultSchemaAndNullDatabaseName()
{
- assertNull(new
DatabaseTypeRegistry(TypedSPILoader.getService(DatabaseType.class,
"BRANCH")).getDefaultSchemaName(null));
+ private static Stream<Arguments> getDefaultSchemaNameArguments() {
+ return Stream.of(
+ Arguments.of("database type contains default schema", "TRUNK",
"FOO", "test"),
+ Arguments.of("database type does not contain default schema",
"BRANCH", "FOO", "FOO"),
+ Arguments.of("database name is null", "BRANCH", null, null));
+ }
+
+ private static Stream<Arguments> formatIdentifierPatternArguments() {
+ return Stream.of(
+ Arguments.of("identifier pattern upper case",
IdentifierPatternType.UPPER_CASE, "FOO"),
+ Arguments.of("identifier pattern lower case",
IdentifierPatternType.LOWER_CASE, "foo"),
+ Arguments.of("identifier pattern keep origin",
IdentifierPatternType.KEEP_ORIGIN, "Foo"));
}
}
