import datetime
import unittest

import josepy as jose
import pytz


class FixedTest(unittest.TestCase):
    """Tests for acme.fields.Fixed."""

            

Reported by Pylint.

              import unittest

import josepy as jose
import pytz


class FixedTest(unittest.TestCase):
    """Tests for acme.fields.Fixed."""


            

Reported by Pylint.

                  """Tests for acme.fields.Fixed."""

    def setUp(self):
        from acme.fields import Fixed
        self.field = Fixed('name', 'x')

    def test_decode(self):
        self.assertEqual('x', self.field.decode('x'))


            

Reported by Pylint.

                      self.encoded = '2015-03-27T00:00:00Z'

    def test_default_encoder(self):
        from acme.fields import RFC3339Field
        self.assertEqual(
            self.encoded, RFC3339Field.default_encoder(self.decoded))

    def test_default_encoder_naive_fails(self):
        from acme.fields import RFC3339Field

            

Reported by Pylint.

                          self.encoded, RFC3339Field.default_encoder(self.decoded))

    def test_default_encoder_naive_fails(self):
        from acme.fields import RFC3339Field
        self.assertRaises(
            ValueError, RFC3339Field.default_encoder, datetime.datetime.now())

    def test_default_decoder(self):
        from acme.fields import RFC3339Field

            

Reported by Pylint.

                          ValueError, RFC3339Field.default_encoder, datetime.datetime.now())

    def test_default_decoder(self):
        from acme.fields import RFC3339Field
        self.assertEqual(
            self.decoded, RFC3339Field.default_decoder(self.encoded))

    def test_default_decoder_raises_deserialization_error(self):
        from acme.fields import RFC3339Field

            

Reported by Pylint.

                          self.decoded, RFC3339Field.default_decoder(self.encoded))

    def test_default_decoder_raises_deserialization_error(self):
        from acme.fields import RFC3339Field
        self.assertRaises(
            jose.DeserializationError, RFC3339Field.default_decoder, '')


class ResourceTest(unittest.TestCase):

            

Reported by Pylint.

                  """Tests for acme.fields.Resource."""

    def setUp(self):
        from acme.fields import Resource
        self.field = Resource('x')

    def test_decode_good(self):
        self.assertEqual('x', self.field.decode('x'))


            

Reported by Pylint.

                  """Tests for acme.fields.Fixed."""

    def setUp(self):
        from acme.fields import Fixed
        self.field = Fixed('name', 'x')

    def test_decode(self):
        self.assertEqual('x', self.field.decode('x'))


            

Reported by Pylint.

                      from acme.fields import Fixed
        self.field = Fixed('name', 'x')

    def test_decode(self):
        self.assertEqual('x', self.field.decode('x'))

    def test_decode_bad(self):
        self.assertRaises(jose.DeserializationError, self.field.decode, 'y')


            

Reported by Pylint.

              import tempfile
from zipfile import ZipFile

from azure.devops.connection import Connection
from github import Github
import requests

# Path to the root directory of the Certbot repository containing this script
REPO_ROOT = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))

            

Reported by Pylint.

              from zipfile import ZipFile

from azure.devops.connection import Connection
from github import Github
import requests

# Path to the root directory of the Certbot repository containing this script
REPO_ROOT = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
# This list contains the names of all Certbot DNS plugins

            

Reported by Pylint.

                  build_client = connection.clients.get_build_client()
    get_builds_response = build_client.get_builds('certbot', definitions='3')
    build_id = get_builds_response.value[0].id
    artifacts = build_client.get_artifacts('certbot', build_id)

    # Save and unzip files
    for filename in ('windows-installer', 'changelog'):
        print("Downloading artifact %s" % filename)
        url = build_client.get_artifact('certbot', build_id, filename).resource.download_url

            

