apitestgen 1.0.1__tar.gz

apitestgen-1.0.1/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: apitestgen
+Version: 1.0.1
+Summary: 智能测试数据生成器 - 支持 JSON Schema / OpenAPI 的正向和负向测试用例生成
+Home-page: https://github.com/your/apitestgen
+Author: 盼盼
+Author-email: 2063769412@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: jsonschema>=4.0.0
+Requires-Dist: rstr>=3.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# apitestgen
+
+智能 API 测试数据生成器，支持 JSON Schema / OpenAPI 的正向和负向测试用例生成。
+
+## 安装
+
+```bash
+pip install apitestgen
+```
+
+##快速开始
+
+from apitestgen.formats import create_generator
+
+schema = {
+    "type": "object",
+    "required": ["name", "age"],
+    "properties": {
+        "name": {"type": "string", "minLength": 2, "maxLength": 10},
+        "age": {"type": "integer", "minimum": 0, "maximum": 150}
+    }
+}
+
+gen = create_generator(schema)
+
+# 正向生成
+print(gen.generate())
+
+# 多场景
+for v in gen.generates():
+    print(v["label"], v["data"])
+
+# 负向测试
+for case in gen.generate_negative():
+    print(case.sub_case_id, case.data)
+	
+## 特性
+ 正向单次/多场景数据生成
+
+ 负向测试用例生成（边界值、类型错误、枚举违反等）
+
+ Schema 校验
+
+ 组合策略（single/pairwise/combinatorial）
+
+ 支持 JSON Schema 和 OpenAPI

apitestgen-1.0.1/README.md

@@ -0,0 +1,46 @@
+# apitestgen
+
+智能 API 测试数据生成器，支持 JSON Schema / OpenAPI 的正向和负向测试用例生成。
+
+## 安装
+
+```bash
+pip install apitestgen
+```
+
+##快速开始
+
+from apitestgen.formats import create_generator
+
+schema = {
+    "type": "object",
+    "required": ["name", "age"],
+    "properties": {
+        "name": {"type": "string", "minLength": 2, "maxLength": 10},
+        "age": {"type": "integer", "minimum": 0, "maximum": 150}
+    }
+}
+
+gen = create_generator(schema)
+
+# 正向生成
+print(gen.generate())
+
+# 多场景
+for v in gen.generates():
+    print(v["label"], v["data"])
+
+# 负向测试
+for case in gen.generate_negative():
+    print(case.sub_case_id, case.data)
+	
+## 特性
+ 正向单次/多场景数据生成
+
+ 负向测试用例生成（边界值、类型错误、枚举违反等）
+
+ Schema 校验
+
+ 组合策略（single/pairwise/combinatorial）
+
+ 支持 JSON Schema 和 OpenAPI

apitestgen-1.0.1/apitestgen/core/base_generator.py

@@ -0,0 +1,76 @@
+# api/core/generator.py
+"""基础生成器 - 工具方法"""
+
+import random
+import logging
+from typing import Any, Optional, Tuple, List
+
+from .meta import GeneratorMeta
+from .config import GeneratorConfig
+from apitestgen.negative.result import FieldNegativeValue
+logger = logging.getLogger(__name__)
+
+
+class BaseGenerator(metaclass=GeneratorMeta):
+    """基础生成器：工具方法"""
+
+    def __init__(self, field, config: Optional[GeneratorConfig] = None, depth: int = 0, **kwargs):
+        self.field = field
+        self.config = config or GeneratorConfig
+        self.depth = depth
+
+    def generate(self) -> Any:
+        if self.depth > self.config.MAX_DEPTH:
+            return None
+        return self._default_value()
+
+    def _default_value(self) -> Any:
+        return self.config.TYPE_DEFAULTS.get(self.field.type, None)
+
+    def _should_generate_optional(self, rate: float) -> bool:
+        return random.random() < rate
+
+    def _make(self, value) -> Any:
+        return FieldNegativeValue(value=value)
+
+    def parse_numeric_bounds(self) -> Tuple[Optional[float], Optional[float], bool, bool]:
+        return (
+            self.field.minimum,
+            self.field.maximum,
+            bool(self.field.exclusive_minimum),
+            bool(self.field.exclusive_maximum),
+        )
+
+    def generate_field_negative(self, tags: Optional[List[str]] = None) -> List:
+        """自动发现 @negative_case 方法"""
+        if not self.config.enable_negative:
+            return []
+
+        from apitestgen.negative.tag import NegativeTag
+
+        cases = []
+        tag_set = set(tags) if tags else None
+
+        for attr_name in dir(self):
+            method = getattr(self, attr_name, None)
+            if not callable(method):
+                continue
+            if not getattr(method, '_is_negative_method', False):
+                continue
+
+            tag = method._negative_tag
+            if tag_set and tag not in tag_set:
+                continue
+
+            try:
+                result = method()
+                if result and isinstance(result, list):
+                    for fv in result:
+                        fv.sub_case_id = tag
+                        fv.description = getattr(method, '_negative_description', tag)
+                        fv.expected_error_type = NegativeTag.error(tag)
+                    cases.extend(result)
+            except Exception as e:
+                logger.warning(f"{self.__class__.__name__}.{attr_name} 失败: {e}")
+
+        return cases

