Michael Merickel
2018-10-18 41f103af2745c336a3bcdc715e70ef3cb5d1e545
tests/test_testing.py
@@ -1,20 +1,26 @@
import unittest
from zope.component import getSiteManager
from zope.interface import Interface
from zope.interface import implementer
from pyramid import testing
class TestDummyRootFactory(unittest.TestCase):
    def _makeOne(self, environ):
        from pyramid.testing import DummyRootFactory
        return DummyRootFactory(environ)
    def test_it(self):
        environ = {'bfg.routes.matchdict':{'a':1}}
        environ = {'bfg.routes.matchdict': {'a': 1}}
        factory = self._makeOne(environ)
        self.assertEqual(factory.a, 1)
class TestDummySecurityPolicy(unittest.TestCase):
    def _getTargetClass(self):
        from pyramid.testing import DummySecurityPolicy
        return DummySecurityPolicy
    def _makeOne(self, userid=None, groupids=(), permissive=True):
@@ -33,47 +39,55 @@
        policy = self._makeOne('user', ('group1',))
        from pyramid.security import Everyone
        from pyramid.security import Authenticated
        self.assertEqual(policy.effective_principals(None),
                         [Everyone, Authenticated, 'user', 'group1'])
        self.assertEqual(
            policy.effective_principals(None),
            [Everyone, Authenticated, 'user', 'group1'],
        )
    def test_effective_principals_nouserid(self):
        policy = self._makeOne()
        from pyramid.security import Everyone
        self.assertEqual(policy.effective_principals(None), [Everyone])
    def test_permits(self):
        policy = self._makeOne()
        self.assertEqual(policy.permits(None, None, None), True)
    def test_principals_allowed_by_permission(self):
        policy = self._makeOne('user', ('group1',))
        from pyramid.security import Everyone
        from pyramid.security import Authenticated
        result = policy.principals_allowed_by_permission(None, None)
        self.assertEqual(result, [Everyone, Authenticated, 'user', 'group1'])
    def test_forget(self):
        policy = self._makeOne()
        self.assertEqual(policy.forget(None), [])
    def test_remember(self):
        policy = self._makeOne()
        self.assertEqual(policy.remember(None, None), [])
class TestDummyResource(unittest.TestCase):
    def _getTargetClass(self):
        from pyramid.testing import DummyResource
        return DummyResource
    def _makeOne(self, name=None, parent=None, **kw):
        klass = self._getTargetClass()
        return klass(name, parent, **kw)
    def test__setitem__and__getitem__and__delitem__and__contains__and_get(self):
    def test__setitem__and__getitem__and__delitem__and__contains__and_get(
        self
    ):
        class Dummy:
            pass
        dummy = Dummy()
        resource = self._makeOne()
        resource['abc'] = dummy
@@ -91,7 +105,7 @@
    def test_extra_params(self):
        resource = self._makeOne(foo=1)
        self.assertEqual(resource.foo, 1)
    def test_clone(self):
        resource = self._makeOne('name', 'parent', foo=1, bar=2)
        clone = resource.clone('name2', 'parent2', bar=1)
@@ -103,6 +117,7 @@
    def test_keys_items_values_len(self):
        class Dummy:
            pass
        resource = self._makeOne()
        resource['abc'] = Dummy()
        resource['def'] = Dummy()
@@ -119,24 +134,27 @@
    def test_bool(self):
        resource = self._makeOne()
        self.assertEqual(resource.__bool__(), True)
    def test_ctor_with__provides__(self):
        resource = self._makeOne(__provides__=IDummy)
        self.assertTrue(IDummy.providedBy(resource))
class TestDummyRequest(unittest.TestCase):
    def _getTargetClass(self):
        from pyramid.testing import DummyRequest
        return DummyRequest
    def _makeOne(self, *arg, **kw):
        return self._getTargetClass()(*arg, **kw)
    def test_params(self):
        request = self._makeOne(params = {'say':'Hello'},
                                environ = {'PATH_INFO':'/foo'},
                                headers = {'X-Foo':'YUP'},
                               )
        request = self._makeOne(
            params={'say': 'Hello'},
            environ={'PATH_INFO': '/foo'},
            headers={'X-Foo': 'YUP'},
        )
        self.assertEqual(request.params['say'], 'Hello')
        self.assertEqual(request.GET['say'], 'Hello')
        self.assertEqual(request.POST['say'], 'Hello')
@@ -146,6 +164,7 @@
    def test_defaults(self):
        from pyramid.threadlocal import get_current_registry
        from pyramid.testing import DummySession
        request = self._makeOne()
        self.assertEqual(request.method, 'GET')
        self.assertEqual(request.application_url, 'http://example.com')