Reported by Pylint.

                  print('Getting revision numbers for', snap, version)
    cmd = ['snapcraft', 'status', snap]
    process = subprocess.run(cmd, check=True, stdout=subprocess.PIPE, universal_newlines=True)
    pattern = f'^\s+beta\s+{version}\s+(\d+)\s*$'
    revisions = re.findall(pattern, process.stdout, re.MULTILINE)
    assert len(revisions) == SNAP_ARCH_COUNT, f'Unexpected number of snaps found for {snap} {version}'
    return revisions



            

Reported by Pylint.

                  print('Getting revision numbers for', snap, version)
    cmd = ['snapcraft', 'status', snap]
    process = subprocess.run(cmd, check=True, stdout=subprocess.PIPE, universal_newlines=True)
    pattern = f'^\s+beta\s+{version}\s+(\d+)\s*$'
    revisions = re.findall(pattern, process.stdout, re.MULTILINE)
    assert len(revisions) == SNAP_ARCH_COUNT, f'Unexpected number of snaps found for {snap} {version}'
    return revisions



            

Reported by Pylint.

                  print('Getting revision numbers for', snap, version)
    cmd = ['snapcraft', 'status', snap]
    process = subprocess.run(cmd, check=True, stdout=subprocess.PIPE, universal_newlines=True)
    pattern = f'^\s+beta\s+{version}\s+(\d+)\s*$'
    revisions = re.findall(pattern, process.stdout, re.MULTILINE)
    assert len(revisions) == SNAP_ARCH_COUNT, f'Unexpected number of snaps found for {snap} {version}'
    return revisions



            

Reported by Pylint.

                  print('Getting revision numbers for', snap, version)
    cmd = ['snapcraft', 'status', snap]
    process = subprocess.run(cmd, check=True, stdout=subprocess.PIPE, universal_newlines=True)
    pattern = f'^\s+beta\s+{version}\s+(\d+)\s*$'
    revisions = re.findall(pattern, process.stdout, re.MULTILINE)
    assert len(revisions) == SNAP_ARCH_COUNT, f'Unexpected number of snaps found for {snap} {version}'
    return revisions



            

Reported by Pylint.

                  print('Getting revision numbers for', snap, version)
    cmd = ['snapcraft', 'status', snap]
    process = subprocess.run(cmd, check=True, stdout=subprocess.PIPE, universal_newlines=True)
    pattern = f'^\s+beta\s+{version}\s+(\d+)\s*$'
    revisions = re.findall(pattern, process.stdout, re.MULTILINE)
    assert len(revisions) == SNAP_ARCH_COUNT, f'Unexpected number of snaps found for {snap} {version}'
    return revisions



            

Reported by Pylint.

              
Setup:
 - Create a github personal access token
   - https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token#creating-a-token
   - You'll need repo scope
   - Save the token to somewhere like ~/.ssh/githubpat.txt
 - Install the snapcraft command line tool and log in to a privileged account.
   - https://snapcraft.io/docs/installing-snapcraft
   - Use the command `snapcraft login` to log in.

            

Reported by Pylint.

              import glob
import os.path
import re
import subprocess
import sys
import tempfile
from zipfile import ZipFile

from azure.devops.connection import Connection

            

Reported by Bandit.

              import logging
from typing import Optional

import dns.flags
import dns.message
import dns.name
import dns.query
import dns.rdataclass
import dns.rdatatype

            

Reported by Pylint.

              from typing import Optional

import dns.flags
import dns.message
import dns.name
import dns.query
import dns.rdataclass
import dns.rdatatype
import dns.tsig

            

Reported by Pylint.

              
import dns.flags
import dns.message
import dns.name
import dns.query
import dns.rdataclass
import dns.rdatatype
import dns.tsig
import dns.tsigkeyring

            

Reported by Pylint.

              import dns.flags
import dns.message
import dns.name
import dns.query
import dns.rdataclass
import dns.rdatatype
import dns.tsig
import dns.tsigkeyring
import dns.update

            

Reported by Pylint.

              import dns.message
import dns.name
import dns.query
import dns.rdataclass
import dns.rdatatype
import dns.tsig
import dns.tsigkeyring
import dns.update


            

Reported by Pylint.

              import dns.name
