Finished basic crash recovery

letsencrypt/tests/client_test.py

@@ -178,6 +178,39 @@ class ClientTest(unittest.TestCase):
 
         shutil.rmtree(tmp_path)
 
+    def test_deploy_certificate(self):
+        self.assertRaises(errors.Error, self.client.deploy_certificate,
+                          ["foo.bar"], "key", "cert", "chain")
+
+        installer = mock.MagicMock()
+        self.client.installer = installer
+
+        self.client.deploy_certificate(["foo.bar"], "key", "cert", "chain")
+        installer.deploy_cert.assert_called_once_with(
+            "foo.bar", os.path.abspath("cert"),
+            os.path.abspath("key"), os.path.abspath("chain"))
+        self.assertTrue(installer.save.call_count == 1)
+        installer.restart.assert_called_once_with()
+
+    @mock.patch("letsencrypt.client.enhancements")
+    def test_enhance_config(self, mock_enhancements):
+        self.assertRaises(errors.Error,
+                          self.client.enhance_config, ["foo.bar"])
+
+        mock_enhancements.ask.return_value = True
+        installer = mock.MagicMock()
+        self.client.installer = installer
+
+        self.client.enhance_config(["foo.bar"])
+        installer.enhance.assert_called_once_with("foo.bar", "redirect")
+        self.assertTrue(installer.save.call_count == 1)
+        installer.restart.assert_called_once_with()
+
+        installer.enhance.side_effect = errors.PluginError
+        self.assertRaises(errors.PluginError,
+                          self.client.enhance_config, ["foo.bar"], True)
+        installer.recovery_routine.assert_called_once_with()
+
 
 class RollbackTest(unittest.TestCase):
     """Tests for letsencrypt.client.rollback."""

letsencrypt/tests/error_handler_test.py

@@ -1,25 +1,46 @@
 """Tests for letsencrypt.error_handler."""
+import signal
 import unittest
 
 import mock
 
+from letsencrypt import error_handler
+
 
 class ErrorHandlerTest(unittest.TestCase):
     """Tests for letsencrypt.error_handler."""
 
     def setUp(self):
-        from letsencrypt import error_handler
         self.init_func = mock.MagicMock()
-        self.error_handler = error_handler.ErrorHandler(self.init_func)
+        self.handler = error_handler.ErrorHandler(self.init_func)
 
     def test_context_manager(self):
         try:
-            with self.error_handler:
+            with self.handler:
                 raise ValueError
         except ValueError:
             pass
         self.init_func.assert_called_once_with()
 
+    @mock.patch('letsencrypt.error_handler.os')
+    @mock.patch('letsencrypt.error_handler.signal')
+    def test_signal_handler(self, mock_signal, mock_os):
+        # pylint: disable=protected-access
+        mock_signal.getsignal.return_value = signal.SIG_DFL
+        self.handler.set_signal_handlers()
+        signal_handler = self.handler._signal_handler
+        for signum in error_handler._SIGNALS:
+            mock_signal.signal.assert_any_call(signum, signal_handler)
+
+        signum = error_handler._SIGNALS[0]
+        signal_handler(signum, None)
+        self.init_func.assert_called_once_with()
+        mock_os.kill.assert_called_once_with(mock_os.getpid(), signum)
+
+        self.handler.reset_signal_handlers()
+        for signum in error_handler._SIGNALS:
+            mock_signal.signal.assert_any_call(signum, signal.SIG_DFL)
+
 
 if __name__ == "__main__":
     unittest.main()  # pragma: no cover