返回顶部

收藏

Spring+iBatis+DBUnit 进行单元测试

更多

在很多成功的软件项目中,测试自动化往往是关键的层面。DBUnit允许开发人员在测试之前给目标数据库植入测试数据,在测试完毕后,再将数据库恢复到测试前的状态。在最近的一个项目中,我尝试使用用DBUnit对Spring+iBatis的架构进行测试,下面记录了DBUnit的使用过程和遇到的一些问题。

测试环境

首先,我们建立一个测试环境(基于Maven 2和Oracle数据库*)。数据表名Account。

数据库

先建立一个测试数据表(数据库为Oracle*)

Account.sql

CREATE TABLE Account
("ID" NUMBER,
  "USERNAME" VARCHAR2(256 BYTE) NOT NULL ENABLE,
  "PASSWORD" VARCHAR2(256 BYTE),
    CONSTRAINT "ACCOUNT_UK_ID" UNIQUE ("ID"),
    CONSTRAINT "ACCOUNT_PK" PRIMARY KEY ("USERNAME")
)

这里我暂时不想涉及Sequence,所以主键**是username,而不是ID,并且ID允许为NULL。这是因为Sequence的递增是不可恢复的,如果项目对记录ID是否连续不是特别在意的话,可以在自己的项目中建立,只要稍微修改一下iBatis配置文件中的SQL语句就可以了。这里我们先屏蔽这个问题。

DBUnit测试Oracle数据库时,帐户最好不要拥有DBA权限,否则会出现org.dbunit.database.AmbiguousTableNameException: COUNTRIES 错误。如果帐户必须具备DBA权限,那么就需要在执行new DatabaseConnection时,明确给定SCHEMA(名称必须大写),详细说明参考下文多处代码注释和“org.dbunit.database.AmbiguousTableNameException异常”章节。

表必须存在主键,否则返回org.dbunit.dataset.NoPrimaryKeyException错误。

Spring配置文件

ApplicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
   "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
   <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
       <property name="locations">
           <list>
               <value>classpath:database.properties</value>
           </list>
       </property>
   </bean>
   <bean id="dataSource"
      class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name="driverClassName" value="${database.connection.driver_class}"/>
      <property name="url" value="${database.connection.url}"/>
      <property name="username" value="${database.connection.username}"/>
      <property name="password" value="${database.connection.password}"/>
   </bean>
   <bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
      <property name="configLocation">
          <value>SqlMapConfig.xml</value>
      </property>
      <property name="dataSource" ref="dataSource"/>
   </bean>

   <bean id="accountManager" class="com.wang.dbunit.AccountManager">
      <property name="sqlMapClient" ref="sqlMapClient"/>
   </bean>
</beans>
database.properties
database.connection.driver_class=oracle.jdbc.driver.OracleDriver
database.connection.url=jdbc:oracle:thin:@xxx.xxx.xxx.xxx:1521:test
database.connection.username=username
database.connection.password=password

iBatis配置文件

SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig
   PUBLIC"-//iBATIS.com//DTD SQL Map Config 2.0//EN"
   "http://www.ibatis.com/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
   <settings
      useStatementNamespaces="false"
      cacheModelsEnabled="true"
      enhancementEnabled="true"
      lazyLoadingEnabled="true"
      maxRequests="32"
      maxSessions="10"
      maxTransactions="5"
   />
   <sqlMap resource="Account.xml"/>
</sqlMapConfig>

Account.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPEsqlMap
   PUBLIC"-//iBATIS.com//DTD SQL Map 2.0//EN"
   "http://www.ibatis.com/dtd/sql-map-2.dtd">
