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_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_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 = spec_validate_parameters(spec, request)
body = spec_validate_body(spec, request)
assert parameters == RequestParameters()
assert isinstance(body, BaseModel)
assert body.ids == ids
data = None
headers = {
'x-delete-confirm': 'true',
}
response = MockResponse(data, status_code=200, headers=headers)
with pytest.warns(DeprecationWarning):
response_result = response_validator.validate(request, response)
assert response_result.errors == []
assert response_result.data is None
response_headers = spec_validate_headers(spec, request, response)
assert response_headers == {
'x-delete-confirm': True,
}
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 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_get_pets_parameter_deserialization_error(self, spec):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/pets'
query_params = {
'limit': 1,
'tags': 12,
}
request = MockRequest(
host_url,
'GET',
'/pets',
path_pattern=path_pattern,
args=query_params,
)
with pytest.raises(DeserializeError):
validate_parameters(spec, request)
body = validate_body(spec, request)
assert body is None
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 = spec_validate_parameters(spec, request)
assert parameters == Parameters(
header={
"api-key": self.api_key,
},
cookie={
"user": 123,
},
)
with pytest.raises(MediaTypeNotFound):
spec_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_get_pets_wrong_parameter_type(self, spec):
host_url = "http://petstore.swagger.io/v1"
path_pattern = "/v1/pets"
query_params = {
"limit": "twenty",
}
request = MockRequest(
host_url,
"GET",
"/pets",
path_pattern=path_pattern,
args=query_params,
)
with pytest.warns(DeprecationWarning):
with pytest.raises(CastError):
spec_validate_parameters(spec, request)
body = spec_validate_body(spec, request)
assert body is None
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 test_valid(self, finder, spec):
token_id = "123"
request_uri = f"/keys/{token_id}/tokens"
method = "get"
request = MockRequest(
"http://petstore.swagger.io", method, request_uri
)
result = finder.find(request.method, request.full_url_pattern)
path_2 = spec / "paths" / self.path_2_name
operation_2 = spec / "paths" / self.path_2_name / method
server = eval(self.location) / "servers" / 0
path_result = TemplateResult(self.path_2_name, {"id": token_id})
server_result = TemplateResult(self.server_url, {})
assert result == (
path_2,
operation_2,
server,
path_result,
server_result,
)
def test_get_pets_tags_param(self, spec, response_validator):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/pets'
query_params = [
('limit', '20'),
('tags', 'cats,dogs'),
]
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': '',
'tags': ['cats', 'dogs'],
})
assert body is None
data_json = {
'data': [],
}
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 response_result.data.data == []
def test_get_tags(self, spec, response_validator):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/tags'
request = MockRequest(
host_url, 'GET', '/tags',
path_pattern=path_pattern,
)
parameters = validate_parameters(spec, request)
body = validate_body(spec, request)
assert parameters == RequestParameters()
assert body is None
data_json = ['cats', 'birds']
data = json.dumps(data_json)
response = MockResponse(data)
response_result = response_validator.validate(request, response)
assert response_result.errors == []
assert response_result.data == data_json
def test_get_pets_parameter_deserialization_error(self, spec):
host_url = "http://petstore.swagger.io/v1"
path_pattern = "/v1/pets"
query_params = {
"limit": 1,
"tags": 12,
}
request = MockRequest(
host_url,
"GET",
"/pets",
path_pattern=path_pattern,
args=query_params,
)
with pytest.warns(DeprecationWarning):
with pytest.raises(DeserializeError):
spec_validate_parameters(spec, request)
body = spec_validate_body(spec, request)
assert body is None
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")], {})
with pytest.warns(DeprecationWarning):
result = validator.validate(request)
assert result.errors == []
assert result.body is None
assert result.parameters == Parameters(query={
"limit": 5,
"page": 1,
"search": "",
"ids": [1, 2],
}, )
def test_get_pet(self, validator):
authorization = 'Basic ' + self.api_key_encoded
headers = {
'Authorization': authorization,
}
request = MockRequest(
self.host_url, 'get', '/v1/pets/1',
path_pattern='/v1/pets/{petId}', view_args={'petId': '1'},
headers=headers,
)
result = validator.validate(request)
assert result.errors == []
assert result.body is None
assert result.parameters == RequestParameters(
path={
'petId': 1,
},
)
assert result.security == {
'petstore_auth': self.api_key,
}
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_get_pet(self, validator):
authorization = "Basic " + self.api_key_encoded
headers = {
"Authorization": authorization,
}
request = MockRequest(
self.host_url,
"get",
"/v1/pets/1",
path_pattern="/v1/pets/{petId}",
view_args={"petId": "1"},
headers=headers,
)
result = validator.validate(request)
assert result.errors == []
assert result.body is None
assert result.parameters == Parameters(path={
"petId": 1,
}, )
assert result.security == {
"petstore_auth": self.api_key_encoded,
}
def test_post_pets_missing_header(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)
cookies = {
'user': '******',
}
request = MockRequest(
host_url,
'POST',
'/pets',
path_pattern=path_pattern,
data=data,
cookies=cookies,
)
with pytest.raises(MissingRequiredParameter):
validate_parameters(spec, request)
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_post_pets_missing_header(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)
cookies = {
"user": "******",
}
request = MockRequest(
host_url,
"POST",
"/pets",
path_pattern=path_pattern,
data=data,
cookies=cookies,
)
with pytest.raises(MissingRequiredParameter):
spec_validate_parameters(spec, request)
body = spec_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_get_pets_response_no_schema(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 == Parameters(
query={
"limit": 20,
"page": 1,
"search": "",
}
)
assert body is None
data = "<html></html>"
response = MockResponse(data, status_code=404, mimetype="text/html")
with pytest.warns(UserWarning):
response_result = response_validator.validate(request, response)
assert response_result.errors == []
assert response_result.data == data
def test_header(self, header, scheme):
"""Tests HttpProvider against Issue29427
https://bugs.python.org/issue29427
"""
spec = {
"type": "http",
"scheme": scheme,
}
value = "MQ"
headers = {
header: " ".join([scheme.title(), value]),
}
request = MockRequest(
"http://localhost",
"GET",
"/pets",
headers=headers,
)
scheme = SpecPath.from_spec(spec)
provider = HttpProvider(scheme)
result = provider(request)
assert result == value
def test_get_pets(self, validator):
request = MockRequest(self.host_url, 'get', '/v1/pets')
response_json = {
'data': [
{
'id': 1,
'name': 'Sparky',
'ears': {
'healthy': True,
},
},
],
}
response_data = json.dumps(response_json)
response = MockResponse(response_data)
result = validator.validate(request, response)
assert result.errors == []
assert isinstance(result.data, BaseModel)
assert len(result.data.data) == 1
assert result.data.data[0].id == 1
assert result.data.data[0].name == 'Sparky'
assert result.headers == {}
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,
)
with pytest.warns(DeprecationWarning):
result = validator.validate(request)
assert result.errors == []
assert result.body is None
assert result.parameters == Parameters(query={
"limit": 10,
"page": 1,
"search": "",
"ids": [1, 2],
}, )
assert result.security == {
"api_key": self.api_key,
}
def test_get_pets(self, validator):
request = MockRequest(self.host_url, "get", "/v1/pets")
response_json = {
"data": [
{
"id": 1,
"name": "Sparky",
"ears": {
"healthy": True,
},
},
],
}
response_data = json.dumps(response_json)
response = MockResponse(response_data)
result = validator.validate(request, response)
assert result.errors == []
assert isinstance(result.data, BaseModel)
assert len(result.data.data) == 1
assert result.data.data[0].id == 1
assert result.data.data[0].name == "Sparky"
assert result.headers == {}
def test_header(self, header, scheme):
"""Tests HttpProvider against Issue29427
https://bugs.python.org/issue29427
"""
spec = {
'type': 'http',
'scheme': scheme,
}
value = 'MQ'
headers = {
header: ' '.join([scheme.title(), value]),
}
request = MockRequest(
'http://localhost',
'GET',
'/pets',
headers=headers,
)
scheme = SpecPath.from_spec(spec)
provider = HttpProvider(scheme)
result = provider(request)
assert result == value
def test_post_pets_missing_cookie(self, spec, spec_dict):
host_url = 'http://petstore.swagger.io/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,
}
request = MockRequest(
host_url,
'POST',
'/pets',
path_pattern=path_pattern,
data=data,
headers=headers,
)
with pytest.raises(MissingRequiredParameter):
validate_parameters(spec, request)
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_raises(self, finder):
request_uri = '/resource'
request = MockRequest('http://petstore.swagger.io', 'get', request_uri)
with pytest.raises(PathNotFound):
finder.find(request)
def test_invalid_complex_parameter(self, validator, spec_dict):
pet_name = "Cat"
pet_tag = "cats"
pet_street = "Piekna"
pet_city = "Warsaw"
data_json = {
"name": pet_name,
"tag": pet_tag,
"position": 2,
"address": {
"street": pet_street,
"city": pet_city,
},
"ears": {
"healthy": True,
},
}
data = json.dumps(data_json)
headers = {
"api-key": self.api_key_encoded,
}
userdata = {
"name": 1,
}
userdata_json = json.dumps(userdata)
cookies = {
"user": "******",
"userdata": userdata_json,
}
request = MockRequest(
"https://development.gigantic-server.com",
"post",
"/v1/pets",
path_pattern="/v1/pets",
data=data,
headers=headers,
cookies=cookies,
)
result = validator.validate(request)
assert len(result.errors) == 1
assert type(result.errors[0]) == InvalidSchemaValue
assert result.parameters == Parameters(
header={
"api-key": self.api_key,
},
cookie={
"user": 123,
},
)
assert result.security == {}
schemas = spec_dict["components"]["schemas"]
pet_model = schemas["PetCreate"]["x-model"]
address_model = schemas["Address"]["x-model"]
assert result.body.__class__.__name__ == pet_model
assert result.body.name == pet_name
assert result.body.tag == pet_tag
assert result.body.position == 2
assert result.body.address.__class__.__name__ == address_model
assert result.body.address.street == pet_street
assert result.body.address.city == pet_city
def test_post_cats_boolean_string(self, spec, spec_dict):
host_url = 'https://staging.gigantic-server.com/v1'
path_pattern = '/v1/pets'
pet_name = 'Cat'
pet_tag = 'cats'
pet_street = 'Piekna'
pet_city = 'Warsaw'
pet_healthy = False
data_json = {
'name': pet_name,
'tag': pet_tag,
'position': 2,
'address': {
'street': pet_street,
'city': pet_city,
},
'healthy': pet_healthy,
'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']
address_model = schemas['Address']['x-model']
assert body.__class__.__name__ == pet_model
assert body.name == pet_name
assert body.tag == pet_tag
assert body.position == 2
assert body.address.__class__.__name__ == address_model
assert body.address.street == pet_street
assert body.address.city == pet_city
assert body.healthy is False