From be9021d377167c72148f2f93da9d450a6800a9bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gina=20H=C3=A4u=C3=9Fge?= Date: Thu, 5 Feb 2015 19:20:51 +0100 Subject: [PATCH] Some more unit tests for the plugin manager --- src/octoprint/plugin/core.py | 5 ++- tests/plugin/test_core.py | 86 +++++++++++++++++++++++++++++++++++- 2 files changed, 88 insertions(+), 3 deletions(-) diff --git a/src/octoprint/plugin/core.py b/src/octoprint/plugin/core.py index 973cebf3..6af26056 100644 --- a/src/octoprint/plugin/core.py +++ b/src/octoprint/plugin/core.py @@ -294,7 +294,10 @@ class PluginManager(object): for plugin_type in self.plugin_types: implementations = plugin.get_implementations(plugin_type) self.plugin_implementations_by_type[plugin_type] += ( (name, implementation) for implementation in implementations ) - self.plugin_implementations[name].update(plugin.get_implementations()) + + plugin_implementations = plugin.get_implementations() + if len(plugin_implementations): + self.plugin_implementations[name].update(plugin_implementations) except: self.logger.exception("There was an error loading plugin %s" % name) diff --git a/tests/plugin/test_core.py b/tests/plugin/test_core.py index 7f96182c..22efe1a9 100644 --- a/tests/plugin/test_core.py +++ b/tests/plugin/test_core.py @@ -1,4 +1,5 @@ import unittest +import mock import octoprint.plugin import octoprint.plugin.core @@ -13,14 +14,17 @@ class PluginTestCase(unittest.TestCase): # TODO mock pkg_resources to return some defined entry_points import os - plugin_folders = [os.path.join(os.path.dirname(os.path.realpath(__file__)), "_plugins")] + self.plugin_folder = os.path.join(os.path.dirname(os.path.realpath(__file__)), "_plugins") + + plugin_folders = [self.plugin_folder] plugin_types = [octoprint.plugin.SettingsPlugin, octoprint.plugin.StartupPlugin] plugin_entry_points = None - self.plugin_manager = octoprint.plugin.core.PluginManager(plugin_folders, plugin_types, plugin_entry_points, plugin_disabled_list=[]) + self.plugin_manager = octoprint.plugin.core.PluginManager(plugin_folders, plugin_types, plugin_entry_points, plugin_disabled_list=[], logging_prefix="logging_prefix.") def test_plugin_loading(self): self.assertEquals(4, len(self.plugin_manager.plugins)) self.assertEquals(1, len(self.plugin_manager.plugin_hooks)) + self.assertEquals(3, len(self.plugin_manager.plugin_implementations)) self.assertEquals(2, len(self.plugin_manager.plugin_implementations_by_type)) self.assertTrue("octoprint.core.startup" in self.plugin_manager.plugin_hooks) @@ -32,6 +36,55 @@ class PluginTestCase(unittest.TestCase): self.assertTrue(octoprint.plugin.SettingsPlugin in self.plugin_manager.plugin_implementations_by_type) self.assertEquals(2, len(self.plugin_manager.plugin_implementations_by_type[octoprint.plugin.SettingsPlugin])) + def test_plugin_initializing(self): + + def test_factory(name, implementation): + return dict(test_factory="test_factory_%s" % name) + + def verify_injection_order(name, implementation): + self.assertTrue(hasattr(implementation, "_basefolder")) + return dict() + + additional_injects = dict( + additional_inject="additional_inject" + ) + additional_inject_factories = [test_factory, verify_injection_order] + self.plugin_manager.initialize_implementations( + additional_injects=additional_injects, + additional_inject_factories=additional_inject_factories + ) + + all_implementations = self.plugin_manager.plugin_implementations + self.assertEquals(3, len(all_implementations)) + for name, implementations in all_implementations.items(): + self.assertEquals(1, len(implementations)) + impl = implementations.pop() + + self.assertTrue(name in self.plugin_manager.plugins) + plugin = self.plugin_manager.plugins[name] + + # test that the standard fields were properly initialized + self.assertTrue(hasattr(impl, "_identifier")) + self.assertEquals(name, impl._identifier) + self.assertTrue(hasattr(impl, "_plugin_name")) + self.assertEquals(plugin.name, impl._plugin_name) + self.assertTrue(hasattr(impl, "_plugin_version")) + self.assertEquals(plugin.version, impl._plugin_version) + self.assertTrue(hasattr(impl, "_logger")) + self.assertIsNotNone(impl._logger) + self.assertEquals("logging_prefix.%s" % name, impl._logger.name) + self.assertTrue(hasattr(impl, "_basefolder")) + self.assertTrue(impl._basefolder.startswith(self.plugin_folder)) + + # test that the additional injects were properly injected + self.assertTrue(hasattr(impl, "_additional_inject")) + self.assertEquals("additional_inject", impl._additional_inject) + + # test that the injection factory was properly executed and the result injected + self.assertTrue(hasattr(impl, "_test_factory")) + self.assertEquals("test_factory_%s" % name, impl._test_factory) + + def test_get_plugin(self): plugin = self.plugin_manager.get_plugin("hook_plugin") self.assertIsNotNone(plugin) @@ -67,3 +120,32 @@ class PluginTestCase(unittest.TestCase): implementations = self.plugin_manager.get_implementations(octoprint.plugin.StartupPlugin, octoprint.plugin.SettingsPlugin) self.assertEquals(1, len(implementations)) self.assertTrue('mixed_plugin' in implementations) + + def test_client_registration(self): + client = mock.Mock() + + self.assertEquals(0, len(self.plugin_manager.registered_clients)) + + self.plugin_manager.register_client(client) + + self.assertEquals(1, len(self.plugin_manager.registered_clients)) + self.assertIn(client, self.plugin_manager.registered_clients) + + self.plugin_manager.unregister_client(client) + + self.assertEquals(0, len(self.plugin_manager.registered_clients)) + self.assertNotIn(client, self.plugin_manager.registered_clients) + + def test_send_plugin_message(self): + client1 = mock.Mock() + client2 = mock.Mock() + + self.plugin_manager.register_client(client1) + self.plugin_manager.register_client(client2) + + plugin = "some plugin" + data = "some data" + self.plugin_manager.send_plugin_message(plugin, data) + client1.sendPluginMessage.assert_called_once_with(plugin, data) + client2.sendPluginMessage.assert_called_once_with(plugin, data) +