from typing import List
import unittest

import josepy as jose
import pytz

from certbot import crypto_util, configuration
from certbot import errors
from certbot import interfaces  # pylint: disable=unused-import

            

Reported by Pylint.

              import unittest

import josepy as jose
import pytz

from certbot import crypto_util, configuration
from certbot import errors
from certbot import interfaces  # pylint: disable=unused-import
from certbot import util

            

Reported by Pylint.

              import josepy as jose
import pytz

from certbot import crypto_util, configuration
from certbot import errors
from certbot import interfaces  # pylint: disable=unused-import
from certbot import util
from certbot._internal import account
from certbot._internal import cli

            

Reported by Pylint.

              import pytz

from certbot import crypto_util, configuration
from certbot import errors
from certbot import interfaces  # pylint: disable=unused-import
from certbot import util
from certbot._internal import account
from certbot._internal import cli
from certbot._internal import constants

            

Reported by Pylint.

              
from certbot import crypto_util, configuration
from certbot import errors
from certbot import interfaces  # pylint: disable=unused-import
from certbot import util
from certbot._internal import account
from certbot._internal import cli
from certbot._internal import constants
from certbot._internal import main

            

Reported by Pylint.

              from certbot import crypto_util, configuration
from certbot import errors
from certbot import interfaces  # pylint: disable=unused-import
from certbot import util
from certbot._internal import account
from certbot._internal import cli
from certbot._internal import constants
from certbot._internal import main
from certbot._internal import updater

            

Reported by Pylint.

              from certbot import errors
from certbot import interfaces  # pylint: disable=unused-import
from certbot import util
from certbot._internal import account
from certbot._internal import cli
from certbot._internal import constants
from certbot._internal import main
from certbot._internal import updater
from certbot._internal.plugins import disco

            

Reported by Pylint.

              from certbot import interfaces  # pylint: disable=unused-import
from certbot import util
from certbot._internal import account
from certbot._internal import cli
from certbot._internal import constants
from certbot._internal import main
from certbot._internal import updater
from certbot._internal.plugins import disco
from certbot._internal.plugins import manual

            

Reported by Pylint.

              from certbot import util
from certbot._internal import account
from certbot._internal import cli
from certbot._internal import constants
from certbot._internal import main
from certbot._internal import updater
from certbot._internal.plugins import disco
from certbot._internal.plugins import manual
from certbot._internal.plugins import null

            

Reported by Pylint.

              from certbot._internal import account
from certbot._internal import cli
from certbot._internal import constants
from certbot._internal import main
from certbot._internal import updater
from certbot._internal.plugins import disco
from certbot._internal.plugins import manual
from certbot._internal.plugins import null
from certbot.compat import filesystem

            

Reported by Pylint.

              except ImportError: # pragma: no cover
    from unittest import mock # type: ignore

from acme import challenges
from certbot import achallenges
from certbot import crypto_util
from certbot import errors
from certbot.compat import filesystem
from certbot.compat import os

            

Reported by Pylint.

                  from unittest import mock # type: ignore

from acme import challenges
from certbot import achallenges
from certbot import crypto_util
from certbot import errors
from certbot.compat import filesystem
from certbot.compat import os
from certbot.tests import acme_util

            

Reported by Pylint.

              
from acme import challenges
from certbot import achallenges
from certbot import crypto_util
from certbot import errors
from certbot.compat import filesystem
from certbot.compat import os
from certbot.tests import acme_util
from certbot.tests import util as certbot_util

            

Reported by Pylint.

              from acme import challenges
from certbot import achallenges
from certbot import crypto_util
from certbot import errors
from certbot.compat import filesystem
from certbot.compat import os
from certbot.tests import acme_util
from certbot.tests import util as certbot_util
from certbot_apache._internal import apache_util

            

Reported by Pylint.

              from certbot import achallenges
from certbot import crypto_util
from certbot import errors
from certbot.compat import filesystem
from certbot.compat import os
from certbot.tests import acme_util
from certbot.tests import util as certbot_util
from certbot_apache._internal import apache_util
from certbot_apache._internal import constants

            

Reported by Pylint.

              from certbot import crypto_util
