def test_hydrate_type_changed(self):
root = Root()
version1 = Version()
version1.name = "v1"
version2 = Version()
version2.name = "v2"
type1 = Type()
type1.name = "m1"
type1.description = "b"
type1.item = ObjectString()
type2 = Type()
type2.name = "m1"
type2.description = "c"
type2.item = ObjectString()
root.versions = {"v1": version1, "v2": version2}
version1.types = {"m1": type1}
version2.types = {"m1": type2}
root_dto = RootDto()
Hydrator(version1, root.versions,
[]).hydrate_type(root_dto, root, type1)
Hydrator(version2, root.versions,
[]).hydrate_type(root_dto, root, type2)
self.assertEqual(1, len(root_dto.type_categories))
self.assertEqual(1, len(root_dto.type_categories[0].types))
self.assertEqual(2,
len(root_dto.type_categories[0].types[0].description))
self.assertEqual(
MultiVersion.Changes.updated,
root_dto.type_categories[0].types[0].changes_status["v2"])
def test_hydrate_object(self):
version1 = Version()
version1.name = "v1"
version2 = Version()
version2.name = "v2"
versions = {"v1": version1, "v2": version2}
object_dto = []
object1 = ObjectObject()
object2 = ObjectObject()
object3 = ObjectObject()
object1.name = "a"
object2.name = "a"
object3.name = "b"
array = ObjectArray()
array.name = "b"
dynamic = ObjectDynamic()
dynamic.name = "c"
string = ObjectString()
string.name = "d"
type = ObjectType()
type.name = "e"
type.type_object = "f"
const = ObjectConst()
const.value = "g"
enum = ObjectEnum()
enum.name = "h"
enum.values = ["h"]
object1.properties = {"p1": array, "p3": const, "p4": enum}
object2.properties = {"p1": array, "p3": const, "p4": enum, "p2": type}
array.items = dynamic
dynamic.items = string
response = Hydrator(version1, versions, []).hydrate_object(object_dto, object1)
response = Hydrator(version2, versions, []).hydrate_object(object_dto, object2)
response = Hydrator(version1, versions, []).hydrate_object(object_dto, object3)
self.assertEqual(1, response)
self.assertEqual(2, len(object_dto))
self.assertIn(version1.name, object_dto[0].versions)
self.assertIn(version1.name, object_dto[0].versions)
self.assertNotIn(version2.name, object_dto[1].versions)
self.assertEqual("a", object_dto[0].value.name)
self.assertEqual("b", object_dto[0].value.properties["p1"][0].value.name)
self.assertEqual("c", object_dto[0].value.properties["p1"][0].value.items[0].value.name)
self.assertEqual("d", object_dto[0].value.properties["p1"][0].value.items[0].value.items[0].value.name)
self.assertEqual("e", object_dto[0].value.properties["p2"][0].value.name)
self.assertEqual("f", object_dto[0].value.properties["p2"][0].value.type_object)
self.assertEqual("g", object_dto[0].value.properties["p3"][0].value.value)
self.assertEqual("h", object_dto[0].value.properties["p4"][0].value.values[0].value)
def test_objecttype_get_default_sample(self):
test = ObjectType()
test.version = "v1"
test.type_name = "baz"
object = ObjectString()
object.sample = "foo"
type = Type()
type.format = TypeFormat()
type.item = object
test.type_object = type
self.assertEqual("foo", test.get_default_sample())
def test_hydrate_type__with_known_category(self):
root = Root()
version = Version()
version.name = "v"
type = Type()
type.category = "c"
type.item = ObjectString()
root.versions = {"v": version}
version.types = {"m": type}
version.types = {"m": type}
category = Category("c")
category.description = "d"
root.categories = {"c": category}
root_dto = RootDto()
hydrator = Hydrator(version, {"v": version}, [])
hydrator.hydrate_type(root_dto, root, type)
self.assertEqual("d", root_dto.type_categories[0].description)
def test_create_from_root(self):
root = Root()
version = Version()
version.name = "v"
method = Method()
method.category = "a"
type = Type()
type.category = "b"
type.item = ObjectString()
root.versions = {"v": version}
version.methods = {"m": method}
version.types = {"m": type}
response = self.factory.create_from_root(root)
self.assertIsInstance(response, RootDto)
self.assertEqual(1, len(response.method_categories))
self.assertEqual("a", response.method_categories[0].name)
self.assertEqual(1, len(response.method_categories[0].methods))
self.assertEqual(1, len(response.type_categories))
self.assertEqual("b", response.type_categories[0].name)
self.assertEqual(1, len(response.type_categories[0].types))
def test_objectType(self):
object = ObjectType()
object.name = "a"
object.type = Object.Types.type
object.type_object = Type()
object.type_object.item = ObjectString()
object_sample = ObjectTypeSample(object)
self.assertEqual("a", object_sample.name)
def test_parameter_get_default_sample__for_type(self):
test = Parameter()
type = Type()
type.item = ObjectString()
type.item.name = "a"
test.type = "b"
test.type_object = type
self.assertEqual("my_a", test.get_default_sample())
def test_hydrate_type__with_multiple_methds(self):
root = Root()
version = Version()
version.name = "v"
type1 = Type()
type1.category = "c"
type1.item = ObjectString()
type2 = Type()
type2.category = "c"
type2.item = ObjectString()
root.versions = {"v": version}
version.types = {"m1": type1, "m2": type2}
version.types = {"m": type}
root_dto = RootDto()
hydrator = Hydrator(version, {"v": version}, [])
hydrator.hydrate_type(root_dto, root, type1)
hydrator.hydrate_type(root_dto, root, type2)
self.assertEqual(1, len(root_dto.type_categories))
def test_replace_references_in_object__additional_properties(self):
object = ObjectObject()
array = ObjectArray()
dynamic = ObjectDynamic()
reference = ObjectReference()
reference.reference_name = "r1"
string1 = ObjectString()
object.additional_properties = array
array.items = dynamic
dynamic.items = reference
self.source.replace_references_in_object(object, {"r1": string1})
self.assertEqual(Object.Types.string, dynamic.items.type)
def test_get_reference(self):
reference = ObjectReference()
reference.reference_name = "r1"
reference.name = "a"
reference.description = "b"
reference.optional = True
reference1 = ObjectReference()
reference1.reference_name = "r2"
reference2 = ObjectString()
response = self.source.get_reference(reference, {"r1": reference1, "r2": reference2})
self.assertNotEqual(reference2, response)
self.assertEqual("a", response.name)
self.assertEqual("b", response.description)
self.assertEqual(True, response.optional)
def test_hydrate_type(self):
root = Root()
version = Version()
version.name = "v"
type = Type()
type.category = "a"
type.item = ObjectString()
root.versions = {"v": version}
version.types = {"m": type}
root_dto = RootDto()
hydrator = Hydrator(version, {"v": version}, [])
hydrator.hydrate_type(root_dto, root, type)
self.assertEqual(0, len(root_dto.method_categories))
self.assertEqual(1, len(root_dto.type_categories))
self.assertEqual(1, len(root_dto.type_categories[0].types))
def create_from_name_and_dictionary(self, name, datas):
"""Return a populated object Object from dictionary datas
"""
if "type" not in datas:
str_type = "any"
else:
str_type = str(datas["type"]).lower()
if str_type not in ObjectRaw.Types:
type = ObjectRaw.Types("type")
else:
type = ObjectRaw.Types(str_type)
if type is ObjectRaw.Types.object:
object = ObjectObject()
if "properties" in datas:
object.properties = self.create_dictionary_of_element_from_dictionary(
"properties", datas)
if "patternProperties" in datas:
object.pattern_properties = self.create_dictionary_of_element_from_dictionary(
"patternProperties", datas)
if "additionalProperties" in datas:
if isinstance(datas["additionalProperties"], dict):
object.additional_properties = self.create_from_name_and_dictionary(
"additionalProperties", datas["additionalProperties"])
elif not to_boolean(datas["additionalProperties"]):
object.additional_properties = None
else:
raise ValueError(
"AdditionalProperties doe not allow empty value (yet)")
elif type is ObjectRaw.Types.array:
object = ObjectArray()
if "items" in datas:
object.items = self.create_from_name_and_dictionary(
"items", datas["items"])
else:
object.items = ObjectObject()
if "sample_count" in datas:
object.sample_count = int(datas["sample_count"])
elif type is ObjectRaw.Types.number:
object = ObjectNumber()
elif type is ObjectRaw.Types.integer:
object = ObjectInteger()
elif type is ObjectRaw.Types.string:
object = ObjectString()
elif type is ObjectRaw.Types.boolean:
object = ObjectBoolean()
if "sample" in datas:
object.sample = to_boolean(datas["sample"])
elif type is ObjectRaw.Types.reference:
object = ObjectReference()
if "reference" in datas:
object.reference_name = str(datas["reference"])
elif type is ObjectRaw.Types.type:
object = ObjectType()
object.type_name = str(datas["type"])
elif type is ObjectRaw.Types.none:
object = ObjectNone()
elif type is ObjectRaw.Types.dynamic:
object = ObjectDynamic()
if "items" in datas:
object.items = self.create_from_name_and_dictionary(
"items", datas["items"])
if "sample" in datas:
if isinstance(datas["sample"], dict):
object.sample = {}
for k, v in datas["sample"].items():
object.sample[str(k)] = str(v)
else:
raise ValueError(
"A dictionnary is expected for dynamic\s object in \"%s\""
% name)
elif type is ObjectRaw.Types.const:
object = ObjectConst()
if "const_type" in datas:
const_type = str(datas["const_type"])
if const_type not in ObjectConst.Types:
raise ValueError("Const type \"%s\" unknwon" % const_type)
else:
const_type = ObjectConst.Types.string
object.const_type = const_type
if "value" not in datas:
raise ValueError("Missing const value")
object.value = datas["value"]
elif type is ObjectRaw.Types.enum:
object = ObjectEnum()
if "values" not in datas or not isinstance(datas['values'], list):
raise ValueError("Missing enum values")
object.values = [str(value) for value in datas["values"]]
if "descriptions" in datas and isinstance(datas['descriptions'],
dict):
for (value_name,
value_description) in datas["descriptions"].items():
value = EnumValue()
value.name = value_name
value.description = value_description
object.descriptions.append(value)
descriptions = [
description.name for description in object.descriptions
]
for value_name in [
x for x in object.values if x not in descriptions
]:
value = EnumValue()
value.name = value_name
object.descriptions.append(value)
else:
object = ObjectRaw()
self.set_common_datas(object, name, datas)
if isinstance(object, Constraintable):
self.set_constraints(object, datas)
object.type = type
if "optional" in datas:
object.optional = to_boolean(datas["optional"])
return object
def test_get_used_types_in_object__for_scalara(self):
object = ObjectString()
response = self.source.get_used_types_in_object(object)
self.assertEqual([], response)
def test_replace_types_in_object_not_an_object(self):
object = ObjectString()
self.source.replace_types_in_object(object, {})
self.assertEqual(vars(ObjectString()), vars(object))
def test_type_get_sample(self):
type = Type()
type.item = ObjectString()
type.item.name = "a"
self.assertEqual("my_a", type.get_sample())
def test_hydrate_object(self):
version1 = Version()
version1.name = "v1"
version2 = Version()
version2.name = "v2"
versions = {"v1": version1, "v2": version2}
object_dto = []
object1 = ObjectObject()
object2 = ObjectObject()
object3 = ObjectObject()
object1.name = "a"
object2.name = "a"
object3.name = "b"
array = ObjectArray()
array.name = "b"
dynamic = ObjectDynamic()
dynamic.name = "c"
string = ObjectString()
string.name = "d"
type = ObjectType()
type.name = "e"
type.type_object = "f"
const = ObjectConst()
const.value = "g"
enum = ObjectEnum()
enum.name = "h"
enum.values = ["h"]
object1.properties = {"p1": array, "p3": const, "p4": enum}
object2.properties = {"p1": array, "p3": const, "p4": enum, "p2": type}
array.items = dynamic
dynamic.items = string
response = Hydrator(version1, versions,
[]).hydrate_object(object_dto, object1)
response = Hydrator(version2, versions,
[]).hydrate_object(object_dto, object2)
response = Hydrator(version1, versions,
[]).hydrate_object(object_dto, object3)
self.assertEqual(1, response)
self.assertEqual(2, len(object_dto))
self.assertIn(version1.name, object_dto[0].versions)
self.assertIn(version1.name, object_dto[0].versions)
self.assertNotIn(version2.name, object_dto[1].versions)
self.assertEqual("a", object_dto[0].value.name)
self.assertEqual("b",
object_dto[0].value.properties["p1"][0].value.name)
self.assertEqual(
"c",
object_dto[0].value.properties["p1"][0].value.items[0].value.name)
self.assertEqual(
"d", object_dto[0].value.properties["p1"]
[0].value.items[0].value.items[0].value.name)
self.assertEqual("e",
object_dto[0].value.properties["p2"][0].value.name)
self.assertEqual(
"f", object_dto[0].value.properties["p2"][0].value.type_object)
self.assertEqual("g",
object_dto[0].value.properties["p3"][0].value.value)
self.assertEqual(
"h", object_dto[0].value.properties["p4"][0].value.values[0].value)