自己写的粗糙的Excel数据驱动Http接口测试框架（一）

最新推荐文章于 2024-01-20 12:48:24 发布
最新推荐文章于 2024-01-20 12:48:24 发布
阅读量150 收藏
点赞数
文章标签： 测试 java json

1、excel用例：

2、用例执行：

@Test
public void BindBank() throws Exception {
    String fileName = "src/main/java/com/datatrees/testcase/BindBank.xlsx";
    handleOk &= initData(userName,enmobile);
    Runner.execute(fileName, mobile);
    System.out.println("##############－》 测试结束");
}

3、Runner封装类
package com.datatrees.framwork;

import com.datatrees.httpHelp.HttpUtils2;
import com.datatrees.httpHelp.TokenUtils;
import com.datatrees.httpHelp.common;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Created by lyh on 17/3/24.
 */
public class Runner {

    //无需登录
    // 执行一条用例，写入一次excel
    public static void execute(String filepath) throws Exception { //--target/classes目录下的文件路径
        List<TestCase> testCases = ExcelUtil.read(filepath);
        int row = 0;
        String respost="";
        //遍历测试用例
        for (TestCase testCase : testCases) {
            row++;
            //URL
            String url = common.pdl_uri + testCase.getPath();
            //参数maps
            List<String> params = new ArrayList();
            Map paramMaps = new HashMap();
            params.add(testCase.getFirstParam());
            params.add(testCase.getSecondParam());
            params.add(testCase.getThirdParam());
            params.add(testCase.getForthParam());
            params.add(testCase.getFifthParam());
            params.add(testCase.getParam_6());
            params.add(testCase.getParam_7());
            for (String param : params) {
                String[] apiParam;
                if (param.contains("-")) {
                    //参数属性和值
                    apiParam = param.split("-");
                    paramMaps.put(apiParam[0], apiParam[1]);
                    System.out.println(paramMaps);
                }
                if (!paramMaps.isEmpty()) {
                    //调用http接口发送请求
                    respost = HttpUtils2.sendHttpPost(url, paramMaps, "utf-8");

                    System.out.print(respost);
                } else {
                    //调用http接口发送请求
                    respost = HttpUtils2.sendHttpPost(url, "utf-8");
                    System.out.print(respost);
                }

            }
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
            String executTime = df.format(new Date());
            //写入实际值到excel和判断
            CompareRes.compare2(filepath, testCase, respost,executTime,row);
        }
    }


