schemathesis 3.15.4__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/specs/openapi/expressions/__init__.py

@@ -2,19 +2,66 @@
 
 https://swagger.io/docs/specification/links/#runtime-expressions
 """
+
+from __future__ import annotations
+
+import json
 from typing import Any
 
+from schemathesis.core.transforms import UNRESOLVABLE, Unresolvable
+from schemathesis.generation.stateful.state_machine import StepOutput
+
 from . import lexer, nodes, parser
-from .context import ExpressionContext
+
+__all__ = ["lexer", "nodes", "parser"]
 
 
-def evaluate(expr: Any, context: ExpressionContext) -> str:
+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, 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(map(str, parts))
+    if any(isinstance(part, Unresolvable) for part in parts):
+        return UNRESOLVABLE
+    return "".join(str(part) for part in parts if part is not None)
+
+
+def _evaluate_nested(expr: dict[str, Any] | list, output: StepOutput) -> Any:
+    if isinstance(expr, dict):
+        result_dict = {}
+        for key, value in expr.items():
+            new_key = _evaluate_object_key(key, output)
+            if new_key is UNRESOLVABLE:
+                return new_key
+            new_value = evaluate(value, output, evaluate_nested=True)
+            if new_value is UNRESOLVABLE:
+                return new_value
+            result_dict[new_key] = new_value
+        return result_dict
+    result_list = []
+    for item in expr:
+        new_value = evaluate(item, output, evaluate_nested=True)
+        if new_value is UNRESOLVABLE:
+            return new_value
+        result_list.append(new_value)
+    return result_list
+
+
+def _evaluate_object_key(key: str, output: StepOutput) -> Any:
+    evaluated = evaluate(key, output)
+    if evaluated is UNRESOLVABLE:
+        return evaluated
+    if isinstance(evaluated, str):
+        return evaluated
+    if isinstance(evaluated, bool):
+        return "true" if evaluated else "false"
+    if isinstance(evaluated, (int, float)):
+        return str(evaluated)
+    if evaluated is None:
+        return "null"
+    return json.dumps(evaluated)

schemathesis/specs/openapi/expressions/extractors.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass
+class Extractor:
+    def extract(self, value: str) -> str | None:
+        raise NotImplementedError
+
+
+@dataclass
+class RegexExtractor(Extractor):
+    """Extract value via a regex."""
+
+    value: re.Pattern
+
+    __slots__ = ("value",)
+
+    def extract(self, value: str) -> str | None:
+        match = self.value.search(value)
+        if match is None:
+            return None
+        return match.group(1)

schemathesis/specs/openapi/expressions/lexer.py

@@ -1,52 +1,55 @@
 """Lexical analysis of runtime expressions."""
+
+from dataclasses import dataclass
 from enum import Enum, unique
 from typing import Callable, Generator
 
-import attr
-
 
-@unique  # pragma: no mutate
-class TokenType(Enum):
-    VARIABLE = 1  # pragma: no mutate
-    STRING = 2  # pragma: no mutate
-    POINTER = 3  # pragma: no mutate
-    DOT = 4  # pragma: no mutate
-    LBRACKET = 5  # pragma: no mutate
-    RBRACKET = 6  # pragma: no mutate
+@unique
+class TokenType(int, Enum):
+    VARIABLE = 1
+    STRING = 2
+    POINTER = 3
+    DOT = 4
+    LBRACKET = 5
+    RBRACKET = 6
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Token:
     """Lexical token that may occur in a runtime expression."""
 
-    value: str = attr.ib()  # pragma: no mutate
-    type_: TokenType = attr.ib()  # pragma: no mutate
+    value: str
+    end: int
+    type_: TokenType
+
+    __slots__ = ("value", "end", "type_")
 
     # Helpers for cleaner instantiation
 
     @classmethod
-    def variable(cls, value: str) -> "Token":
-        return cls(value, TokenType.VARIABLE)
+    def variable(cls, value: str, end: int) -> "Token":
+        return cls(value, end, TokenType.VARIABLE)
 
     @classmethod
-    def string(cls, value: str) -> "Token":
-        return cls(value, TokenType.STRING)
+    def string(cls, value: str, end: int) -> "Token":
+        return cls(value, end, TokenType.STRING)
 
     @classmethod
-    def pointer(cls, value: str) -> "Token":
-        return cls(value, TokenType.POINTER)
+    def pointer(cls, value: str, end: int) -> "Token":
+        return cls(value, end, TokenType.POINTER)
 
     @classmethod
-    def lbracket(cls) -> "Token":
-        return cls("{", TokenType.LBRACKET)
+    def lbracket(cls, end: int) -> "Token":
+        return cls("{", end, TokenType.LBRACKET)
 
     @classmethod
-    def rbracket(cls) -> "Token":
-        return cls("}", TokenType.RBRACKET)
+    def rbracket(cls, end: int) -> "Token":
+        return cls("}", end, TokenType.RBRACKET)
 
     @classmethod
-    def dot(cls) -> "Token":
-        return cls(".", TokenType.DOT)
+    def dot(cls, end: int) -> "Token":
+        return cls(".", end, TokenType.DOT)
 
     # Helpers for simpler type comparison
 
@@ -103,15 +106,15 @@ def tokenize(expression: str) -> TokenGenerator:
         if current_symbol() == "$":
             start = cursor
             move_until(lambda: is_eol() or current_symbol() in stop_symbols)
-            yield Token.variable(expression[start:cursor])
+            yield Token.variable(expression[start:cursor], cursor - 1)
         elif current_symbol() == ".":
-            yield Token.dot()
+            yield Token.dot(cursor)
             move()
         elif current_symbol() == "{":
-            yield Token.lbracket()
+            yield Token.lbracket(cursor)
             move()
         elif current_symbol() == "}":
-            yield Token.rbracket()
+            yield Token.rbracket(cursor)
             move()
         elif current_symbol() == "#":
             start = cursor
@@ -126,8 +129,8 @@ def tokenize(expression: str) -> TokenGenerator:
             # `ID_{$response.body#/foo}_{$response.body#/bar}`
             # Which is much easier if we treat `}` as a closing bracket of an embedded runtime expression
             move_until(lambda: is_eol() or current_symbol() == "}")
-            yield Token.pointer(expression[start:cursor])
+            yield Token.pointer(expression[start:cursor], cursor - 1)
         else:
             start = cursor
             move_until(lambda: is_eol() or current_symbol() in stop_symbols)
-            yield Token.string(expression[start:cursor])
+            yield Token.string(expression[start:cursor], cursor - 1)

schemathesis/specs/openapi/expressions/nodes.py

@@ -1,25 +1,31 @@
 """Expression nodes description and evaluation logic."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
 from enum import Enum, unique
