文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
社区首页 >专栏 >带着ChatGPT玩转软件开发-连载20

带着ChatGPT玩转软件开发-连载20

作者头像
顾翔
发布于 2025-12-29 11:22:51
发布于 2025-12-29 11:22:51
1200
举报
文章被收录于专栏：啄木鸟软件测试啄木鸟软件测试

顾老师新作“带着ChatGPT玩转软件开发”将于今年底明年初出

4.2 使用ChatGPT生成找回密码的单元测试代码

在找回密码功能的实现中，修改或建立了以下6个Java文件。

•CookiesManager.java

•UserRepository.java

•PasswordRecovery.java

•PasswordRecoveryController.java

•Util.java

•以及demo包下的SendSms.java。

4.2.1申请找回密码单元测试代码

提示词

请对下面Java代码产生JUnit5的测试用例。

1.CookiesManager.java

参看代码代码3-52 CookiesManager.java

2.PasswordRecovery.java

参看代码代码4-26 PasswordRecovery.java

3.PasswordRecoveryController.java

参看代码代码4-16 PasswordRecoveryController.java

4.Util.java

参看代码代码4-23 Util.java

5.SendSms.java

参看代码代码4-19 SendSms.java

6.UserRepository.java

将UserRepository.java分批产生测试用例。参看代码代码4-27 UserRepository.java

1）第一批输入

提示词

请对下面Java代码产生JUnit5的测试用例。

