mirror of
https://github.com/correl/openapi-core.git
synced 2024-12-01 03:00:09 +00:00
1170 lines
34 KiB
Python
1170 lines
34 KiB
Python
import json
|
|
import pytest
|
|
from datetime import datetime
|
|
from base64 import b64encode
|
|
from uuid import UUID
|
|
from isodate.tzinfo import UTC
|
|
from six import text_type
|
|
|
|
from openapi_core.casting.schemas.exceptions import CastError
|
|
from openapi_core.deserializing.exceptions import DeserializeError
|
|
from openapi_core.deserializing.parameters.exceptions import (
|
|
EmptyParameterValue,
|
|
)
|
|
from openapi_core.extensions.models.models import BaseModel
|
|
from openapi_core.exceptions import MissingRequiredParameter
|
|
from openapi_core.shortcuts import (
|
|
create_spec, validate_parameters, validate_body, validate_data,
|
|
)
|
|
from openapi_core.templating.media_types.exceptions import MediaTypeNotFound
|
|
from openapi_core.templating.paths.exceptions import (
|
|
ServerNotFound,
|
|
)
|
|
from openapi_core.testing import MockRequest, MockResponse
|
|
from openapi_core.unmarshalling.schemas.exceptions import InvalidSchemaValue
|
|
from openapi_core.validation.request.datatypes import RequestParameters
|
|
from openapi_core.validation.request.validators import RequestValidator
|
|
from openapi_core.validation.response.validators import ResponseValidator
|
|
|
|
|
|
class TestPetstore(object):
|
|
|
|
api_key = '12345'
|
|
|
|
@property
|
|
def api_key_encoded(self):
|
|
api_key_bytes = self.api_key.encode('utf8')
|
|
api_key_bytes_enc = b64encode(api_key_bytes)
|
|
return text_type(api_key_bytes_enc, 'utf8')
|
|
|
|
@pytest.fixture(scope='module')
|
|
def spec_uri(self):
|
|
return "file://tests/integration/data/v3.0/petstore.yaml"
|
|
|
|
@pytest.fixture(scope='module')
|
|
def spec_dict(self, factory):
|
|
return factory.spec_from_file("data/v3.0/petstore.yaml")
|
|
|
|
@pytest.fixture(scope='module')
|
|
def spec(self, spec_dict, spec_uri):
|
|
return create_spec(spec_dict, spec_uri)
|
|
|
|
@pytest.fixture(scope='module')
|
|
def request_validator(self, spec):
|
|
return RequestValidator(spec)
|
|
|
|
@pytest.fixture(scope='module')
|
|
def response_validator(self, spec):
|
|
return ResponseValidator(spec)
|
|
|
|
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_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_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_ids_param(self, spec, response_validator):
|
|
host_url = 'http://petstore.swagger.io/v1'
|
|
path_pattern = '/v1/pets'
|
|
query_params = {
|
|
'limit': '20',
|
|
'ids': ['12', '13'],
|
|
}
|
|
|
|
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': '',
|
|
'ids': [12, 13],
|
|
}
|
|
)
|
|
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_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_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_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(CastError):
|
|
validate_parameters(spec, request)
|
|
|
|
body = validate_body(spec, request)
|
|
|
|
assert body 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_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
|
|
|
|
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_birds(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,
|
|
'wings': {
|
|
'healthy': pet_healthy,
|
|
}
|
|
}
|
|
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 = 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 == pet_healthy
|
|
|
|
def test_post_cats(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': '123',
|
|
}
|
|
|
|
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 == pet_healthy
|
|
|
|
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': '123',
|
|
}
|
|
|
|
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_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': '123',
|
|
}
|
|
|
|
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_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': '123',
|
|
}
|
|
|
|
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_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': '123',
|
|
}
|
|
|
|
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_missing_cookie(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,
|
|
}
|
|
|
|
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_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': '123',
|
|
}
|
|
|
|
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_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(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_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_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 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_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_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_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 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_post_tags_created_now(
|
|
self, spec, response_validator):
|
|
host_url = 'http://petstore.swagger.io/v1'
|
|
path_pattern = '/v1/tags'
|
|
created = 'now'
|
|
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 == created
|
|
assert body.name == pet_name
|
|
|
|
code = 400
|
|
message = 'Bad request'
|
|
rootCause = 'Tag already exist'
|
|
additionalinfo = 'Tag Dog already exist'
|
|
data_json = {
|
|
'code': 400,
|
|
'message': 'Bad request',
|
|
'rootCause': 'Tag already exist',
|
|
'additionalinfo': 'Tag Dog already exist',
|
|
}
|
|
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_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_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
|