This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang 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 6a6532a81c9 Add more test cases on MetaDataPersistService (#32958)
6a6532a81c9 is described below
commit 6a6532a81c958d713fcd0a386b8f4a95dd1522b9
Author: Liang Zhang <[email protected]>
AuthorDate: Mon Sep 23 12:56:45 2024 +0800
Add more test cases on MetaDataPersistService (#32958)
* Add more test cases on MetaDataPersistService
* Add more test cases on MetaDataPersistService
---
.../metadata/persist/MetaDataPersistService.java | 12 +--
.../persist/MetaDataPersistServiceTest.java | 109 +++++++++++++++++++--
2 files changed, 109 insertions(+), 12 deletions(-)
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistService.java
index a64e74e6a47..5ea718403a9 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistService.java
@@ -100,13 +100,13 @@ public final class MetaDataPersistService {
* Persist configurations.
*
* @param databaseName database name
- * @param databaseConfigs database configuration
+ * @param databaseConfig database configuration
* @param dataSources data sources
* @param rules rules
*/
- public void persistConfigurations(final String databaseName, final
DatabaseConfiguration databaseConfigs, final Map<String, DataSource>
dataSources, final Collection<ShardingSphereRule> rules) {
- Map<String, DataSourcePoolProperties> propsMap =
getDataSourcePoolPropertiesMap(databaseConfigs);
- if (propsMap.isEmpty() &&
databaseConfigs.getRuleConfigurations().isEmpty()) {
+ public void persistConfigurations(final String databaseName, final
DatabaseConfiguration databaseConfig, final Map<String, DataSource>
dataSources, final Collection<ShardingSphereRule> rules) {
+ Map<String, DataSourcePoolProperties> propsMap =
getDataSourcePoolPropertiesMap(databaseConfig);
+ if (propsMap.isEmpty() &&
databaseConfig.getRuleConfigurations().isEmpty()) {
databaseMetaDataService.addDatabase(databaseName);
} else {
dataSourceUnitService.persist(databaseName, propsMap);
@@ -125,8 +125,8 @@ public final class MetaDataPersistService {
return result;
}
- private Map<String, DataSourcePoolProperties>
getDataSourcePoolPropertiesMap(final DatabaseConfiguration databaseConfigs) {
- return databaseConfigs.getStorageUnits().entrySet().stream()
+ private Map<String, DataSourcePoolProperties>
getDataSourcePoolPropertiesMap(final DatabaseConfiguration databaseConfig) {
+ return databaseConfig.getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSourcePoolProperties(), (oldValue, currentValue) ->
oldValue, LinkedHashMap::new));
}
diff --git
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistServiceTest.java
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistServiceTest.java
index e280d603d5c..58cc15b399f 100644
---
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistServiceTest.java
+++
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistServiceTest.java
@@ -17,26 +17,56 @@
package org.apache.shardingsphere.metadata.persist;
+import org.apache.shardingsphere.infra.config.database.DatabaseConfiguration;
+import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import
org.apache.shardingsphere.infra.config.rule.decorator.RuleConfigurationDecorator;
+import
org.apache.shardingsphere.infra.datasource.pool.config.DataSourceConfiguration;
+import
org.apache.shardingsphere.infra.datasource.pool.props.creator.DataSourcePoolPropertiesCreator;
+import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnit;
+import
org.apache.shardingsphere.infra.metadata.database.schema.manager.GenericSchemaManager;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
+import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
+import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import
org.apache.shardingsphere.metadata.persist.service.config.database.DataSourceUnitPersistService;
import
org.apache.shardingsphere.metadata.persist.service.config.database.DatabaseRulePersistService;
import
org.apache.shardingsphere.metadata.persist.service.config.global.GlobalRulePersistService;
import
org.apache.shardingsphere.metadata.persist.service.config.global.PropertiesPersistService;
+import
org.apache.shardingsphere.metadata.persist.service.database.DatabaseMetaDataPersistService;
import org.apache.shardingsphere.mode.spi.PersistRepository;
+import org.apache.shardingsphere.test.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.junit.jupiter.MockitoExtension;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Properties;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+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.verify;
+import static org.mockito.Mockito.when;
-@ExtendWith(MockitoExtension.class)
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings({TypedSPILoader.class,
DataSourcePoolPropertiesCreator.class, GenericSchemaManager.class})
class MetaDataPersistServiceTest {
@Mock
- private DataSourceUnitPersistService dataSourceService;
+ private DataSourceUnitPersistService dataSourceUnitService;
+
+ @Mock
+ private DatabaseMetaDataPersistService databaseMetaDataService;
@Mock
private DatabaseRulePersistService databaseRulePersistService;
@@ -52,7 +82,8 @@ class MetaDataPersistServiceTest {
@BeforeEach
void setUp() throws ReflectiveOperationException {
metaDataPersistService = new
MetaDataPersistService(mock(PersistRepository.class));
- setField("dataSourceUnitService", dataSourceService);
+ setField("dataSourceUnitService", dataSourceUnitService);
+ setField("databaseMetaDataService", databaseMetaDataService);
setField("databaseRulePersistService", databaseRulePersistService);
setField("globalRuleService", globalRuleService);
setField("propsService", propsService);
@@ -62,8 +93,74 @@ class MetaDataPersistServiceTest {
Plugins.getMemberAccessor().set(MetaDataPersistService.class.getDeclaredField(name),
metaDataPersistService, value);
}
+ @Test
+ void assertPersistGlobalRuleConfiguration() {
+ Collection<RuleConfiguration> globalRuleConfigs =
Collections.singleton(mock(RuleConfiguration.class));
+ Properties props = new Properties();
+
metaDataPersistService.persistGlobalRuleConfiguration(globalRuleConfigs, props);
+ verify(globalRuleService).persist(globalRuleConfigs);
+ verify(propsService).persist(props);
+ }
+
+ @Test
+ void assertPersistConfigurationsWithEmptyDatabase() {
+ metaDataPersistService.persistConfigurations("foo_db",
mock(DatabaseConfiguration.class), Collections.emptyMap(),
Collections.emptyList());
+ verify(databaseMetaDataService).addDatabase("foo_db");
+ }
+
+ @Test
+ void assertPersistConfigurationsWithDatabaseRuleConfigurations() {
+ DatabaseConfiguration databaseConfig =
mock(DatabaseConfiguration.class, RETURNS_DEEP_STUBS);
+
when(databaseConfig.getStorageUnits()).thenReturn(Collections.emptyMap());
+
when(databaseConfig.getRuleConfigurations().isEmpty()).thenReturn(false);
+ ShardingSphereRule rule = mock(ShardingSphereRule.class);
+ RuleConfiguration ruleConfig = mock(RuleConfiguration.class);
+ when(rule.getConfiguration()).thenReturn(ruleConfig);
+ when(TypedSPILoader.findService(RuleConfigurationDecorator.class,
ruleConfig.getClass())).thenReturn(Optional.of(mock(RuleConfigurationDecorator.class)));
+ metaDataPersistService.persistConfigurations("foo_db", databaseConfig,
Collections.emptyMap(), Collections.singleton(rule));
+ verify(dataSourceUnitService).persist("foo_db",
Collections.emptyMap());
+ verify(databaseRulePersistService).persist(eq("foo_db"), any());
+ }
+
+ @Test
+ void assertPersistConfigurationsWithDataSourcePoolProperties() {
+ DatabaseConfiguration databaseConfig =
mock(DatabaseConfiguration.class, RETURNS_DEEP_STUBS);
+
when(databaseConfig.getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds",
mock(StorageUnit.class, RETURNS_DEEP_STUBS)));
+ metaDataPersistService.persistConfigurations("foo_db", databaseConfig,
Collections.emptyMap(), Collections.emptyList());
+ verify(dataSourceUnitService).persist(eq("foo_db"), any());
+ verify(databaseRulePersistService).persist("foo_db",
Collections.emptyList());
+ }
+
@Test
void assertLoadDataSourceConfigurations() {
-
assertTrue(metaDataPersistService.loadDataSourceConfigurations("foo_db").isEmpty());
+ DataSourcePoolProperties dataSourcePoolProps =
mock(DataSourcePoolProperties.class);
+
when(dataSourceUnitService.load("foo_db")).thenReturn(Collections.singletonMap("foo_ds",
dataSourcePoolProps));
+ DataSourceConfiguration dataSourceConfig =
mock(DataSourceConfiguration.class);
+
when(DataSourcePoolPropertiesCreator.createConfiguration(dataSourcePoolProps)).thenReturn(dataSourceConfig);
+ Map<String, DataSourceConfiguration> actual =
metaDataPersistService.loadDataSourceConfigurations("foo_db");
+ assertThat(actual.size(), is(1));
+ assertThat(actual.get("foo_ds"), is(dataSourceConfig));
+ }
+
+ @Test
+ void assertPersistReloadDatabaseByAlter() {
+ ShardingSphereSchema toBeDeletedSchemas =
mock(ShardingSphereSchema.class);
+ ShardingSphereSchema toBeAddedSchemas =
mock(ShardingSphereSchema.class);
+ when(GenericSchemaManager.getToBeDroppedTablesBySchemas(any(),
any())).thenReturn(Collections.singletonMap("to_be_deleted",
toBeDeletedSchemas));
+ when(GenericSchemaManager.getToBeAddedTablesBySchemas(any(),
any())).thenReturn(Collections.singletonMap("to_be_added", toBeAddedSchemas));
+ metaDataPersistService.persistReloadDatabaseByAlter("foo_db",
mock(ShardingSphereDatabase.class), mock(ShardingSphereDatabase.class));
+ verify(databaseMetaDataService).persistByAlterConfiguration("foo_db",
"to_be_added", toBeAddedSchemas);
+ verify(databaseMetaDataService).delete("foo_db", "to_be_deleted",
toBeDeletedSchemas);
+ }
+
+ @Test
+ void assertPersistReloadDatabaseByDrop() {
+ ShardingSphereSchema toBeDeletedSchemas =
mock(ShardingSphereSchema.class);
+ ShardingSphereSchema toBeAlterSchemas =
mock(ShardingSphereSchema.class);
+ when(GenericSchemaManager.getToBeDroppedTablesBySchemas(any(),
any())).thenReturn(Collections.singletonMap("to_be_deleted",
toBeDeletedSchemas));
+ when(GenericSchemaManager.getToBeAddedTablesBySchemas(any(),
any())).thenReturn(Collections.singletonMap("to_be_altered", toBeAlterSchemas));
+ metaDataPersistService.persistReloadDatabaseByDrop("foo_db",
mock(ShardingSphereDatabase.class), mock(ShardingSphereDatabase.class));
+ verify(databaseMetaDataService).persistByDropConfiguration("foo_db",
"to_be_altered", toBeAlterSchemas);
+ verify(databaseMetaDataService).delete("foo_db", "to_be_deleted",
toBeDeletedSchemas);
}
}
