def test_invalid_path(self, validator):
request = MockRequest(self.host_url, 'get', '/v1')
result = validator.validate(request)
assert len(result.errors) == 1
assert type(result.errors[0]) == InvalidPath
assert result.body is None
assert result.parameters == {}
def test_request_server_error(self, validator):
request = MockRequest('http://petstore.invalid.net/v1', 'get', '/')
result = validator.validate(request)
assert len(result.errors) == 1
assert type(result.errors[0]) == InvalidServer
assert result.body is None
assert result.parameters == {}
def test_invalid_operation(self, validator):
request = MockRequest(self.host_url, 'patch', '/v1/pets')
result = validator.validate(request)
assert len(result.errors) == 1
assert type(result.errors[0]) == InvalidOperation
assert result.body is None
assert result.parameters == {}
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.raises(InvalidParameterValue):
request.get_parameters(spec)
body = request.get_body(spec)
assert body is None
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 = request.get_parameters(spec)
assert parameters == {
'path': {
'petId': 1,
}
}
body = request.get_body(spec)
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 test_post_tags_created_invalid_type(
self, spec, response_validator):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/tags'
created = 'long time ago'
pet_name = 'Dog'
data_json = {
'created': created,
'name': pet_name,
}
data = json.dumps(data_json)
request = MockRequest(
host_url, 'POST', '/tags',
path_pattern=path_pattern, data=data,
)
parameters = request.get_parameters(spec)
with pytest.raises(NoValidSchema):
request.get_body(spec)
assert parameters == {}
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 = request.get_parameters(spec)
assert parameters == {
'path': {
'petId': 1,
}
}
body = request.get_body(spec)
assert body is None
data_id = 1
data_name = 'test'
data_json = {
'data': {
'id': data_id,
'name': data_name,
},
}
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_post_cats_only_required_body(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': '12345',
}
cookies = {
'user': '******',
}
request = MockRequest(
host_url, 'POST', '/pets',
path_pattern=path_pattern, data=data,
headers=headers, cookies=cookies,
)
parameters = request.get_parameters(spec)
assert parameters == {
'header': {
'api_key': 12345,
},
'cookie': {
'user': 123,
},
}
body = request.get_body(spec)
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(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,
}
cookies = {
'user': 123,
}
request = MockRequest(
self.host_url,
'post',
'/v1/pets',
path_pattern='/v1/pets',
data=data,
headers=headers,
cookies=cookies,
)
result = validator.validate(request)
assert result.errors == []
assert result.parameters == {
'header': {
'api_key': self.api_key,
},
'cookie': {
'user': 123,
},
}
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_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(InvalidParameterValue):
request.get_parameters(spec)
body = request.get_body(spec)
assert body is None
def test_invalid_server(self, validator):
request = MockRequest('http://petstore.invalid.net/v1', 'get', '/')
response = MockResponse('Not Found', status_code=404)
result = validator.validate(request, response)
assert len(result.errors) == 1
assert type(result.errors[0]) == InvalidServer
assert result.data is None
assert result.headers is None
def test_invalid_response(self, validator):
request = MockRequest(self.host_url, 'get', '/v1/pets')
response = MockResponse('Not Found', status_code=409)
result = validator.validate(request, response)
assert len(result.errors) == 1
assert type(result.errors[0]) == InvalidResponse
assert result.data is None
assert result.headers is None
def test_invalid_content_type(self, validator):
request = MockRequest(self.host_url, 'get', '/v1/pets')
response = MockResponse('Not Found', mimetype='text/csv')
result = validator.validate(request, response)
assert len(result.errors) == 1
assert type(result.errors[0]) == InvalidContentType
assert result.data is None
assert result.headers == {}
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 = request.get_parameters(spec)
body = request.get_body(spec)
assert parameters == {}
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_missing_body(self, validator):
request = MockRequest(self.host_url, 'get', '/v1/pets')
response = MockResponse(None)
result = validator.validate(request, response)
assert len(result.errors) == 1
assert type(result.errors[0]) == MissingResponseContent
assert result.data is None
assert result.headers == {}
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 = request.get_parameters(spec)
body = request.get_body(spec)
assert parameters == {
'query': {
'limit': 20,
'page': 1,
'search': '',
}
}
assert body is None
data_json = {
'data': [{
'id': 1,
'name': 'Cat',
}],
}
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_invalid_media_type_value(self, validator):
request = MockRequest(self.host_url, 'get', '/v1/pets')
response = MockResponse("{}")
result = validator.validate(request, response)
assert len(result.errors) == 1
assert type(result.errors[0]) == InvalidMediaTypeValue
assert result.data is None
assert result.headers == {}
def test_post_object_success(self, factory, response, spec_path):
spec_dict = factory.spec_from_file(spec_path)
spec = create_spec(spec_dict)
validator = RequestValidator(spec)
request = MockRequest("http://www.example.com",
"post",
"/object",
data=json.dumps(response))
result = validator.validate(request)
assert not result.errors
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 = request.get_parameters(spec)
assert parameters == {}
with pytest.raises(InvalidMediaTypeValue):
request.get_body(spec)
def test_post_pets_raises_invalid_mimetype(self, spec):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/pets'
data_json = {
'name': 'Cat',
'tag': 'cats',
}
data = json.dumps(data_json)
request = MockRequest(
host_url, 'POST', '/pets',
path_pattern=path_pattern, data=data, mimetype='text/html',
)
parameters = request.get_parameters(spec)
assert parameters == {}
with pytest.raises(InvalidContentType):
request.get_body(spec)
def test_get_object_failure(self, factory, response, spec_path):
spec_dict = factory.spec_from_file(spec_path)
spec = create_spec(spec_dict)
request = MockRequest("http://www.example.com", "get",
"/object/{objectId}")
validator = ResponseValidator(spec)
response = MockResponse(data=json.dumps(response))
result = validator.validate(request, response)
assert result.errors
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 = request.get_parameters(spec)
assert parameters == {}
with pytest.raises(InvalidMediaTypeValue):
request.get_body(spec)
def test_string_additional_property(self, response_validator):
request = MockRequest(self.server, "get", "/strings-only")
data_json = {
'data': "test",
"test": "test",
"something": "else",
}
data = json.dumps(data_json)
response = MockResponse(data)
response_result = response_validator.validate(request, response)
assert not response_result.errors, response_result.errors
def test_request_valid_param(self, validator):
request = MockRequest(
'http://example.com',
'get',
'/resource',
args={'resId': '10'},
)
result = validator.validate(request)
assert len(result.errors) == 0
assert result.body is None
assert result.parameters == {'query': {'resId': 10}}
def test_invalid_operation(self, factory, server, spec_path):
spec_dict = factory.spec_from_file(spec_path)
spec = create_spec(spec_dict)
validator = RequestValidator(spec)
request = MockRequest(server, "get", "/nonexistent")
result = validator.validate(request)
assert len(result.errors) == 1
assert isinstance(result.errors[0], InvalidOperation)
assert result.body is None
assert result.parameters == {}
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 = request.get_parameters(spec)
body = request.get_body(spec)
assert parameters == {
'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_post_no_one_of_schema(self, spec, spec_dict):
host_url = 'http://petstore.swagger.io/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': 123,
}
request = MockRequest(
host_url,
'POST',
'/pets',
path_pattern=path_pattern,
data=data,
headers=headers,
cookies=cookies,
)
parameters = request.get_parameters(spec)
assert parameters == {
'header': {
'api_key': self.api_key,
},
'cookie': {
'user': 123,
},
}
with pytest.raises(InvalidMediaTypeValue):
request.get_body(spec)
def test_post_pets_raises_invalid_server_error(self, spec):
host_url = 'http://flowerstore.swagger.io/v1'
path_pattern = '/v1/pets'
data_json = {
'name': 'Cat',
'tag': 'cats',
}
data = json.dumps(data_json)
headers = {
'api_key': 12345,
}
cookies = {
'user': 123,
}
request = MockRequest(
host_url,
'POST',
'/pets',
path_pattern=path_pattern,
data=data,
mimetype='text/html',
headers=headers,
cookies=cookies,
)
with pytest.raises(InvalidServer):
request.get_parameters(spec)
with pytest.raises(InvalidServer):
request.get_body(spec)
def test_missing_parameter(self, validator):
request = MockRequest(self.host_url, 'get', '/v1/pets')
result = validator.validate(request)
assert type(result.errors[0]) == MissingRequiredParameter
assert result.body is None
assert result.parameters == {
'query': {
'page': 1,
'search': '',
},
}
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 = request.get_parameters(spec)
assert parameters == {}
with pytest.raises(UndefinedSchemaProperty):
request.get_body(spec)
