Enforce < 400 status assertions, Pydantic response validation, and pytest addopts override in generated SDKs

- Emit addopts = "-o addopts=" and include pytest in [project].dependencies within openapi_client.scaffolding.scaffold_package so running pytest or uv run pytest inside generated SDK directories overrides parent repository coverage flags and resolves pytest in isolated environments.
- Add schema_ (alias="schema") to openapi_client.models.Response and emit Pydantic BaseModel classes in openapi_client.classes.emit.emit_classes whenever Schema.properties is defined, supporting both OpenAPI 3.x media-type schemas and Swagger 2.0 response schemas.
- Implement _extract_response_model in openapi_client.tests.emit and update emit_operation_test and emit_tests to import generated models (from models import *), assert response.status < 400, and validate single-object and array JSON response payloads via <Model>.model_validate(...).
- Add unit tests for response model extraction and an end-to-end integration test executing uv run pytest -c pyproject.toml test/ against a live local HTTP server inside a freshly generated SDK directory.

Author: SamuelMarks

src/openapi_client/classes/emit.py

@@ -141,7 +141,10 @@ def emit_classes(schemas: Mapping[str, SchemaOrReference]) -> list[cst.ClassDef]
     class_defs: list[cst.ClassDef] = []
     if schemas:
         for name, schema in schemas.items():
-            if isinstance(schema, Schema) and getattr(schema, "type", None) == "object":
+            if isinstance(schema, Schema) and (
+                getattr(schema, "type", None) == "object"
+                or getattr(schema, "properties", None) is not None
+            ):
                 class_defs.append(emit_class(name, schema))
     return class_defs
 

src/openapi_client/models.py

@@ -269,6 +269,7 @@ class Response(OpenAPIBase):
     headers: dict[str, Header | Reference] | None = None
     content: dict[str, MediaType | Reference] | None = None
     links: dict[str, Link | Reference] | None = None
+    schema_: SchemaOrReference | None = Field(None, alias="schema")
 
 
 class Responses(OpenAPIBase):

src/openapi_client/scaffolding.py

@@ -41,6 +41,7 @@ def scaffold_package(out_dir: Path, is_server: bool = False) -> None:
         '    "pydantic-core==2.41.5",',
         '    "urllib3",',
         '    "eval_type_backport",',
+        '    "pytest",',
     ]
 
     if is_server:
@@ -50,7 +51,6 @@ def scaffold_package(out_dir: Path, is_server: bool = False) -> None:
                 '    "uvicorn",',
                 '    "sqlalchemy",',
                 '    "faker",',
-                '    "pytest",',
                 '    "httpx",',
             ]
         )
@@ -82,7 +82,7 @@ def scaffold_package(out_dir: Path, is_server: bool = False) -> None:
 packages = ["src"]
 
 [tool.pytest.ini_options]
