| | |
| | | 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): |
| | |
| | | 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 |
| | |
| | | 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) |
| | |
| | | def test_keys_items_values_len(self): |
| | | class Dummy: |
| | | pass |
| | | |
| | | resource = self._makeOne() |
| | | resource['abc'] = Dummy() |
| | | resource['def'] = Dummy() |
| | |
| | | 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') |
| | |
| | | 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') |
| | |
| | | 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): |
| | |
| | | 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): |
| | |
| | | # 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') |
| | |
| | | # 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') |
| | |
| | | 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=''): |
| | |
| | | |
| | | 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() |
| | | |
| | |
| | | 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() |
| | |
| | | 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() |
| | |
| | | |
| | | def test_it_with_hook_zca_false(self): |
| | | from pyramid.registry import Registry |
| | | |
| | | registry = Registry() |
| | | self._callFUT(registry=registry, hook_zca=False) |
| | | sm = getSiteManager() |
| | |
| | | |
| | | 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() |
| | | |
| | |
| | | |
| | | 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) |
| | |
| | | |
| | | 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) |
| | |
| | | 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): |
| | |
| | | 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): |
| | |
| | | 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) |
| | | |
| | |
| | | session.flash('msg1') |
| | | session.flash('msg2') |
| | | self.assertEqual(session['_f_'], ['msg1', 'msg2']) |
| | | |
| | | |
| | | def test_flash_mixed(self): |
| | | session = self._makeOne() |
| | | session.flash('warn1', 'warn') |
| | |
| | | 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' |
| | |
| | | |
| | | def setUp(self): |
| | | from pyramid import testing |
| | | |
| | | self._log = [] |
| | | self._orig_setUp = testing.setUp |
| | | testing.setUp = self._setUp |
| | |
| | | |
| | | 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) |