Merge branch 'master' into no_irrelevant_items

letsencrypt/tests/auth_handler_test.py

@@ -126,6 +126,7 @@ class GetAuthorizationsTest(unittest.TestCase):
         for achall in self.mock_auth.cleanup.call_args[0][0]:
             self.assertTrue(achall.typ in ["tls-sni-01", "http-01", "dns"])
 
+        # Length of authorizations list
         self.assertEqual(len(authzr), 1)
 
     @mock.patch("letsencrypt.auth_handler.AuthHandler._poll_challenges")
@@ -162,6 +163,9 @@ class GetAuthorizationsTest(unittest.TestCase):
         self.assertRaises(
             errors.AuthorizationError, self.handler.get_authorizations, ["0"])
 
+    def test_no_domains(self):
+        self.assertRaises(errors.AuthorizationError, self.handler.get_authorizations, [])
+
     def _validate_all(self, unused_1, unused_2):
         for dom in self.handler.authzr.keys():
             azr = self.handler.authzr[dom]

letsencrypt/tests/cli_test.py

@@ -23,6 +23,7 @@ from letsencrypt import constants
 from letsencrypt import crypto_util
 from letsencrypt import errors
 from letsencrypt import le_util
+from letsencrypt import main
 from letsencrypt import storage
 
 from letsencrypt.plugins import disco
@@ -57,16 +58,16 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
 
     def _call(self, args):
         "Run the cli with output streams and actual client mocked out"
-        with mock.patch('letsencrypt.cli.client') as client:
+        with mock.patch('letsencrypt.main.client') as client:
             ret, stdout, stderr = self._call_no_clientmock(args)
             return ret, stdout, stderr, client
 
     def _call_no_clientmock(self, args):
         "Run the client with output streams mocked out"
         args = self.standard_args + args
-        with mock.patch('letsencrypt.cli.sys.stdout') as stdout:
-            with mock.patch('letsencrypt.cli.sys.stderr') as stderr:
-                ret = cli.main(args[:])  # NOTE: parser can alter its args!
+        with mock.patch('letsencrypt.main.sys.stdout') as stdout:
+            with mock.patch('letsencrypt.main.sys.stderr') as stderr:
+                ret = main.main(args[:])  # NOTE: parser can alter its args!
         return ret, stdout, stderr
 
     def _call_stdout(self, args):