    //需要登录token执行一条用例，写入一次excel
    public static void execute(String filepath,String mobile) throws Exception { //--target/classes目录下的文件路径
        List<TestCase> testCases = ExcelUtil.read(filepath);
        int row = 0;
        TokenUtils tokencode=new TokenUtils();
        UserTokenCode userTokenCode = tokencode.getTokenCode(mobile);


        //遍历测试用例
        for (TestCase testCase : testCases) {
            row++;
            //URL
            String url = common.pdl_uri + testCase.getPath();
            String respost="";
            //参数maps
            List<String> params = new ArrayList();

            Map paramMaps = new HashMap();
            params.add(testCase.getFirstParam());
            params.add(testCase.getSecondParam());
            params.add(testCase.getThirdParam());
            params.add(testCase.getForthParam());
            params.add(testCase.getFifthParam());
            params.add(testCase.getParam_6());
            params.add(testCase.getParam_7());

            for (String param : params) {
                String[] apiParam;
                if (param.contains("-")) {
                    //参数属性和值
                    apiParam = param.split("-");
                    paramMaps.put(apiParam[0], apiParam[1]);

                    System.out.println(paramMaps);
                }
            }
            paramMaps.put("userId", userTokenCode.getUserId());
            paramMaps.put("token", userTokenCode.getTokenCode());
            if (!paramMaps.isEmpty()) {
                    //调用http接口发送请求
                respost = HttpUtils2.sendHttpPost(url, paramMaps, "utf-8");
                System.out.print(respost);
            } else {
                //调用http接口发送请求
                respost = HttpUtils2.sendHttpPost(url, "utf-8");
                System.out.print(respost);
            }
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
            String executTime = df.format(new Date());
            //写入实际值到excel和判断
            CompareRes.compare2(filepath, testCase, respost,executTime, row);
            }

        }
    //执行完全部测试用例后，将测试结果一次写入excel
    public static void execute2(String filepath) throws Exception { //--target/classes目录下的文件路径
        List<TestCase> testCases = ExcelUtil.read(filepath);
        int row = 0;

        //遍历测试用例
        for (TestCase testCase : testCases) {
            row++;
            //URL
            String url = common.pdl_uri + testCase.getPath();
            String respost;
            //参数maps
            List<String> params = new ArrayList();
            Map paramMaps = new HashMap();
            params.add(testCase.getFirstParam());
            params.add(testCase.getSecondParam());
            params.add(testCase.getThirdParam());
            params.add(testCase.getForthParam());
            params.add(testCase.getFifthParam());
            params.add(testCase.getParam_6());
            params.add(testCase.getParam_7());


            for (String param : params) {
                String[] apiParam;
                if (param.contains("-")) {
                    //参数属性和值
                    apiParam = param.split("-");
                    paramMaps.put(apiParam[0], apiParam[1]);
//
                    System.out.println(paramMaps);
                }
                if (!paramMaps.isEmpty()) {
                    //调用http接口发送请求
                    respost = HttpUtils2.sendHttpPost(url, paramMaps, "utf-8");
                    System.out.print(respost);
                } else {
                    //调用http接口发送请求
                    respost = HttpUtils2.sendHttpPost(url, "utf-8");
                    System.out.print(respost);
                }
                SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
                String executTime = df.format(new Date());
                //实际值填入testcase对象
                testCase.setActResu(respost);
                testCase.setExecuteTime(executTime);
                //将测试结果和报错信息填入testcase
                CompareRes.compare(testCase);

                //将testCase中的实际值，测试结果和报错信息填入excel
            }
            //写入实际值到excel和判断
            row = 0;
            CompareRes.WriteResult(filepath, testCases, row);
        }
    }
}
4、结果比较类
package com.datatrees.framwork;

import com.alibaba.fastjson.JSONObject;
import org.apache.log4j.Logger;

import java.util.*;

/**
 * Created by lyh on 17/3/23.
 */
public class CompareRes {
    private static Logger logger = Logger.getLogger(com.datatrees.framwork.TestCase.class);

