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

phone=CheckFieldByRecover(phonePattern,contact,isValid);
email=CheckFieldByRecover(emailPattern,contact,isValid);

let phone=CheckFieldByRecover(phonePattern,contact,isValid);
let email=CheckFieldByRecover(emailPattern,contact,isValid);

<%@page contentType="text/html;charset=utf-8"%>
<%@page import="ebusiness.Util,ebusiness.CookiesManager,ebusiness.PasswordRecoveryController"%>
<%@page import="org.apache.commons.text.StringEscapeUtils"%>
<%
  CookiesManager ct=new CookiesManager(response,request);
  String csrftoken=ct.generateCsrfToken();//假设在 CookiesManager 中实现
  ct.setCookie(csrftoken);
%>
<div id="recoverError" class="error">
<%
  String method=request.getMethod();
  if("post".equalsIgnoreCase(method)){
    String csrftoken_post=request.getParameter("csrftoken");
    String csrftoken_cookies=ct.getCookie();
  if(csrftoken_cookies!=null&&csrftoken_cookies.equals(csrftoken_post)){
    PasswordRecoveryController recover=new PasswordRecoveryController(response,request);
    recover.recoverPassword();
    }else{
    out.println("可能存在CSRF攻击风险");
    }
  }
%>
</div>

…
Util util=new Util();
Properties prop=util.getPropertiesInfo("jdbc.properties");
String driver=prop.getProperty("driver");
String url=prop.getProperty("url");
String user=prop.getProperty("user");
String password=prop.getProperty("password");
Class.forName(driver);
Connection conn=DriverManager.getConnection(url,user,password);
…

public boolean SendMail(String contact,String message){
try{
Properties prop=util.getPropertiesInfo("config.properties");
//获取数据
String SNMPTServer=prop.getProperty("SNMPTServer");
String from=prop.getProperty("from");
String to=contact;
String title=prop.getProperty("title");
String content=message;
String username=prop.getProperty("username");
String password=prop.getProperty("password");
String port=prop.getProperty("port");
List list=new ArrayList();
//发送Emial验证码
EmailSender sender=new EmailSender(SMTPServer,from,to,title,content,list,username,password,port);
String [] result=sender.sendMail();
if (result[1].equals("发送成功")){
return true;
		}else{
return false;
		}	
	}catch (IOException ex){
		logger.error("发Email验证码信息发生错误" + ex.getMessage());
	}
return false;
}

