def _validate(self):
# Just as ResolvingParser, the magic happens in this function.
# It's this one that processes and saves self.specification.
translator = RefTranslator(self.specification, self.url)
translator.translate_references()
self.specification = translator.specs
BaseParser._validate(self)
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 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 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 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_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 petstore_parser():
return BaseParser('tests/petstore.yaml')
def test_openapi_spec_validator_validate_failure():
with pytest.raises(ValidationError):
parser = BaseParser('tests/missing_reference.yaml',
backend='openapi-spec-validator')
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_filename_or_spec():
with pytest.raises(AssertionError):
BaseParser("", "")
def test_version_fail():
with pytest.raises(ValidationError):
BaseParser(spec_string="""---
openapi: 4.0.0""")
def test_parse_fail():
with pytest.raises(ValidationError):
BaseParser(spec_string="""---
invalid 'a'sda YAML""")
def test_load_fail():
from prance.util.url import ResolutionError
with pytest.raises(ResolutionError):
BaseParser("tests/specs/missing.yaml")
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 petstore_parser():
return BaseParser("tests/specs/petstore.yaml")
def routes():
parser = BaseParser('./datanator_rest_api/spec/DatanatorAPI.yaml')
specification = parser.specification
paths = specification['paths']
return list(paths.items())
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_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)
