基于OpenAPI 3.0.1规范的接口定义文件实现的一种单参数异常自动化测试工具（带异常场景Trace信息）— 第2期：OpenAPI解析为模型

最新推荐文章于 2025-04-20 11:23:54 发布
原创 最新推荐文章于 2025-04-20 11:23:54 发布 · 104 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#自动化 #运维

说明

在生成用例之前，需要将OpenAPI 3.0.1 的文件解析为对应的Api和Parameter模型

解析


import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
import com.snycedu.platform.test.model.Api;
import com.snycedu.platform.test.model.Parameter;

import java.io.File;
import java.math.BigDecimal;
import java.util.*;

public class OpenApiParser {

    public static List<Api> parseOpenApi(String yamlFilePath) throws Exception {
        ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
        Map<String, Object> openApiMap = mapper.readValue(new File(yamlFilePath), Map.class);

        // 全局组件（用于解析$ref）
        Map<String, Object> components = (Map<String, Object>) openApiMap.get("components");
        Map<String, Object> schemas = components != null ? (Map<String, Object>) components.get("schemas") : new HashMap<>();
        Map<String, Object> parameters = components != null ? (Map<String, Object>) components.get("parameters") : new HashMap<>();

        List<Api> apiList = new ArrayList<>();

        // 遍历所有路径
        Map<String, Object> paths = (Map<String, Object>) openApiMap.get("paths");
        for (String apiPath : paths.keySet()) {
            Map<String, Object> pathItem = (Map<String, Object>) paths.get(apiPath);

            // 遍历所有HTTP方法（get/post/put等）
            for (String method : pathItem.keySet()) {
                if (method.startsWith("x-")) continue; // 跳过扩展字段

                Map<String, Object> operation = (Map<String, Object>) pathItem.get(method);
                Api api = new Api();
                api.setApi(apiPath);
                api.setMethod(method.toUpperCase());
                api.setPath(new ArrayList<>());
                api.setQuery(new ArrayList<>());
                api.setBody(new ArrayList<>());

                // ----------------- 1. 解析路径参数 -----------------
                // 从URL路径中提取显式声明的路径参数（如 /api/{id}）
                extractPathParamsFromUrl(apiPath, api.getPath());

                // 解析OpenAPI定义的parameters中的路径参数（覆盖自动提取的值）
                parseOperationParameters(operation, api, "path", parameters, schemas);

                // ----------------- 2. 解析查询参数 -----------------
                parseOperationParameters(operation, api, "query", parameters, schemas);

                // ----------------- 3. 解析请求体 -----------------
                Map<String, Object> requestBody = (Map<String, Object>) operation.get("requestBody");
                if (requestBody != null) {
                    Map<String, Object> content = (Map<String, Object>) ((Map<String, Object>) requestBody.get("content")).values().iterator().next();
                    Map<String, Object> schema = (Map<String, Object>) content.get("schema");
                    List<Parameter> bodyParams = parseSchema(schema, schemas, "#/components/schemas/", "");
                    api.getBody().addAll(bodyParams);
                }

                apiList.add(api);
            }
        }

        return apiList;
    }

    // 从URL路径（如 /users/{id}/detail）提取路径参数
    private static void extractPathParamsFromUrl(String apiPath, List<Parameter> pathParams) {
        String[] segments = apiPath.split("/");
        for (String segment : segments) {
            if (segment.startsWith("{") && segment.endsWith("}")) {
                String paramName = segment.substring(1, segment.length() - 1);
                Parameter param = new Parameter();
                param.setName(paramName);
                param.setLocation(paramName);
                param.setParamType("string"); // 默认类型，实际类型由parameters定义覆盖
                param.setRequired(true);      // 路径参数必填
                pathParams.add(param);
            }
        }
    }

    // 解析操作中的参数（path/query/header等）
    private static void parseOperationParameters(
            Map<String, Object> operation,
            Api api,
            String paramIn,
            Map<String, Object> globalParameters,
            Map<String, Object> schemas
    ) {
        List<Map<String, Object>> parameters = (List<Map<String, Object>>) operation.get("parameters");
        if (parameters == null) return;

        for (Map<String, Object> paramDef : parameters) {
            // 处理参数引用（如 $ref: '#/components/parameters/UserId'）
            if (paramDef.containsKey("$ref")) {
                String ref = ((String) paramDef.get("$ref")).substring("#/components/parameters/".length());
                paramDef = (Map<String, Object>) globalParameters.get(ref);
            }

            String inType = (String) paramDef.get("in");
            if (!paramIn.equals(inType)) continue;

            Parameter param = new Parameter();
            param.setName((String) paramDef.get("name"));
            param.setLocation(param.getName());
            param.setRequired(Boolean.TRUE.equals(paramDef.get("required")));

            // 解析参数类型和约束
            Map<String, Object> schema = (Map<String, Object>) paramDef.get("schema");
            if (schema != null) {
                param.setParamType((String) schema.get("type"));
                applySchemaConstraints(param, schema);
                // 处理枚举
                if (schema.containsKey("enum")) {
                    param.setEnums((List<?>) schema.get("enum"));
                }
                // 处理嵌套对象/数组
                if ("object".equals(param.getParamType()) || "array".equals(param.getParamType())) {
                    param.setRefBody(parseSchema(schema, schemas, "#/components/schemas/", ""));
                }
            }

            // 添加到对应的参数列表
            if ("path".equals(inType)) {
                api.getPath().add(param);
            } else if ("query".equals(inType)) {
                api.getQuery().add(param);
            }
        }
    }