String insertString="INSERT INTO user(username,password,phone,email)VALUES(?,?,?,?)";
try (Connection conn=dataSource.getConnection(); 
	PreparedStatement stmt=conn.prepareStatement(insertString)){
…
try (ResultSet rs=stmt.executeQuery()){
…

//通过User ID获得user表的密码
public String getPassword(int uid){
String password=null;
String query="SELECT password FROM user WHERE id=?";
try(Connection conn=dataSource.getConnection();
PreparedStatement stmt=conn.prepareStatement(query)){
		stmt.setInt(1,uid);
try(ResultSet rs=stmt.executeQuery()){
if(!rs.next()){
				logger.error("通过id获得user表的密码失败");
return "0";//不存在
			}else{
				password=rs.getString("password");//存在
				logger.info("通过id获得user表的密码成功");
			}
		}
	}catch(SQLException e){
		logger.error("getPassword发生数据库错误:"+e.getMessage());
	}
return password!=null?password:"-1";//返回密码或-1
	}

String queryString="SELECT * FROM user WHERE "+field+"=?";

  if(!field.equals("username")||!field.equals("phone")||!field.equals("email")
{
	logger.info("user表"+field+"字段不存在"+value+"值");
return "0";
  }else{
String queryString="SELECT * FROM user WHERE "+field+"=?";
  }

public String userExists(String username,String email,String phone){
//页面的逻辑可能更易于理解
String result=judgeInfo("username",username);
if(!"0".equals(result))return "注册用户的账号必须唯一";
	result=judgeInfo("phone",phone);
if(!"0".equals(result))return "注册用户的手机必须唯一";
	result=judgeInfo("email",email);
if(!"0".equals(result))return "注册用户的邮箱必须唯一";
return "0";
}

//判断验证码是否正确
int info_i=mysql.verifyCode(identifyingCode,uid);
if(info_i!=1){
return "验证码错误，请重新输入！";
}

//重置密码
info_i=updatePassword(newPassword,oldPassword,mysql,uid);
if(info_i==-1){
return "-1";
}

//重置密码
info_i=updatePassword(newPassword,oldPassword,mysql,uid);
if(info_i==-1){
  return "-1";
}

//重置密码
updatePasswordInfo=updatePassword(newPassword,oldPassword,mysql,uid);
if(updatePasswordInfo==-1){
  return "-1";
}

//验证新密码是否使用过
boolean info_b=isPasswordUsed(newPassword,uid,mysql);
if(!info_b){
  return "这个密码以前设置过，请用一个新密码！";
}

//验证新密码是否使用过
boolean isPasswordUsedInfo=isPasswordUsed(newPassword,uid,mysql);
if(!isPasswordUsedInfo){
  return "这个密码以前设置过，请用一个新密码！";
}

int info=mysql.deleteCodeInDB(uidi);
if(info==1 ||info==0){ 
  //将新的验证码记录放入password

int deleteCodeInDBInfo=mysql.deleteCodeInDB(uidi);
if(deleteCodeInDBInfo==1||deleteCodeInDBInfo==0){
  //将新的验证码记录放入password

handleSmsVerification(String contact,int uid,String code)
handleEmailVerification(String contact,int uid,String code)

//通过手机号或Email发送验证码
public String sendVerificationCode(String contact)throws Exception{
		String contactType=getContactType(contact);
if(contactType==null){
return "您输入的手机号或Email格式不正确！";
		}
		UserRepository userRepository=new UserRepository();
		String uid=getUserIdByContact(contact,userRepository);
if(!uid.matches("\\d+")){
return uid;
		}
		int uidi=Integer.parseInt(uid);
		String code=util.generateRandomString(6,"int");
		UserRepository mysql=new UserRepository();
		HikariDataSource dataSource=mysql.dataSource;
if(contactType.equals("phone")){
return sendCodeForSMS(contact,uidi,code,userRepository,mysql,uid);
		}else if(contactType.equals("email")){
return sendCodeForEmail(contact,code,uidi,uid,mysql);
		}
		util.closePool(dataSource);
return contactType;
	}
//通过手机号发送验证码
private String sendCodeForSMS(String contact,int uidi,String code,UserRepository mysql,String uid)throws Exception{
if(sendSmsVerificationCode(contact,uidi,code,mysql).equals("验证码已发送至手机")){
//清除以前code表中的验证码记录
			int info=mysql.deleteCodeinDB(uidi);
if(info==1 ||info==0){
//将新的验证码记录放入code表
				mysql.putCodeInDB(code,uidi);
return uid;
			}else{
				logger.error("从code删除数据失败");
return "-1";
			}
		}else{
			logger.error("短信发送失败！");
return "-1";
		}
	}
//通过Email发送验证码
private String sendCodeForEmial(String contact,String code,int uidi,String uid,UserRepository mysql)throws Exception{
if(sendEmailVerificationCode(contact,code).equals("验证码已发送至邮箱")){
			int info=mysql.deleteCodeinDB(uidi);
if(info==1 ||info==0){
//将新的验证码记录放入password
				mysql.putCodeInDB(code,uidi);
return uid;
			}else{
				logger.error("从code删除数据失败");
return "-1";
			}
		}else{
			logger.error("邮件发送失败！");
return "-1";
		}
	}

sendCodeForSMS(String contact,int uidi,String code,UserRepository mysql,String uid)

sendCodeForEmail(String contact,String code,int uidi,String uid,UserRepository mysql)

private String sendCodeForSMS(String contact,int uidi,String code,UserRepository mysql,String uid)throws Exception{
return sendCode(contact,mysql,uidi,uid,code,"SMS");	
	}
private String sendCodeForEmail(String contact,String code,int uidi,String uid,UserRepository mysql)throws Exception{
return sendCode(contact,mysql,uidi,uid,code,"Email");
	}
private String sendCode(String contact,UserRepository mysql,int uidi,String uid,String code,String sign)throws Exception{
boolean judge=false;
if(sign.equals("SMS")){
		judge=sendSmsVerificationCode(contact,uidi,code,mysql).equals("验证码已发送至手机");
}else if(sign.equals("Email")){
		judge=sendEmailVerificationCode(contact,code).equals("验证码已发送至邮箱");
}
if(judge){
int info=mysql.deleteCodeinDB(uidi);
if(info==1 ||info==0){
//将新的验证码记录放入password
			mysql.putCodeInDB(code,uidi);
return uid;
		}else{
			logger.error("从code删除数据失败");
return "-1";
		}
}else{
if(sign.equals("SMS")){
			logger.error("短信发送失败！");
	}else if(sign.equals("Email")){
			logger.error("邮件发送失败！");
	}	
return "-1";
}
}

public String sendVerificationCode(String contact)throws Exception{
String contactType=getContactType(contact);
if(contactType==null){
return "您输入的手机号或Email格式不正确！";
	}		
UserRepository mysql=new UserRepository();
try(HikariDataSource dataSource=mysql.dataSource){
String uid=getUserIdByContact(contact,mysql);
		…
}

logger.error("发送验证码的时候发生错误:"+e.getMessage());

logger.error("XXXX的时候发生错误:"+e.getMessage());

//重置密码
public String recoverPassword()throws SQLException,IOException{
	…
String info=passwordrecovery.recoverPassword(identifyingCode,newPassword,mysql,uidi);
if(info.equals("0")){
	userId.clearCookie();
	response.sendRedirect("LoginPage.jsp");
}else{
String encodedMessage=URLEncoder.encode(info,"UTF-8");
String url="RecoverPage.jsp?error="+encodedMessage;
	response.sendRedirect(url);
}
Util util=new Util();
util.closePool(dataSource);

//重置密码
public String recoverPassword()throws SQLException,IOException{
	…
//更新新密码
try(HikariDataSource dataSource=mysql.dataSource){
String info=passwordrecovery.recoverPassword(identifyingCode,newPassword,mysql,uidi);
if(info.equals("0")){
				userId.clearCookie();
				response.sendRedirect("LoginPage.jsp");
			}else{
String encodedMessage=URLEncoder.encode(info,"UTF-8");
String url="RecoverPage.jsp?error="+encodedMessage;
				response.sendRedirect(url);
			}
		}catch(Exception e){
			logger.error("userInfoIsInviald()数据库发生错误:"+e.getMessage());
		}
	}
return "0";
}

public String performLogin()throws SQLException,IOException{
String username=request.getParameter("username");
String password=request.getParameter("password");	
User user=new User(username,password);
ValidateUser ValidateUser=new ValidateUser();
String validationMessage=ValidateUser.validate(user);
String errorMessage="";
if(validationMessage.equals("验证成功")){
validatePass(user,errorMessage,username);
	}else{
		errorMessage=validationMessage;
validatefail(errorMessage);
	}
return "0";
}
private void validatePass(User user,String errorMessage,String username)throws SQLException,IOException{
Util util=new Util();
UserRepository mysql=new UserRepository();
HikariDataSource dataSource=mysql.dataSource;
try{
if(mysql.login(user).equals("0")){
String url="/jsp/LoginPage.jsp";
			errorMessage="账号或密码错误";
util.sendRedirect(response,request.getContextPath()+url,"error",errorMessage);
		}else{
CookiesManager myusername=new CookiesManager("username",username,response,request);
			myusername.setCookie();
String url="/jsp/WelcomePage.jsp";
			util.sendRedirect(response,request.getContextPath()+url);
		}
	}catch(Exception e){
		logger.error("validatePass()发生错误:"+e.getMessage());
	}finally{
			util.closePool(dataSource);
	}
}
private void validatefail(String errorMessage)throws IOException{
Util util=new Util();
String url="/jsp/LoginPage.jsp";
	util.sendRedirect(response,request.getContextPath()+url,"error",errorMessage);
}

private void validatePass(User user,String errorMessage,String username)throws SQLException,IOException{
Util util=new Util();
UserRepository mysql=new UserRepository();
try(HikariDataSource dataSource=mysql.dataSource){
if(mysql.login(user).equals("0")){
			…
	}catch(Exception e){
		logger.error("validatePass()发生错误:"+e.getMessage());
	}
}

function check(username,password,confirmPassword,phone,email){
…
}
function checkLogin(username,password){
…
}
function checkVeriCode(contact){
…
}

public boolean isHash(String str){
  …
}

 public String validate(User user){
  …
}

//设置cookies的方法
public void setCookie(){
if(this.cookies_value!=null&&!this.cookies_value.isEmpty()){
try{
//创建一个 Cookie
		Cookie cookie=new Cookie(this.cookies_name,this.cookies_value);	
//设置 Cookie 的路径
		cookie.setPath(request.getContextPath());//确保在应用的上下文中可用 
//cookie.setDomain("192.168.31.184");//注意：这可能在某些浏览器中不被支持
//可选：设置 Cookie 的过期时间（单位：秒）
		cookie.setMaxAge(60*60*24);//1天 
//可选：设置 Cookie 的 HttpOnly 属性
		cookie.setHttpOnly(true);
//将 Cookie 添加到响应中
		response.addCookie(cookie);
	}catch(Exception e){
		logger.error("setCookie()发生错误:"+e.getMessage());
	}
	}else{
//处理cookies为空的情况
	logger.info("cookie 为空.");
}
}

public String performRegister()throws SQLException,IOException{
User user=getUser();
ValidateUser ValidateUser=new ValidateUser();
String validationResult=ValidateUser.validate(user);
Util util=new Util();
if(!validationResult.equals("验证成功")){
	util.sendRedirect(response,request.getContextPath()+"/jsp/RegisterPage.jsp","error",validationResult);
}else{
userInfoIsInviald(user);
}
return "0";
}
private User getUser(){
String username=this.request.getParameter("username");
String password=this.request.getParameter("password");
String phone=this.request.getParameter("phone");
String email=this.request.getParameter("email");
User user=new User(username,password,phone,email);
return user;
}
private void userInfoIsInviald(User user)throws SQLException,IOException{
Util util=new Util();
UserRepository mysql=new UserRepository();
HikariDataSource dataSource=mysql.dataSource;
try{
String info=mysql.insert(user);
if(info.equals("1")){
		util.sendRedirect(response,request.getContextPath()+"/jsp/LoginPage.jsp");
	}else{
util.sendRedirect(response,request.getContextPath()+"/jsp/RegisterPage.jsp","error",info);
	}
	}catch(Exception e){
		logger.error("userInfoIsInviald()数据库发生错误:"+e.getMessage());
	}finally{
		util.closePool(dataSource);
	}
}

package ebusiness;
import java.io.IOException;
import java.sql.SQLException;
import javax.servlet.http.HttpServletResponse;
import org.apache.log4j.Logger;
import com.zaxxer.hikari.HikariDataSource;
import javax.servlet.http.HttpServletRequest;
public class RegisterController{
private static final Logger logger=Logger.getLogger(RegisterController.class);
private HttpServletResponse response;
private HttpServletRequest request;
public RegisterController(HttpServletResponse response,HttpServletRequest request){
this.response=response;
this.request=request;
	}
public String performRegister()throws SQLException,IOException{
User user=getUser();
ValidateUser ValidateUser=new ValidateUser();
String validationResult=ValidateUser.validate(user);
Util util=new Util();
if(!validationResult.equals("验证成功")){
			util.sendRedirect(response,request.getContextPath()+"/jsp/RegisterPage.jsp","error",validationResult);
		}else{
userInfoIsInviald(user);
		}
return "0";
	}
private User getUser(){
String username=this.request.getParameter("username");
String password=this.request.getParameter("password");
String phone=this.request.getParameter("phone");
String email=this.request.getParameter("email");
User user=new User(username,password,phone,email);
return user;
	}
private void userInfoIsInviald(User user)throws SQLException,IOException{
Util util=new Util();
UserRepository mysql=new UserRepository();
HikariDataSource dataSource=mysql.dataSource;
try{
String info=mysql.insert(user);
if(info.equals("1")){
				util.sendRedirect(response,request.getContextPath()+"/jsp/LoginPage.jsp");
			}else{
				util.sendRedirect(response,request.getContextPath()+"/jsp/RegisterPage.jsp","error",info);
			}
		}catch(Exception e){
			logger.error("userInfoIsInviald()数据库发生错误:"+e.getMessage());
		}finally{
			util.closePool(dataSource);
		}
	}
}

public String performRegister()throws SQLException,IOException{
String username=this.request.getParameter("username");
String password=this.request.getParameter("password");
String phone=this.request.getParameter("phone");
String email=this.request.getParameter("email");
//Validate user input
String validationMessage=validateInput(username,password,phone,email);
if(validationMessage!=null){
return validationMessage;//Return validation message
	}
User user=new User(username,password,phone,email);
ValidateUser validateUser=new ValidateUser();
String validationResult=validateUser.validate(user);
if(!validationResult.equals("验证成功")){
return validationResult;
	}
UserRepository mysql=new UserRepository();
try(HikariDataSource dataSource=mysql.getDataSource()){//Use try-with-resources
String info=mysql.insert(user);
if("1".equals(info)){
this.response.sendRedirect("LoginPage.jsp");
		}else{
String encodedMessage=URLEncoder.encode(info,"UTF-8");
String url="RegisterPage.jsp?error="+encodedMessage;
this.response.sendRedirect(url);
		}
	}catch(SQLException e){
		logger.error("performRegister()数据库发生错误:"+e.getMessage(),e);
//Optionally return a user-friendly message
	}
return "0";//Consider returning meaningful status or message
}
private String validateInput(String username,String password,String phone,String email){
//Add input validation logic here
//Return null if valid,or return a validation message if invalid
}

private void userInfoIsInviald(User user)throws SQLException,IOException{
Util util=new Util();
UserRepository mysql=new UserRepository();
try(HikariDataSource dataSource=mysql.dataSource){
String info=mysql.insert(user);
		…
	}catch(Exception e){
		logger.error("userInfoIsInviald()数据库发生错误:"+e.getMessage());
	}
}

class Config:
REGISTER_URL="http://127.0.0.1:8080/CharGPTEbusiness/jsp/RegisterPage.jsp"
LOGIN_URL="http://127.0.0.1:8080/CharGPTEbusiness/jsp/LoginPage.jsp"
WELCOME_URL="http://127.0.0.1:8080/CharGPTEbusiness/jsp/WelcomePage.jsp"
VERICODE_URL="http://127.0.0.1:8080/CharGPTEbusiness/jsp/VeriCodePage.jsp"
RECOVER_URL="http://127.0.0.1:8080/CharGPTEbusiness/jsp/RecoverPage.jsp"
VALID_USERNAME="validUser123"
VALID_PASSWORD="Valid123!"
INVALID_USERNAME="validUser321"
INVALID_PASSWORD="Valid321!"
SHORT_USERNAME="usr2"
LONG_USERNAME="user12345678901234567"
SHORT_PLUS1_USERNAME="usr12"
LONG_REDUCE1_USERNAME="user1234567890123456"
OTHER_USERNAME="validUser456"
XSS_USERNAME="<script>alert('XSS')</script>"
SQL_USERNAME="admin'--"
DIFF_PASSWORD="Abc@123"
SHORT_PASSWORD="abc"
LONG_PASSWORD="iLongpassword12@Longpassword12@"
SIMPLE_PASSWORD="12345"
VALID_PHONE="13812345677"
OTHER_PHONE="13812345688"
INVALID_PHONE="12345"
CONTRACT_PHONE="13681732596"
VALID_EMAIL="valid@example.com"
INVALID_EMAIL="invalid@example"
OTHER_EMAIL="valid1@example.com"
CONTRACT_EMAIL="xianggu625@126.com"
CODE="123456"
ZERO_SIZE_STRING=""

class Test TestRecoverAPI(unittest.TestCase):
def setUp(self):
self.session=requests.Session()
		response=self.session.get(Config.VERICODE_URL)
self.csrf=CSRF.get_csrf(response.text)
self.token={"csrftoken":self.csrf}
self.db=ClassDB()
self.db.init_login(username="",password="")
def tearDown(self):
self.db.init_db()
def _post_request(self,url,data):
try:
		response=requests.post(url,data=data,cookies=self.token)
		response.raise_for_status()
return response
except requests.exceptions.RequestException as e:
self.fail(f"请求失败:{e}，URL:{url}，数据:{data}")
	@parameterized.expand([

                #参数化用例
	])
def test_valid_contact(self,sig,contact,message):
"""验证有效和无效的联系方式"""
		uid=str(self.db.getId(Config.CONTRACT_EMAIL))
		data1={'csrftoken':self.csrf,'contact':contact}
self.token['uid']=uid
		response=self._post_request(Config.VERICODE_URL,data1)
if sig==0:
self.assertEqual(response.status_code,200)
self.assertIn(message,response.text)
else:
self.assertEqual(response.status_code,200)
self.assertIn("找回密码",response.text)
                #处理验证码逻辑
#...

#-*-coding:utf-8-*-
import requests
import unittest
from Util import ClassDB
from Util import CSRF
from Util import HASH
from parameterized import parameterized
from globals import Config
MESSAGES={
"OK":"登录",
"NON_EXISTER_EMAIL_OR_PHONE":"您输入的手机号或Email不存在，请重新输入！",
"INCORRECT_VERIFICATION":"验证码错误，请重新输入！",
"HAVEN_USING_PASSWORD":"这个密码以前设置过，请用一个新密码！",
"PASSWORD_NEED_HASH":"密码需要HASH散列",
}
class TestRecoverAPI(unittest.TestCase):
def setUp(self):
self.session=requests.Session()
		response=self.session.get(Config.VERICODE_URL)
self.csrf=CSRF.get_csrf(response.text)
self.token={"csrftoken":self.csrf}
self.db=ClassDB()
self.db.init_login(username="",password="")
def tearDown(self):
self.db.init_db()
def _post_request(self,url,data):
try:
		response=requests.post(url,data=data,cookies=self.token)
		response.raise_for_status()
return response
except requests.exceptions.RequestException as e:
self.fail(f"请求失败:{e}，URL:{url}，数据:{data}")
	@parameterized.expand([
	(1,Config.CONTRACT_PHONE,MESSAGES["OK"]),
	(1,Config.CONTRACT_EMAIL,MESSAGES["OK"],),
	(0,Config.OTHER_EMAIL,MESSAGES["NON_EXISTER_EMAIL_OR_PHONE"]),
	(0,Config.OTHER_PHONE,MESSAGES["NON_EXISTER_EMAIL_OR_PHONE"]),
	(1,Config.CONTRACT_EMAIL,MESSAGES["INCORRECT_VERIFICATION"]),
	(1,Config.CONTRACT_EMAIL,MESSAGES["HAVEN_USING_PASSWORD"]),
	])
def test_valid_contact(self,sig,contact,message):
"""TC-001-输入有效的注册手机号进行找回密码"""
"""TC-002-输入有效的注册邮箱进行找回密码"""
"""TC-003-输入未注册的邮箱"""
"""TC-004-输入未注册的手机"""
"""TC-005-验证码输入错误"""
"""TC-009-新密码已使用过"""
		uid=str(self.db.getId(Config.CONTRACT_EMAIL))
		data1={'csrftoken':self.csrf,'contact':contact}
self.token['uid']=uid
		response=self._post_request(Config.VERICODE_URL,data1)
if sig==0:
self.assertEqual(response.status_code,200)
self.assertIn(message,response.text)
else:
self.assertEqual(response.status_code,200)
self.assertIn("找回密码",response.text)
if message=="验证码错误，请重新输入！":
			vricode=Config.INVALID_CODE
else:
			vricode=self.db.geveriCode(uid)
if message=="这个密码以前设置过，请用一个新密码！":
			newpassword=Config.VALID_PASSWORD
else:
			newpassword=Config.DIFF_PASSWORD
		data2={
'csrftoken':self.csrf,
'identifyingCode':vricode,
'newPassword':HASH.hash_password(newpassword),
'confirmPassword':HASH.hash_password(newpassword)
		}

                #进入输入新密码页面
self.csrf=CSRF.get_csrf(response.text)
		response=self._post_request(Config.RECOVER_URL,data2)
self.assertEqual(response.status_code,200)
self.assertIn(message,response.text)
	@parameterized.expand([
	(Config.VALID_PASSWORD),
	(Config.ZERO_SIZE_STRING),
	])
def test_recover_password_by_password_format_no_hash256(self,newpassword):
"""TC-010-密码正确使用SHA256散列传输"""
"""TC-011-空字段提交"""

                #进入输入手机或Email页面
		uid=str(self.db.getId(Config.CONTRACT_EMAIL))
		data1={
'csrftoken':self.csrf,
'contact':Config.CONTRACT_EMAIL
	}

                #获取Uid
self.token['uid']=uid
		response=self._post_request(Config.VERICODE_URL,data1)
self.assertEqual(response.status_code,200)
self.assertIn("找回密码",response.text)

                #获取验证码
		vricode=self.db.geveriCode(uid)
		data2={
'csrftoken':self.csrf,
'identifyingCode':vricode,
'newPassword':newpassword,
'confirmPassword':newpassword
	}

                #进入输入新密码页面
self.csrf=CSRF.get_csrf(response.text)
		response=self._post_request(Config.RECOVER_URL,data2)
self.assertEqual(response.status_code,200)
self.assertIn(MESSAGES["PASSWORD_NEED_HASH"],response.text)
if __name__=="__main__":
	unittest.main()

class TestRecover:
	@pytest.fixture(autouse=True)
def setup_and_teardown(self):
self.db=ClassDB()
self.db.init_login(username="",password="")
yield
self.db.init_db()
def _fill_new_password_form(self,page:Page,code:str,password:str,repassword:str):

                #填充新密码表单
		page.get_by_placeholder("输入验证码").fill(code)
		page.get_by_placeholder("输入新密码").fill(password)
		page.get_by_placeholder("确认新密码").fill(repassword)
		page.get_by_role("button",name="确定").click()
	@pytest.mark.parametrize("code,password,repassword,expected_message",[

                #参数化用例
	])
def test_reset_password(self,page:Page,code,password,repassword,expected_message):
try:
		page.goto(Config.RECOVER_URL)
except TimeoutError:
		pytest.fail(f"加载页面失败:{Config.RECOVER_URL}")
		page.reload()
self._fill_new_password_form(page,code,password,repassword)
		error_message=page.inner_text("#confirmPasswordError" if expected_message=="密码确认不一致!" else "#newPasswordError")
assert expected_message in error_message

import pytest
from playwright.sync_APIimport Page
from Util import ClassDB
import time
from globals import Config
class TestRecover:
	@pytest.fixture(autouse=True)
def setup_and_teardown(self):
self.db=ClassDB()
self.db.init_login(username="",password="")
yield
self.db.init_db()
def _fill_new_password_form(self,page:Page,code:str,password:str,repassword:str):

                #填充新密码表单
		page.get_by_placeholder("输入验证码").fill(code)
		page.get_by_placeholder("输入新密码").fill(password)
		page.get_by_placeholder("确认新密码").fill(repassword)
		page.get_by_role("button",name="确定").click()
def _fill_phone_mail_form(self,page:Page,contact:str):
		page.get_by_placeholder("输入手机号码或邮箱").fill(contact)
		page.get_by_role("button",name="发送验证码").click()
	@pytest.mark.parametrize("code,password,repassword,expected_message",[
	(Config.CODE,Config.VALID_PASSWORD,Config.DIFF_PASSWORD,"密码确认不一致!"),#TC-006:新密码和确认密码不一致
	(Config.CODE,Config.SIMPLE_PASSWORD,Config.SIMPLE_PASSWORD,"密码必须包含大小写字母、数字和特殊字符,长度在5-30之间"),#TC-007:新密码不符合复杂度要求
	(Config.CODE,Config.SHORT_PASSWORD,Config.SHORT_PASSWORD,"密码必须包含大小写字母、数字和特殊字符,长度在5-30之间"),#TC-008:新密码长度不符合要求
	])
def test_reset_password(self,page:Page,code,password,repassword,expected_message):
try:
		page.goto(Config.RECOVER_URL)
except TimeoutError:
		pytest.fail(f"加载页面失败:{Config.RECOVER_URL}")
		page.reload()
self._fill_new_password_form(page,code,password,repassword)
		error_message=page.inner_text("#confirmPasswordError" if expected_message=="密码确认不一致!" else "#newPasswordError")
assert expected_message in error_message
	@pytest.mark.parametrize("contact,expected_message",[
		(Config.INVALID_PHONE,"请输入有效的中国手机号或Email"),#TC-012:用户输入的邮箱格式不正确
		(Config.INVALID_EMAIL,"请输入有效的中国手机号或Email"),#TC-013:用户输入的邮箱格式不正确
		])
def test_invalid_phone_format(self,page:Page,contact,expected_message):
try:
		page.goto(Config.VERICODE_URL)
except TimeoutError:
		pytest.fail("加载页面失败:{"+Config.VERICODE_URL+"}")
		page.reload()
self._fill_phone_mail_form(page,contact)

                #检查错误提示
		error_message=page.inner_text("#contactError")
assert expected_message in error_message
if __name__=='__main__':
	pytest.main(["-sv","Test_Recover_GUI.py"])

class ClassDB:
def initDB(self):
		host='localhost'
		user='root'
		password='123456'
		database='ebusiness'
return pymysql.connect(host=host,user=user,password=password,database=database,charset='utf8')
def execute_query(self,query,params=None):
		connection=self.initDB()
try:
with connection.cursor()as cursor:
			cursor.execute(query,params)
			connection.commit()
return cursor.fetchall()
finally:
		connection.close()
def init_db(self):
self.execute_query("DELETE FROM code")
self.execute_query("DELETE FROM password")
self.execute_query("DELETE FROM user")
def init_login(self,username,password):
		username=username or "validUser"
		password=HASH.hash_password(password or "ValidPassword123!")
self.execute_query("INSERT INTO user(username,password,phone,email)VALUES(%s,%s,%s,%s)",
					(username,password,"13681732596","xianggu625@126.com"))

#-*-coding:utf-8-*-
import pymysql
import re
import hashlib
from globals import Config
class ClassDB:
def initDB(self):
		host='localhost'
		user='root'
		password='123456'
		database='ebusiness'
return pymysql.connect(host=host,user=user,password=password,database=database,charset='utf8')
def execute_query(self,query,params=None):
		connection=self.initDB()
try:
with connection.cursor()as cursor:
			cursor.execute(query,params)
			connection.commit()
return cursor.fetchall()
finally:
		connection.close()
def init_db(self):
self.execute_query("DELETE FROM code")
self.execute_query("DELETE FROM password")
self.execute_query("DELETE FROM user")
def init_login(self,username,password):
		username=username or Config.VALID_USERNAME
		password=HASH.hash_password(password or Config.VALID_PASSWORD)
self.execute_query("INSERT INTO user(username,password,phone,email)VALUES(%s,%s,%s,%s)",
					(username,password,"13681732596","xianggu625@126.com"))

        #关闭数据库连接
def closedb(self,connection):
try:
		connection.close()
except MySQLError as e:
print(f"数据库关闭失败:{e}")