Преглед изворни кода

Merge pull request #258 from kalliope-project/unittests

Unittests
Monf пре 8 година
родитељ
комит
3b47637c25

+ 11 - 1
Tests/test_file_manager.py

@@ -12,6 +12,10 @@ class TestFileManager(unittest.TestCase):
     def setUp(self):
     def setUp(self):
         pass
         pass
 
 
+    def create_file_manager(self):
+        file_manager = FileManager()
+        self.assertIsInstance(FileManager, file_manager)
+
     def test_create_directory(self):
     def test_create_directory(self):
         """
         """
         Test to create a new directory.
         Test to create a new directory.
@@ -55,6 +59,12 @@ class TestFileManager(unittest.TestCase):
         if os.path.exists(file_path):
         if os.path.exists(file_path):
             os.remove(file_path)
             os.remove(file_path)
 
 
+        # run into IOError by trying to write something in root
+        dir_path = "/root/"
+        file_name = "test_FileManager_writeInFile"
+        file_path = os.path.join(dir_path, file_name)
+        self.assertFalse(FileManager.write_in_file(file_path=file_path, content=in_file_text))
+
     def test_file_is_empty(self):
     def test_file_is_empty(self):
         """
         """
         Test that the file is empty
         Test that the file is empty
@@ -168,4 +178,4 @@ class TestFileManager(unittest.TestCase):
                          "Fail to assert not accessing this path ")
                          "Fail to assert not accessing this path ")
 
 
 if __name__ == '__main__':
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

+ 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"]
 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
     # create arguments
     parser = argparse.ArgumentParser(description='Kalliope')
     parser = argparse.ArgumentParser(description='Kalliope')
     parser.add_argument("action", help="[start|gui|install|uninstall]")
     parser.add_argument("action", help="[start|gui|install|uninstall]")
@@ -59,52 +62,58 @@ def main():
                         version='Kalliope ' + version_str)
                         version='Kalliope ' + version_str)
 
 
     # parse arguments from script parameters
     # 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)
         sys.exit(1)
 
 
     # check if we want debug
     # 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.
     # by default, no brain file is set.
     # Use the default one: brain.yml in the root path
     # Use the default one: brain.yml in the root path
     brain_file = None
     brain_file = None
 
 
     # check if user set a brain.yml file
     # 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
     # 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
     # 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")
             Utils.print_danger("You must specify the git url")
+            sys.exit(1)
         else:
         else:
             parameters = {
             parameters = {
-                "git_url": args.git_url
+                "git_url": parser.git_url
             }
             }
             res_manager = ResourcesManager(**parameters)
             res_manager = ResourcesManager(**parameters)
             res_manager.install()
             res_manager.install()
         return
         return
 
 
     # uninstall modules
     # 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 "
             Utils.print_danger("You must specify a module name with --neuron-name or --stt-name or --tts-name "
                                "or --trigger-name")
                                "or --trigger-name")
+            sys.exit(1)
         else:
         else:
             res_manager = ResourcesManager()
             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
         return
 
 
     # load the brain once
     # load the brain once
@@ -116,20 +125,20 @@ def main():
     settings_loader = SettingLoader()
     settings_loader = SettingLoader()
     settings = settings_loader.settings
     settings = settings_loader.settings
 
 
-    if args.action == "start":
+    if parser.action == "start":
 
 
         # user set a synapse to 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)
                                                   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,
                                                             brain=brain,
                                                             settings=settings,
                                                             settings=settings,
                                                             is_api_call=False)
                                                             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
             # first, load events in event manager
             EventManager(brain.synapses)
             EventManager(brain.synapses)
             Utils.print_success("Events loaded")
             Utils.print_success("Events loaded")
@@ -141,7 +150,7 @@ def main():
             # start the state machine
             # start the state machine
             MainController(brain=brain)
             MainController(brain=brain)
 
 
-    if args.action == "gui":
+    if parser.action == "gui":
         ShellGui(brain=brain)
         ShellGui(brain=brain)
 
 
 
 

+ 3 - 1
kalliope/core/Utils/FileManager.py

@@ -41,6 +41,7 @@ class FileManager:
             return not FileManager.file_is_empty(file_path)
             return not FileManager.file_is_empty(file_path)
         except IOError as e:
         except IOError as e:
             logger.error("I/O error(%s): %s", e.errno, e.strerror)
             logger.error("I/O error(%s): %s", e.errno, e.strerror)
+            return False
 
 
     @staticmethod
     @staticmethod
     def file_is_empty(file_path):
     def file_is_empty(file_path):
@@ -82,5 +83,6 @@ class FileManager:
         """
         """
         try:
         try:
             return os.path.exists(pathname) or FileManager.is_path_creatable(pathname)
             return os.path.exists(pathname) or FileManager.is_path_creatable(pathname)
-        except OSError:
+        except OSError as e:
+            logger.error("OSError(%s): %s", e.errno, e.strerror)
             return False
             return False

+ 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.LIFOBuffer import LIFOBuffer
 from kalliope.core.NeuronParameterLoader import NeuronParameterLoader
 from kalliope.core.NeuronParameterLoader import NeuronParameterLoader
 from kalliope.core.NeuronModule import NeuronModule
 from kalliope.core.NeuronModule import NeuronModule
+from kalliope.core.MainController import MainController
+from kalliope.core.EventManager import EventManager

+ 53 - 0
kalliope/neurons/ansible_playbook/tests/test_ansible_playbook.py

@@ -1,5 +1,9 @@
 import os
 import os
 import unittest
 import unittest
+from collections import namedtuple
+
+import mock
+
 from kalliope.neurons.ansible_playbook import Ansible_playbook
 from kalliope.neurons.ansible_playbook import Ansible_playbook
 from kalliope.core.NeuronModule import MissingParameterException
 from kalliope.core.NeuronModule import MissingParameterException
 
 
@@ -26,10 +30,37 @@ class TestAnsible_Playbook(unittest.TestCase):
         }
         }
         run_test(parameters)
         run_test(parameters)
 
 
+        # missing sudo user
+        parameters = {
+            "sudo": True,
+            "random": self.random
+        }
+        run_test(parameters)
+
+        # missing sudo password
+        parameters = {
+            "sudo": True,
+            "sudo_user": "user"
+        }
+        run_test(parameters)
+
+        # parameters ok
+        parameters = {
+            "task_file": "kalliope/neurons/ansible_playbook/tests/test_ansible_playbook_neuron.yml",
+            "sudo": True,
+            "sudo_user": "user",
+            "sudo_password": "password"
+        }
+
+        with mock.patch("ansible.executor.playbook_executor.PlaybookExecutor.run"):
+            instanciated_neuron = Ansible_playbook(**parameters)
+            self.assertTrue(instanciated_neuron._is_parameters_ok)
+
     def test_create_file_via_ansible_playbook(self):
     def test_create_file_via_ansible_playbook(self):
         """
         """
         This test will use an ansible playbook the create a file. We check that the file has been created
         This test will use an ansible playbook the create a file. We check that the file has been created
         """
         """
+        # without sudo
         param = {
         param = {
             "task_file": "kalliope/neurons/ansible_playbook/tests/test_ansible_playbook_neuron.yml"
             "task_file": "kalliope/neurons/ansible_playbook/tests/test_ansible_playbook_neuron.yml"
         }
         }
@@ -41,6 +72,28 @@ class TestAnsible_Playbook(unittest.TestCase):
         if os.path.exists(self.test_file):
         if os.path.exists(self.test_file):
             os.remove(self.test_file)
             os.remove(self.test_file)
 
 
+        # with sudo
+        param = {
+            "task_file": "kalliope/neurons/ansible_playbook/tests/test_ansible_playbook_neuron.yml",
+            "sudo": True,
+            "sudo_user": "user",
+            "sudo_password": "password"
+        }
+
+        Options = namedtuple('Options',
+                             ['connection', 'forks', 'become', 'become_method', 'become_user', 'check', 'listhosts',
+                              'listtasks', 'listtags', 'syntax', 'module_path'])
+
+        expected_option = Options(connection='local', forks=100, become=True, become_method="sudo",
+                                  become_user="user", check=False, listhosts=False, listtasks=False, listtags=False,
+                                  syntax=False, module_path="")
+
+        with mock.patch("ansible.executor.playbook_executor.PlaybookExecutor.run") as playbookExecutor:
+            instance_neuron = Ansible_playbook(**param)
+            playbookExecutor.assert_called_once()
+
+            self.assertEqual(instance_neuron._get_options(), expected_option)
+
 
 
 if __name__ == '__main__':
 if __name__ == '__main__':
     unittest.main()
     unittest.main()

+ 1 - 0
kalliope/neurons/ansible_playbook/tests/test_ansible_playbook_neuron.retry

@@ -0,0 +1 @@
+localhost