    //每执行一个用例，将测试结果相关数据填入一次excel
    public static void compare2(String filePath, TestCase testCase, String actResu,String executeTime, int row) {
        int actResuNo = 12;//测试结果在第13例
        int ExecuteTimeNo = 13;//对比结果在第14列
        int TestResNo = 14;//对比结果在第15列
        int CommentNo = 15;//报错信息在16列
        JSONObject actRes_jsonObject;
        ExcelUtil.writeCell(filePath, row, ExecuteTimeNo, executeTime);
        ExcelUtil.writeCell(filePath, row, actResuNo, actResu);
        testCase.setActResu(actResu);
        String actRes = testCase.getActResu();
        String expRes = testCase.getExpResu();
        Map<String, String> actdata_map = new HashMap<String, String>();
        Map<String, String> expdata_map = new HashMap<String, String>();
        if (actRes.startsWith("{")) {
            actRes_jsonObject = JSONObject.parseObject(actRes);
            JSONObject expRes_jsonObject = JSONObject.parseObject(expRes);
            String actErrorMsg = actRes_jsonObject.getString("errorMsg");
            String actCode = actRes_jsonObject.getString("code");
            String expErrorMsg = expRes_jsonObject.getString("errorMsg");
            String expCode = expRes_jsonObject.getString("code");
            String act_data = actRes_jsonObject.getString("data");
            String exp_data = expRes_jsonObject.getString("data");
//            if (act_data != null && act_data.startsWith("{")) {
//                actdata_map = JsonsUtil.convertJsonStrToMap(act_data.trim());
//            }
//            if (exp_data != null && act_data.startsWith("{")) {
//                expdata_map = JsonsUtil.convertJsonStrToMap(exp_data.trim());
//            }
            if (exp_data != null&&act_data!=null) {
                if (actErrorMsg.trim().equals(expErrorMsg.trim()) && actCode.trim().equals(expCode.trim()) && ((act_data.trim().equals(exp_data.trim())) || (actdata_map.size() == expdata_map.size()))) {
                    ExcelUtil.writeCell(filePath, row, TestResNo, "Passed");
                } else if (actErrorMsg.trim().equals(expErrorMsg) == false) {
                    ExcelUtil.writeCell(filePath, row, TestResNo, "Failed");
                    ExcelUtil.writeCell(filePath, row, CommentNo, "expErrorMsg不相同");
                } else if (actCode.trim().equals(expCode) == false) {
                    ExcelUtil.writeCell(filePath, row, TestResNo, "Failed");
                    ExcelUtil.writeCell(filePath, row, CommentNo, "expCode不相同");
                } else if (act_data.trim().equals(exp_data) == false) {
                    ExcelUtil.writeCell(filePath, row, TestResNo, "Failed");
                    ExcelUtil.writeCell(filePath, row, CommentNo, "data不相同");
                }
            } else if (exp_data==null&&act_data==null){
                if (actErrorMsg.trim().equals(expErrorMsg) && actCode.trim().equals(expCode)) {
                    ExcelUtil.writeCell(filePath, row, TestResNo, "Passed");
                } else if (actErrorMsg.trim().equals(expErrorMsg) == false) {
                    ExcelUtil.writeCell(filePath, row, TestResNo, "Failed");
                    ExcelUtil.writeCell(filePath, row, CommentNo, "expErrorMsg不相同");
                } else if (actCode.trim().equals(expCode) == false) {
                    ExcelUtil.writeCell(filePath, row, TestResNo, "Failed");
                    ExcelUtil.writeCell(filePath, row, CommentNo, "expCode不相同");
                }
            }else {
                ExcelUtil.writeCell(filePath, row, TestResNo, "Failed");
                ExcelUtil.writeCell(filePath, row, CommentNo, "返回结果错误1");
            }
        } else {
            ExcelUtil.writeCell(filePath, row, TestResNo, "Failed");
            ExcelUtil.writeCell(filePath, row, CommentNo, "返回结果错误");
        }
    }

    //将用例都执行完，再将结果一次全部填入excel
    public static void WriteResult(String filePath, List<TestCase> testCases, int row) {
        int actResuNo = 12;//测试结果在第13例
        int executeNo = 13;//对比结果在第14列
        int TestResNo = 14;//对比结果在第15列
        int CommentNo = 15;//报错信息在16列
        for (TestCase testcase : testCases) {
            row++;
            ExcelUtil.writeCell(filePath, row, actResuNo, testcase.getActResu());
            ExcelUtil.writeCell(filePath, row, executeNo, testcase.getExecuteTime());
            ExcelUtil.writeCell(filePath, row, TestResNo, testcase.getTestResult());
            ExcelUtil.writeCell(filePath, row, CommentNo, testcase.getComment());
        }
    }

