def test_apple_fruit(self):
# make an instance of Fruit, a composed schema oneOf model
# apple test
color = 'red'
cultivar = 'golden delicious'
fruit = Fruit(color=color, cultivar=cultivar)
# check its properties
self.assertEqual(fruit.color, color)
self.assertEqual(fruit['color'], color)
self.assertEqual(getattr(fruit, 'color'), color)
self.assertEqual(fruit.cultivar, cultivar)
self.assertEqual(fruit['cultivar'], cultivar)
self.assertEqual(getattr(fruit, 'cultivar'), cultivar)
# check the dict representation
self.assertEqual(fruit.to_dict(), {
'color': color,
'cultivar': cultivar
})
# model._composed_instances is a list of the instances that were
# made from the anyOf/allOf/OneOf classes in model._composed_schemas
for composed_instance in fruit._composed_instances:
if composed_instance.__class__ == apple.Apple:
apple_instance = composed_instance
self.assertEqual(fruit._composed_instances, [apple_instance])
# model._var_name_to_model_instances maps the variable name to the
# model instances which store that variable
self.assertEqual(
fruit._var_name_to_model_instances, {
'color': [fruit, apple_instance],
'cultivar': [fruit, apple_instance],
})
self.assertEqual(fruit._additional_properties_model_instances, [fruit])
def test_banana_fruit(self):
"""Test Fruit"""
# make an instance of Fruit, a composed schema oneOf model
# banana test
fruit = Fruit(length_cm=self.length_cm, color=self.color)
# check its properties
self.assertEqual(fruit.length_cm, self.length_cm)
self.assertEqual(fruit['length_cm'], self.length_cm)
self.assertEqual(fruit.get('length_cm'), self.length_cm)
self.assertEqual(getattr(fruit, 'length_cm'), self.length_cm)
self.assertEqual(fruit.color, self.color)
self.assertEqual(fruit['color'], self.color)
self.assertEqual(getattr(fruit, 'color'), self.color)
# check the dict representation
self.assertEqual(fruit.to_dict(), {
'length_cm': self.length_cm,
'color': self.color
})
# make sure that the ModelComposed class properties are correct
# model._composed_schemas stores the anyOf/allOf/oneOf info
self.assertEqual(fruit._composed_schemas, {
'anyOf': [],
'allOf': [],
'oneOf': [
apple.Apple,
banana.Banana,
],
})
# model._composed_instances is a list of the instances that were
# made from the anyOf/allOf/OneOf classes in model._composed_schemas
self.assertEqual(len(fruit._composed_instances), 1)
for composed_instance in fruit._composed_instances:
if composed_instance.__class__ == banana.Banana:
banana_instance = composed_instance
self.assertEqual(fruit._composed_instances, [banana_instance])
# model._var_name_to_model_instances maps the variable name to the
# model instances which store that variable
print(fruit._var_name_to_model_instances)
self.assertEqual(
fruit._var_name_to_model_instances, {
'color': [fruit, banana_instance],
'length_cm': [fruit, banana_instance],
})
self.assertEqual(fruit._additional_properties_model_instances, [fruit])
# if we modify one of the properties owned by multiple
# model_instances we get an exception when we try to access that
# property because the retrieved values are not all the same
banana_instance.length_cm = 4.56
with self.assertRaises(petstore_api.ApiValueError):
some_length_cm = fruit.length_cm
# including input parameters for two oneOf instances raise an exception
with self.assertRaises(petstore_api.ApiValueError):
fruit = Fruit(length_cm=self.length_cm, cultivar='granny smith')
def test_fruit_assigning_additional_props_in_client(self):
# setting a value that doesn't exist works because additional_properties_type allows any type
other_fruit = Fruit(length_cm=self.length_cm, color=self.color)
blah = 'blah'
other_fruit['a'] = blah
assert other_fruit.a == blah
# with setattr
setattr(other_fruit, 'b', blah)
assert other_fruit.b == blah
self.assertEqual(
other_fruit.to_dict(), {
'a': 'blah',
'b': 'blah',
'length_cm': self.length_cm,
'color': self.color
})
def testFruit(self):
"""Test Fruit"""
# make an instance of Fruit, a composed schema oneOf model
# banana test
length_cm = 20.3
color = 'yellow'
fruit = Fruit(length_cm=length_cm, color=color)
# check its properties
self.assertEqual(fruit.length_cm, length_cm)
self.assertEqual(fruit['length_cm'], length_cm)
self.assertEqual(fruit.get('length_cm'), length_cm)
self.assertEqual(getattr(fruit, 'length_cm'), length_cm)
self.assertEqual(fruit.color, color)
self.assertEqual(fruit['color'], color)
self.assertEqual(getattr(fruit, 'color'), color)
# check the dict representation
self.assertEqual(fruit.to_dict(), {
'length_cm': length_cm,
'color': color
})
# setting a value that doesn't exist raises an exception
# with a key
with self.assertRaises(AttributeError):
fruit['invalid_variable'] = 'some value'
# Assert that we can call the builtin hasattr() function.
# hasattr should return False for non-existent attribute.
# Internally hasattr catches the AttributeError exception.
self.assertFalse(hasattr(fruit, 'invalid_variable'))
# Assert that we can call the builtin hasattr() function.
# hasattr should return True for existent attribute.
self.assertTrue(hasattr(fruit, 'color'))
# with setattr
with self.assertRaises(AttributeError):
setattr(fruit, 'invalid_variable', 'some value')
# getting a value that doesn't exist raises an exception
# with a key
with self.assertRaises(AttributeError):
invalid_variable = fruit['cultivar']
# with getattr
# Per Python doc, if the named attribute does not exist,
# default is returned if provided.
self.assertEqual(getattr(fruit, 'cultivar', 'some value'),
'some value')
self.assertEqual(fruit.get('cultivar'), None)
self.assertEqual(fruit.get('cultivar', 'some value'), 'some value')
# Per Python doc, if the named attribute does not exist,
# default is returned if provided, otherwise AttributeError is raised.
with self.assertRaises(AttributeError):
getattr(fruit, 'cultivar')
# make sure that the ModelComposed class properties are correct
# model._composed_schemas stores the anyOf/allOf/oneOf info
self.assertEqual(fruit._composed_schemas, {
'anyOf': [],
'allOf': [],
'oneOf': [
apple.Apple,
banana.Banana,
],
})
# model._composed_instances is a list of the instances that were
# made from the anyOf/allOf/OneOf classes in model._composed_schemas
for composed_instance in fruit._composed_instances:
if composed_instance.__class__ == banana.Banana:
banana_instance = composed_instance
self.assertEqual(fruit._composed_instances, [banana_instance])
# model._var_name_to_model_instances maps the variable name to the
# model instances which store that variable
self.assertEqual(
fruit._var_name_to_model_instances, {
'color': [fruit],
'length_cm': [fruit, banana_instance],
'cultivar': [fruit],
'origin': [fruit],
})
# model._additional_properties_model_instances stores a list of
# models which have the property additional_properties_type != None
self.assertEqual(fruit._additional_properties_model_instances, [])
# if we modify one of the properties owned by multiple
# model_instances we get an exception when we try to access that
# property because the retrieved values are not all the same
banana_instance.length_cm = 4.56
with self.assertRaises(petstore_api.ApiValueError):
some_length_cm = fruit.length_cm
# including extra parameters raises an exception
with self.assertRaises(petstore_api.ApiValueError):
fruit = Fruit(color=color,
length_cm=length_cm,
unknown_property='some value')
# including input parameters for two oneOf instances raise an exception
with self.assertRaises(petstore_api.ApiValueError):
fruit = Fruit(length_cm=length_cm, cultivar='granny smith')
# make an instance of Fruit, a composed schema oneOf model
# apple test
color = 'red'
cultivar = 'golden delicious'
fruit = Fruit(color=color, cultivar=cultivar)
# check its properties
self.assertEqual(fruit.color, color)
self.assertEqual(fruit['color'], color)
self.assertEqual(getattr(fruit, 'color'), color)
self.assertEqual(fruit.cultivar, cultivar)
self.assertEqual(fruit['cultivar'], cultivar)
self.assertEqual(getattr(fruit, 'cultivar'), cultivar)
# check the dict representation
self.assertEqual(fruit.to_dict(), {
'color': color,
'cultivar': cultivar
})
# model._composed_instances is a list of the instances that were
# made from the anyOf/allOf/OneOf classes in model._composed_schemas
for composed_instance in fruit._composed_instances:
if composed_instance.__class__ == apple.Apple:
apple_instance = composed_instance
self.assertEqual(fruit._composed_instances, [apple_instance])
# model._var_name_to_model_instances maps the variable name to the
# model instances which store that variable
self.assertEqual(
fruit._var_name_to_model_instances, {
'color': [fruit],
'length_cm': [fruit],
'cultivar': [fruit, apple_instance],
'origin': [fruit, apple_instance],
})
# model._additional_properties_model_instances stores a list of
# models which have the property additional_properties_type != None
self.assertEqual(fruit._additional_properties_model_instances, [])