Junit的使用

1， junit的安装和调试原则

　　1）导入junit的jar包，这里使用junit4.10， 不建议使用Eclipse自带的.

　　2）创建测试类的原则：

　　　　在Eclipse中创建一个source folder 命名为test

　　　　创建测试类所在的包，包名与要测试的类的包名一致

　　3）Junit3 和Junit4的区别是比较大的

　　　　在Junit3中，如果某个类是测试类，必须继承TestCase，如果某个方法是测试方法，这个方法必须是testXXX的形式;

　　　　在Junit3中，如果希望指定某个测试方法运行之前运行某个初始化方法，这个方法的名称必须是setUp()，如果希望在某个测试方法运行之后运行某个释放资源的方法，这个方法的名称必须是 tearDown.

　　　　在Junit4中，一个Pojo类就是一个测试类，测试方法通过@Test标识，初始化方法通过@Before标识，释放资源的方法通过@After标识。但是为了让Junit4中的测试类在Junit3中也可以使用，习惯上把初始化方法命名为setUp，释放资源的方式命名为tearDown，测试方法也同样以test开头.

　　3）断言的使用

　　　　在Junit4中提供了一个Assert的类，这个类中有大量的方法进行断言处理，在Junit3中由于继承了TestCase类，TestCase类提供了大量的assert方法.

2， 第一个简单的Junit测试例子

package com.yangw.util;

public class Calcuate {

public int add(int a,int b){
return a+b;
}

public int divide(int a,int b){
return a/b;
}

}

package com.yangw.util;

import static junit.framework.Assert.*;

import org.junit.Before;
import org.junit.Test;

public class TestCalcuate {

Calcuate cal;

// 执行任意测试方法之前都会执行该方法
@Before
public void setUp(){
cal = new Calcuate();
}

@Test
public void testAdd(){
/**
* 简单断言的编写
* 参数1： 表示如果出差给出的错误信息
* 参数2：表示方法执行完成之后预期的一个值
* 参数3：表示实际值
*/
//Assert.assertEquals("加法有问题", cal.add(1, 2),3);
// 将Assert所有的静态方法静态导入，这样不用添加类名从而有效兼容junit3
assertEquals("加法有问题", cal.add(1, 2),3);
}

@Test
public void testDivide(){
assertEquals("除法有问题", cal.divide(4, 2),2);
}

//表示这个方法应该抛出ArithmeticException异常，如果不抛出就报错
@Test(expected=ArithmeticException.class)
public void testDivideException(){
cal.divide(4, 0);
}

//表示这个方法要在300毫秒以内完成.
// 可以进行简单的性能测试.
@Test(timeout=300)
public void testTime() throws Exception{
Thread.sleep(500);
}

}

3，dbunit的使用.

　　1), 导入 dbunit-2.4.9.jar、slf4j-api-1.6.1.jar

　　2), 创建dbunit的测试数据xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!-- dataset根标签 -->
<dataset>
<!-- 表信息 -->
<!-- 第一种方式  基于节点的方式-->
<!--
<t_user>
<id>1</id>
<username>yangw</username>
<password>123456</password>
</t_user>
-->
<!-- 第二种方式 -->
<!-- 基于属性的方式 -->
<t_user id="1" username="yangw" password="123456" />
</dataset>

　　3), 创建dbunit的Connection

　　dbunit的Connection是用来对数据文件进行操作的，这个Connection必须依赖于目前项目中所使用的Connection.

IDatabaseConnection conn=new DatabaseConnection(DBUtil.getConnection());

　　4), 创建IDataSet,通过DataSet来获取测试数据文件中的数据

//如果xml是基于节点的使用XmlDataSet ，如果是基于属性的使用 FlatXmlDataSet
IDataSet ds = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(TestDbunit.class.getClassLoader().getResourceAsStream("t_user.xml"))));

　　5), 初始化数据并且完成测试

　　

　　　　　　// 清空数据库中的数据，插入xml中的数据
DatabaseOperation.CLEAN_INSERT.execute(conn, ds);
//DatabaseOperation.DELETE 删除数据库中存在的xml数据
//DatabaseOperation.DELETE_ALL 删除数据库中所有的数据
//DatabaseOperation.INSERT 插入xml中的测试数据
//DatabaseOperation.NONE  什么都不做
//DatabaseOperation.REFRESH 刷新数据库中的数据
//DatabaseOperation.TRUNCATE_TABLE 清空数据库表中的数据
//DatabaseOperation.UPDATE 把数据库中的数据更新为xml中目前指定的数据

//从Dao中获取数据并完成测试
IUserDao ud = new UserDao();
User u = ud.load("yangw");
Assert.assertEquals(u.getId(), 1);
Assert.assertEquals(u.getUsername(), "yangw");
Assert.assertEquals(u.getPassword(), "123456");

　6) 备份和还原数据库

　　6.1. 备份：

　　