    //实际值与预期值对比，并写入testcase对象
    public static void compare(TestCase testCase) {

        String actRes = testCase.getActResu();
        String expRes = testCase.getExpResu();
        JSONObject actRes_jsonObject;
        if (actRes.startsWith("{")) {
            actRes_jsonObject = JSONObject.parseObject(actRes);
            JSONObject expRes_jsonObject = JSONObject.parseObject(expRes);
            String actErrorMsg = actRes_jsonObject.getString("errorMsg");
            String actCode = actRes_jsonObject.getString("code");
            String act_data = actRes_jsonObject.getString("data");
            String expErrorMsg = expRes_jsonObject.getString("errorMsg");
            String expCode = expRes_jsonObject.getString("code");
            String exp_data = expRes_jsonObject.getString("data");

            if (actErrorMsg.trim().equals(expErrorMsg) && actCode.trim().equals(expCode) && act_data.trim().equals(exp_data)) {
                testCase.setTestResult("Passed");
            } else if (actErrorMsg.trim().equals(expErrorMsg) == false) {
                testCase.setTestResult("Failed");
                testCase.setComment("expErrorMsg不相同");
            } else if (actCode.trim().equals(expCode) == false) {
                testCase.setTestResult("Failed");
                testCase.setComment("expCode不相同");
            } else if (act_data.trim().equals(exp_data) == false) {
                testCase.setTestResult("Failed");
                testCase.setComment("data不相同");
            }
        } else {
            testCase.setTestResult("Failed");
            testCase.setComment("实际值与预期值不同");
        }
    }


    //断言优化
    public static void execute3(String filePath, TestCase testCase, String actResu, int row) {
        int actResuNo = 12;//测试结果在第13例
        int TestResNo = 13;//对比结果在第14列
        int CommentNo = 14;//报错信息在15列
        ExcelUtil.writeCell(filePath, row, actResuNo, actResu);
        testCase.setActResu(actResu);
        String actRes = testCase.getActResu();
        String expRes = testCase.getExpResu();
        String caseName = testCase.getSubID();
        AssertResult.AssertFunction(caseName, expRes, actRes, filePath, row);
    }

}

5、excelUtil类：
package com.datatrees.framwork;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by lyh on 17/3/23.
 */
public class ExcelUtil {
    //读取Excel中数据
    public static List<TestCase> read(String fileName) throws Exception {
        XSSFWorkbook wb = new XSSFWorkbook();
        XSSFSheet s = wb.createSheet();
        XSSFRow row = s.createRow(0);
        XSSFCell cell = row.createCell((int) 0, 0);
        //－－－－－－－－－－－－从xls读出数据
//        fileName = ClassLoader.getSystemResource("").toString().replace("file:", "").replace("target/classes/", "").trim() + fileName;

        wb = new XSSFWorkbook(new FileInputStream(fileName));

        s = wb.getSheetAt(0);

        //获得EXCEL行数
        int rowNums = s.getLastRowNum();
        //获得Excell列数
        //int columnNum=r.getPhysicalNumberOfCells();

        List<TestCase> testCases = new ArrayList<TestCase>();
        for (int i = 1; i <= rowNums; i++) {
            XSSFRow r = s.getRow(i);
//            cell = r.getCell(0);
            TestCase testCase = new TestCase();

            testCase.setID(getCellValue(r.getCell(0)));
            testCase.setSubID(r.getCell(1).getStringCellValue());
            testCase.setCaseDes(r.getCell(2).getStringCellValue());
            testCase.setPath(r.getCell(3).getStringCellValue());

            testCase.setFirstParam(r.getCell(4).getStringCellValue());
            testCase.setSecondParam(r.getCell(5).getStringCellValue());
            testCase.setThirdParam(r.getCell(6).getStringCellValue());
            testCase.setForthParam(r.getCell(7).getStringCellValue());
            testCase.setFifthParam(r.getCell(8).getStringCellValue());
            testCase.setParam_6(r.getCell(9).getStringCellValue());
            testCase.setParam_7(r.getCell(10).getStringCellValue());

            testCase.setExpResu(r.getCell(11).getStringCellValue());
            testCase.setActResu(r.getCell(12).getStringCellValue());
            testCase.setExecuteTime(r.getCell(13).getStringCellValue());
            testCase.setTestResult(r.getCell(14).getStringCellValue());
            testCase.setComment(r.getCell(15).getStringCellValue());
//        System.out.println(cell.getRichStringCellValue());
                testCases.add(testCase);

        }
        return testCases;

    }

