Merge remote-tracking branch 'origin/master' into non-interactive

(Merge conflict due to PEP8iness)

letsencrypt/tests/cli_test.py

@@ -442,11 +442,11 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         chain_path = '/etc/letsencrypt/live/foo.bar/fullchain.pem'
 
         mock_lineage = mock.MagicMock(cert=cert_path, fullchain=chain_path)
-        mock_cert = mock.MagicMock(body='body')
+        mock_certr = mock.MagicMock()
         mock_key = mock.MagicMock(pem='pem_key')
         mock_renewal.return_value = ("renew", mock_lineage)
         mock_client = mock.MagicMock()
-        mock_client.obtain_certificate.return_value = (mock_cert, 'chain',
+        mock_client.obtain_certificate.return_value = (mock_certr, 'chain',
                                                        mock_key, 'csr')
         mock_init.return_value = mock_client
         with mock.patch('letsencrypt.cli.OpenSSL'):

letsencrypt/tests/client_test.py

@@ -141,9 +141,9 @@ class ClientTest(unittest.TestCase):
         tmp_path = tempfile.mkdtemp()
         os.chmod(tmp_path, 0o755)  # TODO: really??
 
-        certr = mock.MagicMock(body=test_util.load_cert(certs[0]))
-        chain_cert = [test_util.load_cert(certs[1]),
-                      test_util.load_cert(certs[2])]
+        certr = mock.MagicMock(body=test_util.load_comparable_cert(certs[0]))
+        chain_cert = [test_util.load_comparable_cert(certs[1]),
+                      test_util.load_comparable_cert(certs[2])]
         candidate_cert_path = os.path.join(tmp_path, "certs", "cert.pem")
         candidate_chain_path = os.path.join(tmp_path, "chains", "chain.pem")
         candidate_fullchain_path = os.path.join(tmp_path, "chains", "fullchain.pem")

letsencrypt/tests/display/ops_test.py

@@ -407,10 +407,11 @@ class ChooseNamesTest(unittest.TestCase):
                                           "uniçodé.com")
         self.assertEqual(_choose_names_manually(), [])
         # IDN exception with previous mocks
-        with mock.patch("letsencrypt.display.util") as mock_sl:
-            uerror = UnicodeEncodeError('mock', u'',
-                                        0, 1, 'mock')
-            mock_sl.separate_list_input.side_effect = uerror
+        with mock.patch(
+                "letsencrypt.display.ops.display_util.separate_list_input"
+        ) as mock_sli:
+            unicode_error = UnicodeEncodeError('mock', u'', 0, 1, 'mock')
+            mock_sli.side_effect = unicode_error
             self.assertEqual(_choose_names_manually(), [])
         # Punycode and no retry
         mock_util().input.return_value = (display_util.OK,

letsencrypt/tests/renewer_test.py

@@ -9,6 +9,8 @@ import unittest
 import configobj
 import mock
 
+from acme import jose
+
 from letsencrypt import configuration
 from letsencrypt import errors
 from letsencrypt.storage import ALL_FOUR
@@ -379,6 +381,10 @@ class RenewableCertTests(BaseRenewableCertTest):
         self.assertEqual(self.test_rc.names(12),
                          ["example.com", "www.example.com"])
 
+        # Trying missing cert
+        os.unlink(self.test_rc.cert)
+        self.assertRaises(errors.CertStorageError, self.test_rc.names)
+
     @mock.patch("letsencrypt.storage.datetime")
     def test_time_interval_judgments(self, mock_datetime):
         """Test should_autodeploy() and should_autorenew() on the basis
@@ -702,9 +708,10 @@ class RenewableCertTests(BaseRenewableCertTest):
         self.test_rc.configfile["renewalparams"]["authenticator"] = "apache"
         mock_client = mock.MagicMock()
         # pylint: disable=star-args
+        comparable_cert = jose.ComparableX509(CERT)
         mock_client.obtain_certificate.return_value = (
-            mock.MagicMock(body=CERT), [CERT], mock.Mock(pem="key"),
-            mock.sentinel.csr)
+            mock.MagicMock(body=comparable_cert), [comparable_cert],
+            mock.Mock(pem="key"), mock.sentinel.csr)
         mock_c.return_value = mock_client
         self.assertEqual(2, renewer.renew(self.test_rc, 1))
         # TODO: We could also make several assertions about calls that should

letsencrypt/tests/reverter_test.py

@@ -385,6 +385,15 @@ class TestFullCheckpointsReverter(unittest.TestCase):
         self.assertRaises(
             errors.ReverterError, self.reverter.view_config_changes)
 
+    def test_view_config_changes_for_logging(self):
+        self._setup_three_checkpoints()
+
+        config_changes = self.reverter.view_config_changes(for_logging=True)
+
+        self.assertTrue("First Checkpoint" in config_changes)
+        self.assertTrue("Second Checkpoint" in config_changes)
+        self.assertTrue("Third Checkpoint" in config_changes)
+
     def _setup_three_checkpoints(self):
         """Generate some finalized checkpoints."""
         # Checkpoint1 - config1

letsencrypt/tests/test_util.py

@@ -40,16 +40,24 @@ def load_cert(*names):
     """Load certificate."""
     loader = _guess_loader(
         names[-1], OpenSSL.crypto.FILETYPE_PEM, OpenSSL.crypto.FILETYPE_ASN1)
-    return jose.ComparableX509(OpenSSL.crypto.load_certificate(
-        loader, load_vector(*names)))
+    return OpenSSL.crypto.load_certificate(loader, load_vector(*names))
+
+
+def load_comparable_cert(*names):
+    """Load ComparableX509 cert."""
+    return jose.ComparableX509(load_cert(*names))
 
 
 def load_csr(*names):
     """Load certificate request."""
     loader = _guess_loader(
         names[-1], OpenSSL.crypto.FILETYPE_PEM, OpenSSL.crypto.FILETYPE_ASN1)
-    return jose.ComparableX509(OpenSSL.crypto.load_certificate_request(
-        loader, load_vector(*names)))
+    return OpenSSL.crypto.load_certificate_request(loader, load_vector(*names))
+
+
+def load_comparable_csr(*names):
+    """Load ComparableX509 certificate request."""
+    return jose.ComparableX509(load_csr(*names))
 
 
 def load_rsa_private_key(*names):