Gecko [ paroquia-rio-de-mouro.pt ]

Name	Size	Permission	Date
__pycache__	[ DIR ]	drwxr-xr-x	2021-02-25 12:38
__init__.py	30 B	-rw-r--r--	2019-02-07 22:20
common.py	16.9 KB	-rw-r--r--	2019-02-07 22:20
common_test.py	16.53 KB	-rw-r--r--	2019-02-07 22:20
disco.py	9.92 KB	-rw-r--r--	2019-02-07 22:20
disco_test.py	11.34 KB	-rw-r--r--	2019-02-07 22:20
dns_common.py	11.7 KB	-rw-r--r--	2019-02-07 22:20
dns_common_lexicon.py	5.39 KB	-rw-r--r--	2019-02-07 22:20
dns_common_lexicon_test.py	651 B	-rw-r--r--	2019-02-07 22:20
dns_common_test.py	8.25 KB	-rw-r--r--	2019-02-07 22:20
dns_test_common.py	1.61 KB	-rw-r--r--	2019-02-07 22:20
dns_test_common_lexicon.py	5.48 KB	-rw-r--r--	2019-02-07 22:20
enhancements.py	5.58 KB	-rw-r--r--	2019-02-07 22:20
enhancements_test.py	2.36 KB	-rw-r--r--	2019-02-07 22:20
manual.py	10.6 KB	-rw-r--r--	2019-02-07 22:20
manual_test.py	7.37 KB	-rw-r--r--	2019-02-07 22:20
null.py	1.34 KB	-rw-r--r--	2019-02-07 22:20
null_test.py	624 B	-rw-r--r--	2019-02-07 22:20
selection.py	13.55 KB	-rw-r--r--	2019-02-07 22:20
selection_test.py	7.76 KB	-rw-r--r--	2019-02-07 22:20
standalone.py	11.36 KB	-rw-r--r--	2019-02-07 22:20
standalone_test.py	9.26 KB	-rw-r--r--	2019-02-07 22:20
storage.py	4.08 KB	-rw-r--r--	2019-02-07 22:20
storage_test.py	5.37 KB	-rw-r--r--	2019-02-07 22:20
util.py	1.7 KB	-rw-r--r--	2019-02-07 22:20
util_test.py	1.61 KB	-rw-r--r--	2019-02-07 22:20
webroot.py	11.9 KB	-rw-r--r--	2019-02-07 22:20
webroot_test.py	11.95 KB	-rw-r--r--	2019-02-07 22:20

Rename

"""Tests for certbot.plugins.dns_common."""

import collections
import logging
import os
import unittest

import mock

from certbot import errors
from certbot.display import util as display_util
from certbot.plugins import dns_common
from certbot.plugins import dns_test_common
from certbot.tests import util

class DNSAuthenticatorTest(util.TempDirTestCase, dns_test_common.BaseAuthenticatorTest):
    # pylint: disable=protected-access

class _FakeDNSAuthenticator(dns_common.DNSAuthenticator):
        _setup_credentials = mock.MagicMock()
        _perform = mock.MagicMock()
        _cleanup = mock.MagicMock()

def __init__(self, *args, **kwargs):
            # pylint: disable=protected-access
            super(DNSAuthenticatorTest._FakeDNSAuthenticator, self).__init__(*args, **kwargs)

def more_info(self):  # pylint: disable=missing-docstring,no-self-use
            return 'A fake authenticator for testing.'

class _FakeConfig(object):
        fake_propagation_seconds = 0
        fake_config_key = 1
        fake_other_key = None
        fake_file_path = None

def setUp(self):
        super(DNSAuthenticatorTest, self).setUp()

self.config = DNSAuthenticatorTest._FakeConfig()

self.auth = DNSAuthenticatorTest._FakeDNSAuthenticator(self.config, "fake")

def test_perform(self):
        self.auth.perform([self.achall])

self.auth._perform.assert_called_once_with(dns_test_common.DOMAIN, mock.ANY, mock.ANY)

def test_cleanup(self):
        self.auth._attempt_cleanup = True

self.auth.cleanup([self.achall])

self.auth._cleanup.assert_called_once_with(dns_test_common.DOMAIN, mock.ANY, mock.ANY)

@util.patch_get_utility()
    def test_prompt(self, mock_get_utility):
        mock_display = mock_get_utility()
        mock_display.input.side_effect = ((display_util.OK, "",),
                                          (display_util.OK, "value",))

self.auth._configure("other_key", "")
        self.assertEqual(self.auth.config.fake_other_key, "value")

@util.patch_get_utility()
    def test_prompt_canceled(self, mock_get_utility):
        mock_display = mock_get_utility()
        mock_display.input.side_effect = ((display_util.CANCEL, "c",),)

self.assertRaises(errors.PluginError, self.auth._configure, "other_key", "")

@util.patch_get_utility()
    def test_prompt_file(self, mock_get_utility):
        path = os.path.join(self.tempdir, 'file.ini')
        open(path, "wb").close()

