Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesA passing Python test confirms only that the assertions it ran passed for the inputs and code path it exercised. It does not prove that a real client sends the same request—or that the response observed outside the test matches your API contract. Compare the test request with the real one, then follow the data through parsing, validation, application logic and final JSON serialization.
First, identify which payload looks wrong
Be precise about whether you mean the request sent to the server or the response returned by it. Save the expected and observed payloads separately, and label each one. A printed Python object can look different from its JSON representation, so compare decoded values, types and structure rather than relying on a log line or string representation.
As an Amazon Associate I earn from qualifying purchases.
- For a request, capture the method, path, query parameters, headers, cookies and body.
- For a response, capture the status, relevant headers and decoded body as received by the client.
- Record the expected and actual keys, nested objects or arrays, value types and values that matter to callers.
This separates a mismatch in what the client sends from one introduced while the server handles or returns the data.
Recommended Free Tools
Does the test assert the API contract?
A test that checks only a status code can pass while the body has unexpected keys, missing fields, altered types or an incorrect nested shape. Check what the test actually asserts. A client-level request/response test should verify the response body and any contract-relevant headers as well as the status.
#1 Best Overall
FastAPI’s testing documentation demonstrates checking both the status code and decoded JSON response. An internal unit test can still be useful, but it exercises a different boundary: a successful function call does not establish that the public request and response behave as intended.
Does the test send the same request as the real client?
Compare the test’s request with the real client’s request field by field. A mismatch in method, URL, query parameters, body encoding, headers or cookies can lead the server down a different path even when the test passes.
- Confirm the HTTP method and exact path, including relevant query parameters.
- Check whether the body is JSON or form data, and compare its values and types.
- Compare headers, especially Content-Type, plus any cookies the endpoint depends on.
In FastAPI’s TestClient, pass a Python mapping through json= for a JSON body; use data= for form data. The documentation notes: “Note that the TestClient receives data that can be converted to JSON, not Pydantic models.” In other words, construct the test input as request data, rather than passing a model instance as if it were the client’s wire-format body.
Check Content-Type before changing parsing behavior
When a JSON request works in a test but not from a real client, compare the actual Content-Type header. FastAPI documents strict Content-Type checking for JSON request-body parsing by default: the request needs a valid JSON content type, such as application/json. A missing or invalid header can affect how the body is parsed.
FastAPI documents strict_content_type=False as an opt-out, but its default has a security rationale. Treat that setting as a deliberate, context-specific choice—not a generic fix for a malformed request. First establish what the client sends and whether the endpoint is meant to accept it. The relevant behavior and configuration should also be checked against the FastAPI version installed in your project. See the FastAPI strict Content-Type documentation.
Trace validation and conversion for shape changes
If the server receives the request but the resulting data differs from what the client sent, inspect the parsed and validated value. Compare the declared model with the expected contract, including nested models, field names, defaults and collection types. The exact stages depend on the framework and application configuration; do not assume every Python API uses FastAPI or Pydantic.
For FastAPI applications using Pydantic, validation can convert input into declared types. Some differences may be intentional consequences of the model:
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →- A field declared as a
setremoves duplicate values. If repeated items disappear, check whether deduplication is part of the declared type. - JSON object keys are strings. With a typed mapping, Pydantic may convert integer-like keys, but the JSON representation still has string keys.
- Nested models and defaults can affect which fields and values are present. Compare the validated value with the input and with the API’s intended output contract.
FastAPI’s nested-model documentation describes nested data structures; Pydantic’s serialization documentation covers serialization and conversion behavior. Check the versions pinned in your project before relying on a particular API or behavior.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Inspect the final JSON serialization boundary
A Python value is not necessarily identical to the JSON value a client receives. For example, Pydantic’s JSON mode converts a tuple to a JSON-compatible array and supports converting particular Python types. Unsupported values can instead raise PydanticSerializationError. An in-memory value can therefore look fine while the final response differs or fails during serialization.
Trace the value through request parsing and validation, application logic, any response-model filtering or conversion, and JSON serialization. Inspect both the in-memory value and the final response body. Pydantic documents JSON mode and model_dump_json() in its serialization guide. Some behaviors on that live page are identified as new in Pydantic v2.13, so confirm your installed and pinned version before using a particular API.
Pydantic cautions that “A serialization error like this often only shows up when a particular object reaches the point of being serialized (commonly when building a response), so it can be easy to miss until it happens in production.” That describes a possible failure mode, not every payload mismatch. If the issue occurs only in production, capture the failing input and serialization exception safely, with request context; Pydantic’s documentation also describes instrumentation as a way to capture such errors.
Turn the mismatch into a regression test
Once you know which boundary changes the payload, make the test exercise that boundary. For an API contract, send a client-like request and assert the returned response rather than testing only an internal function.
- Save a representative request, including method, path, query parameters, body, Content-Type and any relevant cookies or headers.
- Send it through the same client-facing route the real caller uses, using the appropriate JSON or form-data mechanism.
- Assert the status and relevant response headers, then check the decoded JSON keys, nested structure and values or types that clients depend on.
- Include cases for meaningful edge conditions, such as duplicate collection values or optional fields, when those cases are part of the contract.
Keep assertions focused on externally meaningful behavior. That gives the test a better chance of detecting a mismatch between what the client sends, what the server processes and what the client receives.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
