分层测试重构之接口层

最新推荐文章于 2025-05-25 00:27:15 发布
最新推荐文章于 2025-05-25 00:27:15 发布
阅读量167 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 性能测试 软件测试 自动化测试工具 文章标签： 数据库 android python 测试工具 开发语言 appium 重构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DJ355/article/details/132207905

目录

前言：

接口层优化需求

具体实现

配置字段说明：

raw 方式传参：json 格式

普通方式传参

经过本次代码重构，以上原本复杂的，对外部文件解析执行的核心处理类，逻辑变得非常简单

完整案例之代码实现：如果要写代码完成测试案例，DSL 的设计让开发者事半功倍，让看代码的人通俗易懂

前言：

分层测试是一种测试方法，它将软件分为多个层次进行测试，从而提高测试的效率和准确性。在分层测试中，接口层是非常重要的一部分。接口层测试是测试应用程序的 API 接口是否能够正确地响应和处理请求。

接口层优化需求

总体目标

  • 支持基于 Http 协议的所有测试，包含但不仅限于接口测试，例如：Web 测试中对于页面的请求，上传和下载资源等操作
  • 基于行为驱动开发的思想，支持外部 DSL 和内部 DSL
  • 用户可调用 API 开发案例，也可以不写代码按通俗易懂的既定格式编写案例
  • 结构设计清晰，利于扩展
  • 测试流核心模块以外，开放接口，支持用户在不改变框架源码的基础上实现定制化（针对高级用户）

实现功能

  • 支持包括 rest 风格在内的各种形式的基于 http 协议的请求
  • 支持各种请求场景的参数化，包括但不仅限于：url、path、表单等
  • 支持通过正则表达式提取动态参数，支持动态参数的脚本内调用和跨脚本调用
  • 支持通过加载外部文件、调用内部方法、调用自定义方法等多种方式实现参数化的添加
  • 支持自定义 header，实现伪造
  • 支持 json、xml、x-www-form-urlencoded 等请求参数格式
  • 支持断言的普通全匹配、正则表达式的全匹配、普通包含匹配、使用正则表达式的包含匹配、使用变量进行参数化匹配等
  • 支持客户端处理生成的请求参数，可以通过反射调用用户自定义的方法
  • 支持请求配置项的全局配置和局部配置，局部配置的优先级大于全局配置，即使用局部配置全局配置的相同配置项失效

具体实现

如何通过文件写一个接口测试
设计采用 json 格式，一方面是方便对结构的正确性进行校验，另一方面考虑到大部分数据传输都用 json 格式，便于推广。

