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

from acme import challenges
from acme import client as acme_client
from acme import errors as acme_errors
from acme import messages
from certbot import achallenges
from certbot import errors

            

Reported by Pylint.

                  from unittest import mock

from acme import challenges
from acme import client as acme_client
from acme import errors as acme_errors
from acme import messages
from certbot import achallenges
from certbot import errors
from certbot import util

            

Reported by Pylint.

              
from acme import challenges
from acme import client as acme_client
from acme import errors as acme_errors
from acme import messages
from certbot import achallenges
from certbot import errors
from certbot import util
from certbot._internal.display import obj as display_obj

            

Reported by Pylint.

              from acme import challenges
from acme import client as acme_client
from acme import errors as acme_errors
from acme import messages
from certbot import achallenges
from certbot import errors
from certbot import util
from certbot._internal.display import obj as display_obj
from certbot.plugins import common as plugin_common

            

Reported by Pylint.

              from acme import client as acme_client
from acme import errors as acme_errors
from acme import messages
from certbot import achallenges
from certbot import errors
from certbot import util
from certbot._internal.display import obj as display_obj
from certbot.plugins import common as plugin_common
from certbot.tests import acme_util

            

Reported by Pylint.

              from acme import errors as acme_errors
from acme import messages
from certbot import achallenges
from certbot import errors
from certbot import util
from certbot._internal.display import obj as display_obj
from certbot.plugins import common as plugin_common
from certbot.tests import acme_util
from certbot.tests import util as test_util

            

Reported by Pylint.

              from acme import messages
from certbot import achallenges
from certbot import errors
from certbot import util
from certbot._internal.display import obj as display_obj
from certbot.plugins import common as plugin_common
from certbot.tests import acme_util
from certbot.tests import util as test_util


            

Reported by Pylint.

              from certbot import achallenges
from certbot import errors
from certbot import util
from certbot._internal.display import obj as display_obj
from certbot.plugins import common as plugin_common
from certbot.tests import acme_util
from certbot.tests import util as test_util



            

Reported by Pylint.

              from certbot import errors
from certbot import util
from certbot._internal.display import obj as display_obj
from certbot.plugins import common as plugin_common
from certbot.tests import acme_util
from certbot.tests import util as test_util


class ChallengeFactoryTest(unittest.TestCase):

            

Reported by Pylint.

              from certbot import util
from certbot._internal.display import obj as display_obj
from certbot.plugins import common as plugin_common
from certbot.tests import acme_util
from certbot.tests import util as test_util


class ChallengeFactoryTest(unittest.TestCase):
    # pylint: disable=protected-access

            

Reported by Pylint.

              import tempfile
import unittest

from acme import challenges
from certbot import errors
from certbot._internal import cli
from certbot._internal import constants
from certbot._internal.plugins import disco
from certbot.compat import filesystem

            

Reported by Pylint.

              import unittest

from acme import challenges
from certbot import errors
from certbot._internal import cli
from certbot._internal import constants
from certbot._internal.plugins import disco
from certbot.compat import filesystem
from certbot.compat import os

            

Reported by Pylint.

              
from acme import challenges
from certbot import errors
from certbot._internal import cli
from certbot._internal import constants
from certbot._internal.plugins import disco
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util

            

Reported by Pylint.

              from acme import challenges
from certbot import errors
from certbot._internal import cli
from certbot._internal import constants
from certbot._internal.plugins import disco
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util
from certbot.tests.util import TempDirTestCase

            

Reported by Pylint.

              from certbot import errors
from certbot._internal import cli
from certbot._internal import constants
from certbot._internal.plugins import disco
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util
from certbot.tests.util import TempDirTestCase


            

Reported by Pylint.

              from certbot._internal import cli
from certbot._internal import constants
from certbot._internal.plugins import disco
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util
from certbot.tests.util import TempDirTestCase

try:

            

Reported by Pylint.

              from certbot._internal import constants
from certbot._internal.plugins import disco
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util
from certbot.tests.util import TempDirTestCase

try:
    import mock

            

Reported by Pylint.

              from certbot._internal.plugins import disco
