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 c191a709093 Add more test cases on DatabaseMetaDataManagerTest (#37254)
c191a709093 is described below
commit c191a7090936641cdbda351b2fd8f1914df74a4d
Author: Liang Zhang <[email protected]>
AuthorDate: Tue Dec 2 15:12:54 2025 +0800
Add more test cases on DatabaseMetaDataManagerTest (#37254)
* Add StatisticsManagerTest
* Add more test cases on DatabaseMetaDataManagerTest
---
.../DatabaseMetaDataManagerTest.java | 95 +++++++++++++++++++---
1 file changed, 82 insertions(+), 13 deletions(-)
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/DatabaseMetaDataManagerTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/database/DatabaseMetaDataManagerTest.java
similarity index 62%
rename from
mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/DatabaseMetaDataManagerTest.java
rename to
mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/database/DatabaseMetaDataManagerTest.java
index 62188b5cf6d..30ce42fad04 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/DatabaseMetaDataManagerTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/database/DatabaseMetaDataManagerTest.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.mode.metadata.manager;
+package org.apache.shardingsphere.mode.metadata.manager.database;
import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
@@ -24,18 +24,19 @@ import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSp
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereView;
+import
org.apache.shardingsphere.infra.rule.attribute.datanode.MutableDataNodeRuleAttribute;
+import org.apache.shardingsphere.infra.rule.scope.GlobalRule;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
-import
org.apache.shardingsphere.mode.metadata.manager.database.DatabaseMetaDataManager;
import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistFacade;
+import
org.apache.shardingsphere.mode.metadata.refresher.util.TableRefreshUtils;
+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.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-import org.mockito.junit.jupiter.MockitoSettings;
-import org.mockito.quality.Strictness;
import java.sql.Types;
import java.util.Collections;
@@ -48,34 +49,39 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-@ExtendWith(MockitoExtension.class)
-@MockitoSettings(strictness = Strictness.LENIENT)
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(TableRefreshUtils.class)
class DatabaseMetaDataManagerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private MetaDataContexts metaDataContexts;
+ @Mock
+ private GlobalRule globalRule;
+
private DatabaseMetaDataManager databaseMetaDataManager;
@BeforeEach
void setUp() {
ShardingSphereDatabase database = mockDatabase();
-
when(metaDataContexts.getMetaData().containsDatabase("foo_db")).thenReturn(true);
-
when(metaDataContexts.getMetaData().getDatabase("foo_db")).thenReturn(database);
-
when(metaDataContexts.getMetaData().getAllDatabases()).thenReturn(Collections.singleton(database));
+
lenient().when(metaDataContexts.getMetaData().containsDatabase("foo_db")).thenReturn(true);
+
lenient().when(metaDataContexts.getMetaData().getDatabase("foo_db")).thenReturn(database);
+
lenient().when(metaDataContexts.getMetaData().getAllDatabases()).thenReturn(Collections.singleton(database));
+
lenient().when(metaDataContexts.getMetaData().getGlobalRuleMetaData().getRules()).thenReturn(Collections.singleton(globalRule));
databaseMetaDataManager = new
DatabaseMetaDataManager(metaDataContexts, mock(MetaDataPersistFacade.class));
}
private ShardingSphereDatabase mockDatabase() {
ShardingSphereDatabase result = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
- when(result.getName()).thenReturn("foo_db");
-
when(result.getProtocolType()).thenReturn(TypedSPILoader.getService(DatabaseType.class,
"FIXTURE"));
- when(result.containsSchema("foo_schema")).thenReturn(true);
+ lenient().when(result.getName()).thenReturn("foo_db");
+
lenient().when(result.getProtocolType()).thenReturn(TypedSPILoader.getService(DatabaseType.class,
"FIXTURE"));
+ lenient().when(result.containsSchema("foo_schema")).thenReturn(true);
return result;
}
@@ -127,10 +133,32 @@ class DatabaseMetaDataManagerTest {
@Test
void assertDropExistedSchema() {
+
when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema").getAllTables()).thenReturn(Collections.emptyList());
databaseMetaDataManager.dropSchema("foo_db", "foo_schema");
verify(metaDataContexts.getMetaData().getDatabase("foo_db")).dropSchema("foo_schema");
}
+ @Test
+ void assertDropSchemaWithSingleTableRefreshRules() {
+ ShardingSphereSchema schema = mock(ShardingSphereSchema.class);
+ ShardingSphereTable singleTable = new ShardingSphereTable("foo_tbl",
Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
+
when(schema.getAllTables()).thenReturn(Collections.singleton(singleTable));
+
when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(schema);
+ when(TableRefreshUtils.isSingleTable("foo_tbl",
metaDataContexts.getMetaData().getDatabase("foo_db"))).thenReturn(true);
+ databaseMetaDataManager.dropSchema("foo_db", "foo_schema");
+
verify(metaDataContexts.getMetaData().getDatabase("foo_db")).reloadRules();
+ }
+
+ @Test
+ void assertRenameSchema() {
+ ShardingSphereSchema schema = createToBeAlteredSchema();
+
when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(schema);
+ databaseMetaDataManager.renameSchema("foo_db", "foo_schema",
"bar_schema");
+
verify(metaDataContexts.getMetaData().getDatabase("foo_db")).addSchema(any(ShardingSphereSchema.class));
+
verify(metaDataContexts.getMetaData().getDatabase("foo_db")).dropSchema("foo_schema");
+
verify(metaDataContexts.getMetaData().getDatabase("foo_db")).reloadRules();
+ }
+
@Test
void assertAlterTableWithNotExistedSchema() {
ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
@@ -153,6 +181,26 @@ class DatabaseMetaDataManagerTest {
assertTrue(table.containsColumn("foo_col"));
}
+ @Test
+ void assertAlterTableWithSingleTableReloadRules() {
+ ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
+
when(metaDataContexts.getMetaData().getDatabase("foo_db").containsSchema("foo_schema")).thenReturn(true);
+
when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(toBeAlteredSchema);
+ when(TableRefreshUtils.isSingleTable("foo_tbl",
metaDataContexts.getMetaData().getDatabase("foo_db"))).thenReturn(true);
+ databaseMetaDataManager.alterTable("foo_db", "foo_schema", new
ShardingSphereTable("foo_tbl", Collections.emptyList(),
Collections.emptyList(), Collections.emptyList()));
+
verify(metaDataContexts.getMetaData().getDatabase("foo_db")).reloadRules();
+ }
+
+ @Test
+ void assertAlterViewWithSingleTableReloadRules() {
+ ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
+
when(metaDataContexts.getMetaData().getDatabase("foo_db").containsSchema("foo_schema")).thenReturn(true);
+
when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(toBeAlteredSchema);
+ when(TableRefreshUtils.isSingleTable("foo_view",
metaDataContexts.getMetaData().getDatabase("foo_db"))).thenReturn(true);
+ databaseMetaDataManager.alterView("foo_db", "foo_schema", new
ShardingSphereView("foo_view", ""));
+
verify(metaDataContexts.getMetaData().getDatabase("foo_db")).reloadRules();
+ }
+
@Test
void assertAlterView() {
ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
@@ -168,6 +216,7 @@ class DatabaseMetaDataManagerTest {
@Test
void assertDropTable() {
when(metaDataContexts.getMetaData().getDatabase("foo_db").getAllSchemas()).thenReturn(Collections.singleton(createToBeAlteredSchema()));
+ mockMutableDataNodeRuleAttribute();
databaseMetaDataManager.dropTable("foo_db", "foo_schema", "foo_tbl");
assertFalse(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema").containsTable("foo_tbl"));
}
@@ -175,10 +224,30 @@ class DatabaseMetaDataManagerTest {
@Test
void assertDropView() {
when(metaDataContexts.getMetaData().getDatabase("foo_db").getAllSchemas()).thenReturn(Collections.singleton(createToBeAlteredSchema()));
+ mockMutableDataNodeRuleAttribute();
databaseMetaDataManager.dropView("foo_db", "foo_schema", "foo_view");
assertFalse(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema").containsView("foo_view"));
}
+ @Test
+ void assertDropTableWithNotExistedSchema() {
+
when(metaDataContexts.getMetaData().getDatabase("foo_db").containsSchema("foo_schema")).thenReturn(false);
+ databaseMetaDataManager.dropTable("foo_db", "foo_schema", "foo_tbl");
+ verify(metaDataContexts.getMetaData().getDatabase("foo_db"),
never()).getSchema(anyString());
+ }
+
+ @Test
+ void assertDropViewWithNotExistedSchema() {
+
when(metaDataContexts.getMetaData().getDatabase("foo_db").containsSchema("foo_schema")).thenReturn(false);
+ databaseMetaDataManager.dropView("foo_db", "foo_schema", "foo_view");
+ verify(metaDataContexts.getMetaData().getDatabase("foo_db"),
never()).getSchema(anyString());
+ }
+
+ private void mockMutableDataNodeRuleAttribute() {
+ MutableDataNodeRuleAttribute attribute =
mock(MutableDataNodeRuleAttribute.class);
+
when(metaDataContexts.getMetaData().getDatabase("foo_db").getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class)).thenReturn(Collections.singleton(attribute));
+ }
+
private ShardingSphereSchema createToBeAlteredSchema() {
ShardingSphereTable beforeChangedTable = new
ShardingSphereTable("foo_tbl", Collections.emptyList(),
Collections.emptyList(), Collections.emptyList());
ShardingSphereView beforeChangedView = new
ShardingSphereView("foo_view", "");
