def test_add_dep_children(self):
"""Test method add_dep for children"""
ent = BaseEntity('foo')
ent_dep = BaseEntity('child')
ent.add_dep(target=ent_dep, parent=False)
self.assertTrue(ent.has_child_dep('child'))
self.assertTrue(ent_dep.has_parent_dep('foo'))
def test_add_dep_parents(self):
"""Test method add dependency for parents"""
ent = BaseEntity('foo')
ent_dep = BaseEntity('parent')
ent.add_dep(ent_dep)
self.assertTrue(ent.has_parent_dep('parent'))
self.assertTrue(ent_dep.has_child_dep('foo'))
def test_has_child_dep(self):
"""Test method has_child_dep"""
ent = BaseEntity('foo')
ent_dep = BaseEntity('child')
ent.children['child'] = Dependency(ent_dep)
self.assertTrue(ent.has_child_dep('child'))
del ent.children['child']
self.assertFalse(ent.has_child_dep('child'))
def test_remote(self):
"""Test the remote property"""
ent1 = BaseEntity('father')
self.assertTrue(ent1.remote)
ent1.remote = False
ent2 = BaseEntity('child')
ent2.inherits_from(ent1)
self.assertFalse(ent2.remote)
def test_clear_deps(self):
"""Test method clear_deps"""
ent = BaseEntity('foo')
ent_dep = BaseEntity('parent')
ent.add_dep(ent_dep)
self.assertEqual(len(ent.parents), 1)
ent.clear_deps()
self.assertEqual(len(ent.parents), 0)
def test_has_parent_dep(self):
"""Test method has_parent_dep"""
ent = BaseEntity('foo')
ent_dep = BaseEntity('parent')
ent.parents['parent'] = Dependency(ent_dep)
self.assertTrue(ent.has_parent_dep('parent'))
del ent.parents['parent']
self.assertFalse(ent.has_parent_dep('parent'))
def test_is_strong_dependency(self):
"""Test the behaviour of is_strong method."""
dep_a = Dependency(BaseEntity("Base"), CHECK)
dep_b = Dependency(BaseEntity("Base"), REQUIRE)
dep_c = Dependency(BaseEntity("Base"), REQUIRE_WEAK)
self.assertTrue(dep_a.is_strong())
self.assertTrue(dep_b.is_strong())
self.assertFalse(dep_c.is_strong())
def test_eval_deps_waiting(self):
"""Test that eval_deps_status return WAITING_STATUS"""
service = BaseEntity("test_service")
serv_a = BaseEntity("A")
serv_b = BaseEntity("B")
service.add_dep(serv_a)
service.add_dep(serv_b, CHECK)
serv_a.status = WAITING_STATUS
self.assertEqual(service.eval_deps_status(), WAITING_STATUS)
def test_dependency_instanciation(self):
"""Test instanciation of a dependency."""
service = BaseEntity("PARENT")
service = BaseEntity("CHILD")
self.assertRaises(AssertionError, Dependency, None)
self.assertRaises(AssertionError, Dependency, service, "TEST")
self.assertTrue(Dependency(service))
self.assertTrue(Dependency(service, CHECK))
self.assertTrue(Dependency(service, CHECK, True))
def test_lookup_variables3(self):
'''Test variables resolution with an undefined var'''
service = BaseEntity('test_service')
service.add_var('VAR', 'test')
group = BaseEntity('group_service')
group.add_var('GVAR', 'group')
service.parent = group
self.assertRaises(UndefinedVariableError, service._lookup_variable,
'BAD_VAR')
def test_lookup_variables2(self):
'''Test variables resolution through multiple entities'''
service = BaseEntity('test_service')
service.add_var('VAR', 'test')
group = BaseEntity('group_service')
group.add_var('GVAR', 'group')
service.parent = group
self.assertEqual(service._lookup_variable('VAR'), 'test')
self.assertEqual(service._lookup_variable('GVAR'), 'group')
def test_fullname(self):
'''Test that the property return the fullname of the current entity'''
ent1 = BaseEntity('alpha')
self.assertEqual(ent1.fullname(), ent1.name)
ent2 = BaseEntity('beta')
ent3 = BaseEntity('gamma')
ent2.parent = ent3
ent1.parent = ent2
self.assertEqual(ent1.fullname(), 'gamma.beta.alpha')
def test_remove_dep(self):
"""Test method remove_dep."""
ent = BaseEntity('foo')
ent_dep = BaseEntity('child')
ent.children['child'] = Dependency(ent_dep)
ent_dep.parents['foo'] = Dependency(ent)
ent.remove_dep('child', parent=False)
self.assertTrue('child' not in ent.children)
self.assertTrue('foo' not in ent.parents)
self.assertRaises(AssertionError, ent.remove_dep, None)
def test_graph_dep_type(self):
"""Test the DOT output of a dependency type"""
ent = BaseEntity("ENTITY")
dep_c = Dependency(BaseEntity("Base"), CHECK)
dep_r = Dependency(BaseEntity("Base"), REQUIRE)
dep_rw = Dependency(BaseEntity("Base"), REQUIRE_WEAK)
self.assertEqual(dep_c.graph(ent), '"ENTITY" -> "Base";\n')
self.assertEqual(dep_r.graph(ent), '"ENTITY" -> "Base";\n')
self.assertEqual(dep_rw.graph(ent),
'"ENTITY" -> "Base" [style=dashed];\n')
def test_eval_deps_error(self):
"""Test that eval_deps_status return DEP_ERROR"""
service = BaseEntity("test_service")
serv_a = BaseEntity("A")
serv_b = BaseEntity("B")
service.add_dep(serv_a)
service.add_dep(serv_b, CHECK)
serv_b.status = DONE
serv_a.status = TIMEOUT
self.assertEqual(service.eval_deps_status(), DEP_ERROR)
def test_clear_childs(self):
'''Test remove all childrens dependencies'''
ent1 = BaseEntity(name='A')
ent2 = BaseEntity(name='B')
ent3 = BaseEntity(name='C')
ent1.add_dep(target=ent2, parent=False)
ent1.add_dep(target=ent3, parent=False)
ent1.clear_child_deps()
self.assertFalse(ent1.has_child_dep('B'))
self.assertFalse(ent1.has_child_dep('C'))
def test_clear_parents(self):
'''Test remove all parents dependencies'''
ent1 = BaseEntity(name='A')
ent2 = BaseEntity(name='B')
ent3 = BaseEntity(name='C')
ent1.add_dep(target=ent2)
ent1.add_dep(target=ent3)
ent1.clear_parent_deps()
self.assertFalse(ent1.has_parent_dep('B'))
self.assertFalse(ent1.has_parent_dep('C'))
def test_lookup_variables4(self):
'''Test variables resolution with a var referencing a property'''
service = BaseEntity('test_service')
service.add_var('VAR', 'test')
group = BaseEntity('group_service')
group.add_var('GVAR', 'group')
service.parent = group
self.assertEqual(service._lookup_variable('GVAR'), 'group')
self.assertEqual(service._lookup_variable('TARGET'), None)
self.assertEqual(service._lookup_variable('NAME'), 'test_service')
def test_tags(self):
"""Test tags property"""
ent1 = BaseEntity(name='parent')
self.assertEqual(ent1.tags, set())
ent1.tags.add('foo')
ent2 = BaseEntity(name='child')
ent2.inherits_from(ent1)
self.assertEqual(ent2.tags, set(['foo']))
ent2.tags = set(['bar'])
self.assertEqual(ent2.tags, set(['bar']))
def test_excluded(self):
"""Test the excluded mecanism"""
ent1 = BaseEntity('E1')
ent2 = BaseEntity('E2')
ent3 = BaseEntity('E3')
ent3.add_dep(ent2)
self.assertFalse(ent1.excluded())
self.assertTrue(ent1.excluded(["E1"]))
self.assertTrue(ent3.excluded(["E2"]))
def test_inheritance_of_non_existing_target(self):
'''
Test inheritance between entities with non-existing target/description
'''
ent1 = BaseEntity(name='parent')
ent1.desc = "foo"
ent2 = BaseEntity(name='child', target="@none")
ent2.desc = ""
ent2.inherits_from(ent1)
self.assertEqual(ent2.target, NodeSet())
self.assertEqual(ent2.desc, "")
def test_reverse_mod(self):
"""Test enable reverse mod over a bunch of entity"""
ent1 = BaseEntity('foo')
ent2 = BaseEntity('bar')
manager = entity_manager_self()
manager.entities['foo'] = ent1
manager.entities['bar'] = ent2
self.assertRaises(AssertionError, manager._reverse_mod, None)
manager._reverse_mod(True)
self.assertTrue(ent1._algo_reversed and ent2._algo_reversed)
self.assertFalse(not ent1._algo_reversed and not ent2._algo_reversed)
def test_search_node_graph(self):
"""Test the research of a node through a graph"""
ent1 = BaseEntity('E1')
ent2 = BaseEntity('E2')
ent3 = BaseEntity('E3')
ent4 = BaseEntity('E4')
ent1.add_dep(ent2)
ent1.add_dep(ent3)
ent2.add_dep(ent4)
ent3.add_dep(ent4)
self.assertTrue(ent1.search('E3') is ent3)
self.assertTrue(ent1.search('E5') is None)
def test_search_node_graph_reverse(self):
"""Test the research of node through a graph in reverse mod"""
ent1 = BaseEntity('E1')
ent2 = BaseEntity('E2')
ent3 = BaseEntity('E3')
ent4 = BaseEntity('E4')
ent1.add_dep(ent2)
ent1.add_dep(ent3)
ent2.add_dep(ent4)
ent3.add_dep(ent4)
self.assertTrue(ent4.search('E1', True) is ent1)
self.assertTrue(ent4.search('E5', True) is None)
def test_eval_deps_no_status(self):
"""Test that eval_deps_status return NO_STATUS"""
service = BaseEntity("test_service")
serv_a = BaseEntity("A")
serv_b = BaseEntity("B")
serv_a.status = WARNING
service.add_dep(serv_a)
service.add_dep(serv_b, CHECK)
self.assertEqual(service.eval_deps_status(), NO_STATUS)
serv_a.status = NO_STATUS
serv_b.status = WARNING
self.assertEqual(service.eval_deps_status(), NO_STATUS)
def test_inheritance_of_properties1(self):
'''Test inheritance between entities'''
ent1 = BaseEntity(name='parent', target='aury[10-16]')
ent1.fanout = 5
ent1.errors = 2
ent1.timeout = 15
ent2 = BaseEntity(name='child')
ent2.inherits_from(ent1)
self.assertEqual(ent2.target, NodeSet('aury[10-16]'))
self.assertEqual(ent2.fanout, 5)
self.assertEqual(ent2.errors, 2)
self.assertEqual(ent2.timeout, 15)
def test_is_ready(self):
"""Test method allowing us to determine if a service can be processed"""
ent = BaseEntity('foo')
ent_dep = BaseEntity('parent')
ent_dep2 = BaseEntity('parent2')
ent.add_dep(ent_dep)
ent.add_dep(ent_dep2)
self.assertFalse(ent.is_ready())
ent_dep.status = WAITING_STATUS
self.assertFalse(ent.is_ready())
ent_dep.status = DONE
ent_dep2.status = DONE
self.assertTrue(ent.is_ready())
def test_eval_deps_warnings(self):
"""eval_deps_status() is DONE with REQUIRE_WEAK on error"""
service = BaseEntity("test_service")
serv_a = BaseEntity("A")
serv_b = BaseEntity("B")
service.add_dep(serv_a, REQUIRE_WEAK)
service.add_dep(serv_b, REQUIRE_WEAK)
serv_a.status = DONE
serv_b.status = ERROR
self.assertEqual(service.eval_deps_status(), DONE)
serv_b.status = DEP_ERROR
serv_a.status = TIMEOUT
self.assertEqual(service.eval_deps_status(), DONE)
def test_search_deps(self):
"""Test method search_deps"""
ent = BaseEntity('test_service')
ent_a = BaseEntity('A')
ent_b = BaseEntity('B')
ent.add_dep(ent_a)
ent.add_dep(ent_b, CHECK)
self.assertEqual(len(ent.search_deps()), 2)
self.assertEqual(len(ent.search_deps([NO_STATUS])), 2)
ent_c = BaseEntity('C')
ent_c.status = DONE
ent.add_dep(ent_c)
self.assertEqual(len(ent.search_deps([NO_STATUS])), 2)
self.assertEqual(len(ent.search_deps([NO_STATUS, DONE])), 3)
def test_longname(self):
""" """
# No dep, no desc
ent1 = BaseEntity('alpha')
self.assertEqual(ent1.longname(), "alpha")
# Desc, no dep
ent1.desc = "small description"
self.assertEqual(ent1.longname(), "alpha - small description")
# Desc and dep
ent2 = BaseEntity('beta')
ent2.desc = "another description"
ent2.parent = ent1
self.assertEqual(ent2.longname(), "alpha.beta - another description")