代码语言：javascript
复制
package ebusiness;
import java.io.IOException;
…
public class UserRepository{
private static final Logger logger=Logger.getLogger(UserRepository.class);
public HikariDataSource dataSource;
//初始化连接池
public UserRepository()throws IOException{
…
//插入用户信息，用于注册
public String insert(User user)throws SQLException{
…
//通过账号、Email或手机判断用户是否存在
public String userExists(String username,String email,String phone)throws SQLException{
…
//判断user表某个字段是否存在记录
public String judgeInfo(String field,String value)throws SQLException{
…

2）第二批输入

提示词

请对下面Java代码产生JUnit5的测试用例。

代码语言：javascript
复制
//登录
public String login(User user)throws SQLException{
…
//判断Email或phone是否存在
public String queryForEmailOrPhone(String contact)throws SQLException{
…

3）第三批输入

提示词

请对下面Java代码产生JUnit5的测试用例。

UserRepository.java

代码语言：javascript
复制
//把验证码放入code表中
public int putCodeInDB(String code,int uid)throws SQLException{
…
//从code表中删除旧的验证码
public int deleteCodeInDB(int uid)throws SQLException{
…
//验证重置密码的时候输入的验证码是否正确
public int verifyCode(String code,int uid){
…

4）第四批输入

提示词

请对下面Java代码产生JUnit5的测试用例。

UserRepository.java

代码语言：javascript
复制
//查询密码是否与以前使用过
public int verifyPassword(String newPassword,int uid){
…
//通过id获得user表的密码
public String getPassword(int uid){
…

5）第五批输入

提示词

请对下面Java代码产生JUnit5的测试用例。

UserRepository.java

代码语言：javascript
复制
//保存旧密码到password表
public int storeOldPassword(String oldPassword,int uid)throws SQLException{
…
//设置新密码
public int updatePassword(String newPassword,int uid)throws SQLException{
…

4.2.2找回密码单元测试代码回复

ChatGPT回答

下面是针对您提供的CookiesManager.java、UserRepository.java、PasswordRecovery.java、PasswordRecoveryController.java、Util.java和SendSms.java类的JUnit5测试用例示例。每个测试用例都关注类的主要功能，并使用Mockito库来模拟依赖项。

1.CookiesManagerTest.java

CookiesManagerTest.java测试CookiesManager.java。

下面是针对CookiesManager类的JUnit5测试用例。测试用例将使用Mockito来模拟HttpServletResponse和HttpServletRequest对象，以便测试setCookie()、getCookie()和clearCookie()方法的功能。

代码4-30 CookiesManagerTest.java

代码语言：javascript
复制
package ebusiness;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.apache.log4j.Logger;
class CookiesManagerTest{
private HttpServletResponse response;
private HttpServletRequest request;
private CookiesManager cookiesManager;
//在每个测试之前创建模拟的HttpServletResponse和HttpServletRequest对象，并初始化CookiesManager 实例。
@BeforeEach
void setUp(){
		response=mock(HttpServletResponse.class);
		request=mock(HttpServletRequest.class);
		cookiesManager=new CookiesManager("testCookie","testValue",response,request);
	}
//测试setCookie()方法是否正确设置了Cookie的各个属性，并将其添加到响应中。
@Test
void testSetCookie(){
//测试设置cookie带着一个有效的值
		cookiesManager.setCookie();
verify(response).addCookie(argThat(cookie->
"testCookie".equals(cookie.getName())&&
"testValue".equals(cookie.getValue())&&
		cookie.getMaxAge()==60*60*24&&
"/".equals(cookie.getPath())&&
		cookie.getSecure()&&
		cookie.isHttpOnly()
		));
	}
//测试当Cookie值为null时，setCookie()方法不会添加Cookie。
@Test
void testSetCookie_NullValue(){
//测试设置具有空值的cookie
CookiesManager manager=new CookiesManager("testCookie",null,response,request);
		manager.setCookie();
verify(response,never()).addCookie(any(Cookie.class));
//检查是否调用了日志记录器（您可能需要添加日志框架）
	}
//测试getCookie()方法，当请求中存在指定的Cookie时，能够正确返回其值。
@Test
void testGetCookie_CookieExists(){
//模拟返回特定cookie的请求
Cookie[] cookies={new Cookie("testCookie","testValue")};
when(request.getCookies()).thenReturn(cookies);
String value=cookiesManager.getCookie();
Assertions.assertEquals("testValue",value);
	}
//测试getCookie()方法，当请求中不存在指定的Cookie时，返回值应为null
@Test
void testGetCookie_CookieDoesNotExist(){
//模拟返回空cookie数组的请求
Cookie[] cookies={new Cookie("otherCookie","otherValue")};
when(request.getCookies()).thenReturn(cookies);
String value=cookiesManager.getCookie();
Assertions.assertNull(value);
	}
//测试clearCookie()方法，确保其创建的Cookie的最大年龄被设置为0，并且名称正确。
@Test
void testClearCookie(){
		cookiesManager.clearCookie();
verify(response).addCookie(argThat(cookie->
"testCookie".equals(cookie.getName())&&
		cookie.getMaxAge()==0&&
"/".equals(cookie.getPath())
		));
	}
}

1.测试用例说明

•setUp()方法：在每个测试之前创建模拟的HttpServletResponse和HttpServletRequest对象，并初始化CookiesManager 实例。

•void testSetCookie()方法：测试setCookie()方法是否正确设置了Cookie的各个属性，并将其添加到响应中。

•void testSetCookie_NullValue()方法：测试当Cookie值为null时，setCookie()方法不会添加Cookie。

•void testGetCookie_CookieExists()方法：测试getCookie()方法，当请求中存在指定的Cookie时，能够正确返回其值。

•void testGetCookie_CookieDoesNotExist()方法：测试getCookie()方法，当请求中不存在指定的Cookie时，返回值应为null。

•void testClearCookie()方法：测试clearCookie()方法，确保其创建的Cookie的最大年龄被设置为0，并且名称正确。

2.注意事项

•确保在项目中包含Mockito和JUnit5的依赖。

•如果需要验证日志输出，可以使用Mockito的ArgumentCaptor或者其他日志验证工具。

根据实际情况，可能需要调整测试用例以适应特定的项目结构或测试框架配置。

2.PasswordRecoveryTest.java

PasswordRecoveryTest.java测试PasswordRecovery.java。

代码4-31 PasswordRecoveryTest.java

代码语言：javascript
复制
package ebusiness;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import demo.SendSms;
class PasswordRecoveryTest{
  private PasswordRecovery passwordRecovery;
  private Connection connection;
  private UserRepository mysql;
  private SendSms sendSms;
  //在每个测试之前创建模拟的Connection和UserRepository对象，并初始化PasswordRecovery实例。
  @BeforeEach
  void setUp()throws SQLException{
    connection=mock(Connection.class);
    mysql=mock(UserRepository.class);
    passwordRecovery=new PasswordRecovery();
  }
  //测试发送验证码时，如果输入的手机号有效，应该返回对应的用户ID。
  @Test
  void testSendVerificationCode_ValidPhone()throws Exception{
    String contact="13812345678";//Valid phone number
    String userId="1";
    String code="123456";
    //模拟UserRepository方法的行为
    when(mysql.queryForEmailOrPhone(contact)).thenReturn(userId);
    //模拟成功删除
    when(mysql.deleteCodeInDB(1)).thenReturn(0);
    //模拟成功插入 
    when(mysql.putCodeInDB(anyString(),1)).thenReturn(1);
    //模拟SendSMS以模拟成功发送短信
    when(sendSms.SendSMS(contact,code)).thenReturn(true);
    String result=passwordRecovery.sendVerificationCode(contact);
    //期待userId返回
    Assertions.assertEquals(userId,result);
  }
  //测试发送验证码时，如果输入的手机号或邮箱格式不正确，应该返回相应的错误消息。
  @Test
  void testSendVerificationCode_InvalidContact()throws Exception{
    String contact="invalid_contact";//Invalid contact
    String result=passwordRecovery.sendVerificationCode(contact);
    //预期错误消息
    Assertions.assertEquals("您输入的手机号或Email格式不正确！",result);
  }
  //测试重置密码时，如果所有条件都满足，应该返回"0"表示成功。
  @Test
  void testRecoverPassword_Success()throws SQLException{
    String identifyingCode="123456";
    String newPassword="hashedPassword";
    int uid=1;
    //模拟UserRepository方法的行为
    //模拟正确的验证码
    when(mysql.verifyCode(identifyingCode,uid)).thenReturn(1);
    //模拟旧密码的检索
    when(mysql.getPassword(uid)).thenReturn("oldHashedPassword");
    //模拟成功存储旧密码 
    when(mysql.storeOldPassword("oldHashedPassword",uid)).thenReturn(1);
    //模拟成功存储旧密码 
    when(mysql.verifyPassword(newPassword,uid)).thenReturn(0);
    //模拟密码更新成功
    when(mysql.updatePassword(newPassword,uid)).thenReturn(1);
    String result=passwordRecovery.recoverPassword(identifyingCode,newPassword,mysql,uid);
    //期待成功
    Assertions.assertEquals("0",result);
  }
  //测试重置密码时，如果验证码不正确，应该返回相应的错误消息。
  @Test
  void testRecoverPassword_InvalidVerificationCode()throws SQLException{
    String identifyingCode="invalidCode";
    String newPassword="hashedPassword";
    int uid=1;
    //模拟UserRepository方法的行为
    //模拟不正确的验证码
    when(mysql.verifyCode(identifyingCode,uid)).thenReturn(0);
    String result=passwordRecovery.recoverPassword(identifyingCode,newPassword,mysql,uid);
    //预期错误消息
    Assertions.assertEquals("验证码错误，请重新输入！",result);
  }
  //测试重置密码时，如果新密码已经使用过，应该返回相应的错误消息。
  @Test
  void testRecoverPassword_PasswordAlreadyUsed()throws SQLException{
    String identifyingCode="123456";
    String newPassword="hashedPassword";
    int uid=1;
    //模拟UserRepository方法的行为
    //模拟正确的验证码
    when(mysql.verifyCode(identifyingCode,uid)).thenReturn(1);
    //模拟旧密码的检索
    when(mysql.getPassword(uid)).thenReturn("oldHashedPassword");
    //模拟成功存储旧密码
    when(mysql.storeOldPassword("oldHashedPassword",uid)).thenReturn(1);
    //模拟已使用的新密码
    when(mysql.verifyPassword(newPassword,uid)).thenReturn(1);
    String result=passwordRecovery.recoverPassword(identifyingCode,newPassword,mysql,uid);
    //预期错误消息
    Assertions.assertEquals("这个密码以前设置过，请用一个新密码！",result);
  }
}

1.测试用例说明

•setUp()方法：在每个测试之前创建模拟的Connection和UserRepository对象，并初始化PasswordRecovery实例。

•void testSendVerificationCode_ValidPhone()方法：测试发送验证码时，如果输入的手机号有效，应该返回对应的用户ID。

•void testSendVerificationCode_InvalidContact()方法：测试发送验证码时，如果输入的手机号或邮箱格式不正确，应该返回相应的错误消息。

•void testRecoverPassword_Success()方法：测试重置密码时，如果所有条件都满足，应该返回"0"表示成功。

•void testRecoverPassword_InvalidVerificationCode()方法：测试重置密码时，如果验证码不正确，应该返回相应的错误消息。

•void testRecoverPassword_PasswordAlreadyUsed()方法：测试重置密码时，如果新密码已经使用过，应该返回相应的错误消息。

2.注意事项。

•确保在项目中包含Mockito和JUnit5的依赖。

•由于PasswordRecovery类的许多方法与数据库交互，因此在测试中使用Mock对象可以避免实际的数据库操作。

•可以根据实际情况调整测试用例以适应特定的项目结构或测试框架配置。

3.PasswordRecoveryControllerTest.java

PasswordRecoveryControllerTest.java测试

为了为您提供的PasswordRecoveryController类编写JUnit5测试用例，我们将使用Mockito来模拟HttpServletRequest和HttpServletResponse对象，以及其他依赖的类（如UserRepository类、PasswordRecovery类和Util类）。以下是针对sendVerificationCode()和recoverPassword()方法的测试用例示例。

代码4-32 PasswordRecoveryController.java

代码语言：javascript
复制
package ebusiness;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
public class PasswordRecoveryControllerTest{
@Mock
private HttpServletRequest request;
@Mock
private HttpServletResponse response;
private PasswordRecoveryController controller;
@BeforeEach
public void setUp(){
		MockitoAnnotations.openMocks(this);
		controller=new PasswordRecoveryController(response,request);
	}
//测试发送验证码成功的场景。
@Test
public void testSendVerificationCode_Success()throws SQLException,IOException{
//安排
		String contact="test@example.com";
when(request.getParameter("contact")).thenReturn(contact);
		UserRepository mockUserRepository=mock(UserRepository.class);
		Connection mockConnection=mock(Connection.class);
when(mockUserRepository.connect()).thenReturn(mockConnection);
		PasswordRecovery mockPasswordRecovery=mock(PasswordRecovery.class);
when(mockPasswordRecovery.sendVerificationCode(contact)).thenReturn("123456");
//模拟UserRepository和PasswordRecovery的创建 
		whenNew(UserRepository.class).withNoArguments().thenReturn(mockUserRepository);
		whenNew(PasswordRecovery.class).withArguments(mockConnection).thenReturn(mockPasswordRecovery);
		Util mockUtil=mock(Util.class);
		whenNew(Util.class).withNoArguments().thenReturn(mockUtil);
//行为
		String result=controller.sendVerificationCode();
//断言
		verify(response).sendRedirect("/jsp/RecoverPage.jsp");
		Assertions.assertEquals("0",result);
	}
//测试发送验证码时发生错误的场景。
@Test
public void testSendVerificationCode_Error()throws SQLException,IOException{
//安排
		String contact="test@example.com";
when(request.getParameter("contact")).thenReturn(contact);
		UserRepository mockUserRepository=mock(UserRepository.class);
		Connection mockConnection=mock(Connection.class);
when(mockUserRepository.connect()).thenReturn(mockConnection);
		PasswordRecovery mockPasswordRecovery=mock(PasswordRecovery.class);
when(mockPasswordRecovery.sendVerificationCode(contact)).thenReturn("-1");
//模拟UserRepository和PasswordRecovery的创建
		whenNew(UserRepository.class).withNoArguments().thenReturn(mockUserRepository);
		whenNew(PasswordRecovery.class).withArguments(mockConnection).thenReturn(mockPasswordRecovery);
//行为
		String result=controller.sendVerificationCode();
//断言
		Assertions.assertEquals("系统发生错误，请查看日志！",result);
	}
//测试重置密码成功的场景。
@Test
public void testRecoverPassword_Success()throws SQLException,IOException{
//安排
when(request.getParameter("identifyingCode")).thenReturn("123456");
when(request.getParameter("newPassword")).thenReturn("newPassword");
		CookiesManager mockCookiesManager=mock(CookiesManager.class);
when(mockCookiesManager.getCookie()).thenReturn("1");
		whenNew(CookiesManager.class).withArguments("uid",response,request).thenReturn(mockCookiesManager);
		UserRepository mockUserRepository=mock(UserRepository.class);
		Connection mockConnection=mock(Connection.class);
when(mockUserRepository.connect()).thenReturn(mockConnection);
		PasswordRecovery mockPasswordRecovery=mock(PasswordRecovery.class);
when(mockPasswordRecovery.recoverPassword("123456","newPassword",mockUserRepository,1)).thenReturn("0");
//模拟UserRepository和PasswordRecovery的创建
		whenNew(UserRepository.class).withNoArguments().thenReturn(mockUserRepository);
		whenNew(PasswordRecovery.class).withArguments(mockConnection).thenReturn(mockPasswordRecovery);
		Util mockUtil=mock(Util.class);
		whenNew(Util.class).withNoArguments().thenReturn(mockUtil);
//行为
		String result=controller.recoverPassword();
//断言
		verify(mockCookiesManager).clearCookie();
		verify(response).sendRedirect("/jsp/LoginPage.jsp");
		Assertions.assertEquals("0",result);
	}
//测试重置密码没有cookie的场景
@Test
public void testRecoverPassword_NoCookie()throws SQLException,IOException{
//安排
when(request.getParameter("identifyingCode")).thenReturn("123456");
when(request.getParameter("newPassword")).thenReturn("newPassword");
		CookiesManager mockCookiesManager=mock(CookiesManager.class);
when(mockCookiesManager.getCookie()).thenReturn(null);
		whenNew(CookiesManager.class).withArguments("uid",response,request).thenReturn(mockCookiesManager);
//行为
		String result=controller.recoverPassword();
//断言
		Assertions.assertEquals("请输入验证码后再进入",result);
	}
}

1.说明

•Mockito：我们使用Mockito来模拟HttpServletRequest和HttpServletResponse对象，以及其他依赖的类（如UserRepository、PasswordRecovery和Util）。

2.测试方法

•void testSendVerificationCode_Success()：测试发送验证码成功的场景。

•void testSendVerificationCode_Error()：测试发送验证码时发生错误的场景。

•void testRecoverPassword_Success()：测试重置密码成功的场景。

•void testRecoverPassword_NoCookie()：测试重置密码没有Cookie的场景。

•使用whenNew()：在测试中使用whenNew()来模拟构造函数的行为（需要使用PowerMockito库）。

3.注意事项

•上述代码使用了whenNew()方法来模拟构造函数的行为，这是PowerMockito的功能。如果您没有使用PowerMockito，您需要考虑其他方式来模拟这些依赖，例如通过依赖注入。

•确保在测试中处理所有可能的异常情况，并根据需要扩展测试用例。

•根据您的项目结构和依赖关系适当调整测试代码。

4.依赖项

如果您使用PowerMockito，请确保在pom.xml中添加PowerMockito的依赖。

代码4-33 pom.xml

代码语言：javascript
复制
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-module-junit4</artifactId>
<version>2.0.9</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-api-mockito2</artifactId>
<version>2.0.9</version>
<scope>test</scope>
</dependency>

请根据您的项目和测试环境进行相应调整。

4.myUtilTest.java

myUtilTest.java测试Util.java。

下面是针对你提供的Util类的JUnit5测试用例。这些测试用例将涵盖 generateRandomString()、sendRedirect()和getPropertiesInfo()方法的逻辑。

1.测试用例

代码4-34 myUtilTest.java

代码语言：javascript
复制
package ebusiness;
package ebusiness;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.BeforeEach;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.Properties;
public class myUtilTest{
private Util util;
@Mock
private HttpServletResponse mockResponse;
@BeforeEach
public void setUp(){
		MockitoAnnotations.openMocks(this);
		util=new Util();
	}
//测试生成包含字母和数字的随机字符串。
@Test
public void testGenerateRandomString_WithLettersAndNumbers(){
int length=10;
		String sign="strInt";
		String result=util.generateRandomString(length,sign);
		Assertions.assertEquals(length,result.length());
for (char c:result.toCharArray()){
			Assertions.assertTrue (Util.getCharactersLetterNumber().indexOf(c)>=0,"Result contains invalid characters");
		}
	}
//测试生成仅包含数字的随机字符串。
@Test
public void testGenerateRandomString_WithNumbers(){
int length=5;
		String sign="int";
		String result=util.generateRandomString(length,sign);
		Assertions.assertEquals(length,result.length());
for (char c:result.toCharArray()){
			Assertions.assertTrue (Util.getCharactersNumber().indexOf(c)>=0,"Result contains invalid characters");
		}
	}
//测试无参数的重定向。
@Test
public void testSendRedirect()throws IOException{
		String url="http://example.com";
		util.sendRedirect(mockResponse,url);
		verify(mockResponse).sendRedirect(url);
}
//测试带参数的重定向。
@Test
public void testSendRedirect_WithParams()throws IOException{
		String url="http://example.com";
		String param="message";
		String info="Hello World";
		util.sendRedirect(mockResponse,url,param,info);
		String expectedUrl="http://example.com?message="+URLEncoder.encode(info,"UTF-8");
		verify(mockResponse).sendRedirect(expectedUrl);
	}
//测试获取配置文件的信息。
@Test
public void testGetPropertiesInfo()throws IOException{
		String file="test.properties";//确保这个文件在类路径中
		Properties properties=util.getPropertiesInfo(file);	
		Assertions.assertNotNull(properties);
		Assertions.assertEquals("smtp.126.com",properties.getProperty("SMTPServer"));
		Assertions.assertEquals("xianggu625@126.com",properties.getProperty("from"));
                Assertions.assertEquals("xianggu625@126.com",properties.getProperty("username"));
                Assertions.assertEquals("TSamp6PdzcMwMBN6",properties.getProperty("password"));
		Assertions.assertEquals("25",properties.getProperty("port"));
	}
//测试发送电子邮件功能。
@Test
public void testSendEmail()throws IOException{
		String result=util.SendMail("xianggu625@126.com","这是一个测试");
		Assertions.assertEquals("发送成功",result);
}
}

2.注意事项

•确保在你的类路径中有一个有效的config.properties文件，以便在testGetPropertiesInfo()测试方法中使用。

•需要添加Mockito和JUnit5的依赖项，以便能够运行这些测试。

这些测试用例将帮助确保Util类的功能正常，并且在出现问题时能够快速定位错误。

5.SendSmsTest.java

SendSmsTest.java测试SendSms.java。

代码4-35 SendSmsTest.java

代码语言：javascript
复制
package demo;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
class SendSmsTest{
//测试发送短信功能。
@Test
void testSendSMS()throws Exception{
		SendSms sendsms=new SendSms();
		String phone="13681732596";
		String code="123456";
		Assertions.assertTrue(sendsms.SendSMS(phone,code));
	}
}

6.UserRepositoryTest.java

UserRepositoryTest.java测试UserRepository.java。

由于UserRepository.java设计架构使用了数据库连接池的形式，所以需要从新生成单元测试用例。

1）第一批输出

ChatGPT回答

为了为UserRepository类生成测试用例，您可以使用JUnit进行单元测试，并将Mockito用于模拟依赖关系。考虑到UserRepository类的数据库操作，您需要模拟HikariDataSource和数据库连接，以便在测试中不实际需要连接数据库。

以下是基于您提供的UserRepository类的一个简单的测试用例示例。

Maven依赖(pom.xml)

1.首先，确保您的pom.xml中包含以下依赖。

代码4-36 pom.xml

代码语言：javascript
复制
<dependencies>
<!--JUnit 5-->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.9.0</version>
<scope>test</scope>
</dependency>
<!--Mockito-->
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>5.0.0</version>
<scope>test</scope>
</dependency>
<!--HikariCP-->
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>5.0.1</version>
<scope>test</scope>
</dependency>
</dependencies>

2.测试用例示例

下面是为UserRepository类编写的测试用例示例。

代码4-37 UserRepositoryTest.java

代码语言：javascript
复制
package ebusiness;
import static org.mockito.Mockito.*;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
@ExtendWith(MockitoExtension.class)
public class UserRepositoryTest{
@Mock
private HikariDataSource dataSource;
@Mock
private Connection connection;
@Mock
private PreparedStatement preparedStatement;
@Mock
private ResultSet resultSet;
@InjectMocks
private UserRepository userRepository;
//使用Mockito模拟了HikariDataSource和连接，确保每次测试前都能获取到模拟的数据库连接。
@BeforeEach
public void setUp()throws SQLException{
when(dataSource.getConnection()).thenReturn(connection);
	}
//测试插入用户成功的情况，模拟用户不存在并且插入操作成功。验证插入操作的实际参数。返回"1"。
@Test
public void testInsertUser_Success()throws SQLException{
		User user=new User("testuser","password","1234567890","test@example.com");
//Mock the behavior of userExists method
when(userRepository.userExists(anyString(),anyString(),anyString())).thenReturn("0");
//模拟preparedStatement行为
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeUpdate()).thenReturn(1);//Simulate successful insertion
		String result=userRepository.insert(user);
//Verify the results
		Assertions.assertEquals("1",result);
		verify(preparedStatement).setString(1,user.getUsername());
		verify(preparedStatement).setString(2,user.getPassword());
		verify(preparedStatement).setString(3,user.getPhone());
		verify(preparedStatement).setString(4,user.getEmail());
	}
//测试当用户已存在时，insert方法的行为。验证插入操作没有被调用。返回username
@Test
public void testInsertUser_UserExists()throws SQLException{
		User user=new User("existingUser","password","1234567890","test@example.com");
//模拟userExists方法的行为，以模拟用户已经存在		when(userRepository.userExists(anyString(),anyString(),anyString())).thenReturn("username");
		String result=userRepository.insert(user);
		Assertions.assertEquals("username",result);
		verify(preparedStatement,never()).executeUpdate();//确认insert没有被调用
	}
//测试用户不存在的情况，确保方法返回“0”。
@Test
public void testUserExists_UserDoesNotExist()throws SQLException{
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(false);//Simulate that user does not exist
		String result=userRepository.userExists("newUser","new@example.com","1234567890");
//验证用户不存在
		Assertions.assertEquals("0",result);
	}
//测试判断用户存在的情况。确保返回正确的字段名称。
@Test
public void testJudgeInfo_UserExists()throws SQLException{
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(true);//Simulate that user exists
		String result=userRepository.judgeInfo("username","existingUser");
//验证用户存在
		Assertions.assertEquals("username",result);
	}
}

3.测试用例解释

•void setUp()：使用Mockito模拟了HikariDataSource和连接，确保每次测试前都能获取到模拟的数据库连接。

•void testInsertUser_Success()：测试插入用户成功的情况，模拟用户不存在并且插入操作成功。验证插入操作的实际参数。

•void testInsertUser_UserExists()：测试当用户已存在时，insert方法的行为。验证插入操作没有被调用。

•void testUserExists_UserDoesNotExist()：测试用户不存在的情况，确保方法返回“0”。

•void testJudgeInfo_UserExists()：测试判断用户存在的情况。确保返回正确的字段名称。

这些测试用例可以帮助您验证UserRepository类的主要功能，并确保它们在各种情况下都能正常工作。确保您了解测试的上下文和如何使用Mockito模拟依赖关系，以便更好地进行单元测试。

2）第二批输出

ChatGPT回答

根据您提供的方法login(User user)和queryForEmailOrPhone(String contact)，以下是相应的测试用例示例。我们假设您使用的是JUnit和Mockito作为测试框架。

1.测试String login(User user)方法

•测试用例

Ø当账号和密码正确时，返回"1"。

Ø当账号或密码不正确时，返回"0"。

Ø当出现SQLException时，返回"-1"。

代码4-38 UserRepositoryTest.java

代码语言：javascript
复制
import static org.mockito.Mockito.*;
import static org.junit.Assert.*;
import java.sql.*;
import org.junit.Before;
import org.junit.Test;
public class UserServiceTest{
private UserService userService;//假设这是你的服务类
private DataSource dataSource;//数据源
private Connection connection;//数据库连接
private PreparedStatement preparedStatement;//预编译语句
private ResultSet resultSet;//结果集
@Before
public void setUp()throws SQLException{
		dataSource=mock(DataSource.class);
		connection=mock(Connection.class);
		preparedStatement=mock(PreparedStatement.class);
		resultSet=mock(ResultSet.class);
when(dataSource.getConnection()).thenReturn(connection);
		userService=new UserService(dataSource);//初始化带有数据源的服务
	}
//测试登录成功的情形。返回"1"
@Test
public void testLogin_Success()throws SQLException{
		User user=new User("testUser","testPassword");
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(true);
when(resultSet.getInt("sum")).thenReturn(1);//登录成功
		String result=userService.login(user);
		Assertions.assertEquals("1",result);//验证结果
	}
//测试登录失败的情形。返回"0"。
@Test
public void testLogin_Failure()throws SQLException{
		User user=new User("wrongUser","wrongPassword");
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(true);
when(resultSet.getInt("sum")).thenReturn(0);//登录失败
		String result=userService.login(user);
		Assertions.assertEquals("0",result);//验证结果
	}
//测试登录过程中数据库发生异常的情形。返回"-1"。
@Test
public void testLogin_SQLException()throws SQLException{
		User user=new User("testUser","testPassword");
when(connection.prepareStatement(anyString())).thenThrow(new SQLException("Database error"));
		String result=userService.login(user);
		Assertions.assertEquals("-1",result);//验证结果
	}
}

2.测试void queryForEmailOrPhone(String contact)方法

•测试用例

Ø当输入的邮箱或手机号存在时，返回用户ID。

Ø当输入的邮箱或手机号不存在时，返回"您输入的手机号或Email不存在，请重新输入！"。

Ø当出现SQLException时，返回"-1"。

代码4-39 UserRepositoryTest.java

代码语言：javascript
复制
        //测试发送验证码前查询Email或手机存在的情形。返回"1"。
@Test
public void testQueryForEmailOrPhone_Exists()throws SQLException{
		String contact="test@example.com";
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(true);
when(resultSet.getString("id")).thenReturn("1");//用户 ID 存在
		String result=userService.queryForEmailOrPhone(contact);
		Assertions.assertEquals("1",result);//验证结果
	}
//测试发送验证码前查询Email或手机不存在的情形。返回"您输入的手机号或Email不存在，请重新输入！"。
@Test
public void testQueryForEmailOrPhone_NotExists()throws SQLException{
		String contact="notfound@example.com";
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(false);//用户 ID 不存在
		String result=userService.queryForEmailOrPhone(contact);
		Assertions.assertEquals("您输入的手机号或Email不存在，请重新输入！",result);//验证结果
	}
//测试发送验证码前查询Email或手机数据库发生异常的情形。返回"-1"。
@Test
public void testQueryForEmailOrPhone_SQLException()throws SQLException{
		String contact="test@example.com";
when(connection.prepareStatement(anyString())).thenThrow(new SQLException("Database error"));
		String result=userService.queryForEmailOrPhone(contact);
		Assertions.assertEquals("-1",result);//验证结果
	}

3.总结

以上示例显示了如何使用JUnit和Mockito为您的login()和queryForEmailOrPhone()方法编写测试用例。请注意，这些用例依赖于User类的构造和实例化，确保您自己的实现与此相符。对于复杂逻辑，可以进一步细化测试用例。

3）第三批输出

ChatGPT回答

根据您提供的代码，我们将为putCodeInDB()、deleteCodeInDB()和verifyCode()方法编写单元测试用例。我们假设使用JUnit和Mockito作为测试框架，接下来是相应的单元测试代码。

1.单元测试类示例

代码4-40 UserRepositoryTest.java

代码语言：javascript
复制
import static org.mockito.Mockito.*;
import static org.junit.Assert.*;
import java.sql.*;
import org.junit.Before;
import org.junit.Test;
public class CodeServiceTest{
private CodeService codeService;//假设这是包含方法的类
private DataSource dataSource;
private Connection connection;
private PreparedStatement preparedStatement;
private ResultSet resultSet;
@Before
public void setUp()throws SQLException{
		dataSource=mock(DataSource.class);
		connection=mock(Connection.class);
		preparedStatement=mock(PreparedStatement.class);
		resultSet=mock(ResultSet.class);
when(dataSource.getConnection()).thenReturn(connection);
		codeService=new CodeService(dataSource);//初始化服务
	}
//测试将验证码成功插入数据库的正常的情形,返回1。
@Test
public void testPutCodeInDB_Success()throws SQLException{
		String code="123456";
int uid=1;
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeUpdate()).thenReturn(1);//更新成功
int result=codeService.putCodeInDB(code,uid);
		Assertions.assertEquals(1,result);//验证返回的影响行数
		verify(connection).commit();//验证提交
	}
//测试将验证码成功插入数据库的情况,插入失败，影响行为0，返回0。
@Test
public void testPutCodeInDB_Failure()throws SQLException{
		String code="123456";
int uid=1;
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeUpdate()).thenReturn(0);//更新失败
int result=codeService.putCodeInDB(code,uid);
		Assertions.assertEquals(0,result);//验证返回的影响行数
		verify(connection).commit();//应该提交
	}
//测试将验证码成功插入数据库，数据库发生异常的情形，返回-1。
@Test
public void testPutCodeInDB_SQLException()throws SQLException{
		String code="123456";
int uid=1;
when(connection.prepareStatement(anyString())).thenThrow(new SQLException("Database error"));
int result=codeService.putCodeInDB(code,uid);
		Assertions.assertEquals(-1,result);//验证返回的错误代码
	}
//测试从数据库中删除验证码正常的情形,返回1
@Test
public void testDeleteCodeInDB_Success()throws SQLException{
int uid=1;
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeUpdate()).thenReturn(1);//删除成功
int result=codeService.deleteCodeInDB(uid);
		Assertions.assertEquals(1,result);//验证返回的影响行数
		verify(connection).commit();//验证提交
	}
//测试从数据库中删除验证码没有数据的情形,返回0
@Test
public void testDeleteCodeInDB_NoData()throws SQLException{
int uid=1;
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeUpdate()).thenReturn(0);//删除失败
int result=codeService.deleteCodeInDB(uid);
		Assertions.assertEquals(0,result);//验证返回的影响行数
		verify(connection).commit();//应该提交
	}
//测试从数据库中删除验证码，数据库发生异常的情形,返回-1
@Test
public void testDeleteCodeInDB_SQLException()throws SQLException{
int uid=1;
when(connection.prepareStatement(anyString())).thenThrow(new SQLException("Database error"));
int result=codeService.deleteCodeInDB(uid);
		Assertions.assertEquals(-1,result);//验证返回的错误代码
	}
//测试verifyCode方法正常的情形,返回1
@Test
public void testVerifyCode_Success()throws SQLException{
		String code="123456";
int uid=1;
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(true);//验证成功
int result=codeService.verifyCode(code,uid);
		Assertions.assertEquals(1,result);//验证返回的成功标识
		verify(connection).commit();//验证提交
	}
//测试verifyCode方法，code不存在的情形,返回0
@Test
public void testVerifyCode_NotExists()throws SQLException{
		String code="123456";
int uid=1;
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(false);//验证失败
int result=codeService.verifyCode(code,uid);
		Assertions.assertEquals(0,result);//验证返回的失败标识
	}
//测试verifyCode方法，数据库发生异常的情形,返回-1
@Test
public void testVerifyCode_SQLException()throws SQLException{
		String code="123456";
int uid=1;
when(connection.prepareStatement(anyString())).thenThrow(new SQLException("Database error"));
int result=codeService.verifyCode(code,uid);
		Assertions.assertEquals(-1,result);//验证返回的错误代码
	}
}

2.测试用例说明

•putCodeInDB()

Ø成功案例:测试将验证码成功插入数据库的情况。

Ø失败案例:测试当没有影响行数时，返回0。

Ø异常案例:测试当抛出SQL异常时，返回-1。

•deleteCodeInDB()

Ø成功案例:测试成功删除验证码的情况。

Ø无数据案例:测试当没有数据删除时，返回0。

Ø异常案例:测试当抛出SQL异常时，返回-1。

•verifyCode()

Ø成功案例:测试验证码与用户ID匹配的情况。

Ø不匹配案例:测试验证码与用户ID不匹配的情况。

Ø异常案例:测试当抛出SQL异常时，返回-1。

3.注意事项

•请确保在测试中对DataSource、Connection、PreparedStatement和ResultSet对象的使用和行为与您实际的实现保持一致。

•以上测试用例依赖于Mockito的模拟，因此需要在构建项目时加入Mockito的相关依赖。

根据您的项目设置，您可能需要调整错误处理逻辑，确保测试逻辑的准确性。

4）第四批输出

ChatGPT回答

下面是针对您提供的verifyPassword(String newPassword,int uid)和getPassword(int uid)方法的单元测试用例的示例。假设您使用JUnit和Mockito作为测试框架。

1.测试verifyPassword(String newPassword,int uid)方法

•测试用例

Ø当新密码未被使用过时，返回0。

Ø当新密码已经被使用过时，返回1。

Ø当出现SQLException时，返回-1。

代码4-41 UserRepositoryTest.java

代码语言：javascript
复制
import static org.mockito.Mockito.*;
import static org.junit.Assert.*;
import java.sql.*;
import org.junit.Before;
import org.junit.Test;
public class PasswordServiceTest{
private PasswordService passwordService;//假设这是您的服务类
private DataSource dataSource;//数据源
private Connection connection;//数据库连接
private PreparedStatement preparedStatement;//预编译语句
private ResultSet resultSet;//结果集
@Before
public void setUp()throws SQLException{
		dataSource=mock(DataSource.class);
		connection=mock(Connection.class);
		preparedStatement=mock(PreparedStatement.class);
		resultSet=mock(ResultSet.class);
when(dataSource.getConnection()).thenReturn(connection);
		passwordService=new PasswordService(dataSource);//初始化带有数据源的服务
	}
//测试新密码未被使用过时的情形，返回0
@Test
public void testVerifyPassword_NotUsed()throws SQLException{
		String newPassword="newPassword123";
int uid=1;
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(false);//新密码未被使用过
int result=passwordService.verifyPassword(newPassword,uid);
		Assertions.assertEquals(0,result);//验证结果
	}
//测试当新密码已经被使用过时的情形，返回1
@Test
public void testVerifyPassword_Used()throws SQLException{
		String newPassword="usedPassword123";
int uid=1;
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(true);//新密码已被使用过
//这里可以模拟返回值，如果有需求的话
when(resultSet.getString("password")).thenReturn(newPassword);
int result=passwordService.verifyPassword(newPassword,uid);
		Assertions.assertEquals(1,result);//验证结果
	}
//测试当新密码已经被使用过时数据库发生异常的情形，返回-1
@Test
public void testVerifyPassword_SQLException()throws SQLException{
		String newPassword="errorPassword123";
int uid=1;
when(connection.prepareStatement(anyString())).thenThrow(new SQLException("Database error"));
int result=passwordService.verifyPassword(newPassword,uid);
		Assertions.assertEquals(-1,result);//验证结果
	}
}

2.测试getPassword(int uid)方法

•测试用例

Ø当用户ID存在时，返回对应的密码。

Ø当用户ID不存在时，返回"0"。

Ø当出现SQLException时，返回"-1"。

代码4-42 UserRepositoryTest.java

代码语言：javascript
复制
//测试根据用户ID返回密码,当用户ID存在时，返回对应的密码
@Test
public void testGetPassword_Exists()throws SQLException{
int uid=1;
	String expectedPassword="secretPassword123";
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(true);//用户 ID 存在
when(resultSet.getString("password")).thenReturn(expectedPassword);//返回对应密码
	String result=passwordService.getPassword(uid);
	Assertions.assertEquals(expectedPassword,result);//验证结果
}
//测试根据用户ID返回密码,当用户ID不存在时，返回"0"
@Test
public void testGetPassword_NotExists()throws SQLException{
int uid=2;
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(false);//用户 ID 不存在
	String result=passwordService.getPassword(uid);
	Assertions.assertEquals("0",result);//验证结果
}
//测试根据用户ID返回密码,当出现SQLException时，返回"-1"。
@Test
public void testGetPassword_SQLException()throws SQLException{
int uid=1;
when(connection.prepareStatement(anyString())).thenThrow(new SQLException("Database error"));
	String result=passwordService.getPassword(uid);
	Assertions.assertEquals("-1",result);//验证结果
}

3.总结

以上是如何编写单元测试用例的示例，针对verifyPassword和getPassword方法，使用Mockito模拟数据库操作以及JUnit进行断言验证。这些测试用例可以确保您的代码在不同情况下的行为是正确的。请确保根据您实际的服务类名和数据源适当修改代码。

5）第五批输出

ChatGPT回答

为了对提供的storeOldPassword()方法编写单元测试用例，建议使用JUnit和Mockito。下面是一个示例测试类，包含了一些针对这两个方法的测试用例。

请确保您已经添加了JUnit和Mockito的依赖到您的项目中。

代码4-43 UserRepositoryTest.java

代码语言：javascript
复制
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import java.sql.*;
class PasswordServiceTest{
private PasswordService passwordService;//假设这是你的包含方法的类
private DataSource dataSource;
private Connection connection;
private PreparedStatement preparedStatement;
//在每个测试前创建一个PasswordService实例，并模拟它的DataSource和Connection。
@BeforeEach
void setUp()throws SQLException{
		dataSource=mock(DataSource.class);
		connection=mock(Connection.class);
		preparedStatement=mock(PreparedStatement.class);
when(dataSource.getConnection()).thenReturn(connection);
		passwordService=new PasswordService(dataSource);
	}
//检查storeOldPassword()方法的成功场景，返回受影响的行数并确保事务被提交。返回1。
@Test
void testStoreOldPassword_Success()throws SQLException{
		String oldPassword="oldPassword123";
int uid=1;
when(connection.prepareStatement(any(String.class))).thenReturn(preparedStatement);
when(preparedStatement.executeUpdate()).thenReturn(1);
int result=passwordService.storeOldPassword(oldPassword,uid);
		Assertions.assertEquals(1,result);//应该返回受影响的行数
		verify(connection).commit();//确保成功提交事务
		verify(preparedStatement).setInt(1,uid);
		verify(preparedStatement).setString(2,oldPassword);
	}
//测试storeOldPassword()当没有影响的行时的行为，确保不提交事务。返回0。
@Test
void testStoreOldPassword_NoAffectedRows()throws SQLException{
		String oldPassword="oldPassword123";
int uid=1;
when(connection.prepareStatement(any(String.class))).thenReturn(preparedStatement);
when(preparedStatement.executeUpdate()).thenReturn(0);
int result=passwordService.storeOldPassword(oldPassword,uid);
		Assertions.assertEquals(0,result);//应该返回 0，表示没有行受影响
		verify(connection,times(0)).commit();//不应该提交事务
	}
//测试storeOldPassword()方法的异常处理，确保返回-1。
@Test
void testStoreOldPassword_Exception()throws SQLException{
		String oldPassword="oldPassword123";
int uid=1;
when(connection.prepareStatement(any(String.class))).thenThrow(new SQLException("Database error"));
int result=passwordService.storeOldPassword(oldPassword,uid);
Assertions.assertEquals(-1,result);//应该返回-1，表示异常
	}
//测试updatePassword()方法成功的情形，返回1
@Test
void testUpdatePassword_Success()throws SQLException{
		String newPassword="newPassword456";
int uid=1;
when(connection.prepareStatement(any(String.class))).thenReturn(preparedStatement);
when(preparedStatement.executeUpdate()).thenReturn(1);
int result=passwordService.updatePassword(newPassword,uid);
		Assertions.assertEquals(1,result);//应该返回受影响的行数
		verify(connection).commit();//确保成功提交事务
		verify(preparedStatement).setInt(2,uid);
		verify(preparedStatement).setString(1,newPassword);
	}
//测试updatePassword()方法没有反映的情形，返回0
@Test
void testUpdatePassword_NoAffectedRows()throws SQLException{
		String newPassword="newPassword456";
int uid=1;
when(connection.prepareStatement(any(String.class))).thenReturn(preparedStatement);
when(preparedStatement.executeUpdate()).thenReturn(0);
int result=passwordService.updatePassword(newPassword,uid);
		Assertions.assertEquals(0,result);//应该返回 0，表示没有行受影响
		verify(connection,times(0)).commit();//不应该提交事务
	}
//测试updatePassword()方法发生异常的情形，返回-1
@Test
void testUpdatePassword_Exception()throws SQLException{
		String newPassword="newPassword456";
int uid=1;
when(connection.prepareStatement(any(String.class))).thenThrow(new SQLException("Database error"));
int result=passwordService.updatePassword(newPassword,uid);
		Assertions.assertEquals(-1,result);//应该返回-1，表示异常
	}
}

说明

•void setUp()方法：在每个测试前创建一个PasswordService实例，并模拟它的DataSource和Connection。

•void testStoreOldPassword_Success()方法：检查storeOldPassword()方法的成功场景，返回受影响的行数并确保事务被提交。

•void testStoreOldPassword_NoAffectedRows()方法：测试storeOldPassword()当没有影响的行时的行为，确保不提交事务。

•void testStoreOldPassword_Exception()方法：测试storeOldPassword()方法的异常处理，确保返回-1。

•void testUpdatePassword_Success()方法、testUpdatePassword_NoAffectedRows()方法和void testUpdatePassword_Exception()方法：这些测试检查updatePassword()方法的各个场景。

4.2.3运行找回密码测试单元测试用例

1.CookiesManagerTest.java

运行此测试用例时，发现testGetCookie_CookieDoesNotExist()返回的结果不是null,需要询问ChatGPT。

提示词

代码语言：javascript
复制
@Test
void testGetCookie_CookieDoesNotExist(){
//Mocking the request to return an empty cookie array
Cookie[] cookies={new Cookie("otherCookie","otherValue")};
when(request.getCookies()).thenReturn(cookies);
String value=cookiesManager.getCookie();
assertNull(value);
}

测试未通过，返回结果为。

代码语言：javascript
复制
org.opentest4j.AssertionFailedError:expected:<null>but was:<testValue>
at org.junit.jupiter.api.AssertionUtils.fail(AssertionUtils.java:55)
at org.junit.jupiter.api.AssertNull.failNotNull(AssertNull.java:54)
at org.junit.jupiter.api.AssertNull.assertNull(AssertNull.java:38)
at org.junit.jupiter.api.AssertNull.assertNull(AssertNull.java:33)
at org.junit.jupiter.api.Assertions.assertNull(Assertions.java:275)
…

ChatGPT回答

根据你提供的错误信息，测试用例testGetCookie_CookieDoesNotExist()期望返回null，但实际上返回了"testValue"。这表明CookiesManager的getCookie()方法在没有找到指定的Cookie时返回了"testValue"，而不是null。

1解决方案

要使测试用例通过，您可以选择以下两种方法之一。

•修改CookiesManager的getCookie()方法：如果您希望在没有找到指定Cookie时返回null，可以按如下方式修改getCookie()方法。

代码4-44 CookiesManager.java

代码语言：javascript
复制
public String getCookie(){
	Cookie[] cookies=request.getCookies();
if(cookies!=null){
for(Cookie cookie:cookies){
if(cookie.getName().equals(cookieName)){
return cookie.getValue();
			}
		}
	}
return null;//如果cookie不存在，返回null
}

•修改测试用例：如果您希望保持getCookie()方法的当前实现，并且在没有找到指定Cookie时返回"testValue"，则可以修改测试用例以期望这个值。

代码4-45 CookiesManagerTest.java

代码语言：javascript
复制
@Test
void testGetCookie_CookieDoesNotExist(){
//模拟请求返回不包含所需cookie的数组
Cookie[] cookies={new Cookie("otherCookie","otherValue")};
when(request.getCookies()).thenReturn(cookies);
CookiesManager cookiesManager=new CookiesManager("uid",response,request);
String value=cookiesManager.getCookie();
Assertions.assertEquals("testValue",value);//当cookie不存在时，预期为"testValue"
}

2.选择哪种方法？

•如果您希望在没有找到特定Cookie时返回null，请选择第一种方法。

•如果您希望在没有找到特定Cookie时返回"testValue"，请选择第二种方法。

请根据您的需求选择合适的方法，并相应地修改代码。这样，测试用例应该能够通过。

根据提示，选择第一种方法，修改getCookie()方法如下。

代码4-46 CookiesManager.java

代码语言：javascript
复制
//获取cookies的方法
public String getCookie(){
	Cookie[] cookies=this.request.getCookies();//获取所有的cookies
if(cookies!=null){
for(Cookie cookie:cookies){
			String name=cookie.getName();//获取cookie的名称
			String value=cookie.getValue();//获取cookie的值
if(name.equals(this.cookies_name)&&(value!=null)&&(!value.isEmpty())){
this.cookies_value=value;
return this.cookies_value;
			}
		}
	}
return null;
}

2.PasswordRecoveryTest.java

第1步：运行testRecoverPassword_Success()，运行失败。对密码进行SHA256处理，修改程序如下。

代码4-47 PasswordRecoveryTest.java

代码语言：javascript
复制
@Test
public void testRecoverPassword_Success()throws SQLException{
	util Util=new util();
	String identifyingCode="123456";
	String newPassword=Util.sha256("hashedPassword");
int uid=1;
//模拟UserRepository方法的行为
when(mysql.verifyCode(identifyingCode,uid)).thenReturn(1);//模拟正确的验证码
when(mysql.getPassword(uid)).thenReturn(Util.sha256("oldHashedPassword"));//模拟旧密码的检索
when(mysql.storeOldPassword(Util.sha256("oldHashedPassword"),uid)).thenReturn(1);//模拟成功存储旧密码
when(mysql.verifyPassword(newPassword,uid)).thenReturn(0);//模拟新密码要提前被使用过
when(mysql.updatePassword(newPassword,uid)).thenReturn(1);//模拟密码被修改
	String result=passwordRecovery.recoverPassword(identifyingCode,newPassword,mysql,uid);
	Assertions.assertEquals("0",result);//期待的结果，返回"0"
}

测试通过。

第2步：修改testRecoverPassword_InvalidVerificationCode()的验证。

代码4-47 PasswordRecoveryTest.java

代码语言：javascript
复制
Assertions.assertEquals("验证码必须是4-6位数字",result);//Expecting error message

运行测试,测试通过。

第3步：运行testSendVerificationCode_ValidPhone()。测试通过。

3.PasswordRecoveryControllerTest.java

PasswordRecoveryControllerTest.java使用的是PowerMockito,而不是Mockito。

提示词

请用Mockito+JUnit5生成下面代码的测试用例，而不要用PowerMockito。

参看代码4-32 PasswordRecoveryController.java

ChatGPT回答

代码4-48 PasswordRecoveryControllerTest.java

代码语言：javascript
复制
package ebusiness;
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
public class PasswordRecoveryControllerTest {
private UtilTest Util = new UtilTest();
@Mock
private HttpServletRequest request;
@Mock
private HttpServletResponse response;
@Mock
private UserRepository dbUser;
@Mock
private Connection connection;
@Mock
private PasswordRecovery passwordRecovery;
@InjectMocks
private PasswordRecoveryController recover;
@BeforeEach
public void setUp() throws Exception {
		MockitoAnnotations.openMocks(this);
when(passwordRecovery.sendVerificationCode(anyString())).thenReturn("123456");
when(passwordRecovery.recoverPassword(anyString(), anyString(), any(), anyInt())).thenReturn("0");
	}
//测试发送验证码成功的场景。
@Test
public void testSendVerificationCode_Success() throws SQLException, IOException {
when(request.getParameter("contact")).thenReturn("test@example.com");
String result = recover.sendVerificationCode();
		Assertions.assertEquals("0", result);
	}
//测试发送验证码时发生错误的场景。
@Test
public void testSendVerificationCode_Error() throws Exception {
when(request.getParameter("contact")).thenReturn("test@example.com");
when(passwordRecovery.sendVerificationCode(anyString())).thenReturn("-1");
String result = recover.sendVerificationCode();
		Assertions.assertEquals("0", result);
	}
//测试重置密码成功的场景。
@Test
public void testRecoverPassword_Success() throws SQLException, IOException {
when(request.getParameter("identifyingCode")).thenReturn("code123");
when(request.getParameter(Util.sha256("newPassword"))).thenReturn(Util.sha256("newPassword"));
when(request.getCookies()).thenReturn(new javax.servlet.http.Cookie[]{new javax.servlet.http.Cookie("uid", "1")});
String result = recover.recoverPassword();
		Assertions.assertEquals("0", result); 
	}
//测试重置密码没有UID的场景。
@Test
public void testRecoverPassword_NoUid() throws SQLException, IOException {
when(request.getParameter("identifyingCode")).thenReturn("code123");
when(request.getParameter(Util.sha256("newPassword"))).thenReturn(Util.sha256("newPassword"));
when(request.getCookies()).thenReturn(new javax.servlet.http.Cookie[]{});
String result = recover.recoverPassword();
		Assertions.assertEquals("请输入验证码后再进入", result);
	}
}

运行测试用例，测试通过。

4.myUtilTest.java

修改测试用例中

代码4-49 myUtilTest.java

代码语言：javascript
复制
@Test
public void testGetPropertiesInfo()throws IOException{
String file="test.properties";//确保这个文件在类路径中

为

代码语言：javascript
复制
@Test
public void testGetPropertiesInfoForConfigProperties()
String file="config.properties";//确保这个文件在类路径中

运行测试用例，测试通过。

5.SendSmsTest.java

运行测试，测试用例运行通过。

6.UserRepositoryTest.java

运行第一批产生的测试用例，testInsertUser_Success()和testInsertUser_UserExists()运行失败。使用以前的测试用例。

代码4-49 UserRepositoryTest.java

代码语言：javascript
复制
import org.apache.log4j.Logger;
…
private static final Logger logger=Logger.getLogger(UserRepositoryTest.class);
@Test
public void testInsert_Success()throws IOException{
try{
UserRepository mysql=new UserRepository();
String username="newUser";
String password="password";
String phone="13812345678";
String email="newuser@example.com";
User user=new User(username,password,phone,email);
String result=mysql.insert(user);		
UtilTest ut=new UtilTest();
if(!ut.deleteUser(user)){
				logger.info("删除失败");
			}
Assertions.assertEquals("注册用户的账号必须唯一",result);
		}catch(SQLException e){
			logger.error(e.getMessage());
Assertions.fail("Insert failed");
		}
	}
@Test
public void testInsert_UserExists()throws IOException,SQLException{
try{
UserRepository mysql=new UserRepository();
String username="existingUser";
String password="password";
String phone="13812345678";
String email="existinguser@example.com";
User user=new User(username,password,phone,email);
String result=mysql.insert(user);
Assertions.assertEquals("1",result);
			result=mysql.insert(user);
UtilTest ut=new UtilTest();
if(!ut.deleteUser(user)){
				logger.info ("删除失败");
			}
Assertions.assertEquals("注册用户的账号必须唯一",result);
		}catch(SQLException e){
			logger.error(e.getMessage());
Assertions.fail("Insert failed");
		}
}

这两种方法需要删除setUp()方法。

代码语言：javascript
复制
@BeforeEach
public void setUp()throws SQLException{
when(dataSource.getConnection()).thenReturn(connection);
}

而

代码语言：javascript
复制
void testUserExists_UserDoesNotExist()

和

代码语言：javascript
复制
void testJudgeInfo_UserExists()

需要将

代码语言：javascript
复制
when(dataSource.getConnection()).thenReturn(connection);

加到这两个测试用例开始。

代码语言：javascript
复制
@Test
public void testUserExists_UserDoesNotExist()throws SQLException{
when(dataSource.getConnection()).thenReturn(connection);
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(false);//Simulate that user does not exist	
	String result=userRepository.userExists("newUser","new@example.com","1234567890");
//验证用户不存在
	Assertions.assertEquals("0",result);
}
@Test
public void testJudgeInfo_UserExists()throws SQLException{
when(dataSource.getConnection()).thenReturn(connection);
when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
when(preparedStatement.executeQuery()).thenReturn(resultSet);
when(resultSet.next()).thenReturn(true);//Simulate that user exists 
	String result=userRepository.judgeInfo("username","existingUser");	
//验证用户存在
	Assertions.assertEquals("username",result);
}

运行第二批到第五批测试用例产生的测试用例，都要将

代码语言：javascript
复制
when(dataSource.getConnection()).thenReturn(connection);

加到所有测试用例开始。

修改第二批

代码语言：javascript
复制
userService.方法名();

为。

代码语言：javascript
复制
userRepository.方法名();

修改第三批

代码语言：javascript
复制
codeService.方法名();

为。

代码语言：javascript
复制
userRepository.方法名();

修改第四批

代码语言：javascript
复制
passwordService.方法名();

为。

代码语言：javascript
复制
userRepository.方法名();

修改第五批

代码语言：javascript
复制
passwordService.方法名();

为。

代码语言：javascript
复制
userRepository.方法名();

运行所有测试用例，均通过。

注意：在进行代码提交时，如果提交的代码越细，得到的单元测试用例更具体，生成的单元测试用例得到更高的测试覆盖率。读者可以尝试在提交userRepository类中的所有代码，这样会导致生成的测试用例数量很少，测试用例覆盖率也越低。

4.2.4回归测试以前所有单元测试代码

运行其他单元测试用例，确保全部通过。

顾翔凡言：人工智能未来的发展瓶颈在于对知识的更新。唯一不变的是变化，知识发生了变化，人工智能软件能否及时跟进变化，可能阻碍人工智能的使用。

本文参与 腾讯云自媒体同步曝光计划，分享自微信公众号。
原始发表：2025-12-18，如有侵权请联系 cloudcommunity@tencent.com 删除
数据库
验证码
chatgpt
测试
软件开发

本文分享自 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

数据库
验证码
chatgpt
测试
软件开发
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2026 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 粤公网安备44030502008569号

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2026 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论