schemathesis 4.0.8__py3-none-any.whl → 4.0.10__py3-none-any.whl

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

@@ -20,10 +20,9 @@ from schemathesis.config import ProjectConfig, ReportFormat, SchemathesisWarning
 from schemathesis.core.errors import LoaderError, LoaderErrorKind, format_exception, split_traceback
 from schemathesis.core.failures import MessageBlock, Severity, format_failures
 from schemathesis.core.output import prepare_response_payload
-from schemathesis.core.result import Err, Ok
+from schemathesis.core.result import Ok
 from schemathesis.core.version import SCHEMATHESIS_VERSION
 from schemathesis.engine import Status, events
-from schemathesis.engine.errors import EngineErrorInfo
 from schemathesis.engine.phases import PhaseName, PhaseSkipReason
 from schemathesis.engine.phases.probes import ProbeOutcome
 from schemathesis.engine.recorder import Interaction, ScenarioRecorder
@@ -960,7 +959,9 @@ class OutputHandler(EventHandler):
                     table.add_row(f"{probe_run.probe.name}:", Text(icon, style=style))
 
                 message = Padding(table, BLOCK_PADDING)
-            elif event.status == Status.SKIP:
+            else:
+                assert event.status == Status.SKIP
+                assert isinstance(event.payload, Ok)
                 message = Padding(
                     Text.assemble(
                         ("⏭   ", ""),
@@ -968,17 +969,6 @@ class OutputHandler(EventHandler):
                     ),
                     BLOCK_PADDING,
                 )
-            else:
-                assert event.status == Status.ERROR
-                assert isinstance(event.payload, Err)
-                error = EngineErrorInfo(event.payload.err())
-                message = Padding(
-                    Text.assemble(
-                        ("🚫  ", ""),
-                        (f"API probing failed: {error.message}", Style(color="red")),
-                    ),
-                    BLOCK_PADDING,
-                )
             self.console.print(message)
             self.console.print()
         elif phase.name == PhaseName.STATEFUL_TESTING and phase.is_enabled and self.stateful_tests_manager is not None:
@@ -1337,6 +1327,9 @@ class OutputHandler(EventHandler):
         click.echo(_style("Test Phases:", bold=True))
 
         for phase in PhaseName:
+            if phase == PhaseName.PROBING:
+                # It is not a test phase
+                continue
             status, skip_reason = self.phases[phase]
 
             if status == Status.SKIP:

schemathesis/engine/errors.py

@@ -426,7 +426,16 @@ def is_unrecoverable_network_error(exc: Exception) -> bool:
 
     def has_connection_reset(inner: BaseException) -> bool:
         exc_str = str(inner)
-        if any(pattern in exc_str for pattern in ["Connection reset by peer", "[Errno 104]", "ECONNRESET"]):
+        if any(
+            pattern in exc_str
+            for pattern in [
+                "Connection aborted",
+                "Connection reset by peer",
+                "[Errno 104]",
+                "ECONNRESET",
+                "An established connection was aborted",
+            ]
+        ):
             return True
 
         if inner.__context__ is not None:
@@ -434,7 +443,7 @@ def is_unrecoverable_network_error(exc: Exception) -> bool:
 
         return False
 
-    if isinstance(exc, requests.Timeout):
+    if isinstance(exc, (requests.Timeout, requests.exceptions.ChunkedEncodingError)):
         return True
     if isinstance(exc.__context__, ProtocolError):
         if len(exc.__context__.args) == 2 and isinstance(exc.__context__.args[1], RemoteDisconnected):

schemathesis/engine/phases/probes.py

@@ -13,7 +13,7 @@ import warnings
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from schemathesis.core.result import Err, Ok, Result
+from schemathesis.core.result import Ok, Result
 from schemathesis.core.transport import USER_AGENT
 from schemathesis.engine import Status, events
 from schemathesis.transport.prepare import get_default_headers
@@ -41,16 +41,11 @@ def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
     payload: Result[ProbePayload, Exception] | None = None
     for result in probes:
         if isinstance(result.probe, NullByteInHeader) and result.is_failure:
