seahi/AbsenceManager
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

测试：增加针对DAO实现类的单元测试

Browse Source
This commit is contained in:
seahi 2024-12-18 11:45:56 +08:00
parent 0aad1d1271
commit b58803f6b0
5 changed files with 486 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/dao/impl/LeaveRequestDAOImpl.java
View File

@ -26,6 +26,10 @@ public class LeaveRequestDAOImpl implements LeaveRequestDAO {
*/
@Override
public int insert(LeaveRequest request) {
if (request == null || request.getStudent() == null) {
return 0;
}
String sql = "INSERT INTO leave_requests (student_id, start_time, end_time, status, " +
"duration, location, reason_type, reason_detail, is_leaving_city, " +
"request_time) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
@ -92,6 +96,10 @@ public class LeaveRequestDAOImpl implements LeaveRequestDAO {
*/
@Override
public int update(LeaveRequest request) {
if (request == null || request.getStudent() == null) {
return 0;
}
String sql = "UPDATE leave_requests SET student_id = ?, start_time = ?, " +
"end_time = ?, status = ?, duration = ?, location = ?, " +
"reason_type = ?, reason_detail = ?, is_leaving_city = ?, " +
@ -233,6 +241,31 @@ public class LeaveRequestDAOImpl implements LeaveRequestDAO {
return requests;
}
/**
* 更新请假申请状态
*
* @param id 请假申请ID
* @param status 新的状态
* @param approverComment 审批备注
* @return 影响的行数，更新成功返回1，失败返回0
*/
@Override
public int updateStatus(int id, ApprovalStatus status, String approverComment) {
String sql = "UPDATE leave_requests SET status = ?, approval_comment = ? WHERE id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement stmt = conn.prepareStatement(sql)) {
stmt.setString(1, status.name());
stmt.setString(2, approverComment);
stmt.setInt(3, id);
return stmt.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
return 0;
}
}
/**
* 将ResultSet映射为LeaveRequest对象
* 从结果集中提取数据并创建LeaveRequest实例，同时创建关联的Student对象
@ -259,6 +292,7 @@ public class LeaveRequestDAOImpl implements LeaveRequestDAO {
request.setStartTime(rs.getTimestamp("start_time"));
request.setEndTime(rs.getTimestamp("end_time"));
request.setStatus(ApprovalStatus.valueOf(rs.getString("status")));
request.setApproverComment(rs.getString("approval_comment"));
request.setDuration(rs.getDouble("duration"));
request.setLocation(rs.getString("location"));
request.setReasonType(rs.getString("reason_type"));

16
src/model/LeaveRequest.java
View File

@ -17,7 +17,7 @@ public class LeaveRequest {
private boolean isLeavingCity; // 是否离津
private ApprovalStatus status; // 审批状态
private Teacher approver; // 审批人
private String approvalComment; // 审批意见
private String approverComment; // 审批意见
private Date requestTime; // 申请时间
private Date approvalTime; // 审批时间
@ -117,11 +117,19 @@ public class LeaveRequest {
}
public String getApprovalComment() {
return approvalComment;
return approverComment;
}
public void setApprovalComment(String approvalComment) {
this.approvalComment = approvalComment;
public void setApprovalComment(String approverComment) {
this.approverComment = approverComment;
}
public String getApproverComment() {
return approverComment;
}
public void setApproverComment(String approverComment) {
this.approverComment = approverComment;
}
public Date getRequestTime() {

198
src/test/dao/impl/LeaveRequestDAOImplTest.java Normal file
View File

@ -0,0 +1,198 @@
package test.dao.impl;
import dao.impl.LeaveRequestDAOImpl;
import dao.impl.StudentDAOImpl;
import model.ApprovalStatus;
import model.LeaveRequest;
import model.Student;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import util.DatabaseUtil;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;
import static org.junit.Assert.*;
/**
* LeaveRequestDAOImpl的单元测试类
* 测试请假申请数据访问层的各项功能
*/
public class LeaveRequestDAOImplTest {
private LeaveRequestDAOImpl leaveRequestDAO;
private StudentDAOImpl studentDAO;
private Student testStudent;
@Before
public void setUp() throws SQLException {
leaveRequestDAO = new LeaveRequestDAOImpl();
studentDAO = new StudentDAOImpl();
// 清理测试数据
cleanTestData();
// 创建测试用学生
testStudent = createAndInsertTestStudent();
}
@After
public void tearDown() throws SQLException {
cleanTestData();
}
/**
* 清理测试数据
*/
private void cleanTestData() throws SQLException {
try (Connection conn = DatabaseUtil.getConnection()) {
// 删除请假记录
try (PreparedStatement stmt = conn.prepareStatement("DELETE FROM leave_requests WHERE student_id IN (SELECT id FROM students WHERE student_id = ?)")) {
stmt.setString(1, "2024001");
stmt.executeUpdate();
}
// 删除测试学生
try (PreparedStatement stmt = conn.prepareStatement("DELETE FROM students WHERE student_id = ?")) {
stmt.setString(1, "2024001");
stmt.executeUpdate();
}
}
}
/**
* 创建并插入测试用的Student对象
*/
private Student createAndInsertTestStudent() {
Student student = new Student();
student.setStudentId("2024001");
student.setName("张三");
student.setClassName("计算机科学与技术1班");
student.setContact("13800138000");
student.setCollege("信息科学与工程学院");
student.setMajor("计算机科学与技术");
student.setPassword("password123");
studentDAO.insert(student);
return student;
}
/**
* 创建测试用的LeaveRequest对象
*/
private LeaveRequest createTestLeaveRequest() {
LeaveRequest request = new LeaveRequest();
request.setStudent(testStudent);
request.setStartTime(new Date());
request.setEndTime(new Date(System.currentTimeMillis() + 86400000)); // 一天后
request.setStatus(ApprovalStatus.PENDING);
request.setDuration(24.0);
request.setLocation("北京市海淀区");
request.setReasonType("事假");
request.setReasonDetail("参加亲属婚礼");
request.setLeavingCity(false);
request.setRequestTime(new Date());
return request;
}
@Test
public void testInsert() {
// 准备测试数据
LeaveRequest request = createTestLeaveRequest();
// 执行插入操作
int result = leaveRequestDAO.insert(request);
// 验证结果
assertEquals(1, result);
assertTrue(request.getId() > 0);
// 验证数据是否正确插入
List<LeaveRequest> requests = leaveRequestDAO.findByStudentId(testStudent.getId());
assertFalse(requests.isEmpty());
LeaveRequest foundRequest = requests.get(0);
assertEquals(request.getStudent().getId(), foundRequest.getStudent().getId());
assertEquals(request.getStatus(), foundRequest.getStatus());
assertEquals(request.getLocation(), foundRequest.getLocation());
assertEquals(request.getReasonType(), foundRequest.getReasonType());
assertEquals(request.getReasonDetail(), foundRequest.getReasonDetail());
assertEquals(request.isLeavingCity(), foundRequest.isLeavingCity());
}
@Test
public void testFindByStudentId() {
// 准备测试数据
LeaveRequest request1 = createTestLeaveRequest();
LeaveRequest request2 = createTestLeaveRequest();
leaveRequestDAO.insert(request1);
leaveRequestDAO.insert(request2);
// 执行查询操作
List<LeaveRequest> requests = leaveRequestDAO.findByStudentId(testStudent.getId());
// 验证结果
assertEquals(2, requests.size());
for (LeaveRequest request : requests) {
assertEquals(testStudent.getId(), request.getStudent().getId());
assertEquals(testStudent.getName(), request.getStudent().getName());
}
}
@Test
public void testFindByStudentIdNotFound() {
// 查询不存在的学生ID
List<LeaveRequest> requests = leaveRequestDAO.findByStudentId(-1);
// 验证结果
assertTrue(requests.isEmpty());
}
@Test
public void testInsertWithNullStudent() {
// 准备测试数据
LeaveRequest request = createTestLeaveRequest();
request.setStudent(null);
// 执行插入操作
int result = leaveRequestDAO.insert(request);
// 验证结果
assertEquals(0, result);
}
@Test
public void testUpdateStatus() {
// 准备测试数据
LeaveRequest request = createTestLeaveRequest();
leaveRequestDAO.insert(request);
// 执行更新操作
String comment = "同意请假申请";
int result = leaveRequestDAO.updateStatus(request.getId(), ApprovalStatus.APPROVED, comment);
// 验证结果
assertEquals(1, result);
// 验证状态是否正确更新
List<LeaveRequest> requests = leaveRequestDAO.findByStudentId(testStudent.getId());
assertFalse(requests.isEmpty());
LeaveRequest updatedRequest = requests.get(0);
assertEquals(ApprovalStatus.APPROVED, updatedRequest.getStatus());
assertEquals(comment, updatedRequest.getApproverComment());
}
@Test
public void testUpdateStatusNotFound() {
// 测试更新不存在的记录
int result = leaveRequestDAO.updateStatus(-1, ApprovalStatus.APPROVED, "测试评论");
// 验证结果
assertEquals(0, result);
}
}

123
src/test/dao/impl/StudentDAOImplTest.java Normal file
View File

@ -0,0 +1,123 @@
package test.dao.impl;
import dao.impl.StudentDAOImpl;
import model.Student;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import util.DatabaseUtil;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import static org.junit.Assert.*;
/**
* StudentDAOImpl的单元测试类
* 测试学生数据访问层的各项功能
*/
public class StudentDAOImplTest {
private StudentDAOImpl studentDAO;
private static final String TEST_STUDENT_ID = "2024001";
@Before
public void setUp() throws SQLException {
studentDAO = new StudentDAOImpl();
// 清理测试数据
cleanTestData();
}
@After
public void tearDown() throws SQLException {
cleanTestData();
}
/**
* 清理测试数据
*/
private void cleanTestData() throws SQLException {
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement stmt = conn.prepareStatement("DELETE FROM students WHERE student_id = ?")) {
stmt.setString(1, TEST_STUDENT_ID);
stmt.executeUpdate();
}
}
/**
* 创建测试用的Student对象
*/
private Student createTestStudent() {
Student student = new Student();
student.setStudentId(TEST_STUDENT_ID);
student.setName("张三");
student.setClassName("计算机科学与技术1班");
student.setContact("13800138000");
student.setCollege("信息科学与工程学院");
student.setMajor("计算机科学与技术");
student.setPassword("password123");
return student;
}
@Test
public void testInsert() {
// 准备测试数据
Student student = createTestStudent();
// 执行插入操作
int result = studentDAO.insert(student);
// 验证结果
assertEquals(1, result);
assertTrue(student.getId() > 0);
// 验证数据是否正确插入
Student foundStudent = studentDAO.findByStudentId(TEST_STUDENT_ID);
assertNotNull(foundStudent);
assertEquals(student.getName(), foundStudent.getName());
assertEquals(student.getClassName(), foundStudent.getClassName());
assertEquals(student.getContact(), foundStudent.getContact());
assertEquals(student.getCollege(), foundStudent.getCollege());
assertEquals(student.getMajor(), foundStudent.getMajor());
}
@Test
public void testFindByStudentId() {
// 准备测试数据
Student student = createTestStudent();
studentDAO.insert(student);
// 执行查询操作
Student foundStudent = studentDAO.findByStudentId(TEST_STUDENT_ID);
// 验证结果
assertNotNull(foundStudent);
assertEquals(TEST_STUDENT_ID, foundStudent.getStudentId());
assertEquals(student.getName(), foundStudent.getName());
}
@Test
public void testFindByStudentIdNotFound() {
// 查询不存在的学号
Student foundStudent = studentDAO.findByStudentId("nonexistent");
// 验证结果
assertNull(foundStudent);
}
@Test
public void testInsertDuplicate() {
// 准备测试数据
Student student1 = createTestStudent();
Student student2 = createTestStudent();
// 第一次插入
int result1 = studentDAO.insert(student1);
assertEquals(1, result1);
// 尝试插入重复的学号
int result2 = studentDAO.insert(student2);
assertEquals(0, result2);
}
}

119
src/test/dao/impl/TeacherDAOImplTest.java Normal file
View File

@ -0,0 +1,119 @@
package test.dao.impl;
import dao.impl.TeacherDAOImpl;
import model.Teacher;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import util.DatabaseUtil;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import static org.junit.Assert.*;
/**
* TeacherDAOImpl的单元测试类
* 测试教师数据访问层的各项功能
*/
public class TeacherDAOImplTest {
private TeacherDAOImpl teacherDAO;
private static final String TEST_TEACHER_ID = "T2024001";
@Before
public void setUp() throws SQLException {
teacherDAO = new TeacherDAOImpl();
// 清理测试数据
cleanTestData();
}
@After
public void tearDown() throws SQLException {
cleanTestData();
}
/**
* 清理测试数据
*/
private void cleanTestData() throws SQLException {
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement stmt = conn.prepareStatement("DELETE FROM teachers WHERE teacher_id = ?")) {
stmt.setString(1, TEST_TEACHER_ID);
stmt.executeUpdate();
}
}
/**
* 创建测试用的Teacher对象
*/
private Teacher createTestTeacher() {
Teacher teacher = new Teacher();
teacher.setTeacherId(TEST_TEACHER_ID);
teacher.setName("李四");
teacher.setDepartment("计算机科学系");
teacher.setContact("13900139000");
teacher.setPassword("password123");
return teacher;
}
@Test
public void testInsert() {
// 准备测试数据
Teacher teacher = createTestTeacher();
// 执行插入操作
int result = teacherDAO.insert(teacher);
// 验证结果
assertEquals(1, result);
assertTrue(teacher.getId() > 0);
// 验证数据是否正确插入
Teacher foundTeacher = teacherDAO.findByTeacherId(TEST_TEACHER_ID);
assertNotNull(foundTeacher);
assertEquals(teacher.getName(), foundTeacher.getName());
assertEquals(teacher.getDepartment(), foundTeacher.getDepartment());
assertEquals(teacher.getContact(), foundTeacher.getContact());
}
@Test
public void testFindByTeacherId() {
// 准备测试数据
Teacher teacher = createTestTeacher();
teacherDAO.insert(teacher);
// 执行查询操作
Teacher foundTeacher = teacherDAO.findByTeacherId(TEST_TEACHER_ID);
// 验证结果
assertNotNull(foundTeacher);
assertEquals(TEST_TEACHER_ID, foundTeacher.getTeacherId());
assertEquals(teacher.getName(), foundTeacher.getName());
}
@Test
public void testFindByTeacherIdNotFound() {
// 查询不存在的工号
Teacher foundTeacher = teacherDAO.findByTeacherId("nonexistent");
// 验证结果
assertNull(foundTeacher);
}
@Test
public void testInsertDuplicate() {
// 准备测试数据
Teacher teacher1 = createTestTeacher();
Teacher teacher2 = createTestTeacher();
// 第一次插入
int result1 = teacherDAO.insert(teacher1);
assertEquals(1, result1);
// 尝试插入重复的工号
int result2 = teacherDAO.insert(teacher2);
assertEquals(0, result2);
}
}