schemathesis 3.38.6__py3-none-any.whl → 3.38.7__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -224,8 +224,11 @@ def _iter_coverage_cases(
     from .specs.openapi.constants import LOCATION_TO_CONTAINER
     from .specs.openapi.examples import find_in_responses, find_matching_in_responses
 
-    def _stringify_value(val: Any) -> str:
+    def _stringify_value(val: Any, location: str) -> str | list[str]:
         if isinstance(val, list):
+            if location == "query":
+                # Having a list here ensures there will be multiple query parameters wit the same name
+                return [json.dumps(item) for item in val]
             # use comma-separated values style for arrays
             return ",".join(json.dumps(sub) for sub in val)
         return json.dumps(val)
@@ -246,8 +249,8 @@ def _iter_coverage_cases(
         location = parameter.location
         name = parameter.name
         container = template.setdefault(LOCATION_TO_CONTAINER[location], {})
-        if location in ("header", "cookie", "path") and not isinstance(value.value, str):
-            container[name] = _stringify_value(value.value)
+        if location in ("header", "cookie", "path", "query") and not isinstance(value.value, str):
+            container[name] = _stringify_value(value.value, location)
         else:
             container[name] = value.value
         generators[(location, name)] = gen
@@ -297,8 +300,8 @@ def _iter_coverage_cases(
         container_name = LOCATION_TO_CONTAINER[location]
         container = template[container_name]
         for value in gen:
-            if location in ("header", "cookie", "path") and not isinstance(value.value, str):
-                generated = _stringify_value(value.value)
+            if location in ("header", "cookie", "path", "query") and not isinstance(value.value, str):
+                generated = _stringify_value(value.value, location)
             else:
                 generated = value.value
             case = operation.make_case(**{**template, container_name: {**container, name: generated}})
@@ -310,8 +313,32 @@ def _iter_coverage_cases(
                 parameter_location=location,
             )
             yield case
-    # Generate missing required parameters
     if DataGenerationMethod.negative in data_generation_methods:
+        # Generate HTTP methods that are not specified in the spec
+        methods = {"get", "put", "post", "delete", "options", "head", "patch", "trace"} - set(
+            operation.schema[operation.path]
+        )
+        for method in methods:
+            case = operation.make_case(**template)
+            case._explicit_method = method
+            case.data_generation_method = DataGenerationMethod.negative
+            case.meta = _make_meta(description=f"Unspecified HTTP method: {method}")
+            yield case
+        # Generate duplicate query parameters
+        if operation.query:
+            container = template["query"]
+            for parameter in operation.query:
+                value = container[parameter.name]
+                case = operation.make_case(**{**template, "query": {**container, parameter.name: [value, value]}})
+                case.data_generation_method = DataGenerationMethod.negative
+                case.meta = _make_meta(
+                    description=f"Duplicate `{parameter.name}` query parameter",
+                    location=None,
+                    parameter=parameter.name,
+                    parameter_location="query",
+                )
+                yield case
+        # Generate missing required parameters
         for parameter in operation.iter_parameters():
             if parameter.is_required and parameter.location != "path":
                 name = parameter.name
@@ -324,7 +351,7 @@ def _iter_coverage_cases(
                 case.data_generation_method = DataGenerationMethod.negative
                 case.meta = _make_meta(
                     description=f"Missing `{name}` at {location}",
-                    location=parameter.location,
+                    location=None,
                     parameter=name,
                     parameter_location=location,
                 )
@@ -348,21 +375,26 @@ def _iter_coverage_cases(
 
         # Helper function to create and yield a case
         def make_case(
-            container_values: dict, description: str, _location: str, _container_name: str, _parameter: str | None
+            container_values: dict,
+            description: str,
+            _location: str,
+            _container_name: str,
+            _parameter: str | None,
+            _data_generation_method: DataGenerationMethod,
         ) -> Case:
-            if _location in ("header", "cookie", "path"):
+            if _location in ("header", "cookie", "path", "query"):
                 container = {
-                    name: _stringify_value(val) if not isinstance(val, str) else val
+                    name: _stringify_value(val, _location) if not isinstance(val, str) else val
                     for name, val in container_values.items()
                 }
             else:
                 container = container_values
 
             case = operation.make_case(**{**template, _container_name: container})
-            case.data_generation_method = DataGenerationMethod.positive
+            case.data_generation_method = _data_generation_method
             case.meta = _make_meta(
                 description=description,
-                location=_location,
+                location=None,
                 parameter=_parameter,
                 parameter_location=_location,
             )
@@ -388,12 +420,21 @@ def _iter_coverage_cases(
                 coverage.CoverageContext(data_generation_methods=[DataGenerationMethod.negative]),
                 subschema,
             ):
-                yield make_case(more.value, more.description, _location, _container_name, more.parameter)
+                yield make_case(
+                    more.value,
+                    more.description,
+                    _location,
+                    _container_name,
+                    more.parameter,
+                    DataGenerationMethod.negative,
+                )
 
         # 1. Generate only required properties
         if required and all_params != required:
             only_required = {k: v for k, v in base_container.items() if k in required}
-            yield make_case(only_required, "Only required properties", location, container_name, None)
+            yield make_case(
+                only_required, "Only required properties", location, container_name, None, DataGenerationMethod.positive
+            )
             if DataGenerationMethod.negative in data_generation_methods:
                 subschema = _combination_schema(only_required, required, parameter_set)
                 yield from _yield_negative(subschema, location, container_name)
@@ -403,7 +444,12 @@ def _iter_coverage_cases(
             combo = {k: v for k, v in base_container.items() if k in required or k == opt_param}
             if combo != base_container:
                 yield make_case(
-                    combo, f"All required properties and optional '{opt_param}'", location, container_name, None
+                    combo,
+                    f"All required properties and optional '{opt_param}'",
+                    location,
+                    container_name,
+                    None,
+                    DataGenerationMethod.positive,
                 )
                 if DataGenerationMethod.negative in data_generation_methods:
                     subschema = _combination_schema(combo, required, parameter_set)
@@ -416,7 +462,12 @@ def _iter_coverage_cases(
                     combo = {k: v for k, v in base_container.items() if k in required or k in combination}
                     if combo != base_container:
                         yield make_case(
-                            combo, f"All required and {size} optional properties", location, container_name, None
+                            combo,
+                            f"All required and {size} optional properties",
+                            location,
+                            container_name,
+                            None,
+                            DataGenerationMethod.positive,
                         )
 
 

schemathesis/generation/coverage.py

@@ -324,9 +324,9 @@ def cover_schema_iter(
         for key, value in schema.items():
             with _ignore_unfixable(), ctx.location(key):
                 if key == "enum":
-                    yield from _negative_enum(ctx, value)
+                    yield from _negative_enum(ctx, value, seen)
                 elif key == "const":
-                    for value_ in _negative_enum(ctx, [value]):
+                    for value_ in _negative_enum(ctx, [value], seen):
                         k = _to_hashable_key(value_.value)
                         if k not in seen:
                             yield value_
@@ -744,13 +744,20 @@ def select_combinations(optional: list[str]) -> Iterator[tuple[str, ...]]:
         yield next(combinations(optional, size))
 
 
-def _negative_enum(ctx: CoverageContext, value: list) -> Generator[GeneratedValue, None, None]:
+def _negative_enum(
+    ctx: CoverageContext, value: list, seen: set[Any | tuple[type, str]]
+) -> Generator[GeneratedValue, None, None]:
     def is_not_in_value(x: Any) -> bool:
-        return x not in value
+        if x in value:
+            return False
+        _hashed = _to_hashable_key(x)
+        return _hashed not in seen
 
-    strategy = JSON_STRATEGY.filter(is_not_in_value)
-    # The exact negative value is not important here
-    yield NegativeValue(ctx.generate_from(strategy), description="Invalid enum value", location=ctx.current_location)
+    strategy = (st.none() | st.booleans() | NUMERIC_STRATEGY | st.text()).filter(is_not_in_value)
+    value = ctx.generate_from(strategy)
+    yield NegativeValue(value, description="Invalid enum value", location=ctx.current_location)
+    hashed = _to_hashable_key(value)
+    seen.add(hashed)
 
 
 def _negative_properties(
@@ -846,6 +853,7 @@ def _negative_required(
             {k: v for k, v in template.items() if k != key},
             description=f"Missing required property: {key}",
             location=ctx.current_location,
+            parameter=key,
         )
 
 

schemathesis/models.py

@@ -203,6 +203,7 @@ class Case:
     data_generation_method: DataGenerationMethod | None = None
     _auth: requests.auth.AuthBase | None = None
     _has_explicit_auth: bool = False
+    _explicit_method: str | None = None
 
     def __post_init__(self) -> None:
         self._original_path_parameters = self.path_parameters.copy() if self.path_parameters else None
@@ -265,7 +266,7 @@ class Case:
 
     @property
     def method(self) -> str:
-        return self.operation.method.upper()
+        return self._explicit_method.upper() if self._explicit_method else self.operation.method.upper()
 
     @property
     def base_url(self) -> str | None:

{schemathesis-3.38.6.dist-info → schemathesis-3.38.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.38.6
+Version: 3.38.7
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-3.38.6.dist-info → schemathesis-3.38.7.dist-info}/RECORD

@@ -1,7 +1,7 @@
 schemathesis/__init__.py,sha256=UW2Bq8hDDkcBeAAA7PzpBFXkOOxkmHox-mfQwzHDjL0,1914
 schemathesis/_compat.py,sha256=y4RZd59i2NCnZ91VQhnKeMn_8t3SgvLOk2Xm8nymUHY,1837
 schemathesis/_dependency_versions.py,sha256=pjEkkGAfOQJYNb-9UOo84V8nj_lKHr_TGDVdFwY2UU0,816
-schemathesis/_hypothesis.py,sha256=SHFQKVeKsKX55D7Rfb2DTG7gq7h-jLXMGGD8RG81ac4,21339
+schemathesis/_hypothesis.py,sha256=7hQItl5JqtctCiN7gL4DhWmj8A0Ku6t1_pkxEqkID1g,23463
 schemathesis/_lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/_override.py,sha256=TAjYB3eJQmlw9K_xiR9ptt9Wj7if4U7UFlUhGjpBAoM,1625
 schemathesis/_patches.py,sha256=Hsbpn4UVeXUQD2Kllrbq01CSWsTYENWa0VJTyhX5C2k,895
@@ -18,7 +18,7 @@ schemathesis/graphql.py,sha256=XiuKcfoOB92iLFC8zpz2msLkM0_V0TLdxPNBqrrGZ8w,216
 schemathesis/hooks.py,sha256=p5AXgjVGtka0jn9MOeyBaRUtNbqZTs4iaJqytYTacHc,14856
 schemathesis/lazy.py,sha256=Ddhkk7Tpc_VcRGYkCtKDmP2gpjxVmEZ3b01ZTNjbm8I,19004
 schemathesis/loaders.py,sha256=MoEhcdOEBJxNRn5X-ZNhWB9jZDHQQNpkNfEdQjf_NDw,4590
-schemathesis/models.py,sha256=s0lt63sBShsgKoM_kqLPb56jIeHSwTfk-TDQmQowXH8,49669
+schemathesis/models.py,sha256=Xn1rEF0_g3HNqJaJB9sC8N3gJ9suFPPlgc8ho01VyF0,49769
 schemathesis/parameters.py,sha256=izlu4MFYT1RWrC4RBxrV6weeCal-ODbdLQLMb0PYCZY,2327
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=Lycn1VVfula9B6XpzkxTHja7CZ7RHqbUh9kBic0Yi4M,9056
@@ -61,7 +61,7 @@ schemathesis/fixups/utf8_bom.py,sha256=lWT9RNmJG8i-l5AXIpaCT3qCPUwRgzXPW3eoOjmZE
 schemathesis/generation/__init__.py,sha256=29Zys_tD6kfngaC4zHeC6TOBZQcmo7CWm7KDSYsHStQ,1581
 schemathesis/generation/_hypothesis.py,sha256=74fzLPHugZgMQXerWYFAMqCAjtAXz5E4gek7Gnkhli4,1756
 schemathesis/generation/_methods.py,sha256=r8oVlJ71_gXcnEhU-byw2E0R2RswQQFm8U7yGErSqbw,1204
-schemathesis/generation/coverage.py,sha256=6VCaQ8bUtBmbG-DCOS11rXHA-s6hiIzVtbXAB0pYMZU,38604
+schemathesis/generation/coverage.py,sha256=Y-eKsEDe6INu-2SjlzGpuzayRXF_wdDwTBLsW4pGlrc,38843
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
 schemathesis/internal/checks.py,sha256=SBx2gesB-XzgVSMX_u7Mb416jSxJ68eQKtcdkWlkyOo,2441
 schemathesis/internal/copy.py,sha256=DcL56z-d69kKR_5u8mlHvjSL1UTyUKNMAwexrwHFY1s,1031
@@ -153,8 +153,8 @@ schemathesis/transports/auth.py,sha256=urSTO9zgFO1qU69xvnKHPFQV0SlJL3d7_Ojl0tLnZ
 schemathesis/transports/content_types.py,sha256=MiKOm-Hy5i75hrROPdpiBZPOTDzOwlCdnthJD12AJzI,2187
 schemathesis/transports/headers.py,sha256=hr_AIDOfUxsJxpHfemIZ_uNG3_vzS_ZeMEKmZjbYiBE,990
 schemathesis/transports/responses.py,sha256=OFD4ZLqwEFpo7F9vaP_SVgjhxAqatxIj38FS4XVq8Qs,1680
-schemathesis-3.38.6.dist-info/METADATA,sha256=CbrAdVVhZVREx6pwkPRARvVXqETpf8YE34flEN3Tr4I,12923
-schemathesis-3.38.6.dist-info/WHEEL,sha256=WJ9WQ4-pUYxfD_tEj5GvKSG9KSULNumqkTQdolV8mME,87
-schemathesis-3.38.6.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.38.6.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.38.6.dist-info/RECORD,,
+schemathesis-3.38.7.dist-info/METADATA,sha256=iBsAbz1uaJxY_GUPTnjdD2uMxS3HCk6lX_4IVj_s2yY,12923
+schemathesis-3.38.7.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+schemathesis-3.38.7.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.38.7.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.38.7.dist-info/RECORD,,

{schemathesis-3.38.6.dist-info → schemathesis-3.38.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.2
+Generator: hatchling 1.26.3
 Root-Is-Purelib: true
 Tag: py3-none-any