-            from ...specs.openapi import formats
-            from ...specs.openapi.formats import HEADER_FORMAT, header_values
+            from schemathesis.specs.openapi import formats
+            from schemathesis.specs.openapi.formats import HEADER_FORMAT, header_values
 
             formats.register(HEADER_FORMAT, header_values(exclude_characters="\n\r\x00"))
-        if result.error is not None:
-            status = Status.ERROR
-            payload = Err(result.error)
-        else:
-            status = Status.SUCCESS
-            payload = Ok(ProbePayload(probes=probes))
+        payload = Ok(ProbePayload(probes=probes))
     yield events.PhaseFinished(phase=phase, status=status, payload=payload)
 
 

schemathesis/generation/coverage.py

@@ -177,6 +177,18 @@ class CoverageContext:
                 return bool(value)
         return True
 
+    def can_be_negated(self, schema: dict[str, Any]) -> bool:
+        # Path, query, header, and cookie parameters will be stringified anyway
+        # If there are no constraints, then anything will match the original schema after serialization
+        if self.location in ("query", "path", "header", "cookie"):
+            cleaned = {
+                k: v
+                for k, v in schema.items()
+                if not k.startswith("x-") and k not in ["description", "example", "examples"]
+            }
+            return cleaned != {}
+        return True
+
     def generate_from(self, strategy: st.SearchStrategy) -> Any:
         return cached_draw(strategy)
 
