diff options
Diffstat (limited to 'tests/test_testing.py')
| -rw-r--r-- | tests/test_testing.py | 197 |
1 files changed, 138 insertions, 59 deletions
diff --git a/tests/test_testing.py b/tests/test_testing.py index 51ffb9822..b5c689794 100644 --- a/tests/test_testing.py +++ b/tests/test_testing.py @@ -2,19 +2,23 @@ import unittest from zope.component import getSiteManager 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 +37,55 @@ class TestDummySecurityPolicy(unittest.TestCase): 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 +103,7 @@ class TestDummyResource(unittest.TestCase): 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 +115,7 @@ class TestDummyResource(unittest.TestCase): def test_keys_items_values_len(self): class Dummy: pass + resource = self._makeOne() resource['abc'] = Dummy() resource['def'] = Dummy() @@ -119,24 +132,27 @@ class TestDummyResource(unittest.TestCase): 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 +162,7 @@ class TestDummyRequest(unittest.TestCase): 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 +191,25 @@ class TestDummyRequest(unittest.TestCase): 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 +230,7 @@ class TestDummyRequest(unittest.TestCase): 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 +242,7 @@ class TestDummyRequest(unittest.TestCase): # 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 +261,7 @@ class TestDummyRequest(unittest.TestCase): # 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 +277,35 @@ class TestDummyRequest(unittest.TestCase): 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 + class TestDummyTemplateRenderer(unittest.TestCase): - def _getTargetClass(self, ): + def _getTargetClass(self,): from pyramid.testing import DummyTemplateRenderer + return DummyTemplateRenderer def _makeOne(self, string_response=''): @@ -298,29 +320,32 @@ class TestDummyTemplateRenderer(unittest.TestCase): 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 +357,7 @@ class Test_setUp(unittest.TestCase): 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 +372,15 @@ class Test_setUp(unittest.TestCase): 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 +392,7 @@ class Test_setUp(unittest.TestCase): 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 +400,32 @@ class Test_setUp(unittest.TestCase): 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 +438,9 @@ class Test_tearDown(unittest.TestCase): 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 +455,17 @@ class Test_tearDown(unittest.TestCase): 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 +480,11 @@ class Test_tearDown(unittest.TestCase): 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 +501,33 @@ class TestDummyRendererFactory(unittest.TestCase): 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 +542,52 @@ class TestMockTemplate(unittest.TestCase): 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(): + 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 +606,7 @@ class TestDummySession(unittest.TestCase): 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 +665,39 @@ class TestDummySession(unittest.TestCase): 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 +707,7 @@ class Test_testConfig(unittest.TestCase): def setUp(self): from pyramid import testing + self._log = [] self._orig_setUp = testing.setUp testing.setUp = self._setUp @@ -651,39 +716,53 @@ class Test_testConfig(unittest.TestCase): 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) |