针对DAO层单元测试中断言复杂对象的解决方案

你还在为单元测试中断言大对象而烦恼吗？那么请看。。。
现状：
目前对于 查询 的测试基本上都是通过SQL文(insert语句)准备数据，然后通过代码获取对象，然后检查对象中的数据是否正确。

当是如果一张表的数据过多，想要全部检查每个字段是否正确映射到对象的字段，需要耗费大量的繁琐又无趣的Assert语句。

如信贷系统中的DA_DRAWNDN_CONTRACT表有90多个字段，要每一个字段都Assert过来几乎不现实。

解决方案：
1、通过解析准备数据的SQL(一般都在.sql文件中)，获取每个字段对应的值；

2、再解析ibatis的配置文件(配置sql文的xml文件)，获取每个字段对应的对象属性名；

3、通过放射机制获取需要比较的对象对应属性的值，进行Assert。

具体实现：
通过继承单元测试准备数据的基类AbstractPreparedDatabaseTransactionalTests，增加方法
/**
*检查对象是否正确
*@param t 需要校验的对象
*@param i 与.sql文件中的第几条数据比较
*/
protected <T> void assertObject(T t, int i)

目前已经实现的代码附件：

 AssertObjectTransactionalTests.java

具体应用：
1.继承AssertObjectTransactionalTests

2.通过重载String getsqlMapPath()方法给出ibatis对应的xml配置文件在哪里

 如：

    /**
     * 获取SqlMap的路径
     */
    protected String getsqlMapPath() {
        return "META-INF/sqlmap/CLMS_ACCT_REL_SqlMap.xml";
    }
3.比较通过方法assertObject比较具体的对象和.sql文件中第几条准备数据

如.sql中有

insert into clms_acct_rel (ACCT_REL_ID, GMT_CREATED, GMT_CREATOR, GMT_MODIFIED, GMT_MODIFIER, IS_DELETED, ACCT_NO,
ACCT_REL_NO, ACCT_CUST_NAME, REL_TYPE, ACCT_TYPE, RELATION, USE_TYPE, REPAY_USE_TYPE, REL_START_DATE, REL_DUE_DATE,
AUTO_REPAY_AMT, AUTO_REPAY_RATE, SEND_SEQ_NO, REPAY_SEQ_NO, EMAIL, BANK_PROVINCE, BANK_CITY, BANK_ID, BANK_NAME, REL_STATUS)
values (909090, to_date('11-01-2011', 'dd-mm-yyyy'), 'test', to_date('21-01-2011', 'dd-mm-yyyy'), 'test', '0', 'ACCT000001',
 'REL000001', 'CUST_NAME', '2', '3', '4', '1', '5', to_date('20-01-2011', 'dd-mm-yyyy'), to_date('22-01-2011', 'dd-mm-yyyy'),
 10000.00000000, 50.000000, 1, 3, 'www@test1.com', '浙江', '杭州', '1', '建设银行', '1');
 testCase：

    /**
     * 测试AcctRelDO.getById
     */
    public void testGetbyId() {
        AcctRelDO ret = acctRelDao.getById(909090L);
        Assert.assertNotNull(ret);
        assertObject(ret, 1);
    }
其他
目前该类已经在信贷系统的UT中使用，还在继续完善中。

另外在AssertObjectTransactionalTests增加了一个方法<T> void assertObject(T t1, T t2)，用来断言两个对象中的所有属性值是否相等。

此方法主要真对那些没有equals() 方法的对象，使用方法。。。不解释


package com.alifi.hades.dal.dao;

import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import junit.framework.Assert;

import org.springframework.core.io.Resource;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

public class AssertObjectTransactionalTests extends SqlScriptPreparedDatabaseTransactionalTests {

    private static final String DATE_TYPE    = "DATE";
    private static final String VARCHAR_TYPE = "VARCHAR";
    private static final String CHAR_TYPE    = "CHAR";
    private static final String DECIMAL_TYPE = "DECIMAL";
    protected SimpleDateFormat  dateFormat   = new SimpleDateFormat("dd-MM-yyyy");

    protected String getsqlMapPath() {
        return null;
    }

    /**
     * 检查对象是否正确
     * 
     * @param t 需要校验的对象
     * @param i 与.sql文件中的第几条数据比较
     */
    protected <T> void assertObject(T t, int i) {

        //解析sql文件
        try {

            //如果没有给出sqlMap路径抛出异常
            if (getsqlMapPath() == null) {
                throw new Exception();
            }
            //获取所有的准备数据sql文
            List<String> lstStatement = getStatement();

            //解析sql文获取字段对应的值
            Map<String, String> col_val = parseStatement(lstStatement.get(i - 1));

            //解析sqlMap和比较数据
            parseSqlMap(getsqlMapPath(), col_val, t);

        } catch (Exception ex) {
            Assert.fail();
        }
    }