@@ -389,6 +401,8 @@ def cover_schema_iter(
             yield from _cover_positive_for_type(ctx, schema, ty)
     if GenerationMode.NEGATIVE in ctx.generation_modes:
         template = None
+        if not ctx.can_be_negated(schema):
+            return
         for key, value in schema.items():
             with _ignore_unfixable(), ctx.at(key):
                 if key == "enum":
@@ -1086,6 +1100,8 @@ def _negative_type(
         del strategies["integer"]
     if "integer" in types:
         strategies["number"] = FLOAT_STRATEGY.filter(_is_non_integer_float)
+    if ctx.location == "query":
+        strategies.pop("object", None)
     for strategy in strategies.values():
         value = ctx.generate_from(strategy)
         if seen.insert(value) and ctx.is_valid_for_location(value):

schemathesis/generation/hypothesis/builder.py

@@ -624,7 +624,9 @@ def _iter_coverage_cases(
                 ),
             )
         # Generate duplicate query parameters
-        if generate_duplicate_query_parameters and operation.query:
+        # NOTE: if the query schema has no constraints, then we may have no negative test cases at all
+        # as they all will match the original schema and therefore will be considered as positive ones
+        if generate_duplicate_query_parameters and operation.query and "query" in template:
             container = template["query"]
             for parameter in operation.query:
                 instant = Instant()
@@ -656,24 +658,26 @@ def _iter_coverage_cases(
                 name = parameter.name
                 location = parameter.location
                 container_name = LOCATION_TO_CONTAINER[location]
-                container = template[container_name]
-                data = template.with_container(
-                    container_name=container_name,
-                    value={k: v for k, v in container.items() if k != name},
-                    generation_mode=GenerationMode.NEGATIVE,
-                )
-                yield operation.Case(
-                    **data.kwargs,
-                    _meta=CaseMetadata(
-                        generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
-                        components=data.components,
-                        phase=PhaseInfo.coverage(
-                            description=f"Missing `{name}` at {location}",
-                            parameter=name,
-                            parameter_location=location,
+                # NOTE: if the schema is overly permissive we may not have any negative test cases
+                if container_name in template:
+                    container = template[container_name]
+                    data = template.with_container(
+                        container_name=container_name,
+                        value={k: v for k, v in container.items() if k != name},
+                        generation_mode=GenerationMode.NEGATIVE,
+                    )
+                    yield operation.Case(
+                        **data.kwargs,
+                        _meta=CaseMetadata(
+                            generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
+                            components=data.components,
+                            phase=PhaseInfo.coverage(
+                                description=f"Missing `{name}` at {location}",
+                                parameter=name,
+                                parameter_location=location,
+                            ),
                         ),
-                    ),
-                )
+                    )
     # Generate combinations for each location
     for location, parameter_set in [
         ("query", operation.query),

schemathesis/specs/openapi/examples.py

@@ -206,20 +206,23 @@ def _find_request_body_examples_definition(
 
 
 def extract_inner_examples(
-    examples: dict[str, Any], unresolved_definition: dict[str, Any]
+    examples: dict[str, Any] | list, unresolved_definition: dict[str, Any]
 ) -> Generator[Any, None, None]:
     """Extract exact examples values from the `examples` dictionary."""
-    for name, example in examples.items():
-        if "$ref" in unresolved_definition[name] and "value" not in example and "externalValue" not in example:
-            # The example here is a resolved example and should be yielded as is
-            yield example
-        if isinstance(example, dict):
-            if "value" in example:
-                yield example["value"]
-            elif "externalValue" in example:
-                with suppress(requests.RequestException):
-                    # Report a warning if not available?
-                    yield load_external_example(example["externalValue"])
+    if isinstance(examples, dict):
+        for name, example in examples.items():
+            if "$ref" in unresolved_definition[name] and "value" not in example and "externalValue" not in example:
+                # The example here is a resolved example and should be yielded as is
+                yield example
+            if isinstance(example, dict):
+                if "value" in example:
+                    yield example["value"]
+                elif "externalValue" in example:
+                    with suppress(requests.RequestException):
+                        # Report a warning if not available?
+                        yield load_external_example(example["externalValue"])
+    elif isinstance(examples, list):
+        yield from examples
 
 
 @lru_cache
@@ -381,9 +384,12 @@ def find_in_responses(operation: APIOperation) -> dict[str, list[dict[str, Any]]
                 ("x-examples", "x-example"),
             ):
                 examples = definition.get(examples_field, {})
-                for example in examples.values():
-                    if "value" in example:
-                        output.setdefault(name, []).append(example["value"])
+                if isinstance(examples, dict):
+                    for example in examples.values():
+                        if "value" in example:
+                            output.setdefault(name, []).append(example["value"])
+                elif isinstance(examples, list):
+                    output.setdefault(name, []).extend(examples)
                 if example_field in definition:
                     output.setdefault(name, []).append(definition[example_field])
     return output

schemathesis/specs/openapi/parameters.py

@@ -60,9 +60,11 @@ class OpenAPIParameter(Parameter):
         # JSON Schema allows `examples` as an array
         examples = []
         if self.examples_field in self.definition:
-            examples.extend(
-                [example["value"] for example in self.definition[self.examples_field].values() if "value" in example]
-            )
+            container = self.definition[self.examples_field]
+            if isinstance(container, dict):
+                examples.extend([example["value"] for example in container.values() if "value" in example])
+            elif isinstance(container, list):
+                examples.extend(container)
         if self.example_field in self.definition:
             examples.append(self.definition[self.example_field])
         schema = self.from_open_api_to_json_schema(operation, self.definition)

{schemathesis-4.0.8.dist-info → schemathesis-4.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.0.8
+Version: 4.0.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.0.8.dist-info → schemathesis-4.0.10.dist-info}/RECORD

@@ -23,7 +23,7 @@ schemathesis/cli/commands/run/handlers/__init__.py,sha256=TPZ3KdGi8m0fjlN0GjA31M
 schemathesis/cli/commands/run/handlers/base.py,sha256=yDsTtCiztLksfk7cRzg8JlaAVOfS-zwK3tsJMOXAFyc,530
 schemathesis/cli/commands/run/handlers/cassettes.py,sha256=rRD4byjp4HXCkJS-zx3jSIFOJsPq77ejPpYeyCtsEZs,19461
 schemathesis/cli/commands/run/handlers/junitxml.py,sha256=ydk6Ofj-Uti6H8EucT4Snp85cmTA5W7uVpKkoHrIDKE,2586
-schemathesis/cli/commands/run/handlers/output.py,sha256=IRERu8Mir3yi5BgDf40SFwYQbxd0aTrWE9IRkjdO7h4,62808
+schemathesis/cli/commands/run/handlers/output.py,sha256=zlI0M5PuzduzluzONv3eyuoWWnigPkErPpUtjgHWESE,62476
 schemathesis/cli/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/cli/ext/fs.py,sha256=3lvoAsEDDdih75ITJJNxemd3nwxX55gGWrI7uDxm0cM,447
 schemathesis/cli/ext/groups.py,sha256=kQ37t6qeArcKaY2y5VxyK3_KwAkBKCVm58IYV8gewds,2720
@@ -72,11 +72,11 @@ schemathesis/engine/__init__.py,sha256=QaFE-FinaTAaarteADo2RRMJ-Sz6hZB9TzD5KjMin
 schemathesis/engine/context.py,sha256=x-I9KX6rO6hdCvvN8FEdzIZBqIcNaxdNYHgQjcXbZhM,3931
 schemathesis/engine/control.py,sha256=FXzP8dxL47j1Giqpy2-Bsr_MdMw9YiATSK_UfpFwDtk,1348
 schemathesis/engine/core.py,sha256=5jfAqFH0XSD7NVgoSXuUPW-dooItscneAzUNq1RBh1E,5712
-schemathesis/engine/errors.py,sha256=HRtFFg-TQ68VmGAM3p6VLOimTU7VaFnv6iKD9-ucjaw,18932
+schemathesis/engine/errors.py,sha256=wbFTOE0pmpU79oOzx1l-ypKG92wdFySmNzrN_KTNizM,19168
 schemathesis/engine/events.py,sha256=VV6epicFIJnX4c87fVNSd0ibDccX3gryDv52OUGa3FI,6370
 schemathesis/engine/recorder.py,sha256=K3HfMARrT5mPWXPnYebjjcq5CcsBRhMrtZwEL9_Lvtg,8432
 schemathesis/engine/phases/__init__.py,sha256=jUIfb_9QoUo4zmJEVU0z70PgXPYjt8CIqp4qP_HlYHg,3146
-schemathesis/engine/phases/probes.py,sha256=zvK-uLjVXpvaQ89hNq73WRH_OiIHRWvhvnOkx_C8Iq0,5678
+schemathesis/engine/phases/probes.py,sha256=fhe_1ZPYDCfyzqjeg_0aWK_dhXlsgacE3_VVlbhkwdI,5528
 schemathesis/engine/phases/stateful/__init__.py,sha256=Lz1rgNqCfUSIz173XqCGsiMuUI5bh4L-RIFexU1-c_Q,2461
 schemathesis/engine/phases/stateful/_executor.py,sha256=_303Yqflx1iFNTQI2EfjSp_2T21YvzJJgMSazhpv5JQ,15200
 schemathesis/engine/phases/stateful/context.py,sha256=A7X1SLDOWFpCvFN9IiIeNVZM0emjqatmJL_k9UsO7vM,2946
@@ -85,13 +85,13 @@ schemathesis/engine/phases/unit/_executor.py,sha256=9MmZoKSBVSPk0LWwN3PZ3iaO9nzp
 schemathesis/engine/phases/unit/_pool.py,sha256=iU0hdHDmohPnEv7_S1emcabuzbTf-Cznqwn0pGQ5wNQ,2480
 schemathesis/generation/__init__.py,sha256=tvNO2FLiY8z3fZ_kL_QJhSgzXfnT4UqwSXMHCwfLI0g,645
 schemathesis/generation/case.py,sha256=MuqnKsJBpGm2gaqDFdJi1yGSWgBhqJUwtYaX97kfXgo,11820
-schemathesis/generation/coverage.py,sha256=gf3kBAQAM5SoUS2k5e4UYIw-w6yvBtm_9KmdQyrhiss,49253
+schemathesis/generation/coverage.py,sha256=0d52xHf1HUbilPmCeJlplnw7knSdc0lEv4Hr0HXYUTE,49949
 schemathesis/generation/meta.py,sha256=adkoMuCfzSjHJ9ZDocQn0GnVldSCkLL3eVR5A_jafwM,2552
 schemathesis/generation/metrics.py,sha256=cZU5HdeAMcLFEDnTbNE56NuNq4P0N4ew-g1NEz5-kt4,2836
 schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeXTyU,481
 schemathesis/generation/overrides.py,sha256=OBWqDQPreiliaf2M-oyXppVKHoJkCRzxtwSJx1b6AFw,3759
 schemathesis/generation/hypothesis/__init__.py,sha256=SVwM-rx07jPZzms0idWYACgUtWAxh49HRuTnaQ__zf0,1549
-schemathesis/generation/hypothesis/builder.py,sha256=CURcKG1JamDNwMgZysMaqL5Mrbj0Hx3dgAxJHaB1ZAg,34102
+schemathesis/generation/hypothesis/builder.py,sha256=EPJkeyeirU-pMuD4NGrY1e4HRp0cmBNg_1NLRFRxOfk,34550
 schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
 schemathesis/generation/hypothesis/reporting.py,sha256=uDVow6Ya8YFkqQuOqRsjbzsbyP4KKfr3jA7ZaY4FuKY,279
@@ -128,10 +128,10 @@ schemathesis/specs/openapi/checks.py,sha256=0YiMoUy_wsnPvbOrsbnQ2iDxLloNe2-dc5-h
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=lil8IewM5j8tvt4lpA9g_KITvIwx1M96i45DNSHNjoc,3505
 schemathesis/specs/openapi/definitions.py,sha256=8htclglV3fW6JPBqs59lgM4LnA25Mm9IptXBPb_qUT0,93949
-schemathesis/specs/openapi/examples.py,sha256=11GMuwyTws8MizQ3CkfT3dQD4TFP22CGYBMUyESYsDM,21218
+schemathesis/specs/openapi/examples.py,sha256=V1fbsbMto_So7lTWnyGa7f3u9On2br8yZ-cPzcC2-Bw,21542
 schemathesis/specs/openapi/formats.py,sha256=8AIS7Uey-Z1wm1WYRqnsVqHwG9d316PdqfKLqwUs7us,3516
 schemathesis/specs/openapi/media_types.py,sha256=F5M6TKl0s6Z5X8mZpPsWDEdPBvxclKRcUOc41eEwKbo,2472
-schemathesis/specs/openapi/parameters.py,sha256=BevME4DWLQ-OFvc_7fREMjj99VAbVNxVb5i8OEX6Pfs,14453
+schemathesis/specs/openapi/parameters.py,sha256=ifu_QQCMUzsUHQAkvsOvLuokns6CzesssmQ3Nd3zxII,14594
 schemathesis/specs/openapi/patterns.py,sha256=cBj8W4wn7VLJd4nABaIH5f502-zBDiqljxLgPWUn-50,15609
 schemathesis/specs/openapi/references.py,sha256=40YcDExPLR2B8EOwt-Csw-5MYFi2xj_DXf91J0Pc9d4,8855
 schemathesis/specs/openapi/schemas.py,sha256=4bL-nOFOykfOGHbkmUor9MnCqhAzW5S5oIQbL36wvVc,51972
@@ -157,8 +157,8 @@ schemathesis/transport/prepare.py,sha256=iiB8KTAqnnuqjWzblIPiGVdkGIF7Yr1SAEz-KZz
 schemathesis/transport/requests.py,sha256=rziZTrZCVMAqgy6ldB8iTwhkpAsnjKSgK8hj5Sq3ThE,10656
 schemathesis/transport/serialization.py,sha256=igUXKZ_VJ9gV7P0TUc5PDQBJXl_s0kK9T3ljGWWvo6E,10339
 schemathesis/transport/wsgi.py,sha256=KoAfvu6RJtzyj24VGB8e-Iaa9smpgXJ3VsM8EgAz2tc,6152
-schemathesis-4.0.8.dist-info/METADATA,sha256=drG7CbWUVvqW5yB1wAuNZeU4M8Meq1Bcd0aMag2EZmA,8471
-schemathesis-4.0.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.0.8.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.0.8.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.0.8.dist-info/RECORD,,
+schemathesis-4.0.10.dist-info/METADATA,sha256=VMiIU9pSV3BpGkj_5Jl9RrgdusrmR9tqLsDTpZCfxnw,8472
+schemathesis-4.0.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.0.10.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.0.10.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.0.10.dist-info/RECORD,,