def test_openapi_spec_validator_issue_5_integer_keys(): # Must fail in implicit strict mode. with pytest.raises(ValidationError): BaseParser('tests/specs/issue_5.yaml', backend = 'openapi-spec-validator') # Must fail in explicit strict mode. with pytest.raises(ValidationError): BaseParser('tests/specs/issue_5.yaml', backend = 'openapi-spec-validator', strict = True) # Must succeed in non-strict/lenient mode parser = BaseParser('tests/specs/issue_5.yaml', backend = 'openapi-spec-validator', strict = False) assert '200' in parser.specification['paths']['/test']['post']['responses']
def parse_raw(self) -> None: for source in self.iter_source: if self.validation: from prance import BaseParser base_parser = BaseParser(spec_string=source.text, backend='openapi-spec-validator') specification: Dict[str, Any] = base_parser.specification else: specification = load_yaml(source.text) self.raw_obj = specification schemas: Dict[Any, Any] = specification.get('components', {}).get('schemas', {}) if isinstance(self.source, ParseResult): path_parts: List[str] = self.get_url_path_parts(self.source) else: path_parts = list(source.path.parts) with self.model_resolver.current_root_context(path_parts): for obj_name, raw_obj in schemas.items( ): # type: str, Dict[Any, Any] self.parse_raw_obj( obj_name, raw_obj, [*path_parts, '#/components', 'schemas', obj_name], )
def __init__( self, data_model_type: Type[DataModel], data_model_root_type: Type[DataModel], data_model_field_type: Type[DataModelField] = DataModelField, filename: Optional[str] = None, base_class: Optional[str] = None, target_python_version: PythonVersion = PythonVersion.PY_37, text: Optional[str] = None, result: Optional[List[DataModel]] = None, dump_resolve_reference_action: Optional[Callable[[List[str]], str]] = None, ): self.base_parser = (BaseParser( filename, text, backend='openapi-spec-validator') if filename or text else None) super().__init__( data_model_type, data_model_root_type, data_model_field_type, filename, base_class, target_python_version, text, result, dump_resolve_reference_action, )
def __init__( self, data_model_type: Type[DataModel], data_model_root_type: Type[DataModel], data_model_field_type: Type[DataModelField] = DataModelField, filename: Optional[str] = None, base_class: Optional[str] = None, custom_template_dir: Optional[str] = None, extra_template_data: Optional[DefaultDict[str, Dict]] = None, target_python_version: PythonVersion = PythonVersion.PY_37, text: Optional[str] = None, result: Optional[List[DataModel]] = None, dump_resolve_reference_action: Optional[Callable[[List[str]], str]] = None, ): self.base_parser = (BaseParser( filename, text, backend='openapi-spec-validator') if filename or text else None) self.custom_template_dir = ( Path(custom_template_dir).expanduser().resolve() if custom_template_dir is not None else None) self.extra_template_data: DefaultDict[ str, Any] = extra_template_data or defaultdict(dict) super().__init__( data_model_type, data_model_root_type, data_model_field_type, filename, base_class, target_python_version, text, result, dump_resolve_reference_action, )
def parse_raw(self) -> None: base_parser = BaseParser(spec_string=self.text, backend='openapi-spec-validator') for obj_name, raw_obj in base_parser.specification['components'][ 'schemas'].items(): # type: str, Dict self.parse_raw_obj(obj_name, raw_obj)
def test_convert_parser_validated(): from prance import BaseParser parser = BaseParser('tests/specs/petstore.yaml', backend = 'openapi-spec-validator') # Conversion should work: it's the right backend, and it validates. converted = convert.convert_spec(parser) assert isinstance(converted, BaseParser) assert converted.version_parsed[0] == 3
def test_openapi_spec_validator_issue_20_spec_version_handling(): # The spec is OpenAPI 3, but broken. Need to set 'strict' to False to stringify keys with pytest.raises(ValidationError): parser = BaseParser('tests/specs/issue_20.yaml', backend = 'openapi-spec-validator', strict = False) # Lazy parsing should let us validate what's happening parser = BaseParser('tests/specs/issue_20.yaml', backend = 'openapi-spec-validator', strict = False, lazy = True) assert not parser.valid assert parser.version_parsed == () with pytest.raises(ValidationError): parser.parse() # After parsing, the specs are not valid, but the correct version is # detected. assert not parser.valid assert parser.version_parsed == (3, 0, 0)
def parse_raw(self) -> None: base_parser = BaseParser(spec_string=self.text, backend="openapi-spec-validator", strict=False) for obj_name, raw_obj in base_parser.specification["components"][ "schemas"].items(): self.parse_raw_obj(obj_name, raw_obj)
def parse(cls, path): try: parser = BaseParser(path) except Exception as e: raise e spec = Specification(parser.specification) return spec
def test_convert_parser_lazy_swagger_backend(): from prance import BaseParser, ResolvingParser, ValidationError parser = BaseParser('tests/specs/petstore.yaml') # Conversion should fail with the default backend. with pytest.raises(ValidationError): converted = convert.convert_spec(parser) # However, with the lazy flag it should work. converted = convert.convert_spec(parser, lazy=True) assert isinstance(converted, BaseParser) # Passing a ResolvingParser class should also work. converted = convert.convert_spec(parser, ResolvingParser, lazy=True) assert isinstance(converted, ResolvingParser)
def parse_raw(self) -> None: if self.validation: from prance import BaseParser base_parser = BaseParser(spec_string=self.text, backend='openapi-spec-validator') components: Dict[str, Any] = base_parser.specification['components'] else: components = load_json_or_yaml( self.text)['components'] # type: ignore for obj_name, raw_obj in components['schemas'].items( ): # type: str, Dict self.parse_raw_obj(obj_name, raw_obj)
def parse_raw(self) -> None: for source in self.iter_source: if self.validation: from prance import BaseParser base_parser = BaseParser( spec_string=source.text, backend='openapi-spec-validator' ) components: Dict[str, Any] = base_parser.specification['components'] else: components = yaml.safe_load(source.text)['components'] self.model_resolver.set_current_root(list(source.path.parts)) for obj_name, raw_obj in components[ 'schemas' ].items(): # type: str, Dict[Any, Any] self.parse_raw_obj( obj_name, raw_obj, ['components', 'schemas', obj_name] )
def parse_raw(self) -> None: for source in self.iter_source: if self.validation: from prance import BaseParser base_parser = BaseParser(spec_string=source.text, backend='openapi-spec-validator') specification: Dict[str, Any] = base_parser.specification else: specification = yaml.safe_load(source.text) self.raw_obj = specification schemas: Optional[Dict[Any, Any]] = specification.get('components', {}).get('schemas') if not schemas: # pragma: no cover continue self.model_resolver.set_current_root(list(source.path.parts)) for obj_name, raw_obj in schemas.items( ): # type: str, Dict[Any, Any] self.parse_raw_obj(obj_name, raw_obj, ['#/components', 'schemas', obj_name])
def test_openapi_spec_validator_validate_failure(): with pytest.raises(ValidationError): parser = BaseParser('tests/missing_reference.yaml', backend='openapi-spec-validator')
def petstore_parser(): return BaseParser('tests/petstore.yaml')
def test_filename_or_spec(): with pytest.raises(AssertionError): BaseParser("", "")
def test_load_and_parse_lazy(): parser = BaseParser("tests/specs/petstore.yaml", lazy=True) assert parser.specification is None, "Should not have specs yet!" parser.parse() assert parser.specification, "No specs loaded!"
def test_parse_fail(): with pytest.raises(ValidationError): BaseParser(spec_string="""--- invalid 'a'sda YAML""")
def test_version_fail(): with pytest.raises(ValidationError): BaseParser(spec_string="""--- openapi: 4.0.0""")
def petstore_parser_from_string(): yaml = None with open("tests/specs/petstore.yaml", "rb") as f: x = f.read() yaml = x.decode("utf8") return BaseParser(spec_string=yaml)
def test_load_fail(): from prance.util.url import ResolutionError with pytest.raises(ResolutionError): BaseParser("tests/specs/missing.yaml")
def routes(): parser = BaseParser('./datanator_rest_api/spec/DatanatorAPI.yaml') specification = parser.specification paths = specification['paths'] return list(paths.items())
def petstore_parser(): return BaseParser("tests/specs/petstore.yaml")
def test_load_and_parse_lazy(): parser = BaseParser('tests/specs/petstore.yaml', lazy=True) assert parser.specification is None, 'Should not have specs yet!' parser.parse() assert parser.specification, 'No specs loaded!'
def test_load_fail(): with pytest.raises(FileNotFoundError): BaseParser('tests/specs/missing.yaml')
def test_swagger_spec_validator_validate_success(): parser = BaseParser('tests/petstore.yaml', backend='swagger-spec-validator')
def test_openapi_spec_validator_validate_success(): parser = BaseParser('tests/petstore.yaml', backend='openapi-spec-validator')
def test_bad_backend(): with pytest.raises(ValueError): BaseParser('tests/petstore.yaml', backend='does_not_exist')
{'default': DataType(type_hint='str'), 'byte': DataType(type_hint='str'), 'binary': DataType(type_hint='bytes') }, # 'data': date,}, #As defined by full-date - RFC3339 'boolean': {'default': DataType(type_hint='bool')} } def get_data_type(_type, format=None) -> DataType: _format: str = format or 'default' return data_types[_type][_format] resolving_parser = ResolvingParser('api.yaml', backend='openapi-spec-validator') base_parser = BaseParser('api.yaml', backend='openapi-spec-validator') class Parser: def __init__(self, data_model_type: Type[DataModel], data_model_field_type: Type[DataModelField]): self.data_model_type: Type[DataModel] = data_model_type self.data_model_field_type: Type[DataModelField] = data_model_field_type self.models = [] def parse_object(self, name: str, obj: Dict): requires: Set[str] = set(obj.get('required', [])) d_list: List[DataModelField] = [] for field_name, filed in obj['properties'].items(): # object d_list.append(self.data_model_field_type( name=field_name, type_hint=get_data_type(filed["type"],
def petstore_parser_from_string(): yaml = None with open('tests/specs/petstore.yaml', 'rb') as f: x = f.read() yaml = x.decode('utf8') return BaseParser(spec_string=yaml)