Merge pull request #82 from altor/release_0.6.2

feat: add component name in parsed config

Author: altor

powerapi/__init__.py

@@ -27,4 +27,4 @@
 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-__version__ = "0.6.2"
+__version__ = "0.6.3"

powerapi/cli/parser.py

@@ -67,6 +67,18 @@ def __init__(self, argument_name):
         self.argument_name = argument_name
 
 
+class NoNameSpecifiedForComponentException(ParserException):
+    """
+    Exception raised when attempting to parse substring thant describe a component which not contains the component name
+    """
+
+
+class ComponentAlreadyExistException(ParserException):
+    """
+    Exception raised when attempting to parse a substring to create a component with a name that already exist
+    """
+
+
 class BadValueException(ParserException):
     """
     Exception raised when attempting to parse a value that doens't respect the
@@ -77,6 +89,12 @@ def __init__(self, argument_name, msg):
         self.msg = msg
 
 
+class SubParserWithoutNameArgumentException(PowerAPIException):
+    """
+    Exception raised when a subparser without argument name is added to a parser
+    """
+
+
 class TooManyArgumentNamesException(ParserException):
     """
     Exception raised when attemtping to add an argument with too much names
@@ -437,11 +455,11 @@ def add_argument(self, *names, flag=False, action=store_val, default=None,
                             type=type)
         self._add_argument_names(names, flag)
 
-    def add_component_subparser(self, component_name, subparser, help_str=''):
+    def add_component_subparser(self, component_type, subparser, help_str=''):
         """
         Add a subparser that will be used by the argument *component_name*
 
-        :param str component_name:
+        :param str component_type:
         :param ComponentSubParser subparser:
 
         :raise AlreadyAddedArgumentException: when attempting to add an
@@ -454,17 +472,31 @@ def _action(arg, val, args, acc):
 
             subparser = self.subparsers_group[arg].get_subparser(val)
             args, subparse_result = subparser.subparse(args)
-            acc[arg][subparser.name] = subparse_result
+
+            if 'name' not in subparse_result:
+                raise NoNameSpecifiedForComponentException(component_type)
+
+            component_name = subparse_result['name']
+
+            if subparser.name not in acc[arg]:
+                acc[arg][subparser.name] = {}
+
+            if component_name in acc[arg][subparser.name]:
+                raise ComponentAlreadyExistException(component_name)
+
+            acc[arg][subparser.name][component_name] = subparse_result
             return args, acc
 
-        if component_name not in self.subparsers_group:
-            self.subparsers_group[component_name] = SubParserGroup(component_name, help_str=help_str)
-            self.add_argument(component_name, action=_action, help=help_str)
+        if 'name' not in subparser.actions:
+            raise SubParserWithoutNameArgumentException()
+        if component_type not in self.subparsers_group:
+            self.subparsers_group[component_type] = SubParserGroup(component_type, help_str=help_str)
+            self.add_argument(component_type, action=_action, help=help_str)
         else:
-            if self.subparsers_group[component_name].contains(subparser.name):
+            if self.subparsers_group[component_type].contains(subparser.name):
                 raise AlreadyAddedArgumentException(subparser.name)
 
-        self.subparsers_group[component_name].add_subparser(subparser.name, subparser)
+        self.subparsers_group[component_type].add_subparser(subparser.name, subparser)
 
         for action_name, action in subparser.actions.items():
             self._add_argument_names([action_name], action.is_flag)

powerapi/cli/tools.py

@@ -170,14 +170,15 @@ def generate(self, config):
 
         actors = {}
 
-        for component_name, component_config in config[self.component_group_name].items():
-            try:
-                actors[component_config['name']] = self._gen_actor(component_name, component_config, config)
-            except KeyError as exn:
-                msg = 'CLI error : argument ' + exn.args[0]
-                msg += ' needed with --output ' + component_name
-                print(msg, file=sys.stderr)
-                sys.exit()
+        for component_type, components_list in config[self.component_group_name].items():
+            for component_name, component_config in components_list.items():
+                try:
+                    actors[component_name] = self._gen_actor(component_type, component_config, config)
+                except KeyError as exn:
+                    msg = 'CLI error : argument ' + exn.args[0]
+                    msg += ' needed with --output ' + component_type
+                    print(msg, file=sys.stderr)
+                    sys.exit()
 
         return actors
 
@@ -203,26 +204,8 @@ def __init__(self, component_group_name):
         }
 
     def _generate_db(self, db_name, db_config, main_config):
-        try:
-            return self.db_factory[db_name](db_config)
-        except KeyError as exn:
-            arg = exn.args[0]
-
-            # if an argument is missing, look if it exist in another component group
-            for group_name, group in main_config.items():
-                if group_name == self.component_group_name:
-                    pass
-
-                elif not isinstance(group, dict):
-                    pass
-
-                elif db_name not in group:
-                    pass
+        return self.db_factory[db_name](db_config)
 
-                elif arg in group[db_name]:
-                    db_config[arg] = group[db_name][arg]
-                    return self._generate_db(db_name, db_config, main_config)
-            raise exn
 
     def _gen_actor(self, db_name, db_config, main_config):
         db = self._generate_db(db_name, db_config, main_config)

tests/acceptation/test_simple_architecture_csv.py

@@ -133,11 +133,11 @@ def test_run(files, supervisor):
 
     config = {'verbose': LOG_LEVEL,
               'stream': False,
-              'input': { 'csv' : {'files': FILES,
+              'input': {'csv': {'puller' : {'files': FILES,
                                   'model': 'hwpc_report',
                                   'name': 'puller',
-                                  }},
-              'output': {'csv': {'model': 'power_report', 'name': 'pusher', 'directory': ROOT_PATH}}}
+                                  }}},
+              'output': {'csv': {'pusher': {'model': 'power_report', 'name': 'pusher', 'directory': ROOT_PATH}}}}
 
     # Pusher
     pusher_generator = PusherGenerator()

tests/unit/cli/test_parser.py

@@ -35,7 +35,8 @@
 from powerapi.cli.parser import Parser, MainParser, ComponentSubParser
 from powerapi.cli.parser import store_true
 from powerapi.cli.parser import AlreadyAddedArgumentException, BadTypeException
-from powerapi.cli.parser import UnknowArgException, BadContextException, MissingValueException
+from powerapi.cli.parser import UnknowArgException, BadContextException, MissingValueException, ComponentAlreadyExistException
+from powerapi.cli.parser import SubParserWithoutNameArgumentException, NoNameSpecifiedForComponentException
 from powerapi.cli.parser import TooManyArgumentNamesException, BadValueException
 
 
@@ -200,19 +201,21 @@ def test_subparser():
     - "" : {}
     - "-z" : UnknowArgException(z)
     - "-a" : {a: True}
-    - "-a --sub toto -b" : {a:True, sub: {'toto' : {b: True}}}
+    - "-a --sub toto -b" : NoNameSpecifiedForComponentException
+    - "-a --sub toto -b --name titi" : {a:True, sub: { titi: {'toto' : {b: True}}}}
     - "-b" : BadContextException(b, [toto])
 
     Parser description :
 
     - base parser arguments : -a
-    - subparser toto binded to the argument sub with sub arguments : -b
+    - subparser toto binded to the argument sub with sub arguments : -b and --name
     """
     parser = MainParser(help_arg=False)
     parser.add_argument('a', flag=True, action=store_true)
 
     subparser = ComponentSubParser('toto')
     subparser.add_argument('b', flag=True, action=store_true)