import dns.query
import dns.rdataclass
import dns.rdatatype
import dns.tsig
import dns.tsigkeyring
import dns.update

from certbot import errors

            

Reported by Pylint.

              import dns.query
import dns.rdataclass
import dns.rdatatype
import dns.tsig
import dns.tsigkeyring
import dns.update

from certbot import errors
from certbot.plugins import dns_common

            

Reported by Pylint.

              import dns.rdataclass
import dns.rdatatype
import dns.tsig
import dns.tsigkeyring
import dns.update

from certbot import errors
from certbot.plugins import dns_common
from certbot.plugins.dns_common import CredentialsConfiguration

            

Reported by Pylint.

              import dns.rdatatype
import dns.tsig
import dns.tsigkeyring
import dns.update

from certbot import errors
from certbot.plugins import dns_common
from certbot.plugins.dns_common import CredentialsConfiguration


            

Reported by Pylint.

              import dns.tsigkeyring
import dns.update

from certbot import errors
from certbot.plugins import dns_common
from certbot.plugins.dns_common import CredentialsConfiguration

logger = logging.getLogger(__name__)


            

Reported by Pylint.

              
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric.rsa import generate_private_key
import josepy as jose
import OpenSSL

from acme import client as acme_client
from acme import crypto_util as acme_crypto_util
from acme import errors as acme_errors

            

Reported by Pylint.

              import josepy as jose
import OpenSSL

from acme import client as acme_client
from acme import crypto_util as acme_crypto_util
from acme import errors as acme_errors
from acme import messages
import certbot
from certbot import crypto_util

            

Reported by Pylint.

              import OpenSSL

from acme import client as acme_client
from acme import crypto_util as acme_crypto_util
from acme import errors as acme_errors
from acme import messages
import certbot
from certbot import crypto_util
from certbot import errors

            

Reported by Pylint.

              
from acme import client as acme_client
from acme import crypto_util as acme_crypto_util
from acme import errors as acme_errors
from acme import messages
import certbot
from certbot import crypto_util
from certbot import errors
from certbot import util

            

Reported by Pylint.

              from acme import client as acme_client
from acme import crypto_util as acme_crypto_util
from acme import errors as acme_errors
from acme import messages
import certbot
from certbot import crypto_util
from certbot import errors
from certbot import util
from certbot._internal import account

            

Reported by Pylint.

              
def acme_from_config_key(config, key, regr=None):
    "Wrangle ACME client construction"
    # TODO: Allow for other alg types besides RS256
    net = acme_client.ClientNetwork(key, account=regr, verify_ssl=(not config.no_verify_ssl),
                                    user_agent=determine_user_agent(config))

    with warnings.catch_warnings():
        # TODO: full removal of ACMEv1 support: https://github.com/certbot/certbot/issues/6844

            

Reported by Pylint.

                                                  user_agent=determine_user_agent(config))

    with warnings.catch_warnings():
        # TODO: full removal of ACMEv1 support: https://github.com/certbot/certbot/issues/6844
        warnings.simplefilter("ignore", PendingDeprecationWarning)

        client = acme_client.BackwardsCompatibleClientV2(net, key, config.server)
        if client.acme_version == 1:
            logger.warning(

            

Reported by Pylint.

                          backend=default_backend())
    key = jose.JWKRSA(key=jose.ComparableRSAKey(rsa_key))
    acme = acme_from_config_key(config, key)
    # TODO: add phone?
    regr = perform_registration(acme, config, tos_cb)

    acc = account.Account(regr, key)
    account_storage.save(acc, acme)


            

Reported by Pylint.

                      try:
            orderr = self.acme.new_order(csr_pem)
        except acme_errors.WildcardUnsupportedError:
            raise errors.Error("The currently selected ACME CA endpoint does"
                               " not support issuing wildcard certificates.")

        if not self.auth_handler:
            raise errors.Error("No authorization handler has been set.")


            

