junit+dbunit

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量168 收藏
点赞数
文章标签： java 数据库 python
原文链接：https://my.oschina.net/iamhere/blog/524623
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

目录结构： 


D:\code\kongee\junit_01>tree /f
卷 软件 的文件夹 PATH 列表
卷序列号为 000D-CD8E
D:.
│  .classpath
│  .project
│  student-init.sql
│
├─.settings
│      org.eclipse.jdt.core.prefs
│
├─bin
│  │  student.xml
│  │
│  ├─com
│  │  └─laolang
│  │      ├─dao
│  │      │      StudentDao.class
│  │      │      StudentDaoImpl.class
│  │      │      TestDbUnit.class
│  │      │      TestDbUnit2.class
│  │      │
│  │      ├─modle
│  │      │      Cal.class
│  │      │      Student.class
│  │      │      TestA.class
│  │      │      TestCal.class
│  │      │      TestSuite.class
│  │      │
│  │      └─util
│  │              AbstractTestDbunitCase.class
│  │              DButil.class
│  │              EntitiesHelper.class
│  │              student-sql.properties
│  │
│  └─dbunit-xml
│          student.xml
│
├─lib
│      dbunit-2.4.9.jar
│      hamcrest-all-1.3.jar
│      hamcrest-core-1.3.jar
│      junit-4.11.jar
│      mysql-connector-java-5.1.28-bin.jar
│      slf4j-api-1.6.1.jar
│      slf4j-nop-1.7.12.jar
│
├─src
│  └─com
│      └─laolang
│          ├─dao
│          │      StudentDao.java
│          │      StudentDaoImpl.java
│          │
│          ├─modle
│          │      Cal.java
│          │      Student.java
│          │
│          └─util
│                  AbstractTestDbunitCase.java
│                  DButil.java
│                  EntitiesHelper.java
│                  student-sql.properties
│
└─test
    │  student.xml
    │
    ├─com
    │  └─laolang
    │      ├─dao
    │      │      TestDbUnit.java
    │      │      TestDbUnit2.java
    │      │
    │      └─modle
    │              TestA.java
    │              TestCal.java
    │              TestSuite.java
    │
    └─dbunit-xml
            student.xml


D:\code\kongee\junit_01>



student-init.sql 


create table student (
	stuid int primary key auto_increment,
	stuname varchar(20),
	stuage int,
	stusex varchar(2)
)engine=innodb;


insert into student values 
(1001,'小代码',24,'男'),
(1002,'小叶子',25,'女'),
(1003,'老狼',34,'男'),
(1004,'龙女',43,'女'),
(1005,'天涯',18,'男');


src

com.laolang.dao.StudentDao 


package com.laolang.dao;

import com.laolang.modle.Student;

public interface StudentDao {

	public void add( Student stu ) ;
	
	public void delete ( int stuid );
	
	public Student selectById( int stuid );
	
	public Student selectByName( String stuname );
}

com.laolang.dao.StudentDaoImpl 



package com.laolang.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.laolang.modle.Student;
import com.laolang.util.DButil;

public class StudentDaoImpl implements StudentDao{

	@Override
	public void add(Student stu) {
		Connection conn = null;
		PreparedStatement ps = null;
		
		try {
			conn = DButil.getConnection();
			String sql = "insert into student (stuname,stuage,stusex) values (?,?,?)";
//			System.out.println("sql:"+sql);
			ps = conn.prepareStatement(sql);
//			ps.setInt(1, stu.getStuId());
			ps.setString(1, stu.getStuName());
			ps.setInt(2, stu.getStuAge());
			ps.setString(3, stu.getStuSex());
			ps.executeUpdate();
			
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			DButil.close(ps);
			DButil.close(conn);
		}
	}

	@Override
	public void delete(int stuid) {
		Connection conn = null;
		PreparedStatement ps = null;
		
		try {
			conn = DButil.getConnection();
			String sql = "delete from student where stuid = ?";
			ps = conn.prepareStatement(sql);
			ps.setInt(1, stuid);
			ps.executeUpdate();
			
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			DButil.close(ps);
			DButil.close(conn);
		}
	}

	@Override
	public Student selectById(int stuid) {
		Student stu = null;
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			conn = DButil.getConnection();
			String sql = "select stuid,stuname,stuage,stusex from student where stuid = ?";
			ps = conn.prepareStatement(sql);
			ps.setInt(1, stuid);
			rs = ps.executeQuery();
			
			while(rs.next()){
				if( null == stu ){
					stu = new Student();
				}
				stu.setStuId(stuid);
				stu.setStuName(rs.getString("stuname"));
				stu.setStuAge(rs.getInt("stuage"));
				stu.setStuSex(rs.getString("stusex"));
			}
			
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			DButil.close(rs);
			DButil.close(ps);
			DButil.close(conn);
		}
		
		
		
		return stu;
	}

	@Override
	public Student selectByName(String stuname) {
		Student stu = null;
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			conn = DButil.getConnection();
			String sql = "select stuid,stuname,stuage,stusex from student where stuname = ?";
			ps = conn.prepareStatement(sql);
//			ps.setInt(1, stuid);
			ps.setString(1, stuname);
			rs = ps.executeQuery();
			
			while(rs.next()){
				if( null == stu ){
					stu = new Student();
				}
				stu.setStuId(rs.getInt("stuid"));
				stu.setStuName(rs.getString("stuname"));
				stu.setStuAge(rs.getInt("stuage"));
				stu.setStuSex(rs.getString("stusex"));
			}
//			System.out.println(stu.toString());
			
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			DButil.close(rs);
			DButil.close(ps);
			DButil.close(conn);
		}
		
		
		
		return stu;
	}

}

com.laolang.modle.Student 



package com.laolang.modle;

public class Student {

	public Student() {
		super();
	}

	public Student(String stuName, int stuAge, String stuSex) {
		super();
		this.stuName = stuName;
		this.stuAge = stuAge;
		this.stuSex = stuSex;
	}

	public Student(int stuId, String stuName, int stuAge, String stuSex) {
		super();
		this.stuId = stuId;
		this.stuName = stuName;
		this.stuAge = stuAge;
		this.stuSex = stuSex;
	}

	@Override
	public String toString() {
		return "Student [stuId=" + stuId + ", stuName=" + stuName + ", stuAge="
				+ stuAge + ", stuSex=" + stuSex + "]";
	}

	public int getStuId() {
		return stuId;
	}

	public void setStuId(int stuId) {
		this.stuId = stuId;
	}

	public String getStuName() {
		return stuName;
	}

	public void setStuName(String stuName) {
		this.stuName = stuName;
	}

	public int getStuAge() {
		return stuAge;
	}

	public void setStuAge(int stuAge) {
		this.stuAge = stuAge;
	}

	public String getStuSex() {
		return stuSex;
	}

	public void setStuSex(String stuSex) {
		this.stuSex = stuSex;
	}

	int stuId;
	String stuName;
	int stuAge;
	String stuSex;
}

com.laolang.util.AbstractTestDbunitCase 



package com.laolang.util;

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 junit.framework.Assert;

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;

@SuppressWarnings("deprecation")
public abstract class AbstractTestDbunitCase {

	@BeforeClass
	public static void init() throws DatabaseUnitException, SQLException {
		dconn = new DatabaseConnection(DButil.getConnection());
	}
	
	protected IDataSet createDataset(String tablename ) throws DataSetException{
		InputStream is = AbstractTestDbunitCase.class.getClassLoader().getResourceAsStream("dbunit-xml/"+tablename+".xml");
		Assert.assertNotNull("dbunit xml数据文件未找到",is);
		return new FlatXmlDataSet( new FlatXmlProducer(new InputSource(is)));
		
	}
	
	protected void backupAllTable() throws SQLException, IOException, DataSetException{
		IDataSet dataset = dconn.createDataSet();
		writeBackupFile(dataset);
	}
	
	private void writeBackupFile(IDataSet ds) throws IOException, DataSetException{
		tempfile = File.createTempFile("back","xml");
		FlatXmlDataSet.write(ds, new FileWriter(tempfile));
	}
	
	protected void backupCustomTable(String[] tname) throws DataSetException, IOException {
		QueryDataSet ds = new QueryDataSet(dconn);
		for(String str:tname) {
			ds.addTable(str);
		}
		writeBackupFile(ds);
	}
	
	protected void bakcupOneTable(String tname) throws DataSetException, IOException {
		backupCustomTable(new String[]{tname});
	}
	
	protected void resumeTable() throws FileNotFoundException, DatabaseUnitException, SQLException {
		IDataSet ds = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(new FileInputStream(tempfile))));
		DatabaseOperation.CLEAN_INSERT.execute(dconn, ds);
	}
	
	

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

	public static IDatabaseConnection dconn;
	private File tempfile;
}

com.laolang.util.DBUtil 



package com.laolang.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ResourceBundle;

public class DButil {
	
	
	

	/** 数据库连接地址 */
	private static String URL;

	/** 数据库用户名 */
	private static String USERNAME;

	/** 数据库密码 */
	private static String USERPASSWORD;

	/** mysql 驱动 */
	private static String DRIVER;

	/** The rb. */
	private static ResourceBundle rb = ResourceBundle
			.getBundle("com.laolang.util.student-sql");

	/**
	 * 使用静态代码块加载驱动
	 */
	static {
		URL = rb.getString("jdbc.url");
		USERNAME = rb.getString("jdbc.username");
		USERPASSWORD = rb.getString("jdbc.userpassword");
		DRIVER = rb.getString("jdbc.driver");

		try {
			Class.forName(DRIVER);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	public static Connection getConnection() throws SQLException {
		Connection con = null;
		con = DriverManager.getConnection(
				URL, USERNAME, USERPASSWORD);
		return con;
	}

	public static void close(Connection con) {
		try {
			if (con != null)
				con.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	public static void close(PreparedStatement ps) {
		try {
			if (ps != null)
				ps.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	public static void close(ResultSet rs) {
		try {
			if (rs != null)
				rs.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}




student-sql.properties 


jdbc.url=jdbc:mysql://localhost:3306/student
jdbc.username=root
jdbc.userpassword=root
jdbc.driver=com.mysql.jdbc.Driver

EntitiesHelper 



package com.laolang.util;

import org.junit.Assert;

import com.laolang.modle.Student;

public class EntitiesHelper {

	public static void assertUser(Student expected,Student actual) {
		Assert.assertNotNull(expected);
		Assert.assertEquals(expected.getStuId(), actual.getStuId());
		Assert.assertEquals(expected.getStuName(), actual.getStuName());
		Assert.assertEquals(expected.getStuAge(), actual.getStuAge());
		Assert.assertEquals(expected.getStuSex(), actual.getStuSex());
	}
	
}




test

com.laolang.dao.TestDbUnit 


package com.laolang.dao;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
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.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.dataset.xml.FlatXmlProducer;
import org.dbunit.operation.DatabaseOperation;
import org.junit.Test;
import org.xml.sax.InputSource;

import com.laolang.modle.Student;
import com.laolang.util.DButil;








import static org.junit.Assert.*;

public class TestDbUnit {

	@Test
	public void testselectbyid() {
		
		try {
			testbackupAll();
			IDatabaseConnection dconn = new DatabaseConnection(
					DButil.getConnection());
			IDataSet dataset = new FlatXmlDataSet(new FlatXmlProducer(
					new InputSource(TestDbUnit.class.getClassLoader()
							.getResourceAsStream("student.xml"))));
			
			DatabaseOperation.CLEAN_INSERT.execute(dconn, dataset);
			
			StudentDao dao = new StudentDaoImpl();
			Student stu = dao.selectById(1009);
			if( null == stu ){
				System.out.println("stu == null");
			}
			System.out.println(stu.toString());
			assertEquals(stu.getStuId(), 1009);
			assertEquals(stu.getStuName(), "程序员");
			assertEquals(stu.getStuAge(), 99);
			assertEquals(stu.getStuSex(), "男");
			
		} catch (DatabaseUnitException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		testresume();
	}
	
//	@Test
	public void testbackupAll(){
		try {
			IDatabaseConnection dconn = new DatabaseConnection(DButil.getConnection());
			IDataSet dataset = dconn.createDataSet();
			FlatXmlDataSet.write(dataset, new FileWriter("d:/test.xml"));
		} catch (DatabaseUnitException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
//	@Test
	public void testbackupTable(){
		try {
			IDatabaseConnection dconn = new DatabaseConnection(DButil.getConnection());
			QueryDataSet qds = new QueryDataSet(dconn);
			qds.addTable("student");
			FlatXmlDataSet.write(qds, new FileWriter("d:/teststudent.xml"));
		} catch (DatabaseUnitException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
//	@Test
	public void  testresume(){
			try {
				IDatabaseConnection dconn = new DatabaseConnection(DButil.getConnection());
				IDataSet dataset = new FlatXmlDataSet( new FlatXmlProducer(new InputSource(new FileInputStream("d:/test.xml"))));
				DatabaseOperation.CLEAN_INSERT.execute(dconn, dataset);
				
			} catch (DatabaseUnitException e) {
				e.printStackTrace();
			} catch (SQLException e) {
				e.printStackTrace();
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
	}
}

com.laolang.dao.TestDbUtils2 


package com.laolang.dao;



import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;

import org.dbunit.DatabaseUnitException;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.operation.DatabaseOperation;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import static org.junit.Assert.*;

import com.laolang.modle.Student;
import com.laolang.util.AbstractTestDbunitCase;
import com.laolang.util.DButil;
import com.laolang.util.EntitiesHelper;

public class TestDbUnit2 extends AbstractTestDbunitCase{
	
	private IDataSet ds;
	private StudentDao studao;
	private IDatabaseConnection dconn;
	
	
	@Before
	public void setUp() throws DataSetException, IOException {
		//初始化
		studao = new StudentDaoImpl();
		bakcupOneTable("student");
		ds = createDataset("student");
		try {
			dconn = new DatabaseConnection(DButil.getConnection());
		} catch (DatabaseUnitException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	@Test
	public void testSelectById(){
		try {
			DatabaseOperation.CLEAN_INSERT.execute(dconn, ds);
			Student stu = studao.selectById(1009);
			assertEquals(stu.getStuId(), 1009);
			assertEquals(stu.getStuName(), "程序员");
			assertEquals(stu.getStuAge(), 99);
			assertEquals(stu.getStuSex(), "男");
			
		} catch (DatabaseUnitException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	
	@Test
	public void testAdd(){
//		DatabaseOperation.TRUNCATE_TABLE.execute(dbunitCon, ds);
//		User u = new User(1,"admin","123","管理员");
//		us.add(u);
//		User tu = us.load("admin");
//		EntitiesHelper.assertUser(tu, u);
		
		try {
			DatabaseOperation.TRUNCATE_TABLE.execute(dconn, ds);
//			DatabaseOperation
			Student stu = new Student(1,"1010",100,"男");
			studao.add(stu);
//			Student tstu = studao.selectById(1010);
			Student tstu = studao.selectById(1);
			assertNotNull(tstu);
			EntitiesHelper.assertUser(stu, tstu);
			
//			assertEquals(stu.getStuId(), tstu.getStuId());
//			System.out.println("stu.stuid:"+stu.getStuId());
//			System.out.println("tstu.stuid:"+tstu.getStuId());
//			assertEquals(stu.getStuName(), tstu.getStuName());
//			assertEquals(stu.getStuAge(), tstu.getStuAge());
//			assertEquals(stu.getStuSex(), tstu.getStuSex());
		} catch (DatabaseUnitException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
	}
	
	@After
	public void testResume(){
		try {
			resumeTable();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (DatabaseUnitException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	
	
	

//	@Test
//	public void testselectbyid() {
//		
//		try {
//			testbackupAll();
//			IDatabaseConnection dconn = new DatabaseConnection(
//					DButil.getConnection());
//			IDataSet dataset = new FlatXmlDataSet(new FlatXmlProducer(
//					new InputSource(TestDbUnit2.class.getClassLoader()
//							.getResourceAsStream("student-dbunit.xml"))));
//			
//			DatabaseOperation.CLEAN_INSERT.execute(dconn, dataset);
//			
//			StudentDao dao = new StudentDaoImpl();
//			Student stu = dao.selectById(1009);
//			if( null == stu ){
//				System.out.println("stu == null");
//			}
//			System.out.println(stu.toString());
//			assertEquals(stu.getStuId(), 1009);
//			assertEquals(stu.getStuName(), "程序员");
//			assertEquals(stu.getStuAge(), 99);
//			assertEquals(stu.getStuSex(), "男");
//			
//		} catch (DatabaseUnitException e) {
//			e.printStackTrace();
//		} catch (SQLException e) {
//			e.printStackTrace();
//		}
//		testresume();
//	}
//	
	@Test
//	public void testbackupAll(){
//		try {
//			IDatabaseConnection dconn = new DatabaseConnection(DButil.getConnection());
//			IDataSet dataset = dconn.createDataSet();
//			FlatXmlDataSet.write(dataset, new FileWriter("d:/test.xml"));
//		} catch (DatabaseUnitException e) {
//			e.printStackTrace();
//		} catch (SQLException e) {
//			e.printStackTrace();
//		} catch (IOException e) {
//			e.printStackTrace();
//		}
//	}
//	
	@Test
//	public void testbackupTable(){
//		try {
//			IDatabaseConnection dconn = new DatabaseConnection(DButil.getConnection());
//			QueryDataSet qds = new QueryDataSet(dconn);
//			qds.addTable("student");
//			FlatXmlDataSet.write(qds, new FileWriter("d:/teststudent.xml"));
//		} catch (DatabaseUnitException e) {
//			e.printStackTrace();
//		} catch (SQLException e) {
//			e.printStackTrace();
//		} catch (IOException e) {
//			e.printStackTrace();
//		}
//	}
//	
	@Test
//	public void  testresume(){
//			try {
//				IDatabaseConnection dconn = new DatabaseConnection(DButil.getConnection());
//				IDataSet dataset = new FlatXmlDataSet( new FlatXmlProducer(new InputSource(new FileInputStream("d:/test.xml"))));
//				DatabaseOperation.CLEAN_INSERT.execute(dconn, dataset);
//				
//			} catch (DatabaseUnitException e) {
//				e.printStackTrace();
//			} catch (SQLException e) {
//				e.printStackTrace();
//			} catch (FileNotFoundException e) {
//				e.printStackTrace();
//			}
//	}
}


xml


test/dbunit-xml/student.xml 


<?xml version="1.0" encoding="UTF-8"?>
<dataset>
	<student stuid="1009" stuname="程序员" stuage="99" stusex="男"></student>
</dataset>
test/student.xml 



<?xml version="1.0" encoding="UTF-8"?>
<dataset>
	<student stuid="1009" stuname="程序员" stuage="99" stusex="男"></student>
</dataset>


基本流程

1、根据数据库中的表结构写xml文件

2、写备份和恢复函数 


protected void backupAllTable() throws SQLException, IOException, DataSetException{
		IDataSet dataset = dconn.createDataSet();
		writeBackupFile(dataset);
	}
	
	private void writeBackupFile(IDataSet ds) throws IOException, DataSetException{
		tempfile = File.createTempFile("back","xml");
		FlatXmlDataSet.write(ds, new FileWriter(tempfile));
	}
	
	protected void backupCustomTable(String[] tname) throws DataSetException, IOException {
		QueryDataSet ds = new QueryDataSet(dconn);
		for(String str:tname) {
			ds.addTable(str);
		}
		writeBackupFile(ds);
	}
	
	protected void bakcupOneTable(String tname) throws DataSetException, IOException {
		backupCustomTable(new String[]{tname});
	}
	
	protected void resumeTable() throws FileNotFoundException, DatabaseUnitException, SQLException {
		IDataSet ds = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(new FileInputStream(tempfile))));
		DatabaseOperation.CLEAN_INSERT.execute(dconn, ds);
	}
3、在测试用例中，@Before调用备份


4、测试代码中，使用DatabaseOperation将测试数据插入数据库中

5、@After调用恢复




















转载于:https://my.oschina.net/iamhere/blog/524623

weixin_33921089
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot+dbunit+h2实现单测
shenya2的专栏
12-19 1453
在编写单测的过程中，我们应该尽可能的减少单测实例对第三方组件/服务的依赖。本章主要讲解springboot如何通过dbunit+h2实现脱离数据库独立执行单测实例。 1、pom.xml添加依赖，springboot默认已配置相关版本，只需要直接引入依赖即可 <!-- 单测依赖模块 --> <dependency> <groupId>org.springframework.boot</groupId> <a..
Spring + DbUnit 测试
zsensei的博客
11-11 5584
Spring dbunitspring-test-dbunit 提供了 Spring 与 DbUnit 的集成，在 Spring 中我们可以使用注解来进行数据的准备和清理。配置为了使用 DbUnit 的注解，我们需要使用 DbUnitTestExecutionListener 类，下面是典型的使用 JUnit 4 的注解@RunWith(SpringJUnit4ClassRunner.class)
dbunit java_junit+dbunit
weixin_30653091的博客
02-23 129
目录结构：D:\code\kongee\junit_01>tree /f卷 软件 的文件夹 PATH 列表卷序列号为 000D-CD8ED:.│ .classpath│ .project│ student-init.sql│├─.settings│ org.eclipse.jdt.core.prefs│├─bin│ │ student.xml│ ││ ├─com│ ...
spring test+junit+dbunit注解及使用说明
beijicy的专栏
08-12 1877
转自：http://www.programgo.com/article/88183221961/ TestContext 测试框架的核心由 org.springframework.test.context 包中三个类组成，分别是 TestContext 和 TestContextManager 类以及 TestExecutionListener 接口。   每次测试都会创建T
spring test+junit+dbunit单元测试示例
火凤凰天地
05-27 286
  基于spring testcontext+junit+dbunit的单元测试 /** * */ package com.um.vstore.portal.service.impl; import static org.junit.Assert.assertTrue; import java.io.File; import java.io.FileInputSt...
SPRING + JUNIT + DBUnit + Mockito来做单测
beijicy的专栏
12-26 1787
场景：之前已经调通了spring junit dbunit来做单测，最近发现由于我需要调用系统B的API。本文介绍了通过mock一个B系统的client，让我们单测的时候不真实访问B系统
Springboot+DBunit单元测试，数据库隔离测试
Oumuv的博客
03-31 4336
关于DBunit 百度百科：dbunit是一个基于junit扩展的数据库测试框架。 简言之，dbunit是为了在单元测试中，通过备份数据库、导入测试数据、回滚恢复数据库的手段，在不污染数据库的前提下完成一系列单元测试工作。 DBunit关键知识点 IDataSet接口：用于操作表集合 ITable接口：用于操作表数据集合 DatabaseOperation类：对表数据执行一系列操作，比如刷新、删除...
JUnit、DbUnit、JMockit学习笔记
迟到的月亮
07-26 7081
一、Junit1.Junit简介 JUnit是由 ErichGamma 和Kent Beck 编写的一个回归测试框架（regressiontesting framework）。Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何（How）完成功能和完成什么样（What）的功能。Junit是一套框架，继承TestCase类，就可以用Junit进行自动测试了。Junit环
使用 JUnit 5 和 DBUnit 来测试包含数据库提交操作的类
weixin_41247583的博客
04-26 270
备忘一下，这是一个使用 JUnit 5 和 DBUnit 来测试包含数据库提交操作的类的示例，这个示例不依赖于 Spring 框架。这个示例展示了如何在不使用 Spring 的情况下，使用 JUnit 5 和 DBUnit 来测试涉及显式提交操作的数据库交互代码。在这个测试类中，我们将使用 DBUnit 来准备和验证数据库状态。/initialData.xml 应包含用于测试的初始数据，格式应符合 DBUnit 的要求。这个例子中，我们假设数据库和表已经正确设置，并且连接字符串、用户名和密码是正确的。
Junit+dbunit单元测试jar包
03-07
`Junit` 和 `dbunit` 是两个非常重要的工具，它们分别针对Java应用程序的单元测试和数据库测试提供支持。让我们详细了解一下这两个库以及如何将它们结合使用。 `Junit` 是一个流行的开源Java单元测试框架，由Ernst ...
junit4.10+dbunit2.4.7+httpunit+junitperf的jar包
05-29
Junit4.10、DbUnit2.4.7、HttpUnit和JunitPerf是Java测试领域中常用的四个库，它们各自为不同的测试场景提供了强大的支持。下面将详细介绍这些库的功能和使用方法。 1. Junit4.10： Junit是Java编程语言中最著名的...
junit harmcrest dbunit用到的jar包
07-14
dbunit-2.4.9 hamcrest-core-1.3 hamcrest-library-1.3 junit-4.12 slf4j-api-1.6.1 slf4j-log4j12-1.6.1 log4j-1.2.15
单元测试JUnit4和DbUnit
03-16
为了更好地学习和实践这些概念，文档"单元测试JUnit4和DbUnit.doc"可能包含了详细的步骤和示例代码，而"dbunitAndJunit4"和"junit4"这两个文件夹可能包含了相关的练习项目或者源码，通过阅读和运行这些代码，可以...
使用EJB+Struts1.3+Ant+Cactus+DbUnit+JMeter+StrutsTest实现测试4
12-21
StrutsTest是Struts框架的测试工具，它扩展了JUnit，提供了方便的接口来测试ActionForm和Action类。通过StrutsTest，开发者可以直接在Action层面进行单元测试，而无需依赖整个Web应用环境。 将这些工具和技术整合在...
golang 接口
m0_70982551的博客
07-24 869
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 454
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 543
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 471
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
DbUnit：数据库集成测试利器
"DbUnit是一个用于数据库集成测试的Java工具，它可以作为JUnit的扩展，也可独立使用。DbUnit主要用于准备数据库（在每个测试方法前填充已知数据）和验证数据库（在测试后检查数据是否符合预期）。它提供了一个简单、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值