refactor config common test case

sharding-jdbc-config-parent/sharding-jdbc-config-common/src/main/java/com/dangdang/ddframe/rdb/sharding/config/common/api/ShardingRuleBuilder.java

@@ -117,8 +117,8 @@ public final class ShardingRuleBuilder {
     private Collection<BindingTableRule> buildBindingTableRules(final Collection<TableRule> tableRules) {
         Collection<BindingTableRule> result = new ArrayList<>(shardingRuleConfig.getBindingTables().size());
         for (BindingTableRuleConfig each : shardingRuleConfig.getBindingTables()) {
-            result.add(new BindingTableRule(Lists.transform(new InlineParser(each.getTableNames()).split(), new Function<String, TableRule>() {    
-            
+            result.add(new BindingTableRule(Lists.transform(new InlineParser(each.getTableNames()).split(), new Function<String, TableRule>() {
+                
                 @Override
                 public TableRule apply(final String input) {
                     return findTableRuleByLogicTableName(tableRules, input);
@@ -134,7 +134,7 @@ public final class ShardingRuleBuilder {
                 return each;
             }
         }
-        throw new IllegalArgumentException("Sharding JDBC: Binding table %s is not an available Table rule");
+        throw new IllegalArgumentException(String.format("Sharding JDBC: Binding table `%s` is not an available Table rule", logicTableName));
     }
     
     private <T extends ShardingStrategy> T buildShardingStrategy(final StrategyConfig config, final Class<T> returnClass) {

sharding-jdbc-config-parent/sharding-jdbc-config-common/src/test/java/com/dangdang/ddframe/rdb/sharding/config/common/AllTests.java

@@ -27,11 +27,11 @@ import org.junit.runners.Suite;
 
 @RunWith(Suite.class)
 @Suite.SuiteClasses({
-        ShardingRuleBuilderTest.class, 
-        ClosureDatabaseShardingAlgorithmTest.class,
-        ClosureTableShardingAlgorithmTest.class,
-        ShardingValueWrapperTest.class, 
-        InlineParserTest.class
+    ShardingRuleBuilderTest.class, 
+    ClosureDatabaseShardingAlgorithmTest.class, 
+    ClosureTableShardingAlgorithmTest.class, 
+    ShardingValueWrapperTest.class, 
+    InlineParserTest.class
     })
 public class AllTests {
 }

sharding-jdbc-config-parent/sharding-jdbc-config-common/src/test/java/com/dangdang/ddframe/rdb/sharding/config/common/api/ShardingRuleBuilderTest.java

@@ -17,96 +17,166 @@
 
 package com.dangdang.ddframe.rdb.sharding.config.common.api;
 
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-import javax.sql.DataSource;
-
-import com.dangdang.ddframe.rdb.sharding.api.rule.DynamicDataNode;
+import com.dangdang.ddframe.rdb.sharding.api.rule.BindingTableRule;
+import com.dangdang.ddframe.rdb.sharding.api.rule.DataNode;
 import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
 import com.dangdang.ddframe.rdb.sharding.api.rule.TableRule;
+import com.dangdang.ddframe.rdb.sharding.config.common.api.config.BindingTableRuleConfig;
 import com.dangdang.ddframe.rdb.sharding.config.common.api.config.ShardingRuleConfig;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.dbcp.BasicDataSource;
+import com.dangdang.ddframe.rdb.sharding.config.common.api.config.StrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.config.common.api.config.TableRuleConfig;
+import com.dangdang.ddframe.rdb.sharding.config.common.internal.fixture.MultiAlgorithm;
+import com.dangdang.ddframe.rdb.sharding.config.common.internal.fixture.SingleAlgorithm;
+import com.google.common.base.Joiner;
 import org.junit.Test;
-import org.yaml.snakeyaml.Yaml;
-import org.yaml.snakeyaml.constructor.Constructor;
 
-import static org.hamcrest.CoreMatchers.hasItems;
+import javax.sql.DataSource;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.core.IsCollectionContaining.hasItem;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-@Slf4j
-public class ShardingRuleBuilderTest {
+public final class ShardingRuleBuilderTest {
     
-    @Test
-    public void testAll() {
-        Yaml yaml = new Yaml(new Constructor(ShardingRuleConfig.class));
-        ShardingRuleConfig config = (ShardingRuleConfig) yaml.load(ShardingRuleBuilderTest.class.getResourceAsStream("/config/config-all.yaml"));
-        ShardingRule shardingRule = new ShardingRuleBuilder("config-all.yaml", config).build();
-        assertThat(shardingRule.getTableRules().size(), is(3));
-        assertThat(shardingRule.getBindingTableRules().size(), is(1));
-        assertThat(Arrays.asList(shardingRule.getTableRules().toArray()), hasItems(shardingRule.getBindingTableRules().iterator().next().getTableRules().toArray()));
-        assertThat(shardingRule.getDataSourceRule().getDefaultDataSourceName(), is("db0"));
+    @Test(expected = IllegalArgumentException.class)
+    public void assertBuildFailureWhenDataSourceIsEmpty() {
+        new ShardingRuleBuilder(new ShardingRuleConfig()).build();
     }
     
-    @Test
-    public void testMin() {
-        Yaml yaml = new Yaml(new Constructor(ShardingRuleConfig.class));
-        Map<String, DataSource> dsMap = new HashMap<>();
-        dsMap.put("ds", new BasicDataSource());
-        ShardingRuleConfig config = (ShardingRuleConfig) yaml.load(ShardingRuleBuilderTest.class.getResourceAsStream("/config/config-min.yaml"));
-        ShardingRule shardingRule = new ShardingRuleBuilder("config-min.yaml", dsMap, config).build();
-        assertThat(shardingRule.getTableRules().size(), is(1));
+    @Test(expected = IllegalArgumentException.class)
+    public void assertBuildFailureWhenBindingTableError() {
+        ShardingRuleConfig shardingRuleConfig = new ShardingRuleConfig();
+        shardingRuleConfig.setDataSource(createDataSourceMap());
+        shardingRuleConfig.setTables(createTableRuleConfigMap());
+        shardingRuleConfig.setBindingTables(Collections.singletonList(createBindingTableRule("t_other")));
+        shardingRuleConfig.setDefaultDatabaseStrategy(getDatabaseStrategyConfig(SingleAlgorithm.class.getName()));
+        shardingRuleConfig.setDefaultTableStrategy(getTableStrategyConfigForExpression());
+        new ShardingRuleBuilder(shardingRuleConfig).build().getBindingTableRules().iterator().next().getTableRules().iterator().next();
+    }
+    
+    @Test(expected = IllegalArgumentException.class)
+    public void assertBuildFailureWhenAlgorithmNotExisted() {
+        ShardingRuleConfig shardingRuleConfig = new ShardingRuleConfig();
+        shardingRuleConfig.setDataSource(createDataSourceMap());
+        shardingRuleConfig.setTables(createTableRuleConfigMap());
+        shardingRuleConfig.setDefaultDatabaseStrategy(getDatabaseStrategyConfig("xxx.Algorithm"));
+        new ShardingRuleBuilder(shardingRuleConfig).build();
     }
     
     @Test
-    public void testDynamic() {
-        Yaml yaml = new Yaml(new Constructor(ShardingRuleConfig.class));
-        Map<String, DataSource> dsMap = new HashMap<>();
-        dsMap.put("ds", new BasicDataSource());
-        ShardingRuleConfig config = (ShardingRuleConfig) yaml.load(ShardingRuleBuilderTest.class.getResourceAsStream("/config/config-dynamic.yaml"));
-        ShardingRule shardingRule = new ShardingRuleBuilder("config-dynamic.yaml", dsMap, config).build();
-        int i = 0;
-        for (TableRule each : shardingRule.getTableRules()) {
-            i++;
-            assertThat(each.getActualTables().size(), is(2));
-            assertThat(each.getActualTables(), hasItem(new DynamicDataNode("db0")));
-            assertThat(each.getActualTables(), hasItem(new DynamicDataNode("db1")));
-            switch (i) {
-                case 1:
-                    assertThat(each.getLogicTable(), is("config"));
+    public void assertBuildSuccess() {
+        ShardingRuleConfig shardingRuleConfig = new ShardingRuleConfig();
+        shardingRuleConfig.setDataSource(createDataSourceMap());
+        shardingRuleConfig.setDefaultDataSourceName("ds_0");
+        shardingRuleConfig.setTables(createTableRuleConfigMap());
+        shardingRuleConfig.setBindingTables(Collections.singletonList(createBindingTableRule("t_order", "t_order_item")));
+        shardingRuleConfig.setDefaultDatabaseStrategy(getDatabaseStrategyConfig(SingleAlgorithm.class.getName()));
+        shardingRuleConfig.setDefaultTableStrategy(getTableStrategyConfigForAlgorithmClass());
+        ShardingRule actual = new ShardingRuleBuilder(shardingRuleConfig).build();
+        assertThat(actual.getDataSourceRule().getDataSourceNames().size(), is(2));
+        assertThat(actual.getDataSourceRule().getDataSourceNames(), hasItem("ds_0"));
+        assertThat(actual.getDataSourceRule().getDataSourceNames(), hasItem("ds_1"));
+        assertThat(actual.getTableRules().size(), is(3));
+        for (TableRule each : actual.getTableRules()) {
+            String logicTable = each.getLogicTable();
+            switch (logicTable) {
+                case "t_order":
+                    assertFalse(each.isDynamic());
+                    assertThat(each.getActualTables().size(), is(4));
+                    assertThat(each.getActualTables(), hasItem(new DataNode("ds_0", "t_order_0")));
+                    assertThat(each.getActualTables(), hasItem(new DataNode("ds_0", "t_order_0")));
+                    assertThat(each.getActualTables(), hasItem(new DataNode("ds_1", "t_order_0")));
+                    assertThat(each.getActualTables(), hasItem(new DataNode("ds_1", "t_order_1")));
                     break;
-                case 2:
-                    assertThat(each.getLogicTable(), is("t_order"));
+                case "t_order_item":
+                    assertFalse(each.isDynamic());
+                    assertThat(each.getActualTables().size(), is(4));
+                    assertThat(each.getActualTables(), hasItem(new DataNode("ds_0", "t_order_item_0")));
+                    assertThat(each.getActualTables(), hasItem(new DataNode("ds_0", "t_order_item_0")));
+                    assertThat(each.getActualTables(), hasItem(new DataNode("ds_1", "t_order_item_0")));
+                    assertThat(each.getActualTables(), hasItem(new DataNode("ds_1", "t_order_item_1")));
                     break;
-                case 3:
-                    assertThat(each.getLogicTable(), is("t_order_item"));
+                case "t_log":
+                    assertTrue(each.isDynamic());
+                    assertThat(each.getActualTables().size(), is(2));
+                    assertThat(each.getActualTables(), hasItem(new DataNode("ds_0", "SHARDING_JDBC DYNAMIC_TABLE_PLACEHOLDER")));
+                    assertThat(each.getActualTables(), hasItem(new DataNode("ds_1", "SHARDING_JDBC DYNAMIC_TABLE_PLACEHOLDER")));
                     break;
                 default:
                     fail();
             }
         }
+        assertThat(actual.getBindingTableRules().size(), is(1));
+        BindingTableRule bindingTableRule = actual.getBindingTableRules().iterator().next();
+        assertTrue(bindingTableRule.hasLogicTable("t_order"));
+        assertTrue(bindingTableRule.hasLogicTable("t_order_item"));
+        assertFalse(bindingTableRule.hasLogicTable("t_log"));
+        assertThat(actual.getDatabaseShardingStrategy().getShardingColumns().size(), is(1));
+        assertThat(actual.getDatabaseShardingStrategy().getShardingColumns().iterator().next(), is("uid"));
+        assertThat(actual.getTableShardingStrategy().getShardingColumns().size(), is(1));
+        assertThat(actual.getTableShardingStrategy().getShardingColumns().iterator().next(), is("oid"));
     }
     
-    @Test(expected = IllegalArgumentException.class)
-    public void testClassNotFound() {
-        Yaml yaml = new Yaml(new Constructor(ShardingRuleConfig.class));
-        ShardingRuleConfig config = (ShardingRuleConfig) yaml.load(ShardingRuleBuilderTest.class.getResourceAsStream("/config/config-classNotFound.yaml"));
-        new ShardingRuleBuilder(config).build();
+    private Map<String, DataSource> createDataSourceMap() {
+        Map<String, DataSource> result = new HashMap<>(2);
+        result.put("ds_0", null);
+        result.put("ds_1", null);
+        return result;
     }
     
-    @Test(expected = IllegalArgumentException.class)
-    public void testBindingError() {
-        Yaml yaml = new Yaml(new Constructor(ShardingRuleConfig.class));
-        Map<String, DataSource> dsMap = new HashMap<>();
-        dsMap.put("ds", new BasicDataSource());
-        ShardingRuleConfig config = (ShardingRuleConfig) yaml.load(ShardingRuleBuilderTest.class.getResourceAsStream("/config/config-bindingError.yaml"));
-        ShardingRule shardingRule = new ShardingRuleBuilder("config-bindingError.yaml", dsMap, config).build();
-        for (TableRule tableRule : shardingRule.getBindingTableRules().iterator().next().getTableRules()) {
-            log.info(tableRule.toString());
-        }
+    private Map<String, TableRuleConfig> createTableRuleConfigMap() {
+        Map<String, TableRuleConfig> result = new HashMap<>(3);
+        result.put("t_order", createTableRuleConfig("t_order"));
+        result.put("t_order_item", createTableRuleConfig("t_order_item"));
+        result.put("t_log", createDynamicTableRuleConfig());
+        return result;
+    }
+    
+    private TableRuleConfig createTableRuleConfig(final String logicTable) {
+        TableRuleConfig result = new TableRuleConfig();
+        result.setActualTables(logicTable + "_${[0, 1]}");
+        result.setDataSourceNames("ds_${0..1}");
+        result.setDatabaseStrategy(getDatabaseStrategyConfig(SingleAlgorithm.class.getName()));
+        result.setTableStrategy(getTableStrategyConfigForExpression());
+        return result;
+    }
+    
+    private StrategyConfig getDatabaseStrategyConfig(final String algorithmClassName) {
+        StrategyConfig result = new StrategyConfig();
+        result.setShardingColumns("uid");
+        result.setAlgorithmClassName(algorithmClassName);
+        return result;
+    }
+    
+    private StrategyConfig getTableStrategyConfigForExpression() {
+        StrategyConfig result = new StrategyConfig();
+        result.setShardingColumns("oid");
+        result.setAlgorithmExpression("${oid.longValue() % 2}");
+        return result;
+    }
+    
+    private StrategyConfig getTableStrategyConfigForAlgorithmClass() {
+        StrategyConfig result = new StrategyConfig();
+        result.setShardingColumns("oid");
+        result.setAlgorithmClassName(MultiAlgorithm.class.getName());
+        return result;
+    }
+    
+    private TableRuleConfig createDynamicTableRuleConfig() {
+        TableRuleConfig result = new TableRuleConfig();
+        result.setDynamic(true);
+        return result;
+    }
+    
+    private BindingTableRuleConfig createBindingTableRule(final String... logicTables) {
+        BindingTableRuleConfig result = new BindingTableRuleConfig();
+        result.setTableNames(Joiner.on(",").join(logicTables));
+        return result;
     }
 }

sharding-jdbc-config-parent/sharding-jdbc-config-yaml/src/test/java/com/dangdang/ddframe/rdb/sharding/config/AllYamlShardingConfigTests.java

@@ -18,12 +18,14 @@
 package com.dangdang.ddframe.rdb.sharding.config;
 
 import com.dangdang.ddframe.rdb.sharding.config.yaml.YamlShardingConfigTest;
+import com.dangdang.ddframe.rdb.sharding.config.yaml.YamlintegratedTest;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
 
 @RunWith(Suite.class)
-@Suite.SuiteClasses(
-        YamlShardingConfigTest.class
-    )
+@Suite.SuiteClasses({
+    YamlShardingConfigTest.class,
+    YamlintegratedTest.class
+    })
 public class AllYamlShardingConfigTests {
 }

sharding-jdbc-config-parent/sharding-jdbc-config-yaml/src/test/java/com/dangdang/ddframe/rdb/sharding/config/yaml/YamlintegratedTest.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 com.dangdang.ddframe.rdb.sharding.config.yaml;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import javax.sql.DataSource;
+
+import com.dangdang.ddframe.rdb.sharding.api.rule.DynamicDataNode;
+import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
+import com.dangdang.ddframe.rdb.sharding.api.rule.TableRule;
+import com.dangdang.ddframe.rdb.sharding.config.common.api.ShardingRuleBuilder;
+import com.dangdang.ddframe.rdb.sharding.config.common.api.config.ShardingRuleConfig;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.dbcp.BasicDataSource;
+import org.junit.Test;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+
+import static org.hamcrest.CoreMatchers.hasItems;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsCollectionContaining.hasItem;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+
+@Slf4j
+public class YamlintegratedTest {
+    
+    @Test
+    public void testAll() {
+        Yaml yaml = new Yaml(new Constructor(ShardingRuleConfig.class));
+        ShardingRuleConfig config = (ShardingRuleConfig) yaml.load(YamlintegratedTest.class.getResourceAsStream("/config/config-all.yaml"));
+        ShardingRule shardingRule = new ShardingRuleBuilder("config-all.yaml", config).build();
+        assertThat(shardingRule.getTableRules().size(), is(3));
+        assertThat(shardingRule.getBindingTableRules().size(), is(1));
+        assertThat(Arrays.asList(shardingRule.getTableRules().toArray()), hasItems(shardingRule.getBindingTableRules().iterator().next().getTableRules().toArray()));
+        assertThat(shardingRule.getDataSourceRule().getDefaultDataSourceName(), is("db0"));
+    }
+    
+    @Test
+    public void testMin() {
+        Yaml yaml = new Yaml(new Constructor(ShardingRuleConfig.class));
+        Map<String, DataSource> dsMap = new HashMap<>();
+        dsMap.put("ds", new BasicDataSource());
+        ShardingRuleConfig config = (ShardingRuleConfig) yaml.load(YamlintegratedTest.class.getResourceAsStream("/config/config-min.yaml"));
+        ShardingRule shardingRule = new ShardingRuleBuilder("config-min.yaml", dsMap, config).build();
+        assertThat(shardingRule.getTableRules().size(), is(1));
+    }
+    
+    @Test
+    public void testDynamic() {
+        Yaml yaml = new Yaml(new Constructor(ShardingRuleConfig.class));
+        Map<String, DataSource> dsMap = new HashMap<>();
+        dsMap.put("ds", new BasicDataSource());
+        ShardingRuleConfig config = (ShardingRuleConfig) yaml.load(YamlintegratedTest.class.getResourceAsStream("/config/config-dynamic.yaml"));
+        ShardingRule shardingRule = new ShardingRuleBuilder("config-dynamic.yaml", dsMap, config).build();
+        int i = 0;
+        for (TableRule each : shardingRule.getTableRules()) {
+            i++;
+            assertThat(each.getActualTables().size(), is(2));
+            assertThat(each.getActualTables(), hasItem(new DynamicDataNode("db0")));
+            assertThat(each.getActualTables(), hasItem(new DynamicDataNode("db1")));
+            switch (i) {
+                case 1:
+                    assertThat(each.getLogicTable(), is("config"));
+                    break;
+                case 2:
+                    assertThat(each.getLogicTable(), is("t_order"));
+                    break;
+                case 3:
+                    assertThat(each.getLogicTable(), is("t_order_item"));
+                    break;
+                default:
+                    fail();
+            }
+        }
+    }
+    
+    @Test(expected = IllegalArgumentException.class)
+    public void testClassNotFound() {
+        Yaml yaml = new Yaml(new Constructor(ShardingRuleConfig.class));
+        ShardingRuleConfig config = (ShardingRuleConfig) yaml.load(YamlintegratedTest.class.getResourceAsStream("/config/config-classNotFound.yaml"));
+        new ShardingRuleBuilder(config).build();
+    }
+    
+    @Test(expected = IllegalArgumentException.class)
+    public void testBindingError() {
+        Yaml yaml = new Yaml(new Constructor(ShardingRuleConfig.class));
+        Map<String, DataSource> dsMap = new HashMap<>();
+        dsMap.put("ds", new BasicDataSource());
+        ShardingRuleConfig config = (ShardingRuleConfig) yaml.load(YamlintegratedTest.class.getResourceAsStream("/config/config-bindingError.yaml"));
+        ShardingRule shardingRule = new ShardingRuleBuilder("config-bindingError.yaml", dsMap, config).build();
+        for (TableRule tableRule : shardingRule.getBindingTableRules().iterator().next().getTableRules()) {
+            log.info(tableRule.toString());
+        }
+    }
+}

sharding-jdbc-config-parent/sharding-jdbc-config-common/src/test/resources/config/config-all.yaml → sharding-jdbc-config-parent/sharding-jdbc-config-yaml/src/test/resources/config/config-all.yaml

@@ -23,7 +23,7 @@ tables:
     actualTables: t_order_${0..1}
     databaseStrategy: &db001
       shardingColumns: order_id
-      algorithmClassName: com.dangdang.ddframe.rdb.sharding.config.common.internal.fixture.SingleAlgorithm
+      algorithmClassName: com.dangdang.ddframe.rdb.sharding.config.yaml.algorithm.SingleAlgorithm
     tableStrategy: &table001
       shardingColumns: id
       algorithmExpression: t_order_${id.longValue() % 2}
@@ -42,4 +42,4 @@ defaultDatabaseStrategy:
   algorithmExpression: t_order_${id.longValue() % 2}
 defaultTableStrategy:
   shardingColumns: id, order_id
-  algorithmClassName: com.dangdang.ddframe.rdb.sharding.config.common.internal.fixture.MultiAlgorithm
\ No newline at end of file
+  algorithmClassName: com.dangdang.ddframe.rdb.sharding.config.yaml.algorithm.MultiAlgorithm
\ No newline at end of file

sharding-jdbc-config-parent/sharding-jdbc-config-common/src/test/resources/config/config-bindingError.yaml → sharding-jdbc-config-parent/sharding-jdbc-config-yaml/src/test/resources/config/config-bindingError.yaml

@@ -3,7 +3,7 @@ tables:
     actualTables: t_order_${0..1}
     databaseStrategy: &db001
       shardingColumns: order_id
-      algorithmClassName: com.dangdang.ddframe.rdb.sharding.config.common.internal.fixture.SingleAlgorithm
+      algorithmClassName: com.dangdang.ddframe.rdb.sharding.config.yaml.algorithm.SingleAlgorithm
     tableStrategy: &table001
       shardingColumns: id
       algorithmExpression: t_order_${id.longValue() % 2}

sharding-jdbc-config-parent/sharding-jdbc-config-common/src/test/resources/config/config-dynamic.yaml → sharding-jdbc-config-parent/sharding-jdbc-config-yaml/src/test/resources/config/config-dynamic.yaml

@@ -20,7 +20,7 @@ tables:
     dynamic: true
     databaseStrategy: &db001
       shardingColumns: order_id
-      algorithmClassName: com.dangdang.ddframe.rdb.sharding.config.common.internal.fixture.SingleAlgorithm
+      algorithmClassName: com.dangdang.ddframe.rdb.sharding.config.yaml.algorithm.SingleAlgorithm
     tableStrategy: &table001
       shardingColumns: id
       algorithmExpression: t_order_${id.longValue() % 2}
@@ -37,4 +37,4 @@ defaultDatabaseStrategy:
   algorithmExpression: t_order_${id.longValue() % 2}
 defaultTableStrategy:
   shardingColumns: id, order_id
-  algorithmClassName: com.dangdang.ddframe.rdb.sharding.config.common.internal.fixture.MultiAlgorithm
\ No newline at end of file
+  algorithmClassName: com.dangdang.ddframe.rdb.sharding.config.yaml.algorithm.MultiAlgorithm
\ No newline at end of file