Add to oneOf, anyOf, items discriminator with mapping supports

src/Schema/Keywords/AnyOf.php

@@ -54,6 +54,40 @@ public function validate($data, array $anyOf): void
 
         $innerExceptions = [];
 
+        if (isset($this->parentSchema->discriminator->mapping, $data[$this->parentSchema->discriminator->propertyName])) {
+            $schemaIndex = array_search(
+                $data[$this->parentSchema->discriminator->propertyName],
+                array_keys($this->parentSchema->discriminator->mapping)
+            );
+
+            if ($schemaIndex === false) {
+                throw NotEnoughValidSchemas::fromKeywordWithInnerExceptions(
+                    'anyOf',
+                    $data,
+                    $innerExceptions,
+                    'Data must match at least one schema'
+                );
+            }
+
+            if (isset($anyOf[$schemaIndex])) {
+                try {
+                    $schemaItem = $anyOf[$schemaIndex];
+
+                    $schemaValidator = new SchemaValidator($this->validationDataType);
+                    $schemaValidator->validate($data, $schemaItem, $this->dataBreadCrumb);
+
+                    return;
+                } catch (SchemaMismatch $e) {
+                    throw NotEnoughValidSchemas::fromKeywordWithInnerExceptions(
+                        'anyOf',
+                        $data,
+                        [$e],
+                        'Data mapped by Discriminator is not match'
+                    );
+                }
+            }
+        }
+
         foreach ($anyOf as $schema) {
             $schemaValidator = new SchemaValidator($this->validationDataType);
             try {

src/Schema/Keywords/Items.php

@@ -7,6 +7,7 @@
 use cebe\openapi\spec\Schema as CebeSchema;
 use League\OpenAPIValidation\Schema\BreadCrumb;
 use League\OpenAPIValidation\Schema\Exception\InvalidSchema;
+use League\OpenAPIValidation\Schema\Exception\KeywordMismatch;
 use League\OpenAPIValidation\Schema\Exception\SchemaMismatch;
 use League\OpenAPIValidation\Schema\SchemaValidator;
 use Respect\Validation\Validator;
@@ -52,6 +53,27 @@ public function validate($data, CebeSchema $itemsSchema): void
 
         $schemaValidator = new SchemaValidator($this->validationDataType);
         foreach ($data as $dataIndex => $dataItem) {
+            if (isset($itemsSchema->discriminator->mapping, $dataItem[$itemsSchema->discriminator->propertyName])) {
+                $discriminatorValue = $dataItem[$itemsSchema->discriminator->propertyName];
+                $schemaIndex = array_search($discriminatorValue, array_keys($itemsSchema->discriminator->mapping));
+
+                if ($schemaIndex === false) {
+                    throw KeywordMismatch::fromKeyword($itemsSchema->discriminator->propertyName, $data, 'Discriminator has not mapped in schema');
+                }
+
+                if (isset($itemsSchema->anyOf[$schemaIndex])) {
+                    $mappedSchemaByDiscriminator = $itemsSchema->anyOf[$schemaIndex];
+                    $schemaValidator->validate($dataItem, $mappedSchemaByDiscriminator, $this->dataBreadCrumb->addCrumb($dataIndex));
+                    continue;
+                }
+
+                if (isset($itemsSchema->oneOf[$schemaIndex])) {
+                    $mappedSchemaByDiscriminator = $itemsSchema->oneOf[$schemaIndex];
+                    $schemaValidator->validate($dataItem, $mappedSchemaByDiscriminator, $this->dataBreadCrumb->addCrumb($dataIndex));
+                    continue;
+                }
+            }
+
             $schemaValidator->validate($dataItem, $itemsSchema, $this->dataBreadCrumb->addCrumb($dataIndex));
         }
     }

src/Schema/Keywords/OneOf.php

@@ -61,6 +61,40 @@ public function validate($data, array $oneOf): void
         $innerExceptions = [];
         $validSchemas    = [];
 
+        if (isset($this->parentSchema->discriminator->mapping, $data[$this->parentSchema->discriminator->propertyName])) {
+            $schemaIndex = array_search(
+                $data[$this->parentSchema->discriminator->propertyName],
+                array_keys($this->parentSchema->discriminator->mapping)
+            );
+
+            if ($schemaIndex === false) {
+                throw NotEnoughValidSchemas::fromKeywordWithInnerExceptions(
+                    'oneOf',
+                    $data,
+                    $innerExceptions,
+                    'Data must match at least one schema'
+                );
+            }
+
+            if (isset($oneOf[$schemaIndex])) {
+                try {
+                    $schemaItem = $oneOf[$schemaIndex];
+
+                    $schemaValidator = new SchemaValidator($this->validationDataType);
+                    $schemaValidator->validate($data, $schemaItem, $this->dataBreadCrumb);
+
+                    return;
+                } catch (SchemaMismatch $e) {
+                    throw NotEnoughValidSchemas::fromKeywordWithInnerExceptions(
+                        'oneOf',
+                        $data,
+                        [$e],
+                        'Data mapped by Discriminator is not match'
+                    );
+                }
+            }
+        }
+
         foreach ($oneOf as $schema) {
             try {
                 $schemaValidator->validate($data, $schema, $this->dataBreadCrumb);

tests/Schema/Keywords/AnyOfTest.php

@@ -65,4 +65,88 @@ public function testItValidatesAnyOfRed(): void
             $this->assertEquals('anyOf', $e->keyword());
         }
     }
+
+    public function testItValidatesAnyOfGreenWithDiscriminator(): void
+    {
+        $spec = <<<SPEC
+schema:
+  discriminator: 
+    propertyName: type
+    mapping:
+      NAME: 0
+      TIME: 1
+  anyOf:
+    - type: object
+      properties:
+        type: 
+          type: string
+        name:
+          type: string
+      required:
+      - type
+      - name
+    - type: object
+      properties:
+        type: 
+          type: string
+        age:
+          type: integer
+      required:
+      - type
+      - age
+SPEC;
+
+        $schema = $this->loadRawSchema($spec);
+        $data   = [
+            'type' => 'NAME',
+            'name' => 'John',
+        ];
+
+        (new SchemaValidator())->validate($data, $schema);
+        $this->addToAssertionCount(1);
+    }
+
+    public function testItValidatesAnyOfRedWithDiscriminator(): void
+    {
+        $spec = <<<SPEC
+schema:
+  discriminator: 
+    propertyName: type
+    mapping:
+      NAME: 0
+      TIME: 1
+  anyOf:
+    - type: object
+      properties:
+        type: 
+          type: string
+        name:
+          type: string
+      required:
+      - type
+      - name
+    - type: object
+      properties:
+        type: 
+          type: string
+        age:
+          type: integer
+      required:
+      - type
+      - age
+SPEC;
+
+        $schema = $this->loadRawSchema($spec);
+        $data   = [
+            'type' => 'TIME',
+            'age' => 'today',
+        ];
+
+        try {
+            (new SchemaValidator())->validate($data, $schema);
+            $this->fail('Validation did not expected to pass');
+        } catch (KeywordMismatch $e) {
+            $this->assertEquals('anyOf', $e->keyword());
+        }
+    }
 }

tests/Schema/Keywords/ItemsTest.php

@@ -80,4 +80,52 @@ public function testItValidatesItemsNestedRed(): void
 
         (new SchemaValidator())->validate($data, $schema);
     }
+
+    public function testItValidatesItemsGreenWithDiscriminator(): void
+    {
+        $spec = <<<SPEC
+schema:
+  type: array
+  items:
+    discriminator: 
+      propertyName: type
+      mapping:
+        NAME: 0
+        TIME: 1
+    anyOf:
+      - type: object
+        properties:
+          type: 
+            type: string
+          name:
+            type: string
+        required:
+        - type
+        - name
+      - type: object
+        properties:
+          type: 
+            type: string
+          age:
+            type: integer
+        required:
+        - type
+        - age  
+SPEC;
+
+        $schema = $this->loadRawSchema($spec);
+        $data   = [
+            [
+                'type' => 'NAME',
+                'name' => 'John',
+            ],
+            [
+                'type' => 'TIME',
+                'age' => 22,
+            ],
+        ];
+
+        (new SchemaValidator())->validate($data, $schema);
+        $this->addToAssertionCount(2);
+    }
 }

tests/Schema/Keywords/OneOfTest.php

@@ -85,4 +85,88 @@ public function testItValidatesOneOfNoMatchesRed(): void
             $this->assertEquals('oneOf', $e->keyword());
         }
     }
+
+    public function testItValidatesOneOfGreenWithDiscriminator(): void
+    {
+        $spec = <<<SPEC
+schema:
+  discriminator: 
+    propertyName: type
+    mapping:
+      NAME: 0
+      TIME: 1
+  oneOf:
+    - type: object
+      properties:
+        type: 
+          type: string
+        name:
+          type: string
+      required:
+      - type
+      - name
+    - type: object
+      properties:
+        type: 
+          type: string
+        age:
+          type: integer
+      required:
+      - type
+      - age
+SPEC;
+
+        $schema = $this->loadRawSchema($spec);
+        $data   = [
+            'type' => 'NAME',
+            'name' => 'John',
+        ];
+
+        (new SchemaValidator())->validate($data, $schema);
+        $this->addToAssertionCount(1);
+    }
+
+    public function testItValidatesOneOfRedWithDiscriminator(): void
+    {
+        $spec = <<<SPEC
+schema:
+  discriminator: 
+    propertyName: type
+    mapping:
+      NAME: 0
+      TIME: 1
+  oneOf:
+    - type: object
+      properties:
+        type: 
+          type: string
+        name:
+          type: string
+      required:
+      - type
+      - name
+    - type: object
+      properties:
+        type: 
+          type: string
+        age:
+          type: integer
+      required:
+      - type
+      - age
+SPEC;
+
+        $schema = $this->loadRawSchema($spec);
+        $data   = [
+            'type' => 'TIME',
+            'age' => 'today',
+        ];
+
+        try {
+            (new SchemaValidator())->validate($data, $schema);
+            $this->fail('Validation did not expected to pass');
+        } catch (KeywordMismatch $e) {
+            $this->assertEquals('oneOf', $e->keyword());
+        }
+    }
 }