apitestgen-1.0.1/apitestgen/core/config.py

@@ -0,0 +1,79 @@
+# api/core/config.py
+"""生成器通用配置"""
+
+from typing import Dict, Any
+
+
+class GeneratorConfig:
+    """生成器通用配置"""
+
+    MAX_DEPTH: int = 10
+    OPTIONAL_RATE: float = 1.0  # 1.0=所有字段, 0.0=仅必填
+
+    GENERATE_MODE: str = "single"  # single | combinatorial
+    EXPAND_BOOLEAN: bool = True  # 展开布尔 True/False
+    EXPAND_ENUM: bool = True  # 展开枚举所有值
+    EXPAND_TUPLE: bool = True  # 展开元组数组
+    EXPAND_NESTED_REQUIRED: bool = True  # 展开嵌套必填
+    MAX_COMBINATIONS: int = 100  # 最大组合数
+    INCLUDE_EMPTY: bool = True  # 输出空对象/空数组
+    # ========== 组合策略 ==========
+    COMBINE_MODE: str = "single"  # single | pairwise | combinatorial
+
+    # ========== 校验 ==========
+    ENABLE_VALIDATION: bool = False  # 是否启用 Schema 校验
+
+
+    # 字符串
+    DEFAULT_MIN_LENGTH: int = 0
+    DEFAULT_MAX_LENGTH: int = 100
+    STRING_CHARSET: str = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+    DEFAULT_STRING_MAX_LEN: int = 50
+    DEFAULT_PATTERN_STRING_MAX_LEN: int = 256
+    MAX_STRING_LENGTH_INCREMENT: int = 20
+    AX_PATTERN_ATTEMPTS: int = 100
+    INVALID_CHARSET: str = "!@#$%^&*()_+-=[]{}|;:',.<>?/~`"
+
+
+    # 数组
+    DEFAULT_MIN_ITEMS: int = 0
+    DEFAULT_MAX_ITEMS: int = 10
+    EXPAND_BOOLEAN: bool = True
+    EXPAND_TUPLE_ARRAY: bool = True
+    EXPAND_NESTED_REQUIRED: bool = True  # 嵌套必填
+    EXPAND_IF_THEN_ELSE: bool = True  # if-then-else 分支
+    EXPAND_ONEOF: bool = True  # oneOf 分支
+
+    # 数值
+    DEFAULT_INT_MIN: int = -10000
+    DEFAULT_INT_MAX: int = 10000
+    DEFAULT_NUM_MIN: float = -1000000.0
+    DEFAULT_NUM_MAX: float = 1000000.0
+    DEFAULT_PRECISION: int = 10
+
+    # 精度
+    EPSILON: float = 1e-9
+
+    # 负向测试
+    enable_negative: bool = True
+    max_cases_per_tag: int = 1
+    boundary_offset_integer: int = 1
+    boundary_offset_number: float = 0.1
+    boundary_offset_string: int = 1
+    boundary_offset_array: int = 1
+
+    # 类型默认值
+    TYPE_DEFAULTS: Dict[str, Any] = {
+        'string': '', 'integer': 0, 'number': 0.0,
+        'boolean': False, 'array': [], 'object': {}, 'null': None,
+    }
+
+    WRONG_TYPE_MAP: Dict[str, list] = {
+        'string': [123, 1.5, True, [], {}, None],
+        'integer': ["not_int", 1.5, True, [], {}, None],
+        'number': ["not_num", True, [], {}, None],
+        'boolean': ["not_bool", 0, 1, [], {}, None],
+        'array': ["not_array", 123, 1.5, True, {}, None],
+        'object': ["not_obj", 123, 1.5, True, [], None],
+        'null': ["not_null", 0, 1.5, True, [], {}],
+    }

apitestgen-1.0.1/apitestgen/core/format_generator.py

@@ -0,0 +1,108 @@
+# api/formats/json_schema/format_generator.py
+"""格式生成器 - 基于 Faker 生成 format 数据"""
+
+import random
+from typing import Any, Optional
+
+
+try:
+    from faker import Faker
+    FAKER_AVAILABLE = True
+except ImportError:
+    FAKER_AVAILABLE = False
+
+
+class FormatGenerator:
+    """格式生成器"""
+
+    def __init__(self):
+        self._faker = None
+
+    @property
+    def faker(self):
+        if self._faker is None and FAKER_AVAILABLE:
+            self._faker = Faker()
+        return self._faker
+
+    def generate(self, format_name: str) -> Optional[str]:
+        handlers = {
+            'email': self._email,
+            'uri': self._uri,
+            'url': self._url,
+            'date': self._date,
+            'date-time': self._date_time,
+            'time': self._time,
+            'ipv4': self._ipv4,
+            'ipv6': self._ipv6,
+            'uuid': self._uuid,
+            'hostname': self._hostname,
+            'phone': self._phone,
+        }
+
+        handler = handlers.get(format_name)
+        if handler:
+            return handler()
+        return self._fallback()
+
+    def _email(self):
+        if self.faker:
+            return self.faker.email()
+        return f"user{random.randint(1,9999)}@example.com"
+
+    def _uri(self):
+        if self.faker:
+            return self.faker.uri()
+        return f"https://www.example{random.randint(1,99)}.com/path"
+
+    def _url(self):
+        return self._uri()
+
+    def _date(self):
+        if self.faker:
+            return self.faker.date()
+        return "2024-01-15"
+
+    def _date_time(self):
+        if self.faker:
+            return self.faker.date_time().isoformat()
+        return "2024-01-15T10:30:00"
+
+    def _time(self):
+        if self.faker:
+            return self.faker.time()
+        return "10:30:00"
+
+    def _ipv4(self):
+        if self.faker:
+            return self.faker.ipv4()
+        return "192.168.1.1"
+
+    def _ipv6(self):
+        if self.faker:
+            return self.faker.ipv6()
+        return "::1"
+
+    def _uuid(self):
+        import uuid
+        return str(uuid.uuid4())
+
+    def _hostname(self):
+        if self.faker:
+            return self.faker.hostname()
+        return "host.example.com"
+
+    def _phone(self):
+        if self.faker:
+            return self.faker.phone_number()
+        return f"1{random.randint(3000000000, 9999999999)}"
+
+    def _fallback(self):
+        return f"format_{random.randint(1000, 9999)}"
+
+
+# 全局实例
+_format_generator = FormatGenerator()
+
+
+def get_format_generator() -> FormatGenerator:
+    return _format_generator

apitestgen-1.0.1/apitestgen/core/generators/array_generator.py

@@ -0,0 +1,144 @@
+# api/core/generators/array_generator.py
+"""数组生成器：正负向"""
+
+import random
+import logging
+from typing import List
+
+from ..base_generator import BaseGenerator
+from ..meta import GeneratorMeta
+from apitestgen.negative.tag import negative_case
+from apitestgen.negative.result import FieldNegativeValue
+
+logger = logging.getLogger(__name__)
+
+
+@GeneratorMeta.register('array', alias=['list', 'tuple'])
+class ArrayGenerator(BaseGenerator):
+    """数组：minItems / maxItems / uniqueItems"""
+
+    # ================================================================
+    # 正向
+    # ================================================================
+
+    def generate(self) -> list:
+        if self.field.const is not None:
+            return self.field.const
+        if self.field.enum:
+            return random.choice(self.field.enum)
+        if not self.field.items:
+            return []
+
+        lo = self.field.min_items if self.field.min_items is not None else self.config.DEFAULT_MIN_ITEMS
+        hi = self.field.max_items if self.field.max_items is not None else self.config.DEFAULT_MAX_ITEMS
+
+        if lo == 0 and hi > 0:
+            lo = 1
+
+        result = self._generate_items(lo, hi)
+
+        if self.field.unique_items and result:
+            seen = set()
+            unique = []
+            for item in result:
+                key = str(item)
+                if key not in seen:
+                    seen.add(key)
+                    unique.append(item)
+            result = unique
+
+        return result
+
+    # ================================================================
+    # 通用生成方法
+    # ================================================================
+
+    def _generate_items(self, min_items: int, max_items: int) -> list:
+        """根据 min/max 生成数组元素"""
+        if min_items > max_items:
+            min_items = max_items
+
+        if len(self.field.items) > 1:
+            # 元组类型：所有位置都生成
+            result = []
+            for item in self.field.items:
+                gen = BaseGenerator(item, config=self.config, depth=self.depth + 1)
+                result.append(gen.generate())
+
+            # 少于 min_items：随机补充
+            while len(result) < min_items:
+                extra_item = random.choice(self.field.items)
+                gen = BaseGenerator(extra_item, config=self.config, depth=self.depth + 1)
+                result.append(gen.generate())
+
+            # 超过 max_items：随机截取
+            if len(result) > max_items:
+                result = random.sample(result, max_items)
+        else:
+            # 列表类型：随机长度
+            length = random.randint(min_items, max_items)
+            item_schema = self.field.items[0]
+            result = [
+                BaseGenerator(item_schema, config=self.config, depth=self.depth + 1).generate()
+                for _ in range(length)
+            ]
+
+        return result
+
+    # ================================================================
+    # 负向
+    # ================================================================
+
+    @negative_case("F2_3", "数组元素过少")
+    def _too_few(self) -> List[FieldNegativeValue]:
+        if self.field.type != 'array':
+            return []
+        lo = self.field.min_items or 0
+        if lo <= 0:
+            return []
+        if not self.field.items:
+            return []
+
+        few = self._generate_items(0, max(0, lo - 1))
+        return [self._make(few)]
+
+    @negative_case("F2_4", "数组元素过多")
+    def _too_many(self) -> List[FieldNegativeValue]:
+        if self.field.type != 'array':
+            return []
+        hi = self.field.max_items
+        if hi is None:
+            return []
+        if not self.field.items:
+            return []
+
+        over = hi + self.config.boundary_offset_array
+        many = self._generate_items(over, over)
+        return [self._make(many)]
+
+    @negative_case("F4_1", "类型错误")
+    def _wrong_type(self) -> List[FieldNegativeValue]:
+        vals = self.config.WRONG_TYPE_MAP.get('array', [])
+        return [self._make(v) for v in vals[:self.config.max_cases_per_tag]]
+
+    @negative_case("F6_1", "枚举值违反")
+    def _enum_violation(self) -> List[FieldNegativeValue]:
+        if not self.field.enum:
+            return []
+        cases = []
+        for _ in range(self.config.max_cases_per_tag):
+            valid = random.choice(self.field.enum)
+            cases.append(self._make(valid + ["__INVALID__"]))
+        return cases
+
+    @negative_case("F7_1", "数组元素不唯一")
+    def _unique_violation(self) -> List[FieldNegativeValue]:
+        if not self.field.unique_items:
+            return []
+        if not self.field.items:
+            return []
+
+        item = random.choice(self.field.items)
+        gen = BaseGenerator(item, config=self.config)
+        dup = gen.generate()
+        return [self._make([dup, dup])]

apitestgen-1.0.1/apitestgen/core/generators/boolean_generator.py

@@ -0,0 +1,46 @@
+# api/core/generators/boolean_generator.py
+"""布尔生成器：正负向"""
+
+import random
+from typing import List
+
+from ..base_generator import BaseGenerator
+from ..meta import GeneratorMeta
+from apitestgen.negative.tag import negative_case
+from apitestgen.negative.result import FieldNegativeValue
+
+
+@GeneratorMeta.register('boolean', alias=['bool'])
+class BooleanGenerator(BaseGenerator):
+    """布尔"""
+
+    def generate(self) -> bool:
+        if self.field.const is not None:
+            return self.field.const
+        if self.field.enum:
+            return random.choice(self.field.enum)
+        return random.choice([True, False])
+
+    @negative_case("F4_1", "类型错误")
+    def _wrong_type(self) -> List[FieldNegativeValue]:
+        vals = self.config.WRONG_TYPE_MAP.get('boolean', [])
+        return [self._make(v) for v in vals[:self.config.max_cases_per_tag]]
+
+    @negative_case("F6_1", "枚举值违反")
+    def _enum_violation(self) -> List[FieldNegativeValue]:
+        """不在枚举值范围内"""
+        if not self.field.enum:
+            return []
+
+        cases = []
+        for _ in range(self.config.max_cases_per_tag):
+            # 布尔枚举特殊处理：取一个不在枚举中的值
+            if True not in self.field.enum:
+                cases.append(self._make(True))
+            elif False not in self.field.enum:
+                cases.append(self._make(False))
+            else:
+                # 两个都在，用非布尔值
+                cases.append(self._make("NOT_BOOL"))
+
+        return cases