hunk.code_window:         metavar="DOMAIN", action=_DomainsAction, default=[],
           help="Domain names to apply. For multiple domains you can use "
                "multiple -d flags or enter a comma separated list of domains "
                "as a parameter. (default: Ask)")
       helpful.add(
           [None, "run", "certonly", "manage", "rename", "delete"],
           "--cert-name", dest="certname",
           metavar="CERTNAME", default=None,
           help="Certificate name to apply. Only one certificate name can be used "
                "per Certbot run. To see certificate names, run 'certbot certificates'. "
                "When creating a new certificate, specifies the new certificate's name.")
  
hunk.labels: keep keep keep keep keep replace keep keep keep keep keep
hunk.after_edit:         [None, "run", "certonly", "manage", "rename", "delete", "certificates"],
  
hunk.file_path: certbot/cli.py
hunk.type: replace
file: """Tests for acme.standalone."""
  import os
  import shutil
  import threading
  import tempfile
  import time
  import unittest
  
  from six.moves import http_client  # pylint: disable=import-error
  from six.moves import socketserver  # pylint: disable=import-error
  
  import requests
  
  from acme import challenges
  from acme import crypto_util
  from acme import errors
  from acme import jose
  from acme import test_util
  
  
  class TLSServerTest(unittest.TestCase):
      """Tests for acme.standalone.TLSServer."""
  
      _multiprocess_can_split_ = True
  
      def test_bind(self):  # pylint: disable=no-self-use
          from acme.standalone import TLSServer
          server = TLSServer(
              ('', 0), socketserver.BaseRequestHandler, bind_and_activate=True)
          server.server_close()  # pylint: disable=no-member
  
  
  class TLSSNI01ServerTest(unittest.TestCase):
      """Test for acme.standalone.TLSSNI01Server."""
  
      _multiprocess_can_split_ = True
  
      def setUp(self):
          self.certs = {b'localhost': (
              test_util.load_pyopenssl_private_key('rsa2048_key.pem'),
              test_util.load_cert('rsa2048_cert.pem'),
          )}
          from acme.standalone import TLSSNI01Server
          self.server = TLSSNI01Server(("", 0), certs=self.certs)
          # pylint: disable=no-member
          self.thread = threading.Thread(target=self.server.serve_forever)
          self.thread.start()
  
      def tearDown(self):
          self.server.shutdown()  # pylint: disable=no-member
          self.thread.join()
  
      def test_it(self):
          host, port = self.server.socket.getsockname()[:2]
          cert = crypto_util.probe_sni(
              b'localhost', host=host, port=port, timeout=1)
          self.assertEqual(jose.ComparableX509(cert),
                           jose.ComparableX509(self.certs[b'localhost'][1]))
  
  
  class HTTP01ServerTest(unittest.TestCase):
      """Tests for acme.standalone.HTTP01Server."""
  
      _multiprocess_can_split_ = True
  
      def setUp(self):
          self.account_key = jose.JWK.load(
              test_util.load_vector('rsa1024_key.pem'))
          self.resources = set()
  
          from acme.standalone import HTTP01Server
          self.server = HTTP01Server(('', 0), resources=self.resources)
  
          # pylint: disable=no-member
          self.port = self.server.socket.getsockname()[1]
          self.thread = threading.Thread(target=self.server.serve_forever)
          self.thread.start()
  
      def tearDown(self):
          self.server.shutdown()  # pylint: disable=no-member
          self.thread.join()
  
      def test_index(self):
          response = requests.get(
              'http://localhost:{0}'.format(self.port), verify=False)
          self.assertEqual(
              response.text, 'ACME client standalone challenge solver')
          self.assertTrue(response.ok)
  
      def test_404(self):
          response = requests.get(
              'http://localhost:{0}/foo'.format(self.port), verify=False)
          self.assertEqual(response.status_code, http_client.NOT_FOUND)
  
      def _test_http01(self, add):
          chall = challenges.HTTP01(token=(b'x' * 16))
          response, validation = chall.response_and_validation(self.account_key)
  
          from acme.standalone import HTTP01RequestHandler
          resource = HTTP01RequestHandler.HTTP01Resource(
              chall=chall, response=response, validation=validation)
          if add:
              self.resources.add(resource)
          return resource.response.simple_verify(
              resource.chall, 'localhost', self.account_key.public_key(),
              port=self.port)
  
      def test_http01_found(self):
          self.assertTrue(self._test_http01(add=True))
  
      def test_http01_not_found(self):
          self.assertFalse(self._test_http01(add=False))
  
  
  class TestSimpleTLSSNI01Server(unittest.TestCase):
      """Tests for acme.standalone.simple_tls_sni_01_server."""
  
      _multiprocess_can_split_ = True
  
      def setUp(self):
          # mirror ../examples/standalone
          self.test_cwd = tempfile.mkdtemp()
          localhost_dir = os.path.join(self.test_cwd, 'localhost')
          os.makedirs(localhost_dir)
          shutil.copy(test_util.vector_path('rsa2048_cert.pem'),
                      os.path.join(localhost_dir, 'cert.pem'))
          shutil.copy(test_util.vector_path('rsa2048_key.pem'),
                      os.path.join(localhost_dir, 'key.pem'))
  
          from acme.standalone import simple_tls_sni_01_server
          self.port = 1234
          self.thread = threading.Thread(
              target=simple_tls_sni_01_server, kwargs={
                  'cli_args': ('xxx', '--port', str(self.port)),
                  'forever': False,
              },
          )
          self.old_cwd = os.getcwd()
          os.chdir(self.test_cwd)
          self.thread.start()
  
      def tearDown(self):
          os.chdir(self.old_cwd)
          self.thread.join()
          shutil.rmtree(self.test_cwd)
  
      def test_it(self):
          max_attempts = 5
          while max_attempts:
              max_attempts -= 1
              try:
                  cert = crypto_util.probe_sni(
                      b'localhost', b'0.0.0.0', self.port)
              except errors.Error:
                  self.assertTrue(max_attempts > 0, "Timeout!")
                  time.sleep(1)  # wait until thread starts
              else:
                  self.assertEqual(jose.ComparableX509(cert),
                                   test_util.load_comparable_cert(
                                       'rsa2048_cert.pem'))
                  break
  
  
  if __name__ == "__main__":
      unittest.main()  # pragma: no cover
  