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 2024/09/16 15:54:45 UTC
(shardingsphere) branch master updated: Add test cases for SchemaMetaDataManager (#32906)
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 a9551804bf9 Add test cases for SchemaMetaDataManager (#32906)
a9551804bf9 is described below
commit a9551804bf9cdc4b1c3e531fe8132dfd5203b685
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Mon Sep 16 23:54:39 2024 +0800
Add test cases for SchemaMetaDataManager (#32906)
* Add test cases for SchemaMetaDataManager
* Add test cases for SchemaMetaDataManager
* Add test cases for SchemaMetaDataManager
---
.../core/metadata/data/loader/MetaDataLoader.java | 2 +-
.../mode/manager/ContextManager.java | 6 +-
.../mode/metadata/MetaDataContextManager.java | 3 +-
.../metadata/manager/SchemaMetaDataManager.java | 67 +++----
.../mode/manager/ContextManagerTest.java | 128 +-----------
.../manager/SchemaMetaDataManagerTest.java | 215 +++++++++++++++++++++
6 files changed, 261 insertions(+), 160 deletions(-)
diff --git a/infra/database/core/src/main/java/org/apache/shardingsphere/infra/database/core/metadata/data/loader/MetaDataLoader.java b/infra/database/core/src/main/java/org/apache/shardingsphere/infra/database/core/metadata/data/loader/MetaDataLoader.java
index dd326098d6b..10b8bb73bd8 100644
--- a/infra/database/core/src/main/java/org/apache/shardingsphere/infra/database/core/metadata/data/loader/MetaDataLoader.java
+++ b/infra/database/core/src/main/java/org/apache/shardingsphere/infra/database/core/metadata/data/loader/MetaDataLoader.java
@@ -95,7 +95,7 @@ public final class MetaDataLoader {
for (String each : material.getActualTableNames()) {
TableMetaDataLoader.load(material.getDataSource(), each, material.getStorageType()).ifPresent(tableMetaData::add);
}
- return Collections.singletonList(new SchemaMetaData(material.getDefaultSchemaName(), tableMetaData));
+ return Collections.singleton(new SchemaMetaData(material.getDefaultSchemaName(), tableMetaData));
}
private static void merge(final Map<String, SchemaMetaData> schemaMetaDataMap, final Collection<SchemaMetaData> addedSchemaMetaDataList) {
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
index d861bdf34d5..99f8d4309d0 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
@@ -130,12 +130,10 @@ public final class ContextManager implements AutoCloseable {
ShardingSphereSchema reloadedSchema = loadSchema(database, schemaName, dataSourceName);
if (reloadedSchema.getTables().isEmpty()) {
database.dropSchema(schemaName);
- persistServiceFacade.getMetaDataPersistService().getDatabaseMetaDataService().dropSchema(database.getName(),
- schemaName);
+ persistServiceFacade.getMetaDataPersistService().getDatabaseMetaDataService().dropSchema(database.getName(), schemaName);
} else {
database.addSchema(schemaName, reloadedSchema);
- persistServiceFacade.getMetaDataPersistService().getDatabaseMetaDataService()
- .compareAndPersist(database.getName(), schemaName, reloadedSchema);
+ persistServiceFacade.getMetaDataPersistService().getDatabaseMetaDataService().compareAndPersist(database.getName(), schemaName, reloadedSchema);
}
} catch (final SQLException ex) {
log.error("Reload meta data of database: {} schema: {} with data source: {} failed", database.getName(), schemaName, dataSourceName, ex);
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java
index 5c0c1848653..b39cb56cc11 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java
@@ -74,8 +74,7 @@ public class MetaDataContextManager {
private final RuleConfigurationPersistDecorateEngine ruleConfigPersistDecorateEngine;
- public MetaDataContextManager(final AtomicReference<MetaDataContexts> metaDataContexts, final ComputeNodeInstanceContext computeNodeInstanceContext,
- final PersistRepository repository) {
+ public MetaDataContextManager(final AtomicReference<MetaDataContexts> metaDataContexts, final ComputeNodeInstanceContext computeNodeInstanceContext, final PersistRepository repository) {
this.metaDataContexts = metaDataContexts;
this.computeNodeInstanceContext = computeNodeInstanceContext;
resourceSwitchManager = new ResourceSwitchManager();
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/SchemaMetaDataManager.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/SchemaMetaDataManager.java
index 17742956a7e..97b852601dc 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/SchemaMetaDataManager.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/SchemaMetaDataManager.java
@@ -55,7 +55,7 @@ public final class SchemaMetaDataManager {
/**
* Add database.
*
- * @param databaseName database name
+ * @param databaseName to be added database name
*/
public synchronized void addDatabase(final String databaseName) {
if (metaDataContexts.get().getMetaData().containsDatabase(databaseName)) {
@@ -69,7 +69,7 @@ public final class SchemaMetaDataManager {
/**
* Drop database.
*
- * @param databaseName database name
+ * @param databaseName to be dropped database name
*/
public synchronized void dropDatabase(final String databaseName) {
if (!metaDataContexts.get().getMetaData().containsDatabase(databaseName)) {
@@ -81,8 +81,8 @@ public final class SchemaMetaDataManager {
/**
* Add schema.
*
- * @param databaseName database name
- * @param schemaName schema name
+ * @param databaseName to be added database name
+ * @param schemaName to be added schema name
*/
public synchronized void addSchema(final String databaseName, final String schemaName) {
ShardingSphereMetaData metaData = metaDataContexts.get().getMetaData();
@@ -97,14 +97,11 @@ public final class SchemaMetaDataManager {
/**
* Drop schema.
*
- * @param databaseName database name
- * @param schemaName schema name
+ * @param databaseName to be dropped database name
+ * @param schemaName to be dropped schema name
*/
public synchronized void dropSchema(final String databaseName, final String schemaName) {
ShardingSphereMetaData metaData = metaDataContexts.get().getMetaData();
- if (!metaData.containsDatabase(databaseName)) {
- return;
- }
ShardingSphereDatabase database = metaData.getDatabase(databaseName);
if (!database.containsSchema(schemaName)) {
return;
@@ -118,17 +115,17 @@ public final class SchemaMetaDataManager {
*
* @param databaseName database name
* @param schemaName schema name
- * @param toBeDeletedTableName to be deleted table name
- * @param toBeDeletedViewName to be deleted view name
+ * @param toBeChangedTable to be changed table
+ * @param toBeChangedView to be changed view
*/
- public synchronized void alterSchema(final String databaseName, final String schemaName, final String toBeDeletedTableName, final String toBeDeletedViewName) {
+ public synchronized void alterSchema(final String databaseName, final String schemaName, final ShardingSphereTable toBeChangedTable, final ShardingSphereView toBeChangedView) {
ShardingSphereMetaData metaData = metaDataContexts.get().getMetaData();
- if (!metaData.containsDatabase(databaseName) || !metaData.getDatabase(databaseName).containsSchema(schemaName)) {
+ if (!metaData.getDatabase(databaseName).containsSchema(schemaName)) {
return;
}
- Optional.ofNullable(toBeDeletedTableName).ifPresent(optional -> dropTable(databaseName, schemaName, optional));
- Optional.ofNullable(toBeDeletedViewName).ifPresent(optional -> dropView(databaseName, schemaName, optional));
- if (!Strings.isNullOrEmpty(toBeDeletedTableName) || !Strings.isNullOrEmpty(toBeDeletedViewName)) {
+ Optional.ofNullable(toBeChangedTable).ifPresent(optional -> alterTable(databaseName, schemaName, optional));
+ Optional.ofNullable(toBeChangedView).ifPresent(optional -> alterView(databaseName, schemaName, optional));
+ if (null != toBeChangedTable || null != toBeChangedView) {
metaData.getGlobalRuleMetaData().getRules().forEach(each -> ((GlobalRule) each).refresh(metaData.getDatabases(), GlobalRuleChangedType.SCHEMA_CHANGED));
}
}
@@ -138,33 +135,21 @@ public final class SchemaMetaDataManager {
*
* @param databaseName database name
* @param schemaName schema name
- * @param toBeChangedTable to be changed table
- * @param toBeChangedView to be changed view
+ * @param toBeDeletedTableName to be deleted table name
+ * @param toBeDeletedViewName to be deleted view name
*/
- public synchronized void alterSchema(final String databaseName, final String schemaName, final ShardingSphereTable toBeChangedTable, final ShardingSphereView toBeChangedView) {
+ public synchronized void alterSchema(final String databaseName, final String schemaName, final String toBeDeletedTableName, final String toBeDeletedViewName) {
ShardingSphereMetaData metaData = metaDataContexts.get().getMetaData();
- if (!metaData.containsDatabase(databaseName) || !metaData.getDatabase(databaseName).containsSchema(schemaName)) {
+ if (!metaData.getDatabase(databaseName).containsSchema(schemaName)) {
return;
}
- Optional.ofNullable(toBeChangedTable).ifPresent(optional -> alterTable(databaseName, schemaName, optional));
- Optional.ofNullable(toBeChangedView).ifPresent(optional -> alterView(databaseName, schemaName, optional));
- if (null != toBeChangedTable || null != toBeChangedView) {
+ Optional.ofNullable(toBeDeletedTableName).ifPresent(optional -> dropTable(databaseName, schemaName, optional));
+ Optional.ofNullable(toBeDeletedViewName).ifPresent(optional -> dropView(databaseName, schemaName, optional));
+ if (!Strings.isNullOrEmpty(toBeDeletedTableName) || !Strings.isNullOrEmpty(toBeDeletedViewName)) {
metaData.getGlobalRuleMetaData().getRules().forEach(each -> ((GlobalRule) each).refresh(metaData.getDatabases(), GlobalRuleChangedType.SCHEMA_CHANGED));
}
}
- private void dropTable(final String databaseName, final String schemaName, final String toBeDeletedTableName) {
- metaDataContexts.get().getMetaData().getDatabase(databaseName).getSchema(schemaName).removeTable(toBeDeletedTableName);
- metaDataContexts.get().getMetaData().getDatabase(databaseName)
- .getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class).forEach(each -> each.remove(schemaName, toBeDeletedTableName));
- }
-
- private void dropView(final String databaseName, final String schemaName, final String toBeDeletedViewName) {
- metaDataContexts.get().getMetaData().getDatabase(databaseName).getSchema(schemaName).removeView(toBeDeletedViewName);
- metaDataContexts.get().getMetaData().getDatabase(databaseName)
- .getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class).forEach(each -> each.remove(schemaName, toBeDeletedViewName));
- }
-
private void alterTable(final String databaseName, final String schemaName, final ShardingSphereTable beBoChangedTable) {
ShardingSphereDatabase database = metaDataContexts.get().getMetaData().getDatabase(databaseName);
if (TableRefreshUtils.isSingleTable(beBoChangedTable.getName(), database)) {
@@ -180,4 +165,16 @@ public final class SchemaMetaDataManager {
}
database.getSchema(schemaName).putView(beBoChangedView.getName(), beBoChangedView);
}
+
+ private void dropTable(final String databaseName, final String schemaName, final String toBeDeletedTableName) {
+ metaDataContexts.get().getMetaData().getDatabase(databaseName).getSchema(schemaName).removeTable(toBeDeletedTableName);
+ metaDataContexts.get().getMetaData().getDatabase(databaseName)
+ .getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class).forEach(each -> each.remove(schemaName, toBeDeletedTableName));
+ }
+
+ private void dropView(final String databaseName, final String schemaName, final String toBeDeletedViewName) {
+ metaDataContexts.get().getMetaData().getDatabase(databaseName).getSchema(schemaName).removeView(toBeDeletedViewName);
+ metaDataContexts.get().getMetaData().getDatabase(databaseName)
+ .getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class).forEach(each -> each.remove(schemaName, toBeDeletedViewName));
+ }
}
diff --git a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
index 530190f0851..cc137afb480 100644
--- a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
+++ b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
@@ -34,10 +34,7 @@ import org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaDa
import org.apache.shardingsphere.infra.metadata.database.resource.node.StorageNode;
import org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnit;
import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
-import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereColumn;
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.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.attribute.RuleAttributes;
import org.apache.shardingsphere.infra.rule.attribute.datanode.MutableDataNodeRuleAttribute;
@@ -46,8 +43,6 @@ import org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNode;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
import org.apache.shardingsphere.mode.spi.PersistRepository;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
-import org.apache.shardingsphere.test.util.PropertiesBuilder;
-import org.apache.shardingsphere.test.util.PropertiesBuilder.Property;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -57,7 +52,6 @@ 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;
import java.util.HashMap;
import java.util.Map;
@@ -66,16 +60,11 @@ import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
-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.mock;
-import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -94,7 +83,6 @@ class ContextManagerTest {
ShardingSphereDatabase database = mockDatabase();
when(metaDataContexts.getMetaData().containsDatabase("foo_db")).thenReturn(true);
when(metaDataContexts.getMetaData().getDatabase("foo_db")).thenReturn(database);
- when(metaDataContexts.getMetaData().getDatabase("foo_db").containsSchema("foo_schema")).thenReturn(true);
when(metaDataContexts.getMetaData().getDatabases().values()).thenReturn(Collections.singleton(database));
ComputeNodeInstanceContext computeNodeInstanceContext = mock(ComputeNodeInstanceContext.class);
when(computeNodeInstanceContext.getInstance()).thenReturn(new ComputeNodeInstance(new ProxyInstanceMetaData("foo_id", 3307), Collections.emptyList()));
@@ -106,11 +94,12 @@ class ContextManagerTest {
ShardingSphereDatabase result = mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS);
when(result.getName()).thenReturn("foo_db");
when(result.getProtocolType()).thenReturn(TypedSPILoader.getService(DatabaseType.class, "FIXTURE"));
- ShardingSphereRule rule = mock(ShardingSphereRule.class);
MutableDataNodeRuleAttribute ruleAttribute = mock(MutableDataNodeRuleAttribute.class);
when(ruleAttribute.findTableDataNode("foo_schema", "foo_tbl")).thenReturn(Optional.of(mock(DataNode.class)));
+ ShardingSphereRule rule = mock(ShardingSphereRule.class);
when(rule.getAttributes()).thenReturn(new RuleAttributes(ruleAttribute));
when(result.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(rule)));
+ when(result.containsSchema("foo_schema")).thenReturn(true);
when(result.getSchemas()).thenReturn(new HashMap<>(Collections.singletonMap("foo_schema", new ShardingSphereSchema(DefaultDatabase.LOGIC_NAME))));
StorageUnit storageUnit = mock(StorageUnit.class, RETURNS_DEEP_STUBS);
when(storageUnit.getStorageType()).thenReturn(TypedSPILoader.getService(DatabaseType.class, "FIXTURE"));
@@ -122,16 +111,6 @@ class ContextManagerTest {
return result;
}
- @Test
- void assertGetDataSourceMap() {
- ResourceMetaData resourceMetaData = new ResourceMetaData(Collections.singletonMap("foo_ds", new MockedDataSource()));
- ShardingSphereDatabase database =
- new ShardingSphereDatabase(DefaultDatabase.LOGIC_NAME, mock(DatabaseType.class), resourceMetaData, mock(RuleMetaData.class), Collections.emptyMap());
- when(metaDataContexts.getMetaData().getDatabase(DefaultDatabase.LOGIC_NAME)).thenReturn(database);
- when(metaDataContexts.getMetaData().containsDatabase(DefaultDatabase.LOGIC_NAME)).thenReturn(true);
- assertThat(contextManager.getStorageUnits(DefaultDatabase.LOGIC_NAME).size(), is(1));
- }
-
@Test
void assertRenewMetaDataContexts() {
MetaDataContexts contexts = mock(MetaDataContexts.class);
@@ -140,88 +119,8 @@ class ContextManagerTest {
}
@Test
- void assertAddDatabase() {
- contextManager.getMetaDataContextManager().getSchemaMetaDataManager().addDatabase("new_db");
- verify(metaDataContexts.getMetaData()).addDatabase(eq("new_db"), any(DatabaseType.class), any(ConfigurationProperties.class));
- }
-
- @Test
- void assertAddExistedDatabase() {
- when(metaDataContexts.getMetaData().containsDatabase("foo_db")).thenReturn(true);
- contextManager.getMetaDataContextManager().getSchemaMetaDataManager().addDatabase("foo_db");
- verify(metaDataContexts.getMetaData(), times(0)).addDatabase(eq("foo_db"), any(DatabaseType.class), any(ConfigurationProperties.class));
- }
-
- @Test
- void assertDropDatabase() {
- when(metaDataContexts.getMetaData().getDatabase("foo_db").getName()).thenReturn("foo_db");
- when(metaDataContexts.getMetaData().containsDatabase("foo_db")).thenReturn(true);
- contextManager.getMetaDataContextManager().getSchemaMetaDataManager().dropDatabase("foo_db");
- verify(metaDataContexts.getMetaData()).dropDatabase("foo_db");
- }
-
- @Test
- void assertDropNotExistedDatabase() {
- contextManager.getMetaDataContextManager().getSchemaMetaDataManager().dropDatabase("not_existed_db");
- verify(metaDataContexts.getMetaData(), times(0)).dropDatabase("not_existed_db");
- }
-
- @Test
- void assertAddSchema() {
- contextManager.getMetaDataContextManager().getSchemaMetaDataManager().addSchema("foo_db", "bar_schema");
- verify(metaDataContexts.getMetaData().getDatabase("foo_db")).addSchema(anyString(), any(ShardingSphereSchema.class));
- }
-
- @Test
- void assertAddExistedSchema() {
- when(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db").containsSchema("foo_schema")).thenReturn(true);
- contextManager.getMetaDataContextManager().getSchemaMetaDataManager().addSchema("foo_db", "foo_schema");
- verify(metaDataContexts.getMetaData().getDatabase("foo_db"), times(0)).addSchema(anyString(), any(ShardingSphereSchema.class));
- }
-
- @Test
- void assertAlterSchemaForTableAltered() {
- ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
- when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", toBeAlteredSchema));
- when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(toBeAlteredSchema);
- ShardingSphereColumn toBeChangedColumn = new ShardingSphereColumn("foo_col", Types.VARCHAR, false, false, false, true, false, false);
- ShardingSphereTable toBeChangedTable = new ShardingSphereTable("foo_tbl", Collections.singleton(toBeChangedColumn), Collections.emptyList(), Collections.emptyList());
- contextManager.getMetaDataContextManager().getSchemaMetaDataManager().alterSchema("foo_db", "foo_schema", toBeChangedTable, null);
- ShardingSphereTable table = contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db").getSchema("foo_schema").getTables().get("foo_tbl");
- assertThat(table.getColumnValues().size(), is(1));
- assertTrue(table.containsColumn("foo_col"));
- }
-
- @Test
- void assertAlterSchemaForViewAltered() {
- ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
- when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", toBeAlteredSchema));
- when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(toBeAlteredSchema);
- ShardingSphereView toBeChangedView = new ShardingSphereView("foo_view", "select `foo_view`.`foo_view`.`id` AS `id` from `foo_view`.`foo_view`");
- contextManager.getMetaDataContextManager().getSchemaMetaDataManager().alterSchema("foo_db", "foo_schema", null, toBeChangedView);
- ShardingSphereView view = contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db").getSchema("foo_schema").getView("foo_view");
- assertThat(view.getName(), is("foo_view"));
- assertThat(view.getViewDefinition(), is("select `foo_view`.`foo_view`.`id` AS `id` from `foo_view`.`foo_view`"));
- }
-
- @Test
- void assertAlterSchemaForTableDropped() {
- when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", createToBeAlteredSchema()));
- contextManager.getMetaDataContextManager().getSchemaMetaDataManager().alterSchema("foo_db", "foo_schema", "foo_tbl", null);
- assertFalse(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db").getSchema("foo_schema").getTables().containsKey("foo_tbl"));
- }
-
- @Test
- void assertAlterSchemaForViewDropped() {
- when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", createToBeAlteredSchema()));
- contextManager.getMetaDataContextManager().getSchemaMetaDataManager().alterSchema("foo_db", "foo_schema", "foo_view", null);
- assertFalse(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db").getSchema("foo_schema").getViews().containsKey("foo_view"));
- }
-
- private ShardingSphereSchema createToBeAlteredSchema() {
- ShardingSphereTable beforeChangedTable = new ShardingSphereTable("foo_tbl", Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
- ShardingSphereView beforeChangedView = new ShardingSphereView("foo_tbl", "");
- return new ShardingSphereSchema(DefaultDatabase.LOGIC_NAME, Collections.singletonMap("foo_tbl", beforeChangedTable), Collections.singletonMap("foo_view", beforeChangedView));
+ void assertGetDatabase() {
+ assertNotNull(contextManager.getDatabase("foo_db"));
}
@Test
@@ -229,25 +128,18 @@ class ContextManagerTest {
assertThrows(NoDatabaseSelectedException.class, () -> contextManager.getDatabase(null));
}
- @Test
- void assertGetDatabaseWithEmptyString() {
- assertThrows(NoDatabaseSelectedException.class, () -> contextManager.getDatabase(""));
- }
-
@Test
void assertGetDatabaseWhenNotExisted() {
assertThrows(UnknownDatabaseException.class, () -> contextManager.getDatabase("bar_db"));
}
@Test
- void assertGetDatabase() {
- assertNotNull(contextManager.getDatabase("foo_db"));
- }
-
- @Test
- void assertAlterProperties() {
- contextManager.getMetaDataContextManager().getGlobalConfigurationManager().alterProperties(PropertiesBuilder.build(new Property("foo", "foo_value")));
- assertThat(contextManager.getMetaDataContexts().getMetaData().getProps().getProps().getProperty("foo"), is("foo_value"));
+ void assertGetStorageUnits() {
+ ResourceMetaData resourceMetaData = new ResourceMetaData(Collections.singletonMap("foo_ds", new MockedDataSource()));
+ ShardingSphereDatabase database = new ShardingSphereDatabase(DefaultDatabase.LOGIC_NAME, mock(DatabaseType.class), resourceMetaData, mock(RuleMetaData.class), Collections.emptyMap());
+ when(metaDataContexts.getMetaData().getDatabase(DefaultDatabase.LOGIC_NAME)).thenReturn(database);
+ when(metaDataContexts.getMetaData().containsDatabase(DefaultDatabase.LOGIC_NAME)).thenReturn(true);
+ assertThat(contextManager.getStorageUnits(DefaultDatabase.LOGIC_NAME).size(), is(1));
}
@Test
diff --git a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/SchemaMetaDataManagerTest.java b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/SchemaMetaDataManagerTest.java
new file mode 100644
index 00000000000..cd3eb5c1e76
--- /dev/null
+++ b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/SchemaMetaDataManagerTest.java
@@ -0,0 +1,215 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.mode.metadata.manager;
+
+import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
+import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
+import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereColumn;
+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.spi.type.typed.TypedSPILoader;
+import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
+import org.apache.shardingsphere.mode.spi.PersistRepository;
+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;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+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.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+class SchemaMetaDataManagerTest {
+
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ private MetaDataContexts metaDataContexts;
+
+ private SchemaMetaDataManager schemaMetaDataManager;
+
+ @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().getDatabases().values()).thenReturn(Collections.singleton(database));
+ schemaMetaDataManager = new SchemaMetaDataManager(new AtomicReference<>(metaDataContexts), mock(PersistRepository.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);
+ return result;
+ }
+
+ @Test
+ void assertAddNotExistedDatabase() {
+ schemaMetaDataManager.addDatabase("new_db");
+ verify(metaDataContexts.getMetaData()).addDatabase(eq("new_db"), any(DatabaseType.class), any(ConfigurationProperties.class));
+ }
+
+ @Test
+ void assertAddExistedDatabase() {
+ when(metaDataContexts.getMetaData().containsDatabase("foo_db")).thenReturn(true);
+ schemaMetaDataManager.addDatabase("foo_db");
+ verify(metaDataContexts.getMetaData(), times(0)).addDatabase(eq("foo_db"), any(DatabaseType.class), any(ConfigurationProperties.class));
+ }
+
+ @Test
+ void assertDropExistedDatabase() {
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getName()).thenReturn("foo_db");
+ when(metaDataContexts.getMetaData().containsDatabase("foo_db")).thenReturn(true);
+ schemaMetaDataManager.dropDatabase("foo_db");
+ verify(metaDataContexts.getMetaData()).dropDatabase("foo_db");
+ }
+
+ @Test
+ void assertDropNotExistedDatabase() {
+ schemaMetaDataManager.dropDatabase("not_existed_db");
+ verify(metaDataContexts.getMetaData(), times(0)).dropDatabase("not_existed_db");
+ }
+
+ @Test
+ void assertAddNotExistedSchema() {
+ schemaMetaDataManager.addSchema("foo_db", "bar_schema");
+ verify(metaDataContexts.getMetaData().getDatabase("foo_db")).addSchema(anyString(), any(ShardingSphereSchema.class));
+ }
+
+ @Test
+ void assertAddExistedSchema() {
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").containsSchema("foo_schema")).thenReturn(true);
+ schemaMetaDataManager.addSchema("foo_db", "foo_schema");
+ verify(metaDataContexts.getMetaData().getDatabase("foo_db"), times(0)).addSchema(anyString(), any(ShardingSphereSchema.class));
+ }
+
+ @Test
+ void assertDropNotExistedSchema() {
+ schemaMetaDataManager.dropSchema("foo_db", "bar_schema");
+ verify(metaDataContexts.getMetaData().getDatabase("foo_db"), times(0)).dropSchema(anyString());
+ }
+
+ @Test
+ void assertDropExistedSchema() {
+ schemaMetaDataManager.dropSchema("foo_db", "foo_schema");
+ verify(metaDataContexts.getMetaData().getDatabase("foo_db")).dropSchema("foo_schema");
+ }
+
+ @Test
+ void assertAlterNotExistedSchema() {
+ ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", toBeAlteredSchema));
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(toBeAlteredSchema);
+ schemaMetaDataManager.alterSchema("foo_db", "bar_schema", null, (ShardingSphereView) null);
+ verify(metaDataContexts.getMetaData().getDatabase("foo_db"), times(0)).getSchema(any());
+ }
+
+ @Test
+ void assertAlterSchemaForNothingAltered() {
+ ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", toBeAlteredSchema));
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(toBeAlteredSchema);
+ schemaMetaDataManager.alterSchema("foo_db", "foo_schema", null, (ShardingSphereView) null);
+ verify(metaDataContexts.getMetaData().getDatabase("foo_db"), times(0)).getSchema(any());
+ }
+
+ @Test
+ void assertAlterSchemaForTableAltered() {
+ ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", toBeAlteredSchema));
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(toBeAlteredSchema);
+ ShardingSphereColumn toBeChangedColumn = new ShardingSphereColumn("foo_col", Types.VARCHAR, false, false, false, true, false, false);
+ ShardingSphereTable toBeChangedTable = new ShardingSphereTable("foo_tbl", Collections.singleton(toBeChangedColumn), Collections.emptyList(), Collections.emptyList());
+ schemaMetaDataManager.alterSchema("foo_db", "foo_schema", toBeChangedTable, null);
+ ShardingSphereTable table = metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema").getTables().get("foo_tbl");
+ assertThat(table.getColumnValues().size(), is(1));
+ assertTrue(table.containsColumn("foo_col"));
+ }
+
+ @Test
+ void assertAlterSchemaForViewAltered() {
+ ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", toBeAlteredSchema));
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(toBeAlteredSchema);
+ ShardingSphereView toBeChangedView = new ShardingSphereView("foo_view", "select `foo_view`.`foo_view`.`id` AS `id` from `foo_view`.`foo_view`");
+ schemaMetaDataManager.alterSchema("foo_db", "foo_schema", null, toBeChangedView);
+ ShardingSphereView view = metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema").getView("foo_view");
+ assertThat(view.getName(), is("foo_view"));
+ assertThat(view.getViewDefinition(), is("select `foo_view`.`foo_view`.`id` AS `id` from `foo_view`.`foo_view`"));
+ }
+
+ @Test
+ void assertAlterNotExistedSchemaForTableDropped() {
+ ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", toBeAlteredSchema));
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(toBeAlteredSchema);
+ schemaMetaDataManager.alterSchema("foo_db", "bar_schema", "", "");
+ verify(metaDataContexts.getMetaData().getDatabase("foo_db"), times(0)).getSchema(any());
+ }
+
+ @Test
+ void assertAlterSchemaForNothingTableDropped() {
+ ShardingSphereSchema toBeAlteredSchema = createToBeAlteredSchema();
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", toBeAlteredSchema));
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(toBeAlteredSchema);
+ schemaMetaDataManager.alterSchema("foo_db", "foo_schema", "", "");
+ verify(metaDataContexts.getMetaData().getGlobalRuleMetaData(), times(0)).getRules();
+ }
+
+ @Test
+ void assertAlterSchemaForTableDropped() {
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", createToBeAlteredSchema()));
+ schemaMetaDataManager.alterSchema("foo_db", "foo_schema", "foo_tbl", null);
+ assertFalse(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema").getTables().containsKey("foo_tbl"));
+ }
+
+ @Test
+ void assertAlterSchemaForViewDropped() {
+ when(metaDataContexts.getMetaData().getDatabase("foo_db").getSchemas()).thenReturn(Collections.singletonMap("foo_schema", createToBeAlteredSchema()));
+ schemaMetaDataManager.alterSchema("foo_db", "foo_schema", "foo_view", null);
+ assertFalse(metaDataContexts.getMetaData().getDatabase("foo_db").getSchema("foo_schema").getViews().containsKey("foo_view"));
+ }
+
+ private ShardingSphereSchema createToBeAlteredSchema() {
+ ShardingSphereTable beforeChangedTable = new ShardingSphereTable("foo_tbl", Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
+ ShardingSphereView beforeChangedView = new ShardingSphereView("foo_tbl", "");
+ return new ShardingSphereSchema(DefaultDatabase.LOGIC_NAME, Collections.singletonMap("foo_tbl", beforeChangedTable), Collections.singletonMap("foo_view", beforeChangedView));
+ }
+}