-from typing import Any, Dict, Optional, Union
+from typing import TYPE_CHECKING, Any, cast
 
-import attr
 from requests.structures import CaseInsensitiveDict
 
-from ....utils import WSGIResponse
-from . import pointers
-from .context import ExpressionContext
+from schemathesis.core.transforms import UNRESOLVABLE, Unresolvable, resolve_pointer
+from schemathesis.generation.stateful.state_machine import StepOutput
+from schemathesis.transport.requests import REQUESTS_TRANSPORT
 
+if TYPE_CHECKING:
+    from .extractors import Extractor
 
-@attr.s(slots=True)  # pragma: no mutate
+
+@dataclass
 class Node:
     """Generic expression node."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         raise NotImplementedError
 
 
 @unique
-class NodeType(Enum):
+class NodeType(str, Enum):
     URL = "$url"
     METHOD = "$method"
     STATUS_CODE = "$statusCode"
@@ -27,13 +33,15 @@ class NodeType(Enum):
     RESPONSE = "$response"
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class String(Node):
     """A simple string that is not evaluated somehow specifically."""
 
-    value: str = attr.ib()  # pragma: no mutate
+    value: str
+
+    __slots__ = ("value",)
 
-    def evaluate(self, context: ExpressionContext) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         """String tokens are passed as they are.
 
         ``foo{$request.path.id}``