    /**
     * 写入Excel，在任意坐标处写入数据。
     * String value：你要输入的内容
     * int x ：行坐标，Excel从 0 算起
     * int y   ：列坐标，Excel从 0 算起
     */
    public static void writeCell(String filePath, int x, int y, String value) {
        try {
            // 创建Excel的工作书册 Workbook,对应到一个excel文档
            XSSFWorkbook wb = new XSSFWorkbook(new FileInputStream(filePath));
            XSSFSheet sheet = wb.getSheetAt(0);
            XSSFRow row = sheet.getRow(x);
            XSSFCell cell = row.getCell((short) y);
            cell.setCellValue(value);
            FileOutputStream os;
            os = new FileOutputStream(filePath);
            wb.write(os);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 取表格值
     *
     * @param xssfCell XSSFCell类型对象，表示单元格。
     * @return：返回单元格数值
     */

    public static String getCellValue(XSSFCell xssfCell) {
        if (xssfCell.getCellType() == xssfCell.CELL_TYPE_BOOLEAN) {
            return String.valueOf(xssfCell.getBooleanCellValue());
        } else if (xssfCell.getCellType() == xssfCell.CELL_TYPE_NUMERIC) {
            return new BigDecimal(xssfCell.getNumericCellValue()).toPlainString();
//            return String.valueOf(xssfCell.getNumericCellValue());
        } else {
            return String.valueOf(xssfCell.getStringCellValue());
        }

    }
}
6、用例类：
package com.datatrees.framwork;

/**
 * Created by lyh on 17/3/23.
 */
public class TestCase {
    String ID;//编号
    String SubID;//姓名
    String CaseDes;//年龄
    String Path;//路径
    String FirstParam;//第一个参数
    String SecondParam;//第二个参数
    String ThirdParam;//第三个参数
    String ForthParam;//第四个参数
    String FifthParam;//第五个参数
    String Param_6;//第6个参数
    String Param_7;//第7个参数

    String expResu;//期望结果
    String actResu;//实际结果
    String executeTime;//执行时间
    String TestResult;//是否通过
    String Comment;//描述


    public TestCase() {
    }

    public String getExecuteTime() {
        return executeTime;
    }

    public void setExecuteTime(String executeTime) {
        this.executeTime = executeTime;
    }
    public String getParam_7() {
        return Param_7;
    }

    public void setParam_7(String param_7) {
        Param_7 = param_7;
    }
    public String getParam_6() {
        return Param_6;
    }

    public void setParam_6(String param_6) {
        Param_6 = param_6;
    }

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }
    public String getSubID() {
        return SubID;
    }

    public void setSubID(String subID) {
        SubID = subID;
    }

    public String getCaseDes() {
        return CaseDes;
    }

    public void setCaseDes(String caseDes) {
        CaseDes = caseDes;
    }

    public String getPath() {
        return Path;
    }

    public void setPath(String path) {
        Path = path;
    }

    public String getFirstParam() {
        return FirstParam;
    }

    public void setFirstParam(String firstParam) {
        FirstParam = firstParam;
    }

    public String getSecondParam() {
        return SecondParam;
    }

    public void setSecondParam(String secondParam) {
        SecondParam = secondParam;
    }

    public String getThirdParam() {
        return ThirdParam;
    }

    public void setThirdParam(String thirdParam) {
        ThirdParam = thirdParam;
    }

    public String getForthParam() {
        return ForthParam;
    }

    public void setForthParam(String forthParam) {
        ForthParam = forthParam;
    }

    public String getFifthParam() {
        return FifthParam;
    }

    public void setFifthParam(String fifthParam) {
        FifthParam = fifthParam;
    }

    public String getExpResu() {
        return expResu;
    }

    public void setExpResu(String expResu) {
        this.expResu = expResu;
    }

    public String getActResu() {
        return actResu;
    }

    public void setActResu(String actResu) {
        this.actResu = actResu;
    }

    public String getTestResult() {
        return TestResult;
    }

    public void setTestResult(String testResult) {
        TestResult = testResult;
    }

    public String getComment() {
        return Comment;
    }

    public void setComment(String comment) {
        Comment = comment;
    }
}

7、http工具类：
package com.datatrees.httpHelp;

import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * Created by lyh on 17/3/16.
 */
public class HttpUtils2 {
    private static Logger logger = LoggerFactory.getLogger(HttpUtils2.class);
    private static CloseableHttpClient httpClient = HttpClients.createDefault();