from certbot import errors
from certbot.compat import filesystem
from certbot.compat import os
from certbot.tests import acme_util
from certbot.tests import util as certbot_util
from certbot_apache._internal import apache_util
from certbot_apache._internal import constants
from certbot_apache._internal import obj

            

Reported by Pylint.

              from certbot import errors
from certbot.compat import filesystem
from certbot.compat import os
from certbot.tests import acme_util
from certbot.tests import util as certbot_util
from certbot_apache._internal import apache_util
from certbot_apache._internal import constants
from certbot_apache._internal import obj
from certbot_apache._internal import parser

            

Reported by Pylint.

              from certbot.compat import filesystem
from certbot.compat import os
from certbot.tests import acme_util
from certbot.tests import util as certbot_util
from certbot_apache._internal import apache_util
from certbot_apache._internal import constants
from certbot_apache._internal import obj
from certbot_apache._internal import parser
import util

            

Reported by Pylint.

              from certbot.compat import os
from certbot.tests import acme_util
from certbot.tests import util as certbot_util
from certbot_apache._internal import apache_util
from certbot_apache._internal import constants
from certbot_apache._internal import obj
from certbot_apache._internal import parser
import util


            

Reported by Pylint.

              from certbot.tests import acme_util
from certbot.tests import util as certbot_util
from certbot_apache._internal import apache_util
from certbot_apache._internal import constants
from certbot_apache._internal import obj
from certbot_apache._internal import parser
import util



            

Reported by Pylint.

              import unittest
from unittest import mock

import josepy as jose
import OpenSSL
import requests

from acme import errors


            

Reported by Pylint.

              import OpenSSL
import requests

from acme import errors

import test_util

CERT = test_util.load_comparable_cert('cert.pem')
KEY = jose.JWKRSA(key=test_util.load_rsa_private_key('rsa512_key.pem'))

            

Reported by Pylint.

              class ChallengeTest(unittest.TestCase):

    def test_from_json_unrecognized(self):
        from acme.challenges import Challenge
        from acme.challenges import UnrecognizedChallenge
        chall = UnrecognizedChallenge({"type": "foo"})
        self.assertEqual(chall, Challenge.from_json(chall.jobj))



            

Reported by Pylint.

              
    def test_from_json_unrecognized(self):
        from acme.challenges import Challenge
        from acme.challenges import UnrecognizedChallenge
        chall = UnrecognizedChallenge({"type": "foo"})
        self.assertEqual(chall, Challenge.from_json(chall.jobj))


class UnrecognizedChallengeTest(unittest.TestCase):

            

Reported by Pylint.

              class UnrecognizedChallengeTest(unittest.TestCase):

    def setUp(self):
        from acme.challenges import UnrecognizedChallenge
        self.jobj = {"type": "foo"}
        self.chall = UnrecognizedChallenge(self.jobj)

    def test_to_partial_json(self):
        self.assertEqual(self.jobj, self.chall.to_partial_json())

            

Reported by Pylint.

                      self.assertEqual(self.jobj, self.chall.to_partial_json())

    def test_from_json(self):
        from acme.challenges import UnrecognizedChallenge
        self.assertEqual(
            self.chall, UnrecognizedChallenge.from_json(self.jobj))


class KeyAuthorizationChallengeResponseTest(unittest.TestCase):

            

Reported by Pylint.

                      self.chall.encode.side_effect = _encode

    def test_verify_ok(self):
        from acme.challenges import KeyAuthorizationChallengeResponse
        response = KeyAuthorizationChallengeResponse(
            key_authorization='foo.oKGqedy-b-acd5eoybm2f-NVFxvyOoET5CNy3xnv8WY')
        self.assertTrue(response.verify(self.chall, KEY.public_key()))

    def test_verify_wrong_token(self):

            

Reported by Pylint.

                      self.assertTrue(response.verify(self.chall, KEY.public_key()))

    def test_verify_wrong_token(self):
        from acme.challenges import KeyAuthorizationChallengeResponse
        response = KeyAuthorizationChallengeResponse(
            key_authorization='bar.oKGqedy-b-acd5eoybm2f-NVFxvyOoET5CNy3xnv8WY')
        self.assertFalse(response.verify(self.chall, KEY.public_key()))

    def test_verify_wrong_thumbprint(self):

            

