schemathesis 4.3.8__tar.gz → 4.3.10__tar.gz

{schemathesis-4.3.8 → schemathesis-4.3.10}/CHANGELOG.md

@@ -1,6 +1,25 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.8...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.10...HEAD) - TBD
+
+## [4.3.10](https://github.com/schemathesis/schemathesis/compare/v4.3.9...v4.3.10) - 2025-10-22
+
+### :bug: Fixed
+
+- Internal error when generating invalid type in the coverage phase.
+- Internal error when generating valid instance against an array of types in the coverage phase. [#3194](https://github.com/schemathesis/schemathesis/issues/3194)
+- Missing required request body for schemas without validation keywords.
+
+### :wrench: Changed
+
+- Improve resources inference.
+
+## [4.3.9](https://github.com/schemathesis/schemathesis/compare/v4.3.8...v4.3.9) - 2025-10-21
+
+### :bug: Fixed
+
+- Missing required request body for some schemas during the coverage phase.
+- Adjust some schemas so `hypothesis-jsonschema` can generate data for them.
 
 ## [4.3.8](https://github.com/schemathesis/schemathesis/compare/v4.3.7...v4.3.8) - 2025-10-21
 

{schemathesis-4.3.8 → schemathesis-4.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.8
+Version: 4.3.10
 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://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md

{schemathesis-4.3.8 → schemathesis-4.3.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.3.8"
+version = "4.3.10"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]

schemathesis-4.3.10/src/schemathesis/core/jsonschema/keywords.py

@@ -0,0 +1,40 @@
+ALL_KEYWORDS = frozenset(
+    {
+        "additionalItems",
+        "additionalProperties",
+        "allOf",
+        "anyOf",
+        "const",
+        "contains",
+        "contentEncoding",
+        "contentMediaType",
+        "dependencies",
+        "enum",
+        "else",
+        "exclusiveMaximum",
+        "exclusiveMinimum",
+        "format",
+        "if",
+        "items",
+        "maxItems",
+        "maxLength",
+        "maxProperties",
+        "maximum",
+        "minItems",
+        "minLength",
+        "minProperties",
+        "minimum",
+        "multipleOf",
+        "not",
+        "oneOf",
+        "pattern",
+        "patternProperties",
+        "properties",
+        "propertyNames",
+        "$ref",
+        "required",
+        "then",
+        "type",
+        "uniqueItems",
+    }
+)

{schemathesis-4.3.8 → schemathesis-4.3.10}/src/schemathesis/generation/coverage.py

@@ -7,6 +7,10 @@ from dataclasses import dataclass
 from functools import lru_cache, partial
 from itertools import combinations
 
+from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY
+from schemathesis.core.jsonschema.keywords import ALL_KEYWORDS
+from schemathesis.generation.hypothesis.strategies import combine
+
 try:
     from json.encoder import _make_iterencode  # type: ignore[attr-defined]
 except ImportError:
@@ -72,6 +76,14 @@ STRATEGIES_FOR_TYPE = {
     "array": ARRAY_STRATEGY,
     "object": OBJECT_STRATEGY,
 }
+
+
+def get_strategy_for_type(ty: str | list[str]) -> st.SearchStrategy:
+    if isinstance(ty, str):
+        return STRATEGIES_FOR_TYPE[ty]
+    return combine([STRATEGIES_FOR_TYPE[t] for t in ty if t in STRATEGIES_FOR_TYPE])
+
+
 FORMAT_STRATEGIES = {**BUILT_IN_STRING_FORMATS, **get_default_format_strategies(), **STRING_FORMATS}
 
 UNKNOWN_PROPERTY_KEY = "x-schemathesis-unknown-property"
@@ -267,11 +279,11 @@ class CoverageContext:
         if isinstance(schema, bool):
             return 0
         keys = sorted([k for k in schema if not k.startswith("x-") and k not in ["description", "example", "examples"]])
-        if keys == ["type"] and isinstance(schema["type"], str) and schema["type"] in STRATEGIES_FOR_TYPE:
-            return cached_draw(STRATEGIES_FOR_TYPE[schema["type"]])
+        if keys == ["type"]:
+            return cached_draw(get_strategy_for_type(schema["type"]))
         if keys == ["format", "type"]:
             if schema["type"] != "string":
-                return cached_draw(STRATEGIES_FOR_TYPE[schema["type"]])
+                return cached_draw(get_strategy_for_type(schema["type"]))
             elif schema["format"] in FORMAT_STRATEGIES:
                 return cached_draw(FORMAT_STRATEGIES[schema["format"]])
         if (keys == ["maxLength", "minLength", "type"] or keys == ["maxLength", "type"]) and schema["type"] == "string":
@@ -346,6 +358,19 @@ class CoverageContext:
         if isinstance(schema, dict) and "examples" in schema:
             # Examples may contain binary data which will fail the canonicalisation process in `hypothesis-jsonschema`
             schema = {key: value for key, value in schema.items() if key != "examples"}
+        # Prevent some hard to satisfy schemas
+        if isinstance(schema, dict) and schema.get("additionalProperties") is False and "required" in schema:
+            # Set required properties to any value to simplify generation
+            schema = dict(schema)
+            properties = schema.setdefault("properties", {})
+            for key in schema["required"]:
+                properties.setdefault(key, {})
+
+        # Add bundled schemas if any
+        if isinstance(schema, dict) and BUNDLE_STORAGE_KEY in self.root_schema:
+            schema = dict(schema)
+            schema[BUNDLE_STORAGE_KEY] = self.root_schema[BUNDLE_STORAGE_KEY]
+
         return self.generate_from(from_schema(schema, custom_formats=self.custom_formats))
 
 
@@ -490,12 +515,14 @@ def cover_schema_iter(
             # Can't resolve a reference - at this point, we can't generate anything useful as `$ref` is in the current schema root
             return
 
-    if schema == {} or schema is True:
+    if schema is True:
         types = ["null", "boolean", "string", "number", "array", "object"]
         schema = {}
     elif schema is False:
         types = []
         schema = {"not": {}}
+    elif not any(k in ALL_KEYWORDS for k in schema):
+        types = ["null", "boolean", "string", "number", "array", "object"]
     else:
         types = schema.get("type", [])
     push_examples_to_properties(schema)
@@ -1305,7 +1332,7 @@ def _negative_type(
     }.get(ctx.location)
 
     if "number" in types:
-        del strategies["integer"]
+        strategies.pop("integer", None)
     if "integer" in types:
         strategies["number"] = FLOAT_STRATEGY.filter(_is_non_integer_float)
     if ctx.location == ParameterLocation.QUERY:

{schemathesis-4.3.8 → schemathesis-4.3.10}/src/schemathesis/generation/hypothesis/builder.py

@@ -529,7 +529,6 @@ def _iter_coverage_cases(
 
     instant = Instant()
     responses = list(operation.responses.iter_examples())
-    # NOTE: The HEAD method is excluded
     custom_formats = _build_custom_formats(generation_config)
 
     seen_negative = coverage.HashSet()

{schemathesis-4.3.8 → schemathesis-4.3.10}/src/schemathesis/specs/openapi/stateful/dependencies/naming.py

@@ -2,16 +2,35 @@ from __future__ import annotations
 
 
 def from_parameter(parameter: str, path: str) -> str | None:
-    # TODO: support other naming patterns
-    # Named like "userId" -> look for "User" resource
-    if parameter.endswith("Id") and len(parameter) > 2:
-        return to_pascal_case(parameter[:-2])
-    # Named like "user_id" -> look for "User" resource
-    elif parameter.endswith("_id"):
-        return to_pascal_case(parameter[:-3])
-    # Just "id" -> infer from path context
-    elif parameter == "id":
+    parameter = parameter.strip()
+    lower = parameter.lower()
+
+    if lower == "id":
         return from_path(path, parameter_name=parameter)
+
+    # Capital-sensitive
+    capital_suffixes = ("Id", "Uuid", "Guid")
+    for suffix in capital_suffixes:
+        if parameter.endswith(suffix):
+            prefix = parameter[: -len(suffix)]
+            if len(prefix) >= 2:
+                return to_pascal_case(prefix)
+
+    # Snake_case (case-insensitive is fine here)
+    snake_suffixes = ("_guid", "_uuid", "_id", "-guid", "-uuid", "-id")
+    for suffix in snake_suffixes:
+        if lower.endswith(suffix):
+            prefix = parameter[: -len(suffix)]
+            if len(prefix) >= 2:
+                return to_pascal_case(prefix)
+
+    # Special cases that need exact match
+    # Twilio-style, capital S
+    if parameter.endswith("Sid"):
+        prefix = parameter[:-3]
+        if len(prefix) >= 2:
+            return to_pascal_case(prefix)
+
     return None
 
 
@@ -335,8 +354,12 @@ def to_plural(word: str) -> str:
 
 
 def to_pascal_case(text: str) -> str:
-    parts = text.replace("-", "_").split("_")
-    return "".join(word.capitalize() for word in parts if word)
+    # snake_case/kebab-case - split and capitalize each word
+    if "_" in text or "-" in text:
+        parts = text.replace("-", "_").split("_")
+        return "".join(word.capitalize() for word in parts if word)
+    # camelCase - just uppercase first letter, preserve the rest
+    return text[0].upper() + text[1:] if text else text
 
 
 def to_snake_case(text: str) -> str:

{schemathesis-4.3.8 → schemathesis-4.3.10}/src/schemathesis/specs/openapi/stateful/dependencies/schemas.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any, Callable, Mapping
 
 from schemathesis.core.jsonschema import ALL_KEYWORDS
 from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY, bundle
-from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject
+from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject, get_type
 from schemathesis.core.transforms import encode_pointer
 from schemathesis.specs.openapi.adapter.parameters import resource_name_from_ref
 from schemathesis.specs.openapi.adapter.references import maybe_resolve
@@ -425,7 +425,7 @@ def _detect_externally_tagged_pattern(schema: Mapping[str, Any], path: str) -> s
         if name.lower() not in possible_names:
             continue
 
-        if isinstance(subschema, dict):
+        if isinstance(subschema, dict) and "object" in get_type(subschema):
             return name
 
     return None

{schemathesis-4.3.8 → schemathesis-4.3.10}/test/coverage/test_combinations.py

@@ -1097,6 +1097,16 @@ def test_negative_pattern_with_incompatible_length(nctx):
     assert_not_conform(covered, schema)
 
 
+def test_negative_multiple_types(nctx):
+    schema = {"type": ["integer", "number", "string"]}
+    assert not cover_schema(nctx, schema)
+
+
+def test_positive_multiple_types(pctx):
+    schema = {"type": ["string", "null"], "format": "date-time"}
+    assert cover_schema(pctx, schema) == ["", None]
+
+
 @pytest.mark.parametrize(
     ("schema", "expected"),
     [

{schemathesis-4.3.8 → schemathesis-4.3.10}/test/coverage/test_phase.py

@@ -200,6 +200,9 @@ def run_test(operation, test, modes=ALL_MODES, generate_duplicate_query_paramete
         config.phases.coverage.generate_duplicate_query_parameters = generate_duplicate_query_parameters
     if unexpected_methods is not None:
         config.phases.coverage.unexpected_methods = unexpected_methods
+    config.phases.examples.enabled = False
+    config.phases.fuzzing.enabled = False
+    config.phases.stateful.enabled = False
     test_func = create_test(
         operation=operation,
         test_func=test,
@@ -1975,6 +1978,122 @@ def test_negative_data_rejection(ctx, cli, openapi3_base_url, snapshot_cli):
     )
 
 
+@pytest.mark.parametrize(
+    ["required", "properties"],
+    (
+        (["key"], None),
+        (["key"], {"another": {"type": "string"}}),
+        (["key", "description"], {"key": {"type": "string"}}),
+    ),
+)
+def test_request_body_is_required(ctx, required, properties):
+    inner = {
+        "additionalProperties": False,
+        "required": required,
+        "type": "object",
+    }
+    if properties is not None:
+        inner["properties"] = properties
+    raw_schema = ctx.openapi.build_schema(
+        {
+            "/items": {
+                "post": {
+                    "parameters": [
+                        {"in": "query", "name": "strict", "schema": {}},
+                    ],
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "properties": {"data": inner},
+                                    "type": "object",
+                                }
+                            }
+                        },
+                        "required": True,
+                    },
+                }
+            }
+        }
+    )
+    schema = schemathesis.openapi.from_dict(raw_schema)
+
+    operation = schema["/items"]["post"]
+
+    def test(case):
+        # Body is `required`, hence should never be unset for positive tests
+        assert case.body is not NOT_SET, case.meta.phase.data.description
+
+    run_positive_test(operation, test)
+
+
+@pytest.mark.parametrize("required", [["name"], ["name", "description"]])
+def test_request_body_with_references(ctx, required):
+    raw_schema = ctx.openapi.build_schema(
+        {
+            "/items": {
+                "post": {
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "properties": {"data": {"$ref": "#/components/schemas/Item"}},
+                                    "required": ["data"],
+                                    "type": "object",
+                                }
+                            }
+                        },
+                        "required": True,
+                    }
+                }
+            }
+        },
+        components={
+            "schemas": {
+                "Name": {"type": "string"},
+                "Item": {
+                    "additionalProperties": False,
+                    "properties": {"name": {"$ref": "#/components/schemas/Name"}},
+                    "required": required,
+                    "type": "object",
+                },
+            }
+        },
+    )
+    schema = schemathesis.openapi.from_dict(raw_schema)
+
+    operation = schema["/items"]["post"]
+
+    def test(case):
+        # Body is `required`, hence should never be unset for positive tests
+        assert case.body is not NOT_SET, case.meta.phase.data.description
+
+    run_positive_test(operation, test)
+
+
+def test_request_body_without_validation_keywords(ctx):
+    raw_schema = ctx.openapi.build_schema(
+        {
+            "/items": {
+                "post": {
+                    "requestBody": {
+                        "content": {"application/json": {"schema": {"x-something": True}}},
+                        "required": True,
+                    }
+                }
+            }
+        },
+    )
+    schema = schemathesis.openapi.from_dict(raw_schema)
+
+    operation = schema["/items"]["post"]
+
+    def test(case):
+        assert case.body is not NOT_SET, case.meta.phase.data.description
+
+    run_positive_test(operation, test)
+
+
 @pytest.mark.openapi_version("3.0")
 def test_unspecified_http_methods(ctx, cli, openapi3_base_url, snapshot_cli):
     raw_schema = {

schemathesis-4.3.10/test/specs/openapi/stateful/inference/__snapshots__/test_dependencies/test_dependency_graph[externally-tagged-primitive-types].json

@@ -0,0 +1,27 @@
+{
+  "operations": {
+    "GET /merchants": {
+      "inputs": [],
+      "outputs": [
+        {
+          "cardinality": "ONE",
+          "pointer": "/",
+          "resource": "MerchantsResponse",
+          "status_code": "200"
+        }
+      ]
+    }
+  },
+  "resources": {
+    "MerchantsResponse": {
+      "fields": [
+        "Merchants"
+      ],
+      "types": {
+        "Merchants": [
+          "string"
+        ]
+      }
+    }
+  }
+}

schemathesis-4.3.10/test/specs/openapi/stateful/inference/__snapshots__/test_dependencies/test_dependency_graph[unresolvable-ref].1.json

@@ -0,0 +1 @@
+[]

{schemathesis-4.3.8 → schemathesis-4.3.10}/test/specs/openapi/stateful/inference/test_dependencies.py

@@ -697,6 +697,18 @@ def snapshot_json(snapshot):
             },
             id="externally-tagged-many",
         ),
