schemathesis 4.2.0__py3-none-any.whl → 4.2.1__py3-none-any.whl

schemathesis/cli/commands/run/handlers/cassettes.py

@@ -119,102 +119,84 @@ def get_command_representation() -> str:
 
 
 def vcr_writer(output: TextOutput, config: ProjectConfig, queue: Queue) -> None:
-    """Write YAML to a file in an incremental manner.
-
-    This implementation doesn't use `pyyaml` package and composes YAML manually as string due to the following reasons:
-      - It is much faster. The string-based approach gives only ~2.5% time overhead when `yaml.CDumper` has ~11.2%;
-      - Implementation complexity. We have a quite simple format where almost all values are strings, and it is much
-        simpler to implement it with string composition rather than with adjusting `yaml.Serializer` to emit explicit
-        types. Another point is that with `pyyaml` we need to emit events and handle some low-level details like
-        providing tags, anchors to have incremental writing, with primitive types it is much simpler.
-    """
+    """Write YAML to a file in an incremental manner."""
     current_id = 1
 
-    def format_header_values(values: list[str]) -> str:
-        return "\n".join(f"      - {json.dumps(v)}" for v in values)
+    def write_header_values(stream: IO, values: list[str]) -> None:
+        for v in values:
+            stream.write(f"      - {json.dumps(v)}\n")
 
     if config.output.sanitization.enabled:
-
-        def format_headers(headers: dict[str, list[str]]) -> str:
-            headers = deepclone(headers)
-            sanitize_value(headers, config=config.output.sanitization)
-            return "\n".join(f'      "{name}":\n{format_header_values(values)}' for name, values in headers.items())
-
+        sanitization_keys = config.output.sanitization.keys_to_sanitize
+        sensitive_markers = config.output.sanitization.sensitive_markers
+        replacement = config.output.sanitization.replacement
+
+        def write_headers(stream: IO, headers: dict[str, list[str]]) -> None:
+            for name, values in headers.items():
+                lower_name = name.lower()
+                stream.write(f'      "{name}":\n')
+
+                # Sanitize inline if needed
+                if lower_name in sanitization_keys or any(marker in lower_name for marker in sensitive_markers):
+                    stream.write(f"      - {json.dumps(replacement)}\n")
+                else:
+                    write_header_values(stream, values)
     else:
 
-        def format_headers(headers: dict[str, list[str]]) -> str:
-            return "\n".join(f'      "{name}":\n{format_header_values(values)}' for name, values in headers.items())
-
-    def format_check_message(message: str | None) -> str:
-        return "~" if message is None else f"{message!r}"
+        def write_headers(stream: IO, headers: dict[str, list[str]]) -> None:
+            for name, values in headers.items():
+                stream.write(f'      "{name}":\n')
+                write_header_values(stream, values)
 
-    def format_checks(checks: list[CheckNode]) -> str:
+    def write_checks(stream: IO, checks: list[CheckNode]) -> None:
         if not checks:
-            return "\n  checks: []"
-        items = "\n".join(
-            f"    - name: '{check.name}'\n      status: '{check.status.name.upper()}'\n      message: {format_check_message(check.failure_info.failure.title if check.failure_info else None)}"
-            for check in checks
-        )
-        return f"""
-  checks:
-{items}"""
+            stream.write("\n  checks: []")
+            return
+
+        stream.write("\n  checks:\n")
+        for check in checks:
+            message = check.failure_info.failure.title if check.failure_info else None
+            message_str = "~" if message is None else repr(message)
+            stream.write(
+                f"    - name: '{check.name}'\n"
+                f"      status: '{check.status.name.upper()}'\n"
+                f"      message: {message_str}\n"
+            )
 
     if config.reports.preserve_bytes:
 
-        def format_request_body(output: IO, request: Request) -> None:
+        def write_request_body(stream: IO, request: Request) -> None:
             if request.encoded_body is not None:
-                output.write(
-                    f"""
-    body:
-      encoding: 'utf-8'
-      base64_string: '{request.encoded_body}'"""
-                )
+                stream.write(f"\n    body:\n      encoding: 'utf-8'\n      base64_string: '{request.encoded_body}'")
 
-        def format_response_body(output: IO, response: Response) -> None:
+        def write_response_body(stream: IO, response: Response) -> None:
             if response.encoded_body is not None:
-                output.write(
-                    f"""    body:
-      encoding: '{response.encoding}'
-      base64_string: '{response.encoded_body}'"""
+                stream.write(
+                    f"    body:\n      encoding: '{response.encoding}'\n      base64_string: '{response.encoded_body}'"
                 )
-
     else:
 
-        def format_request_body(output: IO, request: Request) -> None:
+        def write_request_body(stream: IO, request: Request) -> None:
             if request.body is not None:
                 string = request.body.decode("utf8", "replace")
-                output.write(
-                    """
-    body:
-      encoding: 'utf-8'
-      string: """
-                )
-                write_double_quoted(output, string)
+                stream.write("\n    body:\n      encoding: 'utf-8'\n      string: ")
+                write_double_quoted(stream, string)
 
-        def format_response_body(output: IO, response: Response) -> None:
+        def write_response_body(stream: IO, response: Response) -> None:
             if response.content is not None:
                 encoding = response.encoding or "utf8"
                 string = response.content.decode(encoding, "replace")
-                output.write(
-                    f"""    body:
-      encoding: '{encoding}'
-      string: """
-                )
-                write_double_quoted(output, string)
+                stream.write(f"    body:\n      encoding: '{encoding}'\n      string: ")
+                write_double_quoted(stream, string)
 
     with open_text_output(output) as stream:
         while True:
             item = queue.get()
-            if isinstance(item, Initialize):
-                stream.write(
-                    f"""command: '{get_command_representation()}'
-recorded_with: 'Schemathesis {SCHEMATHESIS_VERSION}'
-seed: {item.seed}
-http_interactions:"""
-                )
-            elif isinstance(item, Process):
+            if isinstance(item, Process):
                 for case_id, interaction in item.recorder.interactions.items():
                     case = item.recorder.cases[case_id]
+
+                    # Determine status and checks
                     if interaction.response is not None:
                         if case_id in item.recorder.checks:
                             checks = item.recorder.checks[case_id]
@@ -224,101 +206,93 @@ http_interactions:"""
                                     status = check.status
                                     break
                         else:
-                            # NOTE: Checks recording could be skipped if Schemathesis start skipping just
-                            # discovered failures in order to get past them and potentially discover more failures
                             checks = []
                             status = Status.SKIP
                     else:
                         checks = []
                         status = Status.ERROR
-                    # Body payloads are handled via separate `stream.write` calls to avoid some allocations
-                    stream.write(
-                        f"""\n- id: '{case_id}'
-  status: '{status.name}'"""
-                    )
+
+                    # Write interaction header
+                    stream.write(f"\n- id: '{case_id}'\n  status: '{status.name}'")
+
+                    # Write metadata if present
                     meta = case.value.meta
                     if meta is not None:
-                        # Start metadata block
-                        stream.write(f"""
-  generation:
-    time: {meta.generation.time}
-    mode: {meta.generation.mode.value}
-  components:""")
-
-                        # Write components
+                        stream.write(
+                            f"\n  generation:\n"
+                            f"    time: {meta.generation.time}\n"
+                            f"    mode: {meta.generation.mode.value}\n"
+                            f"  components:"
+                        )
+
                         for kind, info in meta.components.items():
-                            stream.write(f"""
-    {kind.value}:
-      mode: '{info.mode.value}'""")
-                        # Write phase info
-                        stream.write("\n  phase:")
-                        stream.write(f"\n    name: '{meta.phase.name.value}'")
-                        stream.write("\n    data: ")
-
-                        # Write phase-specific data
+                            stream.write(f"\n    {kind.value}:\n      mode: '{info.mode.value}'")
+
+                        stream.write(f"\n  phase:\n    name: '{meta.phase.name.value}'\n    data: ")
+
                         if isinstance(meta.phase.data, CoveragePhaseData):
-                            stream.write("""
-      description: """)
+                            stream.write("\n      description: ")
                             write_double_quoted(stream, meta.phase.data.description)
-                            stream.write("""
-      location: """)
+                            stream.write("\n      location: ")
                             write_double_quoted(stream, meta.phase.data.location)
-                            stream.write("""
-      parameter: """)
+                            stream.write("\n      parameter: ")
                             if meta.phase.data.parameter is not None:
                                 write_double_quoted(stream, meta.phase.data.parameter)
                             else:
                                 stream.write("null")
-                            stream.write("""
-      parameter_location: """)
+                            stream.write("\n      parameter_location: ")
                             if meta.phase.data.parameter_location is not None:
                                 write_double_quoted(stream, meta.phase.data.parameter_location)
                             else:
                                 stream.write("null")
                         else:
-                            # Empty objects for these phases
                             stream.write("{}")
                     else:
-                        stream.write("null")
+                        stream.write("\n  metadata: null")
 
+                    # Sanitize URL if needed
                     if config.output.sanitization.enabled:
                         uri = sanitize_url(interaction.request.uri, config=config.output.sanitization)
                     else:
                         uri = interaction.request.uri
+
                     recorded_at = datetime.datetime.fromtimestamp(
                         interaction.timestamp, datetime.timezone.utc
                     ).isoformat()
+
+                    stream.write(f"\n  recorded_at: '{recorded_at}'")
+                    write_checks(stream, checks)
                     stream.write(
-                        f"""
-  recorded_at: '{recorded_at}'{format_checks(checks)}
-  request:
-    uri: '{uri}'
-    method: '{interaction.request.method}'
-    headers:
-{format_headers(interaction.request.headers)}"""
+                        f"\n  request:\n    uri: '{uri}'\n    method: '{interaction.request.method}'\n    headers:\n"
                     )
-                    format_request_body(stream, interaction.request)
+                    write_headers(stream, interaction.request.headers)
+                    write_request_body(stream, interaction.request)
+
+                    # Write response
                     if interaction.response is not None:
                         stream.write(
-                            f"""
-  response:
-    status:
-      code: '{interaction.response.status_code}'
-      message: {json.dumps(interaction.response.message)}
-    elapsed: '{interaction.response.elapsed}'
-    headers:
-{format_headers(interaction.response.headers)}
-"""
-                        )
-                        format_response_body(stream, interaction.response)
-                        stream.write(
-                            f"""
-    http_version: '{interaction.response.http_version}'"""
+                            f"\n  response:\n"
+                            f"    status:\n"
+                            f"      code: '{interaction.response.status_code}'\n"
+                            f"      message: {json.dumps(interaction.response.message)}\n"
+                            f"    elapsed: '{interaction.response.elapsed}'\n"
+                            f"    headers:\n"
                         )
+                        write_headers(stream, interaction.response.headers)
+                        stream.write("\n")
+                        write_response_body(stream, interaction.response)
+                        stream.write(f"\n    http_version: '{interaction.response.http_version}'")
                     else:
-                        stream.write("""
-  response: null""")
+                        stream.write("\n  response: null")
+
                     current_id += 1
+            elif isinstance(item, Initialize):
+                stream.write(
+                    f"command: '{get_command_representation()}'\n"
+                    f"recorded_with: 'Schemathesis {SCHEMATHESIS_VERSION}'\n"
+                    f"seed: {item.seed}\n"
+                    f"http_interactions:"
+                )
             else:
                 break
 

schemathesis/core/jsonschema/types.py

@@ -17,7 +17,7 @@ def get_type(schema: JsonSchema, *, _check_type: bool = False) -> list[str]:
         return [ty]
     if ty is ANY_TYPE:
         return list(ty)
-    return list(ty)
+    return [t for t in ALL_TYPES if t in ty]
 
 
 def _get_type(schema: JsonSchema) -> list[str]:

schemathesis/generation/hypothesis/__init__.py

@@ -1,4 +1,8 @@
-from typing import Any
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from typing import Any, Literal
 
 
 def setup() -> None:
@@ -9,6 +13,8 @@ def setup() -> None:
     from hypothesis.strategies._internal import collections, core
     from hypothesis.vendor import pretty
     from hypothesis_jsonschema import _canonicalise, _from_schema, _resolve
+    from hypothesis_jsonschema._canonicalise import SCHEMA_KEYS, SCHEMA_OBJECT_KEYS, merged
+    from hypothesis_jsonschema._resolve import LocalResolver
 
     from schemathesis.core import INTERNAL_BUFFER_SIZE
     from schemathesis.core.jsonschema.types import _get_type
@@ -35,11 +41,79 @@ def setup() -> None:
             # depending on the schema size (~300 seconds -> 4.5 seconds in one of the benchmarks)
             return None
 
+    class CacheableSchema:
+        """Cache schema by its JSON representation.
+
+        Canonicalisation is not required as schemas with the same JSON representation
+        will have the same validator.
+        """
+
+        __slots__ = ("schema", "encoded")
+
+        def __init__(self, schema: dict[str, Any]) -> None:
+            self.schema = schema
+            self.encoded = hash(json.dumps(schema, sort_keys=True))
+
+        def __eq__(self, other: "CacheableSchema") -> bool:  # type: ignore
+            return self.encoded == other.encoded
+
+        def __hash__(self) -> int:
+            return self.encoded
+
+    SCHEMA_KEYS = frozenset(SCHEMA_KEYS)
+    SCHEMA_OBJECT_KEYS = frozenset(SCHEMA_OBJECT_KEYS)
+
+    @lru_cache()
+    def get_resolver(cache_key: CacheableSchema) -> LocalResolver:
+        """LRU resolver cache."""
+        return LocalResolver.from_schema(cache_key.schema)
+
+    def resolve_all_refs(
+        schema: Literal[True, False] | dict[str, Any],
+        *,
+        resolver: LocalResolver | None = None,
+    ) -> dict[str, Any]:
+        if schema is True:
+            return {}
+        if schema is False:
+            return {"not": {}}
+        if not schema:
+            return schema
+        if resolver is None:
+            resolver = get_resolver(CacheableSchema(schema))
+
+        _resolve_all_refs = resolve_all_refs
+
+        if "$ref" in schema:
+            s = dict(schema)
+            ref = s.pop("$ref")
+            url, resolved = resolver.resolve(ref)
+            resolver.push_scope(url)
+            try:
+                return merged([s, _resolve_all_refs(deepclone(resolved), resolver=resolver)])  # type: ignore
+            finally:
+                resolver.pop_scope()
+
+        for key, value in schema.items():
+            if key in SCHEMA_KEYS:
+                if isinstance(value, list):
+                    schema[key] = [_resolve_all_refs(v, resolver=resolver) if isinstance(v, dict) else v for v in value]
+                elif isinstance(value, dict):
+                    schema[key] = _resolve_all_refs(value, resolver=resolver)
+            if key in SCHEMA_OBJECT_KEYS:
+                schema[key] = {
+                    k: _resolve_all_refs(v, resolver=resolver) if isinstance(v, dict) else v for k, v in value.items()
+                }
+        return schema
+
     root_core.RepresentationPrinter = RepresentationPrinter  # type: ignore
     _resolve.deepcopy = deepclone  # type: ignore
+    _resolve.resolve_all_refs = resolve_all_refs  # type: ignore
     _from_schema.deepcopy = deepclone  # type: ignore
     _from_schema.get_type = _get_type  # type: ignore
+    _from_schema.resolve_all_refs = resolve_all_refs  # type: ignore
     _canonicalise.get_type = _get_type  # type: ignore
+    _canonicalise.CacheableSchema = CacheableSchema  # type: ignore
     root_core.BUFFER_SIZE = INTERNAL_BUFFER_SIZE  # type: ignore
     engine.BUFFER_SIZE = INTERNAL_BUFFER_SIZE
     collections.BUFFER_SIZE = INTERNAL_BUFFER_SIZE  # type: ignore

{schemathesis-4.2.0.dist-info → schemathesis-4.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.2.0
+Version: 4.2.1
 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.2.0.dist-info → schemathesis-4.2.1.dist-info}/RECORD

@@ -21,7 +21,7 @@ schemathesis/cli/commands/run/loaders.py,sha256=6j0ez7wduAUYbUT28ELKxMf-dYEWr_67
 schemathesis/cli/commands/run/validation.py,sha256=DQaMiBLN2tYT9hONvv8xnyPvNXZH768UlOdUxTd5kZs,9193
 schemathesis/cli/commands/run/handlers/__init__.py,sha256=TPZ3KdGi8m0fjlN0GjA31MAXXn1qI7uU4FtiDwroXZI,1915
 schemathesis/cli/commands/run/handlers/base.py,sha256=qUtDvtr3F6were_BznfnaPpMibGJMnQ5CA9aEzcIUBc,1306
-schemathesis/cli/commands/run/handlers/cassettes.py,sha256=Px1-xBw5t6tg8rzYNM-VBTpe6qvbUu_RsrYBG_RWGt8,19501
+schemathesis/cli/commands/run/handlers/cassettes.py,sha256=LzvQp--Ub5MXF7etet7fQD0Ufloh1R0j2X1o9dT8Z4k,19253
 schemathesis/cli/commands/run/handlers/junitxml.py,sha256=qiFvM4-SlM67sep003SkLqPslzaEb4nOm3bkzw-DO-Q,2602
 schemathesis/cli/commands/run/handlers/output.py,sha256=TwK82zNpIZ7Q76ggTp8gcW2clzrw0WBmHFJMcvYL1nE,63927
 schemathesis/cli/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -72,7 +72,7 @@ schemathesis/core/jsonschema/__init__.py,sha256=gBZGsXIpK2EFfcp8x0b69dqzWAm2OeZH
 schemathesis/core/jsonschema/bundler.py,sha256=ECNAHrXl5nh52crm5Qu1QvRWVV2Vv9gU8H722oKA7k0,7711
 schemathesis/core/jsonschema/keywords.py,sha256=pjseXTfH9OItNs_Qq6ubkhNWQOrxTnwHmrP_jxrHeJU,631
 schemathesis/core/jsonschema/references.py,sha256=uB7-DGYhLFqbIAvuO-IDc9xSatoGw54FOYn4xE4qE6A,4667
-schemathesis/core/jsonschema/types.py,sha256=_B1Q6pFzLqjuLU6mR1JiHsRbuz_pnSmN5HNnbeZJtT0,1223
+schemathesis/core/jsonschema/types.py,sha256=C7f9g8yKFuoxC5_0YNIh8QAyGU0-tj8pzTMfMDjjjVM,1248
 schemathesis/core/output/__init__.py,sha256=SiHqONFskXl73AtP5dV29L14nZoKo7B-IeG52KZB32M,1446
 schemathesis/core/output/sanitization.py,sha256=Ev3tae8dVwsYd7yVb2_1VBFYs92WFsQ4Eu1fGaymItE,2013
 schemathesis/engine/__init__.py,sha256=QaFE-FinaTAaarteADo2RRMJ-Sz6hZB9TzD5KjMinIA,706
@@ -98,7 +98,7 @@ schemathesis/generation/meta.py,sha256=tXhUZBEdpQMn68uMx1SW8Vv59Uf6Wl6yzs-VB9lu_
 schemathesis/generation/metrics.py,sha256=cZU5HdeAMcLFEDnTbNE56NuNq4P0N4ew-g1NEz5-kt4,2836
 schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeXTyU,481
 schemathesis/generation/overrides.py,sha256=xI2djHsa42fzP32xpxgxO52INixKagf5DjDAWJYswM8,3890
-schemathesis/generation/hypothesis/__init__.py,sha256=j_lKp7loYRe63TCzIx5yozyt0Ub1ilSsXEP-2zfJ0Ok,2144
+schemathesis/generation/hypothesis/__init__.py,sha256=Dfdz6_Wa7ez6GxrMBxnWQnLaNjPUweTxfi01jiFqso4,4900
 schemathesis/generation/hypothesis/builder.py,sha256=ZdY68aDGeZLLtIld288KF_O6ardFKZdFMBogwltTx2o,38362
 schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
@@ -172,8 +172,8 @@ schemathesis/transport/prepare.py,sha256=erYXRaxpQokIDzaIuvt_csHcw72iHfCyNq8VNEz
 schemathesis/transport/requests.py,sha256=wriRI9fprTplE_qEZLEz1TerX6GwkE3pwr6ZnU2o6vQ,10648
 schemathesis/transport/serialization.py,sha256=GwO6OAVTmL1JyKw7HiZ256tjV4CbrRbhQN0ep1uaZwI,11157
 schemathesis/transport/wsgi.py,sha256=kQtasFre6pjdJWRKwLA_Qb-RyQHCFNpaey9ubzlFWKI,5907
-schemathesis-4.2.0.dist-info/METADATA,sha256=kkIlvuG4NKfAwk6kzHRslKYeYaaFhfSYciy9777c4L0,8540
-schemathesis-4.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.2.0.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.2.0.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.2.0.dist-info/RECORD,,
+schemathesis-4.2.1.dist-info/METADATA,sha256=66gKdf-zvd-gHePTQubZs_QnlCvuuC3fELYv4hHK8NY,8540
+schemathesis-4.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.2.1.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.2.1.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.2.1.dist-info/RECORD,,