　　/**
　　* 备份数据库中所有的表
　　*/

　　@Test
public void testBackup(){
try {
IDatabaseConnection conn=new DatabaseConnection(DBUtil.getConnection());
//根据Conn来创建DataSet，这个DataSet包含了所有的表
IDataSet ds =conn.createDataSet();
//将ds中的数据通过FlatXmlDataSet格式写到文件中
FlatXmlDataSet.write(ds, new FileWriter("d://test.xml"));
} catch (DataSetException e) {
e.printStackTrace();
} catch (DatabaseUnitException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

/**
* 备份某些指定的表
*/
@Test
public void testBackupOne(){
try {
IDatabaseConnection conn=new DatabaseConnection(DBUtil.getConnection());
//根据Conn来创建DataSet，这个DataSet包含了所有的表
QueryDataSet qds =new QueryDataSet(conn);
//添加t_user这张表为要备份的表
qds.addTable("t_user");
//将ds中的数据通过FlatXmlDataSet格式写到文件中
FlatXmlDataSet.write(qds, new FileWriter("d://test.xml"));
} catch (DataSetException e) {
e.printStackTrace();
} catch (DatabaseUnitException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

　　6.2 还原

　　

　　/**
* 还原数据库
*/
@Test
public void testResume(){
try {
IDatabaseConnection conn=new DatabaseConnection(DBUtil.getConnection());
//根据备份文件创建dataset
IDataSet ds = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(new FileInputStream("d://test.xml"))));
// 清空数据库中的数据，插入xml中的数据
DatabaseOperation.CLEAN_INSERT.execute(conn, ds);

} catch (DatabaseUnitException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

将备份、还原操作写成一个工具测试类，以后其它测试类只要继承它即可.

package frame.base.util;

import static org.junit.Assert.assertNotNull;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;

import org.dbunit.DatabaseUnitException;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.dataset.xml.FlatXmlProducer;
import org.dbunit.operation.DatabaseOperation;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.xml.sax.InputSource;

/**
* 基于DBunit的测试工具类
* @author yangw@eastcom.com
*
*/
public class AbstractDBUtilTestCase {

// dbunit的数据库连接
public static IDatabaseConnection dbunitConn;
private File tempFile;
@BeforeClass
// 在构造之前执行，仅仅执行一次
public static void init() throws DatabaseUnitException, SQLException{
dbunitConn = new DatabaseConnection(JdbcUtil.getDBConnection());
}

/**
* 根据指定的测试文件(xml)获取IDataSet
* @param tname ,一般情况下，测试的xml文件就用表名命名.
* @return
* @throws DataSetException
* @throws IOException
*/
protected IDataSet createDataSet(String tname) throws DataSetException, IOException{

InputStream is=AbstractDBUtilTestCase
.class
.getClassLoader()
.getResourceAsStream("dbunit_xml/"+tname+".xml");

assertNotNull("dbunit的基本数据文件不存在!", is);

//如果xml是基于节点的使用XmlDataSet ，如果是基于属性的使用 FlatXmlDataSet

return new FlatXmlDataSet(new FlatXmlProducer(new InputSource(is)));
}

/**
* 备份数据库所有的表
* @throws DataSetException
* @throws IOException
* @throws SQLException
*/
protected void backupAllTable() throws DataSetException, IOException, SQLException{

IDataSet ds = dbunitConn.createDataSet();
writeBackupFile(ds);
}
/**
* 备份数据库指定的表
* @param tNames 表名
* @throws DataSetException
* @throws IOException
* @throws SQLException
*/
protected void backupCustomTable(String[] tNames) throws DataSetException, IOException, SQLException{

QueryDataSet qds =new QueryDataSet(dbunitConn);

for(String tName:tNames){
qds.addTable(tName);
}
writeBackupFile(qds);
}

/**
* 备份一张指定的表
* @param tName 表名
* @throws DataSetException
* @throws IOException
* @throws SQLException
*/
protected void backupOneTable(String tName) throws DataSetException, IOException, SQLException{

backupCustomTable(new String[]{tName});
}

private void writeBackupFile(IDataSet ds) throws DataSetException, IOException{
//将ds中的数据通过FlatXmlDataSet格式写到文件中
tempFile = File.createTempFile("back", "xml");
FlatXmlDataSet.write(ds, new FileWriter(tempFile));
}

/**
* 还原数据库
* @throws FileNotFoundException
* @throws DatabaseUnitException
* @throws SQLException
*/
protected void resumeTable() throws FileNotFoundException, DatabaseUnitException, SQLException{

InputStream is = new FileInputStream(tempFile);

IDataSet ds = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(is)));
// 清空数据库中的数据，插入xml中的数据
DatabaseOperation.CLEAN_INSERT.execute(dbunitConn, ds);

}

@AfterClass
public static void destory(){
if(dbunitConn!=null){
try {
dbunitConn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}