Commit 2abec6e8 authored by guangyun1013's avatar guangyun1013
Browse files

Add MasterSlaveNamespaceTest, refector spring namespace test

parent d56c5b39

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

+0 −141
Original line number Diff line number Diff line
@@ -19,35 +19,16 @@ package io.shardingjdbc.spring; 


import org.junit.Test;



import io.shardingjdbc.core.api.config.strategy.InlineShardingStrategyConfiguration;

import io.shardingjdbc.core.api.config.strategy.ShardingStrategyConfiguration;

import io.shardingjdbc.core.api.config.strategy.StandardShardingStrategyConfiguration;

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

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

import io.shardingjdbc.core.routing.strategy.ShardingStrategy;

import io.shardingjdbc.core.rule.MasterSlaveRule;

import io.shardingjdbc.core.rule.TableRule;

import io.shardingjdbc.spring.util.FieldValueUtil;



import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.Collection;

import java.util.Map;



import javax.sql.DataSource;



import static org.hamcrest.MatcherAssert.assertThat;

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

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;



public abstract class AbstractShardingBothDataBasesAndTablesSpringDBUnitTest extends AbstractSpringDBUnitTest {

    

    @Test

    public abstract void testShardingNamespace();

    

    @Test

    public void testWithAllPlaceholders() throws SQLException {

        insertData();
@@ -117,126 +98,4 @@ public abstract class AbstractShardingBothDataBasesAndTablesSpringDBUnitTest ext 
            preparedStatement.close();

        }

    }

    

    protected void assertShardingStandardStrategy(final StandardShardingStrategyConfiguration databaseStrategy, final String shardingColumn, final String preciseAlgorithmClass) {

        Object shardingColumnName = FieldValueUtil.getFieldValue(databaseStrategy, "shardingColumn");

        assertNotNull(shardingColumnName);

        assertThat((String) shardingColumnName, is(shardingColumn));

        Object preciseAlgorithmClassName = FieldValueUtil.getFieldValue(databaseStrategy, "preciseAlgorithmClassName");

        assertNotNull(preciseAlgorithmClassName);

        assertThat((String) preciseAlgorithmClassName, is(preciseAlgorithmClass));

    }

    

    protected void assertShardingInlineStrategy(final InlineShardingStrategyConfiguration databaseStrategy, final String shardingColumn, final String algorithmExpression) {

        Object shardingColumnName = FieldValueUtil.getFieldValue(databaseStrategy, "shardingColumn");

        assertNotNull(shardingColumnName);

        assertThat((String) shardingColumnName, is(shardingColumn));

        Object algorithmInlineExpression = FieldValueUtil.getFieldValue(databaseStrategy, "algorithmInlineExpression");

        assertNotNull(algorithmInlineExpression);

        assertThat((String) algorithmInlineExpression, is(algorithmExpression));

    }

    

    @SuppressWarnings("unchecked")

    protected void assertDataSourceName(final ShardingDataSource shardingDataSource) {

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

        assertNotNull(shardingContext);

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

        assertNotNull(shardingRule);

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

        assertNotNull(dataSourceMap);

        assertNotNull(((Map<String, DataSource>) dataSourceMap).get("dbtbl_0"));

        assertNotNull(((Map<String, DataSource>) dataSourceMap).get("dbtbl_1"));

    }

    

    protected void assertDefaultDataSourceName(final ShardingDataSource shardingDataSource) {

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

        assertNotNull(shardingContext);

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

        assertNotNull(shardingRule);

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

        assertThat((String) defaultDataSourceName, is("dbtbl_0"));

    }

    

    protected void assertDefaultDatabaseShardingStrategy(final ShardingDataSource shardingDataSource, final ShardingStrategyConfiguration strategyConfiguration) {

        assertShardingStrategy(shardingDataSource, strategyConfiguration, "defaultDatabaseShardingStrategy");

    }

    

    protected void assertDefaultTableShardingStrategy(final ShardingDataSource shardingDataSource, final ShardingStrategyConfiguration strategyConfiguration) {

        assertShardingStrategy(shardingDataSource, strategyConfiguration, "defaultTableShardingStrategy");

    }

    

    private void assertShardingStrategy(final ShardingDataSource shardingDataSource, final ShardingStrategyConfiguration strategyConfiguration, final String fieldName) {

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

        assertNotNull(shardingContext);

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

        assertNotNull(shardingRule);

        ShardingStrategy defaultDatabaseShardingStrategy = (ShardingStrategy) FieldValueUtil.getFieldValue(shardingRule, fieldName);

        assertNotNull(defaultDatabaseShardingStrategy);

        assertShardingRuleStrategy(defaultDatabaseShardingStrategy, strategyConfiguration);

    }

    

    @SuppressWarnings("unchecked")

    protected Collection<TableRule> getTableRules(final ShardingDataSource shardingDataSource) {

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

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

        return (Collection<TableRule>) FieldValueUtil.getFieldValue(shardingRule, "tableRules");

    }

    

    protected void assertLogicTable(final TableRule tableRule, final String logicTableName) {

        assertThat(tableRule.getLogicTable(), is(logicTableName));

    }

    

    protected void assertActualTables(final TableRule tableRule, final String prefixName) {

        String[] dataSources = new String[]{"dbtbl_0", "dbtbl_1"};

        int shardingTableNum = 4;

        int i = 0;

        for (String dataSourceName : dataSources) {

            for (int j = shardingTableNum * i, k = 0; k < shardingTableNum; k++) {

                assertThat(tableRule.getActualDataNodes().get(j + k).getDataSourceName(), is(dataSourceName));

                assertThat(tableRule.getActualDataNodes().get(j + k).getTableName(), is(prefixName + k));

            }

            i++;

        }

    }

    

    protected void assertShardingRuleStrategy(final ShardingStrategy shardingStrategy, final ShardingStrategyConfiguration strategyConfiguration) {

        assertThat(shardingStrategy.getShardingColumns().size(), is(1));

        String shardingColumn = "";

        if (strategyConfiguration instanceof StandardShardingStrategyConfiguration) {

            shardingColumn = ((StandardShardingStrategyConfiguration) strategyConfiguration).getShardingColumn();

        } else if (strategyConfiguration instanceof InlineShardingStrategyConfiguration) {

            shardingColumn = ((InlineShardingStrategyConfiguration) strategyConfiguration).getShardingColumn();

        }

        assertThat(shardingStrategy.getShardingColumns().iterator().next(), is(shardingColumn));

    }

    

    protected void assertMasterDataSource(final MasterSlaveDataSource masterSlaveDataSource, final String name) {

        MasterSlaveRule masterSlaveRule = masterSlaveDataSource.getMasterSlaveRule();

        assertNotNull(masterSlaveRule);

        Object masterDataSourceName = FieldValueUtil.getFieldValue(masterSlaveRule, "masterDataSourceName");

        assertNotNull(masterDataSourceName);

        assertThat((String) masterDataSourceName, is(name));

        Object masterDataSource = FieldValueUtil.getFieldValue(masterSlaveRule, "masterDataSource");

        assertNotNull(masterDataSource);

    }

    

    @SuppressWarnings("unchecked")

    protected void assertSlaveDataSourceMap(final MasterSlaveDataSource masterSlaveDataSource, final String[] slaveDataSourceNames) {

        MasterSlaveRule masterSlaveRule = masterSlaveDataSource.getMasterSlaveRule();

        assertNotNull(masterSlaveRule);

        Object slaveDataSourceMap = FieldValueUtil.getFieldValue(masterSlaveRule, "slaveDataSourceMap");

        assertNotNull(slaveDataSourceMap);

        assertThat(((Map<String, DataSource>) slaveDataSourceMap).size(), is(slaveDataSourceNames.length));

        for (String each : slaveDataSourceNames) {

            assertNotNull(((Map<String, DataSource>) slaveDataSourceMap).get(each));

        }

    }

    

    protected void assertSlaveDataSourceMap(final MasterSlaveDataSource masterSlaveDataSource, final Class<?> loadBalanceAlgorithmClazz) {

        MasterSlaveRule masterSlaveRule = masterSlaveDataSource.getMasterSlaveRule();

        assertNotNull(masterSlaveRule);

        Object strategy = FieldValueUtil.getFieldValue(masterSlaveRule, "strategy");

        assertNotNull(strategy);

        assertTrue(strategy.getClass() == loadBalanceAlgorithmClazz);

    }

}

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/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/testMasterSlaveNamespace.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

+5 −13
Original line number Diff line number Diff line
@@ -45,7 +45,7 @@ import static org.junit.Assert.assertTrue; 
import java.util.Arrays;

import java.util.Iterator;



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

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

public class ShardingNamespaceTest extends AbstractJUnit4SpringContextTests {

    

    @Test
@@ -111,12 +111,10 @@ public class ShardingNamespaceTest extends AbstractJUnit4SpringContextTests { 
    

    @Test

    public void testTableRuleWithAttributesDataSource() {

        ShardingRule shardingRule = getShardingRule("shardingRuleWithAttributesDataSource");

        ShardingRule shardingRule = getShardingRule("tableRuleWithAttributesDataSource");

        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")));
@@ -132,7 +130,6 @@ public class ShardingNamespaceTest extends AbstractJUnit4SpringContextTests { 
                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
@@ -176,12 +173,7 @@ public class ShardingNamespaceTest extends AbstractJUnit4SpringContextTests { 
        assertTrue(showSql);

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

        assertThat(executorSize, is(10));

        

        //TODO 报NullPointerException，程序待完善

        /*

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

        assertNull(bar);

        */

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

    }

    

    @Test
@@ -206,8 +198,8 @@ public class ShardingNamespaceTest extends AbstractJUnit4SpringContextTests { 
        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);

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

    }

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

+0 −57
Original line number Diff line number Diff line
@@ -17,67 +17,10 @@ 


package io.shardingjdbc.spring.cases;



import io.shardingjdbc.core.api.config.strategy.StandardShardingStrategyConfiguration;

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

import io.shardingjdbc.core.rule.TableRule;

import io.shardingjdbc.spring.AbstractShardingBothDataBasesAndTablesSpringDBUnitTest;



import javax.annotation.Resource;



import org.springframework.test.context.ContextConfiguration;



import static org.hamcrest.CoreMatchers.is;

import static org.junit.Assert.assertThat;



import java.util.Collection;

import java.util.Iterator;





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

public final class WithNamespaceAlgorithmClassTest extends AbstractShardingBothDataBasesAndTablesSpringDBUnitTest {

    

    @Resource

    private StandardShardingStrategyConfiguration databaseStrategy;

    

    @Resource

    private StandardShardingStrategyConfiguration tableStrategy;

    

    @Resource

    private ShardingDataSource shardingDataSource;

    

    public void testShardingNamespace() {

        assertShardingStrategy();

        assertShardingDataSource();

    }

    

    private void assertShardingStrategy() {

        assertShardingStandardStrategy(databaseStrategy, "user_id", "io.shardingjdbc.spring.algorithm.PreciseModuloDatabaseShardingAlgorithm");

        assertShardingStandardStrategy(tableStrategy, "order_id", "io.shardingjdbc.spring.algorithm.PreciseModuloTableShardingAlgorithm");

    }

    

    private void assertShardingDataSource() {

        assertShardingRule();

        assertShardingTableRule();

    }

    

    private void assertShardingRule() {

        assertDataSourceName(shardingDataSource);

        assertDefaultDataSourceName(shardingDataSource);

    }

    

    private void assertShardingTableRule() {

        Collection<TableRule> tableRules = getTableRules(shardingDataSource);

        assertThat(tableRules.size(), is(2));

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

        TableRule orderRule = iter.next();

        assertLogicTable(orderRule, "t_order");

        assertActualTables(orderRule, "t_order_");

        assertShardingRuleStrategy(orderRule.getDatabaseShardingStrategy(), databaseStrategy);

        assertShardingRuleStrategy(orderRule.getTableShardingStrategy(), tableStrategy);

        TableRule orderItemRule = iter.next();

        assertLogicTable(orderItemRule, "t_order_item");

        assertActualTables(orderItemRule, "t_order_item_");

        assertShardingRuleStrategy(orderItemRule.getDatabaseShardingStrategy(), databaseStrategy);

        assertShardingRuleStrategy(orderItemRule.getTableShardingStrategy(), tableStrategy);

    }

}