<sqlMap namespace="Account">
   <resultMap id="accountMap" class="com.wang.dbunit.Account">
      <result property="id" column="id" jdbcType="NUMBER" nullValue="0"/>
      <result property="userName" column="username" jdbcType="VARCHAR2"/>
       <result property="password" column="password" jdbcType="VARCHAR2"/>
   </resultMap>
   <!--** preserve ************************************** -->
   <sql id="id-select">
      <![CDATA[
       SELECT id_sequence.nextval AS id FROM dual
      ]]>
   </sql>
   <!--*************************************************** -->
   <sql id="account-select">
      <![CDATA[
       SELECTid, username
      ]]>
      <dynamic prepend=",">
          <isEqual
           property="includePassword"
           compareValue="true">
            password
          </isEqual>
      </dynamic>
      FROMaccount
   </sql>
   <sql id="account-where">
      <![CDATA[
       username=#userName:VARCHAR2#
      ]]>
      <dynamic>
          <isNotNull
           property="password"
           prepend="AND ">
             <![CDATA[
              password=#password:VARCHAR2#
             ]]>
          </isNotNull>
      </dynamic>
   </sql>
   <select id="getAccount"
    parameterClass="com.wang.dbunit.Account"
    resultMap="accountMap">
      <include refid="account-select"/>
      <dynamic prepend=" WHERE">
          <isNotNull
           property="userName">
             <include refid="account-where"/>
          </isNotNull>
      </dynamic>
   </select>
   <!--**************************************************** -->
   <sql id="account-insert">
      <![CDATA[
       INSERT INTO account(username, password
      ]]>
      <dynamic prepend=",">
          <isNotEqual
           property="id"
           compareValue="0">
          <![CDATA[
            id
         ]]>
          </isNotEqual>
      </dynamic>
      )
   </sql>

   <sql id="account-insert-values">
      <![CDATA[
       VALUES(#userName:VARCHAR2#, #password:VARCHAR2#
      ]]>
      <dynamic prepend=",">
          <isNotEqual
           property="id"
           compareValue="0">
          <![CDATA[
            #id:NUMBER#
         ]]>
          </isNotEqual>
      </dynamic>
      )
   </sql>
   <insert id="createAccount"
    parameterClass="com.wang.dbunit.Account">
      <isEqual
       property="generateIdFromSequence"
       compareValue="true">
          <include refid="id-select"/>
      </isEqual>
      <include refid="account-insert"/>
      <include refid="account-insert-values"/>
   </insert>
</sqlMap>

(这个配置文件中预留了未来使用 sequence 的可能)

DBUnit配置文件

我们通过一个xml种子文件(seedfile)为DBUnit提供测试数据,文件中的数据会被DBUnit在测试开始前自动植入数据表,这个文件结构很简单:

dataSet.xml

<?xml version='1.0' encoding='UTF-8'?>
<DATASET>
   <ACCOUNT id='1'
      username='Drew'
      password='Smith'/>
   <ACCOUNT id='2'
      username='Nick'
      password='Marquiss'/>
   <ACCOUNT id='3'
      username='Jose'
      password='Whitson'/>
</DATASET>

“ACCOUNT”就是表名称,它的属性就是字段内容。

代码

辅助类Accout.java

package com.wang.dbunit;
public class Account
{
   private boolean generateIdFromSequence=false;
   private boolean includePassword = false;
   private long id = 0;
   private String userName = null;
   private String password = null;
   public boolean getGenerateIdFromSequence()
   {
      return generateIdFromSequence;
   }
   public void setGenerateIdFromSequence(boolean generateIdFromSequence)
   {
      this.generateIdFromSequence =generateIdFromSequence;
   }
   public void setId(long id)
   {
      this.id =id;
   }
   public long getId()
   {
      return this.id;
   }
   public String getPassword()
   {
      return password;
   }
   public void setPassword(String password)
   {
      this.password =password;
   }
   public String getUserName()
   {
      return userName;
   }
   public void setUserName(String userName)
   {
      this.userName =userName;
   }
   public boolean isIncludePassword()
   {
      return includePassword;
   }
   public void setIncludePassword(boolean includePassword)
   {
      this.includePassword =includePassword;
   }
}

业务类AccountManager.java

