def test_create_request_body_converter_without_schema(self, mocker):
expected_result = None
converter = converters.PydanticConverter()
result = converter.create_request_body_converter(mocker.sentinel)
assert result is expected_result
def test_create_response_body_converter_without_schema(self):
expected_result = None
converter = converters.PydanticConverter()
result = converter.create_response_body_converter("not a schema")
assert result is expected_result
def test_create_string_converter(self, pydantic_model_mock):
expected_result = None
_, model = pydantic_model_mock
converter = converters.PydanticConverter()
c = converter.create_string_converter(model, None)
assert c is expected_result
def test_init_without_pydantic(self, mocker):
mocker.patch.object(
converters.PydanticConverter,
"pydantic",
new_callable=mocker.PropertyMock,
return_value=None,
)
with pytest.raises(ImportError):
converters.PydanticConverter()
def test_create_request_body_converter(self, pydantic_model_mock):
expected_result = {"id": 0}
request_body = {}
model_mock, model = pydantic_model_mock
model_mock.dict.return_value = expected_result
converter = converters.PydanticConverter()
request_converter = converter.create_request_body_converter(model)
result = request_converter.convert(request_body)
assert result == expected_result
model_mock.dict.assert_called_once()
def test_create_response_body_converter_invalid_response(
self, mocker, pydantic_model_mock):
data = {"quick": "fox"}
_, model = pydantic_model_mock
parse_obj_mock = mocker.patch.object(
model,
"parse_obj",
side_effect=pydantic.ValidationError([], model))
converter = converters.PydanticConverter()
c = converter.create_response_body_converter(model)
with pytest.raises(pydantic.ValidationError):
c.convert(data)
parse_obj_mock.assert_called_once_with(data)
def test_create_response_body_converter(self, mocker, pydantic_model_mock):
expected_result = "data"
model_mock, model = pydantic_model_mock
parse_obj_mock = mocker.patch.object(model,
"parse_obj",
return_value=expected_result)
response = mocker.Mock(spec=["json"])
response.json.return_value = {}
converter = converters.PydanticConverter()
c = converter.create_response_body_converter(model)
result = c.convert(response)
response.json.assert_called_once()
parse_obj_mock.assert_called_once_with(response.json())
assert result == expected_result
def test_convert_complex_model(self):
from json import loads
from datetime import datetime
class ComplexModel(pydantic.BaseModel):
when = datetime.utcnow() # type: datetime
where = "http://example.com" # type: pydantic.AnyUrl
some = [1] # type: typing.List[int]
model = ComplexModel()
request_body = {}
expected_result = loads(model.json())
converter = converters.PydanticConverter()
request_converter = converter.create_request_body_converter(
ComplexModel)
result = request_converter.convert(request_body)
assert result == expected_result
