This is an automated email from the ASF dual-hosted git repository.
zhangliang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new fab39d3adca Spilt YamlRuleRepositoryTupleSwapperEngine.swapToTuples as
GlobalRule and DatabaseRule (#34839)
fab39d3adca is described below
commit fab39d3adca967fc95152199013d353194a14e3e
Author: Liang Zhang <[email protected]>
AuthorDate: Sun Mar 2 12:49:45 2025 +0800
Spilt YamlRuleRepositoryTupleSwapperEngine.swapToTuples as GlobalRule and
DatabaseRule (#34839)
* Spilt YamlRuleRepositoryTupleSwapperEngine.swapToTuples as GlobalRule and
DatabaseRule
* Spilt YamlRuleRepositoryTupleSwapperEngine.swapToTuples as GlobalRule and
DatabaseRule
* Spilt YamlRuleRepositoryTupleSwapperEngine.swapToTuples as GlobalRule and
DatabaseRule
---
.../database/DatabaseRulePersistService.java | 20 +++++---
.../config/global/GlobalRulePersistService.java | 13 ++---
.../YamlRuleRepositoryTupleSwapperEngine.java | 57 +++++++++++++---------
.../YamlRuleRepositoryTupleSwapperEngineTest.java | 23 ++++-----
.../YamlRuleRepositoryTupleSwapperEngineIT.java | 20 +++++---
5 files changed, 75 insertions(+), 58 deletions(-)
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/database/DatabaseRulePersistService.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/database/DatabaseRulePersistService.java
index 88f56363c93..c998fa69b33 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/database/DatabaseRulePersistService.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/database/DatabaseRulePersistService.java
@@ -48,9 +48,15 @@ public final class DatabaseRulePersistService {
private final VersionPersistService versionPersistService;
+ private final YamlRuleConfigurationSwapperEngine yamlSwapperEngine;
+
+ private final YamlRuleRepositoryTupleSwapperEngine tupleSwapperEngine;
+
public DatabaseRulePersistService(final PersistRepository repository) {
this.repository = repository;
versionPersistService = new VersionPersistService(repository);
+ yamlSwapperEngine = new YamlRuleConfigurationSwapperEngine();
+ tupleSwapperEngine = new YamlRuleRepositoryTupleSwapperEngine();
}
/**
@@ -65,8 +71,8 @@ public final class DatabaseRulePersistService {
}
private RuleConfiguration load(final String databaseName, final String
ruleType) {
- return new
YamlRuleConfigurationSwapperEngine().swapToRuleConfiguration(
- new
YamlRuleRepositoryTupleSwapperEngine(databaseName).swapToYamlDatabaseRuleConfiguration(ruleType,
load(databaseName, DatabaseRuleNodeGenerator.generate(ruleType))));
+ return yamlSwapperEngine.swapToRuleConfiguration(
+
tupleSwapperEngine.swapToYamlDatabaseRuleConfiguration(databaseName, ruleType,
load(databaseName, DatabaseRuleNodeGenerator.generate(ruleType))));
}
private Collection<RuleRepositoryTuple> load(final String databaseName,
final DatabaseRuleNode databaseRuleNode) {
@@ -100,9 +106,8 @@ public final class DatabaseRulePersistService {
*/
public Collection<MetaDataVersion> persist(final String databaseName,
final Collection<RuleConfiguration> configs) {
Collection<MetaDataVersion> result = new LinkedList<>();
- YamlRuleRepositoryTupleSwapperEngine tupleSwapperEngine = new
YamlRuleRepositoryTupleSwapperEngine(databaseName);
- for (YamlRuleConfiguration each : new
YamlRuleConfigurationSwapperEngine().swapToYamlRuleConfigurations(configs)) {
-
result.addAll(persistTuples(tupleSwapperEngine.swapToTuples(each)));
+ for (YamlRuleConfiguration each :
yamlSwapperEngine.swapToYamlRuleConfigurations(configs)) {
+
result.addAll(persistTuples(tupleSwapperEngine.swapToTuples(databaseName,
each)));
}
return result;
}
@@ -131,9 +136,8 @@ public final class DatabaseRulePersistService {
*/
public Collection<MetaDataVersion> delete(final String databaseName, final
Collection<RuleConfiguration> configs) {
Collection<MetaDataVersion> result = new LinkedList<>();
- YamlRuleRepositoryTupleSwapperEngine tupleSwapperEngine = new
YamlRuleRepositoryTupleSwapperEngine(databaseName);
- for (YamlRuleConfiguration each : new
YamlRuleConfigurationSwapperEngine().swapToYamlRuleConfigurations(configs)) {
- List<RuleRepositoryTuple> tuples = new
LinkedList<>(tupleSwapperEngine.swapToTuples(each));
+ for (YamlRuleConfiguration each :
yamlSwapperEngine.swapToYamlRuleConfigurations(configs)) {
+ List<RuleRepositoryTuple> tuples = new
LinkedList<>(tupleSwapperEngine.swapToTuples(databaseName, each));
if (tuples.isEmpty()) {
continue;
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/global/GlobalRulePersistService.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/global/GlobalRulePersistService.java
index 33a7653f662..91bab873288 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/global/GlobalRulePersistService.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/global/GlobalRulePersistService.java
@@ -18,6 +18,7 @@
package org.apache.shardingsphere.mode.metadata.persist.config.global;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import
org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
import
org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
import
org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapperEngine;
import
org.apache.shardingsphere.mode.metadata.persist.version.VersionPersistService;
@@ -40,15 +41,15 @@ public final class GlobalRulePersistService {
private final VersionPersistService versionPersistService;
- private final YamlRuleRepositoryTupleSwapperEngine tupleSwapperEngine;
-
private final YamlRuleConfigurationSwapperEngine yamlSwapperEngine;
+ private final YamlRuleRepositoryTupleSwapperEngine tupleSwapperEngine;
+
public GlobalRulePersistService(final PersistRepository repository, final
VersionPersistService versionPersistService) {
this.repository = repository;
this.versionPersistService = versionPersistService;
- tupleSwapperEngine = new YamlRuleRepositoryTupleSwapperEngine();
yamlSwapperEngine = new YamlRuleConfigurationSwapperEngine();
+ tupleSwapperEngine = new YamlRuleRepositoryTupleSwapperEngine();
}
/**
@@ -78,11 +79,11 @@ public final class GlobalRulePersistService {
*/
public void persist(final Collection<RuleConfiguration> globalRuleConfigs)
{
for (YamlRuleConfiguration each :
yamlSwapperEngine.swapToYamlRuleConfigurations(globalRuleConfigs)) {
- persistTuples(tupleSwapperEngine.swapToTuples(each));
+
persistTuple(tupleSwapperEngine.swapToTuple((YamlGlobalRuleConfiguration)
each));
}
}
- private void persistTuples(final Collection<RuleRepositoryTuple> tuples) {
- tuples.forEach(each -> versionPersistService.persist(new
VersionNodePath(each.getPath()), each.getContent()));
+ private void persistTuple(final RuleRepositoryTuple tuple) {
+ versionPersistService.persist(new VersionNodePath(tuple.getPath()),
tuple.getContent());
}
}
diff --git
a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngine.java
b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngine.java
index bd85a17a747..5909ba3ebdf 100644
---
a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngine.java
+++
b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngine.java
@@ -17,11 +17,12 @@
package org.apache.shardingsphere.mode.node.rule.tuple;
+import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
-import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
+import
org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
import
org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
import
org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapper;
import
org.apache.shardingsphere.mode.node.path.engine.generator.NodePathGenerator;
@@ -50,35 +51,40 @@ import java.util.Optional;
/**
* YAML rule repository tuple swapper engine.
*/
-@RequiredArgsConstructor
public final class YamlRuleRepositoryTupleSwapperEngine {
- private final String databaseName;
-
- public YamlRuleRepositoryTupleSwapperEngine() {
- this(NodePathPattern.IDENTIFIER);
+ /**
+ * Swap to rule repository tuple.
+ *
+ * @param yamlGlobalRuleConfig global YAML rule configuration to be swapped
+ * @return rule repository tuple
+ */
+ public RuleRepositoryTuple swapToTuple(final YamlGlobalRuleConfiguration
yamlGlobalRuleConfig) {
+ RuleRepositoryTupleEntity entity =
yamlGlobalRuleConfig.getClass().getAnnotation(RuleRepositoryTupleEntity.class);
+ Preconditions.checkNotNull(entity);
+ Preconditions.checkArgument(entity.leaf());
+ return new RuleRepositoryTuple(NodePathGenerator.toPath(new
GlobalRuleNodePath(entity.value()), false),
YamlEngine.marshal(yamlGlobalRuleConfig));
}
/**
* Swap to rule repository tuples.
*
+ * @param databaseName database name
* @param yamlRuleConfig YAML rule configuration to be swapped
* @return rule repository tuples
*/
- public Collection<RuleRepositoryTuple> swapToTuples(final
YamlRuleConfiguration yamlRuleConfig) {
+ public Collection<RuleRepositoryTuple> swapToTuples(final String
databaseName, final YamlRuleConfiguration yamlRuleConfig) {
RuleRepositoryTupleEntity entity =
yamlRuleConfig.getClass().getAnnotation(RuleRepositoryTupleEntity.class);
if (null == entity) {
return Collections.emptyList();
}
+ Preconditions.checkArgument(!entity.leaf());
String ruleType = entity.value();
- if (entity.leaf()) {
- return Collections.singleton(new
RuleRepositoryTuple(NodePathGenerator.toPath(new GlobalRuleNodePath(ruleType),
false), YamlEngine.marshal(yamlRuleConfig)));
- }
Collection<RuleRepositoryTuple> result = new LinkedList<>();
for (Field each :
YamlRuleConfigurationFieldUtil.getFields(yamlRuleConfig.getClass())) {
boolean isAccessible = each.isAccessible();
each.setAccessible(true);
- result.addAll(swapToTuples(ruleType, yamlRuleConfig, each));
+ result.addAll(swapToTuples(databaseName, ruleType, yamlRuleConfig,
each));
each.setAccessible(isAccessible);
}
return result;
@@ -86,7 +92,7 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
@SneakyThrows(ReflectiveOperationException.class)
@SuppressWarnings("rawtypes")
- private Collection<RuleRepositoryTuple> swapToTuples(final String
ruleType, final YamlRuleConfiguration yamlRuleConfig, final Field field) {
+ private Collection<RuleRepositoryTuple> swapToTuples(final String
databaseName, final String ruleType, final YamlRuleConfiguration
yamlRuleConfig, final Field field) {
Object fieldValue = field.get(yamlRuleConfig);
if (null == fieldValue) {
return Collections.emptyList();
@@ -149,18 +155,19 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
/**
* Swap to YAML database rule configuration.
*
+ * @param databaseName database name
* @param ruleType rule type
* @param tuples rule repository tuples
* @return database rule configuration
* @throws IllegalArgumentException throw if rule configuration not found
*/
@SuppressWarnings("rawtypes")
- public YamlRuleConfiguration swapToYamlDatabaseRuleConfiguration(final
String ruleType, final Collection<RuleRepositoryTuple> tuples) {
+ public YamlRuleConfiguration swapToYamlDatabaseRuleConfiguration(final
String databaseName, final String ruleType, final
Collection<RuleRepositoryTuple> tuples) {
for (YamlRuleConfigurationSwapper each :
OrderedSPILoader.getServices(YamlRuleConfigurationSwapper.class)) {
Class<? extends YamlRuleConfiguration> yamlRuleConfigClass =
getYamlRuleConfigurationClass(each);
RuleRepositoryTupleEntity entity =
yamlRuleConfigClass.getAnnotation(RuleRepositoryTupleEntity.class);
if (null != entity && entity.value().equals(ruleType)) {
- return
swapToYamlDatabaseRuleConfiguration(yamlRuleConfigClass, tuples)
+ return swapToYamlDatabaseRuleConfiguration(databaseName,
yamlRuleConfigClass, tuples)
.orElseThrow(() -> new
IllegalArgumentException(String.format("Can not find rule configuration with
type: %s", ruleType)));
}
}
@@ -168,33 +175,35 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
}
@SneakyThrows(ReflectiveOperationException.class)
- private Optional<YamlRuleConfiguration>
swapToYamlDatabaseRuleConfiguration(final Class<? extends
YamlRuleConfiguration> toBeSwappedType, final Collection<RuleRepositoryTuple>
tuples) {
+ private Optional<YamlRuleConfiguration>
swapToYamlDatabaseRuleConfiguration(final String databaseName,
+
final Class<? extends YamlRuleConfiguration> toBeSwappedType, final
Collection<RuleRepositoryTuple> tuples) {
Collection<Field> fields =
YamlRuleConfigurationFieldUtil.getFields(toBeSwappedType);
YamlRuleConfiguration yamlRuleConfig =
toBeSwappedType.getConstructor().newInstance();
DatabaseRuleNode databaseRuleNode =
DatabaseRuleNodeGenerator.generate(toBeSwappedType);
for (RuleRepositoryTuple each : tuples) {
if (!Strings.isNullOrEmpty(each.getContent())) {
- setFieldValue(yamlRuleConfig, fields,
databaseRuleNode.getRuleType(), each);
+ setFieldValue(databaseName, yamlRuleConfig, fields,
databaseRuleNode.getRuleType(), each);
}
}
return Optional.of(yamlRuleConfig);
}
- private void setFieldValue(final YamlRuleConfiguration yamlRuleConfig,
final Collection<Field> fields, final String ruleType, final
RuleRepositoryTuple tuple) {
+ private void setFieldValue(final String databaseName, final
YamlRuleConfiguration yamlRuleConfig, final Collection<Field> fields, final
String ruleType, final RuleRepositoryTuple tuple) {
for (Field each : fields) {
boolean isAccessible = each.isAccessible();
each.setAccessible(true);
- setFieldValue(yamlRuleConfig, each, ruleType, tuple);
+ setFieldValue(databaseName, yamlRuleConfig, each, ruleType, tuple);
each.setAccessible(isAccessible);
}
}
- private void setFieldValue(final YamlRuleConfiguration yamlRuleConfig,
final Field field, final String ruleType, final RuleRepositoryTuple tuple) {
+ private void setFieldValue(final String databaseName, final
YamlRuleConfiguration yamlRuleConfig,
+ final Field field, final String ruleType, final
RuleRepositoryTuple tuple) {
String itemType =
YamlRuleConfigurationFieldUtil.getTupleItemName(field);
if (isNamedItem(field,
field.getAnnotation(RuleRepositoryTupleKeyListNameGenerator.class))) {
- setNamedItemFieldValue(yamlRuleConfig, ruleType, tuple, itemType,
field);
+ setNamedItemFieldValue(databaseName, yamlRuleConfig, ruleType,
tuple, itemType, field);
} else {
- setUniqueItemFieldValue(yamlRuleConfig, ruleType, tuple, itemType,
field);
+ setUniqueItemFieldValue(databaseName, yamlRuleConfig, ruleType,
tuple, itemType, field);
}
}
@@ -204,7 +213,8 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
@SneakyThrows(ReflectiveOperationException.class)
@SuppressWarnings({"unchecked", "rawtypes"})
- private void setNamedItemFieldValue(final YamlRuleConfiguration
yamlRuleConfig, final String ruleType, final RuleRepositoryTuple tuple, final
String itemType, final Field field) {
+ private void setNamedItemFieldValue(final String databaseName, final
YamlRuleConfiguration yamlRuleConfig,
+ final String ruleType, final
RuleRepositoryTuple tuple, final String itemType, final Field field) {
DatabaseRuleNodePath databaseRuleNodePath = new
DatabaseRuleNodePath(databaseName, ruleType, new DatabaseRuleItem(itemType,
NodePathPattern.QUALIFIED_IDENTIFIER));
Optional<String> itemValue = NodePathSearcher.find(tuple.getPath(),
new NodePathSearchCriteria(databaseRuleNodePath, false, true, 1));
if (!itemValue.isPresent()) {
@@ -228,7 +238,8 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
}
@SneakyThrows(ReflectiveOperationException.class)
- private void setUniqueItemFieldValue(final YamlRuleConfiguration
yamlRuleConfig, final String ruleType, final RuleRepositoryTuple tuple, final
String itemType, final Field field) {
+ private void setUniqueItemFieldValue(final String databaseName, final
YamlRuleConfiguration yamlRuleConfig,
+ final String ruleType, final
RuleRepositoryTuple tuple, final String itemType, final Field field) {
DatabaseRuleNodePath databaseRuleNodePath = new
DatabaseRuleNodePath(databaseName, ruleType, new DatabaseRuleItem(itemType));
if (!NodePathSearcher.isMatchedPath(tuple.getPath(), new
NodePathSearchCriteria(databaseRuleNodePath, false, true, 1))) {
return;
diff --git
a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngineTest.java
b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngineTest.java
index 1b118d97836..9ea88d2e7fb 100644
---
a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngineTest.java
+++
b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngineTest.java
@@ -26,7 +26,6 @@ import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collection;
import java.util.Collections;
import java.util.List;
@@ -38,22 +37,20 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class YamlRuleRepositoryTupleSwapperEngineTest {
@Test
- void assertSwapToTuplesWithoutTupleEntityAnnotation() {
- assertTrue(new YamlRuleRepositoryTupleSwapperEngine().swapToTuples(new
NoneYamlRuleConfiguration()).isEmpty());
+ void assertSwapToTuple() {
+ RuleRepositoryTuple actual = new
YamlRuleRepositoryTupleSwapperEngine().swapToTuple(new
LeafYamlRuleConfiguration("foo"));
+ assertThat(actual.getPath(), is("/rules/leaf"));
+ assertThat(actual.getContent(), is("value: foo" +
System.lineSeparator()));
}
@Test
- void assertSwapToTuplesWithLeafYamlRuleConfiguration() {
- Collection<RuleRepositoryTuple> actual = new
YamlRuleRepositoryTupleSwapperEngine().swapToTuples(new
LeafYamlRuleConfiguration("foo"));
- assertThat(actual.size(), is(1));
- RuleRepositoryTuple actualTuple = actual.iterator().next();
- assertThat(actualTuple.getPath(), is("/rules/leaf"));
- assertThat(actualTuple.getContent(), is("value: foo" +
System.lineSeparator()));
+ void assertSwapToTuplesWithoutTupleEntityAnnotation() {
+ assertTrue(new
YamlRuleRepositoryTupleSwapperEngine().swapToTuples("foo_db", new
NoneYamlRuleConfiguration()).isEmpty());
}
@Test
void assertSwapToTuplesWithEmptyNodeYamlRuleConfiguration() {
- assertTrue(new YamlRuleRepositoryTupleSwapperEngine().swapToTuples(new
NodeYamlRuleConfiguration()).isEmpty());
+ assertTrue(new
YamlRuleRepositoryTupleSwapperEngine().swapToTuples("foo_db", new
NodeYamlRuleConfiguration()).isEmpty());
}
@Test
@@ -71,7 +68,7 @@ class YamlRuleRepositoryTupleSwapperEngineTest {
yamlRuleConfig.setLeaf(leaf);
yamlRuleConfig.setGens(Collections.singleton("value"));
yamlRuleConfig.setGen("single_gen");
- List<RuleRepositoryTuple> actual = new ArrayList<>(new
YamlRuleRepositoryTupleSwapperEngine("foo_db").swapToTuples(yamlRuleConfig));
+ List<RuleRepositoryTuple> actual = new ArrayList<>(new
YamlRuleRepositoryTupleSwapperEngine().swapToTuples("foo_db", yamlRuleConfig));
assertThat(actual.size(), is(10));
assertThat(actual.get(0).getPath(),
is("/metadata/foo_db/rules/node/map_value/k"));
assertThat(actual.get(0).getContent(), is("value: v" +
System.lineSeparator()));
@@ -97,14 +94,14 @@ class YamlRuleRepositoryTupleSwapperEngineTest {
@Test
void assertSwapToYamlRuleConfigurationWithEmptyNodeYamlRuleConfiguration()
{
- NodeYamlRuleConfiguration actual = (NodeYamlRuleConfiguration) new
YamlRuleRepositoryTupleSwapperEngine().swapToYamlDatabaseRuleConfiguration("node",
+ NodeYamlRuleConfiguration actual = (NodeYamlRuleConfiguration) new
YamlRuleRepositoryTupleSwapperEngine().swapToYamlDatabaseRuleConfiguration("foo_db",
"node",
Collections.singleton(new
RuleRepositoryTuple("/metadata/foo_db/rules/node/string_value", "")));
assertThat(actual.getStringValue(), is(""));
}
@Test
void assertSwapToYamlRuleConfigurationWithNodeYamlRuleConfiguration() {
- NodeYamlRuleConfiguration actual = (NodeYamlRuleConfiguration) new
YamlRuleRepositoryTupleSwapperEngine("foo_db").swapToYamlDatabaseRuleConfiguration("node",
Arrays.asList(
+ NodeYamlRuleConfiguration actual = (NodeYamlRuleConfiguration) new
YamlRuleRepositoryTupleSwapperEngine().swapToYamlDatabaseRuleConfiguration("foo_db",
"node", Arrays.asList(
new
RuleRepositoryTuple("/metadata/foo_db/rules/node/map_value/k", "v"),
new
RuleRepositoryTuple("/metadata/foo_db/rules/node/map_value/k:qualified",
"k:qualified"),
new
RuleRepositoryTuple("/metadata/foo_db/rules/node/collection_value", "- !LEAF" +
System.lineSeparator() + " value: foo"),
diff --git
a/test/it/yaml/src/main/java/org/apache/shardingsphere/test/it/yaml/YamlRuleRepositoryTupleSwapperEngineIT.java
b/test/it/yaml/src/main/java/org/apache/shardingsphere/test/it/yaml/YamlRuleRepositoryTupleSwapperEngineIT.java
index fc5c884e1d1..59f6dc57faa 100644
---
a/test/it/yaml/src/main/java/org/apache/shardingsphere/test/it/yaml/YamlRuleRepositoryTupleSwapperEngineIT.java
+++
b/test/it/yaml/src/main/java/org/apache/shardingsphere/test/it/yaml/YamlRuleRepositoryTupleSwapperEngineIT.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.test.it.yaml;
import lombok.extern.slf4j.Slf4j;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import org.apache.shardingsphere.infra.yaml.config.pojo.YamlRootConfiguration;
+import
org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
import
org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
import
org.apache.shardingsphere.mode.node.rule.tuple.YamlRuleRepositoryTupleSwapperEngine;
@@ -32,11 +33,9 @@ import java.net.URL;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
-import java.util.Objects;
import java.util.stream.Collectors;
import static org.hamcrest.CoreMatchers.containsString;
@@ -51,17 +50,23 @@ public abstract class
YamlRuleRepositoryTupleSwapperEngineIT {
private final YamlRuleRepositoryTupleSwapperEngine engine;
+ private final String databaseName;
+
protected YamlRuleRepositoryTupleSwapperEngineIT(final String
yamlFileName) {
URL url =
Thread.currentThread().getContextClassLoader().getResource(yamlFileName);
assertNotNull(url);
yamlFile = new File(url.getFile());
- engine = new YamlRuleRepositoryTupleSwapperEngine("foo_db");
+ engine = new YamlRuleRepositoryTupleSwapperEngine();
+ databaseName = "foo_db";
}
@Test
void assertSwapToTuples() throws IOException {
YamlRuleConfiguration yamlRuleConfig = loadYamlRuleConfiguration();
- assertRepositoryTuples(new
ArrayList<>(engine.swapToTuples(yamlRuleConfig)), yamlRuleConfig);
+ List<RuleRepositoryTuple> tuples = yamlRuleConfig instanceof
YamlGlobalRuleConfiguration
+ ?
Collections.singletonList(engine.swapToTuple((YamlGlobalRuleConfiguration)
yamlRuleConfig))
+ : new ArrayList<>(engine.swapToTuples(databaseName,
yamlRuleConfig));
+ assertRepositoryTuples(tuples, yamlRuleConfig);
}
private YamlRuleConfiguration loadYamlRuleConfiguration() throws
IOException {
@@ -93,11 +98,10 @@ public abstract class
YamlRuleRepositoryTupleSwapperEngineIT {
private String getActualYamlContent() throws IOException {
YamlRuleConfiguration yamlRuleConfig = loadYamlRuleConfiguration();
RuleRepositoryTupleEntity entity =
yamlRuleConfig.getClass().getAnnotation(RuleRepositoryTupleEntity.class);
- String ruleType = Objects.requireNonNull(entity).value();
- Collection<RuleRepositoryTuple> tuples =
engine.swapToTuples(yamlRuleConfig);
+ String ruleType = entity.value();
YamlRuleConfiguration actualYamlRuleConfig = entity.leaf()
- ? engine.swapToYamlGlobalRuleConfiguration(ruleType,
tuples.iterator().next().getContent())
- : engine.swapToYamlDatabaseRuleConfiguration(ruleType, tuples);
+ ? engine.swapToYamlGlobalRuleConfiguration(ruleType,
engine.swapToTuple((YamlGlobalRuleConfiguration) yamlRuleConfig).getContent())
+ : engine.swapToYamlDatabaseRuleConfiguration(databaseName,
ruleType, engine.swapToTuples(databaseName, yamlRuleConfig));
YamlRootConfiguration yamlRootConfig = new YamlRootConfiguration();
yamlRootConfig.setRules(Collections.singletonList(actualYamlRuleConfig));
return YamlEngine.marshal(yamlRootConfig);