package com.wang.dbunit;
import com.ibatis.sqlmap.client.SqlMapClient;
public class AccountManager
{
   protected SqlMapClient sqlMap = null;
   public void setSqlMapClient(SqlMapClient sqlMapClient)
   {
      this.sqlMap =sqlMapClient;
   }
   public Account getAccount(String userName, String password, boolean includePassword) throws Exception
   {
      Account account = new Account();
      account.setUserName(userName);
      account.setPassword(password);
      account.setIncludePassword(includePassword);
      Account ret
         = (Account)(sqlMap.queryForObject("getAccount", account));
      return ret;
   }
   public void createAccount(String userName, String password) throws Exception
   {
      Account account = new Account();
      account.setUserName(userName);
      account.setPassword(password);
      sqlMap.insert("createAccount",account);
   }
}

好了,我们完成了了全部测试环境,接下来我们要开始编写测试用例。

测试

DatabaseTestCase类

DBUnit提供了一个抽象类: DatabaseTestCase,它继承自 JUnit的 TestCase,这个类有两个方法需要重载:

protecte abstract IDatabaseConnection getConnection() throws Exception;
protected abstract IDataSet getDataSet() throws Exception;

getConnection用于告诉测试用例如何找到数据库连接;getDataSet用于告诉测试用例如何获取测试数据文件(dataSet.xml)。下面我们先继承这个抽象类编写测试用例:

package com.wang.dbunit;
import java.io.FileInputStream;
import java.sql.Connection;
import java.util.Properties;
import javax.sql.DataSource;
import com.wang.dbunit.Account;
import org.apache.log4j.Logger;
import org.apache.log4j.LogManager;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.dbunit.DatabaseTestCase;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.operation.DatabaseOperation;
public class HelloDBUnit extends DatabaseTestCase
{
   static Logger logger
      = LogManager.getLogger(HelloDBUnit.class.getName());
   privatestatic ApplicationContext context;
   protected Properties props = new Properties();
   public HelloDBUnit() throws IOException
   {
      super();
      props.load(Resources.getResourceAsStream(
         "database.properties"));
      context = newClassPathXmlApplicationContext(
         "classpath:ApplicationContext.xml");
   }
   ////////////////////////////////////////////////
   @Override
   protected IDatabaseConnection getConnection() throws Exception
   {
      DataSourcedataSource
      = (DataSource)context.getBean("dataSource");
      Connectionconnection = dataSource.getConnection();
      // 如果所用测试帐户是 DBA,为了避免出现 AmbiguousTableNameException
      // 异常,下面必须改写为 newDatabaseConnection(connection, SCHEMA)
      // 形式。注意SCHEMA 要大写**
      return new DatabaseConnection(connection);
   }
   @Override
   protected IDataSet getDataSet()throws Exception
   {
      return new FlatXmlDataSet(
               new FileInputStream("bin/dataSet.xml"));
   }
   ///////////////////////////////////////////////
   @Override
   protected DatabaseOperation getSetUpOperation() throws Exception
   {
      return DatabaseOperation.REFRESH;
   }
   @Override
   protected DatabaseOperation getTearDownOperation() throws Exception
   {
      return DatabaseOperation.NONE;
   }
   ////////////////////////////////////////////////////
   public void testSelectAccount()
   {
      AccountManager manager
         = (AccountManager)context.getBean("accountManager");
      try
      {
         Accountaccount
            = manager.getAccount("Nick", "Marquiss", true);
         assertNotNull(account);
      }
      catch (Exceptione)
      {
         logger.error(e.getMessage(),e);
      }
   }
   public void testCreateAccount()
   {
      AccountManager manager
         = (AccountManager)context.getBean("accountManager");
      try
      {
          manager.createAccount("TEST", "test");
      }
      catch(Exception e)
      {
          logger.error(e.getMessage(),e);
      }
   }
}

在getConnection方法中,我们通过Spring配置文件获得数据连接。

除了前面那两个方法外,我们还重载了 getSetUpOperation 和 getTearDownOperation 方法:DatabaseOperation.REFRESH 告诉DBUnit在测试开始前比较数据库和配置文件,如果发现测试数据不存或不一致在则插入或更新***。DatabaseOperation.NONE表示什么也不做。

这个CASE应该可以运行的很好,但是如果我们把 getTearDownOperation改成:

@Override
protected DatabaseOperation getTearDownOperation() throws Exception
{
   return DatabaseOperation.DELETE_ALL;
}