Reported by Pylint.

                      self.assertFalse(response.verify(self.chall, KEY.public_key()))

    def test_verify_wrong_thumbprint(self):
        from acme.challenges import KeyAuthorizationChallengeResponse
        response = KeyAuthorizationChallengeResponse(
            key_authorization='foo.oKGqedy-b-acd5eoybm2f-NVFxv')
        self.assertFalse(response.verify(self.chall, KEY.public_key()))

    def test_verify_wrong_form(self):

            

Reported by Pylint.

                      self.assertFalse(response.verify(self.chall, KEY.public_key()))

    def test_verify_wrong_form(self):
        from acme.challenges import KeyAuthorizationChallengeResponse
        response = KeyAuthorizationChallengeResponse(
            key_authorization='.foo.oKGqedy-b-acd5eoybm2f-'
            'NVFxvyOoET5CNy3xnv8WY')
        self.assertFalse(response.verify(self.chall, KEY.public_key()))


            

Reported by Pylint.

              from typing import Dict
from unittest import mock

import josepy as jose
import OpenSSL
import requests

from acme import challenges
from acme import errors

            

Reported by Pylint.

              import OpenSSL
import requests

from acme import challenges
from acme import errors
from acme import jws as acme_jws
from acme import messages
from acme.mixins import VersionedLEACMEMixin
import messages_test

            

Reported by Pylint.

              import requests

from acme import challenges
from acme import errors
from acme import jws as acme_jws
from acme import messages
from acme.mixins import VersionedLEACMEMixin
import messages_test
import test_util

            

Reported by Pylint.

              
from acme import challenges
from acme import errors
from acme import jws as acme_jws
from acme import messages
from acme.mixins import VersionedLEACMEMixin
import messages_test
import test_util


            

Reported by Pylint.

              from acme import challenges
from acme import errors
from acme import jws as acme_jws
from acme import messages
from acme.mixins import VersionedLEACMEMixin
import messages_test
import test_util

CERT_DER = test_util.load_vector('cert.der')

            

Reported by Pylint.

              from acme import errors
from acme import jws as acme_jws
from acme import messages
from acme.mixins import VersionedLEACMEMixin
import messages_test
import test_util

CERT_DER = test_util.load_vector('cert.der')
CERT_SAN_PEM = test_util.load_vector('cert-san.pem')

            

Reported by Pylint.

              
    def _init(self):
        uri = 'http://www.letsencrypt-demo.org/directory'
        from acme.client import BackwardsCompatibleClientV2
        return BackwardsCompatibleClientV2(net=self.net,
            key=KEY, server=uri)

    def test_init_downloads_directory(self):
        uri = 'http://www.letsencrypt-demo.org/directory'

            

Reported by Pylint.

              
    def test_init_downloads_directory(self):
        uri = 'http://www.letsencrypt-demo.org/directory'
        from acme.client import BackwardsCompatibleClientV2
        BackwardsCompatibleClientV2(net=self.net,
            key=KEY, server=uri)
        self.net.get.assert_called_once_with(uri)

    def test_init_acme_version(self):

            

Reported by Pylint.

                          uri='https://www.letsencrypt-demo.org/acme/cert/1',
            cert_chain_uri='https://www.letsencrypt-demo.org/ca')

        from acme.client import Client
        self.client = Client(
            directory=self.directory, key=KEY, alg=jose.RS256, net=self.net)

    def test_init_downloads_directory(self):
        uri = 'http://www.letsencrypt-demo.org/directory'

            

Reported by Pylint.

              
    def test_init_downloads_directory(self):
        uri = 'http://www.letsencrypt-demo.org/directory'
        from acme.client import Client
        self.client = Client(
            directory=uri, key=KEY, alg=jose.RS256, net=self.net)
        self.net.get.assert_called_once_with(uri)

    @mock.patch('acme.client.ClientNetwork')

            

Reported by Pylint.

              import unittest
from unittest import mock

import josepy as jose

from acme import challenges
import test_util

CERT = test_util.load_comparable_cert('cert.der')

            

