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