怎么区分前/后端bug？
举个栗子，按以下步骤操作：


打开浏览器，输入url：https://www.jianshu.com/sessionst，打开了简书的登录页


不输入账号密码直接点击登录。


系统提示“手机号码/邮箱地址或密码不能为空”。

请思考一下这里的提示信息是前端返回给我们的还是后台返回给我们的？

答案：前端。因为啥也没输入，根本没有必要发给后端来做校验，直接在前端就可以给校验不通过了。


账号输入13333333333，密码输入123456。点登陆，弹出提示信息如下图.

思考一下这个地方的信息是前端还是后端返回给我们的？


答案：后端。因为前端也不知道咱数据库里有啥账号啊。
所以总结起来，B/S架构的登录功能数据交互过程是这样滴：

① 数据进来之后，先在前端进行数据合法性校验。

② 只有前端数据合法性校验通过后，才会将数据发送到服务器进行处理（后端服务）。

③ 前端合法性校验通过后，还会在后端进行一次数据合法性校验。以防不法分子绕过前端（比如使用发包工具）直接访问后台。

④ 如果后端数据合法性校验通过，才会查询数据库：

如果账号不存在，返回给前端“手机号/邮箱/密码不正确巴拉巴拉”
如果账号存在，则开始进行密码匹配，如果密码不匹配，也会返回一个“手机号/邮箱/密码不正确巴拉巴拉”
如果密码匹配，则返回登录成功。

⑤然后信息从后台返回到前端，前端收到信息后进行数据展示。如果是登录成功，则跳转到首页。

所以判断一个bug属于前端问题还是后端问题，按上面的思路走一圈就差不多可以分析出来了。

软件测试工程师一只，也在不断的学习阶段，平时的小经验不定期分享。
博主经验有限，若有不足，欢迎交流，共同改进~
有意可加Q群 908417285 交流学习。
乾坤未定，你我皆是黑马

接口自动化的思路步骤，所有的测试方法需要完成的事情
1、参数化替换
2、数据库前置查询结果(数据库断言 必须在接口执行前后都查询)
3、调用接口
4、断言响应结果
5、添加接口响应回写内容
6、数据库后置查询结果
7、数据库断言
8、添加断言回写内容
9、添加日志
10、报表断言
测试类都按照以上10个步骤完成所有的调用，接口自动化主要介绍三个接口，注册、登录、需要登录后才可以操作的get请求
BaseCase主要封装三个接口都会用的公共部分，三个接口的测试用例类都继承该类
@step @Description 是报表插件Allure里的使用方法，用于描述方法，使报告更清晰
1、因为每个接口的每个用例都需要执行三遍，所以在父类里就封装好根据语言执行三遍，再在具体的测试类中去重写具体执行接口的方法
2、第三个步骤的调用接口方法call，用于读取接口地址、请求方式、请求类型、请求参数、接收响应数据
2、addWBD方法，添加回写对象到集合中
把行号、列号、响应内容获取后存到list集合里
3、assertResponse方法，响应内容断言
作为一个公共方法是为了方便断言时，可以加减断言的方式，这里只判断了两种，多字段并值匹配和单字段等值匹配
多字段断言时，需要在用例表格中添加一行，设计期望表达式的格式数组类型，然后采用jsonpath解析
4、replace方法，参数替换
该方法主要是在用例中使用参数化，所有的代码都是直接从用例中去读取，如果直接读取的话， 取出来的数据是变量，无法解析，这里需要另外写一个方法用于新的参数代替直接读取到的参数， 这里封装了两个方法
一个是通过读取配置的方式替换，这种方式还需要读取文件，关流，这种方式需要在项目初始化的时候去读取配置文件，一个是通过正则的方式替换，本项目采用了第二种方式
env是一个map集合，用于存储从用例表中读取到的参数集合
5、init方法 初始化
初始化方法用于读取在配置 文件中存放的参数，使用读取配置的方式就要初始化，否则不用
6、finish方法，接口执行完毕后，把执行结果写到用例表中