    /**
     * 解析sql文件获取sql文列表
     * 
     * @return sql文列表
     * @throws Exception
     */
    protected List<String> getStatement() throws Exception {
        List<String> lstStatement = new ArrayList<String>();

        LineNumberReader reader = null;
        Resource resource = applicationContext.getResource(getDataLocation());
        reader = new LineNumberReader(new InputStreamReader(resource.getInputStream(), "UTF-8"));
        String line = null;
        StringBuilder statement = new StringBuilder();
        while ((line = reader.readLine()) != null) {
            line = line.trim();
            if (line.endsWith(";")) {
                statement.append(" ").append(line.substring(0, line.length() - 1));
                lstStatement.add(statement.toString());
                statement = new StringBuilder();
            } else {
                statement.append(" ").append(line);
            }
        }
        return lstStatement;
    }

    /**
     * 解析sql文获取每一字段对应的值
     * 
     * @param statement sql文
     * @return 每一字段对应的值
     * @throws Exception
     */
    protected Map<String, String> parseStatement(String statement) throws Exception {

        Map<String, String> col_val = new HashMap<String, String>();

        String[] statementPart = statement.split("values");
        String columnStatement = statementPart[0].substring(statementPart[0].indexOf('(') + 1,
                statementPart[0].lastIndexOf(')'));
        String valueStatement = statementPart[1].substring(statementPart[1].indexOf('(') + 1,
                statementPart[1].lastIndexOf(')'));

        String[] columns = columnStatement.split(",");
        valueStatement = valueStatement.replaceAll("to_date *\\(", "")
                .replaceAll(", *'dd-mm-yyyy'\\)", "").replaceAll("'", "");
        String[] values = valueStatement.split(",");

        for (int i = 0; i < columns.length; i++) {
            col_val.put(columns[i].trim(), ("".equals(values[i].trim()) || "null".equals(values[i]
                    .trim())) ? null : values[i].trim());
        }

        return col_val;
    }

    /**
     * 通过解析SqlMap获取column对应的属性名和类型，并通过放射规则和对象t进行比较
     * 
     * @param <T>
     * @param sqlMapPath sqlMap路径
     * @param col_val 每一字段对应的值
     * @param t 需要比较的对象
     * @throws Exception
     */
    protected <T> void parseSqlMap(String sqlMapPath, Map<String, String> col_val, T t)
            throws Exception {

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Resource resource = applicationContext.getResource(sqlMapPath);
        Document doc = builder.parse(resource.getInputStream());
        NodeList nl = doc.getElementsByTagName("result");

        String column;
        String type;
        String property;
        Object value;
        for (int i = 0; i < nl.getLength(); i++) {
            column = nl.item(i).getAttributes().getNamedItem("column").getNodeValue();
            type = nl.item(i).getAttributes().getNamedItem("jdbcType").getNodeValue();
            property = nl.item(i).getAttributes().getNamedItem("property").getNodeValue();

            if (DATE_TYPE.equals(type)) {
                value = t
                        .getClass()
                        .getMethod(
                                "get" + property.substring(0, 1).toUpperCase()
                                        + property.substring(1)).invoke(t);
                if (col_val.get(column) != null) {
                    Assert.assertEquals(dateFormat.parse(col_val.get(column)), (Date) value);
                } else {
                    Assert.assertEquals(col_val.get(column), value);
                }
            } else if (VARCHAR_TYPE.equals(type) || CHAR_TYPE.equals(type)) {
                value = t
                        .getClass()
                        .getMethod(
                                "get" + property.substring(0, 1).toUpperCase()
                                        + property.substring(1)).invoke(t);
                if (col_val.get(column) != null) {
                    Assert.assertEquals(col_val.get(column), String.valueOf(value).trim());
                } else {
                    Assert.assertEquals(col_val.get(column), value);
                }
            } else if (DECIMAL_TYPE.equals(type)) {

                value = t
                        .getClass()
                        .getMethod(
                                "get" + property.substring(0, 1).toUpperCase()
                                        + property.substring(1)).invoke(t);
                if (col_val.get(column) != null) {
                    Assert.assertEquals(0, new BigDecimal(value.toString())
                            .compareTo(new BigDecimal(col_val.get(column))));
                } else {
                    Assert.assertEquals(col_val.get(column), value);
                }
            }
        }
    }

    /**
     * 比较两个对象里的属性值
     * 
     * @param t1 对象1
     * @param t2 对象2
     */
    protected <T> void assertObject(T t1, T t2) {
        Method[] methods = t1.getClass().getMethods();

        try {
            for (Method method : methods) {
                if (method.getName().startsWith("get") && !"getClass".equals(method.getName())) {
                    if (method.invoke(t1) == null) {
                        continue;
                    }
                    if (method.getReturnType() == String.class) {
                        Assert.assertEquals(method.invoke(t1).toString().trim(), method.invoke(t2)
                                .toString().trim());
                    } else if (method.getReturnType() == Date.class) {
                        Assert.assertEquals(dateFormat.format(method.invoke(t1)),
                                dateFormat.format(method.invoke(t1)));
                    } else {
                        Assert.assertEquals(0, new BigDecimal(method.invoke(t1).toString())
                                .compareTo(new BigDecimal(method.invoke(t2).toString())));
                    }
                }
            }
        } catch (Exception e) {
            Assert.fail();
        }
    }
}