def test_remove_hidden_elements(self):
root = Root()
version1 = Version()
version2 = Version()
category1 = Category("c1")
category2 = Category("c2")
method1 = Method()
method2 = Method()
root.versions = {"v1": version1, "v2": version2}
root.categories = {"c1": category1, "c2": category2}
version1.methods = {"m1": method1, "m2": method2}
version2.methods = {"m1": method1, "m2": method2}
method1.category = "c1"
method2.category = "c2"
version1.display = False
category2.display = False
self.source.remove_hidden_elements(root)
self.assertEqual(1, len(root.versions))
self.assertEqual(version2, root.versions["v2"])
self.assertEqual(1, len(root.versions["v2"].methods))
self.assertEqual(method1, root.versions["v2"].methods["m1"])
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_category_compare__with_order(self):
category1 = CategoryDto(Category("c"))
category2 = CategoryDto(Category("c"))
category1.order = 1
category2.order = 2
self.assertEqual(category1, sorted([category2, category1])[0])
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_category_compare__with_name(self):
category1 = CategoryDto(Category("a"))
category2 = CategoryDto(Category("b"))
category1.order = 1
category1.label = "a"
category2.order = 1
category2.label = "a"
self.assertEqual(category1, sorted([category2, category1])[0])
def create_from_name_and_dictionary(self, name, datas):
"""Return a populated object Category from dictionary datas
"""
category = ObjectCategory(name)
self.set_common_datas(category, name, datas)
if "order" in datas:
category.order = int(datas["order"])
return category
def test_category(self):
category = Category("a")
category.name = "a"
category.description = "b"
category.order = 2
category_dto = CategoryDto(category)
self.assertEqual("a", category_dto.name)
self.assertEqual("b", category_dto.description)
self.assertEqual(2, category_dto.order)
def test_category(self):
category = Category("a")
category.name = "a"
category.description = "b"
category.order = 2
category_dto = CategoryDto(category)
self.assertEqual("a", category_dto.name)
self.assertEqual("b", category_dto.description)
self.assertEqual(2, category_dto.order)
def test_hide_filtered_elements__category_exclude(self):
root = Root()
category1 = Category("c1")
category2 = Category("c2")
category3 = Category("c3")
root.categories = {"c1": category1, "c2": category2, "c3": category3}
config = ConfigObject()
config["filter"]["categories"]["excludes"] = ["c1", "c3"]
self.source.hide_filtered_elements(root, config["filter"])
self.assertFalse(category1.display)
self.assertTrue(category2.display)
self.assertFalse(category3.display)
def test_define_changes_status__updated(self):
root_dto = RootDto()
version1 = Version()
version1.name = "v1"
version1.major = 1
version1 = VersionDto(version1)
version2 = Version()
version2.name = "v2"
version2.major = 2
version2 = VersionDto(version2)
category1 = MethodCategory(Category("c1"))
method1 = Method()
method1.changes_status = {
"v1": MultiVersion.Changes.new,
"v2": MultiVersion.Changes.updated
}
category1.methods = [method1]
root_dto.versions = [version1, version2]
root_dto.method_categories = [category1]
self.factory.define_changes_status(root_dto)
self.assertEqual(MultiVersion.Changes.new,
method1.changes_status["v1"])
self.assertEqual(MultiVersion.Changes.updated,
method1.changes_status["v2"])
def add_missing_categories(self, root):
"""Remove elements marked a not to display
"""
categories = [method.category for version in root.versions.values() for method in version.methods.values() if method.category not in root.categories.keys()] + \
[type.category for version in root.versions.values() for type in version.types.values() if type.category not in root.categories.keys()]
for category_name in categories:
root.categories[category_name] = Category(category_name)
def test_hide_filtered_elements__category_include(self):
root = Root()
category1 = Category("c")
category2 = Category("c")
category3 = Category("c")
category1.name = "v1"
category2.name = "v2"
category3.name = "v3"
root.categories = {"s1": category1, "s2": category2, "s3": category3}
config = ConfigObject()
config["filter"]["categories"]["includes"] = ["v1", "v3"]
self.source.hide_filtered_elements(root, config["filter"])
self.assertTrue(category1.display)
self.assertFalse(category2.display)
self.assertTrue(category3.display)
def test_hide_filtered_elements__category(self):
root = Root()
version1 = Version()
category1 = Category("c")
category2 = Category("c")
category3 = Category("c")
category1.name = "v1"
category2.name = "v2"
category3.name = "v3"
root.versions = {"v1": version1}
version1.categories = {"s1": category1, "s2": category2, "s3": category3}
config = ConfigObject()
self.source.hide_filtered_elements(root, config["filter"])
self.assertTrue(category1.display)
self.assertTrue(category2.display)
self.assertTrue(category3.display)
def test_hydrate_method__with_known_category(self):
root = Root()
version = Version()
version.name = "v"
method = Method()
method.category = "c"
root.versions = {"v": version}
version.methods = {"m": method}
version.types = {"m": type}
category = Category("c")
category.description = "d"
root.categories = {"c": category}
root_dto = RootDto()
hydrator = Hydrator(version, {"v": version}, [])
hydrator.hydrate_method(root_dto, root, method)
self.assertEqual("d", root_dto.method_categories[0].description)
def test_define_changes_status(self):
root_dto = RootDto()
version1 = Version()
version1.name = "v1"
version1.major = 1
version1 = VersionDto(version1)
version2 = Version()
version2.name = "v2"
version2.major = 2
version2 = VersionDto(version2)
category1 = MethodCategory(Category("c1"))
category2 = TypeCategory(Category("c2"))
method1 = Method()
method1.changes_status = {"v1": MultiVersion.Changes.none}
method2 = Method()
method2.changes_status = {"v1": MultiVersion.Changes.new}
method3 = Method()
method3.changes_status = {"v2": MultiVersion.Changes.new}
category1.methods = [method1, method2, method3]
root_dto.versions = [version1, version2]
root_dto.method_categories = [category1]
root_dto.type_categories = [category2]
self.factory.define_changes_status(root_dto)
self.assertEqual(MultiVersion.Changes.new,
method1.changes_status["v1"])
self.assertEqual(MultiVersion.Changes.deleted,
method2.changes_status["v2"])
self.assertEqual(MultiVersion.Changes.none,
method3.changes_status["v1"])
def test_hydrate_method__with_known_category(self):
root = Root()
version = Version()
version.name = "v"
method = Method()
method.category = "c"
root.versions = {"v": version}
version.methods = {"m": method}
version.types = {"m": type}
category = Category("c")
category.description = "d"
root.categories = {"c": category}
root_dto = RootDto()
hydrator = Hydrator(version, {"v": version}, [])
hydrator.hydrate_method(root_dto, root, method)
self.assertEqual("d", root_dto.method_categories[0].description)
def test_add_missing_categories(self):
root = Root()
version1 = Version()
category1 = Category("c1")
method1 = Method()
method2 = Method()
root.versions = {"v1": version1}
root.categories = {"c1": category1}
version1.methods = {"m1": method1, "m2": method2}
method1.category = "c1"
method2.category = "c2"
self.source.add_missing_categories(root)
self.assertEqual(2, len(root.categories))
self.assertIsInstance(root.categories["c2"], Category)
def hydrate_type(self, root_dto, root, type):
categories = dict(
(category.name, category) for category in root_dto.type_categories)
if type.category not in categories.keys():
if type.category in root.categories.keys():
category = TypeCategory(root.categories[type.category])
else:
category = TypeCategory(Category(type.category))
root_dto.type_categories.append(category)
else:
category = categories[type.category]
types = dict((type.name, type) for type in category.types)
if type.name in types.keys():
type_dto = types[type.name]
type_dto.changes_status[
self.version_name] = MultiVersion.Changes.none
else:
type_dto = Type(type)
category.types.append(type_dto)
type_dto.changes_status[
self.version_name] = MultiVersion.Changes.new
type_dto.versions.append(self.version_name)
changes = 0
changes += self.hydrate_value(type_dto.description, type.description)
changes += self.hydrate_value(type_dto.format.pretty,
type.format.pretty)
changes += self.hydrate_value(type_dto.format.advanced,
type.format.advanced)
changes += self.hydrate_object(type_dto.item, type.item)
if changes > 0 and type_dto.changes_status[
self.version_name] is MultiVersion.Changes.none:
type_dto.changes_status[
self.version_name] = MultiVersion.Changes.updated
type_dto.samples[self.version_name] = TypeSample(type)
def hydrate_method(self, root_dto, root_source, method):
categories = dict((category.name, category)
for category in root_dto.method_categories)
if method.category not in categories.keys():
if method.category in root_source.categories.keys():
category = MethodCategory(
root_source.categories[method.category])
else:
category = MethodCategory(Category(method.category))
root_dto.method_categories.append(category)
else:
category = categories[method.category]
methods = dict((method.name, method) for method in category.methods)
if method.name in methods.keys():
method_dto = methods[method.name]
method_dto.changes_status[
self.version_name] = MultiVersion.Changes.none
else:
method_dto = Method(method)
category.methods.append(method_dto)
method_dto.changes_status[
self.version_name] = MultiVersion.Changes.new
method_dto.versions.append(self.version_name)
for parameter in method.request_parameters.values():
parameter.position = method.full_uri.find("{%s}" % parameter.name)
request_parameters = [
RequestParameter(parameter)
for parameter in method.request_parameters.values()
]
request_headers = [
Parameter(parameter)
for parameter in method.request_headers.values()
]
response_codes = [
ResponseCode(parameter) for parameter in method.response_codes
]
changes = 0
changes += self.hydrate_value(method_dto.description,
method.description)
changes += self.hydrate_value(method_dto.full_uri, method.full_uri)
changes += self.hydrate_value(method_dto.absolute_uri,
method.absolute_uri)
changes += self.hydrate_value(method_dto.code, method.code)
changes += self.hydrate_list(method_dto.request_headers,
sorted(request_headers))
changes += self.hydrate_list(method_dto.request_parameters,
sorted(request_parameters))
changes += self.hydrate_list(method_dto.response_codes,
sorted(response_codes))
changes += self.hydrate_object(method_dto.request_body,
method.request_body)
changes += self.hydrate_object(method_dto.response_body,
method.response_body)
if changes > 0 and method_dto.changes_status[
self.version_name] is MultiVersion.Changes.none:
method_dto.changes_status[
self.version_name] = MultiVersion.Changes.updated
method_dto.samples[self.version_name] = MethodSample(method)
def test_sort_category_lt__on_order(self):
v1 = CategoryDto(Category("a"))
v1.order = 1
v2 = CategoryDto(Category("a"))
v2.order = 2
self.assertLess(v1, v2)
def test_sort_category_lt(self):
v1 = CategoryDto(Category("a"))
v2 = CategoryDto(Category("b"))
self.assertLess(v1, v2)
def test_sort_category_equals(self):
v1 = CategoryDto(Category("a"))
v1.order = 1
v2 = CategoryDto(Category("a"))
v2.order = 1
self.assertEqual(v1, v2)
