Quellcode durchsuchen

add test for entry point script of kalliope

nico vor 8 Jahren
Ursprung
Commit
37688912f3
3 geänderte Dateien mit 150 neuen und 28 gelöschten Zeilen
  1. 111 0
      Tests/test_init.py
  2. 37 28
      kalliope/__init__.py
  3. 2 0
      kalliope/core/__init__.py

+ 111 - 0
Tests/test_init.py

@@ -0,0 +1,111 @@
+import unittest
+
+import logging
+
+import sys
+
+import mock
+
+from kalliope import parse_args, configure_logging, main
+
+
+class TestInit(unittest.TestCase):
+
+    def test_parse_args(self):
+        # start option
+        parser = parse_args(['value'])
+        self.assertEqual(parser.action, "value")
+
+        # no option
+        with self.assertRaises(SystemExit):
+            parse_args([])
+
+        parser = parse_args(['start', '--run-synapse', 'run_synapse'])
+        self.assertEqual(parser.run_synapse, 'run_synapse')
+
+        parser = parse_args(['start', '--run-order', 'my order'])
+        self.assertEqual(parser.run_order, 'my order')
+
+    def test_configure_logging(self):
+        logger = logging.getLogger("kalliope")
+        # Level 10 = DEBUG
+        configure_logging(debug=True)
+        self.assertEqual(logger.getEffectiveLevel(), 10)
+        logger.propagate = False
+
+        # Level 20 = INFO
+        configure_logging(debug=False)
+        self.assertEqual(logger.getEffectiveLevel(), 20)
+
+        # disable after testing
+        logger.disabled = True
+
+    def test_main(self):
+        # test start kalliope
+        sys.argv = ['kalliope.py', 'start']
+        with mock.patch('kalliope.core.MainController.__init__') as mock_maincontroller:
+            mock_maincontroller.return_value = None
+            main()
+            mock_maincontroller.assert_called()
+
+        # test start gui
+        sys.argv = ['kalliope.py', 'gui']
+        with mock.patch('kalliope.core.ShellGui.__init__') as mock_shell_gui:
+            mock_shell_gui.return_value = None
+            main()
+            mock_shell_gui.assert_called()
+
+        # test run_synapse
+        sys.argv = ['kalliope.py', 'start', '--run-synapse', 'synapse_name']
+        with mock.patch('kalliope.core.SynapseLauncher.start_synapse_by_name') as mock_synapse_launcher:
+            mock_synapse_launcher.return_value = None
+            main()
+            mock_synapse_launcher.assert_called()
+
+        # test run order
+        sys.argv = ['kalliope.py', 'start', '--run-order', 'my order']
+        with mock.patch('kalliope.core.SynapseLauncher.run_matching_synapse_from_order') as mock_synapse_launcher:
+            mock_synapse_launcher.return_value = None
+            main()
+            mock_synapse_launcher.assert_called()
+
+        # action doesn't exist
+        sys.argv = ['kalliope.py', 'non_existing_action']
+        with self.assertRaises(SystemExit):
+            main()
+
+        # install
+        sys.argv = ['kalliope.py', 'install', '--git-url', 'https://my_url']
+        with mock.patch('kalliope.core.ResourcesManager.install') as mock_resource_manager:
+            mock_resource_manager.return_value = None
+            main()
+            mock_resource_manager.assert_called()
+
+        # install, no URL
+        sys.argv = ['kalliope.py', 'install']
+        with self.assertRaises(SystemExit):
+            main()
+
+        sys.argv = ['kalliope.py', 'install', '--git-url']
+        with self.assertRaises(SystemExit):
+            main()
+
+        # uninstall
+        sys.argv = ['kalliope.py', 'uninstall', '--neuron-name', 'neuron_name']
+        with mock.patch('kalliope.core.ResourcesManager.uninstall') as mock_resource_manager:
+            mock_resource_manager.return_value = None
+            main()
+            mock_resource_manager.assert_called()
+
+        sys.argv = ['kalliope.py', 'uninstall']
+        with self.assertRaises(SystemExit):
+            main()
+
+
+if __name__ == '__main__':
+    unittest.main()
+
+    # suite = unittest.TestSuite()
+    # suite.addTest(TestInit("test_main"))
+    # runner = unittest.TextTestRunner()
+    # runner.run(suite)

+ 37 - 28
kalliope/__init__.py

@@ -38,9 +38,12 @@ def signal_handler(signal, frame):
 ACTION_LIST = ["start", "gui", "install", "uninstall"]
 
 
-def main():
-    """Entry point of Kalliope program."""
-
+def parse_args(args):
+    """
+    Parsing function
+    :param args: arguments passed from the command line
+    :return: return parser
+    """
     # create arguments
     parser = argparse.ArgumentParser(description='Kalliope')
     parser.add_argument("action", help="[start|gui|install|uninstall]")
@@ -59,52 +62,58 @@ def main():
                         version='Kalliope ' + version_str)
 
     # parse arguments from script parameters
-    args = parser.parse_args()
+    return parser.parse_args(args)
 
-    # require at least one parameter, the action
-    if len(sys.argv[1:]) == 0:
-        parser.print_usage()
+
+def main():
+    """Entry point of Kalliope program."""
+    # parse argument. the script name is removed
+    try:
+        parser = parse_args(sys.argv[1:])
+    except SystemExit:
         sys.exit(1)
 
     # check if we want debug
-    configure_logging(debug=args.debug)
+    configure_logging(debug=parser.debug)
 
-    logger.debug("kalliope args: %s" % args)
+    logger.debug("kalliope args: %s" % parser)
 
     # by default, no brain file is set.
     # Use the default one: brain.yml in the root path
     brain_file = None
 
     # check if user set a brain.yml file
-    if args.brain_file:
-        brain_file = args.brain_file
+    if parser.brain_file:
+        brain_file = parser.brain_file
 
     # check the user provide a valid action
-    if args.action not in ACTION_LIST:
-        Utils.print_warning("%s is not a recognised action\n" % args.action)
-        parser.print_help()
+    if parser.action not in ACTION_LIST:
+        Utils.print_warning("%s is not a recognised action\n" % parser.action)
+        sys.exit(1)
 
     # install modules
-    if args.action == "install":
-        if not args.git_url:
+    if parser.action == "install":
+        if not parser.git_url:
             Utils.print_danger("You must specify the git url")
+            sys.exit(1)
         else:
             parameters = {
-                "git_url": args.git_url
+                "git_url": parser.git_url
             }
             res_manager = ResourcesManager(**parameters)
             res_manager.install()
         return
 
     # uninstall modules
-    if args.action == "uninstall":
-        if not args.neuron_name and not args.stt_name and not args.tts_name and not args.trigger_name:
+    if parser.action == "uninstall":
+        if not parser.neuron_name and not parser.stt_name and not parser.tts_name and not parser.trigger_name:
             Utils.print_danger("You must specify a module name with --neuron-name or --stt-name or --tts-name "
                                "or --trigger-name")
+            sys.exit(1)
         else:
             res_manager = ResourcesManager()
-            res_manager.uninstall(neuron_name=args.neuron_name, stt_name=args.stt_name,
-                                  tts_name=args.tts_name, trigger_name=args.trigger_name)
+            res_manager.uninstall(neuron_name=parser.neuron_name, stt_name=parser.stt_name,
+                                  tts_name=parser.tts_name, trigger_name=parser.trigger_name)
         return
 
     # load the brain once
@@ -116,20 +125,20 @@ def main():
     settings_loader = SettingLoader()
     settings = settings_loader.settings
 
-    if args.action == "start":
+    if parser.action == "start":
 
         # user set a synapse to start
-        if args.run_synapse is not None:
-            SynapseLauncher.start_synapse_by_name(args.run_synapse,
+        if parser.run_synapse is not None:
+            SynapseLauncher.start_synapse_by_name(parser.run_synapse,
                                                   brain=brain)
 
-        if args.run_order is not None:
-            SynapseLauncher.run_matching_synapse_from_order(args.run_order,
+        if parser.run_order is not None:
+            SynapseLauncher.run_matching_synapse_from_order(parser.run_order,
                                                             brain=brain,
                                                             settings=settings,
                                                             is_api_call=False)
 
-        if (args.run_synapse is None) and (args.run_order is None):
+        if (parser.run_synapse is None) and (parser.run_order is None):
             # first, load events in event manager
             EventManager(brain.synapses)
             Utils.print_success("Events loaded")
@@ -141,7 +150,7 @@ def main():
             # start the state machine
             MainController(brain=brain)
 
-    if args.action == "gui":
+    if parser.action == "gui":
         ShellGui(brain=brain)
 
 

+ 2 - 0
kalliope/core/__init__.py

@@ -9,3 +9,5 @@ from kalliope.core.SynapseLauncher import SynapseLauncher
 from kalliope.core.LIFOBuffer import LIFOBuffer
 from kalliope.core.NeuronParameterLoader import NeuronParameterLoader
 from kalliope.core.NeuronModule import NeuronModule
+from kalliope.core.MainController import MainController
+from kalliope.core.EventManager import EventManager