就会发生java.sql.SQLException: Closed Connection异常。这是为什么呢?问题出在DatabaseTestCase中。

参数含义

  • DatabaseOperation.CLEAN_INSERT; 先删除表中所有,再插入准备的数据
  • DatabaseOperation.REFRESH; 使用准备数据更新表,存在则update,不存在则insert
  • DatabaseOperation.DELETE; 只删除准备的数据
  • DatabaseOperation.DELETE_ALL 清除所有记录
  • DatabaseOperation.NONE; 啥都不做

java.sql.SQLException: Closed Connection异常

来看一下DatabaseTestCase的一个关键成员变量tester和有关的一些方法:

public abstract class DatabaseTestCase extends TestCase
{
   ......
   private IDatabaseTester tester;
   ......
   protected IDatabaseTester getDatabaseTester() throws Exception {
      if (this.tester == null) {
         this.tester = newDatabaseTester();
      }
      return this.tester;
   }
   ......
   protected IDatabaseTester newDatabaseTester() throws Exception{
      logger.debug("newDatabaseTester()- start");
      // 重载的 getConnection 方法,在 IDatabaseTester 里有一个同名方法。
      // 注意区分。
      final IDatabaseConnection connection = getConnection();
      final IDatabaseTester tester
         = new DefaultDatabaseTester(connection);
      return tester;
   }
   ......
   protected void setUp() throws Exception
   {
      logger.debug("setUp()- start");
      super.setUp();
      final IDatabaseTester databaseTester = getDatabaseTester();
      assertNotNull("DatabaseTesteris not set", databaseTester);
      databaseTester.setSetUpOperation(getSetUpOperation());
      databaseTester.setDataSet(getDataSet());
      databaseTester.onSetup();
   }
   ......
}

可见 DatabaseTestCase 内部有一个 IDatabaseTester 接口的实例(tester),实际上所有的测试工作是由它完成的。而DatabaseTestCase的newDatabaseTester方法在生成这个实例的时候用的是DefaultDatabaseTester。传入一个由重载的getConnection方法返回的IDatabaseConnection实例。

DefaultDatabaseTester记录了这个连接实例后,提供了一个同名的getConnection()方法(不是DatabaseTestCase中被重载的那个getConnection),用来返回它:

public class DefaultDatabaseTester extends AbstractDatabaseTester
{
   final IDatabaseConnection connection;
   public DefaultDatabaseTester(final IDatabaseConnection connection){
      this.connection= connection;
   }
   public IDatabaseConnection getConnection() throws Exception {
      return this.connection;
   }
}

因为所有的IDatabaseTester实现(包括DefaultDatabaseTester)都继承自AbatractDatabaseTester,这个抽象类有一个统一的执行数据库操作的方法executeOperation,原代码如下:

private void executeOperation(DatabaseOperation operation) throws Exception
{
   logger.debug("executeOperation(operation={})- start", operation);
   if(operation != DatabaseOperation.NONE ){
      // IDatabaseTester 的 getConnection 方法,不是重载的那个。
      IDatabaseConnection connection = getConnection();
      try{
          operation.execute(connection, getDataSet() );
      }
      finally{
         closeConnection(connection);
      }
   }
}

我们看到每执行完一次操作,数据库连接都会被关闭,所以如果继承DefaultDatabaseTester,将导致只能执行一次数据库操作。

如果希望在一个TestCase里执行两次操作,我们可以使用另一个基类

DBTestCase类

如上面所看到的,问题出在DatabaseTestCase的newDatabaseTester方法返回了一个无法重复利用的DefaultDatabaseTester实例,所以DBTestCase的newDatabaseTester方法代码变更如下:

protected IDatabaseTester newDatabaseTester() throws Exception {
   return new PropertiesBasedJdbcDatabaseTester();
}

它用来生成实例的是 PropertiesBasedJdbcDatabaseTester 类,而不是 DefaultDatabaseTester 。这个类的父类 JdbcDatabaseTester(也继承自 AbstractDatabaseTester)的 getConnection 方法:

