二十五、java发送请求-接口数据依赖解决方案

场景：
A接口的输出是B接口的输入
核心：
AB依赖接口的执行顺序
策略：
1、Excel接口测试案例增加两列Is_Dep、Dep_key
Is_Dep 判断此接口是否被依赖 ，YES代表被依赖，反之代表不被依赖
Dep_key 此接口服务器返回值中的某个key，格式是：接口名:JSONPath表达式
2、Excel接口测试案例依赖接口的Req_data列修改
B key=被依赖A接口名:JSONPath表达式
3、TestRun.java代码
step1：isDep = YES 时需解析depKey；解析后将depKey整体当做key，JSONPath表达式从服务器返回值中得到的值整体当做value，最后key，value存储到全局static Map。
step2：reqData 需判断是否有被依赖的接口名:JSONPath表达式，有则需从全局static Map取值并做替换；反之可忽略。

public class StringUtil {
	private StringUtil() {}
	public static String replaceStr(String sourceStr,String matchStr,String replacevalue) {
		
		//左侧字符串
		int index = sourceStr.indexOf(matchStr);//11
		String leftStr = sourceStr.substring(0, index);
		//右侧字符串
		int matchStrLen = matchStr.length();
		String rightStr = sourceStr.substring(index+matchStrLen);
		//左侧字符串+replacevalue+右侧字符串
		return leftStr + replacevalue + rightStr;
	}
}

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.testng.Assert;
import com.alibaba.fastjson.JSONPath;

public class PatternUtil {
	
	private static Map map = new HashMap();
	private static String DepKeyValueRegex = "([\w/]+):([\$\.\w]+)";
	private static String reqDataRegex = "([\w/]+):([\$\.\w]+)";
	private static String compareResultRegex = "(\$[\.\w]+)=([\u4e00-\u9fa5\w]+)";
	
	private PatternUtil() {}
	public static void compareResult(String expResult,String actResult) {
		//建立正则表达式
		Pattern p = Pattern.compile(compareResultRegex);
		//匹配结果
		Matcher m = p.matcher(expResult);
		while(m.find()) {
			//excel内的预期值
			String jsonPath = m.group(1);
			String expValue = m.group(2);
			//服务器返回的实际值
			String actValue = JSONPath.read(actResult, jsonPath).toString();
			
			Assert.assertEquals(actValue, expValue);
		}
	}
	
	public static void storeDepKeyValue(String depKey,String actResult) {
		
		Pattern p = Pattern.compile(DepKeyValueRegex);
		Matcher m = p.matcher(depKey);
		while(m.find()) {
			String key = m.group();
			String value = JSONPath.read(actResult, m.group(2)).toString();
			map.put(key, value);
		}	
	}
	
	public static String handlerReqDataOfDep(String reqData) {
		
		Pattern p = Pattern.compile(reqDataRegex);
		Matcher m = p.matcher(reqData);
		while(m.find()) {
			//2-1、需要得到map中的key
			String key = m.group();       
			//2-2、基于key从map中取值
			String value = map.get(key);  
			
			reqData = StringUtil.replaceStr(reqData, key, value);
		}			
		return reqData;
	}
}

import org.testng.Reporter;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;
import 包名.ExcelUtil;
import 包名.HttpRequestUtil;
import 包名.PatternUtil;

public class TestRun {
	private String filePath = null;

	@Parameters({ "filePathParam" })
	@BeforeTest
	public void beforeTest(String filePath) {
		this.filePath = filePath;
	}
	
	@DataProvider(name = "testcasedata")
	public Object[][] dp() throws Exception {
		ExcelUtil excelUtil = new ExcelUtil(this.filePath);
		return excelUtil.getArrayCellValue(0);	
	}

	@Test(dataProvider = "testcasedata")
	public void httpReq(String id,String isExec,String testCase,String reqType,String reqHost,
			String reqInterface,String reqData,String expResult,String isDep,String depKey) throws Exception{
		
		//初始化
		String reqUrl = reqHost + reqInterface; 
		String actResult = null;
		
		Reporter.log("用例id" + id);
		Reporter.log("用例描述" + testCase);
		Reporter.log("请求方法" + reqType);
		Reporter.log("请求接口" + reqUrl);
		
		//处理依赖接口的reqData 
		reqData = PatternUtil.handlerReqDataOfDep(reqData);
		Reporter.log("请求参数" + reqData);
		
		//发送请求进行接口测试
		if("YES".equals(isExec)) {
			if("POST".equals(reqType)) {
				actResult = HttpRequestUtil.sendPost(reqUrl, reqData);
			}else {
				actResult = HttpRequestUtil.sendGet(reqUrl, reqData);
			}
		}else {
			Reporter.log("不执行测试用例，因为Excel中Test_is_exec为NO");
		}
		
		//解决接口依赖问题
		if("YES".equals(isDep)) {
			PatternUtil.storeDepKeyValue(depKey, actResult);
		}
		
		//实际值与预期值进行比对
		PatternUtil.compareResult(expResult, actResult);	
	}
}