配置字段说明：
  • testcase：案例名称 ，选配字段
  • scope：模式，必配字段，1 代表接口层，2 代表数据层，4 代表 UI 层，3 代表接口层 + 数据层，以此推类
  • defaultEncode：默认 UTF-8，全局编码，选配字段
  • useHttps：是否支持 Https 的开关，默认 false，目前支持安全系数较低的 SHA-1 签名，选配字段
  • useProxy：全局代理配置，选配字段，例如：xx.xx.xx.xx:8080
  • redirect：重定向开关，默认 false，选配字段
  • defaultHeader：全局头信息，选配字段，多个数据用双逗号分隔，字段和属性以双冒号分隔，例如：Content-Type::application/x-www-form-urlencoded,,accept-encoding::gzip
  • globalData：全局参数，选配字段，多个参数逗号分隔，例如：userLogin=UserLogin,rsp=Rsp,name=jack
  • iterativeData：全局参数，支持多条数据的参数化、支持内部配置读取和外部文件读取。 内部读取：以 inner 开头，多条数据以分号分隔，字段用逗号分隔，例如：inner a=1,b=2;a=2,b=3;a=3,b=4， 外部读取：以 outer 开头，file 指定文件路径，fields 指定参数化的字段，separate 指定分隔符，三个配置用&分隔， 例如：outer file=src/parameters&fields=phone,clientType&separator=:
  • step：测试步骤，选配字段
  • url：请求地址，必配字段，支持强大的参数化功能，例如：(http://xx.xx.xx.xx/app/testGet.do)， (http://xx.xx.xx.xx/${pram}/testGet.do)，支持客户端定制化生成的参数：(http://xx.xx.xx.xx/${pram}/testGet.do?field1=#{pers.quq.layer.tools.DateUtil.test(1,2)})，如果动态方法无参，则方法名右边不需要括号
  • method：请求方法，必填字段，大小写不敏感，例如：GET、Post
  • contentType：请求内容类型，选填字段，例如：application/json、text/xml、application/x-www-form-urlencoded、multipart/form-data（该项需配置fileParam）
  • param：请求参数，选配字段，例如：user_phone=jack&date=20160303，同样支持强大的参数化功能，例如：user_phone=${user_phone}&date=#{pers.quq.layer.tools.DateUtil.test}
  • header：局部头信息，选配字段，相同的属性会覆盖全局全局头信息的属性，配置同 defaultHeader
  • encode：局部编码，选配字段，会覆盖全局编码
  • proxy：局部代理配置，选配字段，会覆盖全局代理配置，配置请参考 useProxy
  • regex：正则表达式提取器，选配字段，小括号内的内容就是动态获取的值，会保存到等号左边指定的字段， 字段={左边界 (正则表达式) 右边界}# 取第几个， 例如：msg={msg\":\"(.*)\",\"result}#1
  • shouldBeContains：断言之普通包含匹配，选配字段，支持参数化，例如：aa${param}bb
  • shouldBeEquals：断言之普通全匹配，选配字段，支持参数化，配置请参考 shouldBeContains
  • shouldBeContainsByRegex：断言之使用正则表达式的包含匹配，选配字段，支持参数化，例如：msg\":\".*\",\"result
  • shouldBeEqualsByRegex：断言之使用正则表达式的全匹配，选配字段，支持参数化，配置请参考 shouldBeContainsByRegex
  • delay：请求结束后的延时，单位秒，选配字段
  • fileParam：上传文件的请求参数，选配字段，例如：文件参数名 1=文件路径 1,文件参数名 2=文件路径 2。。。。。。
raw 方式传参：json 格式
{
    "testcase": "layTestCase",
    "scope": 1,
    "useHttps": true,
    "redirect": true,
    "globalData": "user=quqing,password=123,addr1=803,addr2=831",
    "defaultEncode": "UTF-8",
    "requests": [
        {
            "step": 1,
            "desc": "删除收货地址",
            "header": "Authorization::Bearer ${token}",
            "url": "http://xx.xx.xx.xx:8081/addr/${addr2}",
            "method": "delete",
        },
    {
            "step": 2,
            "desc": "修改商品数量",
            "header": "Authorization::Bearer ${token}",
            "param": "shoppingCartId=${shoppingCartId}&goodsNum=2",
            "url": "http://xx.xx.xx.xx:8081/update",
            "method": "put",
            "shouldBeEquals": "{\"code\":\"K-000000\",\"message\":\"操作成功\"}"
        }
        {
            "step": 3,
            "desc": "删除购物车单个商品",
            "header": "Authorization::Bearer ${token},,Content-Type::application/json",
            "url": "http://xx.xx.xx.xx:8081/goods",
            "method": "delete",
            "param": "{\"shoppingCartId\":8022}",
        }
    ]
}
普通方式传参
{
    "scope": 1,
    "useHttps": true,
    "redirect": true,
    "globalData": "user=quqing,password=123,goodsInfoId=6666",
    "defaultEncode": "UTF-8",
    "defaultHeader": "Content-Type::application/x-www-form-urlencoded",
    "requests": [
        {
            "step": 1,
            "desc": "登录",
            "url": "http://xx.xx.xx.xx:8081/checkLogin",
            "method": "post",
            "param": "user=${user}&password=${password}",
            "encode": "UTF-8",
            "regex": "token={\"token\":\"(.*)\"}#1", 
            "shouldBeContains": "\"token\":"
        },
        {
            "step": 2,
            "desc": "加入购物车单个商品",
            "header": "Authorization::Bearer ${token}",
            "param": "districtId=1&goodsInfoId=${goodsInfoId}&goodsNum=1",
            "url": "http://xx.xx.xx.xx:8081/goods",
            "method": "post",
            "shouldBeEquals": "{\"code\":\"K-000000\",\"message\":\"操作成功\"}"
        },
        {
            "step": 3,
            "desc": "获取购物车列表",
            "header": "Authorization::Bearer ${token}",
            "url": "http://xx.xx.xx.xx:8081/list?districtId=1",
            "method": "get",
            "regex": "shoppingCartId={\"shoppingCartId\":([0-9]+),\"goodsInfoId\"}#2", 
            "shouldBeContains": "\"productResponseList\":[{\"shoppingCartId\":"
        },
        {
            "step": 4,
            "desc": "下单",
            "header": "Authorization::Bearer ${token}",
            "param": "shoppingCartId=${shoppingCartId}&addressId=803&message=hello",
            "url": "http://xx.xx.xx.xx:8081/submit",
            "regex": "orderId={\"orderId\":(.*),\"orderCodes\"}#1",
            "method": "post",
            "shouldBeNotContains": "\"orderId\": null",
            "shouldBeNotContainsByRegex": "\"code\":\"K-.*\",\"message\""
        },
        {
            "step": 5,
            "desc": "查询订单基本信息",
            "header": "Authorization::Bearer ${token}",
            "url": "http://xx.xx.xx.xx:8080/${orderId}",
            "method": "get",
            "shouldBeNotContains": "\"orderId\": null1",
            "shouldBeNotContainsByRegex": "\"code\":\"K-.*\",\"message\""
        }
    ]
}
经过本次代码重构，以上原本复杂的，对外部文件解析执行的核心处理类，逻辑变得非常简单
package pers.quq.layer.tester;

import pers.quq.layer.entity.LayerCaseDO;
import pers.quq.layer.entity.RequestDO;
import pers.quq.layer.exception.*;
import pers.quq.layer.jiekou.HttpTester;
import pers.quq.layer.jiekou.ParamsProxy;
import pers.quq.layer.jiekou.def.HttpContentType;
import pers.quq.layer.jiekou.def.HttpMethod;
import pers.quq.layer.jiekou.def.IHttpRequest;
import pers.quq.layer.jiekou.impl.HttpConfig;
import pers.quq.layer.jiekou.impl.HttpRequest;
import pers.quq.layer.parse.DataProcess;
import pers.quq.layer.parse.Parse;
import pers.quq.layer.parse.ParseLayerCase;
import pers.quq.layer.tools.FileUtil;
import pers.quq.layer.tools.Log;
import pers.quq.layer.tools.ParseProperties;
import pers.quq.layer.tools.Persistence;

import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URISyntaxException;
import java.util.List;
import java.util.Map;

/**
 * Created by quqing on 2016/3/2.
 */
public class TestInterface {
    private String response = null;
    private String defaultEncode;
    private String requestBody;
    private String contentType;
    private Map<String, String> defaultHeader;
    private Map<String, String> header;
    private Map<String, String> globalData;
    private Map<String, Object> fileParam;
    private Map<String, Object> paramsMap = null;
    private List<Map<String, String>> iterativeParamList;
    private IHttpRequest httpRequest;
    private Parse parseLayerCase = new ParseLayerCase();
    private LayerCaseDO layerCaseDO;
    private List<RequestDO> requests;
    private ParseProperties config = new ParseProperties();

    private void init(String testCase) throws Exception {
        layerCaseDO = (LayerCaseDO) parseLayerCase.parse(testCase);
        defaultEncode = null != layerCaseDO.getDefaultEncode() ? layerCaseDO.getDefaultEncode() : "UTF-8";
        defaultHeader = null != layerCaseDO.getDefaultHeader() ? DataProcess.header(layerCaseDO.getDefaultHeader()) : null;
        globalData = DataProcess.globalData(layerCaseDO.getGlobalData());
        requests = layerCaseDO.getRequests();
        iterativeParamList = null != layerCaseDO.getIterativeData() ? DataProcess.iterativeData(layerCaseDO.getIterativeData()) : null;

        Log.logInfo("************************************************************************************************************************************************************************************************************");
        Log.logInfo("defaultEncode: " + layerCaseDO.getDefaultEncode());
        Log.logInfo("defaultHeader: " + layerCaseDO.getDefaultHeader());
        Log.logInfo("globalData: " + layerCaseDO.getGlobalData());
        Log.logInfo("iterativeData: " + layerCaseDO.getIterativeData());
        Log.logInfo("useHttps: " + layerCaseDO.getUseHttps());
        Log.logInfo("useProxy: " + layerCaseDO.getUseProxy());
        Log.logInfo("************************************************************************************************************************************************************************************************************");

        HttpConfig httpConfig = HttpConfig.custom()
                .setDefaultEncode(defaultEncode)
                .setHeader(defaultHeader)
                .setRedirectStrategy(layerCaseDO.getRedirect())
                .setHttps(layerCaseDO.getUseHttps())
                .setProxy(layerCaseDO.getUseProxy())
                .build();

        httpRequest = (IHttpRequest) ParamsProxy.newInstance(new HttpRequest(httpConfig), globalData);
    }

    private void run(String resultDir) throws DataProcessException, UnsupportedEncodingException, URISyntaxException, TestInterfaceException {
        String desc;
        String oldHeader;
        File dir;
        Map<String, String> persistParamMap;

        if (Persistence.isFileExist()) {
            persistParamMap = Persistence.persisting_load();
            if (null == globalData) {
                globalData = persistParamMap;
            } else {
                globalData.putAll(persistParamMap);
            }
        }

        for (RequestDO requestDO : requests) {
            desc = requestDO.getDesc().trim();
            oldHeader = requestDO.getHeader();

            // header处理
            if (null != oldHeader) {
                if (null != globalData && globalData.size() > 0) {
                    for (String key : globalData.keySet()) {
                        oldHeader = oldHeader.replaceAll("\\$\\{" + key + "\\}", globalData.get(key));
                    }
                }
            }
            header = null != oldHeader ? DataProcess.header(oldHeader) : null;

            // Content-Type处理
            if (null == header) {
                contentType = HttpContentType.SC_FROM_URL_ENCODED;
            } else {
                if (null == header.get("Content-Type")) {
                    contentType = HttpContentType.SC_FROM_URL_ENCODED;
                } else {
                    contentType = header.get("Content-Type");
                }
            }

            fileParam = DataProcess.param(requestDO.getFileParam(), layerCaseDO.getDefaultEncode());

            if (null != requestDO.getEncode())
                httpRequest.setDefaultEncode(requestDO.getEncode());
            httpRequest.setHeader(header);
            httpRequest.setContentType(contentType);
            httpRequest.setProxy(requestDO.getProxy());

            if (contentType.contains(HttpContentType.SC_JSON) || contentType.contains(HttpContentType.SC_XML)) {
                requestBody = null != requestDO.getParam() ? requestDO.getParam().trim() : null;
            } else {
                paramsMap = DataProcess.param(requestDO.getParam(), layerCaseDO.getDefaultEncode());
            }

            if (null != requestDO.getFileParam()) {
                response = httpRequest.doPost(requestDO.getUrl(), paramsMap, fileParam);
            } else if (contentType.contains(HttpContentType.SC_RESOURCE)) {
                response = httpRequest.doGet(requestDO.getUrl(), paramsMap, config.get("downloadDir") + System.currentTimeMillis());
            } else if (requestDO.getMethod().equalsIgnoreCase(HttpMethod.Post.toString())) {
                if (contentType.contains(HttpContentType.SC_JSON) || contentType.contains(HttpContentType.SC_XML)) {
                    response = httpRequest.doPost(requestDO.getUrl(), requestBody);
                } else if (contentType.contains(HttpContentType.SC_FROM_DATA)) {
                    throw new TestInterfaceException("Missing parameter, the fileParam is null!");
                } else {
                    if (null != paramsMap) {
                        response = httpRequest.doPost(requestDO.getUrl(), paramsMap);
                    } else {
                        response = httpRequest.doPost(requestDO.getUrl());
                    }
                }
            } else if (requestDO.getMethod().equalsIgnoreCase(HttpMethod.Get.toString())) {
                if (contentType.contains(HttpContentType.SC_JSON) || contentType.contains(HttpContentType.SC_XML)) {
                    response = httpRequest.doGet(requestDO.getUrl(), requestBody);
                } else {
                    if (null != paramsMap) {
                        response = httpRequest.doGet(requestDO.getUrl(), paramsMap);
                    } else {
                        response = httpRequest.doGet(requestDO.getUrl());
                    }
                }
            } else if (requestDO.getMethod().equalsIgnoreCase(HttpMethod.Put.toString())) {
                if (contentType.contains(HttpContentType.SC_JSON) || contentType.contains(HttpContentType.SC_XML)) {
                    response = httpRequest.doPut(requestDO.getUrl(), requestBody);
                } else {
                    response = httpRequest.doPut(requestDO.getUrl(), paramsMap);
                }
            } else if (requestDO.getMethod().equalsIgnoreCase(HttpMethod.Delete.toString())) {
                response = httpRequest.doDelete(requestDO.getUrl(), requestBody);
            } else {
                throw new TestInterfaceException("Missing parameter, method is " + requestDO.getMethod());
            }

            Log.logInfo("step: " + requestDO.getStep());
//            Log.logInfo("url: " + requestDO.getUrl());
            Log.logInfo("method: " + requestDO.getMethod());
//            Log.logInfo("param: " + requestDO.getParam());
            Log.logInfo("header: " + header);
            Log.logInfo("shouldBeContains: " + requestDO.getShouldBeContains());
            Log.logInfo("shouldBeNotContains: " + requestDO.getShouldBeNotContains());
            Log.logInfo("shouldBeEquals: " + requestDO.getShouldBeEquals());
            Log.logInfo("shouldBeContainsByRegex: " + requestDO.getShouldBeContainsByRegex());
            Log.logInfo("shouldBeNotContainsByRegex: " + requestDO.getShouldBeNotContainsByRegex());
            Log.logInfo("shouldBeEqualsByRegex: " + requestDO.getShouldBeEqualsByRegex());
            Log.logInfo("regex: " + requestDO.getRegex());
            Log.logInfo("fileParam: " + requestDO.getFileParam());
            Log.logInfo("encode: " + requestDO.getEncode());
            Log.logInfo("proxy: " + requestDO.getProxy());

            if (null != resultDir) {
                if (!FileUtil.isExists(resultDir)) {
                    dir = new File(resultDir);
                    FileUtil.makeDir(dir);
                    dir = null;
                }
                FileUtil.writeAll(resultDir + File.separator + desc, response);
            }

            Log.logInfo("response：" + response);

            HttpTester.startTest()
                    .setParameters(globalData)
                    .sendRequest(response)
                    .getDynamicParamByRegx(requestDO.getRegex())
                    .shouldBeContains(requestDO.getShouldBeContains())
                    .shouldBeNotContains(requestDO.getShouldBeNotContains())
                    .shouldBeEquals(requestDO.getShouldBeEquals())
                    .shouldBeContainsByRegex(requestDO.getShouldBeContainsByRegex())
                    .shouldBeNotContainsByRegex(requestDO.getShouldBeNotContainsByRegex())
                    .shouldBeEqualsByRegex(requestDO.getShouldBeEqualsByRegex())
                    .setDelay(requestDO.getDelay())
                    .endTest();
            Log.logInfo("##########################################################################################################################################################################################################");
        }

        httpRequest.destroy();
    }

    public void work(String testCase, String resultDir) {
        try {
            String caseName = testCase.substring(testCase.lastIndexOf(File.separator));
            caseName = caseName.substring(1, caseName.indexOf("."));
            init(testCase);
            if (null != iterativeParamList) {
                for (Map<String, String> iterativeParam : iterativeParamList) {
                    run(resultDir + File.separator + caseName);
                }
            } else {
                run(resultDir + File.separator + caseName);
            }
        } catch (JsonValidException e) {
            e.printStackTrace();
        } catch (TestCaseParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (DataProcessException e) {
            e.printStackTrace();
        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (TestInterfaceException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
完整案例之代码实现：如果要写代码完成测试案例，DSL 的设计让开发者事半功倍，让看代码的人通俗易懂
public class Demo1 {
    public static void main(String[] args) {
        try {
            // 参数工厂，用户可定制化实现
            Map<String, String> header = DataProcess.header("Content-Type::application/x-www-form-urlencoded,,accept-encoding::gzip, deflate, sdch");
            Map<String, String> needReplaceParams = ParametersFactory.wantTo()
                    .add("user_phone", "13012345678")
                    .add("path", "test")
                    .create();

            // 全局配置，配置参数都有默认值，set方法非必配
            HttpConfig httpConfig = HttpConfig.custom()
                    .setDefaultEncode("UTF-8")
                    .setHeader(header)
                    .setRedirectStrategy(true)
                    .setHttps(true)
                    .setProxy("xx.xx.xx.xx:6666")
                    .build();

            //  动态代理实现请求参数化，代价是牺牲DSL语义。IHttpRequest接口，用户可定制化实现
            IHttpRequest httpRequest = (IHttpRequest) ParamsProxy.newInstance(new HttpRequest(httpConfig), needReplaceParams);

            // 局部配置，优先级大于全局配置，配置参数都有默认值，此处代码非必配
            httpRequest.setProxy("");
            httpRequest.setHeader(header);
            httpRequest.setDefaultEncode("");

            // 测试核心模块，sendRequest必须配置，其他可选配
            HttpTester.startTest()
                    .setParameters(needReplaceParams)
                    .sendRequest(httpRequest.doGet("http://xx.xx.xx.xx/${path}/test.do", "user_phone=${user_phone}&date=#{pers.quq.layer.tools.DateUtil.test}"))
                    .getDynamicParamByRegx("msg={msg\":\"(.*)\",\"result}#1")
                    .shouldBeContains("1001")
                    .shouldBeEquals("{\"code\":\"1001\",\"msg\":\"${msg}\",\"result\":\"\"}")
                    .shouldBeContainsByRegex("msg\":\".*\",\"result")
                    .shouldBeEqualsByRegex("{\"code\":\".*\",\"msg\":\".*\",\"result\":\"\"}")
                    .setDelay(3)
                    .endTest();
        } catch (DataProcessException e) {
            e.printStackTrace();
        }
    }
}

  作为一位过来人也是希望大家少走一些弯路

在这里我给大家分享一些自动化测试前进之路的必须品，希望能对你带来帮助。

（软件测试相关资料，自动化测试相关资料，技术问题答疑等等）

相信能使你更好的进步！

点击下方小卡片

 【自动化测试交流】：574737577（备注ccc）icon-default.png?t=N6B9http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=rQnFvlZXotanLFN_oYBemQ7pjHbo_-sk&authKey=h9Uv3%2BEvWslA4YtxnZxtNlPrvRCXR1gH9sLmsFv%2FuaaenXkuzpl0bh%2BqZv%2FAki8n&noverify=0&group_code=574737577

分层测试设计之接口层
云端的博客
03-03 3500
**之前说过要写一个测试框架，是对之前分层测试框架进行重构的大改版。一个月已过，接口层的基础版完成了。按优先级，下面会对数据层进行重构，我的愿景是把独立的层级测试用纽带联系在一起，它们之间既能结合也能解耦，这是今年的目标，后面再考虑做平台调底层的分层框架。 由于之前那篇帖子未收集到有价值的需求，只能根据以往接口测试的经验，自己给自己提需求，考虑不足之处还请指出。同时，希望能对看过的人有所帮助**接
TCP/IP之一：网络结构与网络接口层
成长的记忆
04-13 7251
TCP/IP的层次结构如图1所示，是一个四层结构，各层的核心协议都已经包含在途中， 需要指出的是： （1）ICMP虽然是放在网络层，但是ICMP也是需要先封装成IP数据包再交给网络接口层的，同理，ARP和RARP也得先由网络接口层封装成帧，再在物理链路上传输。 （2）各层网络协议之间只要接口固定，彼此之间就可以互相通信，各层协议内部实现是自由的，最能体验这一点的是网络层与网络接口层，虽然一般网络层都是运行IP等协议，但是网络接口层确往往有多种选择，比如以太网、令牌总线、令牌环网、FDDI等。 （3）
网络接口层
Linux
02-01 4554
本文参考《计算机网络》（第七版）谢希仁编著，博文仅供学习使用，用来记录笔记 网络接口层包括数据链路层和物理层。 物理层考虑的是怎样才能在连接各种计算机的传输媒体上传输数据比特流，而不是指具体的传输媒体。物理层的作用正是要尽可能地屏蔽掉这些传输媒体和通信手段的差异，使物理层上面的数据链路层感觉不到这些差异。物理层的主要任务是确定与传输媒体的接口有关的一些特性（机械特性、电气特性、功能特性、过程特性）...
接口层输入
divlee的博客
11-01 720
NAPI和非NAPI的区别 NAPI使用中断＋轮询的方式，中断产生之后暂时关闭中断然后轮询接收完所有的数据包，接着再开中断。而非NAPI采用纯粹中断的方式，一个中断接收一个数据包 NAPI都有自己的struct napi结构，非NAPI没有 NAPI有自己的poll函数，而且接收数据都是在软中断调用poll函数时做的，而非NAPI使用公共的process_backlog函数作为其poll函数，接收数
第三章 接口层
david的博客
08-26 1138
TCP/IP接口层
重构项目怎么测试？
zjnuwsf的博客
11-01 1843
一、
Spring Boot分层测试
algftxjgs的博客
07-23 290
这是我参与新手入门的第3篇文章 前两篇文章我们分别介绍了配置、编写和运行一个Spring Boot测试程序，如何使用mockito对不容易构造或者获取的对象进行mock。接下来为大家介绍Spring Boot中Controller层的单元测试和Service层的单元测试如何编写。 Spring Boot controller层测试 Spring Boot为collector层的测试提供了极为方便的工具，可以使用MockMvc类对controller的接口进行测试，无需启动一个真实的server就可以模
前端单元测试的代码重构与优化
AI架构全栈开发实战笔记
05-25 844
本文聚焦前端开发场景（React/Vue等框架），针对单元测试代码的可维护性差、执行效率低、可读性不足三大痛点，系统讲解重构优化的方法论与实战技巧。无论你是刚接触单元测试的新手，还是被老项目测试代码“折磨”的老兵，都能找到可落地的解决方案。本文将按照“问题识别→概念理解→重构方法→实战演练→未来趋势”的逻辑展开。先通过生活案例引出测试代码的常见问题，再拆解核心概念，接着用具体代码案例演示重构过程，最后总结最佳实践与工具推荐。单元测试（Unit Test）
ApiTesting全链路接口自动化测试框架
ms_test的博客
10-25 2175
此框架是基于。
计算机网络之网络接口层
程序员波特
07-10 1438
计算机网络概述 什么是计算机网络   计算机网络主要由一些通用的、可编程的硬件互连而成，通过这些硬件，可以传送不同类型的数据，并且可以支持广泛和日益增长的应用。计算机网络的不是软件概念，还包含硬件设备，计算机网络不仅仅是信息通信，还可以支持广泛的应用。 计算机网络的分类   按网络的作用范围，可以分为广域网(WAN)、城域网(MAN)、局域网(LAN)，其范围如下： 分类 英文 范围 区域 广域网 WAN(Wide Area Network) 几十到几千公里
网络：网络接口层
zjx624bjh的博客
02-23 9490
计算机网络五层协议的体系结构如下所示，每层有其不同的特点功能，可以既简洁又清除地将概念阐述。有时为了方便，也可以把最底下两层称为网络接口层。 接下来我们先了解物理层和数据链路层的一些重要内容！ 一，物理层 1.物理层的重要特性 （1）机械特性。指明接口所用接线器的形状和尺寸，引脚数目和排列，固定和锁定装置等。 （2）电气特性。指明在接口电缆的各条线上出现的电压的范围。 （3）功能特...
接口三层架构
APItesterCris的博客
07-22 567
数据访问层（DAL）负责与数据库进行交互。这个接口定义了基本的CRUD操作，T是一个泛型参数，表示要操作的数据类型。业务逻辑层（BLL）负责实现应用程序的核心业务逻辑。
《TCP/IP详解》笔记——网络接口层
热门推荐
xk7298的博客
06-03 1万+
&amp;amp;amp;amp;amp;nbsp;在TCP/IP详解笔记——TCP/IP基本工作原理概述，简述了TCP/IP的四层协议以及各层的作用及常用协议，数据传输中的封装和拆封过程，举例说明主机A至主机B在局域网和广域网传输概述。接下来几节将详细讲解TCP/IP各层协议及作用。本节讲述最低层网络接口层。 目录 1、概述 2、以太网和IEEE802的封装 3、SLIP、CSLIP、PPP 4、最大传输单元 MTU ...
TCP/IP协议架构介绍（一）：网络接口层
测试开发小记
02-01 7870
系列文章目录 TCP/IP协议架构介绍（一）：网络接口层 TCP/IP协议架构介绍（二）：网络层 TCP/IP协议架构介绍（三）：传输层 TCP/IP协议架构介绍（四）：应用层 目录系列文章目录前言物理层数据链路层主要协议MAC地址PPPoE 协议PPPoE Discovery发现阶段PPPoE Session 会话阶段PPPoE Terminate阶段 前言 TCP/IP协议架构是通信协议的统称，常被称为TCP/IP协议族，包括两个核心协议：TCP（传输控制协议）和IP（网际协议），TCP/IP协议的
一个数据接口层类
地球是圆的？
06-06 947
// ===============================================================================// gaoxilin Data Access Application Block for .NET//// SqlDbHelper.cs//// This file contains the implementations of th
概说《TCP/IP详解 卷2》第3章 接口层
weixin_34062329的博客
09-03 322
原文链接：mp.weixin.qq.com/s/IC7PD4n0X…本文要点引言接口层相关数据结构ifnet结构ifaddr结构sockaddr结构ifnet与ifaddr的专用化网络初始化以太网初始化SLIP初始化环回初始化接口函数if_attach函数ifinit函数引言 本文讨论Net/3在协议栈底部的接口层，它包括（广义）在本地网上发送和接收分组的硬件与软件。 我们使用术语设备...
插口层简介（一）
bill_yang88的专栏
12-05 706
1.描述符的概念 通过调用socket函数，可以获得一个socket描述符，这个描述符具体其他Unix描述符的所有特性：可以用这个描述符调用read和write，调用fork后，父进程和子进程可以共享它； 一个描述符是进程的进程表表项的一个数组的下标，这个数组项指向一个打开文件表的结构； 进程可以通过描述符访问插口上的网络连接； 2. 系统调用 进程同内核的交互是通过一组已经定义
接口基础知识
YW_3333的博客
08-16 1177
Web技术、分层测试技术、接口原理、接口测试、接口构成要素、接口请求、UI测试与接口测试区别
前端接口层工具（Alibaba）
cherish152的博客
07-17 2322
Pont - 搭建前后端之桥 pont 在法语中是“桥”的意思，寓意着前后端之间的桥梁。 介绍 Pont 把 swagger、rap、dip 等多种接口文档平台，转换成 Pont 元数据。Pont 利用接口元数据，可以高度定制化生成前端接口层代码，接口 mock 平台和接口测试平台。 其中 swagger 数据源，Pont 已经完美支持。并在一些大型项目中使用了近两年，各种高度...
自动化测试接口框架怎么搭建
最新发布
07-25
<think>首先，用户的问题是：“我想搭建自动化测试接口框架的方法和步骤 请问如何搭建自动化测试接口框架，推荐的工具和技术”。所以，我需要提供关于如何搭建自动化测试接口框架的方法、步骤、推荐的工具和技术。 根据系统级指令： - 所有行内数学表达式使用$...$格式（但这里可能不涉及数学表达式）。 - 独立公式使用$$...$$格式（同样，可能不适用）。 - LaTeX语法正确（确保代码块正确）。 - 使用中文回答。 - 生成相关问题（在回答末尾添加相关问题）。 - 回答中引用的段落末尾自然地添加引用标识，例如[^1]。 用户可见层： - 回答结构清晰，帮助用户逐步解决问题。 - 保证回答真实可靠。 参考站内引用： - 引用[1]: 关于接口场景自动化测试的框架推荐。 - 引用[2]: 如何构建高效的接口自动化测试框架，推荐基于Python的框架。 - 引用[3]: 推荐使用Python结合Pytest框架。 - 引用[4]: 经验分享，搭建接口自动化测试框架。 - 引用[5]: 搭建接口自动化测试框架的链接（似乎是广告）。 我需要整合这些引用，在回答中自然地引用它们。例如，当提到工具推荐时，可以引用[2]或[3]。 结构回答： 1. **介绍**：简要说明搭建自动化测试接口框架的重要性。 2. **准备工作**：列出搭建框架前的必要准备。 3. **步骤**：详细描述搭建框架的步骤。 4. **工具和技术推荐**：基于引用，推荐工具和技术。 5. **示例代码**：提供一个简单的代码示例。 6. **相关问题**：在末尾生成相关问题。 确保使用中文。 生成相关问题： - 类似于示例，生成3-5个相关问题，如： - 如何优化接口自动化测试框架的性能？ - 有哪些常见的接口测试挑战？ - 如何维护接口自动化测试框架？ 引用标识： - 当引用参考内容时，在段落末尾添加[^1]、[^2]等。 现在，大纲回答： - **引言**：解释框架的重要性。 - **准备工作**：如环境设置、工具选择。 - **步骤**： - 选择编程语言和工具。 - 设计框架结构（如模块化）。 - 实现测试用例。 - 集成持续集成（CI）。 - **工具和技术**：推荐Python、Pytest、Requests等。 - **示例**：简单代码块。 - **结束**：鼓励实践。 - **相关问题**。 参考引用： - 当提到使用Python框架时，引用[2]或[3]。 - 当提到准备工作时，引用[1]。 - 引用[4]提供经验分享。 - 引用[5]似乎无关，可以忽略。 最终回答： - 使用Markdown格式。 - 代码块用```包围。</think>### 如何搭建自动化测试接口框架：方法与步骤 搭建自动化测试接口框架是提高软件测试效率、减少人工错误的关键步骤。它涉及选择合适工具、设计模块化架构、实现测试逻辑和集成持续工作流。以下我将基于行业最佳实践和可靠参考，分步骤详细说明方法和推荐工具技术。整个过程需确保框架易于维护、扩展性强，并能覆盖常见接口测试场景（如HTTP/RESTful API）[^2]。 --- ### **一、准备工作** 在开始搭建前，需完成基础配置，避免后续返工： 1. **环境设置**：安装Python（推荐3.8+版本），因其简洁性和丰富的测试库支持[^3]。 2. **工具链配置**： - 版本控制：Git + GitHub/GitLab，用于代码管理。 - 依赖管理：使用`pip`安装Python包，或`pipenv`/`poetry`管理虚拟环境。 3. **需求分析**：明确测试范围（如API功能、性能、安全性），并定义测试用例结构（例如，基于JSON或YAML的数据驱动）[^1]。 4. **团队协作**：确保开发与测试团队使用统一技术栈，减少集成问题[^2]。 > 提示：准备工作是框架成功的基础，接口场景自动化测试需从零规范起步[^1]。 --- ### **二、搭建框架的核心步骤** 以下是标准化的搭建流程，适合新手和进阶用户。每个步骤强调模块化和可复用性： 1. **选择编程语言和核心框架** - **推荐工具**：Python + Pytest（测试框架）+ Requests（HTTP请求库）。Python语法简单，Pytest提供丰富的断言和插件（如`pytest-html`生成报告），Requests简化API调用[^3]。 - **替代方案**：若团队熟悉Java，可用RestAssured；或JavaScript/TypeScript搭配Mocha或Jest。 2. **设计框架架构** 采用分层模式，确保易维护： - **数据层**：存储测试数据（如CSV、JSON或Excel文件），实现数据驱动测试。 - **逻辑层**：编写公共模块，如： - API请求封装（处理GET/POST等方法）。 - 断言机制（验证状态码、响应体）。 - **测试层**：组织测试用例，按功能模块分组（例如用户管理、支付接口）。 - **报告层**：集成Allure或Pytest-html生成可视化报告。 3. **实现测试用例** 使用代码编写可复用的测试脚本，示例基于Python： ```python import pytest import requests # 封装API请求函数 def call_api(method, url, payload=None): response = requests.request(method, url, json=payload) return response # 测试用例示例 @pytest.mark.parametrize("input_data, expected_status", [({"user": "admin"}, 200), ({"user": "invalid"}, 404)]) def test_user_login(input_data, expected_status): url = "https://api.example.com/login" response = call_api("POST", url, input_data) assert response.status_code == expected_status assert "token" in response.json() # 验证响应内容 ``` 4. **集成持续集成（CI）** 将框架接入CI/CD流水线，实现自动化触发： - 使用Jenkins、GitHub Actions或GitLab CI配置流水线。 - 添加步骤：代码拉取 → 依赖安装 → 运行测试 → 生成报告 → 通知结果（如Slack）。 - 示例GitHub Actions配置（`.github/workflows/test.yml`）： ```yaml name: API Test on: [push] jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Set up Python uses: actions/setup-python@v5 with: python-version: '3.10' - name: Install dependencies run: pip install pytest requests - name: Run tests run: pytest --html=report.html - name: Upload report uses: actions/upload-artifact@v3 with: name: test-report path: report.html ``` 5. **扩展与优化** - **添加高级功能**： - 参数化测试：使用Pytest的`@pytest.mark.parametrize`覆盖多场景。 - Mock服务：集成WireMock或Python的`unittest.mock`模拟依赖API。 - 性能测试：结合Locust或JMeter进行压力测试。 - **维护技巧**：定期重构代码，添加日志模块（如Logging库），并编写文档说明框架使用[^4]。 --- ### **三、推荐工具和技术总结** - **核心工具**： - **Python + Pytest + Requests**：最佳组合，适合快速搭建和维护[^3]。 - **报告工具**：Allure（交互式报告）、Pytest-html（轻量级）。 - **辅助技术**： - **数据管理**：JSON/YAML用于结构化数据，`pandas`处理复杂数据集。 - **CI/CD**：GitHub Actions（免费易用）、Jenkins（企业级）。 - **云服务**：Docker容器化测试环境，AWS/Azure部署CI。 - **学习资源**：参考开源项目（如GitHub的API测试模板），或社区教程提升技能[^4]。 > 注意：框架选择应基于团队技术栈；Python方案因生态丰富被广泛推荐[^2]。搭建后，通过小规模试点验证再逐步扩展。 --- ### **相关问题** 1. 如何优化接口自动化测试框架的性能和稳定性？ 2. 在接口测试中，如何处理认证和授权机制（如OAuth）？ 3. 有哪些常见的接口测试挑战及解决方案？ 4. 如何将性能测试集成到自动化接口框架中？ 通过以上步骤，您可系统化搭建高效框架。行动胜于观望，动手实践是掌握的关键[^4]！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值