Add ShardingConfigurationRepositoryTupleSwapperIT (#31104)

* Refactor RepositoryTupleSwapperIT's impl

* Add ShardingConfigurationRepositoryTupleSwapperIT

features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/ShardingRuleConfigurationRepositoryTupleSwapper.java

@@ -31,6 +31,7 @@
 import org.apache.shardingsphere.sharding.yaml.config.strategy.audit.YamlShardingAuditStrategyConfiguration;
 import org.apache.shardingsphere.sharding.yaml.config.strategy.keygen.YamlKeyGenerateStrategyConfiguration;
 import org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlShardingStrategyConfiguration;
+import org.apache.shardingsphere.sharding.yaml.swapper.rule.YamlShardingTableReferenceRuleConfigurationConverter;
 
 import java.util.Collection;
 import java.util.LinkedHashMap;
@@ -94,19 +95,20 @@ private void swapStrategies(final YamlShardingRuleConfiguration yamlRuleConfig,
     }
 
     private void swapTableRules(final YamlShardingRuleConfiguration yamlRuleConfig, final Collection<RepositoryTuple> repositoryTuples) {
-        for (YamlTableRuleConfiguration each : yamlRuleConfig.getTables().values()) {
-            repositoryTuples.add(new RepositoryTuple(ruleNodePath.getNamedItem(ShardingRuleNodePathProvider.TABLES).getPath(each.getLogicTable()), YamlEngine.marshal(each)));
+        for (Entry<String, YamlTableRuleConfiguration> entry : yamlRuleConfig.getTables().entrySet()) {
+            repositoryTuples.add(new RepositoryTuple(ruleNodePath.getNamedItem(ShardingRuleNodePathProvider.TABLES).getPath(entry.getKey()), YamlEngine.marshal(entry.getValue())));
         }
-        for (YamlShardingAutoTableRuleConfiguration each : yamlRuleConfig.getAutoTables().values()) {
-            repositoryTuples.add(new RepositoryTuple(ruleNodePath.getNamedItem(ShardingRuleNodePathProvider.AUTO_TABLES).getPath(each.getLogicTable()), YamlEngine.marshal(each)));
+        for (Entry<String, YamlShardingAutoTableRuleConfiguration> entry : yamlRuleConfig.getAutoTables().entrySet()) {
+            repositoryTuples.add(
+                    new RepositoryTuple(ruleNodePath.getNamedItem(ShardingRuleNodePathProvider.AUTO_TABLES).getPath(entry.getKey()), YamlEngine.marshal(entry.getValue())));
         }
         for (String each : yamlRuleConfig.getBindingTables()) {
             repositoryTuples.add(new RepositoryTuple(ruleNodePath.getNamedItem(ShardingRuleNodePathProvider.BINDING_TABLES).getPath(getBindingGroupName(each)), each));
         }
     }
 
     private String getBindingGroupName(final String bindingGroup) {
-        return bindingGroup.contains(":") ? bindingGroup.substring(0, bindingGroup.indexOf(":")) : bindingGroup;
+        return YamlShardingTableReferenceRuleConfigurationConverter.convertToObject(bindingGroup).getName();
     }
 
     @Override

features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/it/ShardingConfigurationRepositoryTupleSwapperIT.java

@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.sharding.it;
+
+import org.apache.shardingsphere.infra.util.yaml.datanode.RepositoryTuple;
+import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
+import org.apache.shardingsphere.sharding.yaml.config.YamlShardingRuleConfiguration;
+import org.apache.shardingsphere.sharding.yaml.swapper.ShardingRuleConfigurationRepositoryTupleSwapper;
+import org.apache.shardingsphere.test.it.yaml.RepositoryTupleSwapperIT;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+class ShardingConfigurationRepositoryTupleSwapperIT extends RepositoryTupleSwapperIT {
+
+    ShardingConfigurationRepositoryTupleSwapperIT() {
+        super("yaml/sharding-rule.yaml", new ShardingRuleConfigurationRepositoryTupleSwapper(), false);
+    }
+
+    @Override
+    protected void assertRepositoryTuples(final List<RepositoryTuple> actualRepositoryTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+        assertThat(actualRepositoryTuples.size(), is(19));
+        assertRepositoryTuple(actualRepositoryTuples.get(0),
+                "algorithms/core_standard_fixture", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("core_standard_fixture"));
+        assertRepositoryTuple(actualRepositoryTuples.get(1),
+                "algorithms/core_complex_fixture", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("core_complex_fixture"));
+        assertRepositoryTuple(actualRepositoryTuples.get(2),
+                "algorithms/core_hint_fixture", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("core_hint_fixture"));
+        assertRepositoryTuple(actualRepositoryTuples.get(3),
+                "algorithms/database_inline", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("database_inline"));
+        assertRepositoryTuple(actualRepositoryTuples.get(4),
+                "algorithms/table_inline", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("table_inline"));
+        assertRepositoryTuple(actualRepositoryTuples.get(5), "key_generators/snowflake", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getKeyGenerators().get("snowflake"));
+        assertRepositoryTuple(actualRepositoryTuples.get(6),
+                "auditors/sharding_key_required_auditor", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getAuditors().get("sharding_key_required_auditor"));
+        assertRepositoryTuple(actualRepositoryTuples.get(7),
+                "default_strategies/default_database_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultDatabaseStrategy());
+        assertRepositoryTuple(actualRepositoryTuples.get(8),
+                "default_strategies/default_table_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultTableStrategy());
+        assertRepositoryTuple(actualRepositoryTuples.get(9),
+                "default_strategies/default_key_generate_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultKeyGenerateStrategy());
+        assertRepositoryTuple(actualRepositoryTuples.get(10),
+                "default_strategies/default_audit_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultAuditStrategy());
+        assertRepositoryTuple(actualRepositoryTuples.get(11),
+                "default_strategies/default_sharding_column", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultShardingColumn());
+        assertRepositoryTuple(actualRepositoryTuples.get(12),
+                "sharding_cache", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingCache());
+        assertRepositoryTuple(actualRepositoryTuples.get(13),
+                "tables/t_user", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_user"));
+        assertRepositoryTuple(actualRepositoryTuples.get(14),
+                "tables/t_stock", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_stock"));
+        assertRepositoryTuple(actualRepositoryTuples.get(15),
+                "tables/t_order", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_order"));
+        assertRepositoryTuple(actualRepositoryTuples.get(16),
+                "tables/t_order_item", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_order_item"));
+        assertRepositoryTuple(actualRepositoryTuples.get(17),
+                "binding_tables" + actualRepositoryTuples.get(17).getKey().substring(actualRepositoryTuples.get(17).getKey().indexOf("/")),
+                new ArrayList<>(((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getBindingTables()).get(0));
+        assertRepositoryTuple(actualRepositoryTuples.get(18), "binding_tables/foo", new ArrayList<>(((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getBindingTables()).get(1));
+    }
+}

features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/yaml/ShardingRuleConfigurationYamlIT.java → features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/it/ShardingRuleConfigurationYamlIT.java

@@ -15,15 +15,15 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sharding.yaml;
+package org.apache.shardingsphere.sharding.it;
 
-import org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
 import org.apache.shardingsphere.infra.yaml.config.pojo.YamlRootConfiguration;
 import org.apache.shardingsphere.sharding.yaml.config.YamlShardingRuleConfiguration;
 import org.apache.shardingsphere.sharding.yaml.config.cache.YamlShardingCacheConfiguration;
 import org.apache.shardingsphere.sharding.yaml.config.cache.YamlShardingCacheOptionsConfiguration;
 import org.apache.shardingsphere.test.it.yaml.YamlRuleConfigurationIT;
 
+import java.util.ArrayList;
 import java.util.Optional;
 
 import static org.hamcrest.CoreMatchers.is;
@@ -38,7 +38,6 @@ class ShardingRuleConfigurationYamlIT extends YamlRuleConfigurationIT {
 
     @Override
     protected void assertYamlRootConfiguration(final YamlRootConfiguration actual) {
-        assertDataSourceMap(actual);
         Optional<YamlShardingRuleConfiguration> shardingRuleConfig = actual.getRules().stream()
                 .filter(each -> each instanceof YamlShardingRuleConfiguration).findFirst().map(optional -> (YamlShardingRuleConfiguration) optional);
         assertTrue(shardingRuleConfig.isPresent());
@@ -49,17 +48,9 @@ protected void assertYamlRootConfiguration(final YamlRootConfiguration actual) {
         assertTOrderItem(shardingRuleConfig.get());
         assertBindingTable(shardingRuleConfig.get());
         assertShardingCache(shardingRuleConfig.get());
-        assertProps(actual);
         assertThat(shardingRuleConfig.get().getDefaultShardingColumn(), is("order_id"));
     }
 
-    private void assertDataSourceMap(final YamlRootConfiguration actual) {
-        assertThat(actual.getDataSources().size(), is(3));
-        assertTrue(actual.getDataSources().containsKey("ds_0"));
-        assertTrue(actual.getDataSources().containsKey("ds_1"));
-        assertTrue(actual.getDataSources().containsKey("default_ds"));
-    }
-
     private void assertTUser(final YamlShardingRuleConfiguration actual) {
         assertThat(actual.getTables().get("t_user").getActualDataNodes(), is("ds_${0..1}.t_user_${0..15}"));
         assertThat(actual.getTables().get("t_user").getDatabaseStrategy().getComplex().getShardingColumns(), is("region_id, user_id"));
@@ -90,8 +81,9 @@ private void assertTOrderItem(final YamlShardingRuleConfiguration actual) {
     }
 
     private void assertBindingTable(final YamlShardingRuleConfiguration actual) {
-        assertThat(actual.getBindingTables().size(), is(1));
-        assertThat(actual.getBindingTables().iterator().next(), is("t_order, t_order_item"));
+        assertThat(actual.getBindingTables().size(), is(2));
+        assertThat(new ArrayList<>(actual.getBindingTables()).get(0), is("t_order, t_order_item"));
+        assertThat(new ArrayList<>(actual.getBindingTables()).get(1), is("foo:t_order, t_order_item"));
     }
 
     private void assertShardingCache(final YamlShardingRuleConfiguration actual) {
@@ -102,9 +94,4 @@ private void assertShardingCache(final YamlShardingRuleConfiguration actual) {
         assertThat(actualRouteCacheConfig.getMaximumSize(), is(262144));
         assertTrue(actualRouteCacheConfig.isSoftValues());
     }
-
-    private void assertProps(final YamlRootConfiguration actual) {
-        assertThat(actual.getProps().size(), is(1));
-        assertTrue((boolean) actual.getProps().get(ConfigurationPropertyKey.SQL_SHOW.getKey()));
-    }
 }