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_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(MediaTypeNotFound):
validate_body(spec, request)
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': '******',
}
request = MockRequest(
host_url,
'POST',
'/pets',
path_pattern=path_pattern,
data=data,
mimetype='text/html',
headers=headers,
cookies=cookies,
)
with pytest.raises(InvalidServer):
validate_parameters(spec, request)
with pytest.raises(InvalidServer):
validate_body(spec, request)
def test_no_wrapper_error(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
mock_validate.return_value = ResultMock(error_to_raise=ValueError)
with pytest.raises(ValueError):
validate_body(spec, request)
mock_validate.aasert_called_once_with(request)
def test_wrapper_error(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
mock_validate.return_value = ResultMock(error_to_raise=ValueError)
request_wrapper_class = WrapperClassMock
with pytest.raises(ValueError):
validate_body(spec, request, request_wrapper_class)
mock_validate.assert_called_once_with(WrapperClassMock(request), )
def test_request_factory_error(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
mock_validate.return_value = ResultMock(error_to_raise=ValueError)
request_factory = FactoryClassMock
with pytest.raises(ValueError):
validate_body(spec, request, request_factory)
mock_validate.assert_called_once_with(
FactoryClassMock(request),
)
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 = validate_parameters(spec, request)
with pytest.raises(InvalidSchemaValue):
validate_body(spec, request)
assert parameters == RequestParameters()
code = 400
message = 'Bad request'
correlationId = UUID('a8098c1a-f86e-11da-bd1a-00112444be1e')
rootCause = 'Tag already exist'
additionalinfo = 'Tag Dog already exist'
data_json = {
'code': code,
'message': message,
'correlationId': str(correlationId),
'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.correlationId == correlationId
assert response_result.data.rootCause == rootCause
assert response_result.data.additionalinfo == additionalinfo
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': '******',
}
request = MockRequest(
host_url,
'POST',
'/pets',
path_pattern=path_pattern,
data=data,
mimetype='text/html',
headers=headers,
cookies=cookies,
)
with pytest.raises(ServerNotFound):
validate_parameters(spec, request)
with pytest.raises(ServerNotFound):
validate_body(spec, request)
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)
with pytest.raises(ServerNotFound):
validate_data(spec, request, response)
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_get_pets_param_coordinates(self, spec):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/pets'
coordinates = {
'lat': 1.12,
'lon': 32.12,
}
query_params = {
'limit': None,
'coordinates': json.dumps(coordinates),
}
request = MockRequest(
host_url,
'GET',
'/pets',
path_pattern=path_pattern,
args=query_params,
)
parameters = validate_parameters(spec, request)
assert parameters == RequestParameters(query={
'limit': None,
'page': 1,
'search': '',
'coordinates': coordinates,
})
body = validate_body(spec, request)
assert body is None
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,
)
parameters = validate_parameters(spec, request)
body = validate_body(spec, request)
assert parameters == RequestParameters(query={
'limit': 20,
'page': 1,
'search': '',
})
assert body is None
data = '<html></html>'
response = MockResponse(data, status_code=404, mimetype='text/html')
response_result = response_validator.validate(request, response)
assert response_result.errors == []
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(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': [],
}
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_pet_wildcard(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 = b'imagedata'
response = MockResponse(data, mimetype='image/png')
response_result = response_validator.validate(request, response)
assert response_result.errors == []
assert response_result.data == data
def test_get_pets_none_value(self, spec):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/pets'
query_params = {
'limit': None,
}
request = MockRequest(
host_url, 'GET', '/pets',
path_pattern=path_pattern, args=query_params,
)
parameters = validate_parameters(spec, request)
assert parameters == RequestParameters(
query={
'limit': None,
'page': 1,
'search': '',
}
)
body = validate_body(spec, request)
assert body is None
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
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_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 get_body(self, spec):
warnings.warn(
"`get_body` method is deprecated. "
"Use RequestValidator instead.",
DeprecationWarning,
)
# backward compatibility
from openapi_core.shortcuts import validate_body
return validate_body(spec, self, wrapper_class=None)
def test_post_tags_created_datetime(self, spec, response_validator):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/tags'
created = '2016-04-16T16:06:05Z'
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 = validate_parameters(spec, request)
body = validate_body(spec, request)
assert parameters == RequestParameters()
assert isinstance(body, BaseModel)
assert body.created == datetime(2016, 4, 16, 16, 6, 5, tzinfo=UTC)
assert body.name == pet_name
code = 400
message = 'Bad request'
rootCause = 'Tag already exist'
additionalinfo = 'Tag Dog already exist'
response_data_json = {
'code': code,
'message': message,
'rootCause': rootCause,
'additionalinfo': additionalinfo,
}
response_data = json.dumps(response_data_json)
response = MockResponse(response_data, status_code=404)
data = validate_data(spec, request, response)
assert isinstance(data, BaseModel)
assert data.code == code
assert data.message == message
assert data.rootCause == rootCause
assert data.additionalinfo == additionalinfo
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_no_wrapper(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
body = mock.sentinel.body
mock_validate.return_value = ResultMock(body=body)
result = validate_body(spec, request)
assert result == body
mock_validate.aasert_called_once_with(request)
def test_wrapper(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
body = mock.sentinel.body
mock_validate.return_value = ResultMock(body=body)
request_wrapper_class = WrapperClassMock
result = validate_body(spec, request, request_wrapper_class)
assert result == body
mock_validate.assert_called_once_with(WrapperClassMock(request), )
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_request_factory(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
body = mock.sentinel.body
mock_validate.return_value = ResultMock(body=body)
request_factory = FactoryClassMock
result = validate_body(spec, request, request_factory)
assert result == body
mock_validate.assert_called_once_with(
FactoryClassMock(request),
)
def test_get_pets_invalid_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
response_data_json = {
'data': [
{
'id': 1,
'name': {
'first_name': 'Cat',
},
}
],
}
response_data = json.dumps(response_data_json)
response = MockResponse(response_data)
with pytest.raises(InvalidSchemaValue):
validate_data(spec, request, response)
response_result = response_validator.validate(request, response)
schema_errors = response_result.errors[0].schema_errors
assert response_result.errors == [
InvalidSchemaValue(
type='object',
value=response_data_json,
schema_errors=schema_errors,
),
]
assert response_result.data is None
def test_get_pets_raises_missing_required_param(self, spec):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/pets'
request = MockRequest(
host_url, 'GET', '/pets',
path_pattern=path_pattern,
)
with pytest.raises(MissingRequiredParameter):
validate_parameters(spec, request)
body = validate_body(spec, request)
assert body is None
def test_delete_tags_no_requestbody(self, spec, response_validator):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/tags'
request = MockRequest(
host_url,
'DELETE',
'/tags',
path_pattern=path_pattern,
)
parameters = validate_parameters(spec, request)
body = validate_body(spec, request)
assert parameters == RequestParameters()
assert body is None
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_get_pets_invalid_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': {
'first_name': 'Cat',
},
}],
}
data = json.dumps(data_json)
response = MockResponse(data)
response_result = response_validator.validate(request, response)
original_exc = response_result.errors[0].original_exception
assert response_result.errors == [
InvalidMediaTypeValue(original_exception=InvalidSchemaValue(
type=SchemaType.OBJECT,
value=data_json,
schema_errors=original_exc.schema_errors,
schema_errors_iter=original_exc._schema_errors_iter,
), ),
]
assert response_result.data is None
def test_get_pets_empty_value(self, spec):
host_url = 'http://petstore.swagger.io/v1'
path_pattern = '/v1/pets'
query_params = {
'limit': '',
}
request = MockRequest(
host_url, 'GET', '/pets',
path_pattern=path_pattern, args=query_params,
)
with pytest.raises(EmptyParameterValue):
validate_parameters(spec, request)
body = validate_body(spec, request)
assert body is None