    private static List<Parameter> parseSchema(Map<String, Object> schema,
                                               Map<String, Object> schemas,
                                               String refPrefix,
                                               String parentPath) { // 新增parentPath参数
        List<Parameter> parameters = new ArrayList<>();

        // 处理$ref引用
        if (schema.containsKey("$ref")) {
            String ref = ((String) schema.get("$ref")).substring(refPrefix.length());
            Map<String, Object> refSchema = (Map<String, Object>) schemas.get(ref);
            return parseSchema(refSchema, schemas, refPrefix, parentPath); // 传递当前父路径
        }

        String type = (String) schema.get("type");
        List<String> required = (List<String>) schema.get("required");

        if ("object".equals(type)) {
            Map<String, Object> properties = (Map<String, Object>) schema.get("properties");
            for (String propName : properties.keySet()) {
                // 构建当前参数的完整路径
                String currentPath = parentPath.isEmpty() ? propName : parentPath + "." + propName;

                Map<String, Object> propSchema = (Map<String, Object>) properties.get(propName);
                Parameter param = createParameter(propName, propSchema, schemas, required, refPrefix, currentPath);
                parameters.add(param);
            }
        }

        return parameters;
    }

    private static Parameter createParameter(String name,
                                             Map<String, Object> schema,
                                             Map<String, Object> schemas,
                                             List<String> required,
                                             String refPrefix,
                                             String currentPath) { // 新增currentPath参数
        Parameter param = new Parameter();
        param.setName(name);
        param.setLocation(currentPath); // 直接使用构建好的路径

        String type = (String) schema.get("type");
        param.setParamType(type);
        param.setRequired(required != null && required.contains(name));
        applySchemaConstraints(param, schema);

        // 处理嵌套结构（递归调用时传递当前路径）
        if ("object".equals(type)) {
            param.setRefBody(parseSchema(schema, schemas, refPrefix, currentPath)); // 传递当前路径
        } else if ("array".equals(type)) {
            Map<String, Object> items = (Map<String, Object>) schema.get("items");
            param.setRefBody(parseSchema(items, schemas, refPrefix, currentPath)); // 传递当前路径
        } else if (schema.containsKey("$ref")) {
            String ref = ((String) schema.get("$ref")).substring(refPrefix.length());
            Map<String, Object> refSchema = (Map<String, Object>) schemas.get(ref);
            param.setParamType("object");
            param.setRefBody(parseSchema(refSchema, schemas, refPrefix, currentPath)); // 传递当前路径
        }

        return param;
    }

    // 应用Schema约束（最大值、正则等）
    private static void applySchemaConstraints(Parameter param, Map<String, Object> schema) {
        if (schema.containsKey("maximum")) {
            param.setMaximum(new BigDecimal(schema.get("maximum").toString()));
        }
        if (schema.containsKey("minimum")) {
            param.setMinimum(new BigDecimal(schema.get("minimum").toString()));
        }
        if (schema.containsKey("maxLength")) {
            param.setMaxLength((int) schema.get("maxLength"));
        }
        if (schema.containsKey("minLength")) {
            param.setMinLength((int) schema.get("minLength"));
        }
        if (schema.containsKey("pattern")) {
            param.setPattern((String) schema.get("pattern"));
        }
        if(schema.containsKey("enum")){
            param.setEnums((List<?>) schema.get("enum"));
        }
    }
}

编写测试

package com.snycedu.platform.test;

import com.alibaba.fastjson.JSON;
import com.snycedu.platform.test.model.Api;
import com.snycedu.platform.test.model.TestCaseScenario;
import com.snycedu.platform.test.parse.OpenApiParser;

import java.util.List;

