Property read-only and write-only support

Author: p1c2u

openapi_core/schema/parameters/models.py

@@ -9,9 +9,6 @@
 log = logging.getLogger(__name__)
 
 
-_CONTEXT = UnmarshalContext.REQUEST
-
-
 class Parameter(object):
     """Represents an OpenAPI operation Parameter."""
 

openapi_core/schema/schemas/enums.py

@@ -26,8 +26,3 @@ class SchemaFormat(Enum):
     DATETIME = 'date-time'
     PASSWORD = 'password'
     UUID = 'uuid'
-
-
-class UnmarshalContext(Enum):
-    REQUEST = 'request'
-    RESPONSE = 'response'

openapi_core/schema/schemas/models.py

@@ -60,9 +60,6 @@ def __init__(
         self.read_only = read_only
         self.write_only = write_only
 
-        if self.read_only and self.write_only:
-            raise OpenAPISchemaError("Schema cannot be readOnly AND writeOnly")
-
         self.extensions = extensions and dict(extensions) or {}
 
         self._all_required_properties_cache = None

openapi_core/schema/schemas/util.py

@@ -3,9 +3,6 @@
 from six import string_types
 from json import dumps
 
-from openapi_core.schema.schemas.enums import UnmarshalContext
-from openapi_core.schema.schemas.exceptions import UnmarshalContextNotSet
-
 
 def forcebool(val):
     if isinstance(val, string_types):

openapi_core/schema_validator/_validators.py

@@ -35,6 +35,19 @@ def nullable(validator, is_nullable, instance, schema):
         yield ValidationError("None for not nullable")
 
 
+def required(validator, required, instance, schema):
+    if not validator.is_type(instance, "object"):
+        return
+    for property in required:
+        if property not in instance:
+            prop_schema = schema['properties'][property]
+            read_only = prop_schema.get('readOnly', False)
+            write_only = prop_schema.get('writeOnly', False)
+            if validator.write and read_only or validator.read and write_only:
+                continue
+            yield ValidationError("%r is a required property" % property)
+
+
 def additionalProperties(validator, aP, instance, schema):
     if not validator.is_type(instance, "object"):
         return
@@ -54,5 +67,21 @@ def additionalProperties(validator, aP, instance, schema):
             yield ValidationError(error % extras_msg(extras))
 
 
+def readOnly(validator, ro, instance, schema):
+    if not validator.write or not ro:
+        return
+
+    yield ValidationError(
+        "Tried to write read-only proparty with %s" % (instance))
+
+
+def writeOnly(validator, wo, instance, schema):
+    if not validator.read or not wo:
+        return
+
+    yield ValidationError(
+        "Tried to read write-only proparty with %s" % (instance))
+
+
 def not_implemented(validator, value, instance, schema):
     pass

openapi_core/schema_validator/validators.py

@@ -21,7 +21,6 @@
         u"uniqueItems": _validators.uniqueItems,
         u"maxProperties": _validators.maxProperties,
         u"minProperties": _validators.minProperties,
-        u"required": _validators.required,
         u"enum": _validators.enum,
         # adjusted to OAS
         u"type": oas_validators.type,
@@ -31,6 +30,7 @@
         u"not": _validators.not_,
         u"items": oas_validators.items,
         u"properties": _validators.properties,
+        u"required": oas_validators.required,
         u"additionalProperties": oas_validators.additionalProperties,
         # TODO: adjust description
         u"format": oas_validators.format,
@@ -39,8 +39,8 @@
         # fixed OAS fields
         u"nullable": oas_validators.nullable,
         u"discriminator": oas_validators.not_implemented,
-        u"readOnly": oas_validators.not_implemented,
-        u"writeOnly": oas_validators.not_implemented,
+        u"readOnly": oas_validators.readOnly,
+        u"writeOnly": oas_validators.writeOnly,
         u"xml": oas_validators.not_implemented,
         u"externalDocs": oas_validators.not_implemented,
         u"example": oas_validators.not_implemented,
@@ -54,6 +54,11 @@
 
 class OAS30Validator(BaseOAS30Validator):
 
+    def __init__(self, *args, **kwargs):
+        self.read = kwargs.pop('read', None)
+        self.write = kwargs.pop('write', None)
+        super(OAS30Validator, self).__init__(*args, **kwargs)
+
     def iter_errors(self, instance, _schema=None):
         if _schema is None:
             _schema = self.schema

openapi_core/unmarshalling/schemas/enums.py

@@ -0,0 +1,7 @@
+"""OpenAPI core unmarshalling schemas enums module"""
+from enum import Enum
+
+
+class UnmarshalContext(Enum):
+    REQUEST = 'request'
+    RESPONSE = 'response'

openapi_core/unmarshalling/schemas/factories.py

@@ -5,6 +5,7 @@
 from openapi_core.schema.schemas.models import Schema
 from openapi_core.schema_validator import OAS30Validator
 from openapi_core.schema_validator import oas30_format_checker
+from openapi_core.unmarshalling.schemas.enums import UnmarshalContext
 from openapi_core.unmarshalling.schemas.exceptions import (
     FormatterNotFoundError,
 )
@@ -29,11 +30,17 @@ class SchemaUnmarshallersFactory(object):
         SchemaType.ANY: AnyUnmarshaller,
     }
 
