def reset(self):
     """Reset values of attributes in order to perform multiple exec"""
     BaseEntity.reset(self)
     self.origin = False
     self._last_action = None
     for action in self._actions.values():
         action.reset()

 def test_resolve_property5(self):
     '''Test resolution with a property containing special characters'''
     service = BaseEntity('test_service')
     service.add_var('NODES', HOSTNAME)
     service.target = '%NODES'
     self.assertEqual(service.resolve_property('target'),
         NodeSet(HOSTNAME))

 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_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_reset_entity(self):
     '''Test reset entity'''
     ent = BaseEntity(name='foo', target='fortoy5')
     ent.status = NO_STATUS
     ent.algo_reverse = True
     ent.reset()
     self.assertEqual(ent._algo_reversed, False)
     self.assertEqual(ent.status, NO_STATUS)

 def test_resolve_2_command_substitutions(self):
     '''Test 2 command substitutions'''
     service = BaseEntity('test_service')
     service.add_var('EXCLUDED_NODES', 'foo')
     service.add_var('SELECTED_NODES', 'bar')
     expr = '%([ -n "%SELECTED_NODES" ] && echo "-n %SELECTED_NODES")' + \
           ' %([ -n "%EXCLUDED_NODES" ] && echo "-x %EXCLUDED_NODES")'
     self.assertEqual(service._resolve(expr), '-n bar -x foo')

 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 filter_nodes(self, nodes):
        """
        Add error nodes to skip list.

        Nodes in this list will not be used when launching actions.
        """
        BaseEntity.filter_nodes(self, nodes)
        for service in self._subservices.values():
            service.filter_nodes(nodes)

 def reset(self):
     '''
     Reset values of attributes in order to used the action multiple time.
     '''
     BaseEntity.reset(self)
     self.start_time = None
     self.stop_time = None
     self.worker = None
     self.tries = 0

    def fromdict(self, grpdict):
        """Populate group attributes from dict."""
        BaseEntity.fromdict(self, grpdict)

        if 'services' in grpdict:
            dep_mapping = {}

            # Wrap dependencies from YAML and build the service
            for names, props in grpdict['services'].items():
                for subservice in NodeSet(names):

                    # Parsing dependencies
                    wrap = DepWrapper()
                    for prop in ('require', 'require_weak',
                                 'before', 'after', 'check'):
                        if prop in props:
                            if prop in ('before', 'after'):
                                props['require_weak'] = props[prop]
                                prop = 'require_weak'
                            wrap.deps[prop] = props[prop]

                    # Get subservices which might be Service or ServiceGroup
                    service = None
                    if 'services' in props:
                        service = ServiceGroup(subservice)
                        service.fromdict(props)
                    else:
                        service = Service(subservice)
                        service.fromdict(props)

                    # Link the group and its new subservice together
                    self._subservices[subservice] = service
                    service.parent = self

                    wrap.source = service
                    dep_mapping[subservice] = wrap

            # Generate dependency links of the service
            for wrap in dep_mapping.values():
                # Not any dependencies so just attach
                for dtype in wrap.deps:
                    for dep in wrap.deps[dtype]:
                        if dep not in self._subservices:
                            raise UnknownDependencyError(dep)
                        wrap.source.add_dep(self._subservices[dep],
                                                         sgth=dtype.upper())

            # Bind subgraph to the service group
            for service in self.iter_subservices():
                if not service.children:
                    service.add_dep(self._source, parent=False)
                if not service.parents:
                    service.add_dep(self._sink)

        for subser in self.iter_subservices():
            subser.inherits_from(self)

 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_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_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_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_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 __init__(self, name, target=None):
        BaseEntity.__init__(self, name, target)

        # Define a flag allowing us to specify that this service is the
        # original caller so we do not have to start his children.
        self.origin = False

        # Used for ghost services or services that you do not want to execute.
        self.simulate = False

        # Actions of the service
        self._actions = {}
        self._last_action = None

 def test_resolve_all_variables(self):
     """resolve_all() resolves variables only once"""
     entity = BaseEntity('entity')
     entity.add_var('foo', 'cool')
     entity.add_var('bar', '%foo')
     entity.add_var('baz', '%foo')
     entity.fromdict({'desc': 'New %bar'})
     entity.resolve_all()
     self.assertEqual(entity.variables['foo'], entity.variables['bar'])
     self.assertEqual(entity.variables['foo'], entity.variables['baz'])
     self.assertEqual(entity.desc, 'New cool')

 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_resolve_property1(self):
     '''Test replacement of symbols within a property'''
     service = BaseEntity('test_service')
     service.add_var('NODES', 'localhost,127.0.0.1')
     service.desc = 'start %NAME on %TARGET'
     service.target = '%NODES'
     self.assertEqual(service.resolve_property('target'),
         NodeSet('localhost,127.0.0.1'))
     self.assertEqual(service.resolve_property('name'),
         'test_service')
     self.assertEqual(service.resolve_property('desc'),
         'start test_service on 127.0.0.1,localhost')