@@ -43,83 +51,126 @@ class String(Node):
         return self.value
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class URL(Node):
     """A node for `$url` expression."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        return context.case.get_full_url()
+    __slots__ = ()
 
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
+        import requests
 
-@attr.s(slots=True)  # pragma: no mutate
+        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()
+    __slots__ = ()
 
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
+        return output.case.operation.method.upper()
 
-@attr.s(slots=True)  # pragma: no mutate
+
+@dataclass
 class StatusCode(Node):
     """A node for `$statusCode` expression."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        return str(context.response.status_code)
+    __slots__ = ()
+
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
+        return str(output.response.status_code)
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class NonBodyRequest(Node):
     """A node for `$request` expressions where location is not `body`."""
 
-    location: str = attr.ib()  # pragma: no mutate
-    parameter: str = attr.ib()  # pragma: no mutate
+    location: str
+    parameter: str
+    extractor: Extractor | None
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        container: Union[Dict, CaseInsensitiveDict] = {
-            "query": context.case.query,
-            "path": context.case.path_parameters,
-            "header": context.case.headers,
+    __slots__ = ("location", "parameter", "extractor")
+
+    def __init__(self, location: str, parameter: str, extractor: Extractor | None = None) -> None:
+        self.location = location
+        self.parameter = parameter
+        self.extractor = extractor
+
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
+        container = {
+            "query": output.case.query,
+            "path": output.case.path_parameters,
+            "header": output.case.headers,
         }[self.location] or {}
         if self.location == "header":
             container = CaseInsensitiveDict(container)
-        return container[self.parameter]
+        value = container.get(self.parameter)
+        if value is None:
+            return UNRESOLVABLE
+        if self.extractor is not None:
+            return self.extractor.extract(value) or UNRESOLVABLE
+        return value
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class BodyRequest(Node):
     """A node for `$request` expressions where location is `body`."""
 
-    pointer: Optional[str] = attr.ib(default=None)  # pragma: no mutate
+    pointer: str | None
+
+    __slots__ = ("pointer",)
+
+    def __init__(self, pointer: str | None = None) -> None:
+        self.pointer = pointer
 
-    def evaluate(self, context: ExpressionContext) -> Any:
-        document = context.case.body
+    def evaluate(self, output: StepOutput) -> Any | Unresolvable:
+        document = output.case.body
         if self.pointer is None:
             return document
-        return pointers.resolve(document, self.pointer[1:])
+        return resolve_pointer(document, self.pointer[1:])
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class HeaderResponse(Node):
     """A node for `$response.header` expressions."""
 
-    parameter: str = attr.ib()  # pragma: no mutate
+    parameter: str
+    extractor: Extractor | None
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        return context.response.headers[self.parameter]
+    __slots__ = ("parameter", "extractor")
 
+    def __init__(self, parameter: str, extractor: Extractor | None = None) -> None:
+        self.parameter = parameter
+        self.extractor = extractor
 
-@attr.s(slots=True)  # pragma: no mutate
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
+        value = output.response.headers.get(self.parameter.lower())
+        if value is None:
+            return UNRESOLVABLE
+        if self.extractor is not None:
+            return self.extractor.extract(value[0]) or UNRESOLVABLE
+        return value[0]
+
+
+@dataclass
 class BodyResponse(Node):
     """A node for `$response.body` expressions."""
 
-    pointer: Optional[str] = attr.ib(default=None)  # pragma: no mutate
+    pointer: str | None
+
+    __slots__ = ("pointer",)
+
+    def __init__(self, pointer: str | None = None) -> None:
+        self.pointer = pointer
 
-    def evaluate(self, context: ExpressionContext) -> Any:
-        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
-        return pointers.resolve(document, self.pointer[1:])
+        return resolve_pointer(document, self.pointer[1:])

schemathesis/specs/openapi/expressions/parser.py

@@ -1,21 +1,24 @@
+from __future__ import annotations
+
+import re
 from functools import lru_cache
-from typing import Generator, List, Union
+from typing import Generator
 
-from . import lexer, nodes
+from . import extractors, lexer, nodes
 from .errors import RuntimeExpressionError, UnknownToken
 
 
-@lru_cache()  # pragma: no mutate
-def parse(expr: str) -> List[nodes.Node]:
+@lru_cache
+def parse(expr: str) -> list[nodes.Node]:
     """Parse lexical tokens into concrete expression nodes."""
     return list(_parse(expr))
 
 
 def _parse(expr: str) -> Generator[nodes.Node, None, None]:
     tokens = lexer.tokenize(expr)
-    brackets_stack: List[str] = []
+    brackets_stack: list[str] = []
     for token in tokens:
-        if token.is_string:
+        if token.is_string or token.is_dot:
             yield nodes.String(token.value)
         elif token.is_variable:
             yield from _parse_variable(tokens, token, expr)
@@ -43,16 +46,17 @@ def _parse_variable(tokens: lexer.TokenGenerator, token: lexer.Token, expr: str)
     elif token.value == nodes.NodeType.RESPONSE.value:
         yield _parse_response(tokens, expr)
     else:
-        raise UnknownToken(token.value)
+        raise UnknownToken(f"Invalid expression `{expr}`. Unknown token: `{token.value}`")
 
 
-def _parse_request(tokens: lexer.TokenGenerator, expr: str) -> Union[nodes.BodyRequest, nodes.NonBodyRequest]:
+def _parse_request(tokens: lexer.TokenGenerator, expr: str) -> nodes.BodyRequest | nodes.NonBodyRequest:
     skip_dot(tokens, "$request")
     location = next(tokens)
     if location.value in ("query", "path", "header"):
         skip_dot(tokens, f"$request.{location.value}")
         parameter = take_string(tokens, expr)
-        return nodes.NonBodyRequest(location.value, parameter)
+        extractor = take_extractor(tokens, expr, parameter.end)
+        return nodes.NonBodyRequest(location.value, parameter.value, extractor)
     if location.value == "body":
         try:
             token = next(tokens)
@@ -63,13 +67,14 @@ def _parse_request(tokens: lexer.TokenGenerator, expr: str) -> Union[nodes.BodyR
     raise RuntimeExpressionError(f"Invalid expression: {expr}")
 
 
-def _parse_response(tokens: lexer.TokenGenerator, expr: str) -> Union[nodes.HeaderResponse, nodes.BodyResponse]:
+def _parse_response(tokens: lexer.TokenGenerator, expr: str) -> nodes.HeaderResponse | nodes.BodyResponse:
     skip_dot(tokens, "$response")
     location = next(tokens)
     if location.value == "header":
         skip_dot(tokens, f"$response.{location.value}")
         parameter = take_string(tokens, expr)
-        return nodes.HeaderResponse(parameter)
+        extractor = take_extractor(tokens, expr, parameter.end)
+        return nodes.HeaderResponse(parameter.value, extractor=extractor)
     if location.value == "body":
         try:
             token = next(tokens)
@@ -86,8 +91,25 @@ def skip_dot(tokens: lexer.TokenGenerator, name: str) -> None:
         raise RuntimeExpressionError(f"`{name}` expression should be followed by a dot (`.`). Got: {token.value}")
 
 
-def take_string(tokens: lexer.TokenGenerator, expr: str) -> str:
+def take_string(tokens: lexer.TokenGenerator, expr: str) -> lexer.Token:
     parameter = next(tokens)
     if not parameter.is_string:
         raise RuntimeExpressionError(f"Invalid expression: {expr}")
-    return parameter.value
+    return parameter
+
+
+def take_extractor(tokens: lexer.TokenGenerator, expr: str, current_end: int) -> extractors.Extractor | None:
+    rest = expr[current_end + 1 :]
+    if not rest or rest.startswith("}"):
+        return None
+    extractor = next(tokens)
+    if not extractor.value.startswith("#regex:"):
+        raise RuntimeExpressionError(f"Invalid extractor: {expr}")
+    pattern = extractor.value[len("#regex:") :]
+    try:
+        compiled = re.compile(pattern)
+    except re.error as exc:
+        raise RuntimeExpressionError(f"Invalid regex extractor: {exc}") from None
+    if compiled.groups != 1:
+        raise RuntimeExpressionError("Regex extractor should have exactly one capturing group")
+    return extractors.RegexExtractor(compiled)

schemathesis/specs/openapi/formats.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import platform
+import string
+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
+
+
+IS_PYPY = platform.python_implementation() == "PyPy"
+STRING_FORMATS: dict[str, st.SearchStrategy] = {}
+# For some reason PyPy can't send header values with codepoints > 128, while CPython can
+if IS_PYPY:
+    MAX_HEADER_CODEPOINT = 128
+    DEFAULT_HEADER_EXCLUDE_CHARACTERS = "\n\r\x1f\x1e\x1d\x1c"
+else:
+    MAX_HEADER_CODEPOINT = 255
+    DEFAULT_HEADER_EXCLUDE_CHARACTERS = "\n\r"
+
+
+def register_string_format(name: str, strategy: st.SearchStrategy) -> None:
+    r"""Register a custom Hypothesis strategy for generating string format data.
+
+    Args:
+        name: String format name that matches the "format" keyword in your API schema
+        strategy: Hypothesis strategy to generate values for this format
+
+    Example:
+        ```python
+        import schemathesis
+        from hypothesis import strategies as st
+
+        # Register phone number format
+        phone_strategy = st.from_regex(r"\+1-\d{3}-\d{3}-\d{4}")
+        schemathesis.openapi.format("phone", phone_strategy)
+
+        # Register email with specific domain
+        email_strategy = st.from_regex(r"[a-z]+@company\.com")
+        schemathesis.openapi.format("company-email", email_strategy)
+        ```
+
+    Schema usage:
+        ```yaml
+        properties:
+          phone:
+            type: string
+            format: phone          # Uses your phone_strategy
+          contact_email:
+            type: string
+            format: company-email  # Uses your email_strategy
+        ```
+
+    """
+    from hypothesis.strategies import SearchStrategy
+
+    if not isinstance(name, str):
+        raise TypeError(f"name must be of type {str}, not {type(name)}")
+    if not isinstance(strategy, SearchStrategy):
+        raise TypeError(f"strategy must be of type {SearchStrategy}, not {type(strategy)}")
+
+    STRING_FORMATS[name] = strategy
+
+
+def unregister_string_format(name: str) -> None:
+    """Remove format strategy from the registry."""
+    try:
+        del STRING_FORMATS[name]
+    except KeyError as exc:
+        raise ValueError(f"Unknown Open API format: {name}") from exc
+
+
+def header_values(
+    codec: str | None = None, exclude_characters: str = DEFAULT_HEADER_EXCLUDE_CHARACTERS
+) -> st.SearchStrategy[str]:
+    from hypothesis import strategies as st
+
+    return st.text(
+        alphabet=st.characters(
+            min_codepoint=0, max_codepoint=MAX_HEADER_CODEPOINT, codec=codec, exclude_characters=exclude_characters
+        )
+        # Header values with leading non-visible chars can't be sent with `requests`
+    ).map(str.lstrip)
+
+
+HEADER_FORMAT = "_header_value"
+
+
+@lru_cache
+def get_default_format_strategies() -> dict[str, st.SearchStrategy]:
+    """Get all default "format" strategies."""
+    from hypothesis import strategies as st
+    from requests.auth import _basic_auth_str
+
+    def make_basic_auth_str(item: tuple[str, str]) -> str:
+        return _basic_auth_str(*item)
+
+    latin1_text = st.text(alphabet=st.characters(min_codepoint=0, max_codepoint=255))
+
+    # Define valid characters here to avoid filtering them out in `is_valid_header` later
+    header_value = header_values()
+
+    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)
+        ),
+        HEADER_FORMAT: header_value,
+        "_basic_auth": st.tuples(latin1_text, latin1_text).map(make_basic_auth_str),
+        "_bearer_auth": header_value.map("Bearer {}".format),
+    }
+
+
+register = register_string_format
+unregister = unregister_string_format