-addopts = ""
+addopts = "-o addopts="
 testpaths = {testpaths_str}
 """,
             encoding="utf-8",

src/openapi_client/tests/emit.py

@@ -124,6 +124,103 @@ def get_stub_body(schema_obj: Any, spec: OpenAPI | None = None) -> cst.BaseExpre
         return cst.Dict(elements=[])
 
 
+_PRIMITIVE_ANNOTATIONS = frozenset(
+    {"str", "int", "float", "bool", "Any", "list", "dict", "dict[str, Any]"}
+)
+
+
+def _extract_response_model(
+    operation: Operation, spec: OpenAPI | None = None
+) -> tuple[str | None, bool]:
+    """Extract the Pydantic response model name and whether it is a list from an operation.
+
+    Args:
+        operation: The OpenAPI Operation object.
+        spec: Optional full OpenAPI specification for `$ref` and schema lookup.
+
+    Returns:
+        A tuple of `(model_name, is_list)` where `model_name` is `None` if no Pydantic
+        response model applies.
+    """
+    responses = getattr(operation, "responses", None)
+    if not isinstance(responses, dict) or not responses:
+        return None, False
+
+    available_models: set[str] | None = None
+    if spec is not None and spec.components and spec.components.schemas:
+        available_models = {
+            name
+            for name, schema in spec.components.schemas.items()
+            if getattr(schema, "type", None) == "object"
+            or getattr(schema, "properties", None) is not None
+        }
+
+    ordered_keys = ["200", "201", "202", "default"] + [
+        str(k)
+        for k in responses
+        if str(k) not in ("200", "201", "202", "default") and str(k).startswith("2")
+    ]
+    for code in ordered_keys:
+        resp = responses.get(code)
+        if resp is None:
+            continue
+        ref_str = (
+            resp.get("$ref") if isinstance(resp, dict) else getattr(resp, "ref", None)
+        )
+        if (
+            isinstance(ref_str, str)
+            and "/" in ref_str
+            and spec is not None
+            and spec.components
+            and spec.components.responses
+        ):
+            ref_name = ref_str.split("/")[-1]
+            resp = spec.components.responses.get(ref_name, resp)
+
+        schema_obj: Any = None
+        content = (
+            resp.get("content")
+            if isinstance(resp, dict)
+            else getattr(resp, "content", None)
+        )
+        if isinstance(content, dict) and content:
+            media = (
+                content["application/json"]
+                if "application/json" in content
+                else next(iter(content.values()))
+            )
+            schema_obj = (
+                media.get("schema")
+                if isinstance(media, dict)
+                else getattr(media, "schema_", getattr(media, "schema", None))
+            )
+        if schema_obj is None:
+            schema_obj = (
+                resp.get("schema")
+                if isinstance(resp, dict)
+                else getattr(resp, "schema_", None)
+            )
+
+        if schema_obj is not None:
+            ann = get_annotation_for_schema(schema_obj)
+            if ann.startswith("list[") and ann.endswith("]"):
+                inner = ann[5:-1].strip()
+                if (
+                    inner.isidentifier()
+                    and inner not in _PRIMITIVE_ANNOTATIONS
+                    and (available_models is None or inner in available_models)
+                ):
+                    return inner, True
+            elif (
+                ann.isidentifier()
+                and ann not in _PRIMITIVE_ANNOTATIONS
+                and (available_models is None or ann in available_models)
+            ):
+                return ann, False
+
+    return None, False
+
+
 def emit_operation_test(
     method: str,
     path: str,
@@ -216,40 +313,50 @@ def emit_operation_test(
     )
 
     if composable:
-        responses = getattr(operation, "responses", None) or {}
-        has_only_200 = (
-            "200" in responses
-            and method.lower() == "get"
-            and "{" not in path
-            and not any(str(code).startswith("4") for code in responses)
-        )
-
-        status_expr = cst.Call(
-            func=cst.Name("getattr"),
-            args=[
-                cst.Arg(cst.Name("response")),
-                cst.Arg(cst.SimpleString('"status"')),
-                cst.Arg(cst.Integer("200")),
+        assertion_test = cst.Comparison(
+            left=cst.Attribute(value=cst.Name("response"), attr=cst.Name("status")),
+            comparisons=[
+                cst.ComparisonTarget(
+                    operator=cst.LessThan(), comparator=cst.Integer("400")
+                )
             ],
         )
-        if has_only_200:
-            assertion_test = cst.Comparison(
-                left=status_expr,
-                comparisons=[
-                    cst.ComparisonTarget(
-                        operator=cst.Equal(), comparator=cst.Integer("200")
-                    )
-                ],
-            )
+
+        model_name, is_list = _extract_response_model(operation, spec)
+        if model_name is not None and is_list:
+            validation_block = f"""if getattr(response, "data", None):
+    payload = response.json() if hasattr(response, "json") else json.loads(response.data.decode("utf-8"))
+    assert payload is not None
+    if isinstance(payload, list):
+        for item in payload:
+            if isinstance(item, dict):
+                assert "sabotage" not in item
+            {model_name}.model_validate(item)
+    else:
+        if isinstance(payload, dict):
+            assert "sabotage" not in payload
+        {model_name}.model_validate(payload)
+elif isinstance(response, dict):
+    assert "sabotage" not in response
+    {model_name}.model_validate(response)"""
+        elif model_name is not None:
+            validation_block = f"""if getattr(response, "data", None):
+    payload = response.json() if hasattr(response, "json") else json.loads(response.data.decode("utf-8"))
+    assert payload is not None
+    if isinstance(payload, dict):
+        assert "sabotage" not in payload
+    {model_name}.model_validate(payload)
+elif isinstance(response, dict):
+    assert "sabotage" not in response
+    {model_name}.model_validate(response)"""
         else:
-            assertion_test = cst.Comparison(
-                left=status_expr,
-                comparisons=[
-                    cst.ComparisonTarget(
-                        operator=cst.LessThan(), comparator=cst.Integer("500")
-                    )
-                ],
-            )
+            validation_block = """if getattr(response, "data", None):
+    payload = response.json() if hasattr(response, "json") else json.loads(response.data.decode("utf-8"))
+    assert payload is not None
+    if isinstance(payload, dict):
+        assert "sabotage" not in payload
+elif isinstance(response, dict):
+    assert "sabotage" not in response"""
 
         body: list[cst.BaseStatement] = [
             cst.SimpleStatementLine(
@@ -264,15 +371,7 @@ def emit_operation_test(
             cst.SimpleStatementLine(
                 [cst.Import(names=[cst.ImportAlias(name=cst.Name("json"))])]
             ),
-            cst.parse_statement(
-                """if getattr(response, "data", None):
-    payload = response.json() if hasattr(response, "json") else json.loads(response.data.decode("utf-8"))
-    assert payload is not None
-    if isinstance(payload, dict):
-        assert "sabotage" not in payload
-elif isinstance(response, dict):
-    assert "sabotage" not in response"""
-            ),
+            cst.parse_statement(validation_block),
         ]
 
         params = cst.Parameters(params=[cst.Param(name=cst.Name("client"))])
@@ -434,6 +533,17 @@ def emit_tests(spec: OpenAPI, composable: bool = False) -> cst.Module:
             ]
         )
     )
+    if spec.components and spec.components.schemas:
+        body.append(
+            cst.SimpleStatementLine(
+                [
+                    cst.ImportFrom(
+                        module=cst.Name("models"),
+                        names=cst.ImportStar(),
+                    )
+                ]
+            )
+        )
     body.append(cst.EmptyLine())
 
     if composable: