浏览代码

add test for BrainLoader

nico 8 年之前
父节点
当前提交
712b267667

+ 1 - 2
core/ConfigurationManager/BrainLoader.py

@@ -22,7 +22,7 @@ class BrainLoader(object):
     """
 
     def __init__(self, file_path=None):
-        logger.debug("Loading brain")
+        logger.debug("Loading brain with file path: %s" % file_path)
         self.file_path = file_path
         self.yaml_config = self.get_yaml_config()
         self.brain = self.get_brain()
@@ -85,7 +85,6 @@ class BrainLoader(object):
         if not ConfigurationChecker().check_synapes(synapses):
             brain = None
 
-
         return brain
 
     @staticmethod

+ 1 - 1
core/ConfigurationManager/ConfigurationChecker.py

@@ -196,7 +196,7 @@ class ConfigurationChecker:
         .. raises:: NoEventPeriod
         .. warnings:: Static and Public
         """
-        if event_dict is None:
+        if event_dict is None or event_dict == "":
             raise NoEventPeriod("Event must contain a period: %s" % event_dict)
         return True
 

+ 8 - 0
core/Models/Brain.py

@@ -9,3 +9,11 @@ class Brain:
         self.synapses = synapses
         self.brain_file = brain_file
         self.brain_yaml = brain_yaml
+
+    def __eq__(self, other):
+        """
+        This is used to compare 2 objects
+        :param other:
+        :return:
+        """
+        return self.__dict__ == other.__dict__

+ 8 - 0
core/Models/Event.py

@@ -23,3 +23,11 @@ class Event(object):
         return {
             'event': self.period
         }
+
+    def __eq__(self, other):
+        """
+        This is used to compare 2 objects
+        :param other:
+        :return:
+        """
+        return self.__dict__ == other.__dict__

+ 11 - 0
core/Models/Neuron.py

@@ -20,3 +20,14 @@ class Neuron(object):
             'name': self.name,
             'parameters': str(self.parameters)
         }
+
+    def __str__(self):
+        return "Neuron: name: %s, parameters: %s" % (self.name, self.parameters)
+
+    def __eq__(self, other):
+        """
+        This is used to compare 2 objects
+        :param other:
+        :return:
+        """
+        return self.__dict__ == other.__dict__

+ 8 - 0
core/Models/Order.py

@@ -22,3 +22,11 @@ class Order(object):
         return {
             'order': self.sentence
         }
+
+    def __eq__(self, other):
+        """
+        This is used to compare 2 objects
+        :param other:
+        :return:
+        """
+        return self.__dict__ == other.__dict__

+ 9 - 1
core/Models/Stt.py

@@ -10,4 +10,12 @@ class Stt(object):
         self.parameters = parameters
 
     def __str__(self):
-        return "Stt name: %s, parameters: %s" % (str(self.name), str(self.parameters))
+        return "Stt name: %s, parameters: %s" % (str(self.name), str(self.parameters))
+
+    def __eq__(self, other):
+        """
+        This is used to compare 2 objects
+        :param other:
+        :return:
+        """
+        return self.__dict__ == other.__dict__

+ 18 - 0
core/Models/Synapse.py

@@ -23,3 +23,21 @@ class Synapse(object):
             'neurons': [e.serialize() for e in self.neurons],
             'signals': [e.serialize() for e in self.signals]
         }
+
+    def __str__(self):
+        return_val = "Synapse name: %s" % self.name
+        return_val += "\nneurons:"
+        for el in self.neurons:
+            return_val += str(el)
+        return_val += "\nsignals:"
+        for el in self.signals:
+            return_val += str(el)
+        return return_val
+
+    def __eq__(self, other):
+        """
+        This is used to compare 2 objects
+        :param other:
+        :return:
+        """
+        return self.__dict__ == other.__dict__

+ 8 - 0
core/Models/Trigger.py

@@ -11,3 +11,11 @@ class Trigger(object):
 
     def __str__(self):
         return "Trigger name: %s, parameters: %s" % (str(self.name), str(self.parameters))
+
+    def __eq__(self, other):
+        """
+        This is used to compare 2 objects
+        :param other:
+        :return:
+        """
+        return self.__dict__ == other.__dict__

+ 7 - 0
core/Models/Tts.py

@@ -12,3 +12,10 @@ class Tts(object):
     def __str__(self):
         return "Tts name: %s, parameters: %s" % (str(self.name), str(self.parameters))
 
+    def __eq__(self, other):
+        """
+        This is used to compare 2 objects
+        :param other:
+        :return:
+        """
+        return self.__dict__ == other.__dict__

+ 55 - 29
core/Tests/test_brain_loader.py

@@ -2,6 +2,7 @@ import unittest
 
 from core.ConfigurationManager import BrainLoader
 from core.Models import Brain
+from core.Models import Event
 from core.Models import Neuron
 from core.Models import Order
 from core.Models import Synapse
@@ -9,9 +10,9 @@ from core.Models import Synapse
 
 class TestBrainLoader(unittest.TestCase):
 
-    def test_get_yaml_config(self):
-        brain_to_test = "core/Tests/brains/brain_test.yml"
-        expected_result = [
+    def setUp(self):
+        self.brain_to_test = "core/Tests/brains/brain_test.yml"
+        self.expected_result = [
             {'signals': [{'order': 'test_order'}],
              'neurons': [{'say': {'message': ['test message']}}],
              'name': 'test'},
@@ -24,46 +25,71 @@ class TestBrainLoader(unittest.TestCase):
              'name': 'test3'}
         ]
 
-        self.assertEqual(BrainLoader.get_yaml_config(brain_to_test), expected_result)
+    def test_get_yaml_config(self):
+        """
+        Test we can get a yaml config from the path
+        """
+        brain_loader = BrainLoader.Instance(file_path=self.brain_to_test)
+        self.assertEqual(brain_loader.yaml_config, self.expected_result)
 
     def test_get_brain(self):
-        brain_to_test = "core/Tests/brains/brain_test.yml"
+        """
+        Test the class return a valid brain object
+        """
 
-        neuron1 = Neuron(name='say', parameters={'message': 'test message'})
-        neuron2 = Neuron(name='say', parameters={'message': 'test message'})
-        neuron3 = Neuron(name='say', parameters={'message': 'test message'})
+        neuron = Neuron(name='say', parameters={'message': ['test message']})
 
         signal1 = Order(sentence="test_order")
         signal2 = Order(sentence="test_order_2")
         signal3 = Order(sentence="test_order_3")
 
-        synapse1 = Synapse(name="Synapse1", neurons=[neuron1], signals={signal1})
-        synapse2 = Synapse(name="Synapse2", neurons=[neuron2], signals={signal2})
-        synapse3 = Synapse(name="Synapse3", neurons=[neuron3], signals={signal3})
+        synapse1 = Synapse(name="test", neurons=[neuron], signals=[signal1])
+        synapse2 = Synapse(name="test2", neurons=[neuron], signals=[signal2])
+        synapse3 = Synapse(name="test3", neurons=[neuron], signals=[signal3])
         synapses = [synapse1, synapse2, synapse3]
 
-        expected_result = [
-            {'signals': [{'order': 'test_order'}],
-             'neurons': [{'say': {'message': ['test message']}}],
-             'name': 'test'},
-            {'signals': [{'order': 'test_order_2'}],
-             'neurons': [{'say': {'message': ['test message']}}],
-             'name': 'test2'},
-            {'includes': ['included_brain_test.yml']},
-            {'signals': [{'order': 'test_order_3'}],
-             'neurons': [{'say': {'message': ['test message']}}],
-             'name': 'test3'}
-        ]
-
         brain = Brain()
         brain.synapses = synapses
-        brain.brain_file = brain_to_test
-        brain.brain_yaml = expected_result
-        brain.is_loaded = False
+        brain.brain_file = self.brain_to_test
+        brain.brain_yaml = self.expected_result
+
+        brain_loader = BrainLoader.Instance(file_path=self.brain_to_test)
+        self.assertEqual(brain, brain_loader.brain)
+
+    def test_get_neurons(self):
+        neuron_list = [{'say': {'message': ['test message']}}]
+
+        neuron = Neuron(name='say', parameters={'message': ['test message']})
+
+        bl = BrainLoader.Instance(file_path=self.brain_to_test)
+        neurons_from_brain_loader = bl._get_neurons(neuron_list)
+
+        self.assertEqual([neuron], neurons_from_brain_loader)
+
+    def test_get_signals(self):
+        signals = [{'order': 'test_order'}]
+
+        signal = Order(sentence='test_order')
+
+        bl = BrainLoader.Instance(file_path=self.brain_to_test)
+        signals_from_brain_loader = bl._get_signals(signals)
+
+        self.assertEqual([signal], signals_from_brain_loader)
+
+    def test_get_event_or_order_from_dict(self):
+
+        order_object = Order(sentence="test_order")
+        event_object = Event(period="0 7 * * *")
+
+        dict_order = {'order': 'test_order'}
+        dict_event = {'event': '0 7 * * *'}
 
-        # TODO this is not working. how to test a singleton?
-        self.assertEqual(brain, BrainLoader.get_brain(file_path=brain_to_test))
+        bl = BrainLoader.Instance(file_path=self.brain_to_test)
+        order_from_bl = bl._get_event_or_order_from_dict(dict_order)
+        event_from_bl = bl._get_event_or_order_from_dict(dict_event)
 
+        self.assertEqual(order_from_bl, order_object)
+        self.assertEqual(event_from_bl, event_object)
 
 
 if __name__ == '__main__':