from certbot.compat import filesystem
from certbot.compat import os
import certbot.tests.util as test_util
from certbot.tests.util import TempDirTestCase

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

            

Reported by Pylint.

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

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

            

Reported by Pylint.

              PLUGINS = disco.PluginsRegistry.find_all()


class TestReadFile(TempDirTestCase):
    """Test cli.read_file"""
    def test_read_file(self):
        curr_dir = os.getcwd()
        try:
            # On Windows current directory may be on a different drive than self.tempdir.

            

Reported by Pylint.

              import os
import util

from certbot import errors

from certbot_apache._internal import assertions
from certbot_apache._internal import augeasparser



            

Reported by Pylint.

              
from certbot import errors

from certbot_apache._internal import assertions
from certbot_apache._internal import augeasparser


def _get_augeasnode_mock(filepath):
    """ Helper function for mocking out DualNode instance with an AugeasNode """

            

Reported by Pylint.

              from certbot import errors

from certbot_apache._internal import assertions
from certbot_apache._internal import augeasparser


def _get_augeasnode_mock(filepath):
    """ Helper function for mocking out DualNode instance with an AugeasNode """
    def augeasnode_mock(metadata):

            

Reported by Pylint.

                      self.assertEqual(files, ["first", "second"])

    def test_get_block_node_name(self):
        from certbot_apache._internal.augeasparser import AugeasBlockNode
        block = AugeasBlockNode(
            name=assertions.PASS,
            ancestor=None,
            filepath=assertions.PASS,
            metadata={"augeasparser": mock.Mock(), "augeaspath": "/files/anything"}

            

Reported by Pylint.

                      self.assertTrue("going_to_set_this" in names)

    def test_set_parameters_atinit(self):
        from certbot_apache._internal.augeasparser import AugeasDirectiveNode
        servernames = self.config.parser_root.find_directives("servername")
        setparam = "certbot_apache._internal.augeasparser.AugeasDirectiveNode.set_parameters"
        with mock.patch(setparam) as mock_set:
            AugeasDirectiveNode(
                name=servernames[0].name,

            

Reported by Pylint.

                      self.assertTrue(vh.metadata["augeaspath"].endswith("VirtualHost[2]"))

    def test_node_init_error_bad_augeaspath(self):
        from certbot_apache._internal.augeasparser import AugeasBlockNode
        parameters = {
            "name": assertions.PASS,
            "ancestor": None,
            "filepath": assertions.PASS,
            "metadata": {

            

Reported by Pylint.

                      )

    def test_node_init_error_missing_augeaspath(self):
        from certbot_apache._internal.augeasparser import AugeasBlockNode
        parameters = {
            "name": assertions.PASS,
            "ancestor": None,
            "filepath": assertions.PASS,
            "metadata": {

            

Reported by Pylint.

              import os
import util

from certbot import errors

from certbot_apache._internal import assertions
from certbot_apache._internal import augeasparser



            

Reported by Pylint.

              
from certbot import errors

from certbot_apache._internal import assertions
from certbot_apache._internal import augeasparser


def _get_augeasnode_mock(filepath):
    """ Helper function for mocking out DualNode instance with an AugeasNode """

            

Reported by Pylint.

              from certbot import errors

from certbot_apache._internal import assertions
from certbot_apache._internal import augeasparser


def _get_augeasnode_mock(filepath):
    """ Helper function for mocking out DualNode instance with an AugeasNode """
    def augeasnode_mock(metadata):

            

Reported by Pylint.

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

from certbot import errors
from certbot.compat import os
import util


class BasicParserTest(util.ParserTest):

            

Reported by Pylint.

                  from unittest import mock # type: ignore

from certbot import errors
from certbot.compat import os
import util


class BasicParserTest(util.ParserTest):
    """Apache Parser Test."""

            

Reported by Pylint.

                      Path must be valid before attempting to add to augeas

        """
        from certbot_apache._internal.parser import get_aug_path
        # This makes sure that find_dir will work
        self.parser.modules["mod_ssl.c"] = "/fake/path"

        self.parser.add_dir_to_ifmodssl(
            get_aug_path(self.parser.loc["default"]),

            

Reported by Pylint.

                      self.assertTrue("IfModule" in matches[0])

    def test_add_dir_to_ifmodssl_multiple(self):
        from certbot_apache._internal.parser import get_aug_path
        # This makes sure that find_dir will work
        self.parser.modules["mod_ssl.c"] = "/fake/path"

        self.parser.add_dir_to_ifmodssl(
            get_aug_path(self.parser.loc["default"]),

            

Reported by Pylint.

                      self.assertTrue("IfModule" in matches[0])

    def test_get_aug_path(self):
        from certbot_apache._internal.parser import get_aug_path
        self.assertEqual("/files/etc/apache", get_aug_path("/etc/apache"))

    def test_set_locations(self):
        with mock.patch("certbot_apache._internal.parser.os.path") as mock_path:


            

Reported by Pylint.

                          self.parser.update_runtime_variables)

    def test_add_comment(self):
        from certbot_apache._internal.parser import get_aug_path
        self.parser.add_comment(get_aug_path(self.parser.loc["name"]), "123456")
        comm = self.parser.find_comments("123456")
        self.assertEqual(len(comm), 1)
        self.assertTrue(self.parser.loc["name"] in comm[0])


            

Reported by Pylint.

              
    @mock.patch("certbot_apache._internal.parser.init_augeas")
    def test_prepare_no_augeas(self, mock_init_augeas):
        from certbot_apache._internal.parser import ApacheParser
        mock_init_augeas.side_effect = errors.NoInstallationError
        self.config.config_test = mock.Mock()
        self.assertRaises(
            errors.NoInstallationError, ApacheParser,
            os.path.relpath(self.config_path), "/dummy/vhostpath",

            

Reported by Pylint.

                          version=(2, 4, 22), configurator=self.config)

    def test_init_old_aug(self):
        from certbot_apache._internal.parser import ApacheParser
        with mock.patch("certbot_apache._internal.parser.ApacheParser.check_aug_version") as mock_c:
            mock_c.return_value = False
            self.assertRaises(
                errors.NotSupportedError,
                ApacheParser, os.path.relpath(self.config_path),

            

Reported by Pylint.

              
    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
    def test_unparseable(self, mock_cfg):
        from certbot_apache._internal.parser import ApacheParser
        mock_cfg.return_value = ('Define: TEST')
        self.assertRaises(
            errors.PluginError,
            ApacheParser, os.path.relpath(self.config_path),
            "/dummy/vhostpath", version=(2, 2, 22), configurator=self.config)

            

Reported by Pylint.

                          "/dummy/vhostpath", version=(2, 2, 22), configurator=self.config)

    def test_root_normalized(self):
        from certbot_apache._internal.parser import ApacheParser

        with mock.patch("certbot_apache._internal.parser.ApacheParser."
                        "update_runtime_variables"):
            path = os.path.join(
                self.temp_dir,

            

Reported by Pylint.

              
    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):

            

Reported by Bandit.

              
    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)

            

Reported by Bandit.

              
    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):

            

Reported by Bandit.

              
    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)

            

Reported by Bandit.

              from typing import Set
from unittest import mock

import josepy as jose
import requests

from acme import challenges
from acme import crypto_util
from acme import errors

            

Reported by Pylint.

              import josepy as jose
import requests

from acme import challenges
from acme import crypto_util
from acme import errors

import test_util


            

Reported by Pylint.

              import requests

from acme import challenges
from acme import crypto_util
from acme import errors

import test_util



            

Reported by Pylint.

              
from acme import challenges
from acme import crypto_util
from acme import errors

import test_util


class TLSServerTest(unittest.TestCase):

            

Reported by Pylint.

              

    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()

    def test_ipv6(self):

            

Reported by Pylint.

              
    def test_ipv6(self):
        if socket.has_ipv6:
            from acme.standalone import TLSServer
            server = TLSServer(
                ('', 0), socketserver.BaseRequestHandler, bind_and_activate=True, ipv6=True)
            server.server_close()



            

Reported by Pylint.

              import pkg_resources
import zope.interface

from certbot import errors
from certbot import interfaces
from certbot._internal.plugins import null
from certbot._internal.plugins import standalone
from certbot._internal.plugins import webroot


            

Reported by Pylint.

              import zope.interface

from certbot import errors
from certbot import interfaces
from certbot._internal.plugins import null
from certbot._internal.plugins import standalone
from certbot._internal.plugins import webroot

try:

            

Reported by Pylint.

              
from certbot import errors
from certbot import interfaces
from certbot._internal.plugins import null
from certbot._internal.plugins import standalone
from certbot._internal.plugins import webroot

try:
    import mock

            

Reported by Pylint.

              from certbot import errors
from certbot import interfaces
from certbot._internal.plugins import null
from certbot._internal.plugins import standalone
from certbot._internal.plugins import webroot

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

            

Reported by Pylint.

              from certbot import interfaces
from certbot._internal.plugins import null
from certbot._internal.plugins import standalone
from certbot._internal.plugins import webroot

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

            

Reported by Pylint.

                      self.ep3 = pkg_resources.EntryPoint(
            "ep3", "a.ep3", dist=mock.MagicMock(key="p3"))

        from certbot._internal.plugins.disco import PluginEntryPoint
        self.plugin_ep = PluginEntryPoint(EP_SA)

    def test_entry_point_to_plugin_name_not_prefixed(self):
        from certbot._internal.plugins.disco import PluginEntryPoint


            

Reported by Pylint.

                      self.plugin_ep = PluginEntryPoint(EP_SA)

    def test_entry_point_to_plugin_name_not_prefixed(self):
        from certbot._internal.plugins.disco import PluginEntryPoint

        names = {
            self.ep1: "ep1",
            self.ep1prim: "ep1",
            self.ep2: "ep2",

            

Reported by Pylint.

                              name, PluginEntryPoint.entry_point_to_plugin_name(entry_point, with_prefix=False))

    def test_entry_point_to_plugin_name_prefixed(self):
        from certbot._internal.plugins.disco import PluginEntryPoint

        names = {
            self.ep1: "p1:ep1",
            self.ep1prim: "p2:ep1",
            self.ep2: "p2:ep2",

            

Reported by Pylint.

              
    @classmethod
    def _create_new_registry(cls, plugins):
        from certbot._internal.plugins.disco import PluginsRegistry
        return PluginsRegistry(plugins)

    def setUp(self):
        self.plugin_ep = mock.MagicMock()
        self.plugin_ep.name = "mock"

            

Reported by Pylint.

                          "ep1", "p1.ep1", dist=mock.MagicMock(key="p1"))

    def test_find_all(self):
        from certbot._internal.plugins.disco import PluginsRegistry
        with mock.patch("certbot._internal.plugins.disco.pkg_resources") as mock_pkg:
            mock_pkg.iter_entry_points.side_effect = [
                iter([EP_SA]), iter([EP_WR, self.ep1])
            ]
            with mock.patch.object(pkg_resources.EntryPoint, 'load') as mock_load:

            

Reported by Pylint.

              from cryptography.hazmat.primitives.asymmetric.ec import SECP384R1
from cryptography.hazmat.primitives.asymmetric.ec import SECP521R1
from cryptography.x509 import NameOID
import pytest

from certbot_integration_tests.certbot_tests import context as certbot_context
from certbot_integration_tests.certbot_tests.assertions import assert_cert_count_for_lineage
from certbot_integration_tests.certbot_tests.assertions import assert_elliptic_key
from certbot_integration_tests.certbot_tests.assertions import assert_equals_group_owner

            

Reported by Pylint.

              from os.path import join
import re
import shutil
import subprocess
import time

from cryptography.hazmat.primitives.asymmetric.ec import SECP256R1
from cryptography.hazmat.primitives.asymmetric.ec import SECP384R1
from cryptography.hazmat.primitives.asymmetric.ec import SECP521R1

            

Reported by Bandit.

                      context.certbot(['--csr'])

    new_count_tmpfiles = len(os.listdir(context.workspace))
    assert initial_count_tmpfiles == new_count_tmpfiles


def test_hook_dirs_creation(context):
    """Test all hooks directory are created during Certbot startup."""
    context.certbot(['register'])

            

Reported by Bandit.

                  context.certbot(['register'])

    for hook_dir in misc.list_renewal_hooks_dirs(context.config_dir):
        assert os.path.isdir(hook_dir)


def test_registration_override(context):
    """Test correct register/unregister, and registration override."""
    context.certbot(['register'])

            

Reported by Bandit.

                  """Test that plugins are correctly instantiated and displayed."""
    stdout, _ = context.certbot(['plugins', '--init', '--prepare'])

    assert 'webroot' in stdout


def test_http_01(context):
    """Test the HTTP-01 challenge using standalone plugin."""
    # We start a server listening on the port for the

            

Reported by Bandit.

                  if os.name != 'nt':
        os.chmod(privkey1, 0o444)
    else:
        import win32security  # pylint: disable=import-error
        import ntsecuritycon  # pylint: disable=import-error
        # Get the current DACL of the private key
        security = win32security.GetFileSecurity(privkey1, win32security.DACL_SECURITY_INFORMATION)
        dacl = security.GetSecurityDescriptorDacl()
        # Create a read permission for Everybody group

            

Reported by Pylint.

                      os.chmod(privkey1, 0o444)
    else:
        import win32security  # pylint: disable=import-error
        import ntsecuritycon  # pylint: disable=import-error
        # Get the current DACL of the private key
        security = win32security.GetFileSecurity(privkey1, win32security.DACL_SECURITY_INFORMATION)
        dacl = security.GetSecurityDescriptorDacl()
        # Create a read permission for Everybody group
        everybody = win32security.ConvertStringSidToSid(EVERYBODY_SID)

            

Reported by Pylint.

                  context.certbot(['-d', certname, '--rsa-key-size', '4096'])

    key1 = join(context.config_dir, 'archive', certname, 'privkey1.pem')
    assert os.stat(key1).st_size > 3000  # 4096 bits keys takes more than 3000 bytes
    assert_cert_count_for_lineage(context.config_dir, certname, 1)

    context.certbot(['renew'])

    assert_cert_count_for_lineage(context.config_dir, certname, 2)

            

Reported by Bandit.

              
    assert_cert_count_for_lineage(context.config_dir, certname, 2)
    key2 = join(context.config_dir, 'archive', certname, 'privkey2.pem')
    assert os.stat(key2).st_size > 3000

    context.certbot(['renew', '--rsa-key-size', '2048'])

    assert_cert_count_for_lineage(context.config_dir, certname, 3)
    key3 = join(context.config_dir, 'archive', certname, 'privkey3.pem')

            

Reported by Bandit.

              
    assert_cert_count_for_lineage(context.config_dir, certname, 3)
    key3 = join(context.config_dir, 'archive', certname, 'privkey3.pem')
    assert os.stat(key3).st_size < 1800  # 2048 bits keys takes less than 1800 bytes


def test_renew_ignoring_directory_hooks(context):
    """Test hooks are ignored during renewal with relevant CLI flag."""
    certname = context.get_domain('renew')

            

Reported by Bandit.

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

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


class ReverterCheckpointLocalTest(test_util.ConfigTestCase):

            

Reported by Pylint.

                  from unittest import mock

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


class ReverterCheckpointLocalTest(test_util.ConfigTestCase):
    """Test the Reverter Class."""

            

Reported by Pylint.

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


class ReverterCheckpointLocalTest(test_util.ConfigTestCase):
    """Test the Reverter Class."""
    def setUp(self):

            

Reported by Pylint.

                  """Test the Reverter Class."""
    def setUp(self):
        super().setUp()
        from certbot.reverter import Reverter

        # Disable spurious errors... we are trying to test for them
        logging.disable(logging.CRITICAL)

        self.reverter = Reverter(self.config)

            

Reported by Pylint.

                  """Tests functions having to deal with full checkpoints."""
    def setUp(self):
        super().setUp()
        from certbot.reverter import Reverter
        # Disable spurious errors...
        logging.disable(logging.CRITICAL)

        self.reverter = Reverter(self.config)


            

Reported by Pylint.

              from certbot.tests import util as test_util


class ReverterCheckpointLocalTest(test_util.ConfigTestCase):
    """Test the Reverter Class."""
    def setUp(self):
        super().setUp()
        from certbot.reverter import Reverter


            

Reported by Pylint.

              
class ReverterCheckpointLocalTest(test_util.ConfigTestCase):
    """Test the Reverter Class."""
    def setUp(self):
        super().setUp()
        from certbot.reverter import Reverter

        # Disable spurious errors... we are trying to test for them
        logging.disable(logging.CRITICAL)

            

Reported by Pylint.

              
class ReverterCheckpointLocalTest(test_util.ConfigTestCase):
    """Test the Reverter Class."""
    def setUp(self):
        super().setUp()
        from certbot.reverter import Reverter

        # Disable spurious errors... we are trying to test for them
        logging.disable(logging.CRITICAL)

            

Reported by Pylint.

                  """Test the Reverter Class."""
    def setUp(self):
        super().setUp()
        from certbot.reverter import Reverter

        # Disable spurious errors... we are trying to test for them
        logging.disable(logging.CRITICAL)

        self.reverter = Reverter(self.config)

            

Reported by Pylint.

                      tup = setup_test_files()
        self.config1, self.config2, self.dir1, self.dir2, self.sets = tup

    def tearDown(self):
        shutil.rmtree(self.config.work_dir)
        shutil.rmtree(self.dir1)
        shutil.rmtree(self.dir2)

        logging.disable(logging.NOTSET)

            

Reported by Pylint.

              import unittest
from unittest import mock

from certbot import errors
from certbot._internal.display import obj as display_obj
from certbot.display import util as display_util

CHOICES = [("First", "Description1"), ("Second", "Description2")]
TAGS = ["tag1", "tag2", "tag3"]

            

Reported by Pylint.

              from unittest import mock

from certbot import errors
from certbot._internal.display import obj as display_obj
from certbot.display import util as display_util

CHOICES = [("First", "Description1"), ("Second", "Description2")]
TAGS = ["tag1", "tag2", "tag3"]


            

Reported by Pylint.

              
from certbot import errors
from certbot._internal.display import obj as display_obj
from certbot.display import util as display_util

CHOICES = [("First", "Description1"), ("Second", "Description2")]
TAGS = ["tag1", "tag2", "tag3"]



            

Reported by Pylint.

                      self.assertIn("message2", string)

    def test_notification_decoration(self):
        from certbot.compat import os
        self.displayer.notification("message", pause=False, decorate=False)
        string = self.mock_stdout.write.call_args[0][0]
        self.assertEqual(string, "message" + os.linesep)

        self.displayer.notification("message2", pause=False)

            

Reported by Pylint.

                      mock_logger.debug.assert_called_with("Notifying user: %s", "message")

    def test_notification_decoration(self):
        from certbot.compat import os
        self.displayer.notification("message", pause=False, decorate=False)
        string = self.mock_stdout.write.call_args[0][0]
        self.assertEqual(string, "message" + os.linesep)

        self.displayer.notification("message2", pause=False)

            

Reported by Pylint.

              TAGS = ["tag1", "tag2", "tag3"]


class FileOutputDisplayTest(unittest.TestCase):
    """Test stdout display.

    Most of this class has to deal with visual output.  In order to test how the
    functions look to a user, uncomment the test_visual function.


            

Reported by Pylint.

                      self.displayer = display_obj.FileDisplay(self.mock_stdout, False)

    @mock.patch("certbot._internal.display.obj.logger")
    def test_notification_no_pause(self, mock_logger):
        self.displayer.notification("message", False)
        string = self.mock_stdout.write.call_args[0][0]

        self.assertIn("message", string)
        mock_logger.debug.assert_called_with("Notifying user: %s", "message")

            

Reported by Pylint.

                      self.assertIn("message", string)
        mock_logger.debug.assert_called_with("Notifying user: %s", "message")

    def test_notification_pause(self):
        input_with_timeout = "certbot._internal.display.util.input_with_timeout"
        with mock.patch(input_with_timeout, return_value="enter"):
            self.displayer.notification("message", force_interactive=True)

        self.assertIn("message", self.mock_stdout.write.call_args[0][0])

            

Reported by Pylint.

              
        self.assertIn("message", self.mock_stdout.write.call_args[0][0])

    def test_notification_noninteractive(self):
        self._force_noninteractive(self.displayer.notification, "message")
        string = self.mock_stdout.write.call_args[0][0]
        self.assertIn("message", string)

    def test_notification_noninteractive2(self):

            

Reported by Pylint.

                      string = self.mock_stdout.write.call_args[0][0]
        self.assertIn("message", string)

    def test_notification_noninteractive2(self):
        # The main purpose of this test is to make sure we only call
        # logger.warning once which _force_noninteractive checks internally
        self._force_noninteractive(self.displayer.notification, "message")
        string = self.mock_stdout.write.call_args[0][0]
        self.assertIn("message", string)

            

Reported by Pylint.

              import copy
import unittest

from acme import challenges
from certbot import errors, configuration
from certbot._internal import storage
import certbot.tests.util as test_util

try:

            

Reported by Pylint.

              import unittest

from acme import challenges
from certbot import errors, configuration
from certbot._internal import storage
import certbot.tests.util as test_util

try:
    import mock

            

Reported by Pylint.

              
from acme import challenges
from certbot import errors, configuration
from certbot._internal import storage
import certbot.tests.util as test_util

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

            

Reported by Pylint.

              from acme import challenges
from certbot import errors, configuration
from certbot._internal import storage
import certbot.tests.util as test_util

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

            

Reported by Pylint.

                      lineage = storage.RenewableCert(rc_path, config)
        renewalparams = lineage.configuration['renewalparams']
        # pylint: disable=protected-access
        from certbot._internal import renewal
        renewal._restore_webroot_config(config, renewalparams)
        self.assertEqual(config.webroot_path, ['/var/www/'])

    @mock.patch('certbot._internal.renewal.cli.set_by_cli')
    def test_webroot_params_conservation(self, mock_set_by_cli):

            

Reported by Pylint.

                      # For more details about why this test is important, see:
        # certbot._internal.plugins.webroot_test::
        #   WebrootActionTest::test_webroot_map_partial_without_perform
        from certbot._internal import renewal
        mock_set_by_cli.return_value = False

        renewalparams = {
            'webroot_map': {'test.example.com': '/var/www/test'},
            'webroot_path': ['/var/www/test', '/var/www/other'],

            

Reported by Pylint.

                      le_client = mock.MagicMock()
        le_client.obtain_certificate.return_value = (None, None, None, None)

        from certbot._internal import renewal

        with mock.patch('certbot._internal.renewal.hooks.renew_hook'):
            renewal.renew_cert(self.config, None, le_client, lineage)

        assert self.config.rsa_key_size == 2048

            

Reported by Pylint.

                      le_client = mock.MagicMock()
        le_client.obtain_certificate.return_value = (None, None, None, None)

        from certbot._internal import renewal

        with mock.patch('certbot._internal.renewal.hooks.renew_hook'):
            renewal.renew_cert(self.config, None, le_client, lineage)

        assert self.config.elliptic_curve == 'secp256r1'

            

Reported by Pylint.

                      rc_path = test_util.make_lineage(
            self.config.config_dir, 'sample-renewal-deprecated-option.conf')

        from certbot._internal import renewal
        lineage_config = copy.deepcopy(self.config)
        renewal_candidate = renewal._reconstitute(lineage_config, rc_path)
        # This means that manual_public_ip_logging_ok was not modified in the config based on its
        # value in the renewal conf file
        self.assertIsInstance(lineage_config.manual_public_ip_logging_ok, mock.MagicMock)

            

Reported by Pylint.

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

    @mock.patch('certbot._internal.renewal.cli.set_by_cli')
    def test_allow_subset_of_names_success(self, mock_set_by_cli):
        mock_set_by_cli.return_value = False

            

Reported by Pylint.