Merge pull request #3388 from mmerickel/black

Michael Merickel

2018-10-15 bda1306749c62ef4f11cfe567ed7d56c8ad94240

 tests/test_config/test_testing.py

@@ -1,22 +1,28 @@
import unittest
from zope.interface import implementer

from pyramid.compat import text_
from pyramid.security import AuthenticationAPIMixin, AuthorizationAPIMixin
from . import IDummy


class TestingConfiguratorMixinTests(unittest.TestCase):
    def _makeOne(self, *arg, **kw):
        from pyramid.config import Configurator

        config = Configurator(*arg, **kw)
        return config

    def test_testing_securitypolicy(self):
        from pyramid.testing import DummySecurityPolicy

        config = self._makeOne(autocommit=True)
        config.testing_securitypolicy('user', ('group1', 'group2'),
                                      permissive=False)
        config.testing_securitypolicy(
            'user', ('group1', 'group2'), permissive=False
        )
        from pyramid.interfaces import IAuthenticationPolicy
        from pyramid.interfaces import IAuthorizationPolicy

        ut = config.registry.getUtility(IAuthenticationPolicy)
        self.assertTrue(isinstance(ut, DummySecurityPolicy))
        ut = config.registry.getUtility(IAuthorizationPolicy)
@@ -26,10 +32,14 @@

    def test_testing_securitypolicy_remember_result(self):
        from pyramid.security import remember

        config = self._makeOne(autocommit=True)
        pol = config.testing_securitypolicy(
            'user', ('group1', 'group2'),
            permissive=False, remember_result=True)
            'user',
            ('group1', 'group2'),
            permissive=False,
            remember_result=True,
        )
        request = DummyRequest()
        request.registry = config.registry
        val = remember(request, 'fred')
@@ -38,10 +48,11 @@

    def test_testing_securitypolicy_forget_result(self):
        from pyramid.security import forget

        config = self._makeOne(autocommit=True)
        pol = config.testing_securitypolicy(
            'user', ('group1', 'group2'),
            permissive=False, forget_result=True)
            'user', ('group1', 'group2'), permissive=False, forget_result=True
        )
        request = DummyRequest()
        request.registry = config.registry
        val = forget(request)
@@ -51,27 +62,30 @@
    def test_testing_resources(self):
        from pyramid.traversal import find_resource
        from pyramid.interfaces import ITraverser

        ob1 = object()
        ob2 = object()
        resources = {'/ob1':ob1, '/ob2':ob2}
        resources = {'/ob1': ob1, '/ob2': ob2}
        config = self._makeOne(autocommit=True)
        config.testing_resources(resources)
        adapter = config.registry.getAdapter(None, ITraverser)
        result = adapter(DummyRequest({'PATH_INFO':'/ob1'}))
        result = adapter(DummyRequest({'PATH_INFO': '/ob1'}))
        self.assertEqual(result['context'], ob1)
        self.assertEqual(result['view_name'], '')
        self.assertEqual(result['subpath'], ())
        self.assertEqual(result['traversed'], (text_('ob1'),))
        self.assertEqual(result['virtual_root'], ob1)
        self.assertEqual(result['virtual_root_path'], ())
        result = adapter(DummyRequest({'PATH_INFO':'/ob2'}))
        result = adapter(DummyRequest({'PATH_INFO': '/ob2'}))
        self.assertEqual(result['context'], ob2)
        self.assertEqual(result['view_name'], '')
        self.assertEqual(result['subpath'], ())
        self.assertEqual(result['traversed'], (text_('ob2'),))
        self.assertEqual(result['virtual_root'], ob2)
        self.assertEqual(result['virtual_root_path'], ())
        self.assertRaises(KeyError, adapter, DummyRequest({'PATH_INFO':'/ob3'}))
        self.assertRaises(
            KeyError, adapter, DummyRequest({'PATH_INFO': '/ob3'})
        )
        try:
            config.begin()
            self.assertEqual(find_resource(None, '/ob1'), ob1)
@@ -90,8 +104,7 @@

    def test_testing_add_subscriber_dottedname(self):
        config = self._makeOne(autocommit=True)
        L = config.testing_add_subscriber(
            'tests.test_config.test_init.IDummy')
        L = config.testing_add_subscriber('tests.test_config.test_init.IDummy')
        event = DummyEvent()
        config.registry.notify(event)
        self.assertEqual(len(L), 1)
@@ -101,6 +114,7 @@

    def test_testing_add_subscriber_multiple(self):
        from zope.interface import Interface

        config = self._makeOne(autocommit=True)
        L = config.testing_add_subscriber((Interface, IDummy))
        event = DummyEvent()
@@ -125,13 +139,16 @@
        config = self._makeOne(autocommit=True)
        renderer = config.testing_add_renderer('templates/foo.pt')
        from pyramid.testing import DummyTemplateRenderer

        self.assertTrue(isinstance(renderer, DummyTemplateRenderer))
        from pyramid.renderers import render_to_response

        # must provide request to pass in registry (this is a functest)
        request = DummyRequest()
        request.registry = config.registry
        render_to_response(
            'templates/foo.pt', {'foo':1, 'bar':2}, request=request)
            'templates/foo.pt', {'foo': 1, 'bar': 2}, request=request
        )
        renderer.assert_(foo=1)
        renderer.assert_(bar=2)
        renderer.assert_(request=request)
@@ -141,65 +158,78 @@
        renderer1 = config.testing_add_renderer('templates/foo.pt')
        renderer2 = config.testing_add_renderer('templates/bar.pt')
        from pyramid.testing import DummyTemplateRenderer

        self.assertTrue(isinstance(renderer1, DummyTemplateRenderer))
        self.assertTrue(isinstance(renderer2, DummyTemplateRenderer))
        from pyramid.renderers import render_to_response

        # must provide request to pass in registry (this is a functest)
        request = DummyRequest()
        request.registry = config.registry
        render_to_response(
            'templates/foo.pt', {'foo':1, 'bar':2}, request=request)
            'templates/foo.pt', {'foo': 1, 'bar': 2}, request=request
        )
        renderer1.assert_(foo=1)
        renderer1.assert_(bar=2)
        renderer1.assert_(request=request)
        render_to_response(
            'templates/bar.pt', {'foo':1, 'bar':2}, request=request)
            'templates/bar.pt', {'foo': 1, 'bar': 2}, request=request
        )
        renderer2.assert_(foo=1)
        renderer2.assert_(bar=2)
        renderer2.assert_(request=request)

    def test_testing_add_renderer_explicitrenderer(self):
        config = self._makeOne(autocommit=True)
        class E(Exception): pass

        class E(Exception):
            pass

        def renderer(kw, system):
            self.assertEqual(kw, {'foo':1, 'bar':2})
            self.assertEqual(kw, {'foo': 1, 'bar': 2})
            raise E

        renderer = config.testing_add_renderer('templates/foo.pt', renderer)
        from pyramid.renderers import render_to_response

        # must provide request to pass in registry (this is a functest)
        request = DummyRequest()
        request.registry = config.registry
        try:
            render_to_response(
                'templates/foo.pt', {'foo':1, 'bar':2}, request=request)
                'templates/foo.pt', {'foo': 1, 'bar': 2}, request=request
            )
        except E:
            pass
        else: # pragma: no cover
        else:  # pragma: no cover
            raise AssertionError

    def test_testing_add_template(self):
        config = self._makeOne(autocommit=True)
        renderer = config.testing_add_template('templates/foo.pt')
        from pyramid.testing import DummyTemplateRenderer

        self.assertTrue(isinstance(renderer, DummyTemplateRenderer))
        from pyramid.renderers import render_to_response

        # must provide request to pass in registry (this is a functest)
        request = DummyRequest()
        request.registry = config.registry
        render_to_response('templates/foo.pt', dict(foo=1, bar=2),
                           request=request)
        render_to_response(
            'templates/foo.pt', dict(foo=1, bar=2), request=request
        )
        renderer.assert_(foo=1)
        renderer.assert_(bar=2)
        renderer.assert_(request=request)

from zope.interface import implementer

@implementer(IDummy)
class DummyEvent:
    pass


class DummyRequest(AuthenticationAPIMixin, AuthorizationAPIMixin):
    def __init__(self, environ=None):
        if environ is None:
            environ = {}
        self.environ = environ