+        pytest.param(
+            operation("get", "/merchants", "200", component_ref("MerchantsResponse")),
+            {
+                "schemas": {
+                    "MerchantsResponse": {
+                        "type": "object",
+                        "properties": {"Merchants": {"type": "string"}},
+                    },
+                }
+            },
+            id="externally-tagged-primitive-types",
+        ),
         pytest.param(
             operation("get", "/merchants", "200", component_ref("MerchantsResponse")),
             {

{schemathesis-4.3.8 → schemathesis-4.3.10}/test/specs/openapi/stateful/inference/test_naming.py

@@ -3,6 +3,31 @@ import pytest
 from schemathesis.specs.openapi.stateful.dependencies import naming
 
 
+@pytest.mark.parametrize(
+    ["parameter", "path", "expected"],
+    [
+        ("id", "/users/{id}", "User"),
+        ("ID", "/accounts/{ID}", "Account"),
+        ("userId", "/users/{userId}", "User"),
+        ("accountUuid", "/accounts/{accountUuid}", "Account"),
+        ("Uuid", "/accounts/{accountUuid}", None),
+        ("sessionGuid", "/sessions/{sessionGuid}", "Session"),
+        ("user_id", "/users/{user_id}", "User"),
+        ("account_uuid", "/accounts/{account_uuid}", "Account"),
+        ("_uuid", "/accounts/{account_uuid}", None),
+        ("session-guid", "/sessions/{session-guid}", "Session"),
+        ("messageSid", "/messages/{messageSid}", "Message"),
+        ("Sid", "/messages/{messageSid}", None),
+        ("id", "/users/{id}", "User"),
+        ("_id", "/users/{_id}", None),
+        ("uid", "/users/{uid}", None),
+        ("someRandom", "/users/{someRandom}", None),
+    ],
+)
+def test_from_parameter(parameter, path, expected):
+    assert naming.from_parameter(parameter, path) == expected
+
+
 @pytest.mark.parametrize(
     ["word", "expected"],
     [
@@ -122,6 +147,28 @@ def test_to_plural(word, expected):
     assert naming.to_plural(word) == expected
 
 
+@pytest.mark.parametrize(
+    ["text", "expected"],
+    [
+        ("user_id", "UserId"),
+        ("api_key", "ApiKey"),
+        ("sip_trunk", "SipTrunk"),
+        ("user-id", "UserId"),
+        ("api-key", "ApiKey"),
+        ("sipTrunk", "SipTrunk"),
+        ("userId", "UserId"),
+        ("accountHolder", "AccountHolder"),
+        ("UserProfile", "UserProfile"),
+        ("SipTrunk", "SipTrunk"),
+        ("API", "API"),
+        ("userID", "UserID"),
+        ("user", "User"),
+    ],
+)
+def test_to_pascal_case(text, expected):
+    assert naming.to_pascal_case(text) == expected
+
+
 @pytest.mark.parametrize(
     ["name", "prefixes", "suffixes", "expected"],
     [

{schemathesis-4.3.8 → schemathesis-4.3.10}/test-corpus/__snapshots__/test_inference/test_dependency_graph[openapi-3.0-ably.ioplatform1.1.0.json].json

@@ -226,7 +226,7 @@
         {
           "parameter_location": "body",
           "parameter_name": "id",
-          "resource": "Deviceregistration",
+          "resource": "DeviceRegistration",
           "resource_field": "id"
         }
       ],
@@ -307,7 +307,7 @@
         {
           "parameter_location": "body",
           "parameter_name": "id",
-          "resource": "Deviceregistration",
+          "resource": "DeviceRegistration",
           "resource_field": "id"
         }
       ],
@@ -347,7 +347,7 @@
         {
           "parameter_location": "body",
           "parameter_name": "id",
-          "resource": "Deviceregistration",
+          "resource": "DeviceRegistration",
           "resource_field": "id"
         }
       ],
@@ -481,7 +481,7 @@
         ]
       }
     },
-    "Deviceregistration": {
+    "DeviceRegistration": {
       "fields": [
         "id"
       ],