def test_get_pet_unauthorized(self, validator):
request = MockRequest(
self.host_url,
'get',
'/v1/pets/1',
path_pattern='/v1/pets/{petId}',
view_args={'petId': '1'},
)
result = validator.validate(request)
assert result.errors == [
InvalidSecurity(),
]
assert result.body is None
assert result.parameters == RequestParameters()
assert result.security is None
def test_get_pets(self, validator):
request = MockRequest(
self.host_url, 'get', '/v1/pets',
path_pattern='/v1/pets', args={'limit': '10'},
)
result = validator.validate(request)
assert result.errors == []
assert result.body is None
assert result.parameters == RequestParameters(
query={
'limit': 10,
'page': 1,
'search': '',
},
)
def test_get_file_in_combine_archive_error_handling(self):
endpoint = '/combine/file?url={}&location={}'.format(
urllib.parse.quote('x'),
urllib.parse.quote('Figure1.jpg'),
)
with app.app.app.test_client() as client:
response = client.get(endpoint)
self.assertEqual(response.status_code, 400, response.json)
self.assertTrue(response.json['title'].startswith(
'COMBINE/OMEX archive could not be loaded'))
if hasattr(self, "response_validator"):
request = OpenAPIRequest(
full_url_pattern='https://127.0.0.1/combine/file',
method='get',
mimetype=None,
parameters=RequestParameters(url='x', location='Figure1.jpg'),
)
response = OpenAPIResponse(data=json.dumps(response.json),
status_code=400,
mimetype='image/jpeg')
result = self.response_validator.validate(request, response)
result.raise_for_errors()
archive_filename = os.path.join(
self.FIXTURES_DIR,
'Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.omex'
)
with open(archive_filename, 'rb') as file:
archive_url_content = file.read()
archive_url = 'https://archive.combine.org'
resolve_archive_response = mock.Mock(
raise_for_status=lambda: None,
content=archive_url_content,
)
endpoint = '/combine/file?url={}&location={}'.format(
urllib.parse.quote(archive_url),
urllib.parse.quote('undefined'),
)
with mock.patch('requests.get', return_value=resolve_archive_response):
with app.app.app.test_client() as client:
response = client.get(endpoint)
self.assertEqual(response.status_code, 400, response.json)
self.assertIn('not a valid location', response.json['title'])
def test_post_tags_additional_properties(self, spec, response_validator):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/tags'
pet_name = 'Dog'
data_json = {
'name': pet_name,
}
data = json.dumps(data_json)
request = MockRequest(
host_url,
'POST',
'/tags',
path_pattern=path_pattern,
data=data,
)
parameters = validate_parameters(spec, request)
body = validate_body(spec, request)
assert parameters == RequestParameters()
assert isinstance(body, BaseModel)
assert body.name == pet_name
code = 400
message = 'Bad request'
rootCause = 'Tag already exist'
additionalinfo = 'Tag Dog already exist'
data_json = {
'code': code,
'message': message,
'rootCause': rootCause,
'additionalinfo': additionalinfo,
}
data = json.dumps(data_json)
response = MockResponse(data, status_code=404)
response_result = response_validator.validate(request, response)
assert response_result.errors == []
assert isinstance(response_result.data, BaseModel)
assert response_result.data.code == code
assert response_result.data.message == message
assert response_result.data.rootCause == rootCause
assert response_result.data.additionalinfo == additionalinfo
def test_get_pet(self, spec, response_validator):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/pets/{petId}'
view_args = {
'petId': '1',
}
request = MockRequest(
host_url,
'GET',
'/pets/1',
path_pattern=path_pattern,
view_args=view_args,
)
parameters = validate_parameters(spec, request)
assert parameters == RequestParameters(path={
'petId': 1,
})
body = validate_body(spec, request)
assert body is None
data_id = 1
data_name = 'test'
data_json = {
'data': {
'id': data_id,
'name': data_name,
'ears': {
'healthy': True,
},
},
}
data = json.dumps(data_json)
response = MockResponse(data)
response_result = response_validator.validate(request, response)
assert response_result.errors == []
assert isinstance(response_result.data, BaseModel)
assert isinstance(response_result.data.data, BaseModel)
assert response_result.data.data.id == data_id
assert response_result.data.data.name == data_name
def test_get_pets_response(self, spec, response_validator):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/pets'
query_params = {
'limit': '20',
}
request = MockRequest(
host_url, 'GET', '/pets',
path_pattern=path_pattern, args=query_params,
)
parameters = validate_parameters(spec, request)
body = validate_body(spec, request)
assert parameters == RequestParameters(
query={
'limit': 20,
'page': 1,
'search': '',
}
)
assert body is None
data_json = {
'data': [
{
'id': 1,
'name': 'Cat',
'ears': {
'healthy': True,
},
}
],
}
data = json.dumps(data_json)
response = MockResponse(data)
response_result = response_validator.validate(request, response)
assert response_result.errors == []
assert isinstance(response_result.data, BaseModel)
assert len(response_result.data.data) == 1
assert response_result.data.data[0].id == 1
assert response_result.data.data[0].name == 'Cat'
def test_request_override_param(self, spec_dict):
# override path parameter on operation
spec_dict["paths"]["/resource"]["get"]["parameters"] = [{
# full valid parameter object required
"name": "resId",
"in": "query",
"required": False,
"schema": {
"type": "integer",
},
}]
validator = RequestValidator(create_spec(spec_dict))
request = MockRequest('http://example.com', 'get', '/resource')
result = validator.validate(request)
assert len(result.errors) == 0
assert result.body is None
assert result.parameters == RequestParameters()
def test_get_pets(self, spec, response_validator):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/pets'
query_params = {
'limit': '20',
}
request = MockRequest(
host_url,
'GET',
'/pets',
path_pattern=path_pattern,
args=query_params,
)
with pytest.warns(DeprecationWarning):
parameters = spec_validate_parameters(spec, request)
body = spec_validate_body(spec, request)
assert parameters == RequestParameters(query={
'limit': 20,
'page': 1,
'search': '',
})
assert body is None
data_json = {
'data': [],
}
data = json.dumps(data_json)
headers = {
'Content-Type': 'application/json',
'x-next': 'next-url',
}
response = MockResponse(data, headers=headers)
response_result = response_validator.validate(request, response)
assert response_result.errors == []
assert isinstance(response_result.data, BaseModel)
assert response_result.data.data == []
assert response_result.headers == {
'x-next': 'next-url',
}
def test_get_metadata_for_combine_archive_error_handling(self):
endpoint = '/combine/metadata/biosimulations'
data = MultiDict([
('omexMetadataFormat', OmexMetadataInputFormat.rdfxml.value),
])
with app.app.app.test_client() as client:
response = client.post(endpoint,
data=data,
content_type='multipart/form-data')
self.assertEqual(response.status_code, 400, response.json)
self.assertIn('must be used', response.json['title'])
if hasattr(self, "response_validator"):
request = OpenAPIRequest(
full_url_pattern=
'https://127.0.0.1/combine/metadata/biosimulations',
method='post',
body={
'url': 'x',
'omexMetadataFormat': OmexMetadataInputFormat.rdfxml.value,
},
mimetype=None,
parameters=RequestParameters(),
)
response = OpenAPIResponse(data=json.dumps(response.json),
status_code=400,
mimetype='application/json')
result = self.response_validator.validate(request, response)
result.raise_for_errors()
archive_filename = os.path.join(self.FIXTURES_DIR,
'invalid-metadata.omex')
fid = open(archive_filename, 'rb')
data = MultiDict([
('file', fid),
('omexMetadataFormat', OmexMetadataInputFormat.rdfxml.value),
])
with app.app.app.test_client() as client:
response = client.post(endpoint,
data=data,
content_type="multipart/form-data")
self.assertEqual(response.status_code, 400, response.json)
self.assertIn('is not valid', response.json['title'])
fid.close()
def test_post_cats_only_required_body(self, spec, spec_dict):
host_url = 'https://staging.gigantic-server.com/v1'
path_pattern = '/v1/pets'
pet_name = 'Cat'
pet_healthy = True
data_json = {
'name': pet_name,
'ears': {
'healthy': pet_healthy,
}
}
data = json.dumps(data_json)
headers = {
'api_key': self.api_key_encoded,
}
cookies = {
'user': '******',
}
request = MockRequest(
host_url, 'POST', '/pets',
path_pattern=path_pattern, data=data,
headers=headers, cookies=cookies,
)
parameters = validate_parameters(spec, request)
assert parameters == RequestParameters(
header={
'api_key': self.api_key,
},
cookie={
'user': 123,
},
)
body = validate_body(spec, request)
schemas = spec_dict['components']['schemas']
pet_model = schemas['PetCreate']['x-model']
assert body.__class__.__name__ == pet_model
assert body.name == pet_name
assert not hasattr(body, 'tag')
assert not hasattr(body, 'address')
def test_simple(self, request_factory, request):
request = request_factory('GET', '/', subdomain='www')
openapi_request = RequestsOpenAPIRequest(request)
path = {}
query = ImmutableMultiDict([])
headers = request.headers
cookies = {}
assert openapi_request.parameters == RequestParameters(
path=path,
query=query,
header=headers,
cookie=cookies,
)
assert openapi_request.method == request.method.lower()
assert openapi_request.full_url_pattern == 'http://localhost/'
assert openapi_request.body == request.data
assert openapi_request.mimetype == 'application/json'
def test_get_pet_not_found(self, spec, response_validator):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/pets/{petId}'
view_args = {
'petId': '1',
}
request = MockRequest(
host_url,
'GET',
'/pets/1',
path_pattern=path_pattern,
view_args=view_args,
)
parameters = validate_parameters(spec, request)
assert parameters == RequestParameters(path={
'petId': 1,
})
body = validate_body(spec, request)
assert body is None
code = 404
message = 'Not found'
rootCause = 'Pet not found'
data_json = {
'code': 404,
'message': message,
'rootCause': rootCause,
}
data = json.dumps(data_json)
response = MockResponse(data, status_code=404)
response_result = response_validator.validate(request, response)
assert response_result.errors == []
assert isinstance(response_result.data, BaseModel)
assert response_result.data.code == code
assert response_result.data.message == message
assert response_result.data.rootCause == rootCause
def _get_parameters(self, request, params):
errors = []
seen = set()
locations = {}
for param_name, param in params:
if (param_name, param.location.value) in seen:
# skip parameter already seen
# e.g. overriden path item paremeter on operation
continue
seen.add((param_name, param.location.value))
try:
raw_value = self._get_parameter_value(param, request)
except MissingRequiredParameter as exc:
errors.append(exc)
continue
except MissingParameter:
if not param.schema or not param.schema.has_default():
continue
casted = param.schema.default
else:
try:
deserialised = self._deserialise_parameter(
param, raw_value)
except DeserializeError as exc:
errors.append(exc)
continue
try:
casted = self._cast(param, deserialised)
except CastError as exc:
errors.append(exc)
continue
try:
unmarshalled = self._unmarshal(param, casted)
except (ValidateError, UnmarshalError) as exc:
errors.append(exc)
else:
locations.setdefault(param.location.value, {})
locations[param.location.value][param_name] = unmarshalled
return RequestParameters(**locations), errors
def test_simple(self, request_factory, request):
request = request_factory("GET", "/", subdomain="www")
openapi_request = RequestsOpenAPIRequest(request)
path = {}
query = ImmutableMultiDict([])
headers = Headers(dict(request.headers))
cookies = {}
prepared = request.prepare()
assert openapi_request.parameters == RequestParameters(
path=path,
query=query,
header=headers,
cookie=cookies,
)
assert openapi_request.method == request.method.lower()
assert openapi_request.full_url_pattern == "http://localhost/"
assert openapi_request.body == prepared.body
assert openapi_request.mimetype == "application/json"
def test_post_tags_empty_body(self, spec, spec_dict):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/tags'
data_json = {}
data = json.dumps(data_json)
request = MockRequest(
host_url,
'POST',
'/tags',
path_pattern=path_pattern,
data=data,
)
parameters = validate_parameters(spec, request)
assert parameters == RequestParameters()
with pytest.raises(InvalidSchemaValue):
validate_body(spec, request)
def test_request_override_param_uniqueness(self, spec_dict):
# add parameter on operation with same name as on path but
# different location
spec_dict["paths"]["/resource"]["get"]["parameters"] = [{
# full valid parameter object required
"name": "resId",
"in": "header",
"required": False,
"schema": {
"type": "integer",
},
}]
validator = RequestValidator(create_spec(spec_dict))
request = MockRequest('http://example.com', 'get', '/resource')
result = validator.validate(request)
assert len(result.errors) == 1
assert type(result.errors[0]) == MissingRequiredParameter
assert result.body is None
assert result.parameters == RequestParameters()
def test_post_tags_wrong_property_type(self, spec):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/tags'
tag_name = 123
data = json.dumps(tag_name)
request = MockRequest(
host_url,
'POST',
'/tags',
path_pattern=path_pattern,
data=data,
)
parameters = validate_parameters(spec, request)
assert parameters == RequestParameters()
with pytest.raises(InvalidSchemaValue):
validate_body(spec, request)
def test_url_rule(self, request_factory, request):
request = request_factory("GET", "/browse/12/", subdomain="kb")
openapi_request = FlaskOpenAPIRequest(request)
path = {"id": 12}
query = ImmutableMultiDict([])
headers = Headers(request.headers)
cookies = {}
assert openapi_request.parameters == RequestParameters(
path=path,
query=query,
header=headers,
cookie=cookies,
)
assert openapi_request.method == request.method.lower()
assert openapi_request.full_url_pattern == urljoin(
request.host_url, "/browse/{id}/")
assert openapi_request.body == request.data
assert openapi_request.mimetype == request.mimetype
def test_simple(self, request_factory, request):
request = request_factory('GET', '/', subdomain='www')
openapi_request = FlaskOpenAPIRequest(request)
path = {}
query = ImmutableMultiDict([])
headers = EnvironHeaders(request.environ)
cookies = {}
assert openapi_request.parameters == RequestParameters(
path=path,
query=query,
header=headers,
cookie=cookies,
)
assert openapi_request.method == request.method.lower()
assert openapi_request.full_url_pattern == \
urljoin(request.host_url, request.path)
assert openapi_request.body == request.data
assert openapi_request.mimetype == request.mimetype
def test_get_pets_webob(self, validator):
from webob.multidict import GetDict
request = MockRequest(
self.host_url,
'get',
'/v1/pets',
path_pattern='/v1/pets',
)
request.parameters.query = GetDict([('limit', '5'), ('ids', '1'),
('ids', '2')], {})
result = validator.validate(request)
assert result.errors == []
assert result.body is None
assert result.parameters == RequestParameters(query={
'limit': 5,
'page': 1,
'search': '',
'ids': [1, 2],
}, )
def test_url_rule(self, request_factory, request):
request = request_factory('GET', '/browse/12/', subdomain='kb')
openapi_request = FlaskOpenAPIRequest(request)
path = {'id': 12}
query = ImmutableMultiDict([])
headers = EnvironHeaders(request.environ)
cookies = {}
assert openapi_request.parameters == RequestParameters(
path=path,
query=query,
header=headers,
cookie=cookies,
)
assert openapi_request.host_url == request.host_url
assert openapi_request.path == request.path
assert openapi_request.method == request.method.lower()
assert openapi_request.path_pattern == '/browse/{id}/'
assert openapi_request.body == request.data
assert openapi_request.mimetype == request.mimetype
def __init__(self, request, path_pattern=None):
self.full_url_pattern = path_pattern or request.url
self.method = request.method.lower()
url = urlparse(request.url)
query = parse_qs(url.query) if url.query else {}
# when args have one value, that is the value
args = tuple((key, val[0] if len(val) < 2 else val)
for key, val in query.items())
self.data = request.data
ctype = parse_header(request.headers.get('Content-Type', ''))
self.mimetype = ctype[0]
self.parameters = RequestParameters(
path=args,
query=query,
header=request.headers,
cookie=request.cookies,
)
def test_post_no_one_of_schema(self, spec, spec_dict):
host_url = 'https://staging.gigantic-server.com/v1'
path_pattern = '/v1/pets'
pet_name = 'Cat'
alias = 'kitty'
data_json = {
'name': pet_name,
'alias': alias,
}
data = json.dumps(data_json)
headers = {
'api_key': self.api_key_encoded,
}
cookies = {
'user': '******',
}
request = MockRequest(
host_url,
'POST',
'/pets',
path_pattern=path_pattern,
data=data,
headers=headers,
cookies=cookies,
)
parameters = validate_parameters(spec, request)
assert parameters == RequestParameters(
header={
'api_key': self.api_key,
},
cookie={
'user': 123,
},
)
with pytest.raises(InvalidSchemaValue):
validate_body(spec, request)
def test_no_resolver(self, request_factory):
request = request_factory.get('/admin/')
openapi_request = DjangoOpenAPIRequest(request)
path = {}
query = {}
headers = {
'Cookie': '',
}
cookies = {}
assert openapi_request.parameters == RequestParameters(
path=path,
query=query,
header=headers,
cookie=cookies,
)
assert openapi_request.method == request.method.lower()
assert openapi_request.full_url_pattern == \
request._current_scheme_host + request.path
assert openapi_request.body == request.body
assert openapi_request.mimetype == request.content_type
def test_post_tags_extra_body_properties(self, spec, spec_dict):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/tags'
pet_name = 'Dog'
alias = 'kitty'
data_json = {
'name': pet_name,
'alias': alias,
}
data = json.dumps(data_json)
request = MockRequest(
host_url, 'POST', '/tags',
path_pattern=path_pattern, data=data,
)
parameters = validate_parameters(spec, request)
assert parameters == RequestParameters()
with pytest.raises(InvalidSchemaValue):
validate_body(spec, request)
def test_get_pets(self, validator):
args = {'limit': '10', 'ids': ['1', '2'], 'api_key': self.api_key}
request = MockRequest(
self.host_url, 'get', '/v1/pets',
path_pattern='/v1/pets', args=args,
)
result = validator.validate(request)
assert result.errors == []
assert result.body is None
assert result.parameters == RequestParameters(
query={
'limit': 10,
'page': 1,
'search': '',
'ids': [1, 2],
},
)
assert result.security == {
'api_key': self.api_key,
}
def test_post_pets_raises_invalid_mimetype(self, spec):
host_url = 'https://staging.gigantic-server.com/v1'
path_pattern = '/v1/pets'
data_json = {
'name': 'Cat',
'tag': 'cats',
}
data = json.dumps(data_json)
headers = {
'api_key': self.api_key_encoded,
}
cookies = {
'user': '******',
}
request = MockRequest(
host_url,
'POST',
'/pets',
path_pattern=path_pattern,
data=data,
mimetype='text/html',
headers=headers,
cookies=cookies,
)
parameters = validate_parameters(spec, request)
assert parameters == RequestParameters(
header={
'api_key': self.api_key,
},
cookie={
'user': 123,
},
)
with pytest.raises(InvalidContentType):
validate_body(spec, request)
def __init__(self, host_url: str, op_spec: Operation):
self.spec = op_spec
self._url_parts = urlsplit(host_url)
formatter = Formatter()
self.url_vars = [
var for _, var, _, _ in formatter.parse(op_spec.path_name)
if var is not None
]
self._path_pattern = self._url_parts.path + op_spec.path_name
self.full_url_pattern = urljoin(host_url, self._path_pattern)
self.method = op_spec.http_method.lower()
self.body = None
self.parameters = RequestParameters(
path={},
query=parse_qs(self._url_parts.query),
header={},
cookie={},
)
self.mimetype = list(
op_spec.request_body.content)[0] if op_spec.request_body else None
def test_delete_tags_with_requestbody(self, spec, response_validator):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/tags'
ids = [1, 2, 3]
data_json = {
'ids': ids,
}
data = json.dumps(data_json)
request = MockRequest(
host_url,
'DELETE',
'/tags',
path_pattern=path_pattern,
data=data,
)
parameters = validate_parameters(spec, request)
body = validate_body(spec, request)
assert parameters == RequestParameters()
assert isinstance(body, BaseModel)
assert body.ids == ids
def create(
cls, request: Union[HTTPRequest,
HTTPServerRequest]) -> OpenAPIRequest:
"""Creates an OpenAPI request from Tornado request objects.
Supports both :class:`tornado.httpclient.HTTPRequest` and
:class:`tornado.httputil.HTTPServerRequest` objects.
"""
if isinstance(request, HTTPRequest):
if request.url:
path, _, querystring = request.url.partition("?")
query_arguments: ImmutableMultiDict[str,
str] = ImmutableMultiDict(
parse_qsl(querystring))
else:
path = ""
query_arguments = ImmutableMultiDict()
else:
path, _, _ = request.full_url().partition("?")
if path == "://":
path = ""
query_arguments = ImmutableMultiDict(
itertools.chain(
*[[(k, v.decode("utf-8")) for v in vs]
for k, vs in request.query_arguments.items()]))
return OpenAPIRequest(
full_url_pattern=path,
method=request.method.lower() if request.method else "get",
parameters=RequestParameters(
query=query_arguments,
header=Headers(request.headers.get_all()),
cookie=parse_cookie(request.headers.get("Cookie", "")),
),
body=request.body if request.body else b"",
mimetype=parse_mimetype(
request.headers.get("Content-Type",
"application/x-www-form-urlencoded")),
)
