Commit 38fc2d24 authored by 张亮's avatar 张亮 Committed by GitHub
Browse files

Merge pull request #391 from guangyun1013/2.0.0.M1 

Add spring namespace test
parents 534da8be c0764782

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/java/io/shardingjdbc/spring/AbstractShardingBothDataBasesAndTablesSpringDBUnitTest.java

+1 −2
Original line number Diff line number Diff line
@@ -65,7 +65,6 @@ public abstract class AbstractShardingBothDataBasesAndTablesSpringDBUnitTest ext 
                    preparedStatement.execute();

                    preparedStatement.close();

                    

    

                    preparedStatement = connection.prepareStatement(configSql);

                    preparedStatement.setInt(1,  new Long(System.nanoTime()).intValue());

                    preparedStatement.setString(2, "insert");

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/java/io/shardingjdbc/spring/AllSpringTests.java

+3 −1
Original line number Diff line number Diff line
@@ -40,7 +40,9 @@ import org.junit.runners.Suite.SuiteClasses; 
        WithNamespaceForMasterSlaveWithDefaultStrategyTest.class,

        WithNamespaceForMasterSlaveWithStrategyRefTest.class,

        WithNamespaceForMasterSlaveWithStrategyTypeTest.class,

        GenerateKeyDBUnitTest.class

        GenerateKeyDBUnitTest.class,

        MasterSlaveNamespaceTest.class,

        ShardingNamespaceTest.class

    })

public class AllSpringTests {

}

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/java/io/shardingjdbc/spring/GenerateKeyDBUnitTest.java

+35 −0
Original line number Diff line number Diff line
@@ -20,18 +20,32 @@ package io.shardingjdbc.spring; 
import org.junit.Test;

import org.springframework.test.context.ContextConfiguration;



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

import io.shardingjdbc.core.rule.TableRule;

import io.shardingjdbc.spring.fixture.DecrementKeyGenerator;

import io.shardingjdbc.spring.fixture.IncrementKeyGenerator;

import io.shardingjdbc.spring.util.FieldValueUtil;



import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.Collection;

import java.util.Iterator;



import javax.annotation.Resource;



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

import static org.junit.Assert.assertThat;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;



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

public class GenerateKeyDBUnitTest extends AbstractSpringDBUnitTest {

    

    @Resource

    private ShardingDataSource shardingDataSource;

    

    @Test

    public void assertGenerateKey() throws SQLException {

        try (Connection connection = getShardingDataSource().getConnection();
@@ -46,4 +60,25 @@ public class GenerateKeyDBUnitTest extends AbstractSpringDBUnitTest { 
            assertThat(generateKeyResultSet.getLong(1), is(99L));

        }

    }

    

    @SuppressWarnings("unchecked")

    @Test

    public void assertGenerateKeyColumn() {

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

        assertNotNull(shardingContext);

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

        assertNotNull(shardingRule);

        Object defaultKeyGenerator = FieldValueUtil.getFieldValue(shardingRule, "defaultKeyGenerator");

        assertNotNull(defaultKeyGenerator);

        assertTrue(defaultKeyGenerator instanceof IncrementKeyGenerator);

        Object tableRules = FieldValueUtil.getFieldValue(shardingRule, "tableRules");

        assertNotNull(tableRules);

        assertThat(((Collection<TableRule>) tableRules).size(), is(2));

        Iterator<TableRule> iter = ((Collection<TableRule>) tableRules).iterator();

        TableRule orderRule = iter.next();

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

        TableRule orderItemRule = iter.next();

        assertThat(orderItemRule.getGenerateKeyColumn(), is("order_item_id"));

        assertTrue(orderItemRule.getKeyGenerator() instanceof DecrementKeyGenerator);

    }

}

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/java/io/shardingjdbc/spring/MasterSlaveNamespaceTest.java

0 → 100644
+90 −0
Original line number Diff line number Diff line 
/*

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

import io.shardingjdbc.core.api.algorithm.masterslave.RandomMasterSlaveLoadBalanceAlgorithm;

import io.shardingjdbc.core.api.algorithm.masterslave.RoundRobinMasterSlaveLoadBalanceAlgorithm;

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

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

import io.shardingjdbc.core.rule.MasterSlaveRule;

import io.shardingjdbc.core.rule.ShardingRule;

import io.shardingjdbc.spring.datasource.SpringMasterSlaveDataSource;

import io.shardingjdbc.spring.util.FieldValueUtil;



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

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertThat;

import static org.junit.Assert.assertTrue;



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

public class MasterSlaveNamespaceTest extends AbstractJUnit4SpringContextTests {

    

    @Test

    public void testDefaultMaserSlaveDataSource() {

        MasterSlaveRule masterSlaveRule = getMasterSlaveRule("defaultMasterSlaveDataSource");

        assertThat(masterSlaveRule.getMasterDataSourceName(), is("dbtbl_0_master"));

        assertNotNull(masterSlaveRule.getSlaveDataSourceMap().get("dbtbl_0_slave_0"));

        assertNotNull(masterSlaveRule.getSlaveDataSourceMap().get("dbtbl_0_slave_1"));

    }

    

    @Test

    public void testTypeMasterSlaveDataSource() {

        MasterSlaveRule randomSlaveRule = getMasterSlaveRule("randomMasterSlaveDataSource");

        MasterSlaveRule roundRobinSlaveRule = getMasterSlaveRule("roundRobinMasterSlaveDataSource");

        assertTrue(randomSlaveRule.getStrategy() instanceof RandomMasterSlaveLoadBalanceAlgorithm);

        assertTrue(roundRobinSlaveRule.getStrategy() instanceof RoundRobinMasterSlaveLoadBalanceAlgorithm);

    }

    

    @Test

    public void testRefMasterSlaveDataSource() {

        MasterSlaveLoadBalanceAlgorithm randomStrategy = this.applicationContext.getBean("randomStrategy", MasterSlaveLoadBalanceAlgorithm.class);

        MasterSlaveRule masterSlaveRule = getMasterSlaveRule("refMasterSlaveDataSource");

        assertTrue(masterSlaveRule.getStrategy() == randomStrategy);

    }

    

    @Test

    public void testDefaultShardingDataSource() {

        ShardingRule shardingRule = getShardingRule("defaultShardingDataSource");

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

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

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

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

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

    }

    

    @Test

    public void testShardingDataSourceType() {

        assertTrue(this.applicationContext.getBean("defaultMasterSlaveDataSource", MasterSlaveDataSource.class) instanceof SpringMasterSlaveDataSource);

    }

    

    private ShardingRule getShardingRule(final String shardingDataSourceName) {

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

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

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

    }

    

    private MasterSlaveRule getMasterSlaveRule(final String masterSlaveDataSourceName) {

        MasterSlaveDataSource masterSlaveDataSource = this.applicationContext.getBean(masterSlaveDataSourceName, MasterSlaveDataSource.class);

        return (MasterSlaveRule) FieldValueUtil.getFieldValue(masterSlaveDataSource, "masterSlaveRule", true);

    }

}

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/java/io/shardingjdbc/spring/ShardingNamespaceTest.java

0 → 100644
+206 −0
Original line number Diff line number Diff line 
/*

 * 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/rdb/shardingNamespace.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("tableRuleWithAttributesDataSource");

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

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

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

        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));

        assertNull(ShardingPropertiesConstant.findByKey("foo"));

    }

    

    @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 shardingDataSourceName) {

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

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

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

    }

}