def test_multiple_of_deserialization(self):
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer': 30,
'number': 65.0,
'float': 62.4,
}
response = MockResponse(data=json.dumps(data))
deserialized = self.api_client.deserialize(response, (format_test.FormatTest,), True)
self.assertTrue(isinstance(deserialized, format_test.FormatTest))
with self.checkRaiseRegex(petstore_api.exceptions.ApiValueError, "Invalid value for `integer`, value must be a multiple of `2`"):
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer': 31, # Value is supposed to be multiple of '2'. An error must be raised
'number': 65.0,
'float': 62.4,
}
response = MockResponse(data=json.dumps(data))
deserialized = self.api_client.deserialize(response, (format_test.FormatTest,), True)
# Disable JSON schema validation. No error should be raised during deserialization.
config = petstore_api.Configuration()
config.disabled_client_side_validations = "multipleOf"
api_client = petstore_api.ApiClient(configuration=config)
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer': 31, # Value is supposed to be multiple of '2'
'number': 65.0,
'float': 62.4,
}
response = MockResponse(data=json.dumps(data))
deserialized = api_client.deserialize(response, (format_test.FormatTest,), True)
self.assertTrue(isinstance(deserialized, format_test.FormatTest))
# Disable JSON schema validation but for a different keyword.
# An error should be raised during deserialization.
config = petstore_api.Configuration()
config.disabled_client_side_validations = "maxItems"
api_client = petstore_api.ApiClient(configuration=config)
with self.checkRaiseRegex(petstore_api.exceptions.ApiValueError, "Invalid value for `integer`, value must be a multiple of `2`"):
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer': 31, # Value is supposed to be multiple of '2'
'number': 65.0,
'float': 62.4,
}
response = MockResponse(data=json.dumps(data))
deserialized = api_client.deserialize(response, (format_test.FormatTest,), True)
def test_configuration(self):
config = petstore_api.Configuration()
config.host = 'http://localhost/'
config.api_key['api_key'] = '123456'
config.api_key_prefix['api_key'] = 'PREFIX'
config.username = '******'
config.password = '******'
header_params = {'test1': 'value1'}
query_params = {'test2': 'value2'}
auth_settings = ['api_key', 'unknown']
client = petstore_api.ApiClient(config)
# test prefix
self.assertEqual('PREFIX',
client.configuration.api_key_prefix['api_key'])
# update parameters based on auth setting
client.update_params_for_auth(header_params, query_params,
auth_settings)
# test api key auth
self.assertEqual(header_params['test1'], 'value1')
self.assertEqual(header_params['api_key'], 'PREFIX 123456')
self.assertEqual(query_params['test2'], 'value2')
# test basic auth
self.assertEqual('test_username', client.configuration.username)
self.assertEqual('test_password', client.configuration.password)
def test_configuration(self):
config = petstore_api.Configuration()
config.host = 'http://localhost/'
config.disabled_client_side_validations = ("multipleOf,maximum,exclusiveMaximum,minimum,exclusiveMinimum,"
"maxLength,minLength,pattern,maxItems,minItems")
with self.checkRaiseRegex(ValueError, "Invalid keyword: 'foo'"):
config.disabled_client_side_validations = 'foo'
config.disabled_client_side_validations = ""
def test_configuration(self):
config = petstore_api.Configuration()
config.host = 'http://localhost/'
config.api_key['api_key'] = '123456'
config.api_key_prefix['api_key'] = 'PREFIX'
config.username = '******'
config.password = '******'
header_params = {'test1': 'value1'}
query_params = {'test2': 'value2'}
auth_settings = ['api_key', 'unknown']
client = petstore_api.ApiClient(config)
# test prefix
self.assertEqual('PREFIX',
client.configuration.api_key_prefix['api_key'])
# update parameters based on auth setting
client.update_params_for_auth(header_params, query_params,
auth_settings)
# test api key auth
self.assertEqual(header_params['test1'], 'value1')
self.assertEqual(header_params['api_key'], 'PREFIX 123456')
self.assertEqual(query_params['test2'], 'value2')
# test basic auth
self.assertEqual('test_username', client.configuration.username)
self.assertEqual('test_password', client.configuration.password)
# test api key without prefix
config.api_key['api_key'] = '123456'
config.api_key_prefix['api_key'] = None
# update parameters based on auth setting
client.update_params_for_auth(header_params, query_params,
auth_settings)
self.assertEqual(header_params['api_key'], '123456')
# test api key with empty prefix
config.api_key['api_key'] = '123456'
config.api_key_prefix['api_key'] = ''
# update parameters based on auth setting
client.update_params_for_auth(header_params, query_params,
auth_settings)
self.assertEqual(header_params['api_key'], '123456')
# test api key with prefix specified in the api_key, useful when the prefix
# must include '=' sign followed by the API key secret without space.
config.api_key['api_key'] = 'PREFIX=123456'
config.api_key_prefix['api_key'] = None
# update parameters based on auth setting
client.update_params_for_auth(header_params, query_params,
auth_settings)
self.assertEqual(header_params['api_key'], 'PREFIX=123456')
def testDefaultConfiguration(self):
# prepare default configuration
c1 = petstore_api.Configuration(host="example.com")
c1.debug = True
petstore_api.Configuration.set_default(c1)
# get default configuration
c2 = petstore_api.Configuration.get_default_copy()
self.assertEqual(c2.host, "example.com")
self.assertTrue(c2.debug)
self.assertNotEqual(id(c1.api_key), id(c2.api_key))
self.assertNotEqual(id(c1.api_key_prefix), id(c2.api_key_prefix))
def test_socket_options_get_passed_to_pool_manager(self):
socket_options = ["extra", "socket", "options"]
config = petstore_api.Configuration(host="HOST")
config.socket_options = socket_options
with patch("petstore_api.rest.urllib3.PoolManager", StubPoolManager):
api_client = petstore_api.ApiClient(config)
# urllib3.PoolManager promises to pass socket_options in kwargs
# to the underlying socket. So asserting that our manager
# gets it is a good start
assert api_client.rest_client.pool_manager.actual_kwargs[
"socket_options"] == socket_options
def test_servers(self):
config = petstore_api.Configuration(server_index=1, server_variables={'version': 'v1'})
api_client = petstore_api.ApiClient(config)
api = pet_api.PetApi(api_client)
def request(expected_url, method, url, **kwargs):
assert expected_url == url
raise RuntimeError('pass')
api_client.request = functools.partial(request, 'http://path-server-test.petstore.local/v2/pet')
try:
api.add_pet({'name': 'pet', 'photo_urls': []})
except RuntimeError as e:
assert "pass" == str(e)
api_client.request = functools.partial(request, 'https://localhost:8080/v1/pet/123456789')
try:
api.delete_pet(123456789)
except RuntimeError as e:
assert "pass" == str(e)
class TestFakeApi(unittest.TestCase):
"""FakeApi unit test stubs"""
json_content_type = 'application/json'
configuration = petstore_api.Configuration()
api = FakeApi(api_client=api_client.ApiClient(configuration=configuration))
@staticmethod
def headers_for_content_type(content_type: str) -> dict[str, str]:
return {'content-type': content_type}
@classmethod
def __response(cls,
body: typing.Union[str, bytes],
status: int = 200,
content_type: str = json_content_type,
headers: typing.Optional[dict[str, str]] = None,
preload_content: bool = True) -> urllib3.HTTPResponse:
if headers is None:
headers = {}
headers.update(cls.headers_for_content_type(content_type))
return urllib3.HTTPResponse(body,
headers=headers,
status=status,
preload_content=preload_content)
@staticmethod
def __json_bytes(in_data: typing.Any) -> bytes:
return json.dumps(in_data, separators=(",", ":"),
ensure_ascii=False).encode('utf-8')
@staticmethod
def __assert_request_called_with(
mock_request,
url: str,
method: str = 'POST',
body: typing.Optional[bytes] = None,
content_type: typing.Optional[str] = 'application/json',
fields: typing.Optional[tuple[api_client.RequestField, ...]] = None,
accept_content_type: str = 'application/json',
stream: bool = False,
query_params: typing.Optional[typing.Tuple[typing.Tuple[str, str],
...]] = None):
headers = {
'Accept': accept_content_type,
'User-Agent': 'OpenAPI-Generator/1.0.0/python'
}
if content_type:
headers['Content-Type'] = content_type
kwargs = dict(
headers=HTTPHeaderDict(headers),
query_params=query_params,
fields=fields,
stream=stream,
timeout=None,
)
if method != 'GET':
kwargs['body'] = body
mock_request.assert_called_with(method, url, **kwargs)
def test_array_model(self):
from petstore_api.model import animal_farm, animal
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
json_data = [{"className": "Cat", "color": "black"}]
mock_request.return_value = self.__response(
self.__json_bytes(json_data))
cat = animal.Animal(className="Cat", color="black")
body = animal_farm.AnimalFarm([cat])
api_response = self.api.array_model(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/arraymodel',
body=self.__json_bytes(json_data))
assert isinstance(api_response.body, animal_farm.AnimalFarm)
assert api_response.body == body
def test_recursionlimit(self):
"""Test case for recursionlimit
"""
assert sys.getrecursionlimit() == 1234
def test_array_of_enums(self):
from petstore_api.model import array_of_enums, string_enum
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
value = [string_enum.StringEnum("placed")]
body = array_of_enums.ArrayOfEnums(value)
value_simple = ["placed"]
mock_request.return_value = self.__response(
self.__json_bytes(value_simple))
api_response = self.api.array_of_enums(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/array-of-enums',
body=self.__json_bytes(value_simple))
assert isinstance(api_response.body, array_of_enums.ArrayOfEnums)
assert api_response.body == body
def test_number_with_validations(self):
from petstore_api.model import number_with_validations
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
value = 10.0
body = number_with_validations.NumberWithValidations(value)
mock_request.return_value = self.__response(
self.__json_bytes(value))
api_response = self.api.number_with_validations(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/number',
body=self.__json_bytes(value))
assert isinstance(api_response.body,
number_with_validations.NumberWithValidations)
assert api_response.body == value
def test_composed_one_of_different_types(self):
from petstore_api.model import composed_one_of_different_types
# serialization + deserialization works
number = composed_one_of_different_types.ComposedOneOfDifferentTypes(
10.0)
cat = composed_one_of_different_types.ComposedOneOfDifferentTypes(
className="Cat", color="black")
none_instance = composed_one_of_different_types.ComposedOneOfDifferentTypes(
None)
date_instance = composed_one_of_different_types.ComposedOneOfDifferentTypes(
'1970-01-01')
cast_to_simple_value = [
(number, 10.0),
(cat, {
"className": "Cat",
"color": "black"
}),
(none_instance, None),
(date_instance, '1970-01-01'),
]
for (body, value_simple) in cast_to_simple_value:
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(value_simple))
api_response = self.api.composed_one_of_different_types(
body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/composed_one_of_number_with_validations',
body=self.__json_bytes(value_simple))
assert isinstance(
api_response.body, composed_one_of_different_types.
ComposedOneOfDifferentTypes)
assert api_response.body == body
# inputting the uncast values into the endpoint also works
for (body, value_simple) in cast_to_simple_value:
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(value_simple))
api_response = self.api.composed_one_of_different_types(
body=value_simple)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/composed_one_of_number_with_validations',
body=self.__json_bytes(value_simple))
assert isinstance(
api_response.body, composed_one_of_different_types.
ComposedOneOfDifferentTypes)
assert api_response.body == body
def test_string(self):
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
body = "blah"
value_simple = body
mock_request.return_value = self.__response(
self.__json_bytes(value_simple))
api_response = self.api.string(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/string',
body=self.__json_bytes(value_simple))
assert isinstance(api_response.body, str)
assert api_response.body == value_simple
def test_string_enum(self):
from petstore_api.model import string_enum
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
value = "placed"
body = string_enum.StringEnum(value)
mock_request.return_value = self.__response(
self.__json_bytes(value))
api_response = self.api.string_enum(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/enum',
body=self.__json_bytes(value))
assert isinstance(api_response.body, string_enum.StringEnum)
assert api_response.body == value
def test_mammal(self):
# serialization + deserialization works
from petstore_api.model.mammal import Mammal
with patch.object(RESTClientObject, 'request') as mock_request:
body = Mammal(className="BasquePig")
value_simple = dict(className='BasquePig')
mock_request.return_value = self.__response(
self.__json_bytes(value_simple))
api_response = self.api.mammal(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/mammal',
body=self.__json_bytes(value_simple))
assert isinstance(api_response.body, Mammal)
assert api_response.body == value_simple
def test_missing_or_unset_required_body(self):
# missing required body
with self.assertRaises(TypeError):
self.api.mammal()
# required body may not be unset
with self.assertRaises(petstore_api.ApiValueError):
self.api.mammal(body=schemas.unset)
def test_missing_or_unset_required_query_parameter(self):
from petstore_api.model.user import User
user = User({})
# missing required query param
with self.assertRaises(petstore_api.ApiTypeError):
self.api.body_with_query_params(body=user)
# required query param may not be unset
with self.assertRaises(petstore_api.ApiValueError):
self.api.body_with_query_params(
body=schemas.unset, query_params=dict(query=schemas.unset))
def test_upload_download_file_tx_bytes_and_file(self):
"""Test case for upload_download_file
uploads a file and downloads a file using application/octet-stream # noqa: E501
"""
import os
test_file_dir = os.path.realpath(
os.path.join(os.path.dirname(__file__), "..", "testfiles"))
file_name = '1px_pic1.png'
file_path1 = os.path.join(test_file_dir, file_name)
with open(file_path1, "rb") as some_file:
file_bytes = some_file.read()
file1 = open(file_path1, "rb")
mock_response = self.__response(
file_bytes, content_type='application/octet-stream')
try:
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = mock_response
api_response = self.api.upload_download_file(body=file1)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadDownloadFile',
body=file_bytes,
content_type='application/octet-stream',
accept_content_type='application/octet-stream')
self.assertTrue(
isinstance(api_response.body, schemas.BinarySchema))
self.assertTrue(
isinstance(api_response.body, schemas.BytesSchema))
self.assertTrue(isinstance(api_response.body, bytes))
self.assertEqual(api_response.body, file_bytes)
except petstore_api.ApiException as e:
self.fail("upload_file() raised {0} unexpectedly".format(type(e)))
finally:
file1.close()
# sending just bytes works also
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = mock_response
api_response = self.api.upload_download_file(body=file_bytes)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadDownloadFile',
body=file_bytes,
content_type='application/octet-stream',
accept_content_type='application/octet-stream')
self.assertEqual(api_response.body, file_bytes)
def test_upload_download_file_rx_file(self):
import os
test_file_dir = os.path.realpath(
os.path.join(os.path.dirname(__file__), "..", "testfiles"))
file_name = '1px_pic1.png'
file_path1 = os.path.join(test_file_dir, file_name)
with open(file_path1, "rb") as some_file:
file_bytes = some_file.read()
# passing in file1 as the response body simulates a streamed response
file1 = open(file_path1, "rb")
class StreamableBody:
"""
This class simulates http.client.HTTPResponse for a streamable response
"""
def __init__(self, file: io.BufferedReader):
self.fp = file
def read(self, *args, **kwargs):
return self.fp.read(*args, **kwargs)
def close(self):
self.fp.close()
streamable_body = StreamableBody(file1)
mock_response = self.__response(
streamable_body,
content_type='application/octet-stream',
preload_content=False)
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = mock_response
api_response = self.api.upload_download_file(body=file_bytes,
stream=True)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadDownloadFile',
body=file_bytes,
content_type='application/octet-stream',
accept_content_type='application/octet-stream',
stream=True)
self.assertTrue(file1.closed)
self.assertTrue(isinstance(api_response.body, schemas.BinarySchema))
self.assertTrue(isinstance(api_response.body, schemas.FileSchema))
self.assertTrue(isinstance(api_response.body, schemas.FileIO))
self.assertEqual(api_response.body.read(), file_bytes)
api_response.body.close()
os.unlink(api_response.body.name)
file1 = open(file_path1, "rb")
streamable_body = StreamableBody(file1)
saved_file_name = "fileName.abc"
"""
when streaming is used and the response contains the content disposition header with a filename
that filename is used when saving the file locally
"""
mock_response = self.__response(
streamable_body,
content_type='application/octet-stream',
headers={
'content-disposition':
f'attachment; filename="{saved_file_name}"'
},
preload_content=False)
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = mock_response
api_response = self.api.upload_download_file(body=file_bytes,
stream=True)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadDownloadFile',
body=file_bytes,
content_type='application/octet-stream',
accept_content_type='application/octet-stream',
stream=True)
self.assertTrue(file1.closed)
self.assertTrue(isinstance(api_response.body, schemas.BinarySchema))
self.assertTrue(isinstance(api_response.body, schemas.FileSchema))
self.assertTrue(isinstance(api_response.body, schemas.FileIO))
self.assertTrue(api_response.body.name.endswith(saved_file_name))
self.assertEqual(api_response.body.read(), file_bytes)
api_response.body.close()
os.unlink(api_response.body.name)
def test_upload_file(self):
"""Test case for upload_file
uploads a file using multipart/form-data # noqa: E501
"""
import os
test_file_dir = os.path.realpath(
os.path.join(os.path.dirname(__file__), "..", "testfiles"))
file_name = '1px_pic1.png'
file_path1 = os.path.join(test_file_dir, file_name)
with open(file_path1, "rb") as some_file:
file_bytes = some_file.read()
file1 = open(file_path1, "rb")
response_json = {
'code': 200,
'type': 'blah',
'message': 'file upload succeeded'
}
try:
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(response_json))
api_response = self.api.upload_file(body={'file': file1})
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadFile',
fields=(api_client.RequestField(
name='file',
data=file_bytes,
filename=file_name,
headers={'Content-Type':
'application/octet-stream'}), ),
content_type='multipart/form-data')
self.assertEqual(api_response.body, response_json)
except petstore_api.ApiException as e:
self.fail("upload_file() raised {0} unexpectedly".format(type(e)))
finally:
file1.close()
# sending just bytes works also
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(response_json))
api_response = self.api.upload_file(body={'file': file_bytes})
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadFile',
fields=(api_client.RequestField(
name='file',
data=file_bytes,
headers={'Content-Type': 'application/octet-stream'}), ),
content_type='multipart/form-data')
self.assertEqual(api_response.body, response_json)
# passing in an array of files to when file only allows one
# raises an exceptions
try:
file = open(file_path1, "rb")
with self.assertRaises(petstore_api.ApiTypeError):
self.api.upload_file(body={'file': [file]})
finally:
file.close()
# passing in a closed file raises an exception
with self.assertRaises(ValueError):
file = open(file_path1, "rb")
file.close()
self.api.upload_file(body={'file': file})
def test_upload_files(self):
"""Test case for upload_files
uploads files using multipart/form-data # noqa: E501
"""
import os
test_file_dir = os.path.realpath(
os.path.join(os.path.dirname(__file__), "..", "testfiles"))
file_name = '1px_pic1.png'
file_path1 = os.path.join(test_file_dir, file_name)
with open(file_path1, "rb") as some_file:
file_bytes = some_file.read()
file1 = open(file_path1, "rb")
response_json = {
'code': 200,
'type': 'blah',
'message': 'file upload succeeded'
}
try:
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(response_json))
api_response = self.api.upload_files(
body={'files': [file1, file1]})
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadFiles',
fields=(
api_client.RequestField(name='files',
data=file_bytes,
filename=file_name,
headers={
'Content-Type':
'application/octet-stream'
}),
api_client.RequestField(name='files',
data=file_bytes,
filename=file_name,
headers={
'Content-Type':
'application/octet-stream'
}),
),
content_type='multipart/form-data')
self.assertEqual(api_response.body, response_json)
except petstore_api.ApiException as e:
self.fail("upload_file() raised {0} unexpectedly".format(type(e)))
finally:
file1.close()
# sending just bytes works also
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(response_json))
api_response = self.api.upload_files(
body={'files': [file_bytes, file_bytes]})
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadFiles',
fields=(
api_client.RequestField(
name='files',
data=file_bytes,
headers={'Content-Type': 'application/octet-stream'}),
api_client.RequestField(
name='files',
data=file_bytes,
headers={'Content-Type': 'application/octet-stream'}),
),
content_type='multipart/form-data')
self.assertEqual(api_response.body, response_json)
@staticmethod
def __encode_multipart_formdata(
fields: typing.Dict[str, typing.Any]) -> multipart.MIMEMultipart:
m = multipart.MIMEMultipart("form-data")
for field, value in fields.items():
data = MIMEFormdata(field, "text", "plain")
# data.set_payload(value, charset='us-ascii')
data.set_payload(value)
m.attach(data)
return m
# comment out below for the time being after adding better inline model support
# ref: https://github.com/OpenAPITools/openapi-generator/pull/12104
#
#@patch.object(RESTClientObject, 'request')
#def test_inline_composition(self, mock_request):
# """Test case for inline_composition
# testing composed schemas at inline locations # noqa: E501
# """
# single_char_str = 'a'
# json_bytes = self.__json_bytes(single_char_str)
# # tx and rx json with composition at root level of schema for request + response body
# content_type = 'application/json'
# mock_request.return_value = self.__response(
# json_bytes
# )
# api_response = self.api.inline_composition(
# body=single_char_str,
# query_params={
# 'compositionAtRoot': single_char_str,
# 'compositionInProperty': {'someProp': single_char_str}
# },
# accept_content_types=(content_type,)
# )
# self.__assert_request_called_with(
# mock_request,
# 'http://petstore.swagger.io:80/v2/fake/inlineComposition/',
# accept_content_type=content_type,
# content_type=content_type,
# query_params=(('compositionAtRoot', 'a'), ('someProp', 'a')),
# body=json_bytes
# )
# self.assertEqual(api_response.body, single_char_str)
# self.assertTrue(isinstance(api_response.body, schemas.StrSchema))
# # tx and rx json with composition at property level of schema for request + response body
# content_type = 'multipart/form-data'
# multipart_response = self.__encode_multipart_formdata(fields={'someProp': single_char_str})
# mock_request.return_value = self.__response(
# bytes(multipart_response),
# content_type=multipart_response.get_content_type()
# )
# api_response = self.api.inline_composition(
# body={'someProp': single_char_str},
# query_params={
# 'compositionAtRoot': single_char_str,
# 'compositionInProperty': {'someProp': single_char_str}
# },
# content_type=content_type,
# accept_content_types=(content_type,)
# )
# self.__assert_request_called_with(
# mock_request,
# 'http://petstore.swagger.io:80/v2/fake/inlineComposition/',
# accept_content_type=content_type,
# content_type=content_type,
# query_params=(('compositionAtRoot', 'a'), ('someProp', 'a')),
# fields=(
# api_client.RequestField(
# name='someProp',
# data=single_char_str,
# headers={'Content-Type': 'text/plain'}
# ),
# ),
# )
# self.assertEqual(api_response.body, {'someProp': single_char_str})
# self.assertTrue(isinstance(api_response.body.someProp, schemas.StrSchema))
# # error thrown when a str is input which doesn't meet the composed schema length constraint
# invalid_value = ''
# variable_locations = 4
# for invalid_index in range(variable_locations):
# values = [single_char_str]*variable_locations
# values[invalid_index] = invalid_value
# with self.assertRaises(exceptions.ApiValueError):
# multipart_response = self.__encode_multipart_formdata(fields={'someProp': values[0]})
# mock_request.return_value = self.__response(
# bytes(multipart_response),
# content_type=multipart_response.get_content_type()
# )
# self.api.inline_composition(
# body={'someProp': values[1]},
# query_params={
# 'compositionAtRoot': values[2],
# 'compositionInProperty': {'someProp': values[3]}
# },
# content_type=content_type,
# accept_content_types=(content_type,)
# )
def test_json_with_charset(self):
# serialization + deserialization of json with charset works
with patch.object(RESTClientObject, 'request') as mock_request:
body = None
content_type_with_charset = 'application/json; charset=utf-8'
mock_request.return_value = self.__response(
self.__json_bytes(body),
content_type=content_type_with_charset)
api_response = self.api.json_with_charset(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/jsonWithCharset',
body=self.__json_bytes(body),
content_type=content_type_with_charset,
accept_content_type=content_type_with_charset)
assert isinstance(api_response.body, schemas.AnyTypeSchema)
assert isinstance(api_response.body, schemas.NoneClass)
assert api_response.body.is_none()
def test_response_without_schema(self):
# received response is not loaded into body because there is no deserialization schema defined
with patch.object(RESTClientObject, 'request') as mock_request:
body = None
content_type = 'application/json'
mock_request.return_value = self.__response(
self.__json_bytes(body), )
api_response = self.api.response_without_schema()
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/responseWithoutSchema',
method='GET',
accept_content_type='application/json, application/xml',
content_type=None)
assert isinstance(api_response.body, schemas.Unset)
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
'blah', content_type='text/plain')
# when an incorrect content-type is sent back, and exception is raised
with self.assertRaises(exceptions.ApiValueError):
self.api.response_without_schema()
class TestFakeApi(unittest.TestCase):
"""FakeApi unit test stubs"""
json_content_type = 'application/json'
configuration = petstore_api.Configuration()
api = FakeApi(api_client=api_client.ApiClient(configuration=configuration))
@staticmethod
def headers_for_content_type(content_type: str) -> dict[str, str]:
return {'content-type': content_type}
@classmethod
def __response(cls,
body: typing.Union[str, bytes],
status: int = 200,
content_type: str = json_content_type,
headers: typing.Optional[dict[str, str]] = None,
preload_content: bool = True) -> urllib3.HTTPResponse:
if headers is None:
headers = {}
headers.update(cls.headers_for_content_type(content_type))
return urllib3.HTTPResponse(body,
headers=headers,
status=status,
preload_content=preload_content)
@staticmethod
def __json_bytes(in_data: typing.Any) -> bytes:
return json.dumps(in_data, separators=(",", ":"),
ensure_ascii=False).encode('utf-8')
@staticmethod
def __assert_request_called_with(
mock_request,
url: str,
body: typing.Optional[bytes] = None,
content_type: str = 'application/json',
fields: typing.Optional[tuple[api_client.RequestField, ...]] = None,
accept_content_type: str = 'application/json',
stream: bool = False,
):
mock_request.assert_called_with(
'POST',
url,
headers=HTTPHeaderDict({
'Accept':
accept_content_type,
'Content-Type':
content_type,
'User-Agent':
'OpenAPI-Generator/1.0.0/python'
}),
body=body,
query_params=None,
fields=fields,
stream=stream,
timeout=None,
)
def test_array_model(self):
from petstore_api.model import animal_farm, animal
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
json_data = [{"className": "Cat", "color": "black"}]
mock_request.return_value = self.__response(
self.__json_bytes(json_data))
cat = animal.Animal(className="Cat", color="black")
body = animal_farm.AnimalFarm([cat])
api_response = self.api.array_model(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/arraymodel',
body=self.__json_bytes(json_data))
assert isinstance(api_response.body, animal_farm.AnimalFarm)
assert api_response.body == body
def test_recursionlimit(self):
"""Test case for recursionlimit
"""
assert sys.getrecursionlimit() == 1234
def test_array_of_enums(self):
from petstore_api.model import array_of_enums, string_enum
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
value = [string_enum.StringEnum("placed")]
body = array_of_enums.ArrayOfEnums(value)
value_simple = ["placed"]
mock_request.return_value = self.__response(
self.__json_bytes(value_simple))
api_response = self.api.array_of_enums(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/array-of-enums',
body=self.__json_bytes(value_simple))
assert isinstance(api_response.body, array_of_enums.ArrayOfEnums)
assert api_response.body == body
def test_number_with_validations(self):
from petstore_api.model import number_with_validations
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
value = 10.0
body = number_with_validations.NumberWithValidations(value)
mock_request.return_value = self.__response(
self.__json_bytes(value))
api_response = self.api.number_with_validations(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/number',
body=self.__json_bytes(value))
assert isinstance(api_response.body,
number_with_validations.NumberWithValidations)
assert api_response.body == value
def test_composed_one_of_different_types(self):
from petstore_api.model import composed_one_of_different_types
# serialization + deserialization works
number = composed_one_of_different_types.ComposedOneOfDifferentTypes(
10.0)
cat = composed_one_of_different_types.ComposedOneOfDifferentTypes(
className="Cat", color="black")
none_instance = composed_one_of_different_types.ComposedOneOfDifferentTypes(
None)
date_instance = composed_one_of_different_types.ComposedOneOfDifferentTypes(
'1970-01-01')
cast_to_simple_value = [
(number, 10.0),
(cat, {
"className": "Cat",
"color": "black"
}),
(none_instance, None),
(date_instance, '1970-01-01'),
]
for (body, value_simple) in cast_to_simple_value:
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(value_simple))
api_response = self.api.composed_one_of_different_types(
body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/composed_one_of_number_with_validations',
body=self.__json_bytes(value_simple))
assert isinstance(
api_response.body, composed_one_of_different_types.
ComposedOneOfDifferentTypes)
assert api_response.body == body
# inputting the uncast values into the endpoint also works
for (body, value_simple) in cast_to_simple_value:
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(value_simple))
api_response = self.api.composed_one_of_different_types(
body=value_simple)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/composed_one_of_number_with_validations',
body=self.__json_bytes(value_simple))
assert isinstance(
api_response.body, composed_one_of_different_types.
ComposedOneOfDifferentTypes)
assert api_response.body == body
def test_string(self):
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
body = "blah"
value_simple = body
mock_request.return_value = self.__response(
self.__json_bytes(value_simple))
api_response = self.api.string(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/string',
body=self.__json_bytes(value_simple))
assert isinstance(api_response.body, str)
assert api_response.body == value_simple
def test_string_enum(self):
from petstore_api.model import string_enum
# serialization + deserialization works
with patch.object(RESTClientObject, 'request') as mock_request:
value = "placed"
body = string_enum.StringEnum(value)
mock_request.return_value = self.__response(
self.__json_bytes(value))
api_response = self.api.string_enum(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/enum',
body=self.__json_bytes(value))
assert isinstance(api_response.body, string_enum.StringEnum)
assert api_response.body == value
def test_mammal(self):
# serialization + deserialization works
from petstore_api.model.mammal import Mammal
with patch.object(RESTClientObject, 'request') as mock_request:
body = Mammal(className="BasquePig")
value_simple = dict(className='BasquePig')
mock_request.return_value = self.__response(
self.__json_bytes(value_simple))
api_response = self.api.mammal(body=body)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/refs/mammal',
body=self.__json_bytes(value_simple))
assert isinstance(api_response.body, Mammal)
assert api_response.body == value_simple
def test_missing_or_unset_required_body(self):
# missing required body
with self.assertRaises(TypeError):
self.api.mammal()
# required body may not be unset
with self.assertRaises(petstore_api.ApiValueError):
self.api.mammal(body=schemas.unset)
def test_missing_or_unset_required_query_parameter(self):
from petstore_api.model.user import User
user = User({})
# missing required query param
with self.assertRaises(petstore_api.ApiTypeError):
self.api.body_with_query_params(body=user)
# required query param may not be unset
with self.assertRaises(petstore_api.ApiValueError):
self.api.body_with_query_params(
body=schemas.unset, query_params=dict(query=schemas.unset))
def test_upload_download_file_tx_bytes_and_file(self):
"""Test case for upload_download_file
uploads a file and downloads a file using application/octet-stream # noqa: E501
"""
import os
test_file_dir = os.path.realpath(
os.path.join(os.path.dirname(__file__), "..", "testfiles"))
file_name = '1px_pic1.png'
file_path1 = os.path.join(test_file_dir, file_name)
with open(file_path1, "rb") as some_file:
file_bytes = some_file.read()
file1 = open(file_path1, "rb")
mock_response = self.__response(
file_bytes, content_type='application/octet-stream')
try:
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = mock_response
api_response = self.api.upload_download_file(body=file1)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadDownloadFile',
body=file_bytes,
content_type='application/octet-stream',
accept_content_type='application/octet-stream')
self.assertTrue(
isinstance(api_response.body, schemas.BinarySchema))
self.assertTrue(
isinstance(api_response.body, schemas.BytesSchema))
self.assertTrue(isinstance(api_response.body, bytes))
self.assertEqual(api_response.body, file_bytes)
except petstore_api.ApiException as e:
self.fail("upload_file() raised {0} unexpectedly".format(type(e)))
finally:
file1.close()
# sending just bytes works also
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = mock_response
api_response = self.api.upload_download_file(body=file_bytes)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadDownloadFile',
body=file_bytes,
content_type='application/octet-stream',
accept_content_type='application/octet-stream')
self.assertEqual(api_response.body, file_bytes)
def test_upload_download_file_rx_file(self):
import os
test_file_dir = os.path.realpath(
os.path.join(os.path.dirname(__file__), "..", "testfiles"))
file_name = '1px_pic1.png'
file_path1 = os.path.join(test_file_dir, file_name)
with open(file_path1, "rb") as some_file:
file_bytes = some_file.read()
# passing in file1 as the response body simulates a streamed response
file1 = open(file_path1, "rb")
class StreamableBody:
"""
This class simulates http.client.HTTPResponse for a streamable response
"""
def __init__(self, file: io.BufferedReader):
self.fp = file
def read(self, *args, **kwargs):
return self.fp.read(*args, **kwargs)
def close(self):
self.fp.close()
streamable_body = StreamableBody(file1)
mock_response = self.__response(
streamable_body,
content_type='application/octet-stream',
preload_content=False)
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = mock_response
api_response = self.api.upload_download_file(body=file_bytes,
stream=True)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadDownloadFile',
body=file_bytes,
content_type='application/octet-stream',
accept_content_type='application/octet-stream',
stream=True)
self.assertTrue(file1.closed)
self.assertTrue(isinstance(api_response.body, schemas.BinarySchema))
self.assertTrue(isinstance(api_response.body, schemas.FileSchema))
self.assertTrue(isinstance(api_response.body, schemas.FileIO))
self.assertEqual(api_response.body.read(), file_bytes)
api_response.body.close()
os.unlink(api_response.body.name)
file1 = open(file_path1, "rb")
streamable_body = StreamableBody(file1)
saved_file_name = "fileName.abc"
"""
when streaming is used and the response contains the content disposition header with a filename
that filename is used when saving the file locally
"""
mock_response = self.__response(
streamable_body,
content_type='application/octet-stream',
headers={
'content-disposition':
f'attachment; filename="{saved_file_name}"'
},
preload_content=False)
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = mock_response
api_response = self.api.upload_download_file(body=file_bytes,
stream=True)
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadDownloadFile',
body=file_bytes,
content_type='application/octet-stream',
accept_content_type='application/octet-stream',
stream=True)
self.assertTrue(file1.closed)
self.assertTrue(isinstance(api_response.body, schemas.BinarySchema))
self.assertTrue(isinstance(api_response.body, schemas.FileSchema))
self.assertTrue(isinstance(api_response.body, schemas.FileIO))
self.assertTrue(api_response.body.name.endswith(saved_file_name))
self.assertEqual(api_response.body.read(), file_bytes)
api_response.body.close()
os.unlink(api_response.body.name)
def test_upload_file(self):
"""Test case for upload_file
uploads a file using multipart/form-data # noqa: E501
"""
import os
test_file_dir = os.path.realpath(
os.path.join(os.path.dirname(__file__), "..", "testfiles"))
file_name = '1px_pic1.png'
file_path1 = os.path.join(test_file_dir, file_name)
with open(file_path1, "rb") as some_file:
file_bytes = some_file.read()
file1 = open(file_path1, "rb")
response_json = {
'code': 200,
'type': 'blah',
'message': 'file upload succeeded'
}
try:
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(response_json))
api_response = self.api.upload_file(body={'file': file1})
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadFile',
fields=(api_client.RequestField(
name='file',
data=file_bytes,
filename=file_name,
headers={'Content-Type':
'application/octet-stream'}), ),
content_type='multipart/form-data')
self.assertEqual(api_response.body, response_json)
except petstore_api.ApiException as e:
self.fail("upload_file() raised {0} unexpectedly".format(type(e)))
finally:
file1.close()
# sending just bytes works also
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(response_json))
api_response = self.api.upload_file(body={'file': file_bytes})
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadFile',
fields=(api_client.RequestField(
name='file',
data=file_bytes,
headers={'Content-Type': 'application/octet-stream'}), ),
content_type='multipart/form-data')
self.assertEqual(api_response.body, response_json)
# passing in an array of files to when file only allows one
# raises an exceptions
try:
file = open(file_path1, "rb")
with self.assertRaises(petstore_api.ApiTypeError):
self.api.upload_file(body={'file': [file]})
finally:
file.close()
# passing in a closed file raises an exception
with self.assertRaises(ValueError):
file = open(file_path1, "rb")
file.close()
self.api.upload_file(body={'file': file})
def test_upload_files(self):
"""Test case for upload_files
uploads files using multipart/form-data # noqa: E501
"""
import os
test_file_dir = os.path.realpath(
os.path.join(os.path.dirname(__file__), "..", "testfiles"))
file_name = '1px_pic1.png'
file_path1 = os.path.join(test_file_dir, file_name)
with open(file_path1, "rb") as some_file:
file_bytes = some_file.read()
file1 = open(file_path1, "rb")
response_json = {
'code': 200,
'type': 'blah',
'message': 'file upload succeeded'
}
try:
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(response_json))
api_response = self.api.upload_files(
body={'files': [file1, file1]})
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadFiles',
fields=(
api_client.RequestField(name='files',
data=file_bytes,
filename=file_name,
headers={
'Content-Type':
'application/octet-stream'
}),
api_client.RequestField(name='files',
data=file_bytes,
filename=file_name,
headers={
'Content-Type':
'application/octet-stream'
}),
),
content_type='multipart/form-data')
self.assertEqual(api_response.body, response_json)
except petstore_api.ApiException as e:
self.fail("upload_file() raised {0} unexpectedly".format(type(e)))
finally:
file1.close()
# sending just bytes works also
with patch.object(RESTClientObject, 'request') as mock_request:
mock_request.return_value = self.__response(
self.__json_bytes(response_json))
api_response = self.api.upload_files(
body={'files': [file_bytes, file_bytes]})
self.__assert_request_called_with(
mock_request,
'http://petstore.swagger.io:80/v2/fake/uploadFiles',
fields=(
api_client.RequestField(
name='files',
data=file_bytes,
headers={'Content-Type': 'application/octet-stream'}),
api_client.RequestField(
name='files',
data=file_bytes,
headers={'Content-Type': 'application/octet-stream'}),
),
content_type='multipart/form-data')
self.assertEqual(api_response.body, response_json)
def test_multiple_of_deserialization(self):
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer': 30,
'number': 65.0,
'float': 62.4,
}
from petstore_api.model import format_test
_response_for_200 = api_client.OpenApiResponse(content={
self.json_content_type:
api_client.MediaType(schema=format_test.FormatTest),
}, )
response = self.__response(data)
deserialized = _response_for_200.deserialize(response,
self.configuration)
self.assertTrue(isinstance(deserialized.body, format_test.FormatTest))
with self.assertRaisesRegex(
petstore_api.exceptions.ApiValueError,
r"Invalid value `31`, value must be a multiple of `2` at \('args\[0\]', 'integer'\)"
):
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer':
31, # Value is supposed to be multiple of '2'. An error must be raised
'number': 65.0,
'float': 62.4,
}
response = self.__response(data)
_response_for_200.deserialize(response, self.configuration)
# Disable JSON schema validation. No error should be raised during deserialization.
configuration = petstore_api.Configuration()
configuration.disabled_client_side_validations = "multipleOf"
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer': 31, # Value is supposed to be multiple of '2'
'number': 65.0,
'float': 62.4,
}
response = self.__response(data)
deserialized = _response_for_200.deserialize(response, configuration)
self.assertTrue(isinstance(deserialized.body, format_test.FormatTest))
# Disable JSON schema validation but for a different keyword.
# An error should be raised during deserialization.
configuration = petstore_api.Configuration()
configuration.disabled_client_side_validations = "maxItems"
with self.assertRaisesRegex(
petstore_api.exceptions.ApiValueError,
r"Invalid value `31`, value must be a multiple of `2` at \('args\[0\]', 'integer'\)"
):
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer': 31, # Value is supposed to be multiple of '2'
'number': 65.0,
'float': 62.4,
}
response = self.__response(data)
_response_for_200.deserialize(response, configuration)
class DeserializationTests(unittest.TestCase):
json_content_type = 'application/json'
json_content_type_headers = {'content-type': json_content_type}
configuration = petstore_api.Configuration()
@classmethod
def __response(cls, data: typing.Any) -> urllib3.HTTPResponse:
return urllib3.HTTPResponse(json.dumps(data).encode('utf-8'),
headers=cls.json_content_type_headers)
def test_deserialize_shape(self):
"""
deserialize Shape to an instance of:
- EquilateralTriangle
- IsoscelesTriangle
- IsoscelesTriangle
- ScaleneTriangle
- ComplexQuadrilateral
- SimpleQuadrilateral
by traveling through 2 discriminators
"""
from petstore_api.model import shape, equilateral_triangle
_response_for_200 = api_client.OpenApiResponse(content={
self.json_content_type:
api_client.MediaType(schema=shape.Shape),
}, )
data = {
'shapeType': 'Triangle',
'triangleType': 'EquilateralTriangle',
}
response = self.__response(data)
deserialized = _response_for_200.deserialize(response,
self.configuration)
body = deserialized.body
self.assertTrue(
isinstance(body, equilateral_triangle.EquilateralTriangle))
self.assertEqual(body.shapeType, 'Triangle')
self.assertEqual(body.triangleType, 'EquilateralTriangle')
# invalid quadrilateralType, second discriminator value
data = {
'shapeType': 'Quadrilateral',
'quadrilateralType': 'Triangle',
}
response = self.__response(data)
err_msg = (
r"Invalid discriminator value was passed in to Quadrilateral.quadrilateralType Only the values "
r"\['ComplexQuadrilateral', 'SimpleQuadrilateral'\] are allowed at \('args\[0\]', 'quadrilateralType'\)"
)
with self.assertRaisesRegex(petstore_api.ApiValueError, err_msg):
_response_for_200.deserialize(response, self.configuration)
def test_deserialize_animal(self):
"""
deserialize Animal to a Dog instance
Animal uses a discriminator which has a map built of child classes
that inherrit from Animal
This is the swagger (v2) way of doing something like oneOf composition
"""
from petstore_api.model import animal, dog
_response_for_200 = api_client.OpenApiResponse(content={
self.json_content_type:
api_client.MediaType(schema=animal.Animal),
}, )
data = {
'className': 'Dog',
'color': 'white',
'breed': 'Jack Russel Terrier'
}
response = self.__response(data)
deserialized = _response_for_200.deserialize(response,
self.configuration)
body = deserialized.body
self.assertTrue(isinstance(body, dog.Dog))
self.assertEqual(body.className, 'Dog')
self.assertEqual(body.color, 'white')
self.assertEqual(body.breed, 'Jack Russel Terrier')
def test_regex_constraint(self):
"""
Test regex pattern validation.
"""
from petstore_api.model import apple
# Test with valid regex pattern.
inst = apple.Apple(cultivar="Akane")
assert isinstance(inst, apple.Apple)
inst = apple.Apple(cultivar="Golden Delicious", origin="cHiLe")
assert isinstance(inst, apple.Apple)
# Test with invalid regex pattern.
err_regex = r"Invalid value `.+?`, must match regular expression `.+?` at \('args\[0\]', 'cultivar'\)"
with self.assertRaisesRegex(petstore_api.ApiValueError, err_regex):
inst = apple.Apple(cultivar="!@#%@$#Akane")
err_regex = r"Invalid value `.+?`, must match regular expression `.+?` at \('args\[0\]', 'origin'\)"
with self.assertRaisesRegex(petstore_api.ApiValueError, err_regex):
inst = apple.Apple(cultivar="Golden Delicious",
origin="!@#%@$#Chile")
def test_deserialize_mammal(self):
"""
deserialize mammal
mammal is a oneOf composed schema model with discriminator
"""
# whale test
from petstore_api.model import mammal, zebra, whale
_response_for_200 = api_client.OpenApiResponse(content={
self.json_content_type:
api_client.MediaType(schema=mammal.Mammal),
}, )
has_baleen = True
has_teeth = False
class_name = 'whale'
data = {
'hasBaleen': has_baleen,
'hasTeeth': has_teeth,
'className': class_name
}
response = self.__response(data)
deserialized = _response_for_200.deserialize(response,
self.configuration)
body = deserialized.body
self.assertTrue(isinstance(body, whale.Whale))
self.assertEqual(bool(body.hasBaleen), has_baleen)
self.assertEqual(bool(body.hasTeeth), has_teeth)
self.assertEqual(body.className, class_name)
# zebra test
zebra_type = 'plains'
class_name = 'zebra'
data = {'type': zebra_type, 'className': class_name}
response = self.__response(data)
deserialized = _response_for_200.deserialize(response,
self.configuration)
body = deserialized.body
self.assertTrue(isinstance(body, zebra.Zebra))
self.assertEqual(body.type, zebra_type)
self.assertEqual(body.className, class_name)
def test_deserialize_float_value(self):
"""
Deserialize floating point values.
"""
from petstore_api.model import banana
_response_for_200 = api_client.OpenApiResponse(content={
self.json_content_type:
api_client.MediaType(schema=banana.Banana),
}, )
data = {'lengthCm': 3.1415}
response = self.__response(data)
deserialized = _response_for_200.deserialize(response,
self.configuration)
body = deserialized.body
self.assertTrue(isinstance(body, banana.Banana))
self.assertTrue(isinstance(body.lengthCm, Decimal))
self.assertEqual(body.lengthCm, 3.1415)
"""
Float value is serialized without decimal point
The client receive it as an integer, which work because Banana.lengthCm is type number without format
Which accepts int AND float
"""
data = {'lengthCm': 3}
response = self.__response(data)
deserialized = _response_for_200.deserialize(response,
self.configuration)
body = deserialized.body
self.assertTrue(isinstance(body, banana.Banana))
self.assertTrue(isinstance(body.lengthCm, Decimal))
self.assertEqual(body.lengthCm, 3)
def test_deserialize_fruit_null_value(self):
"""
deserialize fruit with null value.
fruitReq is a oneOf composed schema model with discriminator, including 'null' type.
"""
from petstore_api.model import fruit_req
_response_for_200 = api_client.OpenApiResponse(content={
self.json_content_type:
api_client.MediaType(schema=fruit_req.FruitReq),
}, )
data = None
response = self.__response(data)
deserialized = _response_for_200.deserialize(response,
self.configuration)
self.assertTrue(isinstance(deserialized.body, fruit_req.FruitReq))
self.assertTrue(isinstance(deserialized.body, NoneClass))
def test_deserialize_with_additional_properties(self):
"""
Deserialize data with schemas that have the additionalProperties keyword.
Test conditions when additional properties are allowed, not allowed, have
specific types...
"""
# Dog is allOf with two child schemas.
# The OAS document for Dog does not specify the 'additionalProperties' keyword,
# which means that by default, the Dog schema must allow undeclared properties.
# The additionalProperties keyword is used to control the handling of extra stuff,
# that is, properties whose names are not listed in the properties keyword.
# By default any additional properties are allowed.
from petstore_api.model import dog, mammal, zebra, banana_req
data = {
'className': 'Dog',
'color': 'brown',
'breed': 'golden retriever',
# Below are additional, undeclared properties.
'group': 'Terrier Group',
'size': 'medium',
}
response = self.__response(data)
_response_for_200 = api_client.OpenApiResponse(content={
self.json_content_type:
api_client.MediaType(schema=dog.Dog),
}, )
deserialized = _response_for_200.deserialize(response,
self.configuration)
body = deserialized.body
self.assertTrue(isinstance(body, dog.Dog))
self.assertEqual(body.className, 'Dog')
self.assertEqual(body.color, 'brown')
self.assertEqual(body.breed, 'golden retriever')
self.assertEqual(body.group, 'Terrier Group')
self.assertEqual(body.size, 'medium')
# The 'zebra' schema allows additional properties by explicitly setting
# additionalProperties: true.
# This is equivalent to 'additionalProperties' not being present.
data = {
'className': 'zebra',
'type': 'plains',
# Below are additional, undeclared properties
'group': 'abc',
'size': 3,
'p1': True,
'p2': ['a', 'b', 123],
}
response = self.__response(data)
_response_for_200 = api_client.OpenApiResponse(content={
self.json_content_type:
api_client.MediaType(schema=mammal.Mammal),
}, )
deserialized = _response_for_200.deserialize(response,
self.configuration)
body = deserialized.body
self.assertTrue(isinstance(body, zebra.Zebra))
self.assertEqual(body.className, 'zebra')
self.assertEqual(body.type, 'plains')
self.assertEqual(bool(body.p1), True)
# The 'bananaReq' schema disallows additional properties by explicitly setting
# additionalProperties: false
_response_for_200 = api_client.OpenApiResponse(content={
self.json_content_type:
api_client.MediaType(schema=banana_req.BananaReq),
}, )
with self.assertRaisesRegex(
petstore_api.exceptions.ApiTypeError,
r"BananaReq was passed 1 invalid argument: \['unknown-group'\]"
):
data = {
'lengthCm': 21.2,
'sweet': False,
# Below are additional, undeclared properties. They are not allowed,
# an exception must be raised.
'unknown-group': 'abc',
}
response = self.__response(data)
_response_for_200.deserialize(response, self.configuration)
def test_deserialize_with_additional_properties_and_reference(self):
"""
Deserialize data with schemas that has the additionalProperties keyword
and the schema is specified as a reference ($ref).
"""
from petstore_api.model import drawing
_response_for_200 = api_client.OpenApiResponse(content={
self.json_content_type:
api_client.MediaType(schema=drawing.Drawing),
}, )
data = {
'mainShape': {
'shapeType': 'Triangle',
'triangleType': 'EquilateralTriangle',
},
'shapes': [
{
'shapeType': 'Triangle',
'triangleType': 'IsoscelesTriangle',
},
{
'shapeType': 'Quadrilateral',
'quadrilateralType': 'ComplexQuadrilateral',
},
],
'an_additional_prop': {
'lengthCm': 4,
'color': 'yellow'
}
}
response = self.__response(data)
_response_for_200.deserialize(response, self.configuration)
def test_deserialize_NumberWithValidations(self):
from petstore_api.model.number_with_validations import NumberWithValidations
from petstore_api.api.fake_api_endpoints.number_with_validations import _response_for_200
# make sure that an exception is thrown on an invalid type value
with self.assertRaises(petstore_api.ApiTypeError):
response = self.__response('test str')
_response_for_200.deserialize(response, self.configuration)
# make sure that an exception is thrown on an invalid value
with self.assertRaises(petstore_api.ApiValueError):
response = self.__response(21.0)
_response_for_200.deserialize(response, self.configuration)
# valid value works
number_val = 11.0
response = self.__response(number_val)
response = _response_for_200.deserialize(response, self.configuration)
self.assertTrue(isinstance(response.body, NumberWithValidations))
self.assertEqual(response.body, number_val)
def test_array_of_enums(self):
from petstore_api.model.array_of_enums import ArrayOfEnums
from petstore_api.api.fake_api_endpoints.array_of_enums import _response_for_200
from petstore_api.model import string_enum
data = ["placed", None]
response = self.__response(data)
deserialized = _response_for_200.deserialize(response,
self.configuration)
assert isinstance(deserialized.body, ArrayOfEnums)
expected_results = ArrayOfEnums(
[string_enum.StringEnum(v) for v in data])
assert expected_results == deserialized.body
def test_multiple_of_deserialization(self):
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer': 30,
'number': 65.0,
'float': 62.4,
}
from petstore_api.model import format_test
_response_for_200 = api_client.OpenApiResponse(content={
self.json_content_type:
api_client.MediaType(schema=format_test.FormatTest),
}, )
response = self.__response(data)
deserialized = _response_for_200.deserialize(response,
self.configuration)
self.assertTrue(isinstance(deserialized.body, format_test.FormatTest))
with self.assertRaisesRegex(
petstore_api.exceptions.ApiValueError,
r"Invalid value `31`, value must be a multiple of `2` at \('args\[0\]', 'integer'\)"
):
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer':
31, # Value is supposed to be multiple of '2'. An error must be raised
'number': 65.0,
'float': 62.4,
}
response = self.__response(data)
_response_for_200.deserialize(response, self.configuration)
# Disable JSON schema validation. No error should be raised during deserialization.
configuration = petstore_api.Configuration()
configuration.disabled_client_side_validations = "multipleOf"
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer': 31, # Value is supposed to be multiple of '2'
'number': 65.0,
'float': 62.4,
}
response = self.__response(data)
deserialized = _response_for_200.deserialize(response, configuration)
self.assertTrue(isinstance(deserialized.body, format_test.FormatTest))
# Disable JSON schema validation but for a different keyword.
# An error should be raised during deserialization.
configuration = petstore_api.Configuration()
configuration.disabled_client_side_validations = "maxItems"
with self.assertRaisesRegex(
petstore_api.exceptions.ApiValueError,
r"Invalid value `31`, value must be a multiple of `2` at \('args\[0\]', 'integer'\)"
):
data = {
'byte': '3',
'date': '1970-01-01',
'password': "******",
'integer': 31, # Value is supposed to be multiple of '2'
'number': 65.0,
'float': 62.4,
}
response = self.__response(data)
_response_for_200.deserialize(response, configuration)
def testConfiguration(self):
# check that different instances use different dictionaries
c1 = petstore_api.Configuration()
c2 = petstore_api.Configuration()
self.assertNotEqual(id(c1.api_key), id(c2.api_key))
self.assertNotEqual(id(c1.api_key_prefix), id(c2.api_key_prefix))
def testConfiguration(self):
# check that different instances use different dictionaries
c1 = petstore_api.Configuration()
c2 = petstore_api.Configuration()
assert id(c1.api_key) != id(c2.api_key)
assert id(c1.api_key_prefix) != id(c2.api_key_prefix)
