def test_replace_type(self):
root = Root()
version1 = Version()
method1 = Method()
object_type1 = ObjectType()
object_type1.type_name = "t1"
type1 = Type()
parameter1 = Parameter()
parameter1.type = "t1"
parameter2 = Parameter()
parameter2.type = "t1"
method1.request_body = object_type1
method1.request_parameters = {"p1": parameter1}
method1.request_headers = {"p1": parameter2}
version1.types = {"t1": type1}
version1.methods = {"m1": method1}
root.versions = {"v1": version1}
self.source.replace_types(root)
self.assertEqual(type1, method1.request_body.type_object)
self.assertEqual(type1, method1.request_parameters["p1"].type_object)
self.assertEqual(type1, method1.request_headers["p1"].type_object)
def test_objectType(self):
object = ObjectType()
object.type_name = "a"
object.values = ["c"]
object_dto = ObjectTypeDto(object)
self.assertEqual("a", object_dto.type_name)
self.assertEqual([], object_dto.values)
def test_objectType(self):
object = ObjectType()
object.type_name = "a"
object.values = ["c"]
object_dto = ObjectTypeDto(object)
self.assertEqual("a", object_dto.type_name)
self.assertEqual([], object_dto.values)
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_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_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_get_used_types_in_object__additional_properties(self):
object = ObjectObject()
array = ObjectArray()
dynamic = ObjectDynamic()
reference = ObjectType()
reference.type_name = "t1"
object.additional_properties = array
array.items = dynamic
dynamic.items = reference
response = self.source.get_used_types_in_object(object)
self.assertEqual(["t1"], response)
def test_replace_types_in_object__unknwon(self):
object = ObjectObject()
array = ObjectArray()
dynamic = ObjectDynamic()
reference = ObjectType()
reference.type_name = "t2"
type1 = Type()
object.properties = {"p1": array}
array.items = dynamic
dynamic.items = reference
with self.assertRaises(ValueError):
self.source.replace_types_in_object(object, {"t1": type1})
def test_replace_types_in_object__additional_properties(self):
object = ObjectObject()
array = ObjectArray()
dynamic = ObjectDynamic()
reference = ObjectType()
reference.type_name = "t1"
type1 = Type()
object.additional_properties = array
array.items = dynamic
dynamic.items = reference
self.source.replace_types_in_object(object, {"t1": type1})
self.assertEqual(type1, reference.type_object)
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 create_from_name_and_dictionary(self, name, datas):
"""Return a populated object Type from dictionary datas
"""
if "item" not in datas:
raise ValueError("An item must be set in type \"%s\"." % name)
type = ObjectType()
self.set_common_datas(type, name, datas)
type.item = self.object_factory.create_from_name_and_dictionary(type.name, datas["item"])
if "category" in datas:
type.category = str(datas["category"])
else:
type.category = None
if "format" in datas and datas["format"] is not None:
if "pretty" in datas["format"]:
type.format.pretty = str(datas["format"]["pretty"])
if "advanced" in datas["format"]:
type.format.advanced = str(datas["format"]["advanced"])
return type
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_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)
