mirror of
https://github.com/certbot/certbot.git
synced 2026-01-21 19:01:07 +03:00
834691278e
(venv)root@le:~/lets-encrypt-preview# letsencrypt -vv auth
DEBUG:root:Logging level set at 10
Traceback (most recent call last):
File "/usr/lib/python2.7/logging/__init__.py", line 859, in emit
msg = self.format(record)
File "/usr/lib/python2.7/logging/__init__.py", line 732, in format
return fmt.format(record)
File "/usr/lib/python2.7/logging/__init__.py", line 471, in format
record.message = record.getMessage()
File "/usr/lib/python2.7/logging/__init__.py", line 335, in getMessage
msg = msg % self.args
File "/root/lets-encrypt-preview/letsencrypt/plugins/disco.py", line 219, in __repr__
self.__class__.__name__, set(self._plugins.itervalues()))
TypeError: unhashable type: 'PluginEntryPoint'
Logged from file cli.py, line 356
Traceback (most recent call last):
File "/root/lets-encrypt-preview/venv/bin/letsencrypt", line 9, in <module>
load_entry_point('letsencrypt==0.1', 'console_scripts', 'letsencrypt')()
File "/root/lets-encrypt-preview/letsencrypt/cli.py", line 356, in main
logging.debug("Discovered plugins: %r", plugins)
File "/usr/lib/python2.7/logging/__init__.py", line 1630, in debug
root.debug(msg, *args, **kwargs)
File "/usr/lib/python2.7/logging/__init__.py", line 1148, in debug
self._log(DEBUG, msg, args, **kwargs)
File "/usr/lib/python2.7/logging/__init__.py", line 1279, in _log
self.handle(record)
File "/usr/lib/python2.7/logging/__init__.py", line 1289, in handle
self.callHandlers(record)
File "/usr/lib/python2.7/logging/__init__.py", line 1329, in callHandlers
hdlr.handle(record)
File "/usr/lib/python2.7/logging/__init__.py", line 757, in handle
self.emit(record)
File "/root/lets-encrypt-preview/letsencrypt/log.py", line 40, in emit
for line in record.getMessage().splitlines():
File "/usr/lib/python2.7/logging/__init__.py", line 335, in getMessage
msg = msg % self.args
File "/root/lets-encrypt-preview/letsencrypt/plugins/disco.py", line 219, in __repr__
self.__class__.__name__, set(self._plugins.itervalues()))
TypeError: unhashable type: 'PluginEntryPoint'
244 lines
9.3 KiB
Python
244 lines
9.3 KiB
Python
"""Tests for letsencrypt.plugins.disco."""
|
|
import pkg_resources
|
|
import unittest
|
|
|
|
import mock
|
|
import zope.interface
|
|
|
|
from letsencrypt import errors
|
|
from letsencrypt import interfaces
|
|
|
|
from letsencrypt.plugins.standalone import authenticator
|
|
|
|
EP_SA = pkg_resources.EntryPoint(
|
|
"sa", "letsencrypt.plugins.standalone.authenticator",
|
|
attrs=("StandaloneAuthenticator",),
|
|
dist=mock.MagicMock(key="letsencrypt"))
|
|
|
|
|
|
class PluginEntryPointTest(unittest.TestCase):
|
|
"""Tests for letsencrypt.plugins.disco.PluginEntryPoint."""
|
|
|
|
def setUp(self):
|
|
self.ep1 = pkg_resources.EntryPoint(
|
|
"ep1", "p1.ep1", dist=mock.MagicMock(key="p1"))
|
|
self.ep1prim = pkg_resources.EntryPoint(
|
|
"ep1", "p2.ep2", dist=mock.MagicMock(key="p2"))
|
|
# nested
|
|
self.ep2 = pkg_resources.EntryPoint(
|
|
"ep2", "p2.foo.ep2", dist=mock.MagicMock(key="p2"))
|
|
# project name != top-level package name
|
|
self.ep3 = pkg_resources.EntryPoint(
|
|
"ep3", "a.ep3", dist=mock.MagicMock(key="p3"))
|
|
|
|
from letsencrypt.plugins.disco import PluginEntryPoint
|
|
self.plugin_ep = PluginEntryPoint(EP_SA)
|
|
|
|
def test_entry_point_to_plugin_name(self):
|
|
from letsencrypt.plugins.disco import PluginEntryPoint
|
|
|
|
names = {
|
|
self.ep1: "p1:ep1",
|
|
self.ep1prim: "p2:ep1",
|
|
self.ep2: "p2:ep2",
|
|
self.ep3: "p3:ep3",
|
|
EP_SA: "sa",
|
|
}
|
|
|
|
for entry_point, name in names.iteritems():
|
|
self.assertEqual(
|
|
name, PluginEntryPoint.entry_point_to_plugin_name(entry_point))
|
|
|
|
def test_description(self):
|
|
self.assertEqual("Standalone Authenticator", self.plugin_ep.description)
|
|
|
|
def test_description_with_name(self):
|
|
self.plugin_ep.plugin_cls = mock.MagicMock(description="Desc")
|
|
self.assertEqual(
|
|
"Desc (sa)", self.plugin_ep.description_with_name)
|
|
|
|
def test_ifaces(self):
|
|
self.assertTrue(self.plugin_ep.ifaces((interfaces.IAuthenticator,)))
|
|
self.assertFalse(self.plugin_ep.ifaces((interfaces.IInstaller,)))
|
|
self.assertFalse(self.plugin_ep.ifaces((
|
|
interfaces.IInstaller, interfaces.IAuthenticator)))
|
|
|
|
def test__init__(self):
|
|
self.assertFalse(self.plugin_ep.initialized)
|
|
self.assertFalse(self.plugin_ep.prepared)
|
|
self.assertFalse(self.plugin_ep.misconfigured)
|
|
self.assertFalse(self.plugin_ep.available)
|
|
self.assertTrue(self.plugin_ep.entry_point is EP_SA)
|
|
self.assertEqual("sa", self.plugin_ep.name)
|
|
|
|
self.assertTrue(
|
|
self.plugin_ep.plugin_cls is authenticator.StandaloneAuthenticator)
|
|
|
|
def test_init(self):
|
|
config = mock.MagicMock()
|
|
plugin = self.plugin_ep.init(config=config)
|
|
self.assertTrue(self.plugin_ep.initialized)
|
|
self.assertTrue(plugin.config is config)
|
|
# memoize!
|
|
self.assertTrue(self.plugin_ep.init() is plugin)
|
|
self.assertTrue(plugin.config is config)
|
|
# try to give different config
|
|
self.assertTrue(self.plugin_ep.init(123) is plugin)
|
|
self.assertTrue(plugin.config is config)
|
|
|
|
self.assertFalse(self.plugin_ep.prepared)
|
|
self.assertFalse(self.plugin_ep.misconfigured)
|
|
self.assertFalse(self.plugin_ep.available)
|
|
|
|
def test_verify(self):
|
|
iface1 = mock.MagicMock(__name__="iface1")
|
|
iface2 = mock.MagicMock(__name__="iface2")
|
|
iface3 = mock.MagicMock(__name__="iface3")
|
|
# pylint: disable=protected-access
|
|
self.plugin_ep._initialized = plugin = mock.MagicMock()
|
|
|
|
exceptions = zope.interface.exceptions
|
|
with mock.patch("letsencrypt.plugins."
|
|
"disco.zope.interface") as mock_zope:
|
|
mock_zope.exceptions = exceptions
|
|
def verify_object(iface, obj): # pylint: disable=missing-docstring
|
|
assert obj is plugin
|
|
assert iface is iface1 or iface is iface2 or iface is iface3
|
|
if iface is iface3:
|
|
raise mock_zope.exceptions.BrokenImplementation(None, None)
|
|
mock_zope.verify.verifyObject.side_effect = verify_object
|
|
self.assertTrue(self.plugin_ep.verify((iface1,)))
|
|
self.assertTrue(self.plugin_ep.verify((iface1, iface2)))
|
|
self.assertFalse(self.plugin_ep.verify((iface3,)))
|
|
self.assertFalse(self.plugin_ep.verify((iface1, iface3)))
|
|
|
|
def test_prepare(self):
|
|
config = mock.MagicMock()
|
|
self.plugin_ep.init(config=config)
|
|
self.plugin_ep.prepare()
|
|
self.assertTrue(self.plugin_ep.prepared)
|
|
self.assertFalse(self.plugin_ep.misconfigured)
|
|
|
|
# output doesn't matter that much, just test if it runs
|
|
str(self.plugin_ep)
|
|
|
|
def test_prepare_misconfigured(self):
|
|
plugin = mock.MagicMock()
|
|
plugin.prepare.side_effect = errors.LetsEncryptMisconfigurationError
|
|
# pylint: disable=protected-access
|
|
self.plugin_ep._initialized = plugin
|
|
self.assertTrue(isinstance(self.plugin_ep.prepare(),
|
|
errors.LetsEncryptMisconfigurationError))
|
|
self.assertTrue(self.plugin_ep.prepared)
|
|
self.assertTrue(self.plugin_ep.misconfigured)
|
|
self.assertTrue(self.plugin_ep.available)
|
|
|
|
def test_prepare_no_installation(self):
|
|
plugin = mock.MagicMock()
|
|
plugin.prepare.side_effect = errors.LetsEncryptNoInstallationError
|
|
# pylint: disable=protected-access
|
|
self.plugin_ep._initialized = plugin
|
|
self.assertTrue(isinstance(self.plugin_ep.prepare(),
|
|
errors.LetsEncryptNoInstallationError))
|
|
self.assertTrue(self.plugin_ep.prepared)
|
|
self.assertFalse(self.plugin_ep.misconfigured)
|
|
self.assertFalse(self.plugin_ep.available)
|
|
|
|
def test_repr(self):
|
|
self.assertEqual("PluginEntryPoint#sa", repr(self.plugin_ep))
|
|
|
|
|
|
class PluginsRegistryTest(unittest.TestCase):
|
|
"""Tests for letsencrypt.plugins.disco.PluginsRegistry."""
|
|
|
|
def setUp(self):
|
|
from letsencrypt.plugins.disco import PluginsRegistry
|
|
self.plugin_ep = mock.MagicMock(name="mock")
|
|
self.plugin_ep.__hash__.side_effect = TypeError
|
|
self.plugins = {"mock": self.plugin_ep}
|
|
self.reg = PluginsRegistry(self.plugins)
|
|
|
|
def test_find_all(self):
|
|
from letsencrypt.plugins.disco import PluginsRegistry
|
|
with mock.patch("letsencrypt.plugins.disco.pkg_resources") as mock_pkg:
|
|
mock_pkg.iter_entry_points.return_value = iter([EP_SA])
|
|
plugins = PluginsRegistry.find_all()
|
|
self.assertTrue(plugins["sa"].plugin_cls
|
|
is authenticator.StandaloneAuthenticator)
|
|
self.assertTrue(plugins["sa"].entry_point is EP_SA)
|
|
|
|
def test_getitem(self):
|
|
self.assertEqual(self.plugin_ep, self.reg["mock"])
|
|
|
|
def test_iter(self):
|
|
self.assertEqual(["mock"], list(self.reg))
|
|
|
|
def test_len(self):
|
|
self.assertEqual(1, len(self.reg))
|
|
self.plugins.clear()
|
|
self.assertEqual(0, len(self.reg))
|
|
|
|
def test_init(self):
|
|
self.plugin_ep.init.return_value = "baz"
|
|
self.assertEqual(["baz"], self.reg.init("bar"))
|
|
self.plugin_ep.init.assert_called_once_with("bar")
|
|
|
|
def test_filter(self):
|
|
self.plugins.update({
|
|
"foo": "bar",
|
|
"bar": "foo",
|
|
"baz": "boo",
|
|
})
|
|
self.assertEqual(
|
|
{"foo": "bar", "baz": "boo"},
|
|
self.reg.filter(lambda p_ep: str(p_ep).startswith("b")))
|
|
|
|
def test_ifaces(self):
|
|
self.plugin_ep.ifaces.return_value = True
|
|
# pylint: disable=protected-access
|
|
self.assertEqual(self.plugins, self.reg.ifaces()._plugins)
|
|
self.plugin_ep.ifaces.return_value = False
|
|
self.assertEqual({}, self.reg.ifaces()._plugins)
|
|
|
|
def test_verify(self):
|
|
self.plugin_ep.verify.return_value = True
|
|
# pylint: disable=protected-access
|
|
self.assertEqual(
|
|
self.plugins, self.reg.verify(mock.MagicMock())._plugins)
|
|
self.plugin_ep.verify.return_value = False
|
|
self.assertEqual({}, self.reg.verify(mock.MagicMock())._plugins)
|
|
|
|
def test_prepare(self):
|
|
self.plugin_ep.prepare.return_value = "baz"
|
|
self.assertEqual(["baz"], self.reg.prepare())
|
|
self.plugin_ep.prepare.assert_called_once_with()
|
|
|
|
def test_available(self):
|
|
self.plugin_ep.available = True
|
|
# pylint: disable=protected-access
|
|
self.assertEqual(self.plugins, self.reg.available()._plugins)
|
|
self.plugin_ep.available = False
|
|
self.assertEqual({}, self.reg.available()._plugins)
|
|
|
|
def test_find_init(self):
|
|
self.assertTrue(self.reg.find_init(mock.Mock()) is None)
|
|
self.plugin_ep.initalized = True
|
|
self.assertTrue(
|
|
self.reg.find_init(self.plugin_ep.init()) is self.plugin_ep)
|
|
|
|
def test_repr(self):
|
|
self.plugin_ep.__repr__ = lambda _: "PluginEntryPoint#mock"
|
|
self.assertEqual("PluginsRegistry(PluginEntryPoint#mock)",
|
|
repr(self.reg))
|
|
|
|
def test_str(self):
|
|
self.plugin_ep.__str__ = lambda _: "Mock"
|
|
self.plugins["foo"] = "Mock"
|
|
self.assertEqual("Mock\n\nMock", str(self.reg))
|
|
self.plugins.clear()
|
|
self.assertEqual("No plugins", str(self.reg))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main() # pragma: no cover
|