mock_display = mock_get_utility()
        mock_display.directory_select.side_effect = ((display_util.OK, "",),
                                                     (display_util.OK, "not-a-file.ini",),
                                                     (display_util.OK, self.tempdir),
                                                     (display_util.OK, path,))

self.auth._configure_file("file_path", "")
        self.assertEqual(self.auth.config.fake_file_path, path)

@util.patch_get_utility()
    def test_prompt_file_canceled(self, mock_get_utility):
        mock_display = mock_get_utility()
        mock_display.directory_select.side_effect = ((display_util.CANCEL, "c",),)

self.assertRaises(errors.PluginError, self.auth._configure_file, "file_path", "")

def test_configure_credentials(self):
        path = os.path.join(self.tempdir, 'file.ini')
        dns_test_common.write({"fake_test": "value"}, path)
        setattr(self.config, "fake_credentials", path)

credentials = self.auth._configure_credentials("credentials", "", {"test": ""})

self.assertEqual(credentials.conf("test"), "value")

@util.patch_get_utility()
    def test_prompt_credentials(self, mock_get_utility):
        bad_path = os.path.join(self.tempdir, 'bad-file.ini')
        dns_test_common.write({"fake_other": "other_value"}, bad_path)

path = os.path.join(self.tempdir, 'file.ini')
        dns_test_common.write({"fake_test": "value"}, path)
        setattr(self.config, "fake_credentials", "")

credentials = self.auth._configure_credentials("credentials", "", {"test": ""})
        self.assertEqual(credentials.conf("test"), "value")

class CredentialsConfigurationTest(util.TempDirTestCase):
    class _MockLoggingHandler(logging.Handler):
        messages = None

def __init__(self, *args, **kwargs):
            self.reset()
            logging.Handler.__init__(self, *args, **kwargs)

def emit(self, record):
            self.messages[record.levelname.lower()].append(record.getMessage())

def reset(self):
            """Allows the handler to be reset between tests."""
            self.messages = collections.defaultdict(list)

def test_valid_file(self):
        path = os.path.join(self.tempdir, 'too-permissive-file.ini')

dns_test_common.write({"test": "value", "other": 1}, path)

credentials_configuration = dns_common.CredentialsConfiguration(path)
        self.assertEqual("value", credentials_configuration.conf("test"))
        self.assertEqual("1", credentials_configuration.conf("other"))

def test_nonexistent_file(self):
        path = os.path.join(self.tempdir, 'not-a-file.ini')

self.assertRaises(errors.PluginError, dns_common.CredentialsConfiguration, path)

def test_valid_file_with_unsafe_permissions(self):
        log = self._MockLoggingHandler()
        dns_common.logger.addHandler(log)

path = os.path.join(self.tempdir, 'too-permissive-file.ini')
        open(path, "wb").close()

dns_common.CredentialsConfiguration(path)

self.assertEqual(1, len([_ for _ in log.messages['warning'] if _.startswith("Unsafe")]))

class CredentialsConfigurationRequireTest(util.TempDirTestCase):

def setUp(self):
        super(CredentialsConfigurationRequireTest, self).setUp()

self.path = os.path.join(self.tempdir, 'file.ini')

def _write(self, values):
        dns_test_common.write(values, self.path)

def test_valid(self):
        self._write({"test": "value", "other": 1})

credentials_configuration = dns_common.CredentialsConfiguration(self.path)
        credentials_configuration.require({"test": "", "other": ""})

def test_valid_but_extra(self):
        self._write({"test": "value", "other": 1})

credentials_configuration = dns_common.CredentialsConfiguration(self.path)
        credentials_configuration.require({"test": ""})

def test_valid_empty(self):
        self._write({})

credentials_configuration = dns_common.CredentialsConfiguration(self.path)
        credentials_configuration.require({})

def test_missing(self):
        self._write({})

credentials_configuration = dns_common.CredentialsConfiguration(self.path)
        self.assertRaises(errors.PluginError, credentials_configuration.require, {"test": ""})

def test_blank(self):
        self._write({"test": ""})

credentials_configuration = dns_common.CredentialsConfiguration(self.path)
        self.assertRaises(errors.PluginError, credentials_configuration.require, {"test": ""})

def test_typo(self):
        self._write({"tets": "typo!"})

credentials_configuration = dns_common.CredentialsConfiguration(self.path)
        self.assertRaises(errors.PluginError, credentials_configuration.require, {"test": ""})

class DomainNameGuessTest(unittest.TestCase):

def test_simple_case(self):
        self.assertTrue(
            'example.com' in
            dns_common.base_domain_name_guesses("example.com")
        )

def test_sub_domain(self):
        self.assertTrue(
            'example.com' in
            dns_common.base_domain_name_guesses("foo.bar.baz.example.com")
        )

def test_second_level_domain(self):
        self.assertTrue(
            'example.co.uk' in
            dns_common.base_domain_name_guesses("foo.bar.baz.example.co.uk")
        )

if __name__ == "__main__":
    unittest.main()  # pragma: no cover