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 73e8b2b18c4 Remove rule if rule configuration is empty (#38238)
73e8b2b18c4 is described below
commit 73e8b2b18c4725387d23c4dc3caa0b20dc59e3bc
Author: Haoran Meng <[email protected]>
AuthorDate: Fri Feb 27 17:14:40 2026 +0800
Remove rule if rule configuration is empty (#38238)
* Remove rule if rule configuration is empty
* Refactor ShardingRuleConfigurationEmptyChecker
---
.../EncryptRuleConfigurationEmptyChecker.java | 2 +-
.../checker/MaskRuleConfigurationEmptyChecker.java | 2 +-
...riteSplittingRuleConfigurationEmptyChecker.java | 2 +-
.../ShadowRuleConfigurationEmptyChecker.java | 2 +-
.../ShadowRuleConfigurationEmptyCheckerTest.java | 18 ++++--
.../ShardingRuleConfigurationEmptyChecker.java | 8 ++-
.../ShardingRuleConfigurationEmptyCheckerTest.java | 74 ++++++++++++++++++++--
.../rule/DatabaseRuleConfigurationManager.java | 26 ++++++--
.../manager/rule/DatabaseRuleItemManager.java | 7 +-
.../rule/DatabaseRuleConfigurationManagerTest.java | 68 +++++++++++++++-----
.../manager/rule/DatabaseRuleItemManagerTest.java | 11 ++--
.../StandaloneMetaDataManagerPersistService.java | 2 +-
...tandaloneMetaDataManagerPersistServiceTest.java | 2 +-
13 files changed, 168 insertions(+), 56 deletions(-)
diff --git
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationEmptyChecker.java
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationEmptyChecker.java
index 6ce4e8d5928..61d1e541184 100644
---
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationEmptyChecker.java
+++
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationEmptyChecker.java
@@ -27,7 +27,7 @@ public final class EncryptRuleConfigurationEmptyChecker
implements DatabaseRuleC
@Override
public boolean isEmpty(final EncryptRuleConfiguration ruleConfig) {
- return ruleConfig.getTables().isEmpty();
+ return ruleConfig.getTables().isEmpty() &&
ruleConfig.getEncryptors().isEmpty();
}
@Override
diff --git
a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationEmptyChecker.java
b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationEmptyChecker.java
index f0d245dbe1c..d6317510a65 100644
---
a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationEmptyChecker.java
+++
b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationEmptyChecker.java
@@ -27,7 +27,7 @@ public final class MaskRuleConfigurationEmptyChecker
implements DatabaseRuleConf
@Override
public boolean isEmpty(final MaskRuleConfiguration ruleConfig) {
- return ruleConfig.getTables().isEmpty();
+ return ruleConfig.getTables().isEmpty() &&
ruleConfig.getMaskAlgorithms().isEmpty();
}
@Override
diff --git
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationEmptyChecker.java
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationEmptyChecker.java
index b678a4c605f..3785d14d6b2 100644
---
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationEmptyChecker.java
+++
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationEmptyChecker.java
@@ -27,7 +27,7 @@ public final class
ReadwriteSplittingRuleConfigurationEmptyChecker implements Da
@Override
public boolean isEmpty(final ReadwriteSplittingRuleConfiguration
ruleConfig) {
- return ruleConfig.getDataSourceGroups().isEmpty();
+ return ruleConfig.getDataSourceGroups().isEmpty() &&
ruleConfig.getLoadBalancers().isEmpty();
}
@Override
diff --git
a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationEmptyChecker.java
b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationEmptyChecker.java
index 047bbf6bf55..08f56f7583d 100644
---
a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationEmptyChecker.java
+++
b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationEmptyChecker.java
@@ -27,7 +27,7 @@ public final class ShadowRuleConfigurationEmptyChecker
implements DatabaseRuleCo
@Override
public boolean isEmpty(final ShadowRuleConfiguration ruleConfig) {
- return ruleConfig.getDataSources().isEmpty() ||
ruleConfig.getTables().isEmpty();
+ return ruleConfig.getDataSources().isEmpty() &&
ruleConfig.getTables().isEmpty() && ruleConfig.getShadowAlgorithms().isEmpty();
}
@Override
diff --git
a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationEmptyCheckerTest.java
b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationEmptyCheckerTest.java
index ba797c1584f..b2d4fadda7f 100644
---
a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationEmptyCheckerTest.java
+++
b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationEmptyCheckerTest.java
@@ -29,7 +29,6 @@ import java.util.Collections;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.Mockito.mock;
class ShadowRuleConfigurationEmptyCheckerTest {
@@ -43,22 +42,27 @@ class ShadowRuleConfigurationEmptyCheckerTest {
@Test
void assertIsEmptyDataSources() {
ShadowRuleConfiguration ruleConfig = new ShadowRuleConfiguration();
- ruleConfig.setTables(Collections.singletonMap("foo_tbl",
mock(ShadowTableConfiguration.class)));
- assertTrue(checker.isEmpty(ruleConfig));
+ ruleConfig.setTables(Collections.singletonMap("foo_tbl", new
ShadowTableConfiguration(Collections.emptyList(), Collections.emptyList())));
+ assertFalse(checker.isEmpty(ruleConfig));
}
@Test
void assertIsEmptyTables() {
ShadowRuleConfiguration ruleConfig = new ShadowRuleConfiguration();
-
ruleConfig.setDataSources(Collections.singleton(mock(ShadowDataSourceConfiguration.class)));
- assertTrue(checker.isEmpty(ruleConfig));
+ ruleConfig.setDataSources(Collections.singleton(new
ShadowDataSourceConfiguration("foo_ds", "foo", "foo_shadow")));
+ assertFalse(checker.isEmpty(ruleConfig));
+ }
+
+ @Test
+ void assertIsEmpty() {
+ assertTrue(checker.isEmpty(new ShadowRuleConfiguration()));
}
@Test
void assertIsNotEmpty() {
ShadowRuleConfiguration ruleConfig = new ShadowRuleConfiguration();
-
ruleConfig.setDataSources(Collections.singleton(mock(ShadowDataSourceConfiguration.class)));
- ruleConfig.setTables(Collections.singletonMap("foo_tbl",
mock(ShadowTableConfiguration.class)));
+ ruleConfig.setDataSources(Collections.singleton(new
ShadowDataSourceConfiguration("foo_ds", "foo", "foo_shadow")));
+ ruleConfig.setTables(Collections.singletonMap("foo_tbl", new
ShadowTableConfiguration(Collections.emptyList(), Collections.emptyList())));
assertFalse(checker.isEmpty(ruleConfig));
}
}
diff --git
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationEmptyChecker.java
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationEmptyChecker.java
index 0f4d34508f8..ccadb50a539 100644
---
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationEmptyChecker.java
+++
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationEmptyChecker.java
@@ -27,8 +27,12 @@ public final class ShardingRuleConfigurationEmptyChecker
implements DatabaseRule
@Override
public boolean isEmpty(final ShardingRuleConfiguration ruleConfig) {
- return ruleConfig.getTables().isEmpty() &&
ruleConfig.getAutoTables().isEmpty()
- && null == ruleConfig.getDefaultDatabaseShardingStrategy() &&
null == ruleConfig.getDefaultTableShardingStrategy();
+ return ruleConfig.getTables().isEmpty() &&
ruleConfig.getAutoTables().isEmpty() &&
ruleConfig.getBindingTableGroups().isEmpty()
+ && null == ruleConfig.getDefaultDatabaseShardingStrategy() &&
null == ruleConfig.getDefaultTableShardingStrategy()
+ && null == ruleConfig.getDefaultKeyGenerateStrategy() && null
== ruleConfig.getDefaultAuditStrategy()
+ && (null == ruleConfig.getDefaultShardingColumn() ||
ruleConfig.getDefaultShardingColumn().isEmpty())
+ && ruleConfig.getShardingAlgorithms().isEmpty() &&
ruleConfig.getKeyGenerators().isEmpty()
+ && ruleConfig.getAuditors().isEmpty() && null ==
ruleConfig.getShardingCache();
}
@Override
diff --git
a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationEmptyCheckerTest.java
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationEmptyCheckerTest.java
index 62d4f359269..c45bbcd6feb 100644
---
a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationEmptyCheckerTest.java
+++
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationEmptyCheckerTest.java
@@ -20,15 +20,21 @@ package org.apache.shardingsphere.sharding.checker.config;
import
org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationEmptyChecker;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.cache.ShardingCacheConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.cache.ShardingCacheOptionsConfiguration;
import
org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.rule.ShardingTableReferenceRuleConfiguration;
import
org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
-import
org.apache.shardingsphere.sharding.api.config.strategy.sharding.ShardingStrategyConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.strategy.audit.ShardingAuditStrategyConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.strategy.keygen.KeyGenerateStrategyConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.strategy.sharding.NoneShardingStrategyConfiguration;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import java.util.Collections;
+
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.Mockito.mock;
class ShardingRuleConfigurationEmptyCheckerTest {
@@ -42,28 +48,84 @@ class ShardingRuleConfigurationEmptyCheckerTest {
@Test
void assertIsNotEmptyWithTables() {
ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
- ruleConfig.getTables().add(mock(ShardingTableRuleConfiguration.class));
+ ruleConfig.getTables().add(new
ShardingTableRuleConfiguration("t_order", "ds_0.t_order"));
assertFalse(checker.isEmpty(ruleConfig));
}
@Test
void assertIsNotEmptyWithAutoTables() {
ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
-
ruleConfig.getAutoTables().add(mock(ShardingAutoTableRuleConfiguration.class));
+ ruleConfig.getAutoTables().add(new
ShardingAutoTableRuleConfiguration("t_order", "ds_0"));
+ assertFalse(checker.isEmpty(ruleConfig));
+ }
+
+ @Test
+ void assertIsNotEmptyWithBindingTableGroups() {
+ ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
+ ruleConfig.getBindingTableGroups().add(new
ShardingTableReferenceRuleConfiguration("binding_group",
"t_order,t_order_item"));
assertFalse(checker.isEmpty(ruleConfig));
}
@Test
void assertIsNotEmptyWithGetDefaultDatabaseShardingStrategy() {
ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
-
ruleConfig.setDefaultDatabaseShardingStrategy(mock(ShardingStrategyConfiguration.class));
+ ruleConfig.setDefaultDatabaseShardingStrategy(new
NoneShardingStrategyConfiguration());
assertFalse(checker.isEmpty(ruleConfig));
}
@Test
void assertIsNotEmptyWithGetDefaultTableShardingStrategy() {
ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
-
ruleConfig.setDefaultTableShardingStrategy(mock(ShardingStrategyConfiguration.class));
+ ruleConfig.setDefaultTableShardingStrategy(new
NoneShardingStrategyConfiguration());
+ assertFalse(checker.isEmpty(ruleConfig));
+ }
+
+ @Test
+ void assertIsNotEmptyWithDefaultKeyGenerateStrategy() {
+ ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
+ ruleConfig.setDefaultKeyGenerateStrategy(new
KeyGenerateStrategyConfiguration("order_id", "snowflake"));
+ assertFalse(checker.isEmpty(ruleConfig));
+ }
+
+ @Test
+ void assertIsNotEmptyWithDefaultAuditStrategy() {
+ ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
+ ruleConfig.setDefaultAuditStrategy(new
ShardingAuditStrategyConfiguration(Collections.singleton("foo_auditor"),
false));
+ assertFalse(checker.isEmpty(ruleConfig));
+ }
+
+ @Test
+ void assertIsNotEmptyWithDefaultShardingColumn() {
+ ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
+ ruleConfig.setDefaultShardingColumn("user_id");
+ assertFalse(checker.isEmpty(ruleConfig));
+ }
+
+ @Test
+ void assertIsNotEmptyWithShardingAlgorithms() {
+ ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
+ ruleConfig.getShardingAlgorithms().put("foo_algorithm", null);
+ assertFalse(checker.isEmpty(ruleConfig));
+ }
+
+ @Test
+ void assertIsNotEmptyWithKeyGenerators() {
+ ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
+ ruleConfig.getKeyGenerators().put("foo_key_generator", null);
+ assertFalse(checker.isEmpty(ruleConfig));
+ }
+
+ @Test
+ void assertIsNotEmptyWithAuditors() {
+ ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
+ ruleConfig.getAuditors().put("foo_auditor", null);
+ assertFalse(checker.isEmpty(ruleConfig));
+ }
+
+ @Test
+ void assertIsNotEmptyWithShardingCache() {
+ ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
+ ruleConfig.setShardingCache(new ShardingCacheConfiguration(1, new
ShardingCacheOptionsConfiguration(false, 1, 1)));
assertFalse(checker.isEmpty(ruleConfig));
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleConfigurationManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleConfigurationManager.java
index b608e3683dc..a94d98a41aa 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleConfigurationManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleConfigurationManager.java
@@ -20,11 +20,14 @@ package
org.apache.shardingsphere.mode.metadata.manager.rule;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import
org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationEmptyChecker;
+import
org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.rule.PartialRuleUpdateSupported;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import
org.apache.shardingsphere.infra.rule.builder.database.DatabaseRulesBuilder;
+import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
import org.apache.shardingsphere.mode.metadata.factory.MetaDataContextsFactory;
import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistFacade;
@@ -52,30 +55,41 @@ public final class DatabaseRuleConfigurationManager {
*
* @param databaseName database name
* @param ruleConfig rule configurations
- * @param reBuildRules is need to rebuild rules
* @throws SQLException SQL Exception
*/
@SuppressWarnings({"unchecked", "rawtypes"})
- public synchronized void refresh(final String databaseName, final
RuleConfiguration ruleConfig, final boolean reBuildRules) throws SQLException {
+ public synchronized void refresh(final String databaseName, final
RuleConfiguration ruleConfig) throws SQLException {
ShardingSphereDatabase database =
metaDataContexts.getMetaData().getDatabase(databaseName);
Collection<ShardingSphereRule> rules = new
LinkedList<>(database.getRuleMetaData().getRules());
+ if (isRuleConfigurationEmpty(ruleConfig)) {
+ refreshMetadata(databaseName, ruleConfig, false, database, rules);
+ return;
+ }
Optional<ShardingSphereRule> toBeChangedRule =
rules.stream().filter(each ->
each.getConfiguration().getClass().equals(ruleConfig.getClass())).findFirst();
if (toBeChangedRule.isPresent() && toBeChangedRule.get() instanceof
PartialRuleUpdateSupported) {
boolean needRefreshSchemas = ((PartialRuleUpdateSupported)
toBeChangedRule.get()).partialUpdate(ruleConfig);
((PartialRuleUpdateSupported)
toBeChangedRule.get()).updateConfiguration(ruleConfig);
if (needRefreshSchemas) {
- refreshMetadata(databaseName, ruleConfig, reBuildRules,
database, rules);
+ refreshMetadata(databaseName, ruleConfig, true, database,
rules);
}
} else {
- refreshMetadata(databaseName, ruleConfig, reBuildRules, database,
rules);
+ refreshMetadata(databaseName, ruleConfig, true, database, rules);
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ private boolean isRuleConfigurationEmpty(final RuleConfiguration
ruleConfig) {
+ if (!(ruleConfig instanceof DatabaseRuleConfiguration)) {
+ return false;
}
+ return
TypedSPILoader.getService(DatabaseRuleConfigurationEmptyChecker.class,
ruleConfig.getClass()).isEmpty((DatabaseRuleConfiguration) ruleConfig);
}
- private void refreshMetadata(final String databaseName, final
RuleConfiguration ruleConfig, final boolean reBuildRules, final
ShardingSphereDatabase database,
+ private void refreshMetadata(final String databaseName, final
RuleConfiguration ruleConfig, final boolean buildRule, final
ShardingSphereDatabase database,
final Collection<ShardingSphereRule> rules)
throws SQLException {
Collection<ShardingSphereRule> toBeRemovedRules =
rules.stream().filter(each ->
each.getConfiguration().getClass().isAssignableFrom(ruleConfig.getClass())).collect(Collectors.toList());
rules.removeAll(toBeRemovedRules);
- if (reBuildRules) {
+ if (buildRule) {
rules.add(DatabaseRulesBuilder.build(
databaseName, database.getProtocolType(),
database.getRuleMetaData().getRules(), ruleConfig, computeNodeInstanceContext,
database.getResourceMetaData()));
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleItemManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleItemManager.java
index 6026edbc15c..7fea50c1f84 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleItemManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleItemManager.java
@@ -20,8 +20,6 @@ package org.apache.shardingsphere.mode.metadata.manager.rule;
import com.google.common.base.Preconditions;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
-import
org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationEmptyChecker;
-import
org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
import
org.apache.shardingsphere.infra.exception.external.sql.type.wrapper.SQLWrapperException;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
@@ -62,7 +60,7 @@ public final class DatabaseRuleItemManager {
synchronized (this) {
processor.changeRuleItemConfiguration(itemName, currentRuleConfig,
processor.swapRuleItemConfiguration(itemName, yamlContent));
try {
- databaseRuleConfigManager.refresh(databaseName,
currentRuleConfig, true);
+ databaseRuleConfigManager.refresh(databaseName,
currentRuleConfig);
} catch (final SQLException ex) {
throw new SQLWrapperException(ex);
}
@@ -86,8 +84,7 @@ public final class DatabaseRuleItemManager {
synchronized (this) {
processor.dropRuleItemConfiguration(itemName, currentRuleConfig);
try {
- databaseRuleConfigManager.refresh(databaseName,
currentRuleConfig,
-
!TypedSPILoader.getService(DatabaseRuleConfigurationEmptyChecker.class,
currentRuleConfig.getClass()).isEmpty((DatabaseRuleConfiguration)
currentRuleConfig));
+ databaseRuleConfigManager.refresh(databaseName,
currentRuleConfig);
} catch (final SQLException ex) {
throw new SQLWrapperException(ex);
}
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleConfigurationManagerTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleConfigurationManagerTest.java
index aceaf34242e..bc8636610d1 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleConfigurationManagerTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleConfigurationManagerTest.java
@@ -18,12 +18,16 @@
package org.apache.shardingsphere.mode.metadata.manager.rule;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import
org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationEmptyChecker;
+import
org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
import org.apache.shardingsphere.infra.rule.PartialRuleUpdateSupported;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import
org.apache.shardingsphere.infra.rule.builder.database.DatabaseRulesBuilder;
+import org.apache.shardingsphere.infra.spi.type.typed.TypedSPI;
+import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
import org.apache.shardingsphere.mode.metadata.factory.MetaDataContextsFactory;
import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistFacade;
@@ -55,14 +59,14 @@ import static org.mockito.Mockito.withSettings;
@SuppressWarnings({"rawtypes", "unchecked"})
@ExtendWith(AutoMockExtension.class)
-@StaticMockSettings(DatabaseRulesBuilder.class)
+@StaticMockSettings({DatabaseRulesBuilder.class, TypedSPILoader.class})
class DatabaseRuleConfigurationManagerTest {
private static final String DATABASE_NAME = "foo_db";
@Test
void assertRefreshWithPartialUpdateAndRebuild() throws SQLException {
- RuleConfiguration ruleConfig = mock(RuleConfiguration.class);
+ DatabaseRuleConfiguration ruleConfig =
mockDatabaseRuleConfiguration(false);
ShardingSphereRule closableRule = mock(ShardingSphereRule.class,
withSettings().extraInterfaces(PartialRuleUpdateSupported.class,
AutoCloseable.class));
when(closableRule.getConfiguration()).thenReturn(ruleConfig);
PartialRuleUpdateSupported updater = (PartialRuleUpdateSupported)
closableRule;
@@ -79,7 +83,7 @@ class DatabaseRuleConfigurationManagerTest {
MockedConstruction<MetaDataContextsFactory> ignored =
mockConstruction(MetaDataContextsFactory.class,
(mock, context) ->
when(mock.createByAlterRule(eq(DATABASE_NAME), eq(false),
any(Collection.class),
eq(metaDataContexts))).thenReturn(mock(MetaDataContexts.class)))) {
when(DatabaseRulesBuilder.build(eq(DATABASE_NAME), any(), any(),
eq(ruleConfig), any(), any())).thenReturn(rebuiltRule);
- new DatabaseRuleConfigurationManager(metaDataContexts,
mock(ComputeNodeInstanceContext.class),
mock(MetaDataPersistFacade.class)).refresh(DATABASE_NAME, ruleConfig, true);
+ new DatabaseRuleConfigurationManager(metaDataContexts,
mock(ComputeNodeInstanceContext.class),
mock(MetaDataPersistFacade.class)).refresh(DATABASE_NAME, ruleConfig);
verify((PartialRuleUpdateSupported)
closableRule).updateConfiguration(ruleConfig);
verify(metaDataContexts).update(any(MetaDataContexts.class));
assertDoesNotThrow(() -> verify((AutoCloseable)
closableRule).close());
@@ -88,21 +92,41 @@ class DatabaseRuleConfigurationManagerTest {
@Test
void assertRefreshWithPartialUpdateSkipMetadata() throws SQLException {
- RuleConfiguration ruleConfig = mock(RuleConfiguration.class,
withSettings().extraInterfaces(Serializable.class));
+ DatabaseRuleConfiguration ruleConfig =
mockDatabaseRuleConfiguration(false);
ShardingSphereRule partialRule = mock(ShardingSphereRule.class,
withSettings().extraInterfaces(PartialRuleUpdateSupported.class));
when(partialRule.getConfiguration()).thenReturn(ruleConfig);
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class);
when(database.getRuleMetaData()).thenReturn(new
RuleMetaData(Collections.singleton(partialRule)));
MetaDataContexts metaDataContexts = mock(MetaDataContexts.class,
RETURNS_DEEP_STUBS);
when(metaDataContexts.getMetaData().getDatabase(DATABASE_NAME)).thenReturn(database);
- new DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig, true);
+ new DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig);
verify((PartialRuleUpdateSupported)
partialRule).updateConfiguration(ruleConfig);
verify(metaDataContexts, never()).update(any(MetaDataContexts.class));
}
@Test
- void assertRefreshWithPartialUpdateWithoutRebuild() throws SQLException {
- RuleConfiguration ruleConfig = mock(RuleConfiguration.class,
withSettings().extraInterfaces(Serializable.class));
+ void assertRefreshWithEmptyRuleConfigurationAndPartialRule() throws
SQLException {
+ DatabaseRuleConfiguration ruleConfig =
mockDatabaseRuleConfiguration(true);
+ ShardingSphereRule partialRule = mock(ShardingSphereRule.class,
withSettings().extraInterfaces(PartialRuleUpdateSupported.class));
+ when(partialRule.getConfiguration()).thenReturn(ruleConfig);
+ RuleMetaData ruleMetaData = new RuleMetaData(new
LinkedList<>(Collections.singleton(partialRule)));
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
+ when(database.getRuleMetaData()).thenReturn(ruleMetaData);
+ MetaDataContexts metaDataContexts = mock(MetaDataContexts.class,
RETURNS_DEEP_STUBS);
+
when(metaDataContexts.getMetaData().getDatabase(DATABASE_NAME)).thenReturn(database);
+ try (
+ MockedConstruction<MetaDataContextsFactory> ignored =
mockConstruction(MetaDataContextsFactory.class,
+ (mock, context) ->
when(mock.createByAlterRule(eq(DATABASE_NAME), eq(false),
any(Collection.class),
eq(metaDataContexts))).thenReturn(mock(MetaDataContexts.class)))) {
+ new DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig);
+ verify((PartialRuleUpdateSupported) partialRule,
never()).partialUpdate(ruleConfig);
+ verify((PartialRuleUpdateSupported) partialRule,
never()).updateConfiguration(ruleConfig);
+ verify(metaDataContexts).update(any(MetaDataContexts.class));
+ }
+ }
+
+ @Test
+ void assertRefreshWithPartialUpdateNeedRefreshMetadata() throws
SQLException {
+ DatabaseRuleConfiguration ruleConfig =
mockDatabaseRuleConfiguration(false);
ShardingSphereRule partialRule = mock(ShardingSphereRule.class,
withSettings().extraInterfaces(PartialRuleUpdateSupported.class));
when(partialRule.getConfiguration()).thenReturn(ruleConfig);
PartialRuleUpdateSupported updater = (PartialRuleUpdateSupported)
partialRule;
@@ -115,15 +139,15 @@ class DatabaseRuleConfigurationManagerTest {
try (
MockedConstruction<MetaDataContextsFactory> ignored =
mockConstruction(MetaDataContextsFactory.class,
(mock, context) ->
when(mock.createByAlterRule(eq(DATABASE_NAME), eq(false),
any(Collection.class),
eq(metaDataContexts))).thenReturn(mock(MetaDataContexts.class)))) {
- new DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig, false);
+ new DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig);
verify(metaDataContexts).update(any(MetaDataContexts.class));
verify(updater).updateConfiguration(ruleConfig);
}
}
@Test
- void assertRefreshWithoutExistingRuleAndWithoutRebuild() throws
SQLException {
- RuleConfiguration ruleConfig = mock(RuleConfiguration.class,
withSettings().extraInterfaces(Serializable.class));
+ void assertRefreshWithoutExistingRule() throws SQLException {
+ DatabaseRuleConfiguration ruleConfig =
mockDatabaseRuleConfiguration(false);
ShardingSphereRule otherRule = mock(ShardingSphereRule.class);
when(otherRule.getConfiguration()).thenReturn(mock(RuleConfiguration.class,
withSettings().extraInterfaces(Cloneable.class)));
RuleMetaData ruleMetaData = new
RuleMetaData(Collections.singleton(otherRule));
@@ -131,17 +155,19 @@ class DatabaseRuleConfigurationManagerTest {
when(database.getRuleMetaData()).thenReturn(ruleMetaData);
MetaDataContexts metaDataContexts = mock(MetaDataContexts.class,
RETURNS_DEEP_STUBS);
when(metaDataContexts.getMetaData().getDatabase(DATABASE_NAME)).thenReturn(database);
+ ShardingSphereRule rebuiltRule = mock(ShardingSphereRule.class);
try (
MockedConstruction<MetaDataContextsFactory> ignored =
mockConstruction(MetaDataContextsFactory.class,
(mock, context) ->
when(mock.createByAlterRule(eq(DATABASE_NAME), eq(false),
any(Collection.class),
eq(metaDataContexts))).thenReturn(mock(MetaDataContexts.class)))) {
- new DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig, false);
+ when(DatabaseRulesBuilder.build(eq(DATABASE_NAME), any(), any(),
eq(ruleConfig), any(), any())).thenReturn(rebuiltRule);
+ new DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig);
verify(metaDataContexts).update(any(MetaDataContexts.class));
}
}
@Test
void assertRefreshWithExistingNonPartialRule() throws SQLException {
- RuleConfiguration ruleConfig = mock(RuleConfiguration.class,
withSettings().extraInterfaces(Serializable.class));
+ DatabaseRuleConfiguration ruleConfig =
mockDatabaseRuleConfiguration(false);
ShardingSphereRule existingRule = mock(ShardingSphereRule.class);
when(existingRule.getConfiguration()).thenReturn(ruleConfig);
RuleMetaData ruleMetaData = new
RuleMetaData(Collections.singleton(existingRule));
@@ -154,14 +180,14 @@ class DatabaseRuleConfigurationManagerTest {
MockedConstruction<MetaDataContextsFactory> ignored =
mockConstruction(MetaDataContextsFactory.class,
(mock, context) ->
when(mock.createByAlterRule(eq(DATABASE_NAME), eq(false),
any(Collection.class),
eq(metaDataContexts))).thenReturn(mock(MetaDataContexts.class)))) {
when(DatabaseRulesBuilder.build(eq(DATABASE_NAME), any(), any(),
eq(ruleConfig), any(), any())).thenReturn(rebuiltRule);
- new DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig, true);
+ new DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig);
verify(metaDataContexts).update(any(MetaDataContexts.class));
}
}
@Test
void assertRefreshWrapsException() {
- RuleConfiguration ruleConfig = mock(RuleConfiguration.class,
withSettings().extraInterfaces(Serializable.class));
+ DatabaseRuleConfiguration ruleConfig =
mockDatabaseRuleConfiguration(false);
ShardingSphereRule rule = mock(ShardingSphereRule.class);
when(rule.getConfiguration()).thenReturn(ruleConfig);
RuleMetaData ruleMetaData = new
RuleMetaData(Collections.singleton(rule));
@@ -173,13 +199,13 @@ class DatabaseRuleConfigurationManagerTest {
MockedConstruction<MetaDataContextsFactory> ignored =
mockConstruction(MetaDataContextsFactory.class,
(mock, context) ->
when(mock.createByAlterRule(eq(DATABASE_NAME), eq(false),
any(Collection.class), eq(metaDataContexts))).thenThrow(new
SQLException("failed")))) {
assertThrows(SQLException.class,
- () -> new
DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig, false));
+ () -> new
DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig));
}
}
@Test
void assertRefreshThrowsWhenCloseOriginalRuleFailed() throws Exception {
- RuleConfiguration ruleConfig = mock(RuleConfiguration.class,
withSettings().extraInterfaces(Serializable.class));
+ DatabaseRuleConfiguration ruleConfig =
mockDatabaseRuleConfiguration(false);
ShardingSphereRule closableRule = mock(ShardingSphereRule.class,
withSettings().extraInterfaces(PartialRuleUpdateSupported.class,
AutoCloseable.class));
when(closableRule.getConfiguration()).thenReturn(ruleConfig);
PartialRuleUpdateSupported updater = (PartialRuleUpdateSupported)
closableRule;
@@ -194,7 +220,15 @@ class DatabaseRuleConfigurationManagerTest {
MockedConstruction<MetaDataContextsFactory> ignored =
mockConstruction(MetaDataContextsFactory.class,
(mock, context) ->
when(mock.createByAlterRule(eq(DATABASE_NAME), eq(false),
any(Collection.class),
eq(metaDataContexts))).thenReturn(mock(MetaDataContexts.class)))) {
assertThrows(Exception.class,
- () -> new
DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig, false));
+ () -> new
DatabaseRuleConfigurationManager(metaDataContexts, mock(),
mock()).refresh(DATABASE_NAME, ruleConfig));
}
}
+
+ private DatabaseRuleConfiguration mockDatabaseRuleConfiguration(final
boolean isEmpty) {
+ DatabaseRuleConfiguration result =
mock(DatabaseRuleConfiguration.class,
withSettings().extraInterfaces(Serializable.class));
+ DatabaseRuleConfigurationEmptyChecker checker =
mock(DatabaseRuleConfigurationEmptyChecker.class);
+ when(checker.isEmpty(result)).thenReturn(isEmpty);
+ when((TypedSPI)
TypedSPILoader.getService(DatabaseRuleConfigurationEmptyChecker.class,
result.getClass())).thenReturn(checker);
+ return result;
+ }
}
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleItemManagerTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleItemManagerTest.java
index 67c33babfc8..278d2e96d05 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleItemManagerTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/rule/DatabaseRuleItemManagerTest.java
@@ -18,7 +18,6 @@
package org.apache.shardingsphere.mode.metadata.manager.rule;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
-import
org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationEmptyChecker;
import
org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
import
org.apache.shardingsphere.infra.exception.external.sql.type.wrapper.SQLWrapperException;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
@@ -68,7 +67,7 @@ class DatabaseRuleItemManagerTest {
when((TypedSPI)
TypedSPILoader.getService(RuleItemConfigurationChangedProcessor.class, new
RuleChangedItemType("ruleType", "type"))).thenReturn(processor);
DatabaseRuleItemManager manager = new
DatabaseRuleItemManager(mock(MetaDataContexts.class, RETURNS_DEEP_STUBS),
ruleConfigManager, persistFacade);
manager.alter(new DatabaseRuleNodePath(DATABASE_NAME, "ruleType", new
DatabaseRuleItem("type/item")));
- verify(ruleConfigManager).refresh(DATABASE_NAME, currentRuleConfig,
true);
+ verify(ruleConfigManager).refresh(DATABASE_NAME, currentRuleConfig);
verify(processor).changeRuleItemConfiguration(eq("item"),
eq(currentRuleConfig), any());
}
@@ -80,7 +79,7 @@ class DatabaseRuleItemManagerTest {
when(processor.findRuleConfiguration(any(ShardingSphereDatabase.class))).thenReturn(currentRuleConfig);
when(processor.swapRuleItemConfiguration(any(), any())).thenReturn(new
Object());
when((TypedSPI)
TypedSPILoader.getService(RuleItemConfigurationChangedProcessor.class, new
RuleChangedItemType("ruleType", "type"))).thenReturn(processor);
-
doThrow(SQLException.class).when(ruleConfigManager).refresh(DATABASE_NAME,
currentRuleConfig, true);
+
doThrow(SQLException.class).when(ruleConfigManager).refresh(DATABASE_NAME,
currentRuleConfig);
DatabaseRuleItemManager manager = new
DatabaseRuleItemManager(mock(MetaDataContexts.class, RETURNS_DEEP_STUBS),
ruleConfigManager, persistFacade);
assertThrows(SQLWrapperException.class, () -> manager.alter(new
DatabaseRuleNodePath(DATABASE_NAME, "ruleType", new
DatabaseRuleItem("type/item"))));
verify(processor).changeRuleItemConfiguration(eq("item"),
eq(currentRuleConfig), any());
@@ -94,11 +93,10 @@ class DatabaseRuleItemManagerTest {
RuleItemConfigurationChangedProcessor processor =
mock(RuleItemConfigurationChangedProcessor.class);
when(processor.findRuleConfiguration(any(ShardingSphereDatabase.class))).thenReturn(currentRuleConfig);
when((TypedSPI)
TypedSPILoader.getService(RuleItemConfigurationChangedProcessor.class, new
RuleChangedItemType("ruleType", null))).thenReturn(processor);
- when((TypedSPI)
TypedSPILoader.getService(DatabaseRuleConfigurationEmptyChecker.class,
currentRuleConfig.getClass())).thenReturn(mock(DatabaseRuleConfigurationEmptyChecker.class));
DatabaseRuleItemManager manager = new
DatabaseRuleItemManager(metaDataContexts, ruleConfigManager,
mock(MetaDataPersistFacade.class));
manager.drop(new DatabaseRuleNodePath(DATABASE_NAME, "ruleType",
null));
verify(processor).dropRuleItemConfiguration(null, currentRuleConfig);
- verify(ruleConfigManager).refresh(DATABASE_NAME, currentRuleConfig,
true);
+ verify(ruleConfigManager).refresh(DATABASE_NAME, currentRuleConfig);
}
@Test
@@ -109,8 +107,7 @@ class DatabaseRuleItemManagerTest {
RuleItemConfigurationChangedProcessor processor =
mock(RuleItemConfigurationChangedProcessor.class);
when(processor.findRuleConfiguration(any(ShardingSphereDatabase.class))).thenReturn(currentRuleConfig);
when((TypedSPI)
TypedSPILoader.getService(RuleItemConfigurationChangedProcessor.class, new
RuleChangedItemType("ruleType", "type"))).thenReturn(processor);
- when((TypedSPI)
TypedSPILoader.getService(DatabaseRuleConfigurationEmptyChecker.class,
currentRuleConfig.getClass())).thenReturn(mock(DatabaseRuleConfigurationEmptyChecker.class));
- doThrow(new
SQLException("drop")).when(ruleConfigManager).refresh(DATABASE_NAME,
currentRuleConfig, true);
+ doThrow(new
SQLException("drop")).when(ruleConfigManager).refresh(DATABASE_NAME,
currentRuleConfig);
DatabaseRuleItemManager manager = new
DatabaseRuleItemManager(metaDataContexts, ruleConfigManager,
mock(MetaDataPersistFacade.class));
assertThrows(SQLWrapperException.class, () -> manager.drop(new
DatabaseRuleNodePath(DATABASE_NAME, "ruleType", new
DatabaseRuleItem("type/item"))));
verify(processor).dropRuleItemConfiguration("item", currentRuleConfig);
diff --git
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
index 60ad7578df8..2f6151e5bc0 100644
---
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
@@ -199,7 +199,7 @@ public final class StandaloneMetaDataManagerPersistService
implements MetaDataMa
SingleRuleConfiguration singleRuleConfig =
ruleMetaData.getSingleRule(SingleRule.class).getConfiguration();
metaDataPersistFacade.getDatabaseRuleService().persist(database.getName(),
Collections.singleton(singleRuleConfig));
try {
-
metaDataContextManager.getDatabaseRuleConfigurationManager().refresh(database.getName(),
singleRuleConfig, true);
+
metaDataContextManager.getDatabaseRuleConfigurationManager().refresh(database.getName(),
singleRuleConfig);
} catch (final SQLException ex) {
throw new SQLWrapperException(ex);
}
diff --git
a/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
b/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
index 0f12f52719e..c537a4862c9 100644
---
a/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
+++
b/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
@@ -143,7 +143,7 @@ class StandaloneMetaDataManagerPersistServiceTest {
when(singleRule.getConfiguration()).thenReturn(singleRuleConfig);
metaDataManagerPersistService.alterSingleRuleConfiguration(
new ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), new RuleMetaData(Collections.singleton(singleRule)));
-
verify(metaDataContextManager.getDatabaseRuleConfigurationManager()).refresh("foo_db",
singleRuleConfig, true);
+
verify(metaDataContextManager.getDatabaseRuleConfigurationManager()).refresh("foo_db",
singleRuleConfig);
}
@Test
