接口自动化测试框架设计

接口测试的定义

测试系统间接口的一种测试，测试的对象主要是接口，主要是测试外部系统与所测试系统之间以及内部系统之间的交互点。

接口测试的意义

• 前后端分离，通过测试保证服务端的正确性
• 基于安全考虑，前端验证很容易跳过。
• BUG更容易定位
• 自动化测试落地性价比更高，比UI更稳定
• 测试提前，降低研发成本，提高效率
• 更容易实现持续集成

接口测试的测试用例设计

• 功能
  • 功能是否正常
  • 功能是否按照接口文档实现
• 逻辑业务
  • 是否依赖业务
• 异常处理
  • 参数异常【关键字参数、参数为空、多或少参数、错误参数】
  • 数据异常【关键字数据、数据为空、长度不一致、错误数据】
• 安全
  • Cookie
  • 传输数据是否加密
  • 身份权限验证
  • 密码规则是否符合需求
  • 唯一识别码

接口测试的测试用例设计方法

• 等价类分析
• 边界值分析法
• 决策表
• 场景法
  

postman

主要功能

• 模拟各种http requests
• Collection功能
• 人性化的Response整理
• 内置测试脚本管理
• 设定变量与环境

请求体分类

JSON数据类型

• 数值【整数、浮点数】例：”price”:123.78
• null空值【”“表示空字符串不是空值】 例：”name”:null
• 逻辑值【true\false】 例：”student”:true
• 对象【花括号】例：”address”:{“line”: 123 yuhua road”,“city”:”shijiazhuang”}
• 数组【方括号】例：“employees”: [{ “firstName”:“Bill” , “lastName”:“Gates” }, {“firstName”:“George” , “lastName”:“Bush” }]

postman内置参数

https://learning.postman.com/docs/writing-scripts/script-references/variables-list/

• 时间戳：{{KaTeX parse error: Expected 'EOF', got '}' at position 10: timestamp}̲} {"tag":{"name…timestamp}}"}}
• 随机生成整数0~1000：{{KaTeX parse error: Expected 'EOF', got '}' at position 10: randomInt}̲} {"tag":{"id":…randomInt}}"} }
• 生成随机的GUID的字符串：{{KaTeX parse error: Expected 'EOF', got '}' at position 5: guid}̲} { "tag" : { …guid}}" } }

postman变量

全局变量

全局变量可供所有请求使用
pm.globals.set(“token1”, jsonData.access_token);

环境变量

//提取token的值
var jsonData=JSON.parse(responseBody)
console.log(jsonData.access_token)
pm.environment.set(“token1”, jsonData.access_token);

postman断言

JSON提取器

正则表达式提取器

Cookie提取器

postman加密

常见加密方式三种方式：

• 加密算法（MD5、RSA、DES、AES、SHA）
• 自定义加密算法
• 接口签名
  

接口签名

• 1什么是接口签名？
• 使用用户名，密码，时间戳和所有的排过序之后的参数，拼接组合起来成为一个串，再把该串加密得到的字符串，这就是一个签名。该签名字符串是唯一的有权访问第三方接口的鉴权码。
• 2为什么需要做接口签名？
• 防篡防伪装攻击。
• 改攻击。
• 防重放攻击。
• 防数据泄露 。
• 3生成signature（签名）规则
• 对所有请求参数按key的ASCII码做升序排列
• 把请求参数拼接组合成串
• 把AccessKey和SecretKey码加入上面拼接好的字符串
• 用时间戳连接到字符串的尾部
• 再把这个字符串进行MD5加密，加密后再转化成大写
  
  

接口自动化测试基础

get

• 创建HttpClient对象
• CloseableHttpClient client =HttpClient.createDefault();
• 创建get请求对象
• HttpGet get=new HttpGet(url);
• 执行请求获取响应
• CloseHttpResponse response=client.execute(get)
• 获得响应体
• HttpEntity response_entity=response.getEntity();
• 获取响应体内容
• String response_str=EntityUtils.toString(response_entity,"utf-8");
• 释放资源
• EntityUtils.consume(entity);
• 关闭连接
• response.close();client.close();

post-form

