This is an automated email from the ASF dual-hosted git repository.
jianglongtao 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 8288ed33f59 Add more test cases on ContextManager.alterSchema (#19009)
8288ed33f59 is described below
commit 8288ed33f59f40f9c1ddd3398d91ac680a66f5bd
Author: Liang Zhang <[email protected]>
AuthorDate: Mon Jul 11 01:30:01 2022 +0800
Add more test cases on ContextManager.alterSchema (#19009)
---
.../mode/manager/ContextManager.java | 1 +
.../mode/manager/ContextManagerTest.java | 89 +++++++++++-----------
2 files changed, 45 insertions(+), 45 deletions(-)
diff --git
a/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
b/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
index 9a7151e37d1..d6ef1670a45 100644
---
a/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
+++
b/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
@@ -176,6 +176,7 @@ public final class ContextManager implements AutoCloseable {
if
(metaDataContexts.getMetaData().getDatabases().get(databaseName).getSchemas().containsKey(schemaName))
{
metaDataContexts.getMetaData().getDatabases().get(databaseName).getSchemas().get(schemaName).remove(toBeDeletedTableName);
metaDataContexts.getOptimizerContext().dropTable(databaseName,
schemaName, toBeDeletedTableName);
+ // TODO check whether need to reloadRules(single table rule) if
table dropped?
}
}
diff --git
a/shardingsphere-mode/shardingsphere-mode-core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
b/shardingsphere-mode/shardingsphere-mode-core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
index d276f7924b5..696ef40facf 100644
---
a/shardingsphere-mode/shardingsphere-mode-core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
+++
b/shardingsphere-mode/shardingsphere-mode-core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
@@ -23,13 +23,16 @@ import
org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
import org.apache.shardingsphere.infra.database.DefaultDatabase;
import org.apache.shardingsphere.infra.database.type.DatabaseType;
import org.apache.shardingsphere.infra.database.type.dialect.MySQLDatabaseType;
+import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.datasource.props.DataSourceProperties;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.metadata.database.resource.ShardingSphereResource;
import
org.apache.shardingsphere.infra.metadata.database.rule.ShardingSphereRuleMetaData;
+import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereColumn;
import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereSchema;
import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereTable;
+import
org.apache.shardingsphere.infra.rule.identifier.type.MutableDataNodeRule;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistService;
import
org.apache.shardingsphere.mode.metadata.persist.service.DatabaseMetaDataPersistService;
@@ -40,6 +43,7 @@ import org.junit.Test;
import javax.sql.DataSource;
import java.sql.SQLException;
+import java.sql.Types;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
@@ -49,6 +53,7 @@ import java.util.Optional;
import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
@@ -68,19 +73,29 @@ public final class ContextManagerTest {
@Before
public void setUp() throws SQLException {
metaDataContexts = mock(MetaDataContexts.class, RETURNS_DEEP_STUBS);
-
when(metaDataContexts.getMetaData().getProps().getValue(ConfigurationPropertyKey.KERNEL_EXECUTOR_SIZE)).thenReturn(1);
when(metaDataContexts.getMetaData().getGlobalRuleMetaData().getRules()).thenReturn(Collections.emptyList());
+
when(metaDataContexts.getMetaData().getProps().getValue(ConfigurationPropertyKey.KERNEL_EXECUTOR_SIZE)).thenReturn(1);
when(metaDataContexts.getMetaData().getProps()).thenReturn(new
ConfigurationProperties(new Properties()));
-
when(metaDataContexts.getMetaData().getDatabases().get("foo_db").getResource().getDatabaseType()).thenReturn(new
MySQLDatabaseType());
-
when(metaDataContexts.getMetaData().getDatabases().get("foo_db").getProtocolType()).thenReturn(new
MySQLDatabaseType());
-
when(metaDataContexts.getMetaData().getDatabases().get("foo_db").getSchemas()).thenReturn(new
HashMap<>(Collections.singletonMap("foo_schema", new ShardingSphereSchema())));
-
when(metaDataContexts.getMetaData().getDatabases().get("foo_db").getRuleMetaData()).thenReturn(new
ShardingSphereRuleMetaData(Collections.emptyList()));
+ ShardingSphereDatabase database = mockDatabase();
+
when(metaDataContexts.getMetaData().getDatabases().containsKey("foo_db")).thenReturn(true);
+
when(metaDataContexts.getMetaData().getDatabases().get("foo_db")).thenReturn(database);
when(metaDataContexts.getOptimizerContext().getFederationMetaData().getDatabases()).thenReturn(new
LinkedHashMap<>());
when(metaDataContexts.getOptimizerContext().getParserContexts()).thenReturn(new
LinkedHashMap<>());
when(metaDataContexts.getOptimizerContext().getPlannerContexts()).thenReturn(new
LinkedHashMap<>());
contextManager = new ContextManager(metaDataContexts,
mock(InstanceContext.class));
}
+ private ShardingSphereDatabase mockDatabase() {
+ ShardingSphereDatabase result = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
+ when(result.getProtocolType()).thenReturn(new MySQLDatabaseType());
+ when(result.getResource().getDatabaseType()).thenReturn(new
MySQLDatabaseType());
+ MutableDataNodeRule mutableDataNodeRule =
mock(MutableDataNodeRule.class, RETURNS_DEEP_STUBS);
+ when(mutableDataNodeRule.findSingleTableDataNode("foo_schema",
"foo_tbl")).thenReturn(Optional.of(mock(DataNode.class)));
+ when(result.getRuleMetaData()).thenReturn(new
ShardingSphereRuleMetaData(Collections.singleton(mutableDataNodeRule)));
+ when(result.getSchemas()).thenReturn(new
HashMap<>(Collections.singletonMap("foo_schema", new ShardingSphereSchema())));
+ return result;
+ }
+
@Test
public void assertGetDataSourceMap() {
ShardingSphereResource resource = new
ShardingSphereResource(Collections.singletonMap("foo_ds", new
MockedDataSource()));
@@ -98,9 +113,9 @@ public final class ContextManagerTest {
@Test
public void assertAddDatabase() throws SQLException {
- contextManager.addDatabase("foo_db");
- verify(metaDataContexts.getMetaData()).addDatabase(eq("foo_db"),
any(DatabaseType.class));
-
verify(metaDataContexts.getOptimizerContext()).addDatabase(eq("foo_db"),
any(DatabaseType.class));
+ contextManager.addDatabase("new_db");
+ verify(metaDataContexts.getMetaData()).addDatabase(eq("new_db"),
any(DatabaseType.class));
+
verify(metaDataContexts.getOptimizerContext()).addDatabase(eq("new_db"),
any(DatabaseType.class));
}
@Test
@@ -121,28 +136,9 @@ public final class ContextManagerTest {
@Test
public void assertDropNotExistedDatabase() {
- contextManager.dropDatabase("foo_db");
- verify(metaDataContexts.getMetaData(),
times(0)).dropDatabase("foo_db");
- verify(metaDataContexts.getOptimizerContext(),
times(0)).dropDatabase("foo_db");
- }
-
- @Test
- public void assertAlterSchema() {
-
when(metaDataContexts.getMetaData().getDatabases().containsKey("foo_db")).thenReturn(true);
- ShardingSphereTable fooTable = mock(ShardingSphereTable.class);
- when(fooTable.getName()).thenReturn("FOO_TABLE");
- contextManager.alterSchema("foo_db", "foo_schema", fooTable, null);
-
assertTrue(contextManager.getMetaDataContexts().getMetaData().getDatabases().containsKey("foo_db"));
- assertAlterTable();
- assertAlterDropTable();
- }
-
- public void assertAlterDropTable() {
- contextManager.alterSchema("foo_db", "foo_schema", null, "foo_table");
- }
-
- public void assertAlterTable() {
-
assertTrue(contextManager.getMetaDataContexts().getMetaData().getDatabases().get("foo_db").getSchemas().get("foo_schema").getTables().containsKey("foo_table"));
+ contextManager.dropDatabase("not_existed_db");
+ verify(metaDataContexts.getMetaData(),
times(0)).dropDatabase("not_existed_db");
+ verify(metaDataContexts.getOptimizerContext(),
times(0)).dropDatabase("not_existed_db");
}
@Test
@@ -158,23 +154,28 @@ public final class ContextManagerTest {
verify(metaDataContexts.getOptimizerContext(),
times(0)).addSchema("foo_db", "foo_schema");
}
- private Map<String, DataSourceProperties>
createToBeAddedDataSourceProperties() {
- Map<String, DataSourceProperties> result = new LinkedHashMap<>(2, 1);
- result.put("foo_ds_1", new
DataSourceProperties(MockedDataSource.class.getName(), createProperties("root",
"root")));
- result.put("foo_ds_2", new
DataSourceProperties(MockedDataSource.class.getName(), createProperties("root",
"root")));
- return result;
+ @Test
+ public void assertAlterSchemaForTableAltered() {
+
when(metaDataContexts.getMetaData().getDatabases().get("foo_db").getSchemas()).thenReturn(createToBeAlteredSchemas());
+ ShardingSphereColumn toBeChangedColumn = new
ShardingSphereColumn("foo_col", Types.VARCHAR, false, false, false);
+ ShardingSphereTable toBeChangedTable = new
ShardingSphereTable("foo_tbl", Collections.singleton(toBeChangedColumn),
Collections.emptyList(), Collections.emptyList());
+ contextManager.alterSchema("foo_db", "foo_schema", toBeChangedTable,
null);
+ ShardingSphereTable table =
contextManager.getMetaDataContexts().getMetaData().getDatabases().get("foo_db").getSchemas().get("foo_schema").getTables().get("foo_tbl");
+ assertThat(table.getColumns().size(), is(1));
+ assertTrue(table.getColumns().containsKey("foo_col"));
}
- private void assertAddedDataSources(final Map<String, DataSource> actual) {
- assertThat(actual.size(), is(2));
- assertAddedDataSource((MockedDataSource) actual.get("foo_ds_1"));
- assertAddedDataSource((MockedDataSource) actual.get("foo_ds_2"));
+ @Test
+ public void assertAlterSchemaForTableDropped() {
+
when(metaDataContexts.getMetaData().getDatabases().get("foo_db").getSchemas()).thenReturn(createToBeAlteredSchemas());
+ contextManager.alterSchema("foo_db", "foo_schema", null, "foo_tbl");
+
assertFalse(contextManager.getMetaDataContexts().getMetaData().getDatabases().get("foo_db").getSchemas().get("foo_schema").getTables().containsKey("foo_tbl"));
}
- private void assertAddedDataSource(final MockedDataSource actual) {
- assertThat(actual.getUrl(), is("jdbc:mock://127.0.0.1/foo_ds"));
- assertThat(actual.getUsername(), is("root"));
- assertThat(actual.getPassword(), is("root"));
+ private Map<String, ShardingSphereSchema> createToBeAlteredSchemas() {
+ ShardingSphereTable beforeChangedTable = new
ShardingSphereTable("foo_tbl", Collections.emptyList(),
Collections.emptyList(), Collections.emptyList());
+ ShardingSphereSchema schema = new
ShardingSphereSchema(Collections.singletonMap("foo_tbl", beforeChangedTable));
+ return Collections.singletonMap("foo_schema", schema);
}
@Test
@@ -281,9 +282,7 @@ public final class ContextManagerTest {
@Test
public void assertReloadTable() {
when(metaDataContexts.getMetaData().getDatabases().get("foo_db").getResource().getDataSources()).thenReturn(Collections.singletonMap("foo_ds",
new MockedDataSource()));
- DatabaseMetaDataPersistService databaseMetaDataPersistService =
mock(DatabaseMetaDataPersistService.class, RETURNS_DEEP_STUBS);
MetaDataPersistService metaDataPersistService =
mock(MetaDataPersistService.class);
-
when(metaDataPersistService.getDatabaseMetaDataService()).thenReturn(databaseMetaDataPersistService);
when(metaDataContexts.getPersistService()).thenReturn(Optional.of(metaDataPersistService));
contextManager.reloadTable("foo_db", "foo_schema", "foo_table");
assertTrue(contextManager.getMetaDataContexts().getMetaData().getDatabases().get("foo_db").getResource().getDataSources().containsKey("foo_ds"));