@@ -174,25 +193,25 @@
        self.assertEqual(request.session.__class__, DummySession)
    def test_params_explicit(self):
        request = self._makeOne(params = {'foo':'bar'})
        request = self._makeOne(params={'foo': 'bar'})
        self.assertEqual(request.params['foo'], 'bar')
        self.assertEqual(request.GET['foo'], 'bar')
        self.assertEqual(request.POST['foo'], 'bar')
    def test_environ_explicit(self):
        request = self._makeOne(environ = {'PATH_INFO':'/foo'})
        request = self._makeOne(environ={'PATH_INFO': '/foo'})
        self.assertEqual(request.environ['PATH_INFO'], '/foo')
    def test_headers_explicit(self):
        request = self._makeOne(headers = {'X-Foo':'YUP'})
        request = self._makeOne(headers={'X-Foo': 'YUP'})
        self.assertEqual(request.headers['X-Foo'], 'YUP')
    def test_path_explicit(self):
        request = self._makeOne(path = '/abc')
        request = self._makeOne(path='/abc')
        self.assertEqual(request.path, '/abc')
    def test_cookies_explicit(self):
        request = self._makeOne(cookies = {'type': 'gingersnap'})
        request = self._makeOne(cookies={'type': 'gingersnap'})
        self.assertEqual(request.cookies['type'], 'gingersnap')
    def test_post_explicit(self):
@@ -213,7 +232,7 @@
        self.assertEqual(request.POST.get('foo'), None)
    def test_kwargs(self):
        request = self._makeOne(water = 1)
        request = self._makeOne(water=1)
        self.assertEqual(request.water, 1)
    def test_add_response_callback(self):
@@ -225,6 +244,7 @@
        # see https://github.com/Pylons/pyramid/issues/165
        from pyramid.registry import Registry
        from pyramid.config import Configurator
        request = self._makeOne()
        try:
            registry = Registry('this_test')
@@ -243,6 +263,7 @@
        # see https://github.com/Pylons/pyramid/issues/165
        from pyramid.registry import Registry
        from pyramid.config import Configurator
        request = self._makeOne()
        request.registry = 'abc'
        self.assertEqual(request.registry, 'abc')
@@ -258,32 +279,58 @@
    def test_response_with_responsefactory(self):
        from pyramid.registry import Registry
        from pyramid.interfaces import IResponseFactory
        registry = Registry('this_test')
        class ResponseFactory(object):
            pass
        registry.registerUtility(
            lambda r: ResponseFactory(), IResponseFactory
        )
        registry.registerUtility(lambda r: ResponseFactory(), IResponseFactory)
        request = self._makeOne()
        request.registry = registry
        resp = request.response
        self.assertEqual(resp.__class__, ResponseFactory)
        self.assertTrue(request.response is resp) # reified
        self.assertTrue(request.response is resp)  # reified
    def test_response_without_responsefactory(self):
        from pyramid.registry import Registry
        from pyramid.response import Response
        registry = Registry('this_test')
        request = self._makeOne()
        request.registry = registry
        resp = request.response
        self.assertEqual(resp.__class__, Response)
        self.assertTrue(request.response is resp) # reified
        self.assertTrue(request.response is resp)  # reified
    def test_default_accept(self):
        request = self._makeOne()
        self.assertEqual(
            request.accept.acceptable_offers(['text/html']),
            [('text/html', 1.0)],
        )
        request.accept = 'text/plain'
        self.assertEqual(request.accept.acceptable_offers(['text/html']), [])
        del request.accept
        self.assertEqual(
            request.accept.acceptable_offers(['text/html']),
            [('text/html', 1.0)],
        )
    def test_accept__init__(self):
        request = self._makeOne(accept='text/plain')
        self.assertEqual(
            request.accept.acceptable_offers(['text/html', 'text/plain']),
            [('text/plain', 1.0)],
        )
class TestDummyTemplateRenderer(unittest.TestCase):
    def _getTargetClass(self, ):
    def _getTargetClass(self,):
        from pyramid.testing import DummyTemplateRenderer
        return DummyTemplateRenderer
    def _makeOne(self, string_response=''):
