schemathesis 3.38.0__tar.gz → 3.38.1__tar.gz

{schemathesis-3.38.0 → schemathesis-3.38.1}/PKG-INFO

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

{schemathesis-3.38.0 → schemathesis-3.38.1}/docs/changelog.rst

@@ -1,9 +1,23 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.38.0...HEAD>` - TBD
+:version:`Unreleased <v3.38.1...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.38.1:
+
+:version:`3.38.1 <v3.38.0...v3.38.1>` - 2024-10-21
+--------------------------------------------------
+
+**Added**
+
+- Generating test cases with missing required parameters during the coverage phase.
+- Store information about what parameter is mutated during the coverage phase.
+
+**Changed**
+
+- Adjust the ``negative_data_rejection`` config to include fewer 4XX status codes (400, 401, 403, 404, 422).
+
 .. _v3.38.0:
 
 :version:`3.38.0 <v3.37.1...v3.38.0>` - 2024-10-21

{schemathesis-3.38.0 → schemathesis-3.38.1}/docs/experimental.rst

@@ -187,6 +187,31 @@ Configure status codes:
 
 For more details, join the `GitHub Discussion #2499 <https://github.com/schemathesis/schemathesis/discussions/2499>`_.
 
+Negative Data Rejection
+~~~~~~~~~~~~~~~~~~~~~~~
+
+This feature covers configuring the ``negative_data_rejection`` check and allows for defining what status codes won't trigger this check.
+
+**Allowed status codes**: 400, 401, 403, 404, 422, 5XX
+
+In CLI
+~~~~~~
+
+Configuration options:
+
+.. code-block:: bash
+
+   --experimental-negative-data-rejection-allowed-statuses=4XX
+
+Using Environment Variables
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Configure status codes:
+
+.. code-block:: bash
+
+    export SCHEMATHESIS_EXPERIMENTAL_NEGATIVE_DATA_REJECTION_ALLOWED_STATUSES=4XX
+
 .. _stateful-test-runner:
 
 New Stateful Test Runner

{schemathesis-3.38.0 → schemathesis-3.38.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.38.0"
+version = "3.38.1"
 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.0 → schemathesis-3.38.1}/src/schemathesis/_hypothesis.py

@@ -232,6 +232,8 @@ def _iter_coverage_cases(
         phase=TestPhase.COVERAGE,
         description=None,
         location=None,
+        parameter=None,
+        parameter_location=None,
     )
     generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
     template: dict[str, Any] = {}
@@ -276,6 +278,8 @@ def _iter_coverage_cases(
             case.meta = copy(meta)
             case.meta.description = value.description
             case.meta.location = value.location
+            case.meta.parameter = body.media_type
+            case.meta.parameter_location = "body"
             yield case
             for next_value in gen:
                 case = operation.make_case(**{**template, "body": next_value.value, "media_type": body.media_type})
@@ -283,6 +287,8 @@ def _iter_coverage_cases(
                 case.meta = copy(meta)
                 case.meta.description = next_value.description
                 case.meta.location = next_value.location
+                case.meta.parameter = body.media_type
+                case.meta.parameter_location = "body"
                 yield case
     elif DataGenerationMethod.positive in data_generation_methods:
         case = operation.make_case(**template)
@@ -302,7 +308,27 @@ def _iter_coverage_cases(
             case.meta = copy(meta)
             case.meta.description = value.description
             case.meta.location = value.location
+            case.meta.parameter = name
+            case.meta.parameter_location = location
             yield case
+    # Generate missing required parameters
+    if DataGenerationMethod.negative in data_generation_methods:
+        for parameter in operation.iter_parameters():
+            if parameter.is_required:
+                name = parameter.name
+                location = parameter.location
+                container_name = LOCATION_TO_CONTAINER[location]
+                container = template[container_name]
+                case = operation.make_case(
+                    **{**template, container_name: {k: v for k, v in container.items() if k != name}}
+                )
+                case.data_generation_method = DataGenerationMethod.negative
+                case.meta = copy(meta)
+                case.meta.description = f"Missing `{name}` at {location}"
+                case.meta.location = parameter.location
+                case.meta.parameter = name
+                case.meta.parameter_location = location
+                yield case
 
 
 def find_invalid_headers(headers: Mapping) -> Generator[tuple[str, str], None, None]:

{schemathesis-3.38.0 → schemathesis-3.38.1}/src/schemathesis/cli/cassettes.py

@@ -244,12 +244,24 @@ http_interactions:"""
                     write_double_quoted(stream, interaction.description)
                 else:
                     stream.write("null")
-                stream.write("\n    location: ")
 
+                stream.write("\n    location: ")
                 if interaction.location is not None:
                     write_double_quoted(stream, interaction.location)
                 else:
                     stream.write("null")
+
+                stream.write("\n    parameter: ")
+                if interaction.parameter is not None:
+                    write_double_quoted(stream, interaction.parameter)
+                else:
+                    stream.write("null")
+
+                stream.write("\n    parameter_location: ")
+                if interaction.parameter_location is not None:
+                    write_double_quoted(stream, interaction.parameter_location)
+                else:
+                    stream.write("null")
                 stream.write(
                     f"""
   phase: {phase}

{schemathesis-3.38.0 → schemathesis-3.38.1}/src/schemathesis/internal/checks.py

@@ -21,7 +21,7 @@ CheckFunction = Callable[["CheckContext", "GenericResponse", "Case"], Optional[b
 @dataclass
 class NegativeDataRejectionConfig:
     # 5xx will pass through
-    allowed_statuses: list[str] = field(default_factory=lambda: ["4xx", "5xx"])
+    allowed_statuses: list[str] = field(default_factory=lambda: ["400", "401", "403", "404", "422", "5xx"])
 
 
 @dataclass

{schemathesis-3.38.0 → schemathesis-3.38.1}/src/schemathesis/models.py

@@ -158,10 +158,24 @@ class GenerationMetadata:
     cookies: DataGenerationMethod | None
     body: DataGenerationMethod | None
     phase: TestPhase
+    # Temporary attributes to carry info specific to the coverage phase
     description: str | None
     location: str | None
-
-    __slots__ = ("query", "path_parameters", "headers", "cookies", "body", "phase", "description", "location")
+    parameter: str | None
+    parameter_location: str | None
+
+    __slots__ = (
+        "query",
+        "path_parameters",
+        "headers",
+        "cookies",
+        "body",
+        "phase",
+        "description",
+        "location",
+        "parameter",
+        "parameter_location",
+    )
 
 
 @dataclass(repr=False)
@@ -1073,6 +1087,8 @@ class Interaction:
     # NOTE: It will be better to keep it in a separate attribute
     description: str | None
     location: str | None
+    parameter: str | None
+    parameter_location: str | None
     recorded_at: str = field(default_factory=lambda: datetime.datetime.now(TIMEZONE).isoformat())
 
     @classmethod
@@ -1104,6 +1120,8 @@ class Interaction:
             phase=case.meta.phase if case.meta is not None else None,
             description=case.meta.description if case.meta is not None else None,
             location=case.meta.location if case.meta is not None else None,
+            parameter=case.meta.parameter if case.meta is not None else None,
+            parameter_location=case.meta.parameter_location if case.meta is not None else None,
         )
 
     @classmethod
@@ -1129,6 +1147,8 @@ class Interaction:
             phase=case.meta.phase if case.meta is not None else None,
             description=case.meta.description if case.meta is not None else None,
             location=case.meta.location if case.meta is not None else None,
+            parameter=case.meta.parameter if case.meta is not None else None,
+            parameter_location=case.meta.parameter_location if case.meta is not None else None,
         )
 
 

{schemathesis-3.38.0 → schemathesis-3.38.1}/src/schemathesis/runner/serialization.py

@@ -398,6 +398,8 @@ class SerializedInteraction:
     phase: TestPhase | None
     description: str | None
     location: str | None
+    parameter: str | None
+    parameter_location: str | None
     recorded_at: str
 
     @classmethod
@@ -411,6 +413,8 @@ class SerializedInteraction:
             phase=interaction.phase,
             description=interaction.description,
             location=interaction.location,
+            parameter=interaction.parameter,
+            parameter_location=interaction.parameter_location,
             recorded_at=interaction.recorded_at,
         )
 

{schemathesis-3.38.0 → schemathesis-3.38.1}/src/schemathesis/specs/openapi/_hypothesis.py

@@ -179,6 +179,8 @@ def get_case_strategy(
             phase=phase,
             description=None,
             location=None,
+            parameter=None,
+            parameter_location=None,
         ),
     )
     auth_context = auths.AuthContext(

{schemathesis-3.38.0 → schemathesis-3.38.1}/test/auth/test_cli.py

@@ -42,11 +42,11 @@ def after_call(context, case, response):
 
 
 @pytest.mark.parametrize(
-    "args, expected",
-    (
+    ("args", "expected"),
+    [
         (("--auth", "user:pass"), "Basic dXNlcjpwYXNz"),
         (("-H", "Authorization: Bearer EXPLICIT"), "Bearer EXPLICIT"),
-    ),
+    ],
 )
 @pytest.mark.openapi_version("3.0")
 @pytest.mark.operations("success")
@@ -68,10 +68,10 @@ def after_call(context, case, response):
     assert cli.main("run", schema_url, "--show-trace", *args, hooks=module.purebasename) == snapshot_cli
 
 
-def test_multiple_auth_mechanisms_with_explicit_auth(ctx, testdir, cli, snapshot_cli):
+def test_multiple_auth_mechanisms_with_explicit_auth(ctx, cli, snapshot_cli):
     # When the schema defines multiple auth mechanisms on the same operation
     # And the user passes an explicit `Authorization` header
-    schema = ctx.openapi.build_schema(
+    schema_path = ctx.openapi.write_schema(
         {
             "/health": {
                 "get": {
@@ -97,9 +97,8 @@ def test_multiple_auth_mechanisms_with_explicit_auth(ctx, testdir, cli, snapshot
         },
         security=[{"bearerAuth": []}, {"basicAuth": []}],
     )
-    schema_file = testdir.make_openapi_schema_file(schema)
     # Then it should be able to generate requests
-    assert cli.run(str(schema_file), "--dry-run", "-H", "Authorization: Bearer foo") == snapshot_cli
+    assert cli.run(str(schema_path), "--dry-run", "-H", "Authorization: Bearer foo") == snapshot_cli
 
 
 @pytest.mark.openapi_version("3.0")

{schemathesis-3.38.0 → schemathesis-3.38.1}/test/auth/test_pytest.py

@@ -32,13 +32,13 @@ type Query {
 
 
 @pytest.mark.parametrize(
-    "class_decorator, pre_parametrize_decorator, post_parametrize_decorator",
-    (
+    ("class_decorator", "pre_parametrize_decorator", "post_parametrize_decorator"),
+    [
         ("@schemathesis.auth()", "", ""),
         ("@schema.auth()", "", ""),
         ("", f"@schema.auth({AUTH_CLASS_NAME})", ""),
         ("", "", f"@schema.auth({AUTH_CLASS_NAME})"),
-    ),
+    ],
     ids=("global", "schema", "test-pre-parametrize", "test-post-parametrize"),
 )
 def test_different_scopes(

{schemathesis-3.38.0 → schemathesis-3.38.1}/test/cli/__snapshots__/test_commands/test_no_schema_in_media_type[Open API 3.0].raw

@@ -4,7 +4,7 @@ Stdout:
 ======================= Schemathesis test session starts =======================
 Schema location: file:///tmp/schema.json
 Base URL: http://127.0.0.1/api
-Specification version: Open API 3.0.0
+Specification version: Open API 3.0.2
 Random seed: 42
 Workers: 1
 Collected API operations: 1

{schemathesis-3.38.0 → schemathesis-3.38.1}/test/cli/output/test_default.py

@@ -29,7 +29,7 @@ def click_context():
         yield
 
 
-@pytest.fixture()
+@pytest.fixture
 def execution_context():
     return schemathesis.cli.context.ExecutionContext(hypothesis.settings(), [], operations_count=1)
 
@@ -59,7 +59,7 @@ def response():
     return response
 
 
-@pytest.fixture()
+@pytest.fixture
 def results_set(operation):
     statistic = models.TestResult(
         operation.method,
@@ -70,7 +70,7 @@ def results_set(operation):
     return models.TestResultSet(seed=42, results=[statistic])
 
 
-@pytest.fixture()
+@pytest.fixture
 def after_execution(results_set, operation, swagger_20):
     return runner.events.AfterExecution.from_result(
         result=results_set.results[0],
@@ -88,7 +88,7 @@ def test_get_terminal_width():
 
 
 @pytest.mark.parametrize(
-    "title,separator,printed,expected",
+    ("title", "separator", "printed", "expected"),
     [
         ("TEST", "-", "data in section", "------- TEST -------"),
         ("TEST", "*", "data in section", "******* TEST *******"),
@@ -106,7 +106,7 @@ def test_display_section_name(capsys, title, separator, printed, expected):
     assert expected in out
 
 
-@pytest.mark.parametrize("verbosity", (0, 1))
+@pytest.mark.parametrize("verbosity", [0, 1])
 def test_handle_initialized(capsys, mocker, execution_context, results_set, swagger_20, verbosity):
     execution_context.verbosity = verbosity
     # Given Initialized event
@@ -210,13 +210,15 @@ def test_capture_hypothesis_output():
     assert hypothesis_output == [value, value]
 
 
-@pytest.mark.parametrize("position, length, expected", ((1, 100, "[  1%]"), (20, 100, "[ 20%]"), (100, 100, "[100%]")))
+@pytest.mark.parametrize(
+    ("position", "length", "expected"), [(1, 100, "[  1%]"), (20, 100, "[ 20%]"), (100, 100, "[100%]")]
+)
 def test_get_percentage(position, length, expected):
     assert default.get_percentage(position, length) == expected
 
 
-@pytest.mark.parametrize("current_line_length", (0, 20))
-@pytest.mark.parametrize("operations_processed, percentage", ((0, "[  0%]"), (1, "[100%]")))
+@pytest.mark.parametrize("current_line_length", [0, 20])
+@pytest.mark.parametrize(("operations_processed", "percentage"), [(0, "[  0%]"), (1, "[100%]")])
 def test_display_percentage(
     capsys, execution_context, after_execution, swagger_20, current_line_length, operations_processed, percentage
 ):
@@ -242,7 +244,7 @@ def test_display_hypothesis_output(capsys):
     assert " ".join(lines[1:3]) == strip_style_win32(click.style("foo bar", fg="red"))
 
 
-@pytest.mark.parametrize("body", ({}, {"foo": "bar"}, NOT_SET))
+@pytest.mark.parametrize("body", [{}, {"foo": "bar"}, NOT_SET])
 def test_display_single_failure(capsys, swagger_20, execution_context, operation, body, response):
     # Given a single test result with multiple successful & failed checks
     media_type = "application/json" if body is not NOT_SET else None
@@ -294,8 +296,8 @@ def test_display_single_failure(capsys, swagger_20, execution_context, operation
 
 
 @pytest.mark.parametrize(
-    "status, expected_symbol, color",
-    ((models.Status.success, ".", "green"), (models.Status.failure, "F", "red"), (models.Status.error, "E", "red")),
+    ("status", "expected_symbol", "color"),
+    [(models.Status.success, ".", "green"), (models.Status.failure, "F", "red"), (models.Status.error, "E", "red")],
 )
 def test_handle_after_execution(capsys, execution_context, after_execution, status, expected_symbol, color):
     # Given AfterExecution even with certain status
@@ -326,7 +328,7 @@ def test_after_execution_attributes(execution_context, after_execution):
     assert execution_context.current_line_length == 2
 
 
-@pytest.mark.parametrize("show_errors_tracebacks", (True, False))
+@pytest.mark.parametrize("show_errors_tracebacks", [True, False])
 def test_display_internal_error(capsys, execution_context, show_errors_tracebacks):
     execution_context.show_trace = show_errors_tracebacks
     try:

{schemathesis-3.38.0 → schemathesis-3.38.1}/test/cli/test_asgi.py

@@ -25,7 +25,7 @@ def test_wsgi_app(testdir, cli):
     assert "1 passed, 1 failed in" in result.stdout
 
 
-@pytest.mark.parametrize("workers", (1, 2))
+@pytest.mark.parametrize("workers", [1, 2])
 def test_cli_run_output_success(testdir, cli, workers):
     module = testdir.make_importable_pyfile(
         location="""

{schemathesis-3.38.0 → schemathesis-3.38.1}/test/cli/test_callbacks.py

@@ -12,7 +12,7 @@ from schemathesis.transports.headers import is_latin_1_encodable
 from ..utils import SIMPLE_PATH
 
 
-@pytest.mark.parametrize("value", ("//test", "//ÿ["))
+@pytest.mark.parametrize("value", ["//test", "//ÿ["])
 def test_parse_schema_kind(value):
     with pytest.raises(click.UsageError):
         kind = callbacks.parse_schema_kind(value, app=None)
@@ -71,7 +71,7 @@ def test_reraise_format_error():
 
 @pytest.mark.parametrize(
     "value",
-    ("+", "\\", "[", r"0EEE|[>:>\UEEEEEEEEEEEEEEEEEEEEEEEE>", "(?(8))"),
+    ["+", "\\", "[", r"0EEE|[>:>\UEEEEEEEEEEEEEEEEEEEEEEEE>", "(?(8))"],
 )
 def test_validate_regex(value):
     with pytest.raises(click.BadParameter, match="Invalid regex: "):
@@ -79,23 +79,23 @@ def test_validate_regex(value):
 
 
 @pytest.mark.parametrize(
-    "value, expected",
-    (
+    ("value", "expected"),
+    [
         ("On", True),
         ("F", False),
         ("/tmp/cert.pem", "/tmp/cert.pem"),
-    ),
+    ],
 )
 def test_convert_request_tls_verify(value, expected):
     assert callbacks.convert_boolean_string(None, None, value) == expected
 
 
-@pytest.mark.parametrize("value, expected", (("2", 2), ("auto", callbacks.get_workers_count())))
+@pytest.mark.parametrize(("value", "expected"), [("2", 2), ("auto", callbacks.get_workers_count())])
 def test_convert_workers(value, expected):
     assert callbacks.convert_workers(None, None, value) == expected
 
 
-@pytest.mark.parametrize("value", ("1", "1/g", "f/g"))
+@pytest.mark.parametrize("value", ["1", "1/g", "f/g"])
 def test_validate_rate_limit_invalid(value):
     with pytest.raises(click.UsageError) as exc:
         callbacks.validate_rate_limit(None, None, value)
@@ -110,7 +110,7 @@ def test_validate_rate_limit_valid():
 
 
 @pytest.mark.parametrize(
-    "input_codes, output, error",
+    ("input_codes", "output", "error"),
     [
         (["200", "404"], ["200", "404"], None),
         (["2xx", "4xx"], ["2xx", "4xx"], None),

{schemathesis-3.38.0 → schemathesis-3.38.1}/test/cli/test_cassettes.py

@@ -50,7 +50,7 @@ def load_response_body(cassette, idx):
 
 
 @pytest.mark.parametrize("data_generation_method", [m.value for m in DataGenerationMethod.all()] + ["all"])
-@pytest.mark.parametrize("args", ((), ("--cassette-preserve-exact-body-bytes",)), ids=("plain", "base64"))
+@pytest.mark.parametrize("args", [(), ("--cassette-preserve-exact-body-bytes",)], ids=("plain", "base64"))
 @pytest.mark.operations("success", "upload_file")
 def test_store_cassette(cli, schema_url, cassette_path, hypothesis_max_examples, args, data_generation_method):
     hypothesis_max_examples = hypothesis_max_examples or 2
@@ -94,6 +94,8 @@ def test_store_cassette(cli, schema_url, cassette_path, hypothesis_max_examples,
         if interaction["phase"] == "coverage":
             if interaction["data_generation_method"] == "negative":
                 assert interaction["meta"]["location"] is not None
+                assert interaction["meta"]["parameter"] is not None
+                assert interaction["meta"]["parameter_location"] is not None
 
 
 @pytest.mark.operations("success", "upload_file")
@@ -145,7 +147,7 @@ def test_store_timeout(cli, schema_url, cassette_path):
 
 
 @pytest.mark.parametrize(
-    ["app_fixture", "schema_url"],
+    ("app_fixture", "schema_url"),
     [
         ("loadable_flask_app", "/schema.yaml"),
         ("loadable_fastapi_app", "/openapi.json"),
@@ -288,8 +290,8 @@ def test_main_process_error(cli, schema_url, hypothesis_max_examples, cassette_p
 
 
 @pytest.mark.operations("__all__")
-@pytest.mark.parametrize("verbose", (True, False))
-@pytest.mark.parametrize("args", ((), ("--cassette-preserve-exact-body-bytes",)), ids=("plain", "base64"))
+@pytest.mark.parametrize("verbose", [True, False])
+@pytest.mark.parametrize("args", [(), ("--cassette-preserve-exact-body-bytes",)], ids=("plain", "base64"))
 async def test_replay(
     openapi_version, cli, schema_url, app, reset_app, cassette_path, hypothesis_max_examples, verbose, args
 ):
@@ -360,7 +362,7 @@ async def test_replay(
 
 
 @pytest.mark.operations("__all__")
-@pytest.mark.parametrize("args", ((), ("--cassette-preserve-exact-body-bytes",)), ids=("plain", "base64"))
+@pytest.mark.parametrize("args", [(), ("--cassette-preserve-exact-body-bytes",)], ids=("plain", "base64"))
 def test_har_format(cli, schema_url, cassette_path, hypothesis_max_examples, args):
     cassette_path = cassette_path.with_suffix(".har")
     result = cli.run(
@@ -413,8 +415,8 @@ def test_invalid_format():
 
 
 @pytest.mark.parametrize(
-    "value, expected",
-    (
+    ("value", "expected"),
+    [
         (
             "has_recent_activity=1; path=/; expires=Sat, 29 Jun 2024 18:22:49 GMT; secure; HttpOnly; SameSite=Lax",
             [
@@ -435,7 +437,7 @@ def test_invalid_format():
                 harfile.Cookie(name="spam", value="baz"),
             ],
         ),
-    ),
+    ],
 )
 def test_cookie_to_har(value, expected):
     assert list(_cookie_to_har(value)) == expected
@@ -501,7 +503,7 @@ def test_headers_serialization(cli, openapi2_schema_url, hypothesis_max_examples
     # And should be loadable
 
 
-@pytest.mark.parametrize("value", ("true", "false"))
+@pytest.mark.parametrize("value", ["true", "false"])
 @pytest.mark.operations("headers")
 def test_output_sanitization(cli, openapi2_schema_url, hypothesis_max_examples, cassette_path, value):
     auth = "secret-auth"
@@ -563,8 +565,8 @@ def test_empty_body():
 
 
 @pytest.mark.parametrize(
-    "filters, expected",
-    (
+    ("filters", "expected"),
+    [
         ({"id_": "1"}, ["1"]),
         ({"id_": "2"}, ["2"]),
         ({"status": "SUCCESS"}, ["1"]),
@@ -574,7 +576,7 @@ def test_empty_body():
         ({"method": "PO"}, ["2"]),
         ({"uri": "error|failure"}, ["2", "3"]),
         ({"uri": "error|failure", "method": "POST"}, ["2"]),
-    ),
+    ],
 )
 def test_filter_cassette(filters, expected):
     cassette = [

{schemathesis-3.38.0 → schemathesis-3.38.1}/test/cli/test_checks.py

@@ -26,7 +26,7 @@ def test_register_returns_a_value(new_check):
 
 
 @pytest.mark.parametrize(
-    "exclude_checks,expected_exit_code,expected_result",
+    ("exclude_checks", "expected_exit_code", "expected_result"),
     [
         ("not_a_server_error", ExitCode.TESTS_FAILED, "1 passed, 1 failed in"),
         ("not_a_server_error,status_code_conformance", ExitCode.OK, "2 passed in"),
@@ -75,7 +75,7 @@ def test_exclude_checks(
 
 
 def test_negative_data_rejection(ctx, testdir, cli, openapi3_base_url):
-    schema = ctx.openapi.build_schema(
+    schema_path = ctx.openapi.write_schema(
         {
             "/success": {
                 "get": {
@@ -85,9 +85,8 @@ def test_negative_data_rejection(ctx, testdir, cli, openapi3_base_url):
             }
         }
     )
-    schema_file = testdir.make_openapi_schema_file(schema)
     result = cli.run(
-        str(schema_file),
+        str(schema_path),
         f"--base-url={openapi3_base_url}",
         "--checks",
         "negative_data_rejection",
@@ -164,18 +163,11 @@ def schema(ctx):
         ["--experimental-positive-data-acceptance-allowed-statuses=200,201,400,401"],
     ],
 )
-def test_positive_data_acceptance(
-    testdir,
-    cli,
-    snapshot_cli,
-    schema,
-    openapi3_base_url,
-    args,
-):
-    schema_file = testdir.make_openapi_schema_file(schema)
+def test_positive_data_acceptance(ctx, cli, snapshot_cli, schema, openapi3_base_url, args):
+    schema_path = ctx.makefile(schema)
     assert (
         cli.run(
-            str(schema_file),
+            str(schema_path),
             f"--base-url={openapi3_base_url}",
             "--hypothesis-max-examples=5",
             "--experimental=positive_data_acceptance",
@@ -185,20 +177,13 @@ def test_positive_data_acceptance(
     )
 
 
-def test_positive_data_acceptance_with_env_vars(
-    testdir,
-    cli,
-    snapshot_cli,
-    schema,
-    openapi3_base_url,
-    monkeypatch,
-):
-    schema_file = testdir.make_openapi_schema_file(schema)
+def test_positive_data_acceptance_with_env_vars(ctx, cli, snapshot_cli, schema, openapi3_base_url, monkeypatch):
+    schema_path = ctx.makefile(schema)
     monkeypatch.setenv("SCHEMATHESIS_EXPERIMENTAL_POSITIVE_DATA_ACCEPTANCE", "true")
     monkeypatch.setenv("SCHEMATHESIS_EXPERIMENTAL_POSITIVE_DATA_ACCEPTANCE_ALLOWED_STATUSES", "403")
     assert (
         cli.run(
-            str(schema_file),
+            str(schema_path),
             f"--base-url={openapi3_base_url}",
             "--hypothesis-max-examples=5",
         )