You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by me...@apache.org on 2022/02/03 09:54:42 UTC

[shardingsphere] branch master updated: Refactor ContextManagerTest (#15239)

This is an automated email from the ASF dual-hosted git repository.

menghaoran 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 66fccea  Refactor ContextManagerTest (#15239)
66fccea is described below

commit 66fccea7ef51a7463ae07404be5aa4930e23db92
Author: Liang Zhang <te...@163.com>
AuthorDate: Thu Feb 3 17:53:15 2022 +0800

    Refactor ContextManagerTest (#15239)
---
 .../mode/manager/ContextManagerTest.java           | 184 +++++++--------------
 1 file changed, 60 insertions(+), 124 deletions(-)

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 309f2d9..625978a 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
@@ -18,10 +18,10 @@
 package org.apache.shardingsphere.mode.manager;
 
 import org.apache.shardingsphere.infra.config.RuleConfiguration;
-import org.apache.shardingsphere.infra.datasource.props.DataSourceProperties;
 import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
 import org.apache.shardingsphere.infra.database.DefaultSchema;
 import org.apache.shardingsphere.infra.database.type.DatabaseType;
+import org.apache.shardingsphere.infra.datasource.props.DataSourceProperties;
 import org.apache.shardingsphere.infra.federation.optimizer.context.OptimizerContext;
 import org.apache.shardingsphere.infra.federation.optimizer.context.parser.OptimizerParserContext;
 import org.apache.shardingsphere.infra.federation.optimizer.context.planner.OptimizerPlannerContext;
@@ -49,11 +49,9 @@ import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 
 import javax.sql.DataSource;
-import java.sql.Connection;
-import java.sql.DatabaseMetaData;
 import java.sql.SQLException;
-import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.LinkedList;
@@ -61,7 +59,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Properties;
-import java.util.concurrent.ConcurrentHashMap;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertFalse;
@@ -120,57 +117,40 @@ public final class ContextManagerTest {
     
     @Test
     public void assertGetDataSourceMap() {
-        DataSourcesMetaData dataSourceMetadata = mock(DataSourcesMetaData.class);
-        CachedDatabaseMetaData cachedMetadata = mock(CachedDatabaseMetaData.class);
-        DatabaseType databaseType = mock(DatabaseType.class);
-        ShardingSphereRuleMetaData sphereRuleMetadata = mock(ShardingSphereRuleMetaData.class);
-        ShardingSphereResource resource = new ShardingSphereResource(dataSourceMap, dataSourceMetadata, cachedMetadata, databaseType);
-        ShardingSphereMetaData metadata = new ShardingSphereMetaData("logic_schema", resource, sphereRuleMetadata, new ShardingSphereSchema());
-        when(metaDataContexts.getMetaData(anyString())).thenReturn(metadata);
-        Map<String, DataSource> dataSourceMap = contextManager.getDataSourceMap(DefaultSchema.LOGIC_NAME);
-        assertThat(dataSourceMap.size(), is(2));
+        ShardingSphereResource resource = new ShardingSphereResource(dataSourceMap, mock(DataSourcesMetaData.class), mock(CachedDatabaseMetaData.class), mock(DatabaseType.class));
+        when(metaDataContexts.getMetaData(anyString())).thenReturn(new ShardingSphereMetaData("logic_schema", resource, mock(ShardingSphereRuleMetaData.class), new ShardingSphereSchema()));
+        assertThat(contextManager.getDataSourceMap(DefaultSchema.LOGIC_NAME).size(), is(2));
     }
     
     @Test
     public void assertAddSchema() throws SQLException {
-        Map<String, ShardingSphereMetaData> metaDataMap = new LinkedHashMap<>();
-        when(metaDataContexts.getMetaDataMap()).thenReturn(metaDataMap);
-        OptimizerContext optimizerContext = mock(OptimizerContext.class, RETURNS_DEEP_STUBS);
-        Map<String, FederationSchemaMetaData> federationSchemaMetaDataMap = new LinkedHashMap<>();
-        when(optimizerContext.getFederationMetaData().getSchemas()).thenReturn(federationSchemaMetaDataMap);
-        ConfigurationProperties configurationProperties = mock(ConfigurationProperties.class);
-        when(metaDataContexts.getProps()).thenReturn(configurationProperties);
-        when(metaDataContexts.getOptimizerContext()).thenReturn(optimizerContext);
-        ShardingSphereRuleMetaData shardingSphereRuleMetaData = mock(ShardingSphereRuleMetaData.class, RETURNS_DEEP_STUBS);
-        when(metaDataContexts.getGlobalRuleMetaData()).thenReturn(shardingSphereRuleMetaData);
+        when(metaDataContexts.getMetaDataMap()).thenReturn(new LinkedHashMap<>());
+        when(metaDataContexts.getGlobalRuleMetaData()).thenReturn(mock(ShardingSphereRuleMetaData.class, RETURNS_DEEP_STUBS));
+        when(metaDataContexts.getOptimizerContext().getFederationMetaData().getSchemas()).thenReturn(new LinkedHashMap<>());
+        when(metaDataContexts.getProps()).thenReturn(mock(ConfigurationProperties.class));
         contextManager.addSchema("test_add_schema");
-        assertTrue(federationSchemaMetaDataMap.containsKey("test_add_schema"));
-        assertTrue(metaDataMap.containsKey("test_add_schema"));
+        assertTrue(metaDataContexts.getMetaDataMap().containsKey("test_add_schema"));
+        assertTrue(metaDataContexts.getOptimizerContext().getFederationMetaData().getSchemas().containsKey("test_add_schema"));
     }
     
     @Test
     public void assertDeleteSchema() {
         Map<String, ShardingSphereMetaData> metaDataMap = new LinkedHashMap<>();
+        metaDataMap.put("test_delete_schema", mock(ShardingSphereMetaData.class));
         when(metaDataContexts.getMetaDataMap()).thenReturn(metaDataMap);
-        ShardingSphereMetaData shardingSphereMetaData = mock(ShardingSphereMetaData.class);
-        metaDataMap.put("test_delete_schema", shardingSphereMetaData);
         FederationSchemaMetaData federationSchemaMetaData = mock(FederationSchemaMetaData.class);
         Map<String, FederationSchemaMetaData> federationSchemaMetaDataMap = new LinkedHashMap<>();
         federationSchemaMetaDataMap.put("test_delete_schema", federationSchemaMetaData);
+        when(metaDataContexts.getOptimizerContext().getFederationMetaData().getSchemas()).thenReturn(federationSchemaMetaDataMap);
         Map<String, OptimizerParserContext> parserContexts = new LinkedHashMap<>();
-        OptimizerParserContext optimizerParserContext = mock(OptimizerParserContext.class);
-        parserContexts.put("test_delete_schema", optimizerParserContext);
+        parserContexts.put("test_delete_schema", mock(OptimizerParserContext.class));
+        when(metaDataContexts.getOptimizerContext().getParserContexts()).thenReturn(parserContexts);
         Map<String, OptimizerPlannerContext> plannerContexts = new LinkedHashMap<>();
-        OptimizerPlannerContext optimizerPlannerContext = mock(OptimizerPlannerContext.class);
-        plannerContexts.put("test_delete_schema", optimizerPlannerContext);
-        OptimizerContext optimizerContext = mock(OptimizerContext.class, RETURNS_DEEP_STUBS);
-        when(optimizerContext.getFederationMetaData().getSchemas()).thenReturn(federationSchemaMetaDataMap);
-        when(optimizerContext.getPlannerContexts()).thenReturn(plannerContexts);
-        when(optimizerContext.getParserContexts()).thenReturn(parserContexts);
-        when(metaDataContexts.getOptimizerContext()).thenReturn(optimizerContext);
+        plannerContexts.put("test_delete_schema", mock(OptimizerPlannerContext.class));
+        when(metaDataContexts.getOptimizerContext().getPlannerContexts()).thenReturn(plannerContexts);
         contextManager.deleteSchema("test_delete_schema");
-        assertFalse(metaDataMap.containsKey("test_delete_schema"));
-        assertFalse(federationSchemaMetaDataMap.containsKey("test_delete_schema"));
+        assertFalse(metaDataContexts.getMetaDataMap().containsKey("test_delete_schema"));
+        assertFalse(metaDataContexts.getOptimizerContext().getFederationMetaData().getSchemas().containsKey("test_delete_schema"));
         assertFalse(parserContexts.containsKey("test_delete_schema"));
         assertFalse(plannerContexts.containsKey("test_delete_schema"));
     }
@@ -178,40 +158,24 @@ public final class ContextManagerTest {
     @Test
     public void assertAlterSchema() {
         Map<String, ShardingSphereMetaData> metaDataMap = new LinkedHashMap<>();
-        when(metaDataContexts.getMetaDataMap()).thenReturn(metaDataMap);
         ShardingSphereMetaData shardingSphereMetaData = mock(ShardingSphereMetaData.class, RETURNS_DEEP_STUBS);
         metaDataMap.put("test_schema", shardingSphereMetaData);
+        when(metaDataContexts.getMetaDataMap()).thenReturn(metaDataMap);
         when(metaDataContexts.getMetaData("test_schema")).thenReturn(shardingSphereMetaData);
-        OptimizerContext optimizerContext = mock(OptimizerContext.class, RETURNS_DEEP_STUBS);
-        FederationMetaData federationMetaData = mock(FederationMetaData.class);
-        when(optimizerContext.getFederationMetaData()).thenReturn(federationMetaData);
-        Map<String, FederationSchemaMetaData> federationSchemaMetaDataMap = new LinkedHashMap<>();
-        when(federationMetaData.getSchemas()).thenReturn(federationSchemaMetaDataMap);
-        when(metaDataContexts.getOptimizerContext()).thenReturn(optimizerContext);
-        Map<String, TableMetaData> tables = new ConcurrentHashMap<>();
-        ShardingSphereSchema shardingSphereSchema = mock(ShardingSphereSchema.class, RETURNS_DEEP_STUBS);
-        when(shardingSphereSchema.getTables()).thenReturn(tables);
-        TableMetaData testTableMetaData = mock(TableMetaData.class, RETURNS_DEEP_STUBS);
-        when(testTableMetaData.getName()).thenReturn("test_table_1");
-        tables.put("test_table_1", testTableMetaData);
-        contextManager.alterSchema("test_schema", shardingSphereSchema);
+        when(metaDataContexts.getOptimizerContext().getFederationMetaData().getSchemas()).thenReturn(new LinkedHashMap<>());
+        Map<String, TableMetaData> tables = new HashMap<>();
+        tables.put("test_table_1", new TableMetaData("test_table_1", Collections.emptyList(), Collections.emptyList()));
+        contextManager.alterSchema("test_schema", new ShardingSphereSchema(tables));
         assertTrue(metaDataContexts.getOptimizerContext().getFederationMetaData().getSchemas().get("test_schema").getTables().containsKey("test_table_1"));
     }
     
     @Test
     public void assertAddResource() throws SQLException {
-        mockMetaDataContextsForAddResource();
-        contextManager.addResource("test_schema", createToBeAddedDataSourceProperties());
-        assertAddedDataSources(contextManager.getMetaDataContexts().getMetaDataMap().get("test_schema").getResource().getDataSources());
-    }
-    
-    private void mockMetaDataContextsForAddResource() {
         ShardingSphereMetaData originalMetaData = mockOriginalMetaData();
         when(metaDataContexts.getMetaData("test_schema")).thenReturn(originalMetaData);
         Map<String, ShardingSphereMetaData> metaDataMap = new LinkedHashMap<>();
         metaDataMap.put("test_schema", originalMetaData);
         when(metaDataContexts.getMetaDataMap()).thenReturn(metaDataMap);
-        when(metaDataContexts.getProps()).thenReturn(new ConfigurationProperties(new Properties()));
         ShardingSphereRuleMetaData globalRuleMetaData = mock(ShardingSphereRuleMetaData.class);
         when(globalRuleMetaData.getConfigurations()).thenReturn(new LinkedList<>());
         when(metaDataContexts.getGlobalRuleMetaData()).thenReturn(globalRuleMetaData);
@@ -219,16 +183,27 @@ public final class ContextManagerTest {
         when(metaDataContexts.getOptimizerContext().getFederationMetaData()).thenReturn(mock(FederationMetaData.class));
         when(metaDataContexts.getOptimizerContext().getFederationMetaData().getSchemas()).thenReturn(new LinkedHashMap<>());
         when(metaDataContexts.getOptimizerContext().getParserContexts()).thenReturn(new LinkedHashMap<>());
+        when(metaDataContexts.getProps()).thenReturn(new ConfigurationProperties(new Properties()));
+        contextManager.addResource("test_schema", createToBeAddedDataSourceProperties());
+        assertAddedDataSources(contextManager.getMetaDataContexts().getMetaDataMap().get("test_schema").getResource().getDataSources());
     }
     
     private ShardingSphereMetaData mockOriginalMetaData() {
         ShardingSphereMetaData result = mock(ShardingSphereMetaData.class, RETURNS_DEEP_STUBS);
         when(result.getName()).thenReturn("test_schema");
-        when(result.getRuleMetaData().getConfigurations()).thenReturn(new LinkedList<>());
         when(result.getResource().getDataSources()).thenReturn(new LinkedHashMap<>());
+        when(result.getRuleMetaData().getConfigurations()).thenReturn(new LinkedList<>());
         return result;
     }
     
+    private void assertAddedDataSources(final Map<String, DataSource> actual) {
+        assertThat(contextManager.getMetaDataContexts().getMetaDataMap().get("test_schema").getResource().getDataSources().size(), is(2));
+        assertTrue(actual.containsKey("foo_ds_1"));
+        assertDataSource((MockedDataSource) actual.get("foo_ds_1"));
+        assertTrue(actual.containsKey("foo_ds_2"));
+        assertDataSource((MockedDataSource) actual.get("foo_ds_2"));
+    }
+    
     private Map<String, DataSourceProperties> createToBeAddedDataSourceProperties() {
         Properties dataSourceProps = new Properties();
         dataSourceProps.put("jdbcUrl", "jdbc:mock://127.0.0.1/foo_ds");
@@ -238,14 +213,6 @@ public final class ContextManagerTest {
         return result;
     }
     
-    private void assertAddedDataSources(final Map<String, DataSource> actual) {
-        assertThat(contextManager.getMetaDataContexts().getMetaDataMap().get("test_schema").getResource().getDataSources().size(), is(2));
-        assertTrue(actual.containsKey("foo_ds_1"));
-        assertDataSource((MockedDataSource) actual.get("foo_ds_1"));
-        assertTrue(actual.containsKey("foo_ds_2"));
-        assertDataSource((MockedDataSource) actual.get("foo_ds_2"));
-    }
-    
     @Test
     public void assertAlterResource() throws SQLException {
         Map<String, DataSource> dataSources = new LinkedHashMap<>();
@@ -253,17 +220,12 @@ public final class ContextManagerTest {
         ShardingSphereResource originalResource = mock(ShardingSphereResource.class);
         when(originalResource.getDataSources()).thenReturn(dataSources);
         ShardingSphereRuleMetaData originalShardingSphereRuleMetaData = mock(ShardingSphereRuleMetaData.class);
-        List<RuleConfiguration> ruleConfigurations = new LinkedList<>();
-        when(originalShardingSphereRuleMetaData.getConfigurations()).thenReturn(ruleConfigurations);
-        ShardingSphereMetaData originalMetaData = mock(ShardingSphereMetaData.class, RETURNS_DEEP_STUBS);
-        when(originalMetaData.getName()).thenReturn("test_schema");
-        when(originalMetaData.getRuleMetaData()).thenReturn(originalShardingSphereRuleMetaData);
-        when(originalMetaData.getResource()).thenReturn(originalResource);
+        when(originalShardingSphereRuleMetaData.getConfigurations()).thenReturn(new LinkedList<>());
+        ShardingSphereMetaData originalMetaData = new ShardingSphereMetaData("test_schema", originalResource, originalShardingSphereRuleMetaData, mock(ShardingSphereSchema.class));
         Map<String, ShardingSphereMetaData> metaDataMap = new LinkedHashMap<>();
         metaDataMap.put("test_schema", originalMetaData);
         when(metaDataContexts.getMetaDataMap()).thenReturn(metaDataMap);
         when(metaDataContexts.getMetaData("test_schema")).thenReturn(originalMetaData);
-        when(metaDataContexts.getProps()).thenReturn(new ConfigurationProperties(new Properties()));
         ShardingSphereRuleMetaData globalShardingSphereRuleMetaData = mock(ShardingSphereRuleMetaData.class);
         when(globalShardingSphereRuleMetaData.getConfigurations()).thenReturn(new LinkedList<>());
         when(metaDataContexts.getGlobalRuleMetaData()).thenReturn(globalShardingSphereRuleMetaData);
@@ -271,6 +233,7 @@ public final class ContextManagerTest {
         when(metaDataContexts.getOptimizerContext().getFederationMetaData()).thenReturn(mock(FederationMetaData.class));
         when(metaDataContexts.getOptimizerContext().getFederationMetaData().getSchemas()).thenReturn(new LinkedHashMap<>());
         when(metaDataContexts.getOptimizerContext().getParserContexts()).thenReturn(new LinkedHashMap<>());
+        when(metaDataContexts.getProps()).thenReturn(new ConfigurationProperties(new Properties()));
         contextManager.alterResource("test_schema", createToBeAlteredDataSourceProperties());
         assertAlteredDataSource((MockedDataSource) contextManager.getMetaDataContexts().getMetaDataMap().get("test_schema").getResource().getDataSources().get("foo_ds"));
     }
@@ -302,38 +265,26 @@ public final class ContextManagerTest {
         Map<String, DataSource> originalDataSources = new LinkedHashMap<>();
         originalDataSources.put("ds_1", new MockedDataSource());
         when(originalResource.getDataSources()).thenReturn(originalDataSources);
-        List<String> dsNamesToBeDropped = new LinkedList<>();
-        dsNamesToBeDropped.add("ds_1");
-        contextManager.dropResource("test_schema", dsNamesToBeDropped);
-        assertThat(contextManager.getMetaDataContexts().getMetaData("test_schema").getResource().getDataSources().size(), is(0));
+        contextManager.dropResource("test_schema", Collections.singleton("ds_1"));
+        assertTrue(contextManager.getMetaDataContexts().getMetaData("test_schema").getResource().getDataSources().isEmpty());
     }
     
     @Test
     public void assertAlterRuleConfiguration() {
         Map<String, ShardingSphereMetaData> metaDataMap = new LinkedHashMap<>();
-        ShardingSphereMetaData shardingSphereMetaData = mock(ShardingSphereMetaData.class, RETURNS_DEEP_STUBS);
-        when(shardingSphereMetaData.getName()).thenReturn("test");
+        ShardingSphereMetaData shardingSphereMetaData = new ShardingSphereMetaData(
+                "test", mock(ShardingSphereResource.class), mock(ShardingSphereRuleMetaData.class), mock(ShardingSphereSchema.class));
         metaDataMap.put("test", shardingSphereMetaData);
         when(metaDataContexts.getMetaDataMap()).thenReturn(metaDataMap);
-        MetaDataPersistService metaDataPersistService = mock(MetaDataPersistService.class, RETURNS_DEEP_STUBS);
-        when(metaDataContexts.getMetaDataPersistService()).thenReturn(Optional.of(metaDataPersistService));
-        ShardingSphereRuleMetaData shardingSphereRuleMetaData = mock(ShardingSphereRuleMetaData.class, RETURNS_DEEP_STUBS);
-        when(metaDataContexts.getGlobalRuleMetaData()).thenReturn(shardingSphereRuleMetaData);
-        OptimizerContext optimizerContext = mock(OptimizerContext.class, RETURNS_DEEP_STUBS);
-        FederationMetaData federationMetaData = mock(FederationMetaData.class);
-        Map<String, FederationSchemaMetaData> federationSchemaMetaDataMap = new LinkedHashMap<>();
-        when(federationMetaData.getSchemas()).thenReturn(federationSchemaMetaDataMap);
-        when(optimizerContext.getFederationMetaData()).thenReturn(federationMetaData);
-        when(metaDataContexts.getOptimizerContext()).thenReturn(optimizerContext);
-        ConfigurationProperties configurationProperties = mock(ConfigurationProperties.class, RETURNS_DEEP_STUBS);
-        Properties properties = new Properties();
-        when(configurationProperties.getProps()).thenReturn(properties);
-        when(metaDataContexts.getProps()).thenReturn(configurationProperties);
-        Collection<RuleConfiguration> ruleConfigs = new ArrayList<>();
-        RuleConfiguration ruleConfiguration = mock(RuleConfiguration.class);
-        ruleConfigs.add(ruleConfiguration);
+        when(metaDataContexts.getMetaDataPersistService()).thenReturn(Optional.of(mock(MetaDataPersistService.class, RETURNS_DEEP_STUBS)));
+        when(metaDataContexts.getGlobalRuleMetaData()).thenReturn(mock(ShardingSphereRuleMetaData.class, RETURNS_DEEP_STUBS));
+        when(metaDataContexts.getOptimizerContext().getFederationMetaData().getSchemas()).thenReturn(new LinkedHashMap<>());
+        when(metaDataContexts.getProps()).thenReturn(new ConfigurationProperties(new Properties()));
+        Collection<RuleConfiguration> ruleConfigs = new LinkedList<>();
+        RuleConfiguration ruleConfig = mock(RuleConfiguration.class);
+        ruleConfigs.add(ruleConfig);
         contextManager.alterRuleConfiguration("test", ruleConfigs);
-        assertTrue(contextManager.getMetaDataContexts().getMetaDataMap().get("test").getRuleMetaData().getConfigurations().contains(ruleConfiguration));
+        assertTrue(contextManager.getMetaDataContexts().getMetaDataMap().get("test").getRuleMetaData().getConfigurations().contains(ruleConfig));
     }
     
     @Test
@@ -388,10 +339,10 @@ public final class ContextManagerTest {
     @Test
     public void assertAlterGlobalRuleConfiguration() {
         List<RuleConfiguration> newRuleConfigs = new LinkedList<>();
-        RuleConfiguration ruleConfiguration = mock(RuleConfiguration.class);
-        newRuleConfigs.add(ruleConfiguration);
+        RuleConfiguration ruleConfig = mock(RuleConfiguration.class);
+        newRuleConfigs.add(ruleConfig);
         contextManager.alterGlobalRuleConfiguration(newRuleConfigs);
-        assertTrue(contextManager.getMetaDataContexts().getGlobalRuleMetaData().getConfigurations().contains(ruleConfiguration));
+        assertTrue(contextManager.getMetaDataContexts().getGlobalRuleMetaData().getConfigurations().contains(ruleConfig));
     }
     
     @Test
@@ -403,31 +354,16 @@ public final class ContextManagerTest {
     }
     
     @Test
-    public void assertReloadMetaData() throws SQLException {
-        MockedDataSource testDataSource = mock(MockedDataSource.class, RETURNS_DEEP_STUBS);
-        when(testDataSource.getConnection()).thenReturn(mock(Connection.class));
-        when(testDataSource.getConnection().getMetaData()).thenReturn(mock(DatabaseMetaData.class));
-        when(testDataSource.getConnection().getMetaData().getURL()).thenReturn("jdbc:mock://127.0.0.1/foo_ds");
-        Map<String, DataSource> dataSources = new LinkedHashMap<>();
-        dataSources.put("foo_ds", testDataSource);
+    public void assertReloadMetaData() {
         ShardingSphereResource originalResource = mock(ShardingSphereResource.class);
-        when(originalResource.getDataSources()).thenReturn(dataSources);
-        ShardingSphereRuleMetaData originalRuleMetaData = mock(ShardingSphereRuleMetaData.class);
-        ShardingSphereMetaData originalMetaData = mock(ShardingSphereMetaData.class);
-        when(originalMetaData.getResource()).thenReturn(originalResource);
-        when(originalMetaData.getRuleMetaData()).thenReturn(originalRuleMetaData);
-        when(metaDataContexts.getMetaData("test_schema")).thenReturn(originalMetaData);
-        ConfigurationProperties configurationProperties = new ConfigurationProperties(new Properties());
-        when(metaDataContexts.getProps()).thenReturn(configurationProperties);
-        FederationMetaData federationMetaData = mock(FederationMetaData.class);
-        when(federationMetaData.getSchemas()).thenReturn(new LinkedHashMap<>());
-        OptimizerContext optimizerContext = mock(OptimizerContext.class);
-        when(optimizerContext.getFederationMetaData()).thenReturn(federationMetaData);
-        when(metaDataContexts.getOptimizerContext()).thenReturn(optimizerContext);
+        when(originalResource.getDataSources()).thenReturn(Collections.singletonMap("foo_ds", new MockedDataSource()));
+        when(metaDataContexts.getMetaData("test_schema").getResource()).thenReturn(originalResource);
+        when(metaDataContexts.getOptimizerContext().getFederationMetaData().getSchemas()).thenReturn(new LinkedHashMap<>());
         SchemaMetaDataPersistService schemaMetaDataPersistService = mock(SchemaMetaDataPersistService.class, RETURNS_DEEP_STUBS);
         MetaDataPersistService metaDataPersistService = mock(MetaDataPersistService.class);
         when(metaDataPersistService.getSchemaMetaDataService()).thenReturn(schemaMetaDataPersistService);
-        when(metaDataContexts.getMetaDataPersistService()).thenReturn(Optional.of(metaDataPersistService));  
+        when(metaDataContexts.getMetaDataPersistService()).thenReturn(Optional.of(metaDataPersistService));
+        when(metaDataContexts.getProps()).thenReturn(new ConfigurationProperties(new Properties()));
         contextManager.reloadMetaData("test_schema");
         verify(schemaMetaDataPersistService, times(1)).persist(eq("test_schema"), any(ShardingSphereSchema.class));
         contextManager.reloadMetaData("test_schema", "test_table");