Add ShardingNamespaceTest

/*

 * 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.spring;

import org.junit.Test;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;

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.constant.ShardingProperties;

import io.shardingjdbc.core.constant.ShardingPropertiesConstant;

import io.shardingjdbc.core.jdbc.core.datasource.ShardingDataSource;

import io.shardingjdbc.core.rule.BindingTableRule;

import io.shardingjdbc.core.rule.DataNode;

import io.shardingjdbc.core.rule.ShardingRule;

import io.shardingjdbc.core.rule.TableRule;

import io.shardingjdbc.spring.datasource.SpringShardingDataSource;

import io.shardingjdbc.spring.util.FieldValueUtil;

import static org.hamcrest.core.Is.is;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertThat;

import static org.junit.Assert.assertTrue;

import java.util.Arrays;

import java.util.Iterator;

@ContextConfiguration(locations = "classpath:META-INF/testShardingNamespace.xml")

public class ShardingNamespaceTest extends AbstractJUnit4SpringContextTests {

    @Test

    public void testStandardStrategy() {

        StandardShardingStrategyConfiguration standardStrategy = this.applicationContext.getBean("standardStrategy", StandardShardingStrategyConfiguration.class);

        assertThat(standardStrategy.getShardingColumn(), is("user_id"));

        assertThat(standardStrategy.getPreciseAlgorithmClassName(), is("io.shardingjdbc.spring.algorithm.PreciseModuloDatabaseShardingAlgorithm"));

    }

    @Test

    public void testRangeStandardStrategy() {

        StandardShardingStrategyConfiguration rangeStandardStrategy = this.applicationContext.getBean("rangeStandardStrategy", StandardShardingStrategyConfiguration.class);

        assertThat(rangeStandardStrategy.getShardingColumn(), is("order_id"));

        assertThat(rangeStandardStrategy.getPreciseAlgorithmClassName(), is("io.shardingjdbc.spring.algorithm.PreciseModuloTableShardingAlgorithm"));

        assertThat(rangeStandardStrategy.getRangeAlgorithmClassName(), is("io.shardingjdbc.spring.algorithm.RangeModuloTableShardingAlgorithm"));

    }

    @Test

    public void testComplexStrategy() {

        ComplexShardingStrategyConfiguration complexStrategy = this.applicationContext.getBean("complexStrategy", ComplexShardingStrategyConfiguration.class);

        assertThat(complexStrategy.getShardingColumns(), is("order_id,user_id"));

        assertThat(complexStrategy.getAlgorithmClassName(), is("io.shardingjdbc.spring.algorithm.DefaultComplexKeysShardingAlgorithm"));

    }

    @Test

    public void testInlineStrategy() {

        InlineShardingStrategyConfiguration inlineStrategy = this.applicationContext.getBean("inlineStrategy", InlineShardingStrategyConfiguration.class);

        assertThat(inlineStrategy.getShardingColumn(), is("order_id"));

        assertThat(inlineStrategy.getAlgorithmInlineExpression(), is("t_order_${order_id % 4}"));

    }

    @Test

    public void testHintStrategy() {

        HintShardingStrategyConfiguration hintStrategy = this.applicationContext.getBean("hintStrategy", HintShardingStrategyConfiguration.class);

        assertThat(hintStrategy.getAlgorithmClassName(), is("io.shardingjdbc.spring.algorithm.DefaultHintShardingAlgorithm"));

    }

    @Test

    public void testNoneStrategy() {

        this.applicationContext.getBean("noneStrategy", NoneShardingStrategyConfiguration.class);

    }

    @Test

    public void testSimpleShardingDataSource() {

        ShardingRule shardingRule = getShardingRule("simpleShardingDataSource");

        assertNotNull(shardingRule.getDataSourceMap().get("dbtbl_0"));

        assertThat(shardingRule.getTableRules().size(), is(1));

        assertThat(shardingRule.getTableRules().iterator().next().getLogicTable(), is("t_order"));

    }

    @Test

    public void testShardingRuleWithAttributesDataSource() {

        ShardingRule shardingRule = getShardingRule("shardingRuleWithAttributesDataSource");

        assertNotNull(shardingRule.getDataSourceMap().get("dbtbl_0"));

        assertNotNull(shardingRule.getDataSourceMap().get("dbtbl_1"));

        assertThat(shardingRule.getDefaultDataSourceName(), is("dbtbl_0"));

        assertTrue(Arrays.equals(shardingRule.getDefaultDatabaseShardingStrategy().getShardingColumns().toArray(new String[]{}), 

                new String[]{this.applicationContext.getBean("standardStrategy", StandardShardingStrategyConfiguration.class).getShardingColumn()}));

        assertTrue(Arrays.equals(shardingRule.getDefaultTableShardingStrategy().getShardingColumns().toArray(new String[]{}), 

                new String[]{this.applicationContext.getBean("inlineStrategy", InlineShardingStrategyConfiguration.class).getShardingColumn()}));

        assertThat(shardingRule.getDefaultKeyGenerator().getClass().getName(), is("io.shardingjdbc.spring.fixture.IncrementKeyGenerator"));

    }

    @Test

    public void testTableRuleWithAttributesDataSource() {

        ShardingRule shardingRule = getShardingRule("shardingRuleWithAttributesDataSource");

        assertThat(shardingRule.getTableRules().size(), is(1));

        TableRule tableRule = shardingRule.getTableRules().iterator().next();

        assertThat(tableRule.getLogicTable(), is("t_order"));

        //TODO 以下测试未通过，可能是程序bug

        /*

        assertThat(tableRule.getActualDataNodes().size(), is(8));

        assertTrue(tableRule.getActualDataNodes().contains(new DataNode("dbtbl_0", "t_order_0")));

        assertTrue(tableRule.getActualDataNodes().contains(new DataNode("dbtbl_0", "t_order_1")));

        assertTrue(tableRule.getActualDataNodes().contains(new DataNode("dbtbl_0", "t_order_2")));

        assertTrue(tableRule.getActualDataNodes().contains(new DataNode("dbtbl_0", "t_order_3")));

        assertTrue(tableRule.getActualDataNodes().contains(new DataNode("dbtbl_1", "t_order_0")));

        assertTrue(tableRule.getActualDataNodes().contains(new DataNode("dbtbl_1", "t_order_1")));

        assertTrue(tableRule.getActualDataNodes().contains(new DataNode("dbtbl_1", "t_order_2")));

        assertTrue(tableRule.getActualDataNodes().contains(new DataNode("dbtbl_1", "t_order_3")));

        assertTrue(Arrays.equals(tableRule.getDatabaseShardingStrategy().getShardingColumns().toArray(new String[]{}), 

                new String[]{this.applicationContext.getBean("standardStrategy", StandardShardingStrategyConfiguration.class).getShardingColumn()}));

        assertTrue(Arrays.equals(tableRule.getTableShardingStrategy().getShardingColumns().toArray(new String[]{}), 

                new String[]{this.applicationContext.getBean("inlineStrategy", InlineShardingStrategyConfiguration.class).getShardingColumn()}));

        assertThat(tableRule.getGenerateKeyColumn(), is("order_id"));

        assertThat(tableRule.getKeyGenerator().getClass().getName(), is("io.shardingjdbc.spring.fixture.IncrementKeyGenerator"));

        */

    }

    @Test

    public void testMultiTableRulesDataSource() {

        ShardingRule shardingRule = getShardingRule("multiTableRulesDataSource");

        assertThat(shardingRule.getTableRules().size(), is(2));

        Iterator<TableRule> iter = shardingRule.getTableRules().iterator();

        assertThat(iter.next().getLogicTable(), is("t_order"));

        assertThat(iter.next().getLogicTable(), is("t_order_item"));

    }

    @Test

    public void testBindingTableRuleDatasource() {

        ShardingRule shardingRule = getShardingRule("bindingTableRuleDatasource");

        assertThat(shardingRule.getBindingTableRules().size(), is(1));

        BindingTableRule bindingTableRule = shardingRule.getBindingTableRules().iterator().next();

        assertThat(bindingTableRule.getBindingActualTable("dbtbl_0", "t_order", "t_order_item"), is("t_order"));

        assertThat(bindingTableRule.getBindingActualTable("dbtbl_1", "t_order", "t_order_item"), is("t_order"));

    }

    @Test

    public void testMultiBindingTableRulesDatasource() {

        ShardingRule shardingRule = getShardingRule("multiBindingTableRulesDatasource");

        assertThat(shardingRule.getBindingTableRules().size(), is(2));

        Iterator<BindingTableRule> iter = shardingRule.getBindingTableRules().iterator();

        BindingTableRule orderRule = iter.next();

        assertThat(orderRule.getBindingActualTable("dbtbl_0", "t_order", "t_order_item"), is("t_order"));

        assertThat(orderRule.getBindingActualTable("dbtbl_1", "t_order", "t_order_item"), is("t_order"));

        BindingTableRule userRule = iter.next();

        assertThat(userRule.getBindingActualTable("dbtbl_0", "t_user", "t_user_detail"), is("t_user"));

        assertThat(userRule.getBindingActualTable("dbtbl_1", "t_user", "t_user_detail"), is("t_user"));

    }

    @Test

    public void testPropsDataSource() {

        ShardingDataSource shardingDataSource = this.applicationContext.getBean("propsDataSource", ShardingDataSource.class);

        Object shardingContext = FieldValueUtil.getFieldValue(shardingDataSource, "shardingContext", true);

        assertTrue((boolean) FieldValueUtil.getFieldValue(shardingContext, "showSQL"));

        ShardingProperties shardingProperties = (ShardingProperties) FieldValueUtil.getFieldValue(shardingDataSource, "shardingProperties", true);

        boolean showSql = shardingProperties.getValue(ShardingPropertiesConstant.SQL_SHOW);

        assertTrue(showSql);

        int executorSize = shardingProperties.getValue(ShardingPropertiesConstant.EXECUTOR_SIZE);

        assertThat(executorSize, is(10));

        //TODO 报NullPointerException，程序待完善

        /*

        String bar = shardingProperties.getValue(ShardingPropertiesConstant.findByKey("foo"));

        assertNull(bar);

        */

    }

    @Test

    public void testShardingDataSourceType() {

        assertTrue(this.applicationContext.getBean("simpleShardingDataSource", ShardingDataSource.class) instanceof SpringShardingDataSource);

    }

    @Test

    public void testDefaultActualDataNodes() {

        ShardingDataSource multiTableRulesDataSource = this.applicationContext.getBean("multiTableRulesDataSource", ShardingDataSource.class);

        Object shardingContext = FieldValueUtil.getFieldValue(multiTableRulesDataSource, "shardingContext", true);

        ShardingRule shardingRule = (ShardingRule) FieldValueUtil.getFieldValue(shardingContext, "shardingRule");

        assertThat(shardingRule.getTableRules().size(), is(2));

        Iterator<TableRule> iter = shardingRule.getTableRules().iterator();

        TableRule orderRule = iter.next();

        assertThat(orderRule.getActualDataNodes().size(), is(2));

        assertTrue(orderRule.getActualDataNodes().contains(new DataNode("dbtbl_0", "t_order")));

        assertTrue(orderRule.getActualDataNodes().contains(new DataNode("dbtbl_1", "t_order")));

        TableRule orderItemRule = iter.next();

        assertThat(orderItemRule.getActualDataNodes().size(), is(2));

        assertTrue(orderItemRule.getActualDataNodes().contains(new DataNode("dbtbl_0", "t_order_item")));

        assertTrue(orderItemRule.getActualDataNodes().contains(new DataNode("dbtbl_1", "t_order_item")));

    }

    private ShardingRule getShardingRule(final String shardingRuleName) {

        ShardingDataSource shardingDataSource = this.applicationContext.getBean(shardingRuleName, ShardingDataSource.class);

        Object shardingContext = FieldValueUtil.getFieldValue(shardingDataSource, "shardingContext", true);

        return (ShardingRule) FieldValueUtil.getFieldValue(shardingContext, "shardingRule");

    }

}

