针对DAO层单元测试间断言复杂对象的解决方案
针对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();
}
}
}