schemathesis 3.38.9__tar.gz → 3.38.10__tar.gz

{schemathesis-3.38.9 → schemathesis-3.38.10}/.pre-commit-config.yaml

@@ -38,12 +38,12 @@ repos:
         additional_dependencies: [types-click, types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.1
+    rev: v0.8.2
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.1
+    rev: v0.8.2
     hooks:
       - id: ruff
 

{schemathesis-3.38.9 → schemathesis-3.38.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.38.9
+Version: 3.38.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://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-3.38.9 → schemathesis-3.38.10}/docs/changelog.rst

@@ -1,8 +1,17 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.38.9...HEAD>` - TBD
---------------------------------------------
+:version:`Unreleased <v3.38.10...HEAD>` - TBD
+---------------------------------------------
+
+.. _v3.38.10:
+
+:version:`3.38.10 <v3.38.9...v3.38.10>` - 2024-12-11
+----------------------------------------------------
+
+**Fixed**
+
+- Ignored request-related configuration inside the ``ignored_auth`` check. :issue:`2613`
 
 .. _v3.38.9:
 

{schemathesis-3.38.9 → schemathesis-3.38.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.38.9"
+version = "3.38.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-3.38.9 → schemathesis-3.38.10}/src/schemathesis/internal/checks.py

@@ -52,6 +52,7 @@ class CheckContext:
     auth: HTTPDigestAuth | RawAuth | None
     headers: CaseInsensitiveDict | None
     config: CheckConfig = field(default_factory=CheckConfig)
+    transport_kwargs: dict | None = None
 
 
 def wrap_check(check: Callable) -> CheckFunction:

{schemathesis-3.38.9 → schemathesis-3.38.10}/src/schemathesis/models.py

@@ -474,6 +474,7 @@ class Case:
         excluded_checks: tuple[CheckFunction, ...] = (),
         code_sample_style: str | None = None,
         headers: dict[str, Any] | None = None,
+        transport_kwargs: dict[str, Any] | None = None,
     ) -> None:
         """Validate application response.
 
@@ -507,7 +508,10 @@ class Case:
         additional_checks = tuple(check for check in _additional_checks if check not in excluded_checks)
         failed_checks = []
         ctx = CheckContext(
-            override=self._override, auth=None, headers=CaseInsensitiveDict(headers) if headers else None
+            override=self._override,
+            auth=None,
+            headers=CaseInsensitiveDict(headers) if headers else None,
+            transport_kwargs=transport_kwargs,
         )
         for check in chain(checks, additional_checks):
             copied_case = self.partial_deepcopy()
@@ -591,6 +595,7 @@ class Case:
             headers=headers,
             additional_checks=additional_checks,
             excluded_checks=excluded_checks,
+            transport_kwargs=kwargs,
         )
         return response
 

{schemathesis-3.38.9 → schemathesis-3.38.10}/src/schemathesis/runner/impl/core.py

@@ -994,18 +994,18 @@ def _network_test(
     max_response_time: int | None,
 ) -> requests.Response:
     check_results: list[Check] = []
+    hook_context = HookContext(operation=case.operation)
+    kwargs: dict[str, Any] = {
+        "session": session,
+        "headers": headers,
+        "timeout": request_config.prepared_timeout,
+        "verify": request_config.tls_verify,
+        "cert": request_config.cert,
+    }
+    if request_config.proxy is not None:
+        kwargs["proxies"] = {"all": request_config.proxy}
+    hooks.dispatch("process_call_kwargs", hook_context, case, kwargs)
     try:
-        hook_context = HookContext(operation=case.operation)
-        kwargs: dict[str, Any] = {
-            "session": session,
-            "headers": headers,
-            "timeout": request_config.prepared_timeout,
-            "verify": request_config.tls_verify,
-            "cert": request_config.cert,
-        }
-        if request_config.proxy is not None:
-            kwargs["proxies"] = {"all": request_config.proxy}
-        hooks.dispatch("process_call_kwargs", hook_context, case, kwargs)
         response = case.call(**kwargs)
     except CheckFailed as exc:
         check_name = "request_timeout"
@@ -1030,6 +1030,7 @@ def _network_test(
         auth=ctx.auth,
         headers=CaseInsensitiveDict(headers) if headers else None,
         config=ctx.checks_config,
+        transport_kwargs=kwargs,
     )
     try:
         run_checks(
@@ -1127,6 +1128,7 @@ def _wsgi_test(
         auth=ctx.auth,
         headers=CaseInsensitiveDict(headers) if headers else None,
         config=ctx.checks_config,
+        transport_kwargs=kwargs,
     )
     try:
         run_checks(
@@ -1212,6 +1214,7 @@ def _asgi_test(
         auth=ctx.auth,
         headers=CaseInsensitiveDict(headers) if headers else None,
         config=ctx.checks_config,
+        transport_kwargs=kwargs,
     )
     try:
         run_checks(

{schemathesis-3.38.9 → schemathesis-3.38.10}/src/schemathesis/specs/graphql/schemas.py

@@ -83,11 +83,14 @@ class GraphQLCase(Case):
         excluded_checks: tuple[CheckFunction, ...] = (),
         code_sample_style: str | None = None,
         headers: dict[str, Any] | None = None,
+        transport_kwargs: dict[str, Any] | None = None,
     ) -> None:
         checks = checks or (not_a_server_error,)
         checks += additional_checks
         checks = tuple(check for check in checks if check not in excluded_checks)
-        return super().validate_response(response, checks, code_sample_style=code_sample_style, headers=headers)
+        return super().validate_response(
+            response, checks, code_sample_style=code_sample_style, headers=headers, transport_kwargs=transport_kwargs
+        )
 
 
 C = TypeVar("C", bound=Case)

{schemathesis-3.38.9 → schemathesis-3.38.10}/src/schemathesis/specs/openapi/checks.py

@@ -404,14 +404,21 @@ def ignored_auth(ctx: CheckContext, response: GenericResponse, case: Case) -> bo
             # Auth is explicitly set, it is expected to be valid
             # Check if invalid auth will give an error
             _remove_auth_from_case(case, security_parameters)
-            new_response = case.operation.schema.transport.send(case)
+            kwargs = ctx.transport_kwargs or {}
+            kwargs.copy()
+            if "headers" in kwargs:
+                headers = kwargs["headers"].copy()
+                _remove_auth_from_explicit_headers(headers, security_parameters)
+                kwargs["headers"] = headers
+            kwargs.pop("session", None)
+            new_response = case.operation.schema.transport.send(case, **kwargs)
             if new_response.status_code != 401:
                 _update_response(response, new_response)
                 _raise_no_auth_error(new_response, case.operation.verbose_name, "that requires authentication")
             # Try to set invalid auth and check if it succeeds
             for parameter in security_parameters:
                 _set_auth_for_case(case, parameter)
-                new_response = case.operation.schema.transport.send(case)
+                new_response = case.operation.schema.transport.send(case, **kwargs)
                 if new_response.status_code != 401:
                     _update_response(response, new_response)
                     _raise_no_auth_error(new_response, case.operation.verbose_name, "with any auth")
@@ -526,6 +533,13 @@ def _remove_auth_from_case(case: Case, security_parameters: list[SecurityParamet
             case.cookies.pop(name, None)
 
 
+def _remove_auth_from_explicit_headers(headers: dict, security_parameters: list[SecurityParameter]) -> None:
+    for parameter in security_parameters:
+        name = parameter["name"]
+        if parameter["in"] == "header":
+            headers.pop(name, None)
+
+
 def _set_auth_for_case(case: Case, parameter: SecurityParameter) -> None:
     name = parameter["name"]
     for location, attr_name in (

{schemathesis-3.38.9 → schemathesis-3.38.10}/test/specs/openapi/test_ignored_auth.py

@@ -17,15 +17,17 @@ from schemathesis.internal.checks import CheckContext
 from schemathesis.models import Status
 from schemathesis.runner import from_schema
 from schemathesis.specs.openapi.checks import AuthKind, _contains_auth, _remove_auth_from_case, ignored_auth
+from schemathesis.transports import RequestsTransport
 
 
-def run(schema_url, headers=None, **loader_kwargs):
+def run(schema_url, headers=None, runner_config=None, **loader_kwargs):
     schema = schemathesis.from_uri(schema_url, **loader_kwargs)
     _, _, _, _, _, _, event, *_ = from_schema(
         schema,
         checks=[ignored_auth],
         headers=headers,
         hypothesis_settings=settings(max_examples=1, phases=[Phase.generate]),
+        **(runner_config or {}),
     ).execute()
     return event
 
@@ -68,6 +70,43 @@ def test_no_failure(schema_url):
     assert event.status == Status.success
 
 
+@pytest.mark.openapi_version("3.0")
+@pytest.mark.operations("ignored_auth")
+def test_keep_tls_verification(schema_url, mocker):
+    # See GH-2613
+    # `verify` and other options should not be ignored in `ignored_auth`
+    send = mocker.spy(RequestsTransport, "send")
+    run(
+        schema_url,
+        runner_config={
+            "request_timeout": 5,
+            "request_tls_verify": False,
+        },
+        headers={"Authorization": "Basic dGVzdDp0ZXN0"},
+    )
+    for call in send.mock_calls:
+        assert call.kwargs["timeout"] == 0.005
+        assert not call.kwargs["verify"]
+    send.reset_mock()
+
+    schema = schemathesis.from_uri(schema_url)
+
+    operation = schema["/ignored_auth"]["get"]
+
+    @given(operation.as_strategy())
+    def test(case):
+        try:
+            case.call_and_validate(verify=False, timeout=0.005)
+        except Exception:
+            pass
+
+    test()
+
+    for call in send.mock_calls:
+        assert call.kwargs["timeout"] == 0.005
+        assert not call.kwargs["verify"]
+
+
 @pytest.mark.parametrize(
     ("ctx", "request_kwargs", "parameters", "expected"),
     [