Fully handle anyOf, oneOf and allOf

- handle implicit refs and missing "mapping";
- test all 3 cases.

Author: gberaudo

openapi_schema_validator/_validators.py

@@ -1,10 +1,14 @@
 from jsonschema._utils import find_additional_properties, extras_msg
-from jsonschema._validators import oneOf as _oneOf
+from jsonschema._validators import oneOf as _oneOf, anyOf as _anyOf, allOf as _allOf
 
 from jsonschema.exceptions import ValidationError, FormatError
 
 
 def handle_discriminator(validator, _, instance, schema):
+    """
+    Handle presence of discriminator in anyOf, oneOf and allOf.
+    The behaviour is the same in all 3 cases because at most 1 schema will match.
+    """
     discriminator = schema['discriminator']
     prop_name = discriminator['propertyName']
     prop_value = instance.get(prop_name)
@@ -16,37 +20,54 @@ def handle_discriminator(validator, _, instance, schema):
         )
         return
 
-    # FIXME: handle implicit refs and missing mapping field
-    explicitRef = discriminator['mapping'].get(prop_value)
-    if not explicitRef:
+    # Use explicit mapping if available, otherwise try implicit value
+    ref = discriminator.get('mapping', {}).get(prop_value) or f'#/components/schemas/{prop_value}'
+
+    if not isinstance(ref, str):
+        # this is a schema error
         yield ValidationError(
-            "%r is not a valid discriminator value, expected one of %r" % (
-                instance, discriminator['mapping'].keys()),
+            "%r mapped value for %r should be a string, was %r" % (
+                instance, prop_value, ref),
             context=[],
         )
         return
 
-    if not isinstance(explicitRef, str):
-        # this is a schema error
+    try:
+        validator.resolver.resolve(ref)
+    except:
         yield ValidationError(
-            "%r mapped value for %r should be a string, was %r" % (
-                instance, prop_value, explicitRef),
+            "%r reference %r could not be resolved" % (
+                instance, ref),
             context=[],
         )
         return
 
     yield from validator.descend(instance, {
-        "$ref": explicitRef
+        "$ref": ref
     })
 
 
+def anyOf(validator, anyOf, instance, schema):
+    if 'discriminator' not in schema:
+        yield from _anyOf(validator, anyOf, instance, schema)
+    else:
+        yield from handle_discriminator(validator, anyOf, instance, schema)
+
+
 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 allOf(validator, allOf, instance, schema):
+    if 'discriminator' not in schema:
+        yield from _allOf(validator, allOf, instance, schema)
+    else:
+        yield from handle_discriminator(validator, allOf, instance, schema)
+
+
 def type(validator, data_type, instance, schema):
     if instance is None:
         return

openapi_schema_validator/validators.py

@@ -27,9 +27,9 @@
         u"enum": _validators.enum,
         # adjusted to OAS
         u"type": oas_validators.type,
-        u"allOf": _validators.allOf,
+        u"allOf": oas_validators.allOf,
         u"oneOf": oas_validators.oneOf,
-        u"anyOf": _validators.anyOf,
+        u"anyOf": oas_validators.anyOf,
         u"not": _validators.not_,
         u"items": oas_validators.items,
         u"properties": _validators.properties,

tests/integration/test_validators.py

@@ -240,15 +240,20 @@ def test_oneof_required(self):
         assert result is None
 
 
-    def test_oneof_discriminator(self):
+    @pytest.mark.parametrize('schema_type', [
+        'oneOf', 'anyOf', 'allOf',
+    ])
+    def test_oneof_discriminator(self, schema_type):
         # We define a few components schemas
         components = {
             "MountainHiking": {
                 "type": "object",
                 "properties": {
                     "discipline": {
                         "type": "string",
-                        "enum": ["mountain_hiking"]
+                        # we allow both the explicitely matched mountain_hiking discipline
+                        # and the implicitely matched MoutainHiking discipline
+                        "enum": ["mountain_hiking", "MountainHiking"]
                     },
                     "length": {
                         "type": "integer",
@@ -270,12 +275,13 @@ def test_oneof_discriminator(self):
                 "required": ["discipline", "height"]
             },
             "Route": {
-                "oneOf": [
-                    {"$ref": "#/components/schemas/MountainHiking"},
-                    {"$ref": "#/components/schemas/AlpineClimbing"},
-                ]
+                # defined later
             }
         }
+        components['Route'][schema_type] = [
+            {"$ref": "#/components/schemas/MountainHiking"},
+            {"$ref": "#/components/schemas/AlpineClimbing"},
+        ]
 
         # Add the compoments in a minimalis schema
         schema = {
@@ -285,13 +291,23 @@ def test_oneof_discriminator(self):
             }
         }
 
-        # 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
+        if schema_type != 'allOf':
+            # 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
+
+        if schema_type == 'anyOf':
+            # 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",
@@ -301,31 +317,43 @@ def test_oneof_discriminator(self):
             }
         }
         schema['components']['schemas']['Route']['discriminator'] = discriminator
+
+        # Optional: check we return useful result when the schema is wrong
         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
-
+        # Check we get a non-generic, somehow usable, error message when a discriminated schema is failing
         with pytest.raises(ValidationError, match="'bad_string' is not of type integer"):
             validator.validate({
                 "discipline": "mountain_hiking",
                 "length": "bad_string"
             })
             assert False
 
+        # Check explicit MountainHiking resolution
         validator.validate({
                 "discipline": "mountain_hiking",
                 "length": 10
             })
 
+        # Check implicit MountainHiking resolution
+        validator.validate({
+            "discipline": "MountainHiking",
+                "length": 10
+            })
+
+        # Check non resolvable implicit schema
+        with pytest.raises(ValidationError, match="reference '#/components/schemas/other' could not be resolved"):
+            result = validator.validate({
+                "discipline": "other"
+            })
+            assert False
+
+
 
 class TestOAS31ValidatorValidate(object):
     @pytest.mark.parametrize('schema_type', [