For #647: add YamlShardingRuleConfiguration test case

sharding-core/src/main/java/io/shardingjdbc/core/yaml/sharding/YamlShardingRuleConfiguration.java

@@ -29,6 +29,7 @@ import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Properties;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -60,14 +61,14 @@ public class YamlShardingRuleConfiguration {
     private Properties props = new Properties();
     
     /**
-     * Get sharding rule configuration from yaml.
+     * Get sharding rule configuration.
      *
-     * @return sharding rule configuration from yaml
+     * @return sharding rule configuration
      */
     public ShardingRuleConfiguration getShardingRuleConfiguration() {
         ShardingRuleConfiguration result = new ShardingRuleConfiguration();
         result.setDefaultDataSourceName(defaultDataSourceName);
-        for (Map.Entry<String, YamlTableRuleConfiguration> entry : tables.entrySet()) {
+        for (Entry<String, YamlTableRuleConfiguration> entry : tables.entrySet()) {
             YamlTableRuleConfiguration tableRuleConfig = entry.getValue();
             tableRuleConfig.setLogicTable(entry.getKey());
             result.getTableRuleConfigs().add(tableRuleConfig.build());
@@ -81,13 +82,13 @@ public class YamlShardingRuleConfiguration {
         }
         result.setDefaultKeyGeneratorClass(defaultKeyGeneratorClass);
         Collection<MasterSlaveRuleConfiguration> masterSlaveRuleConfigs = new LinkedList<>();
-        for (Map.Entry<String, YamlMasterSlaveRuleConfiguration> each : masterSlaveRules.entrySet()) {
+        for (Entry<String, YamlMasterSlaveRuleConfiguration> entry : masterSlaveRules.entrySet()) {
             MasterSlaveRuleConfiguration msRuleConfig = new MasterSlaveRuleConfiguration();
-            msRuleConfig.setName(each.getKey());
-            msRuleConfig.setMasterDataSourceName(each.getValue().getMasterDataSourceName());
-            msRuleConfig.setSlaveDataSourceNames(each.getValue().getSlaveDataSourceNames());
-            msRuleConfig.setLoadBalanceAlgorithmType(each.getValue().getLoadBalanceAlgorithmType());
-            msRuleConfig.setLoadBalanceAlgorithmClassName(each.getValue().getLoadBalanceAlgorithmClassName());
+            msRuleConfig.setName(entry.getKey());
+            msRuleConfig.setMasterDataSourceName(entry.getValue().getMasterDataSourceName());
+            msRuleConfig.setSlaveDataSourceNames(entry.getValue().getSlaveDataSourceNames());
+            msRuleConfig.setLoadBalanceAlgorithmType(entry.getValue().getLoadBalanceAlgorithmType());
+            msRuleConfig.setLoadBalanceAlgorithmClassName(entry.getValue().getLoadBalanceAlgorithmClassName());
             masterSlaveRuleConfigs.add(msRuleConfig);
         }
         result.setMasterSlaveRuleConfigs(masterSlaveRuleConfigs);

sharding-core/src/main/java/io/shardingjdbc/core/yaml/sharding/YamlTableRuleConfiguration.java

@@ -55,7 +55,6 @@ public class YamlTableRuleConfiguration {
         TableRuleConfiguration result = new TableRuleConfiguration();
         result.setLogicTable(logicTable);
         result.setActualDataNodes(actualDataNodes);
-        result.setLogicTable(logicTable);
         if (null != databaseStrategy) {
             result.setDatabaseShardingStrategyConfig(databaseStrategy.build());
         }

sharding-core/src/test/java/io/shardingjdbc/core/yaml/AllYamlTests.java

@@ -20,6 +20,9 @@ package io.shardingjdbc.core.yaml;
 import io.shardingjdbc.core.yaml.masterslave.YamlMasterSlaveConfigurationTest;
 import io.shardingjdbc.core.yaml.masterslave.YamlMasterSlaveRuleConfigurationTest;
 import io.shardingjdbc.core.yaml.sharding.YamlShardingConfigurationTest;
+import io.shardingjdbc.core.yaml.sharding.YamlShardingRuleConfigurationTest;
+import io.shardingjdbc.core.yaml.sharding.YamlShardingStrategyConfigurationTest;
+import io.shardingjdbc.core.yaml.sharding.YamlTableRuleConfigurationTest;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
 import org.junit.runners.Suite.SuiteClasses;
@@ -27,6 +30,9 @@ import org.junit.runners.Suite.SuiteClasses;
 @RunWith(Suite.class)
 @SuiteClasses({
         YamlShardingConfigurationTest.class, 
+        YamlShardingRuleConfigurationTest.class, 
+        YamlTableRuleConfigurationTest.class, 
+        YamlShardingStrategyConfigurationTest.class, 
         YamlMasterSlaveConfigurationTest.class, 
         YamlMasterSlaveRuleConfigurationTest.class
 })

sharding-core/src/test/java/io/shardingjdbc/core/yaml/masterslave/YamlMasterSlaveRuleConfigurationTest.java

@@ -32,8 +32,7 @@ public final class YamlMasterSlaveRuleConfigurationTest {
     
     @Test
     public void assertGetMasterSlaveRuleConfiguration() {
-        MasterSlaveRuleConfiguration actual = createYamlMasterSlaveRuleConfig().getMasterSlaveRuleConfiguration();
-        assertMasterSlaveRuleConfig(actual);
+        assertMasterSlaveRuleConfig(createYamlMasterSlaveRuleConfig().getMasterSlaveRuleConfiguration());
     }
         
     private YamlMasterSlaveRuleConfiguration createYamlMasterSlaveRuleConfig() {

sharding-core/src/test/java/io/shardingjdbc/core/yaml/sharding/YamlShardingConfigurationTest.java

@@ -104,6 +104,7 @@ public final class YamlShardingConfigurationTest {
         assertThat(actual.getShardingRule().getTables().get("t_order").getTableStrategy().getInline().getAlgorithmExpression(), is("t_order_${order_id % 2}"));
         assertThat(actual.getShardingRule().getTables().get("t_order").getKeyGeneratorColumnName(), is("order_id"));
         assertThat(actual.getShardingRule().getTables().get("t_order").getKeyGeneratorClass(), is("io.shardingjdbc.core.keygen.DefaultKeyGenerator"));
+        assertThat(actual.getShardingRule().getTables().get("t_order").getLogicIndex(), is("order_index"));
     }
     
     private void assertTOrderItem(final YamlShardingConfiguration actual) {

sharding-core/src/test/java/io/shardingjdbc/core/yaml/sharding/YamlShardingRuleConfigurationTest.java

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed 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.
+ * </p>
+ */
+
+package io.shardingjdbc.core.yaml.sharding;
+
+import io.shardingjdbc.core.api.algorithm.masterslave.MasterSlaveLoadBalanceAlgorithmType;
+import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
+import io.shardingjdbc.core.api.config.ShardingRuleConfiguration;
+import io.shardingjdbc.core.api.config.TableRuleConfiguration;
+import io.shardingjdbc.core.api.config.strategy.NoneShardingStrategyConfiguration;
+import io.shardingjdbc.core.keygen.DefaultKeyGenerator;
+import io.shardingjdbc.core.yaml.masterslave.YamlMasterSlaveRuleConfiguration;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlNoneShardingStrategyConfiguration;
+import org.hamcrest.CoreMatchers;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThat;
+
+public final class YamlShardingRuleConfigurationTest {
+    
+    @Test
+    public void assertGetShardingRuleConfigurationWithoutDefaultStrategy() {
+        ShardingRuleConfiguration actual = createYamlShardingRuleConfigWithoutDefaultStrategy().getShardingRuleConfiguration();
+        assertShardingRuleConfig(actual);
+        assertWithoutDefaultStrategy(actual);
+    }
+    
+    @Test
+    public void assertGetShardingRuleConfigurationWithDefaultStrategy() {
+        ShardingRuleConfiguration actual = createYamlShardingRuleConfigWithDefaultStrategy().getShardingRuleConfiguration();
+        assertShardingRuleConfig(actual);
+        assertWithDefaultStrategy(actual);
+    }
+    
+    private YamlShardingRuleConfiguration createYamlShardingRuleConfigWithoutDefaultStrategy() {
+        YamlShardingRuleConfiguration result = new YamlShardingRuleConfiguration();
+        result.setDefaultDataSourceName("default_ds");
+        result.getTables().put("t_order", new YamlTableRuleConfiguration());
+        result.getTables().put("t_order_item", new YamlTableRuleConfiguration());
+        result.getBindingTables().add("t_order, t_order_item");
+        result.setDefaultKeyGeneratorClass(DefaultKeyGenerator.class.getName());
+        result.getMasterSlaveRules().put("master_slave_ds", createYamlMasterSlaveRuleConfig());
+        return result;
+    }
+    
+    private YamlShardingRuleConfiguration createYamlShardingRuleConfigWithDefaultStrategy() {
+        YamlShardingRuleConfiguration result = createYamlShardingRuleConfigWithoutDefaultStrategy();
+        YamlShardingStrategyConfiguration yamlShardingStrategyConfig = new YamlShardingStrategyConfiguration();
+        yamlShardingStrategyConfig.setNone(new YamlNoneShardingStrategyConfiguration());
+        result.setDefaultDatabaseStrategy(yamlShardingStrategyConfig);
+        result.setDefaultTableStrategy(yamlShardingStrategyConfig);
+        return result;
+    }
+    
+    private YamlMasterSlaveRuleConfiguration createYamlMasterSlaveRuleConfig() {
+        YamlMasterSlaveRuleConfiguration result = new YamlMasterSlaveRuleConfiguration();
+        result.setName("master_slave_ds");
+        result.setMasterDataSourceName("master_ds");
+        result.setSlaveDataSourceNames(Arrays.asList("slave_ds_0", "slave_ds_1"));
+        result.setLoadBalanceAlgorithmType(MasterSlaveLoadBalanceAlgorithmType.ROUND_ROBIN);
+        result.setLoadBalanceAlgorithmClassName("TestLoadBalanceAlgorithmClassName");
+        return result;
+    }
+    
+    private void assertShardingRuleConfig(final ShardingRuleConfiguration actual) {
+        assertThat(actual.getDefaultDataSourceName(), is("default_ds"));
+        assertThat(actual.getTableRuleConfigs().size(), is(2));
+        Iterator<TableRuleConfiguration> tableRuleConfigIterator = actual.getTableRuleConfigs().iterator();
+        assertThat(tableRuleConfigIterator.next().getLogicTable(), is("t_order"));
+        assertThat(tableRuleConfigIterator.next().getLogicTable(), is("t_order_item"));
+        assertThat(actual.getBindingTableGroups().size(), is(1));
+        assertThat(actual.getBindingTableGroups().iterator().next(), is("t_order, t_order_item"));
+        assertThat(actual.getDefaultKeyGeneratorClass(), is(DefaultKeyGenerator.class.getName()));
+        assertMasterSlaveRuleConfig(actual.getMasterSlaveRuleConfigs().iterator().next());
+    }
+    
+    private void assertMasterSlaveRuleConfig(final MasterSlaveRuleConfiguration actual) {
+        assertThat(actual.getName(), is("master_slave_ds"));
+        assertThat(actual.getMasterDataSourceName(), is("master_ds"));
+        assertThat(actual.getSlaveDataSourceNames(), CoreMatchers.<Collection<String>>is(Arrays.asList("slave_ds_0", "slave_ds_1")));
+        assertThat(actual.getLoadBalanceAlgorithmType(), is(MasterSlaveLoadBalanceAlgorithmType.ROUND_ROBIN));
+        assertThat(actual.getLoadBalanceAlgorithmClassName(), is("TestLoadBalanceAlgorithmClassName"));
+    }
+    
+    private void assertWithoutDefaultStrategy(final ShardingRuleConfiguration actual) {
+        assertNull(actual.getDefaultDatabaseShardingStrategyConfig());
+        assertNull(actual.getDefaultTableShardingStrategyConfig());
+    }
+    
+    private void assertWithDefaultStrategy(final ShardingRuleConfiguration actual) {
+        assertThat(actual.getDefaultDatabaseShardingStrategyConfig(), instanceOf(NoneShardingStrategyConfiguration.class));
+        assertThat(actual.getDefaultTableShardingStrategyConfig(), instanceOf(NoneShardingStrategyConfiguration.class));
+    }
+}

sharding-core/src/test/java/io/shardingjdbc/core/yaml/sharding/YamlShardingStrategyConfigurationTest.java

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed 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.
+ * </p>
+ */
+
+package io.shardingjdbc.core.yaml.sharding;
+
+import io.shardingjdbc.core.api.config.strategy.ComplexShardingStrategyConfiguration;
+import io.shardingjdbc.core.api.config.strategy.HintShardingStrategyConfiguration;
+import io.shardingjdbc.core.api.config.strategy.InlineShardingStrategyConfiguration;
+import io.shardingjdbc.core.api.config.strategy.NoneShardingStrategyConfiguration;
+import io.shardingjdbc.core.api.config.strategy.StandardShardingStrategyConfiguration;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlComplexShardingStrategyConfiguration;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlHintShardingStrategyConfiguration;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlInlineShardingStrategyConfiguration;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlNoneShardingStrategyConfiguration;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlStandardShardingStrategyConfiguration;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThat;
+
+public final class YamlShardingStrategyConfigurationTest {
+    
+    @Test
+    public void assertBuildWithStandard() {
+        assertStandardShardingStrategyConfig((StandardShardingStrategyConfiguration) createStandardShardingStrategyConfig().build());
+    }
+    
+    private YamlShardingStrategyConfiguration createStandardShardingStrategyConfig() {
+        YamlStandardShardingStrategyConfiguration standardShardingStrategyConfig = new YamlStandardShardingStrategyConfiguration();
+        standardShardingStrategyConfig.setShardingColumn("order_id");
+        standardShardingStrategyConfig.setPreciseAlgorithmClassName("TestPreciseAlgorithmClass");
+        standardShardingStrategyConfig.setRangeAlgorithmClassName("TestRangeAlgorithmClass");
+        YamlShardingStrategyConfiguration result = new YamlShardingStrategyConfiguration();
+        result.setStandard(standardShardingStrategyConfig);
+        return result;
+    }
+    
+    private void assertStandardShardingStrategyConfig(final StandardShardingStrategyConfiguration actual) {
+        assertThat(actual.getShardingColumn(), is("order_id"));
+        assertThat(actual.getPreciseAlgorithmClassName(), is("TestPreciseAlgorithmClass"));
+        assertThat(actual.getRangeAlgorithmClassName(), is("TestRangeAlgorithmClass"));
+    }
+    
+    @Test
+    public void assertBuildWithComplex() {
+        assertComplexShardingStrategyConfig((ComplexShardingStrategyConfiguration) createComplexShardingStrategyConfig().build());
+    }
+    
+    private YamlShardingStrategyConfiguration createComplexShardingStrategyConfig() {
+        YamlComplexShardingStrategyConfiguration complexShardingStrategyConfig = new YamlComplexShardingStrategyConfiguration();
+        complexShardingStrategyConfig.setShardingColumns("user_id, order_id");
+        complexShardingStrategyConfig.setAlgorithmClassName("TestAlgorithmClass");
+        YamlShardingStrategyConfiguration result = new YamlShardingStrategyConfiguration();
+        result.setComplex(complexShardingStrategyConfig);
+        return result;
+    }
+    
+    private void assertComplexShardingStrategyConfig(final ComplexShardingStrategyConfiguration actual) {
+        assertThat(actual.getShardingColumns(), is("user_id, order_id"));
+        assertThat(actual.getAlgorithmClassName(), is("TestAlgorithmClass"));
+    }
+    
+    @Test
+    public void assertBuildWithHint() {
+        assertHintShardingStrategyConfig((HintShardingStrategyConfiguration) createHintShardingStrategyConfig().build());
+    }
+    
+    private YamlShardingStrategyConfiguration createHintShardingStrategyConfig() {
+        YamlHintShardingStrategyConfiguration hintShardingStrategyConfig = new YamlHintShardingStrategyConfiguration();
+        hintShardingStrategyConfig.setAlgorithmClassName("TestAlgorithmClass");
+        YamlShardingStrategyConfiguration result = new YamlShardingStrategyConfiguration();
+        result.setHint(hintShardingStrategyConfig);
+        return result;
+    }
+    
+    private void assertHintShardingStrategyConfig(final HintShardingStrategyConfiguration actual) {
+        assertThat(actual.getAlgorithmClassName(), is("TestAlgorithmClass"));
+    }
+    
+    @Test
+    public void assertBuildWithInline() {
+        assertInlineShardingStrategyConfig((InlineShardingStrategyConfiguration) createInlineShardingStrategyConfig().build());
+    }
+    
+    private YamlShardingStrategyConfiguration createInlineShardingStrategyConfig() {
+        YamlInlineShardingStrategyConfiguration inlineShardingStrategyConfig = new YamlInlineShardingStrategyConfiguration();
+        inlineShardingStrategyConfig.setShardingColumn("order_id");
+        inlineShardingStrategyConfig.setAlgorithmExpression("t_order_${order_id % 2}");
+        YamlShardingStrategyConfiguration result = new YamlShardingStrategyConfiguration();
+        result.setInline(inlineShardingStrategyConfig);
+        return result;
+    }
+    
+    private void assertInlineShardingStrategyConfig(final InlineShardingStrategyConfiguration actual) {
+        assertThat(actual.getShardingColumn(), is("order_id"));
+        assertThat(actual.getAlgorithmExpression(), is("t_order_${order_id % 2}"));
+    }
+    
+    @Test
+    public void assertBuildWithNone() {
+        assertNoneShardingStrategyConfig((NoneShardingStrategyConfiguration) createNoneShardingStrategyConfig().build());
+    }
+    
+    private YamlShardingStrategyConfiguration createNoneShardingStrategyConfig() {
+        YamlNoneShardingStrategyConfiguration noneShardingStrategyConfig = new YamlNoneShardingStrategyConfiguration();
+        YamlShardingStrategyConfiguration result = new YamlShardingStrategyConfiguration();
+        result.setNone(noneShardingStrategyConfig);
+        return result;
+    }
+    
+    private void assertNoneShardingStrategyConfig(final NoneShardingStrategyConfiguration actual) {
+        assertThat(actual, instanceOf(NoneShardingStrategyConfiguration.class));
+    }
+    
+    @Test
+    public void assertBuildWithNull() {
+        assertNull(new YamlShardingStrategyConfiguration().build());
+    }
+    
+    @Test(expected = IllegalArgumentException.class)
+    public void assertBuildWithMultipleSHardingStrategies() {
+        YamlShardingStrategyConfiguration actual = new YamlShardingStrategyConfiguration();
+        actual.setStandard(new YamlStandardShardingStrategyConfiguration());
+        actual.setComplex(new YamlComplexShardingStrategyConfiguration());
+        actual.build();
+    }
+}

sharding-core/src/test/java/io/shardingjdbc/core/yaml/sharding/YamlTableRuleConfigurationTest.java

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed 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.
+ * </p>
+ */
+
+package io.shardingjdbc.core.yaml.sharding;
+
+import io.shardingjdbc.core.api.config.TableRuleConfiguration;
+import io.shardingjdbc.core.api.config.strategy.NoneShardingStrategyConfiguration;
+import io.shardingjdbc.core.keygen.DefaultKeyGenerator;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlNoneShardingStrategyConfiguration;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThat;
+
+public final class YamlTableRuleConfigurationTest {
+    
+    @Test(expected = NullPointerException.class)
+    public void assertBuildWithoutLogicTable() {
+        new YamlTableRuleConfiguration().build();
+    }
+    
+    @Test
+    public void assertBuildWithoutShardingStrategy() {
+        TableRuleConfiguration actual = createYamlTableRuleConfig().build();
+        assertTableRuleConfig(actual);
+        assertWithoutShardingStrategy(actual);
+    }
+    
+    @Test
+    public void assertBuildWithShardingStrategy() {
+        TableRuleConfiguration actual = createYamlTableRuleConfigWithShardingStrategy().build();
+        assertTableRuleConfig(actual);
+        assertWithShardingStrategy(actual);
+    }
+    
+    private YamlTableRuleConfiguration createYamlTableRuleConfig() {
+        YamlTableRuleConfiguration result = new YamlTableRuleConfiguration();
+        result.setLogicTable("t_order");
+        result.setActualDataNodes("ds_${0..1}.t_order_${0..1}");
+        result.setKeyGeneratorColumnName("order_id");
+        result.setKeyGeneratorClass(DefaultKeyGenerator.class.getName());
+        result.setLogicIndex("order_index");
+        return result;
+    }
+    
+    private YamlTableRuleConfiguration createYamlTableRuleConfigWithShardingStrategy() {
+        YamlTableRuleConfiguration result = createYamlTableRuleConfig();
+        YamlShardingStrategyConfiguration yamlShardingStrategyConfig = new YamlShardingStrategyConfiguration();
+        yamlShardingStrategyConfig.setNone(new YamlNoneShardingStrategyConfiguration());
+        result.setDatabaseStrategy(yamlShardingStrategyConfig);
+        result.setTableStrategy(yamlShardingStrategyConfig);
+        return result;
+    }
+    
+    private void assertTableRuleConfig(final TableRuleConfiguration actual) {
+        assertThat(actual.getLogicTable(), is("t_order"));
+        assertThat(actual.getActualDataNodes(), is("ds_${0..1}.t_order_${0..1}"));
+        assertThat(actual.getKeyGeneratorColumnName(), is("order_id"));
+        assertThat(actual.getKeyGeneratorClass(), is(DefaultKeyGenerator.class.getName()));
+        assertThat(actual.getLogicIndex(), is("order_index"));
+    }
+    
+    private void assertWithoutShardingStrategy(final TableRuleConfiguration actual) {
+        assertNull(actual.getDatabaseShardingStrategyConfig());
+        assertNull(actual.getTableShardingStrategyConfig());
+    }
+    
+    private void assertWithShardingStrategy(final TableRuleConfiguration actual) {
+        assertThat(actual.getDatabaseShardingStrategyConfig(), instanceOf(NoneShardingStrategyConfiguration.class));
+        assertThat(actual.getTableShardingStrategyConfig(), instanceOf(NoneShardingStrategyConfiguration.class));
+    }
+}

sharding-core/src/test/resources/yaml/sharding-rule.yaml

@@ -63,6 +63,7 @@ shardingRule:
           algorithmExpression: t_order_${order_id % 2}
       keyGeneratorColumnName: order_id
       keyGeneratorClass: io.shardingjdbc.core.keygen.DefaultKeyGenerator
+      logicIndex: order_index
     t_order_item:
       actualDataNodes: ds_${0..1}.t_order_item_${0..1}
       tableStrategy: