def find_plugins_test(self): """ Test the find_plugins() method to ensure it imports the correct plugins """ # GIVEN: A plugin manager plugin_manager = PluginManager() # WHEN: We mock out sys.platform to make it return "darwin" and then find the plugins old_platform = sys.platform sys.platform = 'darwin' plugin_manager.find_plugins() sys.platform = old_platform # THEN: We should find the "Songs", "Bibles", etc in the plugins list plugin_names = [plugin.name for plugin in plugin_manager.plugins] self.assertIn('songs', plugin_names, 'There should be a "songs" plugin') self.assertIn('bibles', plugin_names, 'There should be a "bibles" plugin') self.assertIn('presentations', plugin_names, 'There should be a "presentations" plugin') self.assertIn('images', plugin_names, 'There should be a "images" plugin') self.assertIn('media', plugin_names, 'There should be a "media" plugin') self.assertIn('custom', plugin_names, 'There should be a "custom" plugin') self.assertIn('songusage', plugin_names, 'There should be a "songusage" plugin') self.assertIn('alerts', plugin_names, 'There should be a "alerts" plugin') self.assertIn('remotes', plugin_names, 'There should be a "remotes" plugin')
def test_hook_settings_tabs_with_disabled_plugin_and_mocked_form(self): """ Test running the hook_settings_tabs() method with a disabled plugin and a mocked form """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] mocked_settings_form = MagicMock() # Replace the autoloaded plugin with the version for testing in real code this would error mocked_settings_form.plugin_manager = plugin_manager # WHEN: We run hook_settings_tabs() plugin_manager.hook_settings_tabs() # THEN: The create_settings_tab() method should not have been called, but the plugins lists should be the same self.assertEqual( 0, mocked_plugin.create_settings_tab.call_count, 'The create_media_manager_item() method should not have been called.' ) self.assertEqual( mocked_settings_form.plugin_manager.plugins, plugin_manager.plugins, 'The plugins on the settings form should be the same as the plugins in the plugin manager' )
def test_hook_settings_tabs_with_active_plugin_and_mocked_form(self): """ Test running the hook_settings_tabs() method with an active plugin and a mocked settings form """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active plugin_manager = PluginManager() Registry().register('mock_plugin', mocked_plugin) mocked_settings_form = MagicMock() # Replace the autoloaded plugin with the version for testing in real code this would error mocked_settings_form.plugin_manager = plugin_manager State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active) State().flush_preconditions() # WHEN: We run hook_settings_tabs() plugin_manager.hook_settings_tabs() # THEN: The create_media_manager_item() method should have been called with the mocked settings form assert 1 == mocked_plugin.create_settings_tab.call_count, \ 'The create_media_manager_item() method should have been called once.' assert plugin_manager.plugins == mocked_settings_form.plugin_manager.plugins, \ 'The plugins on the settings form should be the same as the plugins in the plugin manager'
def test_bootstrap_initialise(self): """ Test the PluginManager.bootstrap_initialise() method """ # GIVEN: A plugin manager with some mocked out methods manager = PluginManager() with patch.object(manager, 'find_plugins') as mocked_find_plugins, \ patch.object(manager, 'hook_settings_tabs') as mocked_hook_settings_tabs, \ patch.object(manager, 'hook_media_manager') as mocked_hook_media_manager, \ patch.object(manager, 'hook_import_menu') as mocked_hook_import_menu, \ patch.object(manager, 'hook_export_menu') as mocked_hook_export_menu, \ patch.object(manager, 'hook_tools_menu') as mocked_hook_tools_menu, \ patch.object(manager, 'initialise_plugins') as mocked_initialise_plugins: # WHEN: bootstrap_initialise() is called manager.bootstrap_initialise() # THEN: The hook methods should have been called mocked_find_plugins.assert_called_with() mocked_hook_settings_tabs.assert_called_with() mocked_hook_media_manager.assert_called_with() mocked_hook_import_menu.assert_called_with() mocked_hook_export_menu.assert_called_with() mocked_hook_tools_menu.assert_called_with() mocked_initialise_plugins.assert_called_with()
def hook_settings_tabs_with_active_plugin_and_mocked_form_test(self): """ Test running the hook_settings_tabs() method with an active plugin and a mocked settings form """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] mocked_settings_form = MagicMock() # Replace the autoloaded plugin with the version for testing in real code this would error mocked_settings_form.plugin_manager = plugin_manager # WHEN: We run hook_settings_tabs() plugin_manager.hook_settings_tabs() # THEN: The create_media_manager_item() method should have been called with the mocked settings form self.assertEqual( 1, mocked_plugin.create_settings_tab.call_count, 'The create_media_manager_item() method should have been called once.' ) self.assertEqual( plugin_manager.plugins, mocked_settings_form.plugin_manager.plugins, 'The plugins on the settings form should be the same as the plugins in the plugin manager' )
def hook_export_menu_with_active_plugin_test(self): """ Test running the hook_export_menu() method with an active plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_export_menu() plugin_manager.hook_export_menu() # THEN: The add_export_menu_item() method should have been called mocked_plugin.add_export_menu_item.assert_called_with(self.mocked_main_window.file_export_menu)
def hook_settings_tabs_with_active_plugin_and_no_form_test(self): """ Test running the hook_settings_tabs() method with an active plugin and no settings form """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_settings_tabs() plugin_manager.hook_settings_tabs() # THEN: The create_settings_tab() method should have been called mocked_plugin.create_settings_tab.assert_called_with(self.mocked_settings_form)
def test_get_plugin_by_name_exists(self): """ Test running the get_plugin_by_name() method to find a plugin that exists """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.name = 'Mocked Plugin' plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run finalise_plugins() result = plugin_manager.get_plugin_by_name('Mocked Plugin') # THEN: The is_active() and finalise() methods should have been called assert result == mocked_plugin, 'The result for get_plugin_by_name should be the mocked plugin'
def test_hook_media_manager_with_active_plugin(self): """ Test running the hook_media_manager() method with an active plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_media_manager() plugin_manager.hook_media_manager() # THEN: The create_media_manager_item() method should have been called mocked_plugin.create_media_manager_item.assert_called_with()
def get_plugin_by_name_exists_test(self): """ Test running the get_plugin_by_name() method to find a plugin that exists """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.name = 'Mocked Plugin' plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run finalise_plugins() result = plugin_manager.get_plugin_by_name('Mocked Plugin') # THEN: The is_active() and finalise() methods should have been called self.assertEqual(result, mocked_plugin, 'The result for get_plugin_by_name should be the mocked plugin')
def hook_media_manager_with_active_plugin_test(self): """ Test running the hook_media_manager() method with an active plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_media_manager() plugin_manager.hook_media_manager() # THEN: The create_media_manager_item() method should have been called mocked_plugin.create_media_manager_item.assert_called_with()
def test_hook_upgrade_plugin_settings_with_active_plugin(self): """ Test running the hook_upgrade_plugin_settings() method with an active plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] settings = Settings() # WHEN: We run hook_upgrade_plugin_settings() plugin_manager.hook_upgrade_plugin_settings(settings) # THEN: The add_export_menu_item() method should have been called mocked_plugin.upgrade_settings.assert_called_with(settings)
def test_hook_media_manager_with_disabled_plugin(self): """ Test running the hook_media_manager() method with a disabled plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_media_manager() plugin_manager.hook_media_manager() # THEN: The create_media_manager_item() method should have been called assert 0 == mocked_plugin.create_media_manager_item.call_count, \ 'The create_media_manager_item() method should not have been called.'
def hook_media_manager_with_disabled_plugin_test(self): """ Test running the hook_media_manager() method with a disabled plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_media_manager() plugin_manager.hook_media_manager() # THEN: The create_media_manager_item() method should have been called assert mocked_plugin.create_media_manager_item.call_count == 0, \ 'The create_media_manager_item() method should not have been called.'
def test_hook_import_menu_with_active_plugin(self): """ Test running the hook_import_menu() method with an active plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_import_menu() plugin_manager.hook_import_menu() # THEN: The add_import_menu_item() method should have been called mocked_plugin.add_import_menu_item.assert_called_with( self.mocked_main_window.file_import_menu)
def test_hook_settings_tabs_with_active_plugin_and_no_form(self): """ Test running the hook_settings_tabs() method with an active plugin and no settings form """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_settings_tabs() plugin_manager.hook_settings_tabs() # THEN: The create_settings_tab() method should have been called mocked_plugin.create_settings_tab.assert_called_with( self.mocked_settings_form)
def hook_tools_menu_with_disabled_plugin_test(self): """ Test running the hook_tools_menu() method with a disabled plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_tools_menu() plugin_manager.hook_tools_menu() # THEN: The add_tools_menu_item() method should have been called self.assertEqual(0, mocked_plugin.add_tools_menu_item.call_count, 'The add_tools_menu_item() method should not have been called.')
def get_plugin_by_name_does_not_exist_test(self): """ Test running the get_plugin_by_name() method to find a plugin that does not exist """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.name = 'Mocked Plugin' plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run finalise_plugins() result = plugin_manager.get_plugin_by_name('Missing Plugin') # THEN: The is_active() and finalise() methods should have been called self.assertIsNone(result, 'The result for get_plugin_by_name should be None')
def hook_settings_tabs_with_disabled_plugin_and_no_form_test(self): """ Test running the hook_settings_tabs() method with a disabled plugin and no form """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_settings_tabs() plugin_manager.hook_settings_tabs() # THEN: The hook_settings_tabs() method should have been called self.assertEqual(0, mocked_plugin.create_media_manager_item.call_count, 'The create_media_manager_item() method should not have been called.')
def hook_upgrade_plugin_settings_with_disabled_plugin_test(self): """ Test running the hook_upgrade_plugin_settings() method with a disabled plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] settings = Settings() # WHEN: We run hook_upgrade_plugin_settings() plugin_manager.hook_upgrade_plugin_settings(settings) # THEN: The upgrade_settings() method should not have been called self.assertEqual(0, mocked_plugin.upgrade_settings.call_count, 'The upgrade_settings() method should not have been called.')
def test_hook_upgrade_plugin_settings_with_disabled_plugin(self): """ Test running the hook_upgrade_plugin_settings() method with a disabled plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] settings = Settings() # WHEN: We run hook_upgrade_plugin_settings() plugin_manager.hook_upgrade_plugin_settings(settings) # THEN: The upgrade_settings() method should not have been called assert 0 == mocked_plugin.upgrade_settings.call_count, \ 'The upgrade_settings() method should not have been called.'
def new_service_created_with_active_plugin_test(self): """ Test running the new_service_created() method with an active plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active mocked_plugin.is_active.return_value = True plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run new_service_created() plugin_manager.new_service_created() # THEN: The is_active() and finalise() methods should have been called mocked_plugin.is_active.assert_called_with() mocked_plugin.new_service_created.assert_called_with()
def finalise_plugins_with_disabled_plugin_test(self): """ Test running the finalise_plugins() method with a disabled plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled mocked_plugin.is_active.return_value = False plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run finalise_plugins() plugin_manager.finalise_plugins() # THEN: The is_active() method should have been called, and initialise() method should NOT have been called mocked_plugin.is_active.assert_called_with() self.assertEqual(0, mocked_plugin.finalise.call_count, 'The finalise() method should not have been called.')
def hook_tools_menu_with_disabled_plugin_test(self): """ Test running the hook_tools_menu() method with a disabled plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_tools_menu() plugin_manager.hook_tools_menu() # THEN: The add_tools_menu_item() method should have been called self.assertEqual( 0, mocked_plugin.add_tools_menu_item.call_count, 'The add_tools_menu_item() method should not have been called.')
def test_new_service_created_with_active_plugin(self): """ Test running the new_service_created() method with an active plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active mocked_plugin.is_active.return_value = True plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run new_service_created() plugin_manager.new_service_created() # THEN: The is_active() and finalise() methods should have been called mocked_plugin.is_active.assert_called_with() mocked_plugin.new_service_created.assert_called_with()
def test_finalise_plugins_with_disabled_plugin(self): """ Test running the finalise_plugins() method with a disabled plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled mocked_plugin.is_active.return_value = False plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run finalise_plugins() plugin_manager.finalise_plugins() # THEN: The is_active() method should have been called, and initialise() method should NOT have been called mocked_plugin.is_active.assert_called_with() assert 0 == mocked_plugin.finalise.call_count, 'The finalise() method should not have been called.'
def hook_settings_tabs_with_disabled_plugin_and_no_form_test(self): """ Test running the hook_settings_tabs() method with a disabled plugin and no form """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run hook_settings_tabs() plugin_manager.hook_settings_tabs() # THEN: The hook_settings_tabs() method should have been called self.assertEqual( 0, mocked_plugin.create_media_manager_item.call_count, 'The create_media_manager_item() method should not have been called.' )
def test_hook_media_manager_with_active_plugin(self): """ Test running the hook_media_manager() method with an active plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active plugin_manager = PluginManager() Registry().register('mock_plugin', mocked_plugin) State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active) State().flush_preconditions() # WHEN: We run hook_media_manager() plugin_manager.hook_media_manager() # THEN: The create_media_manager_item() method should have been called mocked_plugin.create_media_manager_item.assert_called_with()
def test_get_plugin_by_name_exists(self): """ Test running the get_plugin_by_name() method to find a plugin that exists """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.name = 'Mocked Plugin' plugin_manager = PluginManager() Registry().register('mock_plugin', mocked_plugin) State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active) State().flush_preconditions() # WHEN: We run finalise_plugins() result = plugin_manager.get_plugin_by_name('Mocked Plugin') # THEN: The is_active() and finalise() methods should have been called assert result == mocked_plugin, 'The result for get_plugin_by_name should be the mocked plugin'
def test_hook_settings_tabs_with_disabled_plugin_and_mocked_form(self): """ Test running the hook_settings_tabs() method with a disabled plugin and a mocked form """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] mocked_settings_form = MagicMock() # Replace the autoloaded plugin with the version for testing in real code this would error mocked_settings_form.plugin_manager = plugin_manager # WHEN: We run hook_settings_tabs() plugin_manager.hook_settings_tabs() # THEN: The create_settings_tab() method should not have been called, but the plugins lists should be the same self.assertEqual(0, mocked_plugin.create_settings_tab.call_count, 'The create_media_manager_item() method should not have been called.') self.assertEqual(mocked_settings_form.plugin_manager.plugins, plugin_manager.plugins, 'The plugins on the settings form should be the same as the plugins in the plugin manager')
def hook_settings_tabs_with_active_plugin_and_mocked_form_test(self): """ Test running the hook_settings_tabs() method with an active plugin and a mocked settings form """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] mocked_settings_form = MagicMock() # Replace the autoloaded plugin with the version for testing in real code this would error mocked_settings_form.plugin_manager = plugin_manager # WHEN: We run hook_settings_tabs() plugin_manager.hook_settings_tabs() # THEN: The create_media_manager_item() method should have been called with the mocked settings form self.assertEqual(1, mocked_plugin.create_settings_tab.call_count, 'The create_media_manager_item() method should have been called once.') self.assertEqual(plugin_manager.plugins, mocked_settings_form.plugin_manager.plugins, 'The plugins on the settings form should be the same as the plugins in the plugin manager')
def test_hook_tools_menu_with_disabled_plugin(self): """ Test running the hook_tools_menu() method with a disabled plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled plugin_manager = PluginManager() Registry().register('mock_plugin', mocked_plugin) State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active) State().flush_preconditions() # WHEN: We run hook_tools_menu() plugin_manager.hook_tools_menu() # THEN: The add_tools_menu_item() method should have been called assert 0 == mocked_plugin.add_tools_menu_item.call_count, \ 'The add_tools_menu_item() method should not have been called.'
def test_new_service_created_with_active_plugin(self): """ Test running the new_service_created() method with an active plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Active mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Active mocked_plugin.is_active.return_value = True plugin_manager = PluginManager() Registry().register('mock_plugin', mocked_plugin) State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active) State().flush_preconditions() # WHEN: We run new_service_created() plugin_manager.new_service_created() # THEN: The is_active() and finalise() methods should have been called mocked_plugin.is_active.assert_called_with() mocked_plugin.new_service_created.assert_called_with()
def test_finalise_plugins_with_disabled_plugin(self): """ Test running the finalise_plugins() method with a disabled plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled mocked_plugin.is_active.return_value = False plugin_manager = PluginManager() Registry().register('mock_plugin', mocked_plugin) State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active) State().flush_preconditions() # WHEN: We run finalise_plugins() plugin_manager.finalise_plugins() # THEN: The is_active() method should have been called, and initialise() method should NOT have been called mocked_plugin.is_active.assert_called_with() assert 0 == mocked_plugin.finalise.call_count, 'The finalise() method should not have been called.'
def test_find_plugins(self, mocked_is1, mocked_is2, mocked_is3, mocked_is4, mocked_is5): """ Test the find_plugins() method to ensure it imports the correct plugins """ # GIVEN: A plugin manager plugin_manager = PluginManager() plugin_manager.bootstrap_initialise() # WHEN: We mock out sys.platform to make it return "darwin" and then find the plugins old_platform = sys.platform sys.platform = 'darwin' sys.platform = old_platform # THEN: We should find the "Songs", "Bibles", etc in the plugins list plugin_names = [plugin.name for plugin in State().list_plugins()] assert 'songs' in plugin_names, 'There should be a "songs" plugin' assert 'bibles' in plugin_names, 'There should be a "bibles" plugin' assert 'presentations' in plugin_names, 'There should be a "presentations" plugin' assert 'images' in plugin_names, 'There should be a "images" plugin' assert 'media' in plugin_names, 'There should be a "media" plugin' assert 'custom' in plugin_names, 'There should be a "custom" plugin' assert 'songusage' in plugin_names, 'There should be a "songusage" plugin' assert 'alerts' in plugin_names, 'There should be a "alerts" plugin'
def loader(): """ God class to load all the components which are registered with the Registry :return: None """ State().load_settings() MediaController() PluginManager() # Set up the path with plugins ImageManager() Renderer() # Create slide controllers PreviewController() LiveController()