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 43263128dd0 Add more test cases on
FirebirdNonFixedLengthColumnSizeRegistryTest (#38120)
43263128dd0 is described below
commit 43263128dd04df13d32b44e2becb0104818acac0
Author: Liang Zhang <[email protected]>
AuthorDate: Sat Feb 21 20:58:09 2026 +0800
Add more test cases on FirebirdNonFixedLengthColumnSizeRegistryTest (#38120)
---
...rebirdNonFixedLengthColumnSizeRegistryTest.java | 104 +++++++++++++++------
1 file changed, 77 insertions(+), 27 deletions(-)
diff --git
a/database/connector/dialect/firebird/src/test/java/org/apache/shardingsphere/database/connector/firebird/metadata/data/FirebirdNonFixedLengthColumnSizeRegistryTest.java
b/database/connector/dialect/firebird/src/test/java/org/apache/shardingsphere/database/connector/firebird/metadata/data/FirebirdNonFixedLengthColumnSizeRegistryTest.java
index 156a4099b7a..da167e7cd87 100644
---
a/database/connector/dialect/firebird/src/test/java/org/apache/shardingsphere/database/connector/firebird/metadata/data/FirebirdNonFixedLengthColumnSizeRegistryTest.java
+++
b/database/connector/dialect/firebird/src/test/java/org/apache/shardingsphere/database/connector/firebird/metadata/data/FirebirdNonFixedLengthColumnSizeRegistryTest.java
@@ -17,55 +17,105 @@
package org.apache.shardingsphere.database.connector.firebird.metadata.data;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
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.HashMap;
import java.util.Map;
import java.util.OptionalInt;
+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.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
class FirebirdNonFixedLengthColumnSizeRegistryTest {
+ private Map<String, Map<String, Integer>> columnSizes;
+
+ @BeforeEach
+ @SuppressWarnings("unchecked")
+ void setUp() throws ReflectiveOperationException {
+ columnSizes = (Map<String, Map<String, Integer>>)
Plugins.getMemberAccessor()
+
.get(FirebirdNonFixedLengthColumnSizeRegistry.class.getDeclaredField("COLUMN_SIZES"),
FirebirdNonFixedLengthColumnSizeRegistry.class);
+ columnSizes.clear();
+ }
+
+ @AfterEach
+ void tearDown() {
+ columnSizes.clear();
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("refreshTableRemoveCases")
+ void assertRefreshTableRemovesEntry(final String name, final String
schemaName, final String tableName, final Map<String, Integer> newColumnSizes,
final String tableKey) {
+ columnSizes.put(tableKey, Collections.singletonMap("EXISTING_COL", 9));
+ FirebirdNonFixedLengthColumnSizeRegistry.refreshTable(schemaName,
tableName, newColumnSizes);
+ assertFalse(columnSizes.containsKey(tableKey));
+ }
+
@Test
- void assertRefreshAndFindColumnSize() {
- Map<String, Integer> columnSizes =
Collections.singletonMap("varchar_col", 64);
- FirebirdNonFixedLengthColumnSizeRegistry.refreshTable("schema_a",
"table_a", columnSizes);
- OptionalInt actual =
FirebirdNonFixedLengthColumnSizeRegistry.findColumnSize("schema_a", "table_a",
"VARCHAR_COL");
- assertTrue(actual.isPresent());
- assertThat(actual.getAsInt(), is(64));
- FirebirdNonFixedLengthColumnSizeRegistry.refreshTable("schema_a",
"table_a", Collections.emptyMap());
+ void assertRefreshTableWhenTableNameIsNull() {
+ columnSizes.put("SENTINEL", Collections.singletonMap("EXISTING_COL",
9));
+ FirebirdNonFixedLengthColumnSizeRegistry.refreshTable("schema_a",
null, Collections.singletonMap("size_col", 16));
+ assertTrue(columnSizes.containsKey("SENTINEL"));
+ assertThat(columnSizes.get("SENTINEL").get("EXISTING_COL"), is(9));
}
@Test
- void assertRefreshTableRemovesEntryWhenEmptyColumnSizesProvided() {
- FirebirdNonFixedLengthColumnSizeRegistry.refreshTable("schema_b",
"table_b", Collections.singletonMap("col", 32));
- FirebirdNonFixedLengthColumnSizeRegistry.refreshTable("schema_b",
"table_b", Collections.emptyMap());
-
assertFalse(FirebirdNonFixedLengthColumnSizeRegistry.findColumnSize("schema_b",
"table_b", "COL").isPresent());
+ void assertRefreshTable() {
+ FirebirdNonFixedLengthColumnSizeRegistry.refreshTable("schema_c",
"table_x", createColumnSizesWithMixedNames());
+ Map<String, Integer> actual = columnSizes.get("SCHEMA_C.TABLE_X");
+ assertTrue(actual.containsKey("SIZE_COL"));
+ assertThat(actual.get("SIZE_COL"), is(64));
+ assertThat(actual.size(), is(1));
+ assertThrows(UnsupportedOperationException.class, () ->
actual.put("ANOTHER", 32));
+ }
+
+ private static Map<String, Integer> createColumnSizesWithMixedNames() {
+ Map<String, Integer> result = new HashMap<>(2, 1F);
+ result.put("size_col", 64);
+ result.put(null, 128);
+ return result;
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("findColumnSizeEmptyCases")
+ void assertFindColumnSizeWhenAbsent(final String name, final String
tableName, final String columnName, final boolean registerTable, final boolean
registerColumn) {
+ if (registerTable) {
+ columnSizes.put("SCHEMA_A.TABLE_A", registerColumn ?
Collections.singletonMap("SIZE_COL", 12) :
Collections.singletonMap("OTHER_COL", 12));
+ }
+
assertFalse(FirebirdNonFixedLengthColumnSizeRegistry.findColumnSize("schema_a",
tableName, columnName).isPresent());
}
@Test
- void assertRefreshTableSkipsNullColumnNames() {
- Map<String, Integer> columnSizes = new HashMap<>(2, 1F);
- columnSizes.put("valid", 12);
- columnSizes.put(null, 24);
- FirebirdNonFixedLengthColumnSizeRegistry.refreshTable("schema_c",
"table_c", columnSizes);
- OptionalInt actual =
FirebirdNonFixedLengthColumnSizeRegistry.findColumnSize("schema_c", "table_c",
"VaLiD");
+ void assertFindColumnSize() {
+ columnSizes.put("SCHEMA_A.123", Collections.singletonMap("SIZE_COL",
24));
+ OptionalInt actual =
FirebirdNonFixedLengthColumnSizeRegistry.findColumnSize("schema_a", "123",
"size_col");
assertTrue(actual.isPresent());
- assertThat(actual.getAsInt(), is(12));
-
assertFalse(FirebirdNonFixedLengthColumnSizeRegistry.findColumnSize("schema_c",
"table_c", null).isPresent());
- FirebirdNonFixedLengthColumnSizeRegistry.refreshTable("schema_c",
"table_c", Collections.emptyMap());
+ assertThat(actual.getAsInt(), is(24));
}
- @Test
- void assertRefreshTableRemovesWhenAllColumnsInvalid() {
- Map<String, Integer> columnSizes = new HashMap<>(1, 1F);
- columnSizes.put(null, 48);
- FirebirdNonFixedLengthColumnSizeRegistry.refreshTable("schema_d",
"table_d", columnSizes);
-
assertFalse(FirebirdNonFixedLengthColumnSizeRegistry.findColumnSize("schema_d",
"table_d", "any").isPresent());
+ private static Stream<Arguments> refreshTableRemoveCases() {
+ return Stream.of(
+ Arguments.of("empty_column_sizes", "schema_a", "table_a",
Collections.emptyMap(), "SCHEMA_A.TABLE_A"),
+ Arguments.of("empty_column_sizes_with_trimmed_table", null,
"table_1", Collections.emptyMap(), ".TABLE"),
+ Arguments.of("all_column_names_are_null", "schema_b", "123",
Collections.singletonMap(null, 9), "SCHEMA_B.123"));
+ }
+
+ private static Stream<Arguments> findColumnSizeEmptyCases() {
+ return Stream.of(
+ Arguments.of("null_table_name", null, "size_col", false,
false),
+ Arguments.of("null_column_name", "table_a", null, true, true),
+ Arguments.of("table_not_registered", "table_a", "size_col",
false, false),
+ Arguments.of("column_not_registered", "table_a", "size_col",
true, false));
}
}