@@ -75,20 +76,21 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         caller.
         """
         args = self.standard_args + args
-        with mock.patch('letsencrypt.cli.sys.stderr') as stderr:
-            with mock.patch('letsencrypt.cli.client') as client:
-                ret = cli.main(args[:])  # NOTE: parser can alter its args!
+        with mock.patch('letsencrypt.main.sys.stderr') as stderr:
+            with mock.patch('letsencrypt.main.client') as client:
+                ret = main.main(args[:])  # NOTE: parser can alter its args!
         return ret, None, stderr, client
 
     def test_no_flags(self):
-        with MockedVerb("run") as mock_run:
+        with mock.patch('letsencrypt.main.run') as mock_run:
             self._call([])
             self.assertEqual(1, mock_run.call_count)
 
     def _help_output(self, args):
         "Run a command, and return the ouput string for scrutiny"
+
         output = six.StringIO()
-        with mock.patch('letsencrypt.cli.sys.stdout', new=output):
+        with mock.patch('letsencrypt.main.sys.stdout', new=output):
             self.assertRaises(SystemExit, self._call_stdout, args)
             out = output.getvalue()
             return out
@@ -140,8 +142,8 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         "Ensure that a particular error raises a missing cli flag error containing message"
         exc = None
         try:
-            with mock.patch('letsencrypt.cli.sys.stderr'):
-                cli.main(self.standard_args + args[:])  # NOTE: parser can alter its args!
+            with mock.patch('letsencrypt.main.sys.stderr'):
+                main.main(self.standard_args + args[:])  # NOTE: parser can alter its args!
         except errors.MissingCommandlineFlag as exc:
             self.assertTrue(message in str(exc))
         self.assertTrue(exc is not None)
@@ -151,15 +153,15 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         self._cli_missing_flag(args, "specify a plugin")
         args.extend(['--standalone', '-d', 'eg.is'])
         self._cli_missing_flag(args, "register before running")
-        with mock.patch('letsencrypt.cli._auth_from_domains'):
-            with mock.patch('letsencrypt.cli.client.acme_from_config_key'):
+        with mock.patch('letsencrypt.main._auth_from_domains'):
+            with mock.patch('letsencrypt.main.client.acme_from_config_key'):
                 args.extend(['--email', 'io@io.is'])
                 self._cli_missing_flag(args, "--agree-tos")
 
-    @mock.patch('letsencrypt.cli.client.acme_client.Client')
-    @mock.patch('letsencrypt.cli._determine_account')
-    @mock.patch('letsencrypt.cli.client.Client.obtain_and_enroll_certificate')
-    @mock.patch('letsencrypt.cli._auth_from_domains')
+    @mock.patch('letsencrypt.main.client.acme_client.Client')
+    @mock.patch('letsencrypt.main._determine_account')
+    @mock.patch('letsencrypt.main.client.Client.obtain_and_enroll_certificate')
+    @mock.patch('letsencrypt.main._auth_from_domains')
     def test_user_agent(self, afd, _obt, det, _client):
         # Normally the client is totally mocked out, but here we need more
         # arguments to automate it...
@@ -168,7 +170,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         det.return_value = mock.MagicMock(), None
         afd.return_value = mock.MagicMock(), "newcert"
 
-        with mock.patch('letsencrypt.cli.client.acme_client.ClientNetwork') as acme_net:
+        with mock.patch('letsencrypt.main.client.acme_client.ClientNetwork') as acme_net:
             self._call_no_clientmock(args)
             os_ver = " ".join(le_util.get_os_info())
             ua = acme_net.call_args[1]["user_agent"]
@@ -178,7 +180,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
             if "linux" in plat.lower():
                 self.assertTrue(platform.linux_distribution()[0] in ua)
 
-        with mock.patch('letsencrypt.cli.client.acme_client.ClientNetwork') as acme_net:
+        with mock.patch('letsencrypt.main.client.acme_client.ClientNetwork') as acme_net:
             ua = "bandersnatch"
             args += ["--user-agent", ua]
             self._call_no_clientmock(args)
@@ -190,7 +192,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         chain = 'chain'
         fullchain = 'fullchain'
 
-        with MockedVerb('install') as mock_install:
+        with mock.patch('letsencrypt.main.install') as mock_install:
             self._call(['install', '--cert-path', cert, '--key-path', 'key',
                         '--chain-path', 'chain',
                         '--fullchain-path', 'fullchain'])
@@ -201,8 +203,8 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         self.assertEqual(args.chain_path, os.path.abspath(chain))
         self.assertEqual(args.fullchain_path, os.path.abspath(fullchain))
 
-    @mock.patch('letsencrypt.cli.record_chosen_plugins')
-    @mock.patch('letsencrypt.cli.display_ops')
+    @mock.patch('letsencrypt.main.cli.record_chosen_plugins')
+    @mock.patch('letsencrypt.main.cli.display_ops')
     def test_installer_selection(self, mock_display_ops, _rec):
         self._call(['install', '--domains', 'foo.bar', '--cert-path', 'cert',
                     '--key-path', 'key', '--chain-path', 'chain'])
@@ -241,14 +243,14 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
 
         self._cli_missing_flag(["--standalone"], "With the standalone plugin, you probably")
 
-        with mock.patch("letsencrypt.cli._init_le_client") as mock_init:
-            with mock.patch("letsencrypt.cli._auth_from_domains") as mock_afd:
+        with mock.patch("letsencrypt.main._init_le_client") as mock_init:
+            with mock.patch("letsencrypt.main._auth_from_domains") as mock_afd:
                 mock_afd.return_value = (mock.MagicMock(), mock.MagicMock())
                 self._call(["certonly", "--manual", "-d", "foo.bar"])
                 unused_config, auth, unused_installer = mock_init.call_args[0]
                 self.assertTrue(isinstance(auth, manual.Authenticator))
 
-        with MockedVerb("certonly") as mock_certonly:
+        with mock.patch('letsencrypt.main.obtain_cert') as mock_certonly:
             self._call(["auth", "--standalone"])
             self.assertEqual(1, mock_certonly.call_count)
 
@@ -271,8 +273,8 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
                   for r in xrange(len(flags)))):
             self._call(['plugins'] + list(args))
 
-    @mock.patch('letsencrypt.cli.plugins_disco')
-    @mock.patch('letsencrypt.cli.HelpfulArgumentParser.determine_help_topics')
+    @mock.patch('letsencrypt.main.plugins_disco')
+    @mock.patch('letsencrypt.main.cli.HelpfulArgumentParser.determine_help_topics')
     def test_plugins_no_args(self, _det, mock_disco):
         ifaces = []
         plugins = mock_disco.PluginsRegistry.find_all()
@@ -283,8 +285,8 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         filtered = plugins.visible().ifaces()
         stdout.write.called_once_with(str(filtered))
 
-    @mock.patch('letsencrypt.cli.plugins_disco')
-    @mock.patch('letsencrypt.cli.HelpfulArgumentParser.determine_help_topics')
+    @mock.patch('letsencrypt.main.plugins_disco')
+    @mock.patch('letsencrypt.main.cli.HelpfulArgumentParser.determine_help_topics')
     def test_plugins_init(self, _det, mock_disco):
         ifaces = []
         plugins = mock_disco.PluginsRegistry.find_all()
@@ -298,8 +300,8 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         verified = filtered.verify()
         stdout.write.called_once_with(str(verified))
 
-    @mock.patch('letsencrypt.cli.plugins_disco')
-    @mock.patch('letsencrypt.cli.HelpfulArgumentParser.determine_help_topics')
+    @mock.patch('letsencrypt.main.plugins_disco')
+    @mock.patch('letsencrypt.main.cli.HelpfulArgumentParser.determine_help_topics')
     def test_plugins_prepare(self, _det, mock_disco):
         ifaces = []
         plugins = mock_disco.PluginsRegistry.find_all()
@@ -321,7 +323,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         chain = 'chain'
         fullchain = 'fullchain'
 
-        with MockedVerb('certonly') as mock_obtaincert:
+        with mock.patch('letsencrypt.main.obtain_cert') as mock_obtaincert:
             self._call(['certonly', '--cert-path', cert, '--key-path', 'key',
                         '--chain-path', 'chain',
                         '--fullchain-path', 'fullchain'])
@@ -362,6 +364,10 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
                           self._call,
                           ['-d', '204.11.231.35'])
 
+    def test_csr_with_besteffort(self):
+        args = ["--csr", CSR, "--allow-subset-of-names"]
+        self.assertRaises(errors.Error, self._call, args)
+
     def test_run_with_csr(self):
         # This is an error because you can only use --csr with certonly
         try:
@@ -464,7 +470,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         if domains_arg:
             webroot_map_args.extend(["-d", domains_arg])
         namespace = parse(webroot_map_args)
-        domains = cli._find_domains(namespace, mock.MagicMock()) # pylint: disable=protected-access
+        domains = main._find_domains(namespace, mock.MagicMock()) # pylint: disable=protected-access
         self.assertEqual(namespace.webroot_map, expected_map)
         self.assertEqual(set(domains), set(expectect_domains))
 
@@ -508,9 +514,9 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
                          {"eg.com": "/tmp", "www.eg.com": "/tmp", "eg.is": "/tmp2"})
 
     def _certonly_new_request_common(self, mock_client, args=None):
-        with mock.patch('letsencrypt.cli._treat_as_renewal') as mock_renewal:
+        with mock.patch('letsencrypt.main._treat_as_renewal') as mock_renewal:
             mock_renewal.return_value = ("newcert", None)
-            with mock.patch('letsencrypt.cli._init_le_client') as mock_init:
+            with mock.patch('letsencrypt.main._init_le_client') as mock_init:
                 mock_init.return_value = mock_client
                 if args is None:
                     args = []
@@ -567,17 +573,17 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         mock_client.obtain_certificate.return_value = (mock_certr, 'chain',
                                                        mock_key, 'csr')
         try:
-            with mock.patch('letsencrypt.cli._find_duplicative_certs') as mock_fdc:
+            with mock.patch('letsencrypt.main._find_duplicative_certs') as mock_fdc:
                 mock_fdc.return_value = (mock_lineage, None)
-                with mock.patch('letsencrypt.cli._init_le_client') as mock_init:
+                with mock.patch('letsencrypt.main._init_le_client') as mock_init:
                     mock_init.return_value = mock_client
-                    get_utility_path = 'letsencrypt.cli.zope.component.getUtility'
+                    get_utility_path = 'letsencrypt.main.zope.component.getUtility'
                     with mock.patch(get_utility_path) as mock_get_utility:
-                        with mock.patch('letsencrypt.cli.OpenSSL') as mock_ssl:
+                        with mock.patch('letsencrypt.main.OpenSSL') as mock_ssl:
                             mock_latest = mock.MagicMock()
                             mock_latest.get_issuer.return_value = "Fake fake"
                             mock_ssl.crypto.load_certificate.return_value = mock_latest
-                            with mock.patch('letsencrypt.cli.crypto_util'):
+                            with mock.patch('letsencrypt.main.crypto_util'):
                                 if not args:
                                     args = ['-d', 'isnot.org', '-a', 'standalone', 'certonly']
                                 if extra_args:
@@ -693,9 +699,10 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
             if names is not None:
                 mock_lineage.names.return_value = names
             mock_rc.return_value = mock_lineage
-            with mock.patch('letsencrypt.cli.obtain_cert') as mock_obtain_cert:
+            with mock.patch('letsencrypt.main.obtain_cert') as mock_obtain_cert:
                 kwargs.setdefault('args', ['renew'])
                 self._test_renewal_common(True, None, renew=False, **kwargs)
+
             if assert_oc_called is not None:
                 if assert_oc_called:
                     self.assertTrue(mock_obtain_cert.called)
@@ -754,7 +761,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
             mock_rc.return_value = mock_lineage
             mock_lineage.configuration = {
                 'renewalparams': {'authenticator': 'webroot'}}
-            with mock.patch('letsencrypt.cli.obtain_cert') as mock_obtain_cert:
+            with mock.patch('letsencrypt.main.obtain_cert') as mock_obtain_cert:
                 mock_obtain_cert.side_effect = Exception
                 self._test_renewal_common(True, None, error_expected=True,
                                           args=['renew'], renew=False)
@@ -766,8 +773,8 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
                                   renew=False, error_expected=True)
 
     @mock.patch('letsencrypt.cli.zope.component.getUtility')
-    @mock.patch('letsencrypt.cli._treat_as_renewal')
-    @mock.patch('letsencrypt.cli._init_le_client')
+    @mock.patch('letsencrypt.main._treat_as_renewal')
+    @mock.patch('letsencrypt.main._init_le_client')
     def test_certonly_reinstall(self, mock_init, mock_renewal, mock_get_utility):
         mock_renewal.return_value = ('reinstall', mock.MagicMock())
         mock_init.return_value = mock_client = mock.MagicMock()
@@ -784,9 +791,9 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         mock_client.obtain_certificate_from_csr.return_value = (certr, chain)
         cert_path = '/etc/letsencrypt/live/example.com/cert.pem'
         mock_client.save_certificate.return_value = cert_path, None, None
-        with mock.patch('letsencrypt.cli._init_le_client') as mock_init:
+        with mock.patch('letsencrypt.main._init_le_client') as mock_init:
             mock_init.return_value = mock_client
-            get_utility_path = 'letsencrypt.cli.zope.component.getUtility'
+            get_utility_path = 'letsencrypt.main.zope.component.getUtility'
             with mock.patch(get_utility_path) as mock_get_utility:
                 chain_path = '/etc/letsencrypt/live/example.com/chain.pem'
                 full_path = '/etc/letsencrypt/live/example.com/fullchain.pem'
@@ -795,7 +802,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
                             CSR, cert_path, chain_path, full_path).split()
                 if extra_args:
                     args += extra_args
-                with mock.patch('letsencrypt.cli.crypto_util'):
+                with mock.patch('letsencrypt.main.crypto_util'):
                     self._call(args)
 
         if '--dry-run' in args:
@@ -819,7 +826,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         self.assertTrue(
             'dry run' in mock_get_utility().add_message.call_args[0][0])
 
-    @mock.patch('letsencrypt.cli.client.acme_client')
+    @mock.patch('letsencrypt.main.client.acme_client')
     def test_revoke_with_key(self, mock_acme_client):
         server = 'foo.bar'
         self._call_no_clientmock(['--cert-path', CERT, '--key-path', KEY,
@@ -832,7 +839,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
             mock_revoke = mock_acme_client.Client().revoke
             mock_revoke.assert_called_once_with(jose.ComparableX509(cert))
 
-    @mock.patch('letsencrypt.cli._determine_account')
+    @mock.patch('letsencrypt.main._determine_account')
     def test_revoke_without_key(self, mock_determine_account):
         mock_determine_account.return_value = (mock.MagicMock(), None)
         _, _, _, client = self._call(['--cert-path', CERT, 'revoke'])
@@ -841,7 +848,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
             mock_revoke = client.acme_from_config_key().revoke
             mock_revoke.assert_called_once_with(jose.ComparableX509(cert))
 
-    @mock.patch('letsencrypt.cli.sys')
+    @mock.patch('letsencrypt.main.sys')
     def test_handle_exception(self, mock_sys):
         # pylint: disable=protected-access
         from acme import messages
@@ -849,20 +856,20 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         config = mock.MagicMock()
         mock_open = mock.mock_open()
 
-        with mock.patch('letsencrypt.cli.open', mock_open, create=True):
+        with mock.patch('letsencrypt.main.open', mock_open, create=True):
             exception = Exception('detail')
             config.verbose_count = 1
-            cli._handle_exception(
+            main._handle_exception(
                 Exception, exc_value=exception, trace=None, config=None)
             mock_open().write.assert_called_once_with(''.join(
                 traceback.format_exception_only(Exception, exception)))
             error_msg = mock_sys.exit.call_args_list[0][0][0]
             self.assertTrue('unexpected error' in error_msg)
 
-        with mock.patch('letsencrypt.cli.open', mock_open, create=True):
+        with mock.patch('letsencrypt.main.open', mock_open, create=True):
             mock_open.side_effect = [KeyboardInterrupt]
             error = errors.Error('detail')
-            cli._handle_exception(
+            main._handle_exception(
                 errors.Error, exc_value=error, trace=None, config=None)
             # assert_any_call used because sys.exit doesn't exit in cli.py
             mock_sys.exit.assert_any_call(''.join(
@@ -871,7 +878,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         exception = messages.Error(detail='alpha', typ='urn:acme:error:triffid',
                                    title='beta')
         config = mock.MagicMock(debug=False, verbose_count=-3)
-        cli._handle_exception(
+        main._handle_exception(
             messages.Error, exc_value=exception, trace=None, config=config)
         error_msg = mock_sys.exit.call_args_list[-1][0][0]
         self.assertTrue('unexpected error' in error_msg)
@@ -879,7 +886,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         self.assertTrue('alpha' in error_msg)
         self.assertTrue('beta' in error_msg)
         config = mock.MagicMock(debug=False, verbose_count=1)
-        cli._handle_exception(
+        main._handle_exception(
             messages.Error, exc_value=exception, trace=None, config=config)
         error_msg = mock_sys.exit.call_args_list[-1][0][0]
         self.assertTrue('unexpected error' in error_msg)
@@ -887,7 +894,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         self.assertTrue('alpha' in error_msg)
 
         interrupt = KeyboardInterrupt('detail')
-        cli._handle_exception(
+        main._handle_exception(
             KeyboardInterrupt, exc_value=interrupt, trace=None, config=None)
         mock_sys.exit.assert_called_with(''.join(
             traceback.format_exception_only(KeyboardInterrupt, interrupt)))
@@ -906,7 +913,7 @@ class CLITest(unittest.TestCase):  # pylint: disable=too-many-public-methods
         self.assertEqual(contents, test_contents)
 
     def test_agree_dev_preview_config(self):
-        with MockedVerb('run') as mocked_run:
+        with mock.patch('letsencrypt.main.run') as mocked_run:
             self._call(['-c', test_util.vector_path('cli.ini')])
         self.assertTrue(mocked_run.called)
 
@@ -923,8 +930,8 @@ class DetermineAccountTest(unittest.TestCase):
 
     def _call(self):
         # pylint: disable=protected-access
-        from letsencrypt.cli import _determine_account
-        with mock.patch('letsencrypt.cli.account.AccountFileStorage') as mock_storage:
+        from letsencrypt.main import _determine_account
+        with mock.patch('letsencrypt.main.account.AccountFileStorage') as mock_storage:
             mock_storage.return_value = self.account_storage
             return _determine_account(self.config)
 
@@ -956,7 +963,7 @@ class DetermineAccountTest(unittest.TestCase):
     def test_no_accounts_no_email(self, mock_get_email):
         mock_get_email.return_value = 'foo@bar.baz'
 
-        with mock.patch('letsencrypt.cli.client') as client:
+        with mock.patch('letsencrypt.main.client') as client:
             client.register.return_value = (
                 self.accs[0], mock.sentinel.acme)
             self.assertEqual((self.accs[0], mock.sentinel.acme), self._call())
@@ -968,7 +975,7 @@ class DetermineAccountTest(unittest.TestCase):
 
     def test_no_accounts_email(self):
         self.config.email = 'other email'
-        with mock.patch('letsencrypt.cli.client') as client:
+        with mock.patch('letsencrypt.main.client') as client:
             client.register.return_value = (self.accs[1], mock.sentinel.acme)
             self._call()
         self.assertEqual(self.accs[1].id, self.config.account)
@@ -988,7 +995,7 @@ class DuplicativeCertsTest(storage_test.BaseRenewableCertTest):
 
     @mock.patch('letsencrypt.le_util.make_or_verify_dir')
     def test_find_duplicative_names(self, unused_makedir):
-        from letsencrypt.cli import _find_duplicative_certs
+        from letsencrypt.main import _find_duplicative_certs
         test_cert = test_util.load_vector('cert-san.pem')
         with open(self.test_rc.cert, 'w') as f:
             f.write(test_cert)
@@ -1016,34 +1023,5 @@ class DuplicativeCertsTest(storage_test.BaseRenewableCertTest):
         self.assertEqual(result, (None, None))
 
 
-class MockedVerb(object):
-    """Simple class that can be used for mocking out verbs/subcommands.
-
-    Storing a dictionary of verbs and the functions that implement them
-    in letsencrypt.cli makes mocking much more complicated. This class
-    can be used as a simple context manager for mocking out verbs in CLI
-    tests. For example:
-
-    with MockedVerb("run") as mock_run:
-        self._call([])
-        self.assertEqual(1, mock_run.call_count)
-
-    """
-    def __init__(self, verb_name):
-        self.verb_dict = cli.HelpfulArgumentParser.VERBS
-        self.verb_func = None
-        self.verb_name = verb_name
-
-    def __enter__(self):
-        self.verb_func = self.verb_dict[self.verb_name]
-        mocked_func = mock.MagicMock()
-        self.verb_dict[self.verb_name] = mocked_func
-
-        return mocked_func
-
-    def __exit__(self, unused_type, unused_value, unused_trace):
-        self.verb_dict[self.verb_name] = self.verb_func
-
-
 if __name__ == '__main__':
     unittest.main()  # pragma: no cover

letsencrypt/tests/client_test.py

@@ -63,8 +63,8 @@ class RegisterTest(unittest.TestCase):
     @mock.patch("letsencrypt.client.display_ops.get_email")
     def test_email_retry(self, _rep, mock_get_email):
         from acme import messages
-        msg = "Validation of contact mailto:sousaphone@improbablylongggstring.tld failed"
-        mx_err = messages.Error(detail=msg, typ="malformed", title="title")
+        msg = "DNS problem: NXDOMAIN looking up MX for example.com"
+        mx_err = messages.Error(detail=msg, typ="urn:acme:error:invalidEmail")
         with mock.patch("letsencrypt.client.acme_client.Client") as mock_client:
             mock_client().register.side_effect = [mx_err, mock.MagicMock()]
             self._call()
@@ -96,7 +96,7 @@ class ClientTest(unittest.TestCase):
 
     def setUp(self):
         self.config = mock.MagicMock(
-            no_verify_ssl=False, config_dir="/etc/letsencrypt")
+            no_verify_ssl=False, config_dir="/etc/letsencrypt", allow_subset_of_names=False)
         # pylint: disable=star-args
         self.account = mock.MagicMock(**{"key.pem": KEY})
         self.eg_domains = ["example.com", "www.example.com"]
@@ -115,20 +115,27 @@ class ClientTest(unittest.TestCase):
 
     def _mock_obtain_certificate(self):
         self.client.auth_handler = mock.MagicMock()
+        self.client.auth_handler.get_authorizations.return_value = [None]
         self.acme.request_issuance.return_value = mock.sentinel.certr
         self.acme.fetch_chain.return_value = mock.sentinel.chain
 
     def _check_obtain_certificate(self):
-        self.client.auth_handler.get_authorizations.assert_called_once_with(self.eg_domains)
+        self.client.auth_handler.get_authorizations.assert_called_once_with(
+            self.eg_domains,
+            self.config.allow_subset_of_names)
+
+        authzr = self.client.auth_handler.get_authorizations()
+
         self.acme.request_issuance.assert_called_once_with(
             jose.ComparableX509(OpenSSL.crypto.load_certificate_request(
                 OpenSSL.crypto.FILETYPE_ASN1, CSR_SAN)),
-            self.client.auth_handler.get_authorizations())
+            authzr)
+
         self.acme.fetch_chain.assert_called_once_with(mock.sentinel.certr)
 
     # FIXME move parts of this to test_cli.py...
     @mock.patch("letsencrypt.client.logger")
-    @mock.patch("letsencrypt.cli._process_domain")
+    @mock.patch("letsencrypt.cli.process_domain")
     def test_obtain_certificate_from_csr(self, mock_process_domain, mock_logger):
         self._mock_obtain_certificate()
         from letsencrypt import cli
@@ -151,12 +158,28 @@ class ClientTest(unittest.TestCase):
             self.assertRaises(errors.ConfigurationError,
                 cli.HelpfulArgumentParser.handle_csr, mock_parser, mock_parsed_args)
 
+            authzr = self.client.auth_handler.get_authorizations(self.eg_domains, False)
+
             self.assertEqual(
                 (mock.sentinel.certr, mock.sentinel.chain),
-                self.client.obtain_certificate_from_csr(self.eg_domains, test_csr))
+                self.client.obtain_certificate_from_csr(
+                    self.eg_domains,
+                    test_csr,
+                    authzr=authzr))
             # and that the cert was obtained correctly
             self._check_obtain_certificate()
 
+            # Test for authzr=None
+            self.assertEqual(
+                (mock.sentinel.certr, mock.sentinel.chain),
+                self.client.obtain_certificate_from_csr(
+                    self.eg_domains,
+                    test_csr,
+                    authzr=None))
+
+            self.client.auth_handler.get_authorizations.assert_called_with(
+            self.eg_domains)
+
             # Test for no auth_handler
             self.client.auth_handler = None
             self.assertRaises(
@@ -175,6 +198,21 @@ class ClientTest(unittest.TestCase):
         mock_crypto_util.init_save_key.return_value = mock.sentinel.key
         domains = ["example.com", "www.example.com"]
 
+        # return_value is essentially set to (None, None) in
+        # _mock_obtain_certificate(), which breaks this test.
+        # Thus fixed by the next line.
+
+        authzr = []
+
+        for domain in domains:
+            authzr.append(
+                mock.MagicMock(
+                    body=mock.MagicMock(
+                        identifier=mock.MagicMock(
+                            value=domain))))
+
+        self.client.auth_handler.get_authorizations.return_value = authzr
+
         self.assertEqual(
             self.client.obtain_certificate(domains),
             (mock.sentinel.certr, mock.sentinel.chain, mock.sentinel.key, csr))