• 创建HttpClient对象
• CloseableHttpClient client =HttpClient.createDefault();
• 创建post请求
• HttpPost post=new HttpPost(url);
• 设置请求头
• post.setHeader(Content-Type","application/x-www-form-url")
• 构建请求体
• List<NameValuePair> user=new ArrayList<>() user.add(new BasicNameValuePair("username","vip") user.add(new BasicNameValuePair("password","secret") ;
  HttpEntity user=new StringEntity(“username=vip&password=secret”)
• 设置请求实体
• post.setEntity(new UrlEncodedFormEntity(user));
  post.setEntity(user)
• 执行请求获取响应
• CloseHttpResponse response=client.execute(post)
• 获得响应体
• HttpEntity response_entity=response.getEntity();
• 获取响应体内容
• String response_str=EntityUtils.toString(response_entity,"utf-8");

post-json

• 使用fastjson构建请求体
• JSONObject user=new JSONObject() user.put(" "," ");
• 设置请求实体
• post.setEntity

接口自动化测试框架基础

实现步骤

1.域名存放在属性文件中
2.常用get，post,方法进行封装，针对不同的参数，实现重载。
doGet(String url)
doGet(String url,Map<String,Object> para)
doGetByCookie(String url,CookieStore cookie)
doPost(String url,String para)
doPostByForm(String url, List data )针对Content-type是Form
doPost(String url,JSONObject para) 针对Content-type是JSON
doPostByCookie(String url,JSONObject para,CookieStore cookie)
3.断言的封装 Checker
4.数据驱动(把1000个商品遍历，做submit的操作；10个用户的登录，下单)
5.数据库的访问（JDBC）
6.监听器的使用
ApiListener extends TestListenerAdapter
重写 onFinish（）方法
7.发送邮件 JAVAMail

使用步骤

1.创建空项目 Qg
2.创建libs，把需要的jar拷贝进来
3.拷贝conf目录
4.拷贝log4j2.xml文件
5.每个接口创建一个测试类
6.对接口的操作封装为方法
7.如果需要数据库的验证，测试类需要继承
BaseTest

整体框架示意

文章来源地址https://www.toymoban.com/news/detail-805283.html

代码实现

com.edu.core

ApiListener.java

package com.edu.core;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.testng.ITestContext;
import org.testng.ITestNGMethod;
import org.testng.ITestResult;
import org.testng.TestListenerAdapter;

import com.edu.utils.Log;
import com.edu.utils.ReadPro;

public class ApiListener extends TestListenerAdapter {

	private String writeResultToMail() {
		ITestNGMethod method[] = this.getAllTestMethods();
		List failedList = this.getFailedTests();
		List passedList = this.getPassedTests();
		List failedList1 = new ArrayList();
		List passedList1 = new ArrayList();
		for (int j = 0; j < failedList.size(); j++) {

			ITestResult tr = (ITestResult) failedList.get(j);
			if (tr.getMethod().getDescription() != null) {
				tr.setAttribute("name", tr.getMethod().getDescription());
			} else {
				tr.setAttribute("name", "");
			}

			failedList1.add(tr);
		}
		for (int j = 0; j < passedList.size(); j++) {
			ITestResult tr = (ITestResult) passedList.get(j);
			if (tr.getMethod().getDescription() != null) {
				tr.setAttribute("name", tr.getMethod().getDescription());
			} else {
				tr.setAttribute("name", "");
			}

			passedList1.add(tr);
		}
		Map context = new HashMap();
		context.put("date", new Date());
		context.put("failedList", failedList.size());
		context.put("passedList", passedList1.size());
		context.put("casesize", passedList.size() + failedList.size());
		context.put("failcasesize", failedList.size());
		try {

			String content = mapToString(context);
			return content;
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

	public static String mapToString(Map<String, Object> para) {

		StringBuilder sBuilder = new StringBuilder();
		int size = para.size();
		for (Entry<String, Object> entry : para.entrySet()) {
			sBuilder.append(entry.getKey() + "=" + entry.getValue() + "\n");

		}

		return sBuilder.toString();

	}

	@Override
	public void onFinish(ITestContext testContext) {

		super.onFinish(testContext);
		System.out.println(getAllTestMethods().length);
		String emailContent = this.writeResultToMail();
		System.out.println(emailContent);

		String emailTitle = ReadPro.getPropValue("mail_title") + "----" + this.getTime();
		String toMail = ReadPro.getPropValue("to_mail");
		try {
//			System.out.println(emailContent);
//			MailUtil.sendEmail(toMail, emailTitle, emailContent);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	public String getTime() {
		java.util.Calendar c = java.util.Calendar.getInstance();
		java.text.SimpleDateFormat f = new java.text.SimpleDateFormat("yyyy-MM-dd  hh:mm:ss");
		return f.format(c.getTime());
	}

//	@Override
//	public void onTestSuccess(ITestResult tr) {
//		Log.info(tr.getInstance() + "-" + tr.getName() + "运行成功");
//	}
//
//	@Override
//	public void onTestFailure(ITestResult tr) {
//
//		Log.error(tr.getInstance() + "-" + tr.getName() + "运行失败");
//	}

}

BaseTest.java

package com.edu.core;

import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.BeforeSuite;

import com.edu.utils.DbHelper;

public class BaseTest {
	public DbHelper db ;
	
	@BeforeClass
	public void setUp()	throws Exception {
		db=DbHelper.getInstance();
		System.out.println("初始化数据库");
		
  }

	@AfterClass
	public void tearDown() throws Exception {
		
		db.close();
	}

}

HttpDriver .java

package com.edu.core;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.classic.methods.HttpPost;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.cookie.CookieStore;
import org.apache.hc.client5.http.cookie.StandardCookieSpec;
import org.apache.hc.client5.http.entity.UrlEncodedFormEntity;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.HttpEntity;
import org.apache.hc.core5.http.NameValuePair;
import org.apache.hc.core5.http.ParseException;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.io.entity.StringEntity;

import com.alibaba.fastjson2.JSONObject;
import com.edu.utils.Common;
import com.edu.utils.ReadPro;



public class HttpDriver {
	static CloseableHttpClient httpClient = null;
	static CloseableHttpResponse respone = null;

	public static String doGet(String url) throws Exception {
		httpClient = HttpClients.createDefault();
		HttpGet get = new HttpGet(ReadPro.getPropValue("base_url") + url);
	
		respone = httpClient.execute(get);
		HttpEntity entity = respone.getEntity();
		String content = EntityUtils.toString(entity, "utf-8");
		EntityUtils.consume(entity);
		respone.close();
		httpClient.close();
		return content;
	}

	public static String doGet(String url, JSONObject data) throws Exception {
		String para = URLEncoder.encode(data.toString(), "UTF-8");
		httpClient = HttpClients.createDefault();
		HttpGet get = new HttpGet(url + "?" + para);
		respone = httpClient.execute(get);
		HttpEntity entity = respone.getEntity();
		String content = EntityUtils.toString(entity, "utf-8");
		EntityUtils.consume(entity);
		respone.close();
		httpClient.close();
		return content;
	}

	
	public static String doGetForEncoder(String url, String para) throws Exception {
		httpClient = HttpClients.createDefault();
		String content=URLEncoder.encode(para,"utf-8");
		HttpGet get = new HttpGet(ReadPro.getPropValue("base_url") + url + content);
		respone = httpClient.execute(get);
		HttpEntity entity = respone.getEntity();
		String result = EntityUtils.toString(entity, "utf-8");
		EntityUtils.consume(entity);
		respone.close();
		httpClient.close();
		return result;
	}



	public static String doGet(String url, Map<String, String> para) throws IOException, ParseException {
		String content = null;
		httpClient = HttpClients.createDefault();
		HttpGet get = new HttpGet(ReadPro.getPropValue("base_url") + url + "?" +Common.mapToString(para));
		respone = httpClient.execute(get);
		HttpEntity entity = respone.getEntity();
		content = EntityUtils.toString(entity, "utf-8");
		EntityUtils.consume(entity);
		respone.close();
		httpClient.close();
		return content;
	}

	public static String doPost(String url, JSONObject para) {
		httpClient = HttpClients.createDefault();
		HttpPost post = new HttpPost(ReadPro.getPropValue("base_url") + url);
		post.addHeader("Content-Type", "application/json");
		HttpEntity data;
		String content = null;
		try {
			data = new StringEntity(para.toString());

			post.setEntity(data);
			respone = httpClient.execute(post);

			HttpEntity entity = respone.getEntity();
			content = EntityUtils.toString(entity, "utf-8");
			EntityUtils.consume(entity);

			respone.close();
			httpClient.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		return content;

	}

	public static String doGet(String url, CookieStore cookie) throws Exception {

		CloseableHttpClient client=HttpClients.custom()
				.setDefaultCookieStore(cookie).build();
		HttpGet get = new HttpGet(ReadPro.getPropValue("base_url") + url);
		CloseableHttpResponse response = client.execute(get);
		HttpEntity result_entity = response.getEntity();
		String result = EntityUtils.toString(result_entity, "utf-8");
		EntityUtils.consume(result_entity);
		response.close();
		client.close();
		return result;
	}




	public static String doPostByForm(String url, List<NameValuePair> data ) throws Exception {
		httpClient = HttpClients.createDefault();
		HttpPost post = new HttpPost(ReadPro.getPropValue("base_url") + url);
		post.addHeader("Content-Type", "application/x-www-form-urlencoded");

		post.setEntity(new UrlEncodedFormEntity(data));
		respone = httpClient.execute(post);

		HttpEntity entity = respone.getEntity();
		String content = EntityUtils.toString(entity, "utf-8");

		respone.close();
		httpClient.close();

		return content;

	}



	
	public static String doPost(String url, JSONObject para, CookieStore cookie) throws Exception {
			httpClient=HttpClients.custom()
								.setDefaultCookieStore(cookie).build();
		HttpPost post = new HttpPost(ReadPro.getPropValue("base_url")+url);
		post.addHeader("Content-Type", "application/json");
		HttpEntity data = new StringEntity(para.toString());
		post.setEntity(data);
		CloseableHttpResponse respone = httpClient.execute(post);
		HttpEntity entity = respone.getEntity();
		String content = EntityUtils.toString(entity, "utf-8");
		EntityUtils.consume(entity);
		respone.close();
		httpClient.close();
		return content;

	}

}

MailUtil.java

package com.edu.core;

import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.Properties;

import java.util.Properties;

import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.NoSuchProviderException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;


public class MailUtil {
	static int port = 25;

    static String server = "smtp.126.com";
    static String from = "李焕贞";
    static String user = "testlihuanzhen@126.com";
    static String password = "123456abcd";//授权码

   
    public static void sendEmail(String email, String subject, String body) throws UnsupportedEncodingException {
        try {
            Properties props = new Properties();
            props.put("mail.smtp.host", server);
            props.put("mail.smtp.port", String.valueOf(port));
            props.put("mail.smtp.auth", "true");
            Transport transport = null;
            Session session = Session.getDefaultInstance(props,null);
            transport = session.getTransport("smtp");
            transport.connect(server, user, password);
            MimeMessage msg = new MimeMessage(session);
            msg.setSentDate(new Date());
            
            InternetAddress fromAddress = new InternetAddress(user,from,"UTF-8");
            msg.setFrom(fromAddress);
            String emailList[]=email.split(",");
            InternetAddress[] toAddress = new InternetAddress[emailList.length];
            
            for(int i=0;i<emailList.length;i++)
            {
            	toAddress[i]=new InternetAddress(emailList[i]);
            }
          
            msg.addRecipients(Message.RecipientType.TO, toAddress);
            msg.setSubject(subject, "UTF-8");   
            msg.setContent(body, "text/html;charset=utf-8");
            msg.saveChanges();
            transport.sendMessage(msg, msg.getAllRecipients());
        } catch (NoSuchProviderException e) {
            e.printStackTrace();
        } catch (MessagingException e) {
            e.printStackTrace();
        }
    }
    public static void main(String args[]) throws UnsupportedEncodingException
    {
    	
    	MailUtil.sendEmail("testlihuanzhen@126.com", "星期二", "测试");
    }


}

com.edu.dataprovider

ExcelDataProvider.java

package com.edu.dataprovider;


import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
/*
 * Excel数据驱动类
 */

public class ExcelDataProvider {



	public Object[][] getTestDataByExcel(String fileName, String sheetName)
			throws IOException {
		File file = new File(fileName);
		FileInputStream inputstream = new FileInputStream(file);
		Workbook wbook = null;
		String fileExtensionName = fileName.substring(fileName.indexOf("."));
	
		if (fileExtensionName.equals(".xlsx")) {
			wbook = new XSSFWorkbook(inputstream);
		
		} else if (fileExtensionName.equals(".xls")) {
			wbook = new HSSFWorkbook(inputstream);
		}
		Sheet sheet = wbook.getSheet(sheetName);
		// 通过sheetName生成Sheet对象
		int rowCount = sheet.getLastRowNum() - sheet.getFirstRowNum();
		// 获取当前sheet行数，行号和列号都是从０开始
		List<Object[]> records = new ArrayList<Object[]>();
		// 使用双循环获取excel文件的所有数据（第一行除外）
		for (int i = 1; i < rowCount + 1; i++) {
			Row row = sheet.getRow(i);
			String fields[] = new String[row.getLastCellNum()];
			for (int j = 0; j < row.getLastCellNum(); j++) {
				// 获取单元格数据
				fields[j] = row.getCell(j).getStringCellValue();
			}
			records.add(fields);
		}
		Object[][] results = new Object[records.size()][];
		for (int i = 0; i < records.size(); i++) {
			results[i] = records.get(i);
		}
		return results;
	}
	

}

MysqlDataProvider.java

package com.edu.dataprovider;

import java.io.IOException;
import java.sql.*;

import java.util.ArrayList;
import java.util.List;

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class MysqlDataProvider {
	

	
	public  Object[][] getTestDataByMysql(String sql) {
		String url = "jdbc:mysql://10.7.90.21:3306/market_db";
		List<Object[]> records = new ArrayList<Object[]>();

		try {
			Class.forName("com.mysql.jdbc.Driver");
			Connection conn = DriverManager
					.getConnection(url, "root", "123456");
			if (!conn.isClosed()) {
				System.out.println("连接数据库成功");
			}
			// Statement里面带有很多方法，比如executeUpdate可以实现插入，更新和删除等
			Statement stmt = conn.createStatement();
			ResultSet rs = stmt.executeQuery(sql);
			//得到数据集的结构
			ResultSetMetaData rsMetaData = rs.getMetaData();
			int cols = rsMetaData.getColumnCount();
			System.out.println(cols);
			while (rs.next()) {
				String fields[] = new String[cols];

				int col=0;
				for (int i = 0; i < cols; i++) {
					fields[col] = rs.getString(i+1);//读取当前行指定的列
					col++;
				}
				records.add(fields);
			
			}
			rs.close();
			conn.close();

		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Object[][] results = new Object[records.size()][];
		for (int i = 0; i < records.size(); i++) {
			results[i] = records.get(i);
		}
		return results;
	}


}

NSDataProvider.java

package com.edu.dataprovider;

import java.io.IOException;

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class NSDataProvider {

	@DataProvider(name="goodId")
	public Object[][] getId() throws IOException{
		return new ExcelDataProvider()
				.getTestDataByExcel("data/mall.xlsx", 
						"Sheet1");
	}
	
	@Test(dataProvider ="goodId" )
	public void test1(String id) {
		System.out.println(id);
	}
	
	@DataProvider(name="zl_shop")
	public  Object[][] getTxtData() throws IOException{
		return new  TxtDataProvider().getTxtUser("data/user.txt");
	}
	@DataProvider(name="user")
	public  Object[][] getMovieData() throws IOException{
		return new  ExcelDataProvider().getTestDataByExcel("data/user.xlsx","Sheet1");
	}
	@Test(dataProvider="txt")
	public void getData(String a,String b) {
		System.out.println(a+" "+b);
		
	}

	@DataProvider(name="excel")
	public Object[][] getExcelDada() throws IOException{
		return new ExcelDataProvider().getTestDataByExcel("data/user.xlsx","Sheet1");
	}
	
	@DataProvider(name="mysql")
	public Object[][] getMysqlDada() throws IOException{
		return new MysqlDataProvider().getTestDataByMysql
				("SELECT pid,name from t_product");
	}
	
	@Test(dataProvider="mysql")
	public void testDB(String a,String b) {
		System.out.println(a+" "+b);
	}
	
}

TxtDataProvider.java

package com.edu.dataprovider;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class TxtDataProvider {
	
	
	public Object[][] getTxtUser(String fileName) throws IOException {
		
		List<String> dataList = new ArrayList<String>();
	
		File file = new File(fileName);
		FileInputStream fis = new FileInputStream(file);
		InputStreamReader isr= new InputStreamReader(fis);
		BufferedReader reader = new BufferedReader(isr);
		int cols=reader.readLine().split("\t").length;
		
		String readData;
		while((readData=reader.readLine())!=null) {
			dataList.add(readData);
		}
		
		Object [][] result = new Object[dataList.size()][cols];
		String [] arrays;
		for(int i=0;i<dataList.size();i++) {
			arrays=dataList.get(i).split("\t");
			for(int j=0;j<cols;j++)
				result[i][j]=arrays[j];
		}
		return result;
		
	}


	

}

com.edu.utils

Checker.java

package com.edu.utils;

import static org.testng.Assert.assertEquals;

import java.util.List;

import com.alibaba.fastjson2.JSONObject;




public class Checker {
	
	String exceptionMessage = "";

	String message = "";

	String actualValue = "";

	String expectValue = "";
	JSONObject json = null;

	public Checker(String result) {
		this.json = JSONObject.parseObject(result);
	}

	public void assertArray(String patten,String key,String content){
		actualValue=this.json.getJSONArray(patten).getJSONObject(0).getString(key);
	assertEquals(actualValue, content);
	}

	public void verifyTextPresent(String patten) throws Exception {

		boolean value = json.containsKey(patten);

		if (value) {
			Log.info("the Text: '" + patten + "' is Present!");
		} else {
			Log.fatal("the Text: '" + patten + "' is not Present!");
			throw new Exception("the Text: '" + patten + "' is not Present!");
		}
	}

	public void verifyXpath(String locator, String patten) throws Exception {

		actualValue = this.json.getString(locator);
		verify(patten, actualValue);
	}


	

	public void verify(String pattern, String actualValue) throws Exception {
		this.actualValue = actualValue;
		this.setExceptionMessage(actualValue, pattern);
		this.setMessage(pattern, actualValue);
		String errormsg = getExceptionMessage();
		String msg = getMessage();
		if (ResultVerifier.verifyStringsByEqualAndExist(pattern, actualValue)) {
			Log.info(msg);
		} else {
			Log.fatal(errormsg);
			Log.info(json.toString());
			throw new Exception(errormsg);
		}
	}
	
	public void assertXpath(String locator, String object) throws Exception {
		// TODO Auto-generated method stub
		actualValue = this.json.getString(locator);
		assertEquals(actualValue,object);
	}
	
	public void setExceptionMessage(String actualValue, String expectValue) {
		this.exceptionMessage = "expectedValue doesn't match actualValue,actual Value is :" + actualValue
				+ "; expected Value is :" + expectValue;
	}

	public void setMessage(String expectValue, String actualValue) {
		this.message = "expectedValue :" + expectValue + "  match actualValue:" + actualValue;
	}

	public String getExceptionMessage() {
		return exceptionMessage;
	}

	public String getMessage() {
		return message;
	}
}

Common.java

package com.edu.utils;

import java.io.IOException;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.hc.client5.http.classic.methods.HttpPost;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.cookie.BasicCookieStore;
import org.apache.hc.client5.http.cookie.CookieStore;
import org.apache.hc.client5.http.cookie.StandardCookieSpec;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.HttpEntity;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.io.entity.StringEntity;

import com.alibaba.fastjson2.JSONObject;



public class Common {
	// 把map类型转换为String,并用&加以拼接
	public static String mapToString(Map<String, String> para) {

		StringBuilder sBuilder = new StringBuilder();
		String content = null;
		int size = para.size();
		for (Entry<String, String> entry : para.entrySet()) {
			sBuilder.append(entry.getKey() + "=" + entry.getValue());
			size--;
			if (size >= 1) {
				sBuilder.append("&");
			}

		}
		return sBuilder.toString();
	}
	
	
	public static CookieStore getCookie(String u_name,String password) throws Exception, IOException {
		JSONObject user=new JSONObject();
		user.put("phoneArea", "86");
		user.put("phoneNumber", u_name);
		user.put("password", password);
		
		
		CookieStore cookie = new BasicCookieStore();

		CloseableHttpClient client = HttpClients.
				custom().
				setDefaultCookieStore(cookie)
				.build();
		
		String loginurl=ReadPro.getPropValue("base_url")+"/common/fgadmin/login";
		HttpPost post =new HttpPost(loginurl);
		//设置请求体
		HttpEntity userEntity=new StringEntity(user.toString());
		post.setHeader("Content-Type","application/json");
		post.setEntity(userEntity);
		CloseableHttpResponse response=client.execute(post);
		HttpEntity responseEntity=response.getEntity();
		String result=EntityUtils.toString(responseEntity,"UTF-8");
		System.out.println(result);
		EntityUtils.consume(responseEntity);
		response.close();
		client.close();
	
		return cookie;
		
		
	}

}

DbHelper.java

package com.edu.utils;


import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
//import java.sql.DriverManager;
//import java.sql.PreparedStatement;
//import java.sql.ResultSet;
//import java.sql.SQLException;
//import java.sql.Statement;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;


public class DbHelper {
	static Logger log = LogManager.getLogger(DbHelper.class.getName());
	
	public java.sql.Connection conn = null; //connection object
	public ResultSet rs = null; //resultset object
	public Statement stmt = null; //statement object
	public PreparedStatement pstmt = null; //preparedstatement object
	private String drivers = null; //connection parameter:drivers
	private String url = null; //connection parameter:url
	private String user = null; //connection parameter:user
	private String password = null; //connection parameter:password
	private String configFile;

	public DbHelper() {

	}

	public DbHelper(String configFile) {
		this.configFile = configFile;
		init();
	}

	public static DbHelper getInstance() {
		DbHelper instance = new DbHelper("conf/conf.properties");
		instance.init();
		return instance;
	}

	private void init() {
		drivers = ReadPro.getPropValue("persistence.datasource.driverClassName");
		url = ReadPro.getPropValue("persistence.datasource.url");
		user = ReadPro.getPropValue("persistence.datasource.username");
		password = ReadPro.getPropValue("persistence.datasource.password");
		try {
			log.info(drivers+"---"+url);
			Class.forName(drivers);
			conn = DriverManager.getConnection(url, user, password);
			stmt = conn.createStatement();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public List query(String sql) throws Exception{
		List list = null;
		rs = stmt.executeQuery(sql);
		if (null != rs) {
			list = ResultSetHandler.toMapList(rs);
		}
		return list;
	}
	
	public boolean execute(String sql) throws Exception{
		boolean flag=false;
		flag = stmt.execute(sql);
		return flag;
	}

	public Map queryToMap(String sql) throws Exception{
		Map map = null;
		rs = stmt.executeQuery(sql);
		if (null != rs) {
			map = ResultSetHandler.toMap(rs);
		}
		return map;
	}

	public List queryToList(String sql) throws Exception {
		List list = null;
		rs = stmt.executeQuery(sql);
		if (null != rs) {
			list = ResultSetHandler.toStringArrayList(rs);
		}
		return list;
	}

	public String queryToString(String sql) { 
		String str = null;
		try {
			rs = stmt.executeQuery(sql);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if (null != rs) {
			try {
				str = ResultSetHandler.toString(rs);
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return str;
	}

	public void close() {
		if (null != rs) {
			try {
				rs.close();
			} catch (SQLException ex) {
				rs = null;
			}
		}
		if (null != stmt) {
			try {
				stmt.close();
			} catch (SQLException ex) {
				stmt = null;
			}
		}
		if (null != pstmt) {
			try {
				pstmt.close();
			} catch (SQLException ex) {
				pstmt = null;
			}
		}
		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				conn = null;
			}

		}
	}

	public static void main(String args[]) {
		DbHelper db = DbHelper.getInstance();
		try {
			List list = db.query("select * from malluser");
			for (int i = 0; i < list.size(); i++) {
				HashMap map = (HashMap) list.get(i);
				System.out.println(map.toString());
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

Log.java

package com.edu.utils;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Log {
	static Logger logger = LogManager.getLogger(Log.class);


	public static void fatal(String msg) {
		logger.fatal(msg);
	}

	public static void error(String msg) {
		logger.error(msg);
	}

	public static void warn(String msg) {
		logger.warn(msg);
	}

	public static void info(String msg) {
		logger.info(msg);
	}

	public static void debug(String msg) {
		logger.debug(msg);
	}
}

ReadPro.java

package com.edu.utils;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;


public class ReadPro {

	public static final String filePath="conf/conf.properties";
	

	public static String getPropValue(String key) {
		Properties prop = new Properties();
		FileInputStream fis;
		try {
			fis = new FileInputStream(filePath);
			prop.load(fis);
			fis.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		return prop.getProperty(key);
		
	}
}

ResultSetHandler.java

package com.edu.utils;

import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;





public class ResultSetHandler {
	
	static Logger log = LogManager.getLogger(ResultSetHandler.class.getName());
    public static List<Map<String, String>> toMapList(ResultSet rs)
    {
        List<Map<String, String>> lst = new ArrayList<Map<String, String>>();
        ResultSetMetaData md;
        try
        {
            md = rs.getMetaData();
            String[] fieldNames = new String[md.getColumnCount()];
            for(int i=1;i<=fieldNames.length;i++)
            {
                fieldNames[i-1] = md.getColumnLabel(i).toLowerCase();
            }
            while(rs.next())
            {
                Map<String, String> map = new HashMap<String, String>();
                for (int i = 1; i <= fieldNames.length; i++) 
                {
                	if(8==md.getColumnType(i))
                	{
                		map.put(fieldNames[i-1],String.valueOf(rs.getDouble(i)));
                	}else
                	{
                		map.put(fieldNames[i-1],rs.getString(i));
                	}
                    
                }
                lst.add(map);
            }
        }
        catch (Exception e)
        {
            log.error(e.getMessage(),e);
            //throw(new BaseException(Errors.ERRORS_COMMON,new String[]{Errors.DBOPERATION_FORMATRESULT},e.getMessage(),e));
        }
        return lst;
    }
    
    //private static Logger log = Logger.getLogger(ResultSetHandler.class);

    public static Map<String, String> toMap(ResultSet rs)
    {
    	Map<String, String> map = new HashMap<String, String>();
        ResultSetMetaData md;
        try
        {
            md = rs.getMetaData();
            String[] fieldNames = new String[md.getColumnCount()];
            for(int i=1;i<=fieldNames.length;i++)
            {
                fieldNames[i-1] = md.getColumnLabel(i).toLowerCase();
            }
            if(rs.next())
            {
                for (int i = 1; i <= fieldNames.length; i++) 
                {
                	if(8==md.getColumnType(i))
                	{
                		map.put(fieldNames[i-1],String.valueOf(rs.getDouble(i)));
                	}else
                	{
                		map.put(fieldNames[i-1],rs.getString(i));
                	}
                }
            }
        }
        catch (Exception e)
        {
            log.error(e.getMessage(),e);
            //throw(new BaseException(Errors.ERRORS_COMMON,new String[]{Errors.DBOPERATION_FORMATRESULT},e.getMessage(),e));
        }
        return map;
    }
 
    public static List toStringArrayList(ResultSet rs) throws Exception
    {
        List<String[]> lst = new ArrayList<String[]>();
        ResultSetMetaData md = rs.getMetaData();
        int fieldCount = md.getColumnCount();
        while(rs.next())
        {
            String[] arr = new String[fieldCount];
            for (int i = 1; i <= fieldCount; i++) 
            {
                arr[i-1] = rs.getString(i);
            }
            lst.add(arr);
        }
        return lst;
    }
    
  
    public static String toString(ResultSet rs) throws Exception
    {
    	String str = "";
        ResultSetMetaData md = rs.getMetaData();
        int fieldCount = md.getColumnCount();
        if(rs.next()&&fieldCount>=1)
        {           
        	if(8==md.getColumnType(1))
        	{
        		str = String.valueOf(rs.getDouble(1));
        	}else
        	{
        		str = rs.getString(1);
        	}
        	
        }
        return str;
    }
  
    public static List<Object[]> toObjectArrayList(ResultSet rs)
    {
        List<Object[]> lst = new ArrayList<Object[]>();
        ResultSetMetaData md;
        try
        {
            md = rs.getMetaData();
            int fieldCount = md.getColumnCount();
            while(rs.next())
            {
                Object[] arr = new Object[fieldCount];
                for (int i = 1; i <= fieldCount; i++) 
                {
                    arr[i-1] = rs.getObject(i);
                }
                lst.add(arr);
            }        }
        catch (SQLException e)
        {
            //log.error(e.getMessage(),e);
            //throw(new BaseException(Errors.ERRORS_COMMON,new String[]{Errors.DBOPERATION_FORMATRESULT},e.getMessage(),e));
        }
        return lst;
    }
    
    public List<String> getFieldList(ResultSet rs) 
    {
        ResultSetMetaData md;
        List<String> list = null;
        try
        {
            md = rs.getMetaData();
            list = new ArrayList<String>();
            for(int i=1;i<=md.getColumnCount();i++)
            {
                list.add(md.getColumnLabel(i).toLowerCase());
            }
        }
        catch (SQLException e)
        {
            log.error(e.getMessage(),e);
           
        }
        
        return list;
    }
}

ResultVerifier.java

package com.edu.utils;



public class ResultVerifier {


    public static boolean verifyStringsByEqual(final String expectedValue, final String actualValue) {
		return expectedValue != null && expectedValue.equals(actualValue);
	}
    
    public static boolean verifyStringsByEqualAndExist(final String expectedValue, final String actualValue) {
		boolean flag=false;
    	if(expectedValue != null && expectedValue.equals(actualValue))
		{
    		flag=true;
    		return flag;
		}
    	if(expectedValue != null && actualValue.contains(expectedValue))
    	{
    		flag=true;
    		return flag;
    	}
    	return flag;
	}
    public static void main(String args[])
    {
    	System.out.print(ResultVerifier.verifyStringsByEqualAndExist("hello", "hello world"));

    }
}

com.edu.test

LoginTest.java

package com.edu.test;


import org.testng.annotations.Test;

import com.alibaba.fastjson2.JSONObject;
import com.edu.core.ApiListener;
import com.edu.core.HttpDriver;
import com.edu.dataprovider.NSDataProvider;
import com.edu.utils.Checker;




public class LoginTest {
	String login_url = "/common/fgadmin/login";
	Checker check = null;

	public void login(Object phoneArea, Object phoneNumber, Object password) {
		JSONObject user = new JSONObject();
		user.put("phoneArea", phoneArea);
		user.put("phoneNumber", phoneNumber);
		user.put("password", password);
		String result = HttpDriver.doPost(login_url, user);
		System.out.println(result);
		check = new Checker(result);
	}

	
	@Test
	public void testLoginSuccess() throws Exception {
		login("86", "2000", "123456");
		check.verifyTextPresent("message");
		check.verifyXpath("code", "200");
	}

	

}

src-log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn">
	<Appenders>
	
		<Console name="Console" target="SYSTEM_ERR">
			<PatternLayout pattern="[%-5p] %d %c - %m%n" />
		</Console>
		<File name="File" fileName="dist/my.log">
			<PatternLayout pattern="[%-5p] %d %c - %m%n" />
		</File>
	</Appenders>
	<Loggers>
		<Root level="WARN">
			<AppenderRef ref="File" />
			<AppenderRef ref="Console" />
		</Root>
	</Loggers>
</Configuration>

到了这里，关于接口自动化测试框架设计的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！