1.待测试的接口说明
1、自己写的一个登录功能，通过加密算法获得私钥，token还有cookie，通过Postman访问该接口
接口的地址：http://localhost:8080/login
请求的方式：post
请求的结果：


2、测试目标

登录成功后，返回是否返回预期的状态和token
2.新建Java web项目
1、工程结构说明

2、User.java源码
package com.test.entities;

/**
 * 用户实例，每个字段对应数据库user表的每个字段
 */
public class User {
	private String username;
	private String password;

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	@Override
	public String toString() {
		return "User [username=" + username + ", password=" + password + "]";
	}
}


3、JdbcUtils.java源码
package com.test.utils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
 * 数据库连接常用类
 *
 */
public class JdbcUtils {
	/**
	 * 进行数据库连接，并返回连接对象
	 * @return 数据库连接对象
	 * @throws Exception
	 */
	public static Connection getConnection() throws Exception {
		String url = "jdbc:mysql:///数据库名?characterEncoding=utf8&useSSL=false";
		String username = "用户名";
		String password = "密码";
		String driver = "com.mysql.jdbc.Driver";
		Class.forName(driver); // 将数据库连接驱动driver加载到内存中
		return DriverManager.getConnection(url, username, password); // 返回连接对象 
	}
	/**
	 * 关闭数据库连接的静态方法
	 * @param conn 需要关闭的连接对象
	 * @param stmt 需要关闭的语句对象 
	 * @param rs 需要关闭的查询结果对象
	 */
	public static void close(Connection conn, Statement stmt, ResultSet rs) {
		if(rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		if(stmt != null) {
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		if(conn!=null) {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
}


4、UserDao.java源码
package com.test.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import com.test.entities.User;
import com.test.utils.JdbcUtils;
public class UserDao {
	/**
	 * 根据给定的sql和参数进行数据库查询，并将结果转成对象返回
	 * @param sql 需要执行的select语句
	 * @param args select查询语句中占位符所需的参数
	 * @return select查询后返回的对象集合
	 */
	public List<User> getUsers(String sql, Object...args){
		List<User> users = new ArrayList<>();
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			conn = JdbcUtils.getConnection(); // 获取数据库连接
			ps = conn.prepareStatement(sql); // 创建带有占位符的语句对象
			for(int i = 0; i < args.length; i++) {
				ps.setObject(i+1, args[i]); // 对占位符进行实际赋值
			}
			rs = ps.executeQuery(); // 执行sql语句，并获取返回
			while(rs.next()) { // 根据返回进行记录的逐条遍历
				User _user = new User();
				_user.setUsername(rs.getString("username"));
				_user.setPassword(rs.getString("password"));
				
				users.add(_user); // 每一条记录代表一个user对象，添加到集合中
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JdbcUtils.close(conn, ps, rs); // 关闭数据库连接 
		}
		return users;
	}
}


5、Authorization .java源码
package com.test.entities;
/**
 * 返回给成功登录的授权用户当前的token
 *
 */
public class Authorization {
	/**
	 * 状态信息
	 */
	private String status;
	/**
	 * token信息
	 */
	private String token;
	public String getStatus() {
		return status;
	}
	public void setStatus(String status) {
		this.status = status;
	}
	public String getToken() {
		return token;
	}
	public void setToken(String token) {
		this.token = token;
	}
	@Override
	public String toString() {
		return "Authorization [status=" + status + ", token=" + token + "]";
	}
}

6、SearchError .java源码
package com.test.entities;
/**
 * 用于返回用户各类访问错误的实例
 *
 */
public class SearchError {
	/**
	 * 错误编号
	 */
	private int errorCode;
	/**
	 * 错误信息
	 */
	private String message;
	public int getErrorCode() {
		return errorCode;
	}
	public void setErrorCode(int errorCode) {
		this.errorCode = errorCode;
	}
	public String getMessage() {
		return message;
	}
	public void setMessage(String message) {
		this.message = message;
	}
	@Override
	public String toString() {
		return "SearchError [errorCode=" + errorCode + ", message=" + message + "]";
	}
}

7、UserService .java源码
package com.test.services;

import java.util.ArrayList;
import java.util.List;
import com.test.dao.UserDao;
import com.test.entities.User;

public class UserService {

	/**
	 * 用于对输入指定筛选条件信息数据库查询的方法
	 * @param userName 用户名
	 * @param password 密码
	 * @return 所有符合条件的user对象集合
	 */
	public List<User> getUsers(String userName, String password){
		List<User> users = null;
		String sql = "select * from tb_User where "; // 不完整的sql语句，最后的where用于和之后的筛选条件拼接
		List<Object> listArgs = new ArrayList<>(); // 用于输入到sql中的占位参数，对应sql中“？”占位符
		if(userName!=null && !userName.equals("")) { // 如果username不为空
			
			sql = sql + "username=? and ";  // sql语句中拼接username的筛选条件
			listArgs.add(userName); // 将username的值加入到参数中
		}
		if(password!=null && !password.equals("")) { // 如果password不为空
			sql = sql + "password =? and"; // 拼接password的筛选条件
			listArgs.add(password); // 将查询条件加入参数集合中
		}
		 // 最后拼接1=1恒true表达式，用于结尾，否则sql最后留下一个and关键字，语法错误
		sql=sql+"and 1=1";
		UserDao userDao = new UserDao();
		users = userDao.getUsers(sql, listArgs.toArray()); // 将组织好的sql，和传递的参数交给DAO进行数据库实际访问
		return users;
	}
}

8、BearerToken .java源码
package com.test.utils;

import java.util.Date;
import javax.crypto.SecretKey;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
/**
 * 用于生成token
 *
 */
public class BearerToken {
	/**
	 * 生成token的静态方法 
	 * @param key 加密私钥
	 * @param username 授权用户的用户名
	 * @param expir token过期时间
	 * @return token字符串
	 */
	public static String createToken(SecretKey key, String username, Date expir) {
		SignatureAlgorithm sa = SignatureAlgorithm.HS256; // 设置签名算法
		JwtBuilder builder = Jwts.builder()
				.setAudience(username) // 授权用户
				.setExpiration(expir) // 过期时间
				.signWith(sa, key); // 签名算法和私钥 
		return builder.compact();
	}
}


9、CreateKey .java源码
package com.test.utils;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
/**
 * 用于生成私钥
 *
 */
public class CreateKey {
	/**
	 * 生成私钥的静态方法
	 * @return
	 */
	public static SecretKey genKey() {
		String seed = System.currentTimeMillis()+""; // 私钥的生成是根据当前系统时间的毫秒表达式
		return new SecretKeySpec(seed.getBytes(), "AES"); //通过AES算法将字节数组加密为私钥 
	}
}


10、Login.java源码-实现用户登录授权的接口
package com.test.jk;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import java.util.List;

import javax.crypto.SecretKey;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.test.entities.Authorization;
import com.test.entities.SearchError;
import com.test.entities.User;
import com.test.services.UserService;
import com.test.utils.BearerToken;
import com.test.utils.CreateKey;

/**
 * Servlet implementation class Login
 * 实现用户登录授权的接口，要求用户通过post请求传递user和pwd两个参数，分别代表用户的注册用户名和密码。
 * 如果用户名和密码校验成功，则会生成一小时有效的token，并将token返回给用户，同时在用户端生成cookie，用于记录过期时间。
 */
public class Login extends HttpServlet {
	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		String username = request.getParameter("user");
		String password = request.getParameter("pwd");
		Gson gson = new GsonBuilder().create();
		String json = null;
		if (username != null && password != null) { // 如果用户名和密码不为空
			List<User> user=new UserService().getUsers(username, password);//使用数据库数据来校验用户名和密码
			if (user.size()>0) {
				SecretKey key = null;
				Object obj = getServletContext().getAttribute("secretKey");
				if(obj==null){//如果没有secretKey属性，则说明之前未生成过服务器端加密用的私钥
					key=CreateKey.genKey();//获得一个新的私钥
					getServletContext().setAttribute("secretKey", key);
				}else{
					key=(SecretKey)obj;
				}
				Date expir=new Date(System.currentTimeMillis()+3600000);//设置token的过期时间为一个小时
				Authorization auth=new Authorization();
				auth.setStatus("authoried");//将返回对象的status属性设为已授权
				auth.setToken(BearerToken.createToken(key, username, expir));//调用createToken方法对用户名和过期时间进行签名生成token
				json=gson.toJson(auth);//将auth对象转成json格式
				Cookie cookie=new Cookie("expir", expir.getTime()+"");//设置客户端需要保存的cookie，名字是expir，值时过期时间的毫秒表达式
				cookie.setMaxAge(3600);//设置cookie过期的时间是1小时
				response.addCookie(cookie);//将cookie发送到客户端
			} else {//如果用户名和密码不正确，设置错误返回对象
				SearchError error = new SearchError();
				error.setErrorCode(101);
				error.setMessage("错误的用户名或密码");
				json = gson.toJson(error);
			}
		} else {//当未提交用户名或者密码，则设置错误返回对象
			SearchError error = new SearchError();
			error.setErrorCode(102);
			error.setMessage("未提供用户名和密码进行身份验证");
			json = gson.toJson(error);
		}
		response.setCharacterEncoding("utf-8");
		response.setContentType("application/json");
		PrintWriter out = response.getWriter();
		out.print(json);
		out.flush();
	}

}


4、使用PostMan访问地址接口##
1、启动eclipse的tomcat服务

2、在PostMan新建一个Request，输入地址，选择请求方法

3、在body里面输入用户名和密码（数据库已注册的用户名密码）

4、点击send按钮

一、Cookie与token机制测试
Cookie与Session
token机制
cookie/session机制需要在服务端保存大量的session信息，造成严重负担，而token机制则避免记录大量信息，采用服务器签发的token完成验证。
1、客户端使用用户名跟密码请求登录
2、服务端收到请求，去验证用户名与密码
3、验证成功后，服务端会签发一个 Token，再把这个 Token 发送给客户端
4、客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里或者 Local Storage 里
5、客户端每次向服务端请求资源的时候需要带着服务端签发的 Token
6、服务端收到请求，然后去验证客户端请求里面带着的 Token，如果验证成功，就向客户端返回请求的数据
相当于酒店在你入住之后，给你一段暗号，之后再来酒店，报暗号就可以入住了。
Cookie与token测试
加载与清空cookieStore
Httpclient提供了cookieStore类用于加载和读取cookies。
通过private CookieStore cookies = new BasicCookieStore();创建cookieStore
在构建httpclient时通过.setDefaultCookieStore(cookies)方法加载。
也可以通过添加头域Cookie的方式来添加Cookie。
通过一个布尔类型的标识参数来决定是否需要加载cookies。
添加token到请求头域
token通常在头域中被添加，当需要添加头域参数时，通过布尔类型的标识参数来决定是否设置新的头域。
通过setHeader方法完成头域的添加。
二、头域添加与参数传递
头域操作
为了方便头域信息键值对的传递和反复使用，并且方便方法封装时调用。使用map来保存头域信息的键值对，并通过循环遍历将头域headermap中的内容添加到http请求中使用。
参数传递
Httpclient方法封装
为了便于头域的管理和方法反复调用，将存储头域的map作为关键字类的成员变量，通过布尔变量来控制方法是否需要添加头域。
并设计方法实现该成员变量map赋值和清空。
同理，cookiestore也通过类似机制来管理是否需要使用cookie。
三、关键字需求封装
完成httpclientkw类的封装之后，发包流程的操作已经封装完成，基本操作已实现，接下来封装测试过程中的需求，以完成测试操作。
关键字需求封装
断言实现
将每次发包方法调用返回结果赋值给成员变量response，针对response进行断言操作。
头域参数json格式转换
为便于头域参数的管理，将头域参数写为json格式，通过json转换为map，再传递给HttpclientKw的addheader方法操作。