-    def __init__(self, resolver=None, custom_formatters=None):
+    CONTEXT_VALIDATION = {
+        UnmarshalContext.REQUEST: 'write',
+        UnmarshalContext.RESPONSE: 'read',
+    }
+
+    def __init__(self, resolver=None, custom_formatters=None, context=None):
         self.resolver = resolver
         if custom_formatters is None:
             custom_formatters = {}
         self.custom_formatters = custom_formatters
+        self.context = context
 
     def create(self, schema, type_override=None):
         """Create unmarshaller from the schema."""
@@ -50,7 +57,9 @@ def create(self, schema, type_override=None):
         elif schema_type in self.COMPLEX_UNMARSHALLERS:
             klass = self.COMPLEX_UNMARSHALLERS[schema_type]
             kwargs = dict(
-                schema=schema, unmarshallers_factory=self)
+                schema=schema, unmarshallers_factory=self,
+                context=self.context,
+            )
 
         formatter = self.get_formatter(klass.FORMATTERS, schema.format)
 
@@ -70,10 +79,17 @@ def get_formatter(self, default_formatters, type_format=SchemaFormat.NONE):
             return default_formatters.get(schema_format)
 
     def get_validator(self, schema):
-        format_checker = deepcopy(oas30_format_checker)
+        format_checker = self._get_format_checker()
+        kwargs = {
+            'resolver': self.resolver,
+            'format_checker': format_checker,
+        }
+        if self.context is not None:
+            kwargs[self.CONTEXT_VALIDATION[self.context]] = True
+        return OAS30Validator(schema.__dict__, **kwargs)
+
+    def _get_format_checker(self):
+        fc = deepcopy(oas30_format_checker)
         for name, formatter in self.custom_formatters.items():
-            format_checker.checks(name)(formatter.validate)
-        return OAS30Validator(
-            schema.__dict__,
-            resolver=self.resolver, format_checker=format_checker,
-        )
+            fc.checks(name)(formatter.validate)
+        return fc

openapi_core/unmarshalling/schemas/unmarshallers.py

@@ -13,6 +13,7 @@
     is_object, is_number, is_string,
 )
 from openapi_core.schema_validator._format import oas30_format_checker