@@ -298,29 +345,32 @@
    def test_getattr(self):
        renderer = self._makeOne()
        renderer({'a':1})
        renderer({'a': 1})
        self.assertEqual(renderer.a, 1)
        self.assertRaises(AttributeError, renderer.__getattr__, 'b')
    def test_assert_(self):
        renderer = self._makeOne()
        renderer({'a':1, 'b':2})
        renderer({'a': 1, 'b': 2})
        self.assertRaises(AssertionError, renderer.assert_, c=1)
        self.assertRaises(AssertionError, renderer.assert_, b=3)
        self.assertTrue(renderer.assert_(a=1, b=2))
    def test_nondefault_string_response(self):
        renderer = self._makeOne('abc')
        result = renderer({'a':1, 'b':2})
        result = renderer({'a': 1, 'b': 2})
        self.assertEqual(result, 'abc')
class Test_setUp(unittest.TestCase):
    def _callFUT(self, **kw):
        from pyramid.testing import setUp
        return setUp(**kw)
    def tearDown(self):
        from pyramid.threadlocal import manager
        manager.clear()
        getSiteManager.reset()
@@ -332,6 +382,7 @@
        from pyramid.threadlocal import manager
        from pyramid.threadlocal import get_current_registry
        from pyramid.registry import Registry
        old = True
        manager.push(old)
        config = self._callFUT()
@@ -346,13 +397,15 @@
    def test_it_with_registry(self):
        from pyramid.registry import Registry
        from pyramid.threadlocal import manager
        registry = Registry()
        self._callFUT(registry=registry)
        current = manager.get()
        self.assertEqual(current['registry'], registry)
    def test_it_with_request(self):
        from pyramid.threadlocal import manager
        request = object()
        self._callFUT(request=request)
        current = manager.get()
@@ -364,6 +417,7 @@
    def test_it_with_hook_zca_false(self):
        from pyramid.registry import Registry
        registry = Registry()
        self._callFUT(registry=registry, hook_zca=False)
        sm = getSiteManager()
@@ -371,26 +425,32 @@
    def test_it_with_settings_passed_explicit_registry(self):
        from pyramid.registry import Registry
        registry = Registry()
        self._callFUT(registry=registry, hook_zca=False, settings=dict(a=1))
        self.assertEqual(registry.settings['a'], 1)
    def test_it_with_settings_passed_implicit_registry(self):
        config = self._callFUT(hook_zca=False, settings=dict(a=1))
        self.assertEqual(config.registry.settings['a'], 1)
class Test_cleanUp(Test_setUp):
    def _callFUT(self, *arg, **kw):
        from pyramid.testing import cleanUp
        return cleanUp(*arg, **kw)
class Test_tearDown(unittest.TestCase):
    def _callFUT(self, **kw):
        from pyramid.testing import tearDown
        return tearDown(**kw)
    def tearDown(self):
        from pyramid.threadlocal import manager
        manager.clear()
        getSiteManager.reset()
@@ -403,8 +463,9 @@
    def test_defaults(self):
        from pyramid.threadlocal import manager
        registry = DummyRegistry()
        old = {'registry':registry}
        old = {'registry': registry}
        hook = lambda *arg: None
        try:
            self._setSMHook(hook)
@@ -419,14 +480,17 @@
    def test_registry_cannot_be_inited(self):
        from pyramid.threadlocal import manager
        registry = DummyRegistry()
        def raiseit(name):
            raise TypeError
        registry.__init__ = raiseit
        old = {'registry':registry}
        old = {'registry': registry}
        try:
            manager.push(old)
            self._callFUT() # doesn't blow up
            self._callFUT()  # doesn't blow up
            current = manager.get()
            self.assertNotEqual(current, old)
            self.assertEqual(registry.inited, 1)
@@ -441,9 +505,11 @@
        finally:
            self._assertSMHook(hook)
class TestDummyRendererFactory(unittest.TestCase):
    def _makeOne(self, name, factory):
        from pyramid.testing import DummyRendererFactory
        return DummyRendererFactory(name, factory)
    def test_add_no_colon(self):
@@ -460,30 +526,33 @@
    def test_call(self):
        f = self._makeOne('name', None)
        f.renderers['spec'] = 'renderer'
        info = DummyRendererInfo({'name':'spec'})
        info = DummyRendererInfo({'name': 'spec'})
        self.assertEqual(f(info), 'renderer')
    def test_call2(self):
        f = self._makeOne('name', None)
        f.renderers['spec'] = 'renderer'
        info = DummyRendererInfo({'name':'spec:spec'})
        info = DummyRendererInfo({'name': 'spec:spec'})
        self.assertEqual(f(info), 'renderer')
    def test_call3(self):
        def factory(spec):
            return 'renderer'
        f = self._makeOne('name', factory)
        info = DummyRendererInfo({'name':'spec'})
        info = DummyRendererInfo({'name': 'spec'})
        self.assertEqual(f(info), 'renderer')
    def test_call_miss(self):
        f = self._makeOne('name', None)
        info = DummyRendererInfo({'name':'spec'})
        info = DummyRendererInfo({'name': 'spec'})
        self.assertRaises(KeyError, f, info)
class TestMockTemplate(unittest.TestCase):
    def _makeOne(self, response):
        from pyramid.testing import MockTemplate
        return MockTemplate(response)
    def test_getattr(self):
@@ -498,39 +567,52 @@
        template = self._makeOne('123')
        self.assertEqual(template(), '123')
class Test_skip_on(unittest.TestCase):
    def setUp(self):
        from pyramid.testing import skip_on
        self.os_name = skip_on.os_name
        skip_on.os_name = 'wrong'
    def tearDown(self):
        from pyramid.testing import skip_on
        skip_on.os_name = self.os_name
    def _callFUT(self, *platforms):
        from pyramid.testing import skip_on
        return skip_on(*platforms)
    def test_wrong_platform(self):
        def foo(): return True
        def foo():  # pragma: no cover
            return True
        decorated = self._callFUT('wrong')(foo)
        self.assertEqual(decorated(), None)
    def test_ok_platform(self):
        def foo(): return True
        def foo():
            return True
        decorated = self._callFUT('ok')(foo)
        self.assertEqual(decorated(), True)
class TestDummySession(unittest.TestCase):
    def _makeOne(self):
        from pyramid.testing import DummySession
        return DummySession()
    @testing.skip_on('pypy') # see https://github.com/Pylons/pyramid/issues/3237
    @testing.skip_on(
        'pypy'
    )  # see https://github.com/Pylons/pyramid/issues/3237
    def test_instance_conforms(self):
        from zope.interface.verify import verifyObject
        from pyramid.interfaces import ISession
        session = self._makeOne()
        verifyObject(ISession, session)
@@ -549,7 +631,7 @@
        session.flash('msg1')
        session.flash('msg2')
        self.assertEqual(session['_f_'], ['msg1', 'msg2'])
    def test_flash_mixed(self):
        session = self._makeOne()
        session.flash('warn1', 'warn')
@@ -608,32 +690,35 @@
        self.assertNotEqual(token, None)
        self.assertTrue(len(token) >= 1)
from zope.interface import Interface
from zope.interface import implementer
class IDummy(Interface):
    pass
@implementer(IDummy)
class DummyEvent:
    pass
class DummyFactory:
    def __init__(self, environ):
        """ """
class DummyRegistry(object):
    inited = 0
    __name__ = 'name'
    def __init__(self, name=''):
        self.inited = self.inited + 1
class DummyRendererInfo(object):
    def __init__(self, kw):
        self.__dict__.update(kw)
class Test_testConfig(unittest.TestCase):
class Test_testConfig(unittest.TestCase):
    def _setUp(self, **kw):
        self._log.append(('setUp', kw))
        return 'fake config'
@@ -643,6 +728,7 @@
    def setUp(self):
        from pyramid import testing
        self._log = []
        self._orig_setUp = testing.setUp
        testing.setUp = self._setUp
@@ -651,39 +737,53 @@
    def tearDown(self):
        from pyramid import testing
        testing.setUp = self._orig_setUp
        testing.tearDown = self._orig_tearDown
    def _callFUT(self, inner, **kw):
        from pyramid.testing import testConfig
        with testConfig(**kw) as config:
            inner(config)
    def test_ok_calls(self):
        self.assertEqual(self._log, [])
        def inner(config):
            self.assertEqual(self._log,
                    [('setUp',
                        {'autocommit': True,
            self.assertEqual(
                self._log,
                [
                    (
                        'setUp',
                        {
                            'autocommit': True,
                            'hook_zca': True,
                            'registry': None,
                            'request': None,
                            'settings': None})])
                            'settings': None,
                        },
                    )
                ],
            )
            self._log.pop()
        self._callFUT(inner)
        self.assertEqual(self._log,
                [('tearDown', {'unhook_zca': True})])
        self.assertEqual(self._log, [('tearDown', {'unhook_zca': True})])
    def test_teardown_called_on_exception(self):
        class TestException(Exception):
            pass
        def inner(config):
            self._log = []
            raise TestException('oops')
        self.assertRaises(TestException, self._callFUT, inner)
        self.assertEqual(self._log[0][0], 'tearDown')
    def test_ok_get_config(self):
        def inner(config):
            self.assertEqual(config, 'fake config')
        self._callFUT(inner)