Reported by Pylint.

                  :raises .errors.Error: when validation fails

    """
    # TODO: Handle all of these problems appropriately
    # The client can eventually do things like prompt the user
    # and allow the user to take more appropriate actions

    # Key must be readable and valid.
    if privkey.pem and not crypto_util.valid_privkey(privkey.pem):

            

Reported by Pylint.

              import typing
from unittest.mock import MagicMock

import josepy as jose
from requests.exceptions import HTTPError
from requests.exceptions import RequestException

from acme.challenges import Challenge
from certbot import errors

            

Reported by Pylint.

              from requests.exceptions import HTTPError
from requests.exceptions import RequestException

from acme.challenges import Challenge
from certbot import errors
from certbot.plugins import dns_test_common
from certbot.plugins.dns_common_lexicon import LexiconClient
from certbot.plugins.dns_test_common import _AuthenticatorCallableTestCase
from certbot.tests import util as test_util

            

Reported by Pylint.

              except ImportError:  # pragma: no cover
    from unittest import mock  # type: ignore
if typing.TYPE_CHECKING:
    from typing_extensions import Protocol
else:
    Protocol = object  # type: ignore




            

Reported by Pylint.

                  achall: Challenge


class _LexiconAwareTestCase(Protocol):
    """
    Protocol describing a TestCase suitable to test a real LexiconClient instance.
    """
    client: LexiconClient
    provider_mock: MagicMock

            

Reported by Pylint.

                  LOGIN_ERROR: Exception
    UNKNOWN_LOGIN_ERROR: Exception

    def assertRaises(self, *unused_args) -> None:
        """
        See
        https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertRaises
        """
        ...

            

Reported by Pylint.

                  LOGIN_ERROR: Exception
    UNKNOWN_LOGIN_ERROR: Exception

    def assertRaises(self, *unused_args) -> None:
        """
        See
        https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertRaises
        """
        ...

            

Reported by Pylint.

              # These classes are intended to be subclassed/mixed in, so not all members are defined.
# pylint: disable=no-member

class BaseLexiconAuthenticatorTest(dns_test_common.BaseAuthenticatorTest):

    @test_util.patch_display_util()
    def test_perform(self: _AuthenticatorCallableLexiconTestCase, unused_mock_get_utility):
        self.auth.perform([self.achall])


            

Reported by Pylint.

              class BaseLexiconAuthenticatorTest(dns_test_common.BaseAuthenticatorTest):

    @test_util.patch_display_util()
    def test_perform(self: _AuthenticatorCallableLexiconTestCase, unused_mock_get_utility):
        self.auth.perform([self.achall])

        expected = [mock.call.add_txt_record(DOMAIN, '_acme-challenge.'+DOMAIN, mock.ANY)]
        self.assertEqual(expected, self.mock_client.mock_calls)


            

Reported by Pylint.

                      expected = [mock.call.add_txt_record(DOMAIN, '_acme-challenge.'+DOMAIN, mock.ANY)]
        self.assertEqual(expected, self.mock_client.mock_calls)

    def test_cleanup(self: _AuthenticatorCallableLexiconTestCase):
        self.auth._attempt_cleanup = True  # _attempt_cleanup | pylint: disable=protected-access
        self.auth.cleanup([self.achall])

        expected = [mock.call.del_txt_record(DOMAIN, '_acme-challenge.'+DOMAIN, mock.ANY)]
        self.assertEqual(expected, self.mock_client.mock_calls)

            

Reported by Pylint.

                      self.assertEqual(expected, self.mock_client.mock_calls)


class BaseLexiconClientTest:
    DOMAIN_NOT_FOUND = Exception('No domain found')
    GENERIC_ERROR = RequestException
    LOGIN_ERROR = HTTPError('400 Client Error: ...')
    UNKNOWN_LOGIN_ERROR = HTTPError('500 Surprise! Error: ...')


            

Reported by Pylint.

              import sys
import unittest

from certbot.compat import filesystem  # pylint: disable=ungrouped-imports
from certbot.compat import os  # pylint: disable=ungrouped-imports
import certbot.tests.util as test_util  # pylint: disable=ungrouped-imports

try:
    import mock

            

Reported by Pylint.

              import unittest

from certbot.compat import filesystem  # pylint: disable=ungrouped-imports
from certbot.compat import os  # pylint: disable=ungrouped-imports
import certbot.tests.util as test_util  # pylint: disable=ungrouped-imports

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

            

Reported by Pylint.

              
from certbot.compat import filesystem  # pylint: disable=ungrouped-imports
from certbot.compat import os  # pylint: disable=ungrouped-imports
import certbot.tests.util as test_util  # pylint: disable=ungrouped-imports

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

            

Reported by Pylint.

              
        # directories must end with os.sep for completer to
        # search inside the directory for possible completions
        if self.tempdir[-1] != os.sep:
            self.tempdir += os.sep

        self.paths: List[str] = []
        # create some files and directories in temp_dir
        for c in string.ascii_lowercase:

            

Reported by Pylint.

                      # directories must end with os.sep for completer to
        # search inside the directory for possible completions
        if self.tempdir[-1] != os.sep:
            self.tempdir += os.sep

        self.paths: List[str] = []
        # create some files and directories in temp_dir
        for c in string.ascii_lowercase:
            path = os.path.join(self.tempdir, c)

            

Reported by Pylint.

                      self.paths: List[str] = []
        # create some files and directories in temp_dir
        for c in string.ascii_lowercase:
            path = os.path.join(self.tempdir, c)
            self.paths.append(path)
            if ord(c) % 2:
                filesystem.mkdir(path)
            else:
                with open(path, 'w'):

            

Reported by Pylint.

                                  pass

    def test_complete(self):
        from certbot._internal.display import completer
        my_completer = completer.Completer()
        num_paths = len(self.paths)

        for i in range(num_paths):
            completion = my_completer.complete(self.tempdir, i)

            

Reported by Pylint.

                      num_paths = len(self.paths)

        for i in range(num_paths):
            completion = my_completer.complete(self.tempdir, i)
            self.assertIn(completion, self.paths)
            self.paths.remove(completion)

        self.assertEqual(len(self.paths), 0)
        completion = my_completer.complete(self.tempdir, num_paths)

            

Reported by Pylint.

                          self.paths.remove(completion)

        self.assertEqual(len(self.paths), 0)
        completion = my_completer.complete(self.tempdir, num_paths)
        self.assertIsNone(completion)

    @unittest.skipIf('readline' not in sys.modules,
                     reason='Not relevant if readline is not available.')
    def test_import_error(self):

            

Reported by Pylint.

                      sys.modules['readline'] = original_readline

    def test_context_manager_with_unmocked_readline(self):
        from certbot._internal.display import completer
        reload_module(completer)

        original_completer = readline.get_completer()
        original_delims = readline.get_completer_delims()


            

Reported by Pylint.

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

from certbot import errors
from certbot._internal import constants
from certbot.compat import misc
from certbot.compat import os
from certbot.tests import util as test_util


            

Reported by Pylint.

                  from unittest import mock

from certbot import errors
from certbot._internal import constants
from certbot.compat import misc
from certbot.compat import os
from certbot.tests import util as test_util



            

Reported by Pylint.

              
from certbot import errors
from certbot._internal import constants
from certbot.compat import misc
from certbot.compat import os
from certbot.tests import util as test_util


class NamespaceConfigTest(test_util.ConfigTestCase):

            

Reported by Pylint.

              from certbot import errors
from certbot._internal import constants
from certbot.compat import misc
from certbot.compat import os
from certbot.tests import util as test_util


class NamespaceConfigTest(test_util.ConfigTestCase):
    """Tests for certbot.configuration.NamespaceConfig."""

            

Reported by Pylint.

              from certbot._internal import constants
from certbot.compat import misc
from certbot.compat import os
from certbot.tests import util as test_util


class NamespaceConfigTest(test_util.ConfigTestCase):
    """Tests for certbot.configuration.NamespaceConfig."""


            

Reported by Pylint.

              
    def test_init_same_ports(self):
        self.config.namespace.https_port = 4321
        from certbot.configuration import NamespaceConfig
        self.assertRaises(errors.Error, NamespaceConfig, self.config.namespace)

    def test_proxy_getattr(self):
        self.assertEqual(self.config.foo, 'bar')
        self.assertEqual(self.config.work_dir, os.path.join(self.tempdir, 'work'))

            

Reported by Pylint.

                          os.path.normpath(os.path.join(self.config.work_dir, 't')))

    def test_absolute_paths(self):
        from certbot.configuration import NamespaceConfig

        config_base = "foo"
        work_base = "bar"
        logs_base = "baz"
        server = "mock.server"

            

Reported by Pylint.

                                  self.config.config_dir, 'renewal_configs'))

    def test_renewal_absolute_paths(self):
        from certbot.configuration import NamespaceConfig

        config_base = "foo"
        work_base = "bar"
        logs_base = "baz"


            

Reported by Pylint.

              class NamespaceConfigTest(test_util.ConfigTestCase):
    """Tests for certbot.configuration.NamespaceConfig."""

    def setUp(self):
        super().setUp()
        self.config.foo = 'bar' # pylint: disable=blacklisted-name
        self.config.server = 'https://acme-server.org:443/new'
        self.config.https_port = 1234
        self.config.http01_port = 4321

            

Reported by Pylint.

              class NamespaceConfigTest(test_util.ConfigTestCase):
    """Tests for certbot.configuration.NamespaceConfig."""

    def setUp(self):
        super().setUp()
        self.config.foo = 'bar' # pylint: disable=blacklisted-name
        self.config.server = 'https://acme-server.org:443/new'
        self.config.https_port = 1234
        self.config.http01_port = 4321

            

Reported by Pylint.

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

from certbot import errors
from certbot._internal.cli import HelpfulArgumentParser
from certbot._internal.cli import _DomainsAction
from certbot._internal import constants



            

Reported by Pylint.

                  from unittest import mock

from certbot import errors
from certbot._internal.cli import HelpfulArgumentParser
from certbot._internal.cli import _DomainsAction
from certbot._internal import constants


class TestScanningFlags(unittest.TestCase):

            

Reported by Pylint.

              
from certbot import errors
from certbot._internal.cli import HelpfulArgumentParser
from certbot._internal.cli import _DomainsAction
from certbot._internal import constants


class TestScanningFlags(unittest.TestCase):
    '''Test the prescan_for_flag method of HelpfulArgumentParser'''

            

Reported by Pylint.

              from certbot import errors
from certbot._internal.cli import HelpfulArgumentParser
from certbot._internal.cli import _DomainsAction
from certbot._internal import constants


class TestScanningFlags(unittest.TestCase):
    '''Test the prescan_for_flag method of HelpfulArgumentParser'''
    def test_prescan_no_help_flag(self):

            

Reported by Pylint.

              
class TestScanningFlags(unittest.TestCase):
    '''Test the prescan_for_flag method of HelpfulArgumentParser'''
    def test_prescan_no_help_flag(self):
        arg_parser = HelpfulArgumentParser(['run'], {})
        detected_flag = arg_parser.prescan_for_flag('--help',
                                                        ['all', 'certonly'])
        self.assertIs(detected_flag, False)
        detected_flag = arg_parser.prescan_for_flag('-h',

            

Reported by Pylint.

                                                                      ['all, certonly'])
        self.assertIs(detected_flag, False)

    def test_prescan_unvalid_topic(self):
        arg_parser = HelpfulArgumentParser(['--help', 'all'], {})
        detected_flag = arg_parser.prescan_for_flag('--help',
                                                    ['potato'])
        self.assertIs(detected_flag, True)
        detected_flag = arg_parser.prescan_for_flag('-h',

            

Reported by Pylint.

                                                                  arg_parser.help_topics)
        self.assertIs(detected_flag, False)

    def test_prescan_valid_topic(self):
        arg_parser = HelpfulArgumentParser(['-h', 'all'], {})
        detected_flag = arg_parser.prescan_for_flag('-h',
                                                    arg_parser.help_topics)
        self.assertEqual(detected_flag, 'all')
        detected_flag = arg_parser.prescan_for_flag('--help',

            

Reported by Pylint.

              
class TestDetermineVerbs(unittest.TestCase):
    '''Tests for determine_verb methods of HelpfulArgumentParser'''
    def test_determine_verb_wrong_verb(self):
        arg_parser = HelpfulArgumentParser(['potato'], {})
        self.assertEqual(arg_parser.verb, "run")
        self.assertEqual(arg_parser.args, ["potato"])

    def test_determine_verb_help(self):

            

Reported by Pylint.

                      self.assertEqual(arg_parser.verb, "run")
        self.assertEqual(arg_parser.args, ["potato"])

    def test_determine_verb_help(self):
        arg_parser = HelpfulArgumentParser(['--help', 'everything'], {})
        self.assertEqual(arg_parser.verb, "help")
        self.assertEqual(arg_parser.args, ["--help", "everything"])
        arg_parser = HelpfulArgumentParser(['-d', 'some_domain', '--help',
                                               'all'], {})

            

Reported by Pylint.

                      self.assertEqual(arg_parser.args, ['-d', 'some_domain', '--help',
                                               'all'])

    def test_determine_verb(self):
        arg_parser = HelpfulArgumentParser(['certonly'], {})
        self.assertEqual(arg_parser.verb, 'certonly')
        self.assertEqual(arg_parser.args, [])

        arg_parser = HelpfulArgumentParser(['auth'], {})

            

Reported by Pylint.

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

from certbot import errors
from certbot.compat import os
from certbot.tests import util as certbot_util
from certbot_apache._internal import apache_util
from certbot_apache._internal import obj
import util

            

Reported by Pylint.

                  from unittest import mock # type: ignore

from certbot import errors
from certbot.compat import os
from certbot.tests import util as certbot_util
from certbot_apache._internal import apache_util
from certbot_apache._internal import obj
import util


            

Reported by Pylint.

              
from certbot import errors
from certbot.compat import os
from certbot.tests import util as certbot_util
from certbot_apache._internal import apache_util
from certbot_apache._internal import obj
import util



            

Reported by Pylint.

              from certbot import errors
from certbot.compat import os
from certbot.tests import util as certbot_util
from certbot_apache._internal import apache_util
from certbot_apache._internal import obj
import util


class MultipleVhostsTestDebian(util.ApacheTest):

            

Reported by Pylint.

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


class MultipleVhostsTestDebian(util.ApacheTest):
    """Multiple vhost tests for Debian family of distros"""

            

Reported by Pylint.

                          self.assertTrue(ssl_vhost.enabled)

    def test_enable_site_failure(self):
        self.config.parser.root = "/tmp/nonexistent"
        with mock.patch("certbot.compat.os.path.isdir") as mock_dir:
            mock_dir.return_value = True
            with mock.patch("certbot.compat.os.path.islink") as mock_link:
                mock_link.return_value = False
                self.assertRaises(

            

Reported by Bandit.

                  def test_enable_site_call_parent(self):
        with mock.patch(
            "certbot_apache._internal.configurator.ApacheConfigurator.enable_site") as e_s:
            self.config.parser.root = "/tmp/nonexistent"
            vh = self.vh_truth[0]
            vh.enabled = False
            self.config.enable_site(vh)
            self.assertTrue(e_s.called)


            

Reported by Bandit.

                      self.config.deploy_cert = mocked_deploy_cert
        return self.config

    def test_enable_mod_unsupported_dirs(self):
        shutil.rmtree(os.path.join(self.config.parser.root, "mods-enabled"))
        self.assertRaises(
            errors.NotSupportedError, self.config.enable_mod, "ssl")

    @mock.patch("certbot.util.run_script")

            

Reported by Pylint.

                  @mock.patch("certbot.util.run_script")
    @mock.patch("certbot.util.exe_exists")
    @mock.patch("certbot_apache._internal.apache_util.subprocess.run")
    def test_enable_mod(self, mock_run, mock_exe_exists, mock_run_script):
        mock_run.return_value.stdout = "Define: DUMP_RUN_CFG"
        mock_run.return_value.stderr = ""
        mock_run.return_value.returncode = 0
        mock_exe_exists.return_value = True


            

Reported by Pylint.

              
        self.assertTrue(mock_run_script.called)

    def test_deploy_cert_enable_new_vhost(self):
        # Create
        ssl_vhost = self.config.make_vhost_ssl(self.vh_truth[0])
        self.config.parser.modules["ssl_module"] = None
        self.config.parser.modules["mod_ssl.c"] = None
        self.assertFalse(ssl_vhost.enabled)

            

Reported by Pylint.

              import shutil
import tempfile

from certbot._internal import constants
from certbot_compatibility_test import interfaces
from certbot_compatibility_test import errors
from certbot_compatibility_test import util

logger = logging.getLogger(__name__)

            

Reported by Pylint.

              
    def load_config(self):
        """Returns the next config directory to be tested"""
        shutil.rmtree(self.le_config.work_dir, ignore_errors=True)
        backup = os.path.join(self.le_config.work_dir, constants.BACKUP_DIR)
        os.makedirs(backup)
        return self._configs.pop()

    def copy_certs_and_keys(self, cert_path, key_path, chain_path=None):

            

Reported by Pylint.

                  def load_config(self):
        """Returns the next config directory to be tested"""
        shutil.rmtree(self.le_config.work_dir, ignore_errors=True)
        backup = os.path.join(self.le_config.work_dir, constants.BACKUP_DIR)
        os.makedirs(backup)
        return self._configs.pop()

    def copy_certs_and_keys(self, cert_path, key_path, chain_path=None):
        """Copies certs and keys into the temporary directory"""

            

Reported by Pylint.

                      self._temp_dir = tempfile.mkdtemp()
        # tempfile.mkdtemp() creates folders with too restrictive permissions to be accessible
        # to an Apache worker, leading to HTTP challenge failures. Let's fix that.
        os.chmod(self._temp_dir, 0o755)
        self.le_config = util.create_le_config(self._temp_dir)
        config_dir = util.extract_configs(args.configs, self._temp_dir)
        self._configs = [
            os.path.join(config_dir, config)
            for config in os.listdir(config_dir)]

            

Reported by Bandit.

              logger = logging.getLogger(__name__)


class Proxy(interfaces.ConfiguratorProxy):
    """A common base for compatibility test configurators"""

    @classmethod
    def add_parser_arguments(cls, parser):
        """Adds command line arguments needed by the plugin"""

            

Reported by Pylint.

              logger = logging.getLogger(__name__)


class Proxy(interfaces.ConfiguratorProxy):
    """A common base for compatibility test configurators"""

    @classmethod
    def add_parser_arguments(cls, parser):
        """Adds command line arguments needed by the plugin"""

            

Reported by Pylint.

                          return self._test_names
        return {"example.com"}

    def deploy_cert(self, domain, cert_path, key_path, chain_path=None,
                    fullchain_path=None):
        """Installs cert"""
        cert_path, key_path, chain_path = self.copy_certs_and_keys(
            cert_path, key_path, chain_path)
        if not self._configurator:

            

Reported by Pylint.

                          domain, cert_path, key_path, chain_path, fullchain_path)


    def cleanup(self, achalls):
        self._configurator.cleanup(achalls)

    def config_test(self):
        self._configurator.config_test()


            

Reported by Pylint.

                  def cleanup(self, achalls):
        self._configurator.cleanup(achalls)

    def config_test(self):
        self._configurator.config_test()

    def enhance(self, domain, enhancement, options = None):
        self._configurator.enhance(domain, enhancement, options)


            

Reported by Pylint.

                  def config_test(self):
        self._configurator.config_test()

    def enhance(self, domain, enhancement, options = None):
        self._configurator.enhance(domain, enhancement, options)

    def get_all_names(self):
        return self._configurator.get_all_names()


            

Reported by Pylint.