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_valid_http_signature_ec_p521(self):
privkey_path = self.ec_p521_key_path
signing_cfg = signing.HttpSigningConfiguration(
key_id="my-key-id",
signing_scheme=signing.SCHEME_HS2019,
private_key_path=privkey_path,
private_key_passphrase=self.private_key_passphrase,
hash_algorithm=signing.HASH_SHA512,
signed_headers=[
signing.HEADER_REQUEST_TARGET,
signing.HEADER_CREATED,
]
)
config = Configuration(host=HOST, signing_info=signing_cfg)
# Set the OAuth2 acces_token to None. Here we are interested in testing
# the HTTP signature scheme.
config.access_token = None
api_client = petstore_api.ApiClient(config)
pet_api = PetApi(api_client)
mock_pool = MockPoolManager(self)
api_client.rest_client.pool_manager = mock_pool
mock_pool.set_signing_config(signing_cfg)
mock_pool.expect_request('POST', 'http://petstore.swagger.io/v2/pet',
body=json.dumps(api_client.sanitize_for_serialization(self.pet)),
headers={'Content-Type': r'application/json',
'Authorization': r'Signature keyId="my-key-id",algorithm="hs2019",created=[0-9]+,'
r'headers="\(request-target\) \(created\)",'
r'signature="[a-zA-Z0-9+/=]+"',
'User-Agent': r'OpenAPI-Generator/1.0.0/python'},
preload_content=True, timeout=None)
pet_api.add_pet(self.pet)
def test_deserialize_cat_discard_unknown_properties(self):
"""
Deserialize Cat with unknown properties.
Request to discard unknown properties, but Cat is composed schema
with one inner schema that has 'additionalProperties' set to true.
"""
config = Configuration(discard_unknown_keys=True)
api_client = petstore_api.ApiClient(config)
data = {
"class_name": "Cat",
"color": "black",
"declawed": True,
# Below are additional (undeclared) properties.
"my_additional_property": 123,
}
# The 'my_additional_property' is undeclared, but 'Cat' has a 'Address' type through
# the allOf: [ $ref: '#/components/schemas/Address' ].
response = MockResponse(data=json.dumps(data))
deserialized = api_client.deserialize(response, ((petstore_api.Cat), ),
True)
self.assertTrue(isinstance(deserialized, petstore_api.Cat))
# Check the 'unknown_property' and 'more-unknown' properties are not present in the
# output.
self.assertIn("declawed", deserialized.to_dict().keys())
self.assertIn("my_additional_property", deserialized.to_dict().keys())
def setUp(self):
config = Configuration()
config.host = HOST
self.api_client = petstore_api.ApiClient(config)
self.pet_api = petstore_api.PetApi(self.api_client)
self.setUpModels()
self.setUpFiles()
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_deserialize_banana_req_discard_unknown_properties(self):
"""
Deserialize bananaReq with unknown properties.
Discard unknown properties.
"""
config = Configuration(discard_unknown_keys=True)
api_client = petstore_api.ApiClient(config)
data = {
'lengthCm': 21.3,
'sweet': False,
# Below are additional (undeclared) properties not specified in the bananaReq schema.
'unknown_property': 'a-value',
'more-unknown': ['a']
}
# The 'unknown_property' is undeclared, which would normally raise an exception, but
# when discard_unknown_keys is set to True, the unknown properties are discarded.
response = MockResponse(data=json.dumps(data))
deserialized = api_client.deserialize(response,
((banana_req.BananaReq), ), True)
self.assertTrue(isinstance(deserialized, banana_req.BananaReq))
# Check the 'unknown_property' and 'more-unknown' properties are not present in the
# output.
self.assertIn("length_cm", deserialized.to_dict().keys())
self.assertNotIn("unknown_property", deserialized.to_dict().keys())
self.assertNotIn("more-unknown", deserialized.to_dict().keys())
def test_deserialize_banana_req_do_not_discard_unknown_properties(self):
"""
deserialize bananaReq with unknown properties.
Strict validation is enabled.
Simple (non-composed) schema scenario.
"""
config = Configuration(discard_unknown_keys=False)
api_client = petstore_api.ApiClient(config)
data = {
'lengthCm': 21.3,
'sweet': False,
# Below is an unknown property not explicitly declared in the OpenAPI document.
# It should not be in the payload because additional properties (undeclared) are
# not allowed in the bananaReq schema (additionalProperties: false).
'unknown_property': 'a-value'
}
response = MockResponse(data=json.dumps(data))
# Deserializing with strict validation raises an exception because the 'unknown_property'
# is undeclared.
with self.assertRaises(
petstore_api.exceptions.ApiAttributeError) as cm:
deserialized = api_client.deserialize(response,
((banana_req.BananaReq), ),
True)
self.assertTrue(
re.match("BananaReq has no attribute 'unknown_property' at.*",
str(cm.exception)),
'Exception message: {0}'.format(str(cm.exception)))
def test_deserialize_fruit_req_do_not_discard_unknown_properties(self):
"""
deserialize FruitReq with unknown properties.
Strict validation is enabled.
Composed schema scenario.
"""
config = Configuration(discard_unknown_keys=False)
api_client = petstore_api.ApiClient(config)
data = {
'lengthCm': 21.3,
'sweet': False,
# Below is an unknown property not explicitly declared in the OpenAPI document.
# It should not be in the payload because additional properties (undeclared) are
# not allowed in the schema (additionalProperties: false).
'unknown_property': 'a-value'
}
response = MockResponse(data=json.dumps(data))
# Deserializing with strict validation raises an exception because the 'unknown_property'
# is undeclared.
with self.assertRaisesRegex(
petstore_api.ApiValueError,
"Invalid inputs given to generate an instance of FruitReq. None of the oneOf schemas matched the input data."
):
deserialized = api_client.deserialize(response,
((fruit_req.FruitReq), ),
True)
def test_deserialize_isosceles_triangle_do_not_discard_unknown_properties(
self):
"""
deserialize IsoscelesTriangle with unknown properties.
Strict validation is enabled.
Composed schema scenario.
"""
config = Configuration(discard_unknown_keys=False)
api_client = petstore_api.ApiClient(config)
data = {
'shape_type': 'Triangle',
'triangle_type': 'EquilateralTriangle',
# Below is an unknown property not explicitly declared in the OpenAPI document.
# It should not be in the payload because additional properties (undeclared) are
# not allowed in the schema (additionalProperties: false).
'unknown_property': 'a-value'
}
response = MockResponse(data=json.dumps(data))
# Deserializing with strict validation raises an exception because the 'unknown_property'
# is undeclared.
with self.assertRaises(petstore_api.ApiValueError) as cm:
deserialized = api_client.deserialize(
response, ((isosceles_triangle.IsoscelesTriangle), ), True)
self.assertTrue(
re.match('.*Not all inputs were used.*unknown_property.*',
str(cm.exception)),
'Exception message: {0}'.format(str(cm.exception)))
def setUp(self):
config = Configuration()
config.host = HOST
config.access_token = 'ACCESS_TOKEN'
self.api_client = petstore_api.ApiClient(config)
self.pet_api = PetApi(self.api_client)
self.setUpModels()
self.setUpFiles()
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 test_create_api_instance(self):
pet_api = petstore_api.PetApi()
pet_api2 = petstore_api.PetApi()
api_client3 = petstore_api.ApiClient()
api_client3.user_agent = 'api client 3'
api_client4 = petstore_api.ApiClient()
api_client4.user_agent = 'api client 4'
pet_api3 = petstore_api.PetApi(api_client3)
# same default api client
self.assertEqual(pet_api.api_client, pet_api2.api_client)
# confirm using the default api client in the config module
self.assertEqual(pet_api.api_client, petstore_api.configuration.api_client)
# 2 different api clients are not the same
self.assertNotEqual(api_client3, api_client4)
# customized pet api not using the default api client
self.assertNotEqual(pet_api3.api_client, petstore_api.configuration.api_client)
# customized pet api not using the old pet api's api client
self.assertNotEqual(pet_api3.api_client, pet_api2.api_client)
async def test_proxy(self):
config = Configuration()
# set not-existent proxy and catch an error to verify that
# the client library (aiohttp) tried to use it.
config.proxy = 'http://localhost:8080/proxy'
async with petstore_api.ApiClient(config) as client:
pet_api = petstore_api.PetApi(client)
with self.assertRaisesRegex(petstore_api.rest.aiohttp.client_exceptions.ClientProxyConnectionError,
'Cannot connect to host localhost:8080'):
await pet_api.get_pet_by_id(self.pet.id)
async def test_context_manager_closes_client(self):
async with petstore_api.ApiClient() as client:
# thread pool
self.assertIsNotNone(client.pool)
pool_ref = weakref.ref(client._pool)
self.assertIsNotNone(pool_ref())
# pool_manager
self.assertFalse(client.rest_client.pool_manager.closed)
rest_pool_ref = client.rest_client.pool_manager
self.assertIsNone(pool_ref())
self.assertTrue(rest_pool_ref.closed)
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 testReadOnlyForComposedSchema(self):
"""Test ReadOnlyForComposedSchema"""
MockResponse = namedtuple('MockResponse', 'data')
client = petstore_api.ApiClient()
""" deserialize dict(str, Enum_Test) """
data = {
"Dog": {
"class_name": "Dog",
"breed": "BullDog",
"color": "Black",
"tail": True
}
}
response = MockResponse(data=json.dumps(data))
deserialized = client.deserialize(response, ({str: (Dog, )}, ), True)
assert isinstance(deserialized, dict)
assert isinstance(deserialized['Dog'], Dog)
def test_deserialize_dog_do_not_discard_unknown_properties(self):
""" deserialize str, Dog) with unknown properties, strict validation is enabled """
config = Configuration(discard_unknown_keys=False)
api_client = petstore_api.ApiClient(config)
data = {
"class_name": "Dog",
"color": "black",
"breed": "husky",
"unknown_property": "a-value"
}
response = MockResponse(data=json.dumps(data))
# Deserializing with strict validation raises an exception because the 'unknown_property'
# is undeclared.
with self.assertRaises(petstore_api.ApiValueError) as cm:
deserialized = api_client.deserialize(response, ((petstore_api.Dog),), True)
self.assertTrue(re.match('.*Not all inputs were used.*unknown_property.*', str(cm.exception)),
'Exception message: {0}'.format(str(cm.exception)))
def test_deserialize_cat_do_not_discard_unknown_properties(self):
""" deserialize str, Cat) with unknown properties, strict validation is enabled """
config = Configuration(discard_unknown_keys=False)
api_client = petstore_api.ApiClient(config)
data = {
"class_name": "Cat",
"color": "black",
"declawed": True,
"dynamic-property": 12345,
}
response = MockResponse(data=json.dumps(data))
# Deserializing with strict validation does not raise an exception because the even though
# the 'dynamic-property' is undeclared, the 'Cat' schema defines the additionalProperties
# attribute.
deserialized = api_client.deserialize(response, ((petstore_api.Cat),), True)
self.assertTrue(isinstance(deserialized, petstore_api.Cat))
self.assertIn('color', deserialized.to_dict())
self.assertEqual(deserialized['color'], 'black')
def test_deserialize_fruit_req_discard_unknown_properties(self):
"""
deserialize FruitReq with unknown properties.
Strict validation is enabled.
Composed schema scenario.
"""
config = Configuration(discard_unknown_keys=True)
api_client = petstore_api.ApiClient(config)
data = {
'lengthCm': 21.3,
'sweet': False,
# Below is an unknown property not explicitly declared in the OpenAPI document.
# It should not be in the payload because additional properties (undeclared) are
# not allowed in BananaReq
'unknown_property': 'a-value'
}
response = MockResponse(data=json.dumps(data))
deserialized = api_client.deserialize(response,
((fruit_req.FruitReq), ), True)
self.assertNotIn("unknown_property", deserialized.to_dict().keys())
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)
def test_deserialize_cat_discard_unknown_properties(self):
"""
Deserialize Cat with unknown properties.
Request to discard unknown properties, but Cat is composed schema
with one inner schema that has 'additionalProperties' set to true.
"""
config = Configuration(discard_unknown_keys=True)
api_client = petstore_api.ApiClient(config)
data = {
"class_name": "Cat",
"color": "black",
"declawed": True,
# Below are additional (undeclared) properties.
"my_additional_property": 123,
}
# The 'my_additional_property' is undeclared
response = MockResponse(data=json.dumps(data))
deserialized = api_client.deserialize(response, ((cat.Cat), ), True)
self.assertTrue(isinstance(deserialized, cat.Cat))
# Check the 'my_additional_property' is present
self.assertIn("my_additional_property", deserialized.to_dict().keys())
def test_deserialize_dog_discard_unknown_properties(self):
""" deserialize str, Dog) with unknown properties, discard unknown properties """
config = Configuration(discard_unknown_keys=True)
api_client = petstore_api.ApiClient(config)
data = {
"class_name": "Dog",
"color": "black",
"breed": "husky",
"unknown_property": "a-value",
"more-unknown": [
"a"
]
}
# The 'unknown_property' is undeclared, which would normally raise an exception, but
# when discard_unknown_keys is set to True, the unknown properties are discarded.
response = MockResponse(data=json.dumps(data))
deserialized = api_client.deserialize(response, ((petstore_api.Dog),), True)
self.assertTrue(isinstance(deserialized, petstore_api.Dog))
# Check the 'unknown_property' and 'more-unknown' properties are not present in the
# output.
self.assertIn("breed", deserialized.to_dict().keys())
self.assertNotIn("unknown_property", deserialized.to_dict().keys())
self.assertNotIn("more-unknown", deserialized.to_dict().keys())
def test_atexit_closes_threadpool(self):
client = petstore_api.ApiClient()
self.assertIsNotNone(client.pool)
self.assertIsNotNone(client._pool)
atexit._run_exitfuncs()
self.assertIsNone(client._pool)
def test_context_manager_closes_threadpool(self):
with petstore_api.ApiClient() as client:
self.assertIsNotNone(client.pool)
pool_ref = weakref.ref(client._pool)
self.assertIsNotNone(pool_ref())
self.assertIsNone(pool_ref())
def setUp(self):
self.api_client = petstore_api.ApiClient()
def setUp(self):
self.api_client = petstore_api.ApiClient()
self.deserialize = self.api_client.deserialize
def setUp(self):
self.api_client = petstore_api.ApiClient()
self.pet_api = petstore_api.PetApi(self.api_client)
self.setUpModels()
def setUp(self):
self.api_client = petstore_api.ApiClient()
self.serialize = self.api_client.sanitize_for_serialization
def setUp(self):
self.api_client = petstore_api.ApiClient()
from petstore_api.api.pet_api import PetApi
self.pet_api = PetApi(self.api_client)
self.setUpModels()