Validate oneOf with discriminator

Author: gberaudo

openapi_schema_validator/_validators.py

@@ -1,7 +1,52 @@
 from jsonschema._utils import find_additional_properties, extras_msg
+from jsonschema._validators import oneOf as _oneOf
+
 from jsonschema.exceptions import ValidationError, FormatError
 
 
+def handle_discriminator(validator, _, instance, schema):
+    discriminator = schema['discriminator']
+    prop_name = discriminator['propertyName']
+    prop_value = instance.get(prop_name)
+    if not prop_value:
+        # instance is missing discriminator value, this is a schema error
+        yield ValidationError(
+            "%r does not contain discriminating property" % (instance,),
+            context=[],
+        )
+        return
+
+    # FIXME: handle implicit refs and missing mapping field
+    subschema = discriminator['mapping'].get(prop_value)
+    if not subschema:
+        yield ValidationError(
+            "%r is not a valid discriminator value, expected one of %r" % (
+                instance, discriminator['mapping'].keys()),
+            context=[],
+        )
+        return
+
+    if not isinstance(subschema, str):
+        # this is a schema error
+        yield ValidationError(
+            "%r mapped value for %r should be a string, was %r" % (
+                instance, prop_value, subschema),
+            context=[],
+        )
+        return
+
+    yield from validator.descend(instance, {
+        "$ref": subschema
+    })
+
+
+def oneOf(validator, oneOf, instance, schema):
+    if 'discriminator' not in schema:
+        yield from _oneOf(validator, oneOf, instance, schema)
+    else:
+        yield from handle_discriminator(validator, oneOf, instance, schema)
+
+
 def type(validator, data_type, instance, schema):
     if instance is None:
         return

openapi_schema_validator/validators.py

@@ -28,7 +28,7 @@
         # adjusted to OAS
         u"type": oas_validators.type,
         u"allOf": _validators.allOf,
-        u"oneOf": _validators.oneOf,
+        u"oneOf": oas_validators.oneOf,
         u"anyOf": _validators.anyOf,
         u"not": _validators.not_,
         u"items": oas_validators.items,

tests/integration/test_validators.py

@@ -240,6 +240,87 @@ def test_oneof_required(self):
         assert result is None
 
 
+    def test_oneof_discriminator(self):
+        schema = {
+            "$ref": "#/$defs/Route",
+            "$defs": {
+                "MountainHiking": {
+                    "type": "object",
+                    "properties": {
+                        "discipline": {
+                            "type": "string",
+                            "enum": ["mountain_hiking"]
+                        },
+                        "length": {
+                            "type": "integer",
+                        }
+                    },
+                    "required": ["discipline", "length"]
+                },
+                "AlpineClimbing": {
+                    "type": "object",
+                    "properties": {
+                        "discipline": {
+                            "type": "string",
+                            "enum": ["alpine_climbing"]
+                        },
+                        "height": {
+                            "type": "integer",
+                        },
+                    },
+                    "required": ["discipline", "height"]
+                },
+                "Route": {
+                    "oneOf": [
+                        {"$ref": "#/$defs/MountainHiking"},
+                        {"$ref": "#/$defs/AlpineClimbing"},
+                    ]
+                }
+            }
+        }
+
+        # use jsonschema validator when no discriminator is defined
+        validator = OAS30Validator(schema, format_checker=oas30_format_checker)
+        with pytest.raises(ValidationError, match="is not valid under any of the given schemas"):
+            validator.validate({
+                "something": "matching_none_of_the_schemas"
+            })
+            assert False
+
+        discriminator = {
+            "propertyName": "discipline",
+            "mapping": {
+                "mountain_hiking": "#/$defs/MountainHiking",
+                "alpine_climbing": "#/$defs/AlpineClimbing",
+            }
+        }
+        schema['$defs']['Route']['discriminator'] = discriminator
+        validator = OAS30Validator(schema, format_checker=oas30_format_checker)
+        with pytest.raises(ValidationError, match="does not contain discriminating property"):
+            validator.validate({
+                "something": "missing"
+            })
+            assert False
+
+        with pytest.raises(ValidationError, match="is not a valid discriminator value, expected one of"):
+            result = validator.validate({
+                "discipline": "other"
+            })
+            assert False
+
+        with pytest.raises(ValidationError, match="'bad_string' is not of type integer"):
+            validator.validate({
+                "discipline": "mountain_hiking",
+                "length": "bad_string"
+            })
+            assert False
+
+        validator.validate({
+                "discipline": "mountain_hiking",
+                "length": 10
+            })
+
+
 class TestOAS31ValidatorValidate(object):
     @pytest.mark.parametrize('schema_type', [
         'boolean', 'array', 'integer', 'number', 'string',