readOnly should affect only properties

Author: hh-h

aiohttp_swagger3/validators.py

@@ -576,10 +576,11 @@ def validate(self, request: web.Request, raw: bool) -> Dict[str, str]:
         return values
 
 
-def to_integer(schema: Dict) -> Integer:
+def to_integer(schema: Dict, is_property: bool) -> Integer:
+    read_only = schema.get("readOnly", False) if is_property else False
     return Integer(
         nullable=schema.get("nullable", False),
-        readOnly=schema.get("readOnly", False),
+        readOnly=read_only,
         minimum=schema.get("minimum"),
         maximum=schema.get("maximum"),
         exclusiveMinimum=schema.get("exclusiveMinimum", False),
@@ -590,10 +591,11 @@ def to_integer(schema: Dict) -> Integer:
     )
 
 
-def to_number(schema: Dict) -> Number:
+def to_number(schema: Dict, is_property: bool) -> Number:
+    read_only = schema.get("readOnly", False) if is_property else False
     return Number(
         nullable=schema.get("nullable", False),
-        readOnly=schema.get("readOnly", False),
+        readOnly=read_only,
         minimum=schema.get("minimum"),
         maximum=schema.get("maximum"),
         exclusiveMinimum=schema.get("exclusiveMinimum", False),
@@ -604,11 +606,12 @@ def to_number(schema: Dict) -> Number:
     )
 
 
-def to_string(schema: Dict) -> String:
+def to_string(schema: Dict, is_property: bool) -> String:
+    read_only = schema.get("readOnly", False) if is_property else False
     return String(
         format=schema.get("format"),
         nullable=schema.get("nullable", False),
-        readOnly=schema.get("readOnly", False),
+        readOnly=read_only,
         minLength=schema.get("minLength"),
         maxLength=schema.get("maxLength"),
         enum=schema.get("enum"),
@@ -617,27 +620,29 @@ def to_string(schema: Dict) -> String:
     )
 
 
-def to_boolean(schema: Dict) -> Boolean:
+def to_boolean(schema: Dict, is_property: bool) -> Boolean:
+    read_only = schema.get("readOnly", False) if is_property else False
     return Boolean(
         nullable=schema.get("nullable", False),
-        readOnly=schema.get("readOnly", False),
+        readOnly=read_only,
         default=schema.get("default"),
     )
 
 
-def to_array(schema: Dict) -> Array:
+def to_array(schema: Dict, is_property: bool) -> Array:
+    read_only = schema.get("readOnly", False) if is_property else False
     return Array(
         nullable=schema.get("nullable", False),
-        readOnly=schema.get("readOnly", False),
+        readOnly=read_only,
         validator=schema_to_validator(schema["items"]),
         uniqueItems=schema.get("uniqueItems", False),
         minItems=schema.get("minItems"),
         maxItems=schema.get("maxItems"),
     )
 
 
-def to_object(schema: Dict) -> Object:
-    properties = {k: schema_to_validator(v) for k, v in schema.get("properties", {}).items()}
+def to_object(schema: Dict, is_property: bool) -> Object:
+    properties = {k: schema_to_validator(v, is_property=True) for k, v in schema.get("properties", {}).items()}
     raw_additional_properties = schema.get("additionalProperties", True)
     if isinstance(raw_additional_properties, dict):
         additional_properties = schema_to_validator(raw_additional_properties)
@@ -649,9 +654,10 @@ def to_object(schema: Dict) -> Object:
         if getattr(validator, "readOnly", False):
             required.discard(name)
 
+    read_only = schema.get("readOnly", False) if is_property else False
     return Object(
         nullable=schema.get("nullable", False),
-        readOnly=schema.get("readOnly", False),
+        readOnly=read_only,
         properties=properties,
         required=required,
         minProperties=schema.get("minProperties"),
@@ -670,15 +676,15 @@ def to_object(schema: Dict) -> Object:
 }
 
 
-def _type_to_validator(schema: Dict) -> Validator:
+def _type_to_validator(schema: Dict, *, is_property: bool) -> Validator:
     if "type" not in schema:
         raise KeyError("type is required")
     if schema["type"] not in _TYPE_TO_FACTORY:
         raise Exception(f"Unknown type '{schema['type']}'")
-    return _TYPE_TO_FACTORY[schema["type"]](schema)
+    return _TYPE_TO_FACTORY[schema["type"]](schema, is_property)
 
 
-def schema_to_validator(schema: Dict) -> Validator:
+def schema_to_validator(schema: Dict, *, is_property: bool = False) -> Validator:
     if "$ref" in schema:
         components = COMPONENTS.get()
         if not components:
@@ -688,7 +694,7 @@ def schema_to_validator(schema: Dict) -> Validator:
         schema = components[section][obj]
 
     if not any(field in schema for field in ("oneOf", "anyOf", "allOf")):
-        return _type_to_validator(schema)
+        return _type_to_validator(schema, is_property=is_property)
 
     if "oneOf" in schema:
         cls: Type[Union[OneOf, AnyOf]] = OneOf

tests/test_docs_request_bodies.py

@@ -1314,200 +1314,6 @@ async def handler(request, body: Dict):
     assert error == {"body": "no handler for application/json"}
 
 
-async def test_object_read_only_properties_skipped(swagger_docs, aiohttp_client):
-
-    routes = web.RouteTableDef()
-
-    @routes.post("/r")
-    async def handler(request, body: Dict):
-        """
-        ---
-        requestBody:
-          required: true
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  boolean:
-                    type: boolean
-                    readOnly: true
-                  integer:
-                    type: integer
-                    readOnly: true
-                  number:
-                    type: number
-                    readOnly: true
-                  string:
-                    type: string
-                    readOnly: true
-                  array:
-                    type: array
-                    items:
-                      type: string
-                    readOnly: true
-                  object:
-                    type: object
-                    readOnly: true
-
-        responses:
-          '200':
-            description: OK.
-        """
-        return web.json_response(body)
-
-    swagger = swagger_docs()
-    swagger.add_routes(routes)
-
-    client = await aiohttp_client(swagger._app)
-
-    resp = await client.post("/r", json={})
-    assert resp.status == 200
-    assert await resp.json() == {}
-
-
-async def test_object_read_only_properties_passed(swagger_docs, aiohttp_client):
-
-    routes = web.RouteTableDef()
-
-    @routes.post("/r")
-    async def handler(request, body: Dict):
-        """
-        ---
-        requestBody:
-          required: true
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  boolean:
-                    type: boolean
-                    readOnly: true
-                  integer:
-                    type: integer
-                    readOnly: true
-                  number:
-                    type: number
-                    readOnly: true
-                  string:
-                    type: string
-                    readOnly: true
-                  array:
-                    type: array
-                    items:
-                      type: string
-                    readOnly: true
-                  object:
-                    type: object
-                    readOnly: true
-
-        responses:
-          '200':
-            description: OK.
-        """
-        return web.json_response(body)
-
-    swagger = swagger_docs()
-    swagger.add_routes(routes)
-
-    client = await aiohttp_client(swagger._app)
-
-    resp = await client.post(
-        "/r",
-        json={
-            "boolean": True,
-            "integer": 10,
-            "number": 1.1,
-            "string": "str",
-            "array": [1, 2, 3],
-            "object": {"some": "thing"},
-        },
-    )
-    assert resp.status == 400
-    error = error_to_json(await resp.text())
-    msg = "property is read-only"
-    assert error == {
-        "body": {
-            "boolean": msg,
-            "integer": msg,
-            "number": msg,
-            "string": msg,
-            "array": msg,
-            "object": msg,
-        }
-    }
-
-
-async def test_object_required_read_only_properties(swagger_docs, aiohttp_client):
-
-    routes = web.RouteTableDef()
-
-    @routes.post("/r")
-    async def handler(request, body: Dict):
-        """
-        ---
-        requestBody:
-          required: true
-          content:
-            application/json:
-              schema:
-                type: object
-                required:
-                  - id
-                  - name
-                  - description
-                  - updated_at
-                properties:
-                  id:
-                    type: integer
-                    readOnly: true
-                  name:
-                    type: string
-                  description:
-                    type: string
-                  updated_at:
-                    type: integer
-                    readOnly: true
-
-        responses:
-          '200':
-            description: OK.
-        """
-        return web.json_response(body)
-
-    swagger = swagger_docs()
-    swagger.add_routes(routes)
-
-    client = await aiohttp_client(swagger._app)
-
-    body = {
-        "name": "name1",
-        "description": "description",
-    }
-    resp = await client.post("/r", json=body)
-    assert resp.status == 200
-    assert await resp.json() == body
-
-    resp = await client.post(
-        "/r",
-        json={
-            "id": 1,
-            "name": "name1",
-            "description": "description",
-            "updated_at": 1609407277,
-        },
-    )
-    assert resp.status == 400
-    error = error_to_json(await resp.text())
-    assert error == {
-        "body": {
-            "id": "property is read-only",
-            "updated_at": "property is read-only",
-        }
-    }
-
-
 async def test_nullable_ref(swagger_docs_with_components, aiohttp_client):
 
     routes = web.RouteTableDef()