New interfaces for installers to run tasks on renew verb (#5879)

* ServerTLSUpdater and InstallerSpecificUpdater implementation

* Fixed tests and added disables for linter :/

* Added error logging for misconfigurationerror from plugin check

* Remove redundant parameter from interfaces

* Renaming the interfaces

* Finalize interface renaming and move tests to own file

* Refactored the runners

* Refactor the cli params

* Fix the interface args

* Fixed documentation

* Documentation and naming fixes

* Remove ServerTLSConfigurationUpdater

* Remove unnecessary linter disable

* Rename run_renewal_updaters to run_generic_updaters

* Do not raise exception, but make log message more informative and visible for the user

* Run renewal deployer before installer restart

certbot/tests/main_test.py

@@ -23,6 +23,7 @@ from certbot import configuration
 from certbot import crypto_util
 from certbot import errors
 from certbot import main
+from certbot import updater
 from certbot import util
 
 from certbot.plugins import disco
@@ -1232,7 +1233,9 @@ class MainTest(test_util.ConfigTestCase):  # pylint: disable=too-many-public-met
         self._test_renew_common(renewalparams=renewalparams, error_expected=True,
                                 names=names, assert_oc_called=False)
 
-    def test_renew_with_configurator(self):
+    @mock.patch('certbot.plugins.selection.choose_configurator_plugins')
+    def test_renew_with_configurator(self, mock_sel):
+        mock_sel.return_value = (mock.MagicMock(), mock.MagicMock())
         renewalparams = {'authenticator': 'webroot'}
         self._test_renew_common(
             renewalparams=renewalparams, assert_oc_called=True,
@@ -1448,6 +1451,18 @@ class MainTest(test_util.ConfigTestCase):  # pylint: disable=too-many-public-met
                             email in mock_utility().add_message.call_args[0][0])
                         self.assertTrue(mock_handle.called)
 
+    @mock.patch('certbot.plugins.selection.choose_configurator_plugins')
+    def test_plugin_selection_error(self, mock_choose):
+        mock_choose.side_effect = errors.PluginSelectionError
+        self.assertRaises(errors.PluginSelectionError, main.renew_cert,
+                          None, None, None)
+
+        with mock.patch('certbot.updater.logger.warning') as mock_log:
+            updater.run_generic_updaters(None, None, None)
+            self.assertTrue(mock_log.called)
+            self.assertTrue("Could not choose appropriate plugin for updaters"
+                            in mock_log.call_args[0][0])
+
 
 class UnregisterTest(unittest.TestCase):
     def setUp(self):

certbot/tests/renewupdater_test.py

@@ -0,0 +1,76 @@
+"""Tests for renewal updater interfaces"""
+import unittest
+import mock
+
+from certbot import interfaces
+from certbot import main
+from certbot import updater
+
+import certbot.tests.util as test_util
+
+
+class RenewUpdaterTest(unittest.TestCase):
+    """Tests for interfaces.RenewDeployer and interfaces.GenericUpdater"""
+
+    def setUp(self):
+        class MockInstallerGenericUpdater(interfaces.GenericUpdater):
+            """Mock class that implements GenericUpdater"""
+            def __init__(self, *args, **kwargs):
+                # pylint: disable=unused-argument
+                self.restart = mock.MagicMock()
+                self.callcounter = mock.MagicMock()
+            def generic_updates(self, domain, *args, **kwargs):
+                self.callcounter(*args, **kwargs)
+
+        class MockInstallerRenewDeployer(interfaces.RenewDeployer):
+            """Mock class that implements RenewDeployer"""
+            def __init__(self, *args, **kwargs):
+                # pylint: disable=unused-argument
+                self.callcounter = mock.MagicMock()
+            def renew_deploy(self, lineage, *args, **kwargs):
+                self.callcounter(*args, **kwargs)
+
+        self.generic_updater = MockInstallerGenericUpdater()
+        self.renew_deployer = MockInstallerRenewDeployer()
+
+    def get_config(self, args):
+        """Get mock config from dict of parameters"""
+        config = mock.MagicMock()
+        for key in args.keys():
+            config.__dict__[key] = args[key]
+        return config
+
+    @mock.patch('certbot.main._get_and_save_cert')
+    @mock.patch('certbot.plugins.selection.choose_configurator_plugins')
+    @test_util.patch_get_utility()
+    def test_server_updates(self, _, mock_select, mock_getsave):
+        config = self.get_config({"disable_renew_updates": False})
+
+        lineage = mock.MagicMock()
+        lineage.names.return_value = ['firstdomain', 'seconddomain']
+        mock_getsave.return_value = lineage
+        mock_generic_updater = self.generic_updater
+
+        # Generic Updater
+        mock_select.return_value = (mock_generic_updater, None)
+        with mock.patch('certbot.main._init_le_client'):
+            main.renew_cert(config, None, mock.MagicMock())
+        self.assertTrue(mock_generic_updater.restart.called)
+
+        mock_generic_updater.restart.reset_mock()
+        mock_generic_updater.callcounter.reset_mock()
+        updater.run_generic_updaters(config, None, lineage)
+        self.assertEqual(mock_generic_updater.callcounter.call_count, 2)
+        self.assertFalse(mock_generic_updater.restart.called)
+
+    def test_renew_deployer(self):
+        config = self.get_config({"disable_renew_updates": False})
+        lineage = mock.MagicMock()
+        lineage.names.return_value = ['firstdomain', 'seconddomain']
+        mock_deployer = self.renew_deployer
+        updater.run_renewal_deployer(lineage, mock_deployer, config)
+        self.assertTrue(mock_deployer.callcounter.called_with(lineage))
+
+
+if __name__ == '__main__':
+    unittest.main()  # pragma: no cover