/*

 * 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.spring.algorithm;

import java.util.Collection;

import io.shardingjdbc.core.api.algorithm.sharding.ShardingValue;

import io.shardingjdbc.core.api.algorithm.sharding.complex.ComplexKeysShardingAlgorithm;

public class DefaultComplexKeysShardingAlgorithm implements ComplexKeysShardingAlgorithm {

    @Override

    public Collection<String> doSharding(final Collection<String> availableTargetNames, final Collection<ShardingValue> shardingValues) {

        return availableTargetNames;

    }

}

/*

 * 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.spring.algorithm;

import java.util.Collection;

import io.shardingjdbc.core.api.algorithm.sharding.ShardingValue;

import io.shardingjdbc.core.api.algorithm.sharding.hint.HintShardingAlgorithm;

public class DefaultHintShardingAlgorithm implements HintShardingAlgorithm {

    @Override

    public Collection<String> doSharding(final Collection<String> availableTargetNames, final ShardingValue shardingValue) {

        return availableTargetNames;

    }

}

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:sharding="http://shardingjdbc.io/schema/shardingjdbc/sharding" 

    xsi:schemaLocation="http://www.springframework.org/schema/beans 

                        http://www.springframework.org/schema/beans/spring-beans.xsd

                        http://www.springframework.org/schema/context 

                        http://www.springframework.org/schema/context/spring-context.xsd 

                        http://shardingjdbc.io/schema/shardingjdbc/sharding 

                        http://shardingjdbc.io/schema/shardingjdbc/sharding/sharding.xsd 

                        ">

    <context:property-placeholder location="classpath:conf/rdb/conf.properties" ignore-unresolvable="true" />

    <bean id="dbtbl_0" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

        <property name="driverClassName" value="${dbtbl_0.driver}" />

        <property name="url" value="${dbtbl_0.url}" />

        <property name="username" value="${dbtbl_0.username}" />

        <property name="password" value="${dbtbl_0.password}" />

    </bean>

    <bean id="dbtbl_1" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

        <property name="driverClassName" value="${dbtbl_1.driver}" />

        <property name="url" value="${dbtbl_1.url}" />

        <property name="username" value="${dbtbl_1.username}" />

        <property name="password" value="${dbtbl_1.password}" />

    </bean>

    <sharding:standard-strategy id="standardStrategy" sharding-column="user_id" 

        precise-algorithm-class="io.shardingjdbc.spring.algorithm.PreciseModuloDatabaseShardingAlgorithm" />

    <sharding:standard-strategy id="rangeStandardStrategy" sharding-column="order_id" 

        precise-algorithm-class="io.shardingjdbc.spring.algorithm.PreciseModuloTableShardingAlgorithm" 

        range-algorithm-class="io.shardingjdbc.spring.algorithm.RangeModuloTableShardingAlgorithm"/>

    <sharding:complex-strategy id="complexStrategy" sharding-columns="order_id,user_id" 

        algorithm-class="io.shardingjdbc.spring.algorithm.DefaultComplexKeysShardingAlgorithm"/>

    <sharding:inline-strategy id="inlineStrategy" sharding-column="order_id" algorithm-expression="t_order_${order_id % 4}" />

    <sharding:hint-strategy id="hintStrategy" algorithm-class="io.shardingjdbc.spring.algorithm.DefaultHintShardingAlgorithm" />

    <sharding:none-strategy id="noneStrategy" />

    <sharding:data-source id="simpleShardingDataSource">

        <sharding:sharding-rule data-source-names="dbtbl_0">

            <sharding:table-rules>

                <sharding:table-rule logic-table="t_order" />

            </sharding:table-rules>

        </sharding:sharding-rule>

    </sharding:data-source>

    <sharding:data-source id="shardingRuleWithAttributesDataSource">

        <sharding:sharding-rule 

            data-source-names="dbtbl_0,dbtbl_1" 

            default-data-source-name="dbtbl_0" 

            default-database-strategy-ref="standardStrategy" 

            default-table-strategy-ref="inlineStrategy" 

            key-generator-class="io.shardingjdbc.spring.fixture.IncrementKeyGenerator">

            <sharding:table-rules>

                <sharding:table-rule logic-table="t_order" />

            </sharding:table-rules>

        </sharding:sharding-rule>

    </sharding:data-source>

    <sharding:data-source id="tableRuleWithAttributesDataSource">

        <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1">

            <sharding:table-rules>

                <sharding:table-rule logic-table="t_order" actual-data-nodes="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="standardStrategy" table-strategy-ref="inlineStrategy" generate-key-column="order_id" column-key-generator-class="io.shardingjdbc.spring.fixture.IncrementKeyGenerator" />

            </sharding:table-rules>

        </sharding:sharding-rule>

    </sharding:data-source>

    <sharding:data-source id="multiTableRulesDataSource">

        <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1">

            <sharding:table-rules>

                <sharding:table-rule logic-table="t_order" />

                <sharding:table-rule logic-table="t_order_item" />

            </sharding:table-rules>

        </sharding:sharding-rule>

    </sharding:data-source>

    <sharding:data-source id="bindingTableRuleDatasource">

        <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" >

            <sharding:table-rules>

                <sharding:table-rule logic-table="t_order" />

                <sharding:table-rule logic-table="t_order_item" />

            </sharding:table-rules>

            <sharding:binding-table-rules>

                <sharding:binding-table-rule logic-tables="t_order, t_order_item" />

            </sharding:binding-table-rules>

        </sharding:sharding-rule>

    </sharding:data-source>

    <sharding:data-source id="multiBindingTableRulesDatasource">

        <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" >

            <sharding:table-rules>

                <sharding:table-rule logic-table="t_order" />

                <sharding:table-rule logic-table="t_order_item" />

                <sharding:table-rule logic-table="t_user" />

                <sharding:table-rule logic-table="t_user_detail" />

            </sharding:table-rules>

            <sharding:binding-table-rules>

                <sharding:binding-table-rule logic-tables="t_order, t_order_item" />

                <sharding:binding-table-rule logic-tables="t_user, t_user_detail" />

            </sharding:binding-table-rules>

        </sharding:sharding-rule>

    </sharding:data-source>

    <sharding:data-source id="propsDataSource">

        <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1">

            <sharding:table-rules>

                <sharding:table-rule logic-table="t_order" />

            </sharding:table-rules>

        </sharding:sharding-rule>

        <sharding:props>

            <prop key="sql.show">${sql_show}</prop>

            <prop key="executor.size">10</prop>

            <prop key="foo">bar</prop>

        </sharding:props>

    </sharding:data-source>

</beans>

dbtbl_1.url=jdbc:h2:mem:dbtbl_1;DB_CLOSE_DELAY=-1;DATABASE_TO_UPPER=false;MODE=MYSQL

dbtbl_1.username=sa

dbtbl_1.password=

sql_show=true