Adds json schema test cases for 11 added keywords (#241)

* Adds const components and examples

* Excludes components that throw errors in swagger-parser

* Excludes more test cases

* Excludes 2 more test cases

* Samples regen

* removes error files

* Removes failing test cases

* Samples regen

* Adds contains samples in test spec

* Adds contains test cases

* Samples regen

* Adds dependentRequired python tests

* Removes test that does not pass

* Adds test for dependentSchemas

* Adds maxContains tests

* Adds minContains test cases

* Turns on patternProperties tests

* Moves additionalProperties evaluation to the end so keywords can be validated first

* patternProperties tests added, turns off broken addProps test

* Adds prefixItems tests

* Adds propertyNames tests

* Adds unevaluatedItems test cases to test spec

* Excludes some of the unevaluatedItems tests begause of swagger parser bugs

* Adds unevaluatedItems tests

* Skips 6 test cases

* Disables 6 more test schemas

* Disables 5 more test cases

* Disables 4 test cases

* Disables 5 more tests

* Disables 5 more broken tests

* Adds unevaluatedProperties tests

* All tests passing

* Turns on tests that were turned off because of 303 not supporting type arrays

* Samples regen

Author: spacether

README.md

@@ -132,7 +132,7 @@ mvn -Pstatic-analysis clean install
 
 #### OpenAPI JSON Schema Generator CLI Docker Image
 
-The OpenAPI JSON Schema Generator image acts as a standalone executable. It can be used as an alternative to installing via homebrew, or for developers who are unable to install Java or upgrade the installed version.
+The docker image acts as a standalone executable. It can be used as an alternative to installing via homebrew, or for developers who are unable to install Java or upgrade the installed version.
 
 To generate code with this image, you'll need to mount a local location as a volume.
 

samples/client/3_0_3_unit_test/python/src/unit_test_api/components/schema/additionalproperties_should_not_look_in_applicators.py

@@ -145,8 +145,8 @@ class AdditionalpropertiesShouldNotLookInApplicators(
     Do not edit the class manually.
     """
     # any type
-    additional_properties: typing.Type[AdditionalProperties] = dataclasses.field(default_factory=lambda: AdditionalProperties) # type: ignore
     all_of: AllOf = dataclasses.field(default_factory=lambda: schemas.tuple_to_instance(AllOf)) # type: ignore
+    additional_properties: typing.Type[AdditionalProperties] = dataclasses.field(default_factory=lambda: AdditionalProperties) # type: ignore
     type_to_output_cls: typing.Mapping[
         typing.Type,
         typing.Type

samples/client/3_0_3_unit_test/python/src/unit_test_api/schemas/validation.py

@@ -99,6 +99,14 @@ def _validate(
                 validation_metadata,
                 path_to_schemas
             )
+        validated_pattern_properties: typing.Optional[PathToSchemasType] = None
+        if 'pattern_properties' in vars(cls_schema):
+             validated_pattern_properties = _get_validated_pattern_properties(
+                 arg,
+                 vars(cls_schema)['pattern_properties'],
+                 cls,
+                 validation_metadata
+             )
         prefix_items_length = 0
         if 'prefix_items' in vars(cls_schema):
             prefix_items_length = len(vars(cls_schema)['prefix_items'])
@@ -113,6 +121,8 @@ def _validate(
             elif keyword in {'types'}:
                 format: typing.Optional[str] = vars(cls_schema).get('format', None)
                 used_val = (val, format)
+            elif keyword in {'pattern_properties', 'additional_properties'}:
+                used_val = (val, validated_pattern_properties)
             else:
                 used_val = val
             validator = json_schema_keyword_to_validator[keyword]
@@ -737,19 +747,25 @@ def validate_properties(
 
 def validate_additional_properties(
     arg: typing.Any,
-    additional_properties_cls: typing.Type[SchemaValidator],
+    additional_properties_cls_val_pprops: typing.Tuple[
+        typing.Type[SchemaValidator],
+        typing.Optional[PathToSchemasType]
+    ],
     cls: typing.Type,
     validation_metadata: ValidationMetadata,
 ) -> typing.Optional[PathToSchemasType]:
     if not isinstance(arg, immutabledict):
         return None
-    schema = _get_class(additional_properties_cls)
+    schema = _get_class(additional_properties_cls_val_pprops[0])
     path_to_schemas: PathToSchemasType = {}
     cls_schema = cls()
     properties = cls_schema.properties if hasattr(cls_schema, 'properties') else {}
     present_additional_properties = {k: v for k, v, in arg.items() if k not in properties}
+    validated_pattern_properties = additional_properties_cls_val_pprops[1]
     for property_name, value in present_additional_properties.items():
         path_to_item = validation_metadata.path_to_item + (property_name,)
+        if validated_pattern_properties and path_to_item in validated_pattern_properties:
+            continue
         arg_validation_metadata = ValidationMetadata(
             path_to_item=path_to_item,
             configuration=validation_metadata.configuration,
@@ -1148,7 +1164,7 @@ def validate_property_names(
     return None
 
 
-def validate_pattern_properties(
+def _get_validated_pattern_properties(
     arg: typing.Any,
     pattern_properties: typing.Mapping[PatternInfo, typing.Type[SchemaValidator]],
     cls: typing.Type,
@@ -1178,6 +1194,21 @@ def validate_pattern_properties(
     return path_to_schemas
 
 
+def validate_pattern_properties(
+    arg: typing.Any,
+    pattern_properties_validation_results: typing.Tuple[
+        typing.Mapping[PatternInfo, typing.Type[SchemaValidator]],
+        typing.Optional[PathToSchemasType]
+    ],
+    cls: typing.Type,
+    validation_metadata: ValidationMetadata,
+) -> typing.Optional[PathToSchemasType]:
+    if not isinstance(arg, immutabledict):
+        return None
+    validation_results = pattern_properties_validation_results[1]
+    return validation_results
+
+
 def validate_prefix_items(
     arg: typing.Any,
     prefix_items: typing.Tuple[typing.Type[SchemaValidator], ...],

samples/client/3_1_0_json_schema/python/src/json_schema_api/schemas/validation.py

@@ -99,6 +99,14 @@ def _validate(
                 validation_metadata,
                 path_to_schemas
             )
+        validated_pattern_properties: typing.Optional[PathToSchemasType] = None
+        if 'pattern_properties' in vars(cls_schema):
+             validated_pattern_properties = _get_validated_pattern_properties(
+                 arg,
+                 vars(cls_schema)['pattern_properties'],
+                 cls,
+                 validation_metadata
+             )
         prefix_items_length = 0
         if 'prefix_items' in vars(cls_schema):
             prefix_items_length = len(vars(cls_schema)['prefix_items'])
@@ -113,6 +121,8 @@ def _validate(
             elif keyword in {'types'}:
                 format: typing.Optional[str] = vars(cls_schema).get('format', None)
                 used_val = (val, format)
+            elif keyword in {'pattern_properties', 'additional_properties'}:
+                used_val = (val, validated_pattern_properties)
             else:
                 used_val = val
             validator = json_schema_keyword_to_validator[keyword]
@@ -737,19 +747,25 @@ def validate_properties(
 
 def validate_additional_properties(
     arg: typing.Any,
-    additional_properties_cls: typing.Type[SchemaValidator],
+    additional_properties_cls_val_pprops: typing.Tuple[
+        typing.Type[SchemaValidator],
+        typing.Optional[PathToSchemasType]
+    ],
     cls: typing.Type,
     validation_metadata: ValidationMetadata,
 ) -> typing.Optional[PathToSchemasType]:
     if not isinstance(arg, immutabledict):
         return None
-    schema = _get_class(additional_properties_cls)
+    schema = _get_class(additional_properties_cls_val_pprops[0])
     path_to_schemas: PathToSchemasType = {}
     cls_schema = cls()
     properties = cls_schema.properties if hasattr(cls_schema, 'properties') else {}
     present_additional_properties = {k: v for k, v, in arg.items() if k not in properties}
+    validated_pattern_properties = additional_properties_cls_val_pprops[1]
     for property_name, value in present_additional_properties.items():
         path_to_item = validation_metadata.path_to_item + (property_name,)
+        if validated_pattern_properties and path_to_item in validated_pattern_properties:
+            continue
         arg_validation_metadata = ValidationMetadata(
             path_to_item=path_to_item,
             configuration=validation_metadata.configuration,
@@ -1148,7 +1164,7 @@ def validate_property_names(
     return None
 
 
-def validate_pattern_properties(
+def _get_validated_pattern_properties(
     arg: typing.Any,
     pattern_properties: typing.Mapping[PatternInfo, typing.Type[SchemaValidator]],
     cls: typing.Type,
@@ -1178,6 +1194,21 @@ def validate_pattern_properties(
     return path_to_schemas
 
 
+def validate_pattern_properties(
+    arg: typing.Any,
+    pattern_properties_validation_results: typing.Tuple[
+        typing.Mapping[PatternInfo, typing.Type[SchemaValidator]],
+        typing.Optional[PathToSchemasType]
+    ],
+    cls: typing.Type,
+    validation_metadata: ValidationMetadata,
+) -> typing.Optional[PathToSchemasType]:
+    if not isinstance(arg, immutabledict):
+        return None
+    validation_results = pattern_properties_validation_results[1]
+    return validation_results
+
+
 def validate_prefix_items(
     arg: typing.Any,
     prefix_items: typing.Tuple[typing.Type[SchemaValidator], ...],