+    subparser.add_argument('n', 'name')
     parser.add_component_subparser('sub', subparser)
 
     check_parsing_result(parser, '', {})
@@ -222,13 +225,53 @@ def test_subparser():
 
     check_parsing_result(parser, '-a', {'a': True})
 
-    check_parsing_result(parser, '-a --sub toto -b',
-                         {'a': True, 'sub': {'toto': { 'b': True}}})
+    with pytest.raises(NoNameSpecifiedForComponentException):
+        check_parsing_result(parser, '-a --sub toto -b', {})
+
+    check_parsing_result(parser, '-a --sub toto -b --name titi', {'a': True, 'sub': {'toto': {'titi': {'name': 'titi', 'b': True}}}})
 
     with pytest.raises(BadContextException):
         check_parsing_result(parser, '-b', None)
 
 
+def test_create_two_component():
+    """
+    Create two component of the same type with the following cli : 
+    --sub toto --name titi --sub toto -b --name tutu
+
+    test if the result is :
+    {sub:{'toto' : {'titi': {'name': 'titi'}, 'tutu': {'name': 'tutu', 'b':False}}}}
+
+    """
+    parser = MainParser(help_arg=False)
+
+    subparser = ComponentSubParser('toto')
+    subparser.add_argument('b', flag=True, action=store_true)
+    subparser.add_argument('n', 'name')
+    parser.add_component_subparser('sub', subparser)
+
+    check_parsing_result(parser, '--sub toto --name titi --sub toto -b --name tutu', {'sub': {'toto': {'titi': {'name': 'titi'}, 'tutu': {'name': 'tutu', 'b': True}}}})
+
+
+def test_create_component_that_already_exist():
+    """
+    Create two component with the same name with the following cli
+    --sub toto --name titi --sub toto --name titi
+
+    test if an ComponentAlreadyExistException is raised
+
+
+    """
+    parser = MainParser(help_arg=False)
+
+    subparser = ComponentSubParser('toto')
+    subparser.add_argument('b', flag=True, action=store_true)
+    subparser.add_argument('n', 'name')
+    parser.add_component_subparser('sub', subparser)
+
+    with pytest.raises(ComponentAlreadyExistException):
+        check_parsing_result(parser, '--sub toto --name titi --sub toto --name titi', None)
+
 def test_argument_with_val():
     """
     test to parse strings with a parser and retrieve the following results :
@@ -348,9 +391,11 @@ def test_add_component_subparser_that_aldready_exists():
     """
     parser = MainParser(help_arg=False)
     subparser = ComponentSubParser('titi')
+    subparser.add_argument('n', 'name')
     parser.add_component_subparser('toto', subparser)
     subparser2 = ComponentSubParser('titi')
-
+    subparser2.add_argument('n', 'name')
+    
     with pytest.raises(AlreadyAddedArgumentException):
         parser.add_component_subparser('toto', subparser2)
 
@@ -363,8 +408,21 @@ def test_add_component_subparser_with_two_name():
     parser = MainParser(help_arg=False)
     subparser = ComponentSubParser('titi')
     subparser.add_argument('a', 'aaa', flag=True, action=store_true, default=False)
+    subparser.add_argument('n', 'name')
     parser.add_component_subparser('sub', subparser)
-    check_parsing_result(parser, '--sub titi -a', {'sub': {'titi': {'aaa': True}}})
+    check_parsing_result(parser, '--sub titi -a --name tutu', {'sub': {'titi': {'tutu': {'aaa': True, 'name': 'tutu'}}}})
+
+
+def test_add_component_subparser_that_aldready_exists():
+    """
+    Add a component_subparser with no argument 'name'
+    test if a SubParserWithoutNameArgumentException is raised
+    """
+    parser = MainParser(help_arg=False)
+    subparser = ComponentSubParser('titi')
+
+    with pytest.raises(SubParserWithoutNameArgumentException):
+        parser.add_component_subparser('toto', subparser)
 
 
 def test_parse_empty_string_default_value():