Reported by Pylint.

              
import josepy as jose

from acme import challenges
import test_util

CERT = test_util.load_comparable_cert('cert.der')
CSR = test_util.load_comparable_csr('csr.der')
KEY = test_util.load_rsa_private_key('rsa512_key.pem')

            

Reported by Pylint.

                  """Tests for acme.messages.Error."""

    def setUp(self):
        from acme.messages import Error, ERROR_PREFIX
        self.error = Error.with_code('malformed', detail='foo', title='title')
        self.jobj = {
            'detail': 'foo',
            'title': 'some title',
            'type': ERROR_PREFIX + 'malformed',

            

Reported by Pylint.

                      self.empty_error = Error()

    def test_default_typ(self):
        from acme.messages import Error
        self.assertEqual(Error().typ, 'about:blank')

    def test_from_json_empty(self):
        from acme.messages import Error
        self.assertEqual(Error(), Error.from_json('{}'))

            

Reported by Pylint.

                      self.assertEqual(Error().typ, 'about:blank')

    def test_from_json_empty(self):
        from acme.messages import Error
        self.assertEqual(Error(), Error.from_json('{}'))

    def test_from_json_hashable(self):
        from acme.messages import Error
        hash(Error.from_json(self.error.to_json()))

            

Reported by Pylint.

                      self.assertEqual(Error(), Error.from_json('{}'))

    def test_from_json_hashable(self):
        from acme.messages import Error
        hash(Error.from_json(self.error.to_json()))

    def test_description(self):
        self.assertEqual('The request message was malformed', self.error.description)
        self.assertIsNone(self.error_custom.description)

            

Reported by Pylint.

                      self.assertIsNone(self.error_custom.description)

    def test_code(self):
        from acme.messages import Error
        self.assertEqual('malformed', self.error.code)
        self.assertIsNone(self.error_custom.code)
        self.assertIsNone(Error().code)

    def test_is_acme_error(self):

            

Reported by Pylint.

                      self.assertIsNone(Error().code)

    def test_is_acme_error(self):
        from acme.messages import is_acme_error, Error
        self.assertTrue(is_acme_error(self.error))
        self.assertFalse(is_acme_error(self.error_custom))
        self.assertFalse(is_acme_error(Error()))
        self.assertFalse(is_acme_error(self.empty_error))
        self.assertFalse(is_acme_error("must pet all the {dogs|rabbits}"))

            

Reported by Pylint.

                      self.assertFalse(is_acme_error("must pet all the {dogs|rabbits}"))

    def test_unicode_error(self):
        from acme.messages import Error, is_acme_error
        arabic_error = Error.with_code(
            'malformed', detail=u'\u0639\u062f\u0627\u0644\u0629', title='title')
        self.assertTrue(is_acme_error(arabic_error))

    def test_with_code(self):

            

Reported by Pylint.

                      self.assertTrue(is_acme_error(arabic_error))

    def test_with_code(self):
        from acme.messages import Error, is_acme_error
        self.assertTrue(is_acme_error(Error.with_code('badCSR')))
        self.assertRaises(ValueError, Error.with_code, 'not an ACME error code')

    def test_str(self):
        self.assertEqual(

            

Reported by Pylint.

              import logging
import unittest

import certbot.util

try:
    import mock
except ImportError:  # pragma: no cover
    from unittest import mock

            

Reported by Pylint.

                  from unittest import mock
import OpenSSL

from certbot import errors
from certbot import util
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util


            

Reported by Pylint.

              import OpenSSL

from certbot import errors
from certbot import util
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

RSA256_KEY = test_util.load_vector('rsa256_key.pem')

            

Reported by Pylint.

              
from certbot import errors
from certbot import util
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

RSA256_KEY = test_util.load_vector('rsa256_key.pem')
RSA256_KEY_PATH = test_util.vector_path('rsa256_key.pem')

            

Reported by Pylint.

              from certbot import errors
from certbot import util
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

RSA256_KEY = test_util.load_vector('rsa256_key.pem')
RSA256_KEY_PATH = test_util.vector_path('rsa256_key.pem')
RSA512_KEY = test_util.load_vector('rsa512_key.pem')

            

Reported by Pylint.

              from certbot import util
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

RSA256_KEY = test_util.load_vector('rsa256_key.pem')
RSA256_KEY_PATH = test_util.vector_path('rsa256_key.pem')
RSA512_KEY = test_util.load_vector('rsa512_key.pem')
RSA2048_KEY_PATH = test_util.vector_path('rsa2048_key.pem')

            

Reported by Pylint.

              
    @classmethod
    def _call(cls, key_size, key_dir):
        from certbot.crypto_util import generate_key
        return generate_key(key_size, key_dir, 'key-certbot.pem', strict_permissions=True)

    @mock.patch('certbot.crypto_util.make_key')
    def test_success(self, mock_make):
        mock_make.return_value = b'key_pem'

            

Reported by Pylint.

                  @mock.patch("certbot.crypto_util.generate_key")
    @mock.patch("certbot.crypto_util.zope.component")
    def test_it(self, mock_zope, mock_generate):
        from certbot.crypto_util import init_save_key

        mock_zope.getUtility.return_value = mock.MagicMock(strict_permissions=True)

        with self.assertWarns(DeprecationWarning):
            init_save_key(4096, "/some/path")

            

Reported by Pylint.

                  @mock.patch('acme.crypto_util.make_csr')
    @mock.patch('certbot.crypto_util.util.make_or_verify_dir')
    def test_it(self, unused_mock_verify, mock_csr):
        from certbot.crypto_util import generate_csr

        mock_csr.return_value = b'csr_pem'

        csr = generate_csr(
            mock.Mock(pem='dummy_key'), 'example.com', self.tempdir, strict_permissions=True)

            

Reported by Pylint.

                  @mock.patch("certbot.crypto_util.generate_csr")
    @mock.patch("certbot.crypto_util.zope.component")
    def test_it(self, mock_zope, mock_generate):
        from certbot.crypto_util import init_save_csr

        mock_zope.getUtility.return_value = mock.MagicMock(must_staple=True,
                                                           strict_permissions=True)
        key = certbot.util.Key(file=None, pem=None)


            

Reported by Pylint.

              import sys
import unittest

from certbot import errors
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

try:

            

Reported by Pylint.

              import unittest

from certbot import errors
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

try:
    import mock

            

Reported by Pylint.

              
from certbot import errors
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

try:
    import mock
except ImportError: # pragma: no cover

            

Reported by Pylint.

              from certbot import errors
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

try:
    import mock
except ImportError: # pragma: no cover
    from unittest import mock

            

Reported by Pylint.

                  """Tests for certbot.util.env_no_snap_for_external_calls."""
    @classmethod
    def _call(cls):
        from certbot.util import env_no_snap_for_external_calls
        return env_no_snap_for_external_calls()

    def test_removed(self):
        original_path = os.environ['PATH']
        env_copy_dict = os.environ.copy()

            

Reported by Pylint.

                  """Tests for certbot.util.run_script."""
    @classmethod
    def _call(cls, params):
        from certbot.util import run_script
        return run_script(params)

    @mock.patch("certbot.util.subprocess.run")
    def test_default(self, mock_run):
        """These will be changed soon enough with reload."""

            

Reported by Pylint.

              
    @classmethod
    def _call(cls, exe):
        from certbot.util import exe_exists
        return exe_exists(exe)

    def test_exe_exists(self):
        with mock.patch("certbot.util.filesystem.is_executable", return_value=True):
            self.assertTrue(self._call("/path/to/exe"))

            

Reported by Pylint.

                  """Tests for certbot.util.lock_dir_until_exit."""
    @classmethod
    def _call(cls, *args, **kwargs):
        from certbot.util import lock_dir_until_exit
        return lock_dir_until_exit(*args, **kwargs)

    def setUp(self):
        super().setUp()
        # reset global state from other tests

            

Reported by Pylint.

                  def setUp(self):
        super().setUp()
        # reset global state from other tests
        import certbot.util
        reload_module(certbot.util)

    @mock.patch('certbot.util.logger')
    @mock.patch('certbot.util.atexit_register')
    def test_it(self, mock_register, mock_logger):

            

Reported by Pylint.

                      self.assertEqual(mock_register.call_count, 1)
        registered_func = mock_register.call_args[0][0]

        from certbot import util
        # Despite lock_dir_until_exit has been called twice to subdir, its lock should have been
        # added only once. So we expect to have two lock references: for self.tempdir and subdir
        self.assertEqual(len(util._LOCKS), 2)  # pylint: disable=protected-access
        registered_func()  # Exception should not be raised
        # Logically, logger.debug, that would be invoked in case of unlock failure,

            

Reported by Pylint.

                  from unittest import mock # type: ignore
import OpenSSL

from acme import challenges
from acme import messages
from certbot import achallenges
from certbot import crypto_util
from certbot import errors
from certbot.compat import os

            

Reported by Pylint.

              import OpenSSL

from acme import challenges
from acme import messages
from certbot import achallenges
from certbot import crypto_util
from certbot import errors
from certbot.compat import os
from certbot.tests import util as certbot_test_util

            

Reported by Pylint.

              
from acme import challenges
from acme import messages
from certbot import achallenges
from certbot import crypto_util
from certbot import errors
from certbot.compat import os
from certbot.tests import util as certbot_test_util
from certbot_nginx._internal import obj

            

Reported by Pylint.

              from acme import challenges
from acme import messages
from certbot import achallenges
from certbot import crypto_util
from certbot import errors
from certbot.compat import os
from certbot.tests import util as certbot_test_util
from certbot_nginx._internal import obj
from certbot_nginx._internal import parser

            

Reported by Pylint.

              from acme import messages
from certbot import achallenges
from certbot import crypto_util
from certbot import errors
from certbot.compat import os
from certbot.tests import util as certbot_test_util
from certbot_nginx._internal import obj
from certbot_nginx._internal import parser
from certbot_nginx._internal.configurator import _redirect_block_for_domain

            

Reported by Pylint.

              from certbot import achallenges
from certbot import crypto_util
from certbot import errors
from certbot.compat import os
from certbot.tests import util as certbot_test_util
from certbot_nginx._internal import obj
from certbot_nginx._internal import parser
from certbot_nginx._internal.configurator import _redirect_block_for_domain
from certbot_nginx._internal.nginxparser import UnspacedList

            

Reported by Pylint.

              from certbot import crypto_util
from certbot import errors
from certbot.compat import os
from certbot.tests import util as certbot_test_util
from certbot_nginx._internal import obj
from certbot_nginx._internal import parser
from certbot_nginx._internal.configurator import _redirect_block_for_domain
from certbot_nginx._internal.nginxparser import UnspacedList
import test_util as util

            

Reported by Pylint.

              from certbot import errors
from certbot.compat import os
from certbot.tests import util as certbot_test_util
from certbot_nginx._internal import obj
from certbot_nginx._internal import parser
from certbot_nginx._internal.configurator import _redirect_block_for_domain
from certbot_nginx._internal.nginxparser import UnspacedList
import test_util as util


            

Reported by Pylint.

              from certbot.compat import os
from certbot.tests import util as certbot_test_util
from certbot_nginx._internal import obj
from certbot_nginx._internal import parser
from certbot_nginx._internal.configurator import _redirect_block_for_domain
from certbot_nginx._internal.nginxparser import UnspacedList
import test_util as util



            

Reported by Pylint.

              from certbot.tests import util as certbot_test_util
from certbot_nginx._internal import obj
from certbot_nginx._internal import parser
from certbot_nginx._internal.configurator import _redirect_block_for_domain
from certbot_nginx._internal.nginxparser import UnspacedList
import test_util as util


class NginxConfiguratorTest(util.NginxTest):

            

Reported by Pylint.

                  import mock
except ImportError: # pragma: no cover
    from unittest import mock
import pytz

import certbot
from certbot import errors
from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem

            

Reported by Pylint.

                  from unittest import mock
import pytz

import certbot
from certbot import errors
from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

            

Reported by Pylint.

              import pytz

import certbot
from certbot import errors
from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util


            

Reported by Pylint.

              
import certbot
from certbot import errors
from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

CERT = test_util.load_cert('cert_512.pem')

            

Reported by Pylint.

              import certbot
from certbot import errors
from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

CERT = test_util.load_cert('cert_512.pem')


            

Reported by Pylint.

              from certbot import errors
from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

CERT = test_util.load_cert('cert_512.pem')



            

Reported by Pylint.

              from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

CERT = test_util.load_cert('cert_512.pem')


def unlink_all(rc_object):

            

Reported by Pylint.

                      self.values = {"server": "example.org"}

    def _call(self, *args, **kwargs):
        from certbot._internal.storage import relevant_values
        return relevant_values(*args, **kwargs)

    @mock.patch("certbot._internal.cli.option_was_set")
    @mock.patch("certbot._internal.plugins.disco.PluginsRegistry.find_all")
    def test_namespace(self, mock_find_all, mock_option_was_set):

            

Reported by Pylint.

                  """

    def setUp(self):
        from certbot._internal import storage

        super().setUp()

        # TODO: maybe provide NamespaceConfig.make_dirs?
        # TODO: main() should create those dirs, c.f. #902

            

Reported by Pylint.

                      the renewal configuration file doesn't end in ".conf"

        """
        from certbot._internal import storage
        broken = os.path.join(self.config.config_dir, "broken.conf")
        with open(broken, "w") as f:
            f.write("[No closing bracket for you!")
        self.assertRaises(errors.CertStorageError, storage.RenewableCert,
                          broken, self.config)

            

Reported by Pylint.

              except ImportError: # pragma: no cover
    from unittest import mock

from certbot import errors, configuration
from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem
from certbot.compat import os
from certbot.display import util as display_util
from certbot.tests import util as test_util

            

Reported by Pylint.

                  from unittest import mock

from certbot import errors, configuration
from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem
from certbot.compat import os
from certbot.display import util as display_util
from certbot.tests import util as test_util
import storage_test

            

Reported by Pylint.

              
from certbot import errors, configuration
from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem
from certbot.compat import os
from certbot.display import util as display_util
from certbot.tests import util as test_util
import storage_test


            

Reported by Pylint.

              from certbot import errors, configuration
from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem
from certbot.compat import os
from certbot.display import util as display_util
from certbot.tests import util as test_util
import storage_test



            

Reported by Pylint.

              from certbot._internal.storage import ALL_FOUR
from certbot.compat import filesystem
from certbot.compat import os
from certbot.display import util as display_util
from certbot.tests import util as test_util
import storage_test


class BaseCertManagerTest(test_util.ConfigTestCase):

            

Reported by Pylint.

              from certbot.compat import filesystem
from certbot.compat import os
from certbot.display import util as display_util
from certbot.tests import util as test_util
import storage_test


class BaseCertManagerTest(test_util.ConfigTestCase):
    """Base class for setting up Cert Manager tests.

            

Reported by Pylint.

                  def test_update_live_symlinks(self):
        """Test update_live_symlinks"""
        # create files with incorrect symlinks
        from certbot._internal import cert_manager
        archive_paths = {}
        for domain in self.domains:
            custom_archive = self.domains[domain]
            if custom_archive is not None:
                archive_dir_path = custom_archive

            

Reported by Pylint.

                  """

    def _call(self):
        from certbot._internal import cert_manager
        cert_manager.delete(self.config)

    @test_util.patch_display_util()
    @mock.patch('certbot.display.util.notify')
    @mock.patch('certbot._internal.cert_manager.lineage_for_certname')

            

Reported by Pylint.

                  """Tests for certbot._internal.cert_manager.certificates
    """
    def _certificates(self, *args, **kwargs):
        from certbot._internal.cert_manager import certificates
        return certificates(*args, **kwargs)

    @mock.patch('certbot._internal.cert_manager.logger')
    @test_util.patch_display_util()
    def test_certificates_parse_fail(self, mock_utility, mock_logger):

            

Reported by Pylint.

                  def test_report_human_readable(self, mock_revoked, mock_serial):
        mock_revoked.return_value = None
        mock_serial.return_value = 1234567890
        from certbot._internal import cert_manager
        import datetime
        import pytz
        expiry = pytz.UTC.fromutc(datetime.datetime.utcnow())

        cert = mock.MagicMock(lineagename="nameone")

            

Reported by Pylint.