+from openapi_core.unmarshalling.schemas.enums import UnmarshalContext
 from openapi_core.unmarshalling.schemas.exceptions import (
     UnmarshalError, ValidateError, InvalidSchemaValue,
     InvalidSchemaFormatValue,
@@ -120,9 +121,12 @@ class BooleanUnmarshaller(PrimitiveTypeUnmarshaller):
 
 class ComplexUnmarshaller(PrimitiveTypeUnmarshaller):
 
-    def __init__(self, formatter, validator, schema, unmarshallers_factory):
+    def __init__(
+            self, formatter, validator, schema, unmarshallers_factory,
+            context=None):
         super(ComplexUnmarshaller, self).__init__(formatter, validator, schema)
         self.unmarshallers_factory = unmarshallers_factory
+        self.context = context
 
 
 class ArrayUnmarshaller(ComplexUnmarshaller):
@@ -206,6 +210,10 @@ def _unmarshal_properties(self, value=NoValue, one_of_schema=None):
                 properties[prop_name] = prop_value
 
         for prop_name, prop in iteritems(all_props):
+            if self.context == UnmarshalContext.REQUEST and prop.read_only:
+                continue
+            if self.context == UnmarshalContext.RESPONSE and prop.write_only:
+                continue
             try:
                 prop_value = value[prop_name]
             except KeyError:

openapi_core/validation/request/validators.py

@@ -11,9 +11,9 @@
 )
 from openapi_core.schema.paths.exceptions import InvalidPath
 from openapi_core.schema.request_bodies.exceptions import MissingRequestBody
-from openapi_core.schema.schemas.enums import UnmarshalContext
 from openapi_core.schema.servers.exceptions import InvalidServer
 from openapi_core.security.exceptions import SecurityError
+from openapi_core.unmarshalling.schemas.enums import UnmarshalContext
 from openapi_core.unmarshalling.schemas.exceptions import (
     UnmarshalError, ValidateError,
 )
@@ -24,8 +24,6 @@
 from openapi_core.validation.util import get_operation_pattern
 
 
-_CONTEXT = UnmarshalContext.REQUEST
-
 class RequestValidator(object):
 
     def __init__(
@@ -259,7 +257,9 @@ def _unmarshal(self, param_or_media_type, value):
             SchemaUnmarshallersFactory,
         )
         unmarshallers_factory = SchemaUnmarshallersFactory(
-            self.spec._resolver, self.custom_formatters)
+            self.spec._resolver, self.custom_formatters,
+            context=UnmarshalContext.REQUEST,
+        )
         unmarshaller = unmarshallers_factory.create(
             param_or_media_type.schema)
         return unmarshaller(value)

openapi_core/validation/response/validators.py

@@ -6,16 +6,14 @@
 from openapi_core.schema.responses.exceptions import (
     InvalidResponse, MissingResponseContent,
 )
-from openapi_core.schema.schemas.enums import UnmarshalContext
 from openapi_core.schema.servers.exceptions import InvalidServer
+from openapi_core.unmarshalling.schemas.enums import UnmarshalContext
 from openapi_core.unmarshalling.schemas.exceptions import (
     UnmarshalError, ValidateError,
 )
 from openapi_core.validation.response.datatypes import ResponseValidationResult
 from openapi_core.validation.util import get_operation_pattern
 
-_CONTEXT = UnmarshalContext.RESPONSE
-
 
 class ResponseValidator(object):
 
@@ -76,7 +74,6 @@ def _get_data(self, response, operation_response):
 
         try:
             media_type = operation_response[response.mimetype]
-
         except InvalidContentType as exc:
             return None, [exc, ]
 
@@ -143,7 +140,9 @@ def _unmarshal(self, param_or_media_type, value):
             SchemaUnmarshallersFactory,
         )
         unmarshallers_factory = SchemaUnmarshallersFactory(
-            self.spec._resolver, self.custom_formatters)
+            self.spec._resolver, self.custom_formatters,
+            context=UnmarshalContext.RESPONSE,
+        )
         unmarshaller = unmarshallers_factory.create(
             param_or_media_type.schema)
         return unmarshaller(value)

tests/integration/schema/test_spec.py

@@ -268,5 +268,9 @@ def test_spec(self, spec, spec_dict):
         if not spec.components:
             return
 
-        for _, schema in iteritems(spec.components.schemas):
+        for schema_name, schema in iteritems(spec.components.schemas):
             assert type(schema) == Schema
+
+            schema_spec = spec_dict['components']['schemas'][schema_name]
+            assert schema.read_only == schema_spec.get('readOnly', False)
+            assert schema.write_only == schema_spec.get('writeOnly', False)