public class Test {
    public static void main(String[] args) throws Exception {
        // 构造基础请求负载
        List<Api> apiList = OpenApiParser.parseOpenApi("/Users/xiyubaby.17/Desktop/04workspace/testtools/src/main/resources/article-tmp.yaml");
        System.out.println(JSON.toJSONString(apiList));
    }
}

输出测试结果

[{
	"api": "/api/v1/article",
	"body": [{
		"location": "title",
		"maxLength": 32,
		"minLength": 10,
		"name": "title",
		"paramType": "string",
		"required": true
	}, {
		"enums": ["CSDN", "HEAD_NEWS"],
		"location": "type",
		"name": "type",
		"paramType": "string",
		"required": true
	}, {
		"location": "content",
		"name": "content",
		"paramType": "object",
		"refBody": [{
			"location": "content.id",
			"maximum": 99999999,
			"minimum": 100,
			"name": "id",
			"paramType": "integer",
			"required": false
		}, {
			"enums": ["MARKDOWN", "TEXT"],
			"location": "content.format",
			"name": "format",
			"paramType": "string",
			"required": false
		}],
		"required": true
	}],
	"method": "POST",
	"path": [],
	"query": []
}]
OPENAPI3.0 与 SpringBoot 开发实战: 新型高效开发模式,实现代码与API分离,高效开发,开发必看!!!
码小呆的博客
07-29 1万+
Open3.0 开发模式不仅仅是对于开发来说,对于整个公司都是有利的,开发的api逻辑清晰,前端对接高效,每个字段都有注释统一的result api风格,对外提供api更加便捷
OpenApi3.0注解说明
shgg2917的博客
11-09 2834
本文详细介绍了OpenAPI规范中的Swagger注解，包括@Tag、@Hidden、@ApiResponse、@Schema、@Operation、@Parameter等，用于描述API的元数据、响应信息、实体类属性以及控制器和方法上的参数。这些注解对于构建和文档化RESTfulAPI至关重要。注解代码位于 io.swagger.v3.oas.annotations 包里。OpenAPI 规范 - 中文版swagger 2swagger 3@Api@Tag 或者 Tags。
OpenAPI 3.0学习笔记
最新发布
佩奇的技术笔记
04-20 1472
OpenAPI（前身Swagger）是用于描述和定义RESTful API的。
使用openApi3.0生成接口文档
weixin_46096297的博客
04-17 519
swagger、openApi3.0、接口文档
OpenAPI 3.0 规范-食用指南
m0_56069948的博客
06-26 6325
OpenAPI 3.0 规范由 8 个根对象组成：OpenAPI 的其余功能都是基于这 8 根对象扩展而成，凡是包含以上对象并且扩展名为 ， 的文件，我们可以将其视为符合 OpenAPI 规范的描述文件 ，你可以在：API Editor 在线编辑器 中来验证你的 OpenAPI 文件是否符合规范，以下我们就主要介绍 8 个根对象的使用和扩展方法openapi 是最简单也是最基础的属性，我们为 OpenAPI 添加第一个根对象属性，指定使用的规范版本： 然后继续补充信息 一个极简的 OpenAPI 文件就诞生
OpenAPI指南
热门推荐
xiaoyi52的专栏
11-07 2万+
OpenAPI指南 基本介绍 什么是OpenAPI OpenAPI规范(以前叫swagger规范)是一个接口文档规范，它用一个文件来描述API接口，包括： 可用的api接口(如/users) 和接口方法 (GET /users, POST /users) 输入和输出参数 鉴权方法 联系信息, 代码许可, 使用条款和其他信息等. 文件可是可以是json或yaml的，完整的规范参见: OpenAPI 3.0 Specification 什么是swagger Swagger is a set of open-
探索未来API开发：OpenAPI 3.0与TypeScript的完美结合 —— `openapi3-ts`
gitblog_00064的博客
04-20 727
探索未来API开发：OpenAPI 3.0与TypeScript的完美结合 —— openapi3-ts 在这个数字化的时代，API已经成为软件系统之间交流的核心。而随着OpenAPI 3.0规范的推出，API设计和文档编写变得更加标准化和高效。今天我们要介绍的项目——，正是基于OpenAPI 3.0规范，利用TypeScript的强大类型系统实现的一个工具库，旨在帮助开发者更好地管理和操作他们的...
Swagger OpenAPI 3.0.0 规范（中文版）
Dr.叶子的博客
07-22 1万+
开放API规范 版本 3.0.0 The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “NOT RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in BCP 14 RFC2119 RFC8174 when, and onl
SpringBoot 3.0整合OpenAPI使用教程
竹林幽深
11-09 3339
原创 Web开发札记发表于江苏收录于合集#SpringBoot6个温馨提示Spring Boot 3 只支持OpenAPI3规范Knife4j提供的starter已经引用springdoc-openapi的jar，开发者需注意避免jar包冲突JDK版本必须 >= 17。
SpringBoot基于OpenAPI3的接口文档管理快速集成和使用
欢迎关注公众号“雨林寻北”，添加个人微信codetrend（备注技术）。
06-02 1789
本文主要简单介绍SpringCloud2023中进行接口文档管理，方便前后端开发和文档维护。文档管理工具基于开源的knife4j封装的openapi3。
openapi 3.0 规范说明
lxxxl0001的博客
11-01 2563
前言 任何项目在开发完成后都需要编写接口文档,而手动编写文档即消耗人力又可能由于维护不及时导致文档和项目版本不一致,反之如果使用swagger在项目更新的同时自动生成相应的接口文档则可以避免上述问题。由于swagger2.0的规范依赖于openapi 3.0版本的规范，所以在使用swagger生成文档前，了解和掌握openapi的规范是必要的,所以我下边列出了openapi文档的常用示例并赋予中文说明: 官方文档（中文版） The OpenAPI Specification | 开放API规范 示例 ope
Django 快速整合 Swagger：实用步骤和最佳实践
nhb687096的博客
01-04 2245
Swagger 是一种用于的开源框架，可以帮助开发者快速构建和文档化 API。Swagger 文档提供了一种自动生成和可视化 API 文档的方式，使得 API 的设计和使用更加简单和易懂。Swagger 文档通过描述 API 的路径、参数、请求体、响应和错误码等信息，让开发者可以快速了解 API 的设计和使用方式，方便开发者进行 API 的集成和调用。Swagger 2.0 是 Swagger 规范的第二个版本，引入了许多新的功能和改进。
Spring Cloud Gateway 网关整合 Knife4j 4.3 实现微服务接口文档聚合
有来技术
10-27 1万+
本文介绍了如何通过整合 Knife4j 4.3 和 Spring Cloud，以及利用 Spring Cloud Gateway 网关聚合各个服务的接口文档，实现对 youlai-mall 新版本的接口文档统一管理。同时，通过接口文档测试 Spring Authorization Server 的自定义扩展的 OAuth2 密码模式的认证授权流程。
简单易懂： Go 自动生成 Swagger API 文档教程
py0007的博客
03-29 1206
作为 Go 语言中支持 Swagger 2.0 和 OpenAPI 3.0 规范的工具之一，go-swagger 主要用于快速构建、记录并测试 RESTful API。允许开发者自动化生成客户端和服务端代码，极大地提高了开发效率和接口的标准化。
OpenApi 3.0.0 文档和 Swagger UI 集成指南
gitblog_00222的博客
04-17 654
OpenApi 3.0.0 文档和 Swagger UI 集成指南 1. 项目介绍 oatpp-swagger 是一个为 oatpp 框架提供的开源项目，它能够生成 OpenApi 3.0.0 文档并为 oatpp 服务集成 Swagger UI。通过这个项目，开发者可以轻松地为他们的 oatpp 应用程序添加强大的 API 文档和交互式的 API 探索界面。 2. 项目快速启动 以下是一个快速启...
基于OpenAPI 3.0.1规范的接口定义文件实现的一种单参数异常自动化测试工具（带异常场景Trace信息）— 第1期：背景与模型设计
因为热爱，所以付出
03-31 309
使用单参数异常算法来生成用例，每个用例保证1个参数异常取值，其他参数符合正常取值。但需考虑特殊场景，例如所有字段缺失，所有字段值为null。如果参数是对象或者数组对象类型，不仅要根据单参数异常规则来递归到对象或者数组对象的叶子节点属性，还要考虑数组是空数组、null取值，对象是空对象、null取值的场景。接口是基于openapi3.0.1规范定义。
OpenAPI 3.0 说明文档
csdn_manong1的博客
04-24 2633
openapiinfoserverspathscomponentssecuritytagsOpenAPI 的其余功能都是基于这 8 根对象扩展而成，凡是包含以上对象并且扩展名为jsonyaml的文件，我们可以将其视为符合OpenAPI 规范的描述文件API Editor 在线编辑器中来验证你的 OpenAPI 文件是否符合规范，以下我们就主要介绍 8 个根对象的使用和扩展方法以上就是一个完整的 OpenAPI 规范的文件的使用说明。
自动化SDK生成工具：基于OpenAPI定义
OpenAPI规范允许开发者以一种简单且直观的方式来描述API的结构和功能，这样就可以被不同的工具和库用于自动化API文档生成、客户端SDK生成、服务器端框架生成等。 2. 自动化SDK生成工具： 通过使用自动化SDK生成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xiyubaby.17

您的鼓励是我创作的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值