public IDatabaseConnection getConnection() throws Exception
{
   logger.debug("getConnection() - start");
   if(!initialized ){
      // 注意这个方法,等一下详解
      initialize();
   }
   assertNotNullNorEmpty("connectionUrl", connectionUrl);
   Connection conn = null;
   if(username == null && password == null ){
      conn = DriverManager.getConnection(connectionUrl);
   }else{
      Conn = DriverManager.getConnection(connectionUrl,username,password);
   }
   return new DatabaseConnection( conn, getSchema() );
}

可以看到每次调用这个方法,都会新建一个连接,而不是简单的返回我们重载的 getConnection 中返回的连接的引用。这样就避免了 DefaultDatabaseTester 仅仅是简单返回之前的连接而倒置的问题。不过这也意味着用 DBTestCase 就不用我们自己去重载 getConnection 了,因为 DBTestCase 已经实现了这个方法(DatabaseTestCase没有实现):

protected IDatabaseConnection getConnection() throws Exception {
   logger.debug("getConnection() - start");
   final IDatabaseTester databaseTester = getDatabaseTester();
   assertNotNull( "DatabaseTester is not set",databaseTester);
   return databaseTester.getConnection();
}

我们看到DBTestCase的getConnection简单的把这个方法转给JdbcDatabaseTester(IDatabaseTester) 的getConnection。而JdbcDatabaseTester的实现我们在前面已经看到了。

现在我们把DatabaseTestCase替换成DBTestCase,并且注释掉HelloDBUnit中重载的getConnection(不再需要了,父类DBTestCase中已经实现了该方法。)然后执行,我们又遇到一个异常:

org.dbunit.AbstractDatabaseTester$AssertionFailedError:driverClass is null

这是因为PropertiesBasedJdbcDatabaseTester的initialize方法(见上面代码)用来初始化数据库连接参数:

protected void initialize() throwsException
{
   logger.debug("initialize() - start");
   setDriverClass(System.getProperty(DRIVER_CLASS));
   setConnectionUrl(System.getProperty(CONNECTION_URL));
   setUsername(System.getProperty(USERNAME));
   setPassword(System.getProperty(PASSWORD));
   // 如果所用测试帐户是 DBA,为了避免出现 AmbiguousTableNameException
   // 异常,必须明确给出 SCHEMA。注意 SCHEMA要大写**
   // setSchema(System.getProperty(SCHEMA));
   super.initialize();
}

从这里我们看到DBTestCase需要从系统变量中获得连接参数,所以我们必须修改HelloDBUnit的构造函数,将配置参数读入系统变量:

public HelloDBUnit() throws IOException
{
   super();
      props.load(Resources.getResourceAsStream("database.properties"));
      if(null == context)
      {
         context = new ClassPathXmlApplicationContext(
            "classpath:ApplicationContext.xml");
      }
   System.setProperty(
      PropertiesBasedJdbcDatabaseTester.DBUNIT_DRIVER_CLASS,
      props.getProperty("database.connection.driver_class"));
   System.setProperty(
      PropertiesBasedJdbcDatabaseTester.DBUNIT_CONNECTION_URL,
      props.getProperty("database.connection.url"));
   System.setProperty(
      PropertiesBasedJdbcDatabaseTester.DBUNIT_USERNAME,
      props.getProperty("database.connection.username"));
   System.setProperty(
      PropertiesBasedJdbcDatabaseTester.DBUNIT_PASSWORD,
      props.getProperty("database.connection.password"));
}

现在可以正确执行了。不过,这依然存在遗憾,既然我们使所有配置参数都文本化了,就不希望看到

   System.setProperty(
      PropertiesBasedJdbcDatabaseTester.DBUNIT_DRIVER_CLASS,
      props.getProperty("database.connection.driver_class"));

这样的代码,因为如果我们有多个数据源,或改变了配置文件,我们不得不还需要改变测试用例的代码。可以用DataSourceBasedDBTestCase 来解决这个问题。

DataSourceBasedDBTestCase类 DataSourceBasedDBTestCase 抽象类要求子类实现 getDataSource 方法以获取外部数据源。

首先,改变父类为 DataSourceBasedDBTestCase 。然后移除构造函数中关于系统变量的设置。最后加入以下代码:

@Override
protected DataSource getDataSource(){
   return(DataSource)context.getBean("dataSource");
}

org.dbunit.database.AmbiguousTableNameException异常

很遗憾, DataSourceBasedDBTestCase 没有提供设置 SCHEMA 的方法,虽然它的成员变量 DataSourceBasedDBTester 通过继承了 AbstractDatabaseTester 而提供了 setSchema 方法,但是因为所有的 IDatabaseTester 都是 Private 变量,因此实际上我们无法访问到它的 setSchema。所以如果使用 DataSourceBasedDBTestCase ,除非重载 setUp 和tearDown方法,否则就不能有DBA权限。

protected void setUp() throws Exception
{
   DataSource dataSource = getDataSource();
   Connection connection = dataSource.getConnection();
   IDatabaseConnection dbUnitCon
      = new DatabaseConnection(connection, "SYSTEM");
   if(getDataSet() != null)
   {
      try
      {
          getSetUpOperation().execute(dbUnitCon, getDataSet());
      }
      finally
      {
          if(connection!= null)
             connection.close();
      }
   }
}
protected void tearDown() throws Exception
{
   DataSource dataSource = getDataSource();
   Connection connection = dataSource.getConnection();
   IDatabaseConnection dbUnitCon
      = new DatabaseConnection(connection, "SYSTEM");
   if(getDataSet()!= null)
   {
      try
      {
          getTearDownOperation().execute(dbUnitCon,getDataSet());
      }
      finally
      {
          if(connection!= null)
             connection.close();
      }
   }
}

支持事务回滚

虽然DBUnit提供了一些方法让我们可以在测试开始和结束时清理数据库,但是有时候依然不能满足需求,比如在上面的代码中,我们在执行阶段插入了一条记录(见testCreateAccount方法),这种不是在种子文件中的额外数据,测试结束后除非在tearDown中返回DatabaseOperation.DELETE_ALL,否则是不会被自动删除的,可是如果删除全部数据,那么又有可能删掉了不希望删掉的数据。Spring提供了一个AbstractTransactionalDataSourceSpringContextTests测试类,这个类可以在测试结束后回滚数据库,可是DBUnit没有提供类似的机制,所以我们要进一步手工扩展测试用例,以加入类似功能。

修改ApplicationContext.xml

首先,修改Spring的配置文件ApplicationContext.xml,加入以下配置:

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   <property name="dataSource">
      <ref bean="dataSource"/>
   </property>
</bean>
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
   <property name="transactionManager">
      <ref bean="transactionManager"/>
   </property>
   <property name="transactionAttributes">
      <props>
          <prop key="*">PROPAGATION_REQUIRED</prop>
      </props>
   </property>
</bean>

如果希望业务类也支持事务处理可以加入以下配置,否则可以略过:

<bean id="accountManagerTarget" class="com.wang.dbunit.AccountManager">
   <property name="sqlMapClient" ref="sqlMapClient"/>
</bean>
<bean id="accountManager" class="org.springframework.aop.framework.ProxyFactoryBean">
   <property name="proxyInterfaces">
      <value>
          com.wang.dbunit.IAccountManager
      </value>
   </property>
   <property name="interceptorNames">
      <list>
          <idref local="transactionInterceptor" />
          <idref local="accountManagerTarget" />
      </list>
   </property>
</bean>

以上配置只作用于使业务类,因为我们的测试用例类“HelloDBUnit.java”没有出现在配置文件中,更没有设置任何拦截器,所以测试用例对数据库的所有操作(插入、清除测试数据)目前都不在拦截范围。我们必须在测试用例中手工为它加入事务处理,才可以达到我们的目的。

添加事务管理代码

添加以下属性和方法:

private TransactionStatus ts = null;
private DataSourceTransactionManager transactionManager = null;
......
protected void setUpTransaction()
{
   transactionManager
      =(DataSourceTransactionManager)context.getBean(
         "transactionManager");
   TransactionDefinition td = new DefaultTransactionDefinition();
   ts = transactionManager.getTransaction(td);
}
protected void tearDownTransaction(boolean commit)
{
   if(commit)
   {
      transactionManager.commit(ts);
   }
   else
   {
      transactionManager.rollback(ts);
   }
}

修改setUp和tearDown方法:

protected void setUp() throws Exception
{
   setUpTransaction();
   DataSourced ataSource = getDataSource();
   // 替换 Connection connection = dataSource.getConnection();
   Connection connection = DataSourceUtils.getConnection(dataSource);
   IDatabaseConnection dbUnitCon
      = new DatabaseConnection(connection, "SYSTEM");
   if(getDataSet()!= null)
   {
      try
      {
         getSetUpOperation().execute(dbUnitCon, getDataSet());
      }
      finally
      {
         if(connection!= null)
         {
            // 替换 connection.close();
            DataSourceUtils.releaseConnection(
               connection, dataSource);
          }
      }
   }
}
protected void tearDown() throws Exception
{
   DataSource dataSource = getDataSource();
   // 替换 Connection connection = dataSource.getConnection();
   Connection connection = DataSourceUtils.getConnection(dataSource);
   IDatabaseConnection dbUnitCon
      = new DatabaseConnection(connection, "SYSTEM");
   if(getDataSet() != null)
   {
      try
      {
          // 如果不希望回滚数据,传入 true 参数。
          tearDownTransaction(false);
          getTearDownOperation().execute(dbUnitCon, getDataSet());
      }
      finally
      {
         if(connection!= null)
         {
            // 替换 connection.close();
            DataSourceUtils.releaseConnection(
               connection, dataSource);
          }
      }
   }
}

最后修改getTearDownOperation,用 DELETE 替换 DELETE_ALL:

protected DatabaseOperation getTearDownOperation() throws Exception
{
    return DatabaseOperation.DELETE;
}

现在在表中随便添加一些记录,然后执行我们的测试用例,执行完后,手工添加的数据没有受到任何影响。

最后一点提示:

因为每一个 testXxx 方法时都会初始化一个测试用例,所以每执行一次 testXxxx 方法都会导致 setUp 和 tearDown 方法被调用一次,而本例的事务定义也都由 setUp 开始, tearDown 结束,也就意味着不同测试方法(同一测试用例)之间处于不同的事务范围,导致数据操作结果无法共享(如果每次 tearDown 都回滚数据)。比如在 testInsert 方法中插入数据,在 testSelect 无法获得。要解决这个问题,就要适当的修改对 setUpTransaction 和 dearDownTransaction 的调用,使得事务可以在全局范围内被多个 test 方法共享。

E:\work\bpm2_v1_00\test.xml:171: org.dbunit.dataset.NoSuchTableException: VERSION_INFO

DBunit 要求schema 大写

标签:DBUnit,单元测试,iBatis,Spring,java

收藏

1人收藏

支持

1

反对

0

相关聚客文章
  1. 博主 发表 2015-06-16 13:47:14 spring4不兼容ibatis的解决方法
  2. tdoly 发表 2014-02-18 09:29:46 使用spring+ibatis的raw sql语句的自助查询
  3. lianghaijian 发表 2014-07-24 05:02:31 Mockito、PowerMock进行Junit测试和集成Spring测试的一些总结
  4. bystander 发表 2013-09-20 07:50:46 Spring松耦合示例
  5. 刘莉莉 发表 2016-02-28 12:47:00 跟我学Spring3(8.1):对ORM的支持之概述
  6. 博主 发表 2015-06-18 08:04:10 Spring之思
  7. ajaxj 发表 2014-07-23 00:47:34 [Java][web]利用Spring随时随地获得Request和Session
  8. ajaxj 发表 2014-08-08 02:09:18 java springbatch简介与helloworld
  9. ajaxj 发表 2014-08-12 06:30:26 java Spring+MyBatis实践——MyBatis访问数据库
  10. 博主 发表 2018-04-10 11:34:22 HttpClient常用配置
  11. 博主 发表 2014-07-05 08:22:19 Quartz任务调度实践
  12. 王 雪松 发表 2014-07-17 03:35:51 Spring中的Quartz配置

发表评论