schemathesis 3.39.7__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/specs/openapi/converter.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 from itertools import chain
 from typing import Any, Callable
 
-from ...internal.copy import fast_deepcopy
-from ...internal.jsonschema import traverse_schema
+from schemathesis.core.transforms import deepclone, transform
+
 from .patterns import update_quantifier
 
 
@@ -22,7 +22,7 @@ def to_json_schema(
     See a recursive version below.
     """
     if copy:
-        schema = fast_deepcopy(schema)
+        schema = deepclone(schema)
     if schema.get(nullable_name) is True:
         del schema[nullable_name]
         schema = {"anyOf": [schema, {"type": "null"}]}
@@ -94,7 +94,7 @@ def is_read_only(schema: dict[str, Any] | bool) -> bool:
 def to_json_schema_recursive(
     schema: dict[str, Any], nullable_name: str, is_response_schema: bool = False, update_quantifiers: bool = True
 ) -> dict[str, Any]:
-    return traverse_schema(
+    return transform(
         schema,
         to_json_schema,
         nullable_name=nullable_name,

schemathesis/specs/openapi/definitions.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from ..._lazy_import import lazy_import
+from schemathesis.core.lazy_import import lazy_import
 
 if TYPE_CHECKING:
     from jsonschema import Validator

schemathesis/specs/openapi/examples.py

@@ -9,11 +9,15 @@ from typing import TYPE_CHECKING, Any, Generator, Iterator, Union, cast
 import requests
 from hypothesis_jsonschema import from_schema
 
-from ...constants import DEFAULT_RESPONSE_TIMEOUT
-from ...generation import get_single_example
-from ...internal.copy import fast_deepcopy
-from ...models import APIOperation, Case, TestPhase
-from ._hypothesis import get_case_strategy, get_default_format_strategies
+from schemathesis.core.transforms import deepclone
+from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT
+from schemathesis.generation import GenerationConfig
+from schemathesis.generation.case import Case
+from schemathesis.generation.hypothesis import examples
+from schemathesis.generation.meta import TestPhase
+from schemathesis.schemas import APIOperation
+
+from ._hypothesis import get_default_format_strategies, openapi_cases
 from .constants import LOCATION_TO_CONTAINER
 from .formats import STRING_FORMATS
 from .parameters import OpenAPIBody, OpenAPIParameter
@@ -21,8 +25,6 @@ from .parameters import OpenAPIBody, OpenAPIParameter
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy
 
-    from ...generation import GenerationConfig
-
 
 @dataclass
 class ParameterExample:
@@ -45,7 +47,7 @@ Example = Union[ParameterExample, BodyExample]
 
 
 def get_strategies_from_examples(
-    operation: APIOperation[OpenAPIParameter, Case], as_strategy_kwargs: dict[str, Any] | None = None
+    operation: APIOperation[OpenAPIParameter], **kwargs: Any
 ) -> list[SearchStrategy[Case]]:
     """Build a set of strategies that generate test cases based on explicit examples in the schema."""
     maps = {}
@@ -68,15 +70,15 @@ def get_strategies_from_examples(
     examples = list(extract_top_level(operation))
     # Add examples from parameter's schemas
     examples.extend(extract_from_schemas(operation))
-    as_strategy_kwargs = as_strategy_kwargs or {}
-    as_strategy_kwargs["phase"] = TestPhase.EXPLICIT
     return [
-        get_case_strategy(operation=operation, **{**parameters, **(as_strategy_kwargs or {})}).map(serialize_components)
+        openapi_cases(operation=operation, **{**parameters, **kwargs, "phase": TestPhase.EXPLICIT}).map(
+            serialize_components
+        )
         for parameters in produce_combinations(examples)
     ]
 
 
-def extract_top_level(operation: APIOperation[OpenAPIParameter, Case]) -> Generator[Example, None, None]:
+def extract_top_level(operation: APIOperation[OpenAPIParameter]) -> Generator[Example, None, None]:
     """Extract top-level parameter examples from `examples` & `example` fields."""
     responses = find_in_responses(operation)
     for parameter in operation.iter_parameters():
@@ -144,7 +146,7 @@ def _expand_subschemas(schema: dict[str, Any] | bool) -> Generator[dict[str, Any
                 for subschema in schema[key]:
                     yield subschema
         if "allOf" in schema:
-            subschema = fast_deepcopy(schema["allOf"][0])
+            subschema = deepclone(schema["allOf"][0])
             for sub in schema["allOf"][1:]:
                 if isinstance(sub, dict):
                     for key, value in sub.items():
@@ -162,7 +164,7 @@ def _expand_subschemas(schema: dict[str, Any] | bool) -> Generator[dict[str, Any
 
 
 def _find_parameter_examples_definition(
-    operation: APIOperation[OpenAPIParameter, Case], parameter_name: str, field_name: str
+    operation: APIOperation[OpenAPIParameter], parameter_name: str, field_name: str
 ) -> dict[str, Any]:
     """Find the original, unresolved `examples` definition of a parameter."""
     from .schemas import BaseOpenAPISchema
@@ -180,13 +182,13 @@ def _find_parameter_examples_definition(
 
 
 def _find_request_body_examples_definition(
-    operation: APIOperation[OpenAPIParameter, Case], alternative: OpenAPIBody
+    operation: APIOperation[OpenAPIParameter], alternative: OpenAPIBody
 ) -> dict[str, Any]:
     """Find the original, unresolved `examples` definition of a request body variant."""
     from .schemas import BaseOpenAPISchema
 
     schema = cast(BaseOpenAPISchema, operation.schema)
-    if schema.spec_version == "2.0":
+    if schema.specification.version == "2.0":
         raw_schema = schema.raw_schema
         path_data = raw_schema["paths"][operation.path]
         parameters = chain(path_data[operation.method].get("parameters", []), path_data.get("parameters", []))
@@ -222,12 +224,12 @@ def extract_inner_examples(
 @lru_cache
 def load_external_example(url: str) -> bytes:
     """Load examples the `externalValue` keyword."""
-    response = requests.get(url, timeout=DEFAULT_RESPONSE_TIMEOUT / 1000)
+    response = requests.get(url, timeout=DEFAULT_RESPONSE_TIMEOUT)
     response.raise_for_status()
     return response.content
 
 
-def extract_from_schemas(operation: APIOperation[OpenAPIParameter, Case]) -> Generator[Example, None, None]:
+def extract_from_schemas(operation: APIOperation[OpenAPIParameter]) -> Generator[Example, None, None]:
     """Extract examples from parameters' schema definitions."""
     for parameter in operation.iter_parameters():
         schema = parameter.as_json_schema(operation)
@@ -244,7 +246,7 @@ def extract_from_schemas(operation: APIOperation[OpenAPIParameter, Case]) -> Gen
 
 
 def extract_from_schema(
-    operation: APIOperation[OpenAPIParameter, Case],
+    operation: APIOperation[OpenAPIParameter],
     schema: dict[str, Any],
     example_field_name: str,
     examples_field_name: str,
@@ -306,7 +308,7 @@ def _generate_single_example(
         allow_x00=generation_config.allow_x00,
         codec=generation_config.codec,
     )
-    return get_single_example(strategy)
+    return examples.generate_one(strategy)
 
 
 def produce_combinations(examples: list[Example]) -> Generator[dict[str, Any], None, None]:

schemathesis/specs/openapi/expressions/__init__.py

@@ -8,42 +8,38 @@ from __future__ import annotations
 import json
 from typing import Any
 
+from schemathesis.generation.stateful.state_machine import StepOutput
+
 from . import lexer, nodes, parser
-from .context import ExpressionContext
 
-__all__ = [
-    "lexer",
-    "nodes",
-    "parser",
-    "ExpressionContext",
-]
+__all__ = ["lexer", "nodes", "parser"]
 
 
-def evaluate(expr: Any, context: ExpressionContext, evaluate_nested: bool = False) -> Any:
+def evaluate(expr: Any, output: StepOutput, evaluate_nested: bool = False) -> Any:
     """Evaluate runtime expression in context."""
     if isinstance(expr, (dict, list)) and evaluate_nested:
-        return _evaluate_nested(expr, context)
+        return _evaluate_nested(expr, output)
     if not isinstance(expr, str):
         # Can be a non-string constant
         return expr
-    parts = [node.evaluate(context) for node in parser.parse(expr)]
+    parts = [node.evaluate(output) for node in parser.parse(expr)]
     if len(parts) == 1:
         return parts[0]  # keep the return type the same as the internal value type
     # otherwise, concatenate into a string
     return "".join(str(part) for part in parts if part is not None)
 
 
-def _evaluate_nested(expr: dict[str, Any] | list, context: ExpressionContext) -> Any:
+def _evaluate_nested(expr: dict[str, Any] | list, output: StepOutput) -> Any:
     if isinstance(expr, dict):
         return {
-            _evaluate_object_key(key, context): evaluate(value, context, evaluate_nested=True)
+            _evaluate_object_key(key, output): evaluate(value, output, evaluate_nested=True)
             for key, value in expr.items()
         }
-    return [evaluate(item, context, evaluate_nested=True) for item in expr]
+    return [evaluate(item, output, evaluate_nested=True) for item in expr]
 
 
-def _evaluate_object_key(key: str, context: ExpressionContext) -> Any:
-    evaluated = evaluate(key, context)
+def _evaluate_object_key(key: str, output: StepOutput) -> Any:
+    evaluated = evaluate(key, output)
     if isinstance(evaluated, str):
         return evaluated
     if isinstance(evaluated, bool):

schemathesis/specs/openapi/expressions/extractors.py

@@ -1,10 +1,7 @@
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    import re
 
 
 @dataclass

schemathesis/specs/openapi/expressions/nodes.py

@@ -4,14 +4,15 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import Enum, unique
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from requests.structures import CaseInsensitiveDict
 
-from .. import references
+from schemathesis.core.transforms import UNRESOLVABLE, resolve_pointer
+from schemathesis.generation.stateful.state_machine import StepOutput
+from schemathesis.transport.requests import REQUESTS_TRANSPORT
 
 if TYPE_CHECKING:
-    from .context import ExpressionContext
     from .extractors import Extractor
 
 
@@ -19,7 +20,7 @@ if TYPE_CHECKING:
 class Node:
     """Generic expression node."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
+    def evaluate(self, output: StepOutput) -> str:
         raise NotImplementedError
 
 
@@ -38,7 +39,7 @@ class String(Node):
 
     value: str
 
-    def evaluate(self, context: ExpressionContext) -> str:
+    def evaluate(self, output: StepOutput) -> str:
         """String tokens are passed as they are.
 
         ``foo{$request.path.id}``
@@ -52,24 +53,29 @@ class String(Node):
 class URL(Node):
     """A node for `$url` expression."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        return context.case.get_full_url()
+    def evaluate(self, output: StepOutput) -> str:
+        import requests
+
+        base_url = output.case.operation.base_url or "http://127.0.0.1"
+        kwargs = REQUESTS_TRANSPORT.serialize_case(output.case, base_url=base_url)
+        prepared = requests.Request(**kwargs).prepare()
+        return cast(str, prepared.url)
 
 
 @dataclass
 class Method(Node):
     """A node for `$method` expression."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        return context.case.operation.method.upper()
+    def evaluate(self, output: StepOutput) -> str:
+        return output.case.operation.method.upper()
 
 
 @dataclass
 class StatusCode(Node):
     """A node for `$statusCode` expression."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        return str(context.response.status_code)
+    def evaluate(self, output: StepOutput) -> str:
+        return str(output.response.status_code)
 
 
 @dataclass
@@ -80,11 +86,11 @@ class NonBodyRequest(Node):
     parameter: str
     extractor: Extractor | None = None
 
-    def evaluate(self, context: ExpressionContext) -> str:
+    def evaluate(self, output: StepOutput) -> str:
         container: dict | CaseInsensitiveDict = {
-            "query": context.case.query,
-            "path": context.case.path_parameters,
-            "header": context.case.headers,
+            "query": output.case.query,
+            "path": output.case.path_parameters,
+            "header": output.case.headers,
         }[self.location] or {}
         if self.location == "header":
             container = CaseInsensitiveDict(container)
@@ -102,12 +108,12 @@ class BodyRequest(Node):
 
     pointer: str | None = None
 
-    def evaluate(self, context: ExpressionContext) -> Any:
-        document = context.case.body
+    def evaluate(self, output: StepOutput) -> Any:
+        document = output.case.body
         if self.pointer is None:
             return document
-        resolved = references.resolve_pointer(document, self.pointer[1:])
-        if resolved is references.UNRESOLVABLE:
+        resolved = resolve_pointer(document, self.pointer[1:])
+        if resolved is UNRESOLVABLE:
             return None
         return resolved
 
@@ -119,13 +125,13 @@ class HeaderResponse(Node):
     parameter: str
     extractor: Extractor | None = None
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        value = context.response.headers.get(self.parameter)
+    def evaluate(self, output: StepOutput) -> str:
+        value = output.response.headers.get(self.parameter.lower())
         if value is None:
             return ""
         if self.extractor is not None:
-            return self.extractor.extract(value) or ""
-        return value
+            return self.extractor.extract(value[0]) or ""
+        return value[0]
 
 
 @dataclass
@@ -134,17 +140,12 @@ class BodyResponse(Node):
 
     pointer: str | None = None
 
-    def evaluate(self, context: ExpressionContext) -> Any:
-        from ....transports.responses import WSGIResponse
-
-        if isinstance(context.response, WSGIResponse):
-            document = context.response.json
-        else:
-            document = context.response.json()
+    def evaluate(self, output: StepOutput) -> Any:
+        document = output.response.json()
         if self.pointer is None:
             # We need the parsed document - data will be serialized before sending to the application
             return document
-        resolved = references.resolve_pointer(document, self.pointer[1:])
-        if resolved is references.UNRESOLVABLE:
+        resolved = resolve_pointer(document, self.pointer[1:])
+        if resolved is UNRESOLVABLE:
             return None
         return resolved

schemathesis/specs/openapi/formats.py

@@ -5,6 +5,8 @@ from base64 import b64encode
 from functools import lru_cache
 from typing import TYPE_CHECKING
 
+from schemathesis.transport.serialization import Binary
+
 if TYPE_CHECKING:
     from hypothesis import strategies as st
 
@@ -54,8 +56,6 @@ def get_default_format_strategies() -> dict[str, st.SearchStrategy]:
     from hypothesis import strategies as st
     from requests.auth import _basic_auth_str
 
-    from ...serializers import Binary
-
     def make_basic_auth_str(item: tuple[str, str]) -> str:
         return _basic_auth_str(*item)
 
@@ -67,6 +67,7 @@ def get_default_format_strategies() -> dict[str, st.SearchStrategy]:
     return {
         "binary": st.binary().map(Binary),
         "byte": st.binary().map(lambda x: b64encode(x).decode()),
+        "uuid": st.uuids().map(str),
         # RFC 7230, Section 3.2.6
         "_header_name": st.text(
             min_size=1, alphabet=st.sampled_from("!#$%&'*+-.^_`|~" + string.digits + string.ascii_letters)