Commit 22259a9c authored by guangyun1013's avatar guangyun1013
Browse files

Add spring namespace test

parent a89c95a0

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

+142 −2
Original line number Diff line number Diff line
@@ -19,16 +19,35 @@ 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();
@@ -65,7 +84,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");
@@ -99,4 +117,126 @@ 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/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/cases/WithNamespaceAlgorithmClassTest.java

+58 −0
Original line number Diff line number Diff line
@@ -17,9 +17,67 @@ 


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

    }

}

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

+61 −0
Original line number Diff line number Diff line
@@ -17,9 +17,70 @@ 


package io.shardingjdbc.spring.cases;



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

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

import io.shardingjdbc.core.rule.TableRule;

import io.shardingjdbc.spring.AbstractShardingBothDataBasesAndTablesSpringDBUnitTest;



import static org.hamcrest.CoreMatchers.is;

import static org.junit.Assert.assertThat;



import java.util.Collection;

import java.util.Iterator;



import javax.annotation.Resource;



import org.springframework.test.context.ContextConfiguration;



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

public final class WithNamespaceAlgorithmExpressionTest extends AbstractShardingBothDataBasesAndTablesSpringDBUnitTest {

    

    @Resource

    private InlineShardingStrategyConfiguration databaseStrategy;

    

    @Resource

    private InlineShardingStrategyConfiguration orderTableStrategy;

    

    @Resource

    private InlineShardingStrategyConfiguration orderItemTableStrategy;

    

    @Resource

    private ShardingDataSource shardingDataSource;

    

    public void testShardingNamespace() {

        assertShardingStrategy();

        assertShardingDataSource();

    }

    

    private void assertShardingStrategy() {

        assertShardingInlineStrategy(databaseStrategy, "user_id", "dbtbl_${user_id % 2}");

        assertShardingInlineStrategy(orderTableStrategy, "order_id", "t_order_${order_id % 4}");

        assertShardingInlineStrategy(orderItemTableStrategy, "order_id", "t_order_item_${order_id % 4}");

    }

    

    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(), orderTableStrategy);

        TableRule orderItemRule = iter.next();

        assertLogicTable(orderItemRule, "t_order_item");

        assertActualTables(orderItemRule, "t_order_item_");

        assertShardingRuleStrategy(orderItemRule.getDatabaseShardingStrategy(), databaseStrategy);

        assertShardingRuleStrategy(orderItemRule.getTableShardingStrategy(), orderItemTableStrategy);

    }

}

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

+77 −0
Original line number Diff line number Diff line
@@ -17,9 +17,86 @@ 


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.BindingTableRule;

import io.shardingjdbc.core.rule.TableRule;

import io.shardingjdbc.spring.AbstractShardingBothDataBasesAndTablesSpringDBUnitTest;

import io.shardingjdbc.spring.util.FieldValueUtil;



import static org.hamcrest.CoreMatchers.is;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertThat;



import java.util.Collection;

import java.util.Iterator;

import java.util.List;



import javax.annotation.Resource;



import org.springframework.test.context.ContextConfiguration;



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

public final class WithNamespaceBindingTablesTest 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();

        assertShardingBindingTableRule();

    }

    

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

    }

    

    @SuppressWarnings("unchecked")

    private void assertShardingBindingTableRule() {

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

        assertNotNull(shardingContext);

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

        assertNotNull(shardingRule);

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

        assertNotNull(bindingTableRules);

        assertThat(((Collection<BindingTableRule>) bindingTableRules).size(), is(1));

        List<TableRule> tableRules = ((Collection<BindingTableRule>) bindingTableRules).iterator().next().getTableRules();

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

        assertThat(tableRules.get(0).getLogicTable(), is("t_order"));

        assertThat(tableRules.get(1).getLogicTable(), is("t_order_item"));

    }

}