Unit tests, mapping overridden

Author: 8r2y5

base_plugin.py

@@ -4,15 +4,15 @@
 from packets import Packets
 
 
-packet_name_regex = re.compile(r'(on|after)_(?P<packet_name>\w+)')
+packet_name_regex = re.compile(r'(?P<when>on|after)_(?P<packet_name>\w+)')
 
 
 class MapOverridePacketsMethods(type):
     ignored_methods = ('activate', 'deactivate')
 
     def __new__(cls, name, bases, cls_dict):
         if name != 'BasePlugin':
-            cls_dict['override_packets'] = []
+            cls_dict['override_packets'] = {}
             methods = (
                 key for key, value in cls_dict.iteritems()
                 if key not in cls.ignored_methods and callable(value)
@@ -22,8 +22,10 @@ def __new__(cls, name, bases, cls_dict):
                 if packet:
                     packet_name = packet.group('packet_name').upper()
                     enum = getattr(Packets, packet_name, None)
-                    if enum and enum.value not in cls_dict['override_packets']:
-                        cls_dict['override_packets'].append(enum.value)
+                    if enum:
+                        cls_dict['override_packets'].setdefault(
+                            enum.value, {}
+                        )[packet.group('when')] = packet_method_name
 
         return super(MapOverridePacketsMethods, cls).__new__(
             cls, name, bases, cls_dict
@@ -56,6 +58,15 @@ class BasePlugin(object):
     depends = []
     active = True
 
+    def __init__(self, *args, **kwargs):
+        super(BasePlugin, self).__init__(*args, **kwargs)
+        if self.__class__.__name__ != 'BasePlugin':
+            for packet, when_dict in self.override_packets.iteritems():
+                for when, packet_name in when_dict.iteritems():
+                    self.override_packets[packet][when] = getattr(
+                        self, packet_name
+                    )
+
     def activate(self):
         """
         Called when the plugins are activated, do any setup work here.
@@ -403,11 +414,14 @@ def after_fly_ship(self, data):
     def after_central_structure_update(self, data):
         return True
 
-    def __repr__(self):
-        return '<Plugin instance: {} (version {})>'.format(
+    def __unicode__(self):
+        return u'<Plugin instance: {} (version {})>'.format(
             self.name, self.version
         )
 
+    def __str__(self):
+        return self.__unicode__()
+
 
 class CommandNameError(Exception):
     """

plugin_manager.py

@@ -52,6 +52,7 @@ def __init__(self, factory, base_class=BasePlugin):
 
         :param base_class: The base class to use while searching for plugins.
         """
+        self.packets = {}
         self.plugins = {}
         self.plugin_classes = {}
         self.plugins_waiting_to_load = {}
@@ -216,6 +217,7 @@ def activate_plugins(self, plugins, dependencies):
                     for p in plugin_deps:
                         self.plugin_classes[plugin.name].plugins[p.name] = p
                 self.plugins[plugin.name].activate()
+                self.map_plugin_packets(plugin)
             except FatalPluginError as e:
                 self.logger.critical(
                     'A plugin reported a fatal error. Error: %s', str(e)
@@ -231,8 +233,9 @@ def deactivate_plugins(self):
                     'A plugin reported a fatal error. Error: %s', str(e)
                 )
                 raise
+            self.de_map_plugin_packets(plugin)
 
-    def do(self, protocol, command, data):
+    def do(self, protocol, when, data):
         """
         Runs a command across all currently loaded plugins.
 
@@ -247,27 +250,45 @@ def do(self, protocol, command, data):
             return True
 
         return_values = []
-        plugins = (
-            plugin for plugin in self.plugins.itervalues()
-            if plugin.active and data.id in plugin.override_packets
-        )
-        for plugin in plugins:
+        packets = self.packets.get(data.id, {}).get(when, {}).itervalues()
+        for plugin, packet_method in packets:
             try:
                 plugin.protocol = protocol
-                res = getattr(plugin, command, lambda _: True)(data)
+                res = packet_method(data)
                 if res is None:
                     res = True
                 return_values.append(res)
             except:
                 self.logger.exception(
                     'Error in plugin %s with function %s.',
-                    str(plugin), command
+                    str(plugin), packet_method.__name__
                 )
         return all(return_values)
 
     def die(self):
         self.deactivate_plugins()
 
+    def map_plugin_packets(self, plugin):
+        """
+        Maps plugin overridden packets ready to use in do method.
+        """
+        for packet_id, when_dict in plugin.override_packets.iteritems():
+            for when, packet_method in when_dict.iteritems():
+                self.packets.setdefault(
+                    packet_id, {}
+                ).setdefault(
+                    when, {}
+                )[plugin.name] = (plugin, packet_method)
+
+    def de_map_plugin_packets(self, plugin):
+        """
+        Removes plugin overridden packets method from packets dictionary.
+        """
+        for packet_id, when_dict in self.packets.iteritems():
+            for when, plugins in when_dict.iteritems():
+                if plugin.name in plugins:
+                    plugins.pop(plugin.name)
+
 
 def route(func):
     """
@@ -276,18 +297,15 @@ def route(func):
     logger = logging.getLogger('starrypy.plugin_manager.route')
 
     def wrapped_function(self, data):
-        name = func.__name__
-        on = 'on_%s' % name
-        after = 'after_%s' % name
-        res = self.plugin_manager.do(self, on, data)
+        res = self.plugin_manager.do(self, 'on', data)
         if res:
             res = func(self, data)
             d = deferLater(
                 reactor,
                 .01,
                 self.plugin_manager.do,
                 self,
-                after,
+                'after',
                 data
             )
             d.addErrback(print_this_defered_failure)

tests/test_base_plugin.py

@@ -21,7 +21,28 @@ class TestPlugin2(BasePlugin):
             def on_burn_container(self, data):
                 pass
 
+            def after_burn_container(self, data):
+                pass
+
         test_plugin2 = TestPlugin2()
         test_plugin = TestPlugin()
-        self.assertListEqual(test_plugin.override_packets, [5, 14])
-        self.assertListEqual(test_plugin2.override_packets, [44])
+        self.assertDictEqual(
+            test_plugin.override_packets,
+            {
+                5: {
+                    'on': test_plugin.on_chat_received
+                },
+                14: {
+                    'on': test_plugin.on_chat_sent
+                }
+            }
+        )
+        self.assertDictEqual(
+            test_plugin2.override_packets,
+            {
+                44: {
+                    'on': test_plugin2.on_burn_container,
+                    'after': test_plugin2.after_burn_container
+                }
+            }
+        )

tests/test_plugin_manager.py

@@ -101,19 +101,3 @@ def test_installed_plugins(self, mock_config, mock_path, mock_sys):
         result = pm.installed_plugins()
 
         self.assertListEqual(result, ['plugin'])
-
-    @patch('plugin_manager.__import__')
-    @patch('plugin_manager.inspect.getmembers')
-    @patch('plugin_manager.sys')
-    @patch('plugin_manager.path')
-    @patch('plugin_manager.ConfigurationManager')
-    def test_import_plugin(
-        self,
-        mock_config,
-        mock_path,
-        mock_sys,
-        mock_getmembers,
-        mock_import
-    ):
-        mock_factory = Mock()
-        mock_import.return_value = ''