def test_no_wrappers_error(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
response = mock.sentinel.response
mock_validate.return_value = ResultMock(error_to_raise=ValueError)
with pytest.raises(ValueError):
validate_data(spec, request, response)
mock_validate.aasert_called_once_with(request, response)
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_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_factories_error(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
response = mock.sentinel.response
mock_validate.return_value = ResultMock(error_to_raise=ValueError)
request_factory = FactoryClassMock
response_factory = FactoryClassMock
with pytest.raises(ValueError):
validate_data(
spec, request, response,
request_factory, response_factory,
)
mock_validate.assert_called_once_with(
FactoryClassMock(request),
FactoryClassMock(response),
)
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
async def decorator(request: web.Request) -> web.StreamResponse:
app = request.app
config_dict = request.config_dict
# Step 1. Ensure that OpenAPI schema exists as well as given
# operation ID
schema = get_openapi_schema(config_dict)
operation = get_openapi_operation(schema, operation_id)
# Step 2. Ensure that OpenAPI spec exists and convert aiohttp.web
# request to openapi-core request
spec = get_openapi_spec(config_dict)
core_request = await to_openapi_core_request(request)
# Step 3. Validate request parameters & body
parameters = to_openapi_parameters(
validate_parameters(spec, core_request))
data = validate_body(spec, core_request)
if isinstance(data, Model):
data = types.MappingProxyType(vars(data))
# Step 4. Validate security data if any
security = validate_security(request, operation, oas=schema)
# Step 5. Provide OpenAPI context for the handler
request[OPENAPI_CONTEXT_REQUEST_KEY] = OpenAPIContext(
request=request,
app=app,
config_dict=config_dict,
operation=operation,
parameters=parameters,
data=data,
security=security,
)
# Step 5. Validate response if needed
response = await handler(request)
if config_dict[OPENAPI_IS_VALIDATE_RESPONSE_APP_KEY]:
validate_data(spec, core_request,
to_openapi_core_response(response))
return response
def test_no_wrappers(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
response = mock.sentinel.response
data = mock.sentinel.data
mock_validate.return_value = ResultMock(data=data)
result = validate_data(spec, request, response)
assert result == data
mock_validate.aasert_called_once_with(request, response)
def test_wrappers_error(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
response = mock.sentinel.response
mock_validate.return_value = ResultMock(error_to_raise=ValueError)
request_wrapper_class = WrapperClassMock
response_wrapper_class = WrapperClassMock
with pytest.raises(ValueError):
validate_data(
spec,
request,
response,
request_wrapper_class,
response_wrapper_class,
)
mock_validate.assert_called_once_with(
WrapperClassMock(request),
WrapperClassMock(response),
)
def test_factories(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
response = mock.sentinel.response
data = mock.sentinel.data
mock_validate.return_value = ResultMock(data=data)
request_factory = FactoryClassMock
response_factory = FactoryClassMock
result = validate_data(
spec, request, response,
request_factory, response_factory,
)
assert result == data
mock_validate.assert_called_once_with(
FactoryClassMock(request),
FactoryClassMock(response),
)
def test_wrappers(self, mock_validate):
spec = mock.sentinel.spec
request = mock.sentinel.request
response = mock.sentinel.response
data = mock.sentinel.data
mock_validate.return_value = ResultMock(data=data)
request_wrapper_class = WrapperClassMock
response_wrapper_class = WrapperClassMock
result = validate_data(
spec,
request,
response,
request_wrapper_class,
response_wrapper_class,
)
assert result == data
mock_validate.assert_called_once_with(
WrapperClassMock(request),
WrapperClassMock(response),
)