    public String sendHttpGet(String url) {
        HttpGet httpGet = new HttpGet(url);
        String result = "fail";
        try {
            CloseableHttpResponse response = httpClient.execute(httpGet);
            if (response.getStatusLine().getStatusCode() == 200) {
                result = EntityUtils.toString(response.getEntity());
                logger.debug(result);
            }
        } catch (ClientProtocolException e) {
            logger.error(e.toString());
        } catch (IOException e) {
            logger.error(e.toString());
        }
        return result;
    }

    public static String sendHttpPost(String url, JSONObject json, String charset) {
        HttpPost httppost = new HttpPost(url);
        httppost.setHeader("Content-type", "application/json");
        httppost.setHeader("Accept", "application/json;charset=UTF-8");
        String result = "fail";
        try {
            StringEntity entity = new StringEntity(json.toString(), charset);
            entity.setContentEncoding("UTF-8");
            httppost.setEntity(entity);
            HttpResponse response = httpClient.execute(httppost);
            System.out.println(response.getStatusLine().getStatusCode());
            if (response.getStatusLine().getStatusCode() == 200) {
                //读返回数据
                result = EntityUtils.toString(response.getEntity());
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            logger.error(e.toString());
        }
        return result;
    }

    public static String sendHttpPost(String url, Map<String, String> map, String charset) {
        logger.info(url);
        System.out.print("url:"+url);
        HttpPost httpPost = new HttpPost(url);

        String result = null;

        try {
            //设置参数
            List<NameValuePair> list = new ArrayList<NameValuePair>();
            Iterator iterator = map.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, String> elem = (Map.Entry<String, String>) iterator.next();
                list.add(new BasicNameValuePair(elem.getKey(), elem.getValue()));
            }
            if (list.size() > 0) {
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, charset);
                httpPost.setEntity(entity);
            }
            HttpResponse response = httpClient.execute(httpPost);
            if (response != null) {
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    result = EntityUtils.toString(resEntity, charset);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return result;
    }

    public static String sendHttpPost2(String url, Map<String, String> map, String charset) {
        HttpPost httpPost = new HttpPost(url);
        String result = null;

        try {
            //设置参数
            List<NameValuePair> list = new ArrayList<NameValuePair>();
            Iterator iterator = map.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, String> elem = (Map.Entry<String, String>) iterator.next();
                list.add(new BasicNameValuePair(elem.getKey(), elem.getValue()));
            }
            if (list.size() > 0) {
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, charset);
                httpPost.setEntity(entity);
            }
            HttpResponse response = httpClient.execute(httpPost);
            if (response != null) {
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    result = EntityUtils.toString(resEntity, charset);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return result;
    }

    public static String sendHttpPost(String url, List<NameValuePair> list, String charset) {
        HttpPost httpPost = new HttpPost(url);
        String result = null;
        try {
            if (list.size() > 0) {
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, charset);
                httpPost.setEntity(entity);
            }
            HttpResponse response = httpClient.execute(httpPost);
            if (response != null) {
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    result = EntityUtils.toString(resEntity, charset);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return result;
    }
    public static String sendHttpPost(String url, String charset) {
        HttpPost httpPost = new HttpPost(url);
        String result = null;
        try {
            HttpResponse response = httpClient.execute(httpPost);
            if (response != null) {
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    result = EntityUtils.toString(resEntity, charset);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return result;
    }
    public static String sendHttpPost(String url) {
        HttpPost httpPost = new HttpPost(url);
        String result = null;
        try {
            HttpResponse response = httpClient.execute(httpPost);
            if (response != null) {
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    result = EntityUtils.toString(resEntity, "utf-8");
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return result;
    }
}











 

weixin_34097242
关注
java读取excel文件中数据作为参数循环调用http 的put请求接口
my_power520的博客
02-10 1236
需求背景：这个系统只有单条新增的功能，现在需要把excel文件中的数据大量插入进去，人工操作太费时费力，又没有系统源码，没法直接开发导入的功能，只好采用循环调用http接口的方式进行插入。 需要的maven依赖： <!--读取excel依赖--> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi-ooxml</artifactId>
python excel接口测试_读写excel接口数据，进行接口测试
weixin_39623244的博客
02-09 437
1、导入对应要用到的模块方法：a、命令行：pip install 模块名b、pycharm安装：File>Settings…>Project:Test>Project Interpreter，这里安装仅对本项目有用(Test) 2、这里我将登陆接口单独拿出来，为了取token给后边用a、设置登录的接口以及入参，data入参设置为dict也可以是字符串，偏向于用字典b、请求接口c、...
Excelante:Excelante是一个用于通过HTTP请求读写Excel文件的API
05-30
Excelante 是一个开源 API，允许用户与 XLSX 文件交互、从中提取数据或从给定输入创建文件。 使用我们的 API 只需要一个 HTTP 请求，它对于需要处理 XLSX 文件或自动化的网站/应用程序非常有用。 文档 所有 API 文档都可以在找到 Swagger API 文档可以在/api/v1/swagger/ 基准 基准是在 MacBook Pro（2015）笔记本电脑上实现的：2,7 GHz Intel Core i5 双核 8 Go 1867 MHz DDR3 作家 测试 运行 1 运行 2 运行 3 运行 4 运行 5 莫伊 10x10（100 个单元格） 382ms 361ms 249ms 269 毫秒 214ms 295ms 100x100（10 000 个单元格） 627ms 501ms 517ms 512毫秒 475ms 526
excel数据驱动接口测试框架
http_tester的博客
12-28 3282
接口测试自动化框架搭建                                                                                                                      作者：杨刚 前言：   经常，在应用程序的业务逻辑中存在大量的这样的接口：他们接受不同的输入，然后进行或验证，或处理，进而完成相同的流
Excel+Httpclient，数据驱动接口自动化测试
测试菜鸟的博客
12-20 2152
N个B端产品，一个产品有N个http接口、一个http接口又有N个入参，每个入参都要作非法性测试，一遍遍修改报文、再进行post，重复劳动可想而知。尝试写了一个简陋的api自动化框架，具体如下。还待持续完善。一、框架设计1、每一个http接口定义成一个类，以接口号为类名，属性为该接口的各个入参，用构造方法实现数据初始化。 2、制作一个excel模板1作为基础模板，模板1包含TestCase No.
demo_ddt_interface:接口测试框架demo（ddt数据驱动excel管理测试用例）
03-13
综上所述，"demo_ddt_interface"是一个基于Python的数据驱动接口测试框架，它利用Excel作为测试用例的数据源，通过清晰的项目结构管理各个组件，提供了自动化测试的能力，并且能生成测试报告，便于团队协作和测试...
Python3+unittest+requests+excel实现接口自动化测试框架源码
02-04
**Excel数据驱动** 在接口自动化测试中，经常需要对不同的输入数据进行测试，以覆盖各种边界条件和异常情况。Excel是一种常用的数据存储格式，易于读写，适合做数据驱动测试。可以使用pandas等Python库读取Excel文件...
【接口自动化】数据驱动｜Easy POI读取接口测试用例的excel
最新发布
weixin_40772077的博客
01-20 1136
自动化数据驱动｜Easy POI读取接口测试用例的excel
excel如何用vba发送http请求
weixin_42584758的博客
02-12 1230
您可以使用VBA代码在Excel中发送HTTP请求。这是一个简单的示例代码： Sub sendHTTPRequest() Dim XMLHTTPAs Object Set XMLHTTP = CreateObject("MSXML2.serverXMLHTTP") XMLHTTP.Open "GET", "http://www.example.com", Fals...
excel和python接口_excel+python进行接口测试
weixin_39548490的博客
12-05 197
工作之余写了一个超级简单的excel+Python的接口测试脚本，将多个接口的测试用例写到表格里后，脚本针对单个接口测试它的全用例，然后将返回结果打印出来。之前用postman集成的时候引入excel表格，发现可以跑多个用例，但是我只能看到结果是成功(呈绿色)还是失败(呈红色)，具体的返回结果看不到，感觉很蛋疼，所以就用初学的python写了一个小东西，虽然很粗糙，但起码能满足我的需求，哈哈#-*...
实现调用API接口
紫郡的博客
01-28 4370
什么是 API API介绍 API（Application Programming Interface）应用程序编程接口，是一些预先定义的函数，目的为提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码或理解内部工作机制的细节。 API特点 ① 明确定义的接口，可以为其他软件提供特定服务。 ② API可以小到只包含一个单独的函数，也可以大到半酣数以百计的类、方法...
python接口自动化脚本_python http接口自动化脚本详解
weixin_39552304的博客
11-20 455
今天给大家分享一个简单的python脚本，使用python进行http的接口测试，脚本很简单，逻辑是：读取excel写好的测试用例，然后根据excel中的用例内容进行调用，判断预期结果中的返回值是否和返回报文中的值一致，如果不一致则根据用例标题把bug提交到bug管理系统，这里使用的bug管理系统是bugfree。实现步骤：1、读取excel，保存测试用例中的内容；2、根据excel中的请求url...
python处理excel和调用http接口实战案例
flyingant9的博客
02-22 807
功能描述： 调用第三方接口获取数据，并写入excel中。 用到了在Python中读取和写入excel，如何调用http接口，如何对接口返回json处理。 代码： #!/usr/bin/python3 # -*- coding: UTF-8 -*- import time import json import requests from openpyxl.reader.excel import load_workbook #初始化数值 access_token = 'xxxx' file_name = '
操纵Excel文件的 ExcelUtil 类 ！
weixin_30757793的博客
12-13 206
1 package FileDemo1; 2 3 import java.io.File; 4 import java.io.FileInputStream; 5 import java.io.FileOutputStream; 6 import java.util.ArrayList; 7 import java.util.List; ...
ExcelUtil工具类
程序员路同学
09-16 4581
maven依赖导入poi <!-- excel工具类 --> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi-ooxml</artifactId> <version>4.1.1</version> </dependency> 导入jackson依赖包： <!--jackson工具包--&gt...
java读取excel的工具类-POI解析excel
制心一处
09-06 3240
分享一个操作excel的工具类，这个工具分3个部分， ExcelUtil.java 　　//工具类 ExcelSheetPO.java　　//实体对象 ExcelVersion.java　//版本枚举   可以把excel数据读取到内存中，转换为 List&lt;List&lt;Object&gt;&gt;，也可以根据List&lt;List&lt;Object&gt;&gt;转化成ex...
Python语言——使用Excel分离数据进行接口测试
happy183的博客
03-05 345
使用Excel分离数据进行接口测试 ExcelDataReturn.py #!/usr/bin/env python #-*- coding:utf-8 -*- # author:飞天P import xlrd import json import unittest import time as t import requests ''' 接口测试： requests GET请求：reque...
Excel自动获取网页数据
热门推荐
灯塔ADA的专栏
04-09 1万+
  利用Excle可以自动获取网页数据，譬如从网页中自动获取基金净值数据，取得所关注基金的净值，列出当日涨幅最高的基金。本文用简单的Web查询结合Excel公式的方法完成上述需求，当然也可以用VBA编写功能更加丰富的自动查询网页数据工具。         1. 创建和编辑 Web 查询Excel2003数据 - 导入外部数据 -
Python接口测试框架：Excel数据读取核心封装
本文档详细介绍了如何使用Python实现一个基础的接口测试框架，特别是针对Excel数据进行测试的处理。核心功能集中在`excel_utils.py`模块，该模块主要负责读取和操作Excel文件中的测试数据。 **1. 框架菜单与common...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值