| commit | author | age | ||
| deb0dc | 1 | import unittest |
| 6c3f4f | 2 | from zope.component import getSiteManager |
| 54533f | 3 | from pyramid import testing |
| e8b295 | 4 | |
| 0c29cf | 5 | |
| 927acd | 6 | class TestDummyRootFactory(unittest.TestCase): |
| CM | 7 | def _makeOne(self, environ): |
| b60bdb | 8 | from pyramid.testing import DummyRootFactory |
| 0c29cf | 9 | |
| 927acd | 10 | return DummyRootFactory(environ) |
| CM | 11 | |
| 12 | def test_it(self): | |
| 0c29cf | 13 | environ = {'bfg.routes.matchdict': {'a': 1}} |
| 927acd | 14 | factory = self._makeOne(environ) |
| CM | 15 | self.assertEqual(factory.a, 1) |
| 0c29cf | 16 | |
| 927acd | 17 | |
| a1a9fb | 18 | class TestDummySecurityPolicy(unittest.TestCase): |
| deb0dc | 19 | def _getTargetClass(self): |
| b60bdb | 20 | from pyramid.testing import DummySecurityPolicy |
| 0c29cf | 21 | |
| a1a9fb | 22 | return DummySecurityPolicy |
| deb0dc | 23 | |
| a1a9fb | 24 | def _makeOne(self, userid=None, groupids=(), permissive=True): |
| deb0dc | 25 | klass = self._getTargetClass() |
| a1a9fb | 26 | return klass(userid, groupids, permissive) |
| deb0dc | 27 | |
| CM | 28 | def test_authenticated_userid(self): |
| 29 | policy = self._makeOne('user') | |
| 7ec9e7 | 30 | self.assertEqual(policy.authenticated_userid(None), 'user') |
| 2526d8 | 31 | |
| CM | 32 | def test_unauthenticated_userid(self): |
| 33 | policy = self._makeOne('user') | |
| 34 | self.assertEqual(policy.unauthenticated_userid(None), 'user') | |
| 35 | ||
| deb0dc | 36 | def test_effective_principals_userid(self): |
| CM | 37 | policy = self._makeOne('user', ('group1',)) |
| b60bdb | 38 | from pyramid.security import Everyone |
| CM | 39 | from pyramid.security import Authenticated |
| 0c29cf | 40 | |
| MM | 41 | self.assertEqual( |
| 42 | policy.effective_principals(None), | |
| 43 | [Everyone, Authenticated, 'user', 'group1'], | |
| 44 | ) | |
| deb0dc | 45 | |
| CM | 46 | def test_effective_principals_nouserid(self): |
| 47 | policy = self._makeOne() | |
| b60bdb | 48 | from pyramid.security import Everyone |
| 0c29cf | 49 | |
| 7ec9e7 | 50 | self.assertEqual(policy.effective_principals(None), [Everyone]) |
| deb0dc | 51 | |
| CM | 52 | def test_permits(self): |
| 53 | policy = self._makeOne() | |
| 54 | self.assertEqual(policy.permits(None, None, None), True) | |
| 0c29cf | 55 | |
| deb0dc | 56 | def test_principals_allowed_by_permission(self): |
| CM | 57 | policy = self._makeOne('user', ('group1',)) |
| b60bdb | 58 | from pyramid.security import Everyone |
| CM | 59 | from pyramid.security import Authenticated |
| 0c29cf | 60 | |
| a1a9fb | 61 | result = policy.principals_allowed_by_permission(None, None) |
| CM | 62 | self.assertEqual(result, [Everyone, Authenticated, 'user', 'group1']) |
| deb0dc | 63 | |
| a1a9fb | 64 | def test_forget(self): |
| deb0dc | 65 | policy = self._makeOne() |
| 7ec9e7 | 66 | self.assertEqual(policy.forget(None), []) |
| 0c29cf | 67 | |
| a1a9fb | 68 | def test_remember(self): |
| deb0dc | 69 | policy = self._makeOne() |
| 7ec9e7 | 70 | self.assertEqual(policy.remember(None, None), []) |
| 0c29cf | 71 | |
| a1a9fb | 72 | |
| 3e2f12 | 73 | class TestDummyResource(unittest.TestCase): |
| deb0dc | 74 | def _getTargetClass(self): |
| 3e2f12 | 75 | from pyramid.testing import DummyResource |
| 0c29cf | 76 | |
| 3e2f12 | 77 | return DummyResource |
| deb0dc | 78 | |
| 6a7914 | 79 | def _makeOne(self, name=None, parent=None, **kw): |
| deb0dc | 80 | klass = self._getTargetClass() |
| 6a7914 | 81 | return klass(name, parent, **kw) |
| deb0dc | 82 | |
| 0c29cf | 83 | def test__setitem__and__getitem__and__delitem__and__contains__and_get( |
| MM | 84 | self |
| 85 | ): | |
| deb0dc | 86 | class Dummy: |
| CM | 87 | pass |
| 0c29cf | 88 | |
| deb0dc | 89 | dummy = Dummy() |
| 3e2f12 | 90 | resource = self._makeOne() |
| CM | 91 | resource['abc'] = dummy |
| deb0dc | 92 | self.assertEqual(dummy.__name__, 'abc') |
| 3e2f12 | 93 | self.assertEqual(dummy.__parent__, resource) |
| CM | 94 | self.assertEqual(resource['abc'], dummy) |
| 95 | self.assertEqual(resource.get('abc'), dummy) | |
| 96 | self.assertRaises(KeyError, resource.__getitem__, 'none') | |
| a1d395 | 97 | self.assertTrue('abc' in resource) |
| 3e2f12 | 98 | del resource['abc'] |
| a1d395 | 99 | self.assertFalse('abc' in resource) |
| 3e2f12 | 100 | self.assertEqual(resource.get('abc', 'foo'), 'foo') |
| CM | 101 | self.assertEqual(resource.get('abc'), None) |
| deb0dc | 102 | |
| 6a7914 | 103 | def test_extra_params(self): |
| 3e2f12 | 104 | resource = self._makeOne(foo=1) |
| CM | 105 | self.assertEqual(resource.foo, 1) |
| 0c29cf | 106 | |
| 6a7914 | 107 | def test_clone(self): |
| 3e2f12 | 108 | resource = self._makeOne('name', 'parent', foo=1, bar=2) |
| CM | 109 | clone = resource.clone('name2', 'parent2', bar=1) |
| 6a7914 | 110 | self.assertEqual(clone.bar, 1) |
| CM | 111 | self.assertEqual(clone.__name__, 'name2') |
| 112 | self.assertEqual(clone.__parent__, 'parent2') | |
| 113 | self.assertEqual(clone.foo, 1) | |
| 114 | ||
| b0a241 | 115 | def test_keys_items_values_len(self): |
| e8ebc2 | 116 | class Dummy: |
| CM | 117 | pass |
| 0c29cf | 118 | |
| 3e2f12 | 119 | resource = self._makeOne() |
| CM | 120 | resource['abc'] = Dummy() |
| 121 | resource['def'] = Dummy() | |
| 475532 | 122 | L = list |
| CM | 123 | self.assertEqual(L(resource.values()), L(resource.subs.values())) |
| 124 | self.assertEqual(L(resource.items()), L(resource.subs.items())) | |
| 125 | self.assertEqual(L(resource.keys()), L(resource.subs.keys())) | |
| 3e2f12 | 126 | self.assertEqual(len(resource), 2) |
| b0a241 | 127 | |
| CM | 128 | def test_nonzero(self): |
| 3e2f12 | 129 | resource = self._makeOne() |
| CM | 130 | self.assertEqual(resource.__nonzero__(), True) |
| e8ebc2 | 131 | |
| 050b71 | 132 | def test_bool(self): |
| CM | 133 | resource = self._makeOne() |
| 134 | self.assertEqual(resource.__bool__(), True) | |
| 0c29cf | 135 | |
| ab4e7b | 136 | def test_ctor_with__provides__(self): |
| 3e2f12 | 137 | resource = self._makeOne(__provides__=IDummy) |
| a1d395 | 138 | self.assertTrue(IDummy.providedBy(resource)) |
| ab4e7b | 139 | |
| 0c29cf | 140 | |
| a9a8a2 | 141 | class TestDummyRequest(unittest.TestCase): |
| CM | 142 | def _getTargetClass(self): |
| b60bdb | 143 | from pyramid.testing import DummyRequest |
| 0c29cf | 144 | |
| a9a8a2 | 145 | return DummyRequest |
| CM | 146 | |
| 147 | def _makeOne(self, *arg, **kw): | |
| 148 | return self._getTargetClass()(*arg, **kw) | |
| 149 | ||
| 3ede8b | 150 | def test_params(self): |
| 0c29cf | 151 | request = self._makeOne( |
| MM | 152 | params={'say': 'Hello'}, |
| 153 | environ={'PATH_INFO': '/foo'}, | |
| 154 | headers={'X-Foo': 'YUP'}, | |
| 155 | ) | |
| a9a8a2 | 156 | self.assertEqual(request.params['say'], 'Hello') |
| CM | 157 | self.assertEqual(request.GET['say'], 'Hello') |
| 158 | self.assertEqual(request.POST['say'], 'Hello') | |
| 159 | self.assertEqual(request.headers['X-Foo'], 'YUP') | |
| 160 | self.assertEqual(request.environ['PATH_INFO'], '/foo') | |
| 3ede8b | 161 | |
| TS | 162 | def test_defaults(self): |
| b60bdb | 163 | from pyramid.threadlocal import get_current_registry |
| 51b2e8 | 164 | from pyramid.testing import DummySession |
| 0c29cf | 165 | |
| 3ede8b | 166 | request = self._makeOne() |
| TS | 167 | self.assertEqual(request.method, 'GET') |
| 168 | self.assertEqual(request.application_url, 'http://example.com') | |
| 169 | self.assertEqual(request.host_url, 'http://example.com') | |
| 170 | self.assertEqual(request.path_url, 'http://example.com') | |
| 171 | self.assertEqual(request.url, 'http://example.com') | |
| 172 | self.assertEqual(request.host, 'example.com:80') | |
| 173 | self.assertEqual(request.content_length, 0) | |
| 174 | self.assertEqual(request.environ.get('PATH_INFO'), None) | |
| 175 | self.assertEqual(request.headers.get('X-Foo'), None) | |
| 176 | self.assertEqual(request.params.get('foo'), None) | |
| 177 | self.assertEqual(request.GET.get('foo'), None) | |
| 178 | self.assertEqual(request.POST.get('foo'), None) | |
| 179 | self.assertEqual(request.cookies.get('type'), None) | |
| 180 | self.assertEqual(request.path, '/') | |
| 181 | self.assertEqual(request.path_info, '/') | |
| 182 | self.assertEqual(request.script_name, '') | |
| 183 | self.assertEqual(request.path_qs, '') | |
| 184 | self.assertEqual(request.view_name, '') | |
| 1cd598 | 185 | self.assertEqual(request.subpath, ()) |
| 3ede8b | 186 | self.assertEqual(request.context, None) |
| 1cd598 | 187 | self.assertEqual(request.root, None) |
| CM | 188 | self.assertEqual(request.virtual_root, None) |
| 189 | self.assertEqual(request.virtual_root_path, ()) | |
| 44b16b | 190 | self.assertEqual(request.registry, get_current_registry()) |
| 51b2e8 | 191 | self.assertEqual(request.session.__class__, DummySession) |
| 3ede8b | 192 | |
| 6801b5 | 193 | def test_params_explicit(self): |
| 0c29cf | 194 | request = self._makeOne(params={'foo': 'bar'}) |
| 6801b5 | 195 | self.assertEqual(request.params['foo'], 'bar') |
| TS | 196 | self.assertEqual(request.GET['foo'], 'bar') |
| 197 | self.assertEqual(request.POST['foo'], 'bar') | |
| 198 | ||
| 3ede8b | 199 | def test_environ_explicit(self): |
| 0c29cf | 200 | request = self._makeOne(environ={'PATH_INFO': '/foo'}) |
| 3ede8b | 201 | self.assertEqual(request.environ['PATH_INFO'], '/foo') |
| TS | 202 | |
| 203 | def test_headers_explicit(self): | |
| 0c29cf | 204 | request = self._makeOne(headers={'X-Foo': 'YUP'}) |
| 3ede8b | 205 | self.assertEqual(request.headers['X-Foo'], 'YUP') |
| TS | 206 | |
| 207 | def test_path_explicit(self): | |
| 0c29cf | 208 | request = self._makeOne(path='/abc') |
| 3ede8b | 209 | self.assertEqual(request.path, '/abc') |
| TS | 210 | |
| 211 | def test_cookies_explicit(self): | |
| 0c29cf | 212 | request = self._makeOne(cookies={'type': 'gingersnap'}) |
| 3ede8b | 213 | self.assertEqual(request.cookies['type'], 'gingersnap') |
| TS | 214 | |
| 6801b5 | 215 | def test_post_explicit(self): |
| 3ede8b | 216 | POST = {'foo': 'bar', 'baz': 'qux'} |
| TS | 217 | request = self._makeOne(post=POST) |
| 218 | self.assertEqual(request.method, 'POST') | |
| 219 | self.assertEqual(request.POST, POST) | |
| 6801b5 | 220 | # N.B.: Unlike a normal request, passing 'post' should *not* put |
| TS | 221 | # explict POST data into params: doing so masks a possible |
| 222 | # XSS bug in the app. Tests for apps which don't care about | |
| 223 | # the distinction should just use 'params'. | |
| 3ede8b | 224 | self.assertEqual(request.params, {}) |
| TS | 225 | |
| 6801b5 | 226 | def test_post_empty_shadows_params(self): |
| TS | 227 | request = self._makeOne(params={'foo': 'bar'}, post={}) |
| 228 | self.assertEqual(request.method, 'POST') | |
| 229 | self.assertEqual(request.params.get('foo'), 'bar') | |
| 230 | self.assertEqual(request.POST.get('foo'), None) | |
| 231 | ||
| 232 | def test_kwargs(self): | |
| 0c29cf | 233 | request = self._makeOne(water=1) |
| 6801b5 | 234 | self.assertEqual(request.water, 1) |
| TS | 235 | |
| 844e98 | 236 | def test_add_response_callback(self): |
| CM | 237 | request = self._makeOne() |
| 238 | request.add_response_callback(1) | |
| 39a03e | 239 | self.assertEqual(list(request.response_callbacks), [1]) |
| 8af47b | 240 | |
| CM | 241 | def test_registry_is_config_registry_when_setup_is_called_after_ctor(self): |
| 242 | # see https://github.com/Pylons/pyramid/issues/165 | |
| 243 | from pyramid.registry import Registry | |
| 244 | from pyramid.config import Configurator | |
| 0c29cf | 245 | |
| 8af47b | 246 | request = self._makeOne() |
| CM | 247 | try: |
| 248 | registry = Registry('this_test') | |
| 249 | config = Configurator(registry=registry) | |
| 250 | config.begin() | |
| a1d395 | 251 | self.assertTrue(request.registry is registry) |
| 8af47b | 252 | finally: |
| CM | 253 | config.end() |
| 844e98 | 254 | |
| a7b1a9 | 255 | def test_set_registry(self): |
| CM | 256 | request = self._makeOne() |
| 257 | request.registry = 'abc' | |
| 258 | self.assertEqual(request.registry, 'abc') | |
| 259 | ||
| 260 | def test_del_registry(self): | |
| 261 | # see https://github.com/Pylons/pyramid/issues/165 | |
| 262 | from pyramid.registry import Registry | |
| 263 | from pyramid.config import Configurator | |
| 0c29cf | 264 | |
| a7b1a9 | 265 | request = self._makeOne() |
| CM | 266 | request.registry = 'abc' |
| 267 | self.assertEqual(request.registry, 'abc') | |
| 268 | del request.registry | |
| 269 | try: | |
| 270 | registry = Registry('this_test') | |
| 271 | config = Configurator(registry=registry) | |
| 272 | config.begin() | |
| a1d395 | 273 | self.assertTrue(request.registry is registry) |
| a7b1a9 | 274 | finally: |
| CM | 275 | config.end() |
| 276 | ||
| 277 | def test_response_with_responsefactory(self): | |
| 278 | from pyramid.registry import Registry | |
| 279 | from pyramid.interfaces import IResponseFactory | |
| 0c29cf | 280 | |
| a7b1a9 | 281 | registry = Registry('this_test') |
| 0c29cf | 282 | |
| a7b1a9 | 283 | class ResponseFactory(object): |
| CM | 284 | pass |
| 0c29cf | 285 | |
| MM | 286 | registry.registerUtility(lambda r: ResponseFactory(), IResponseFactory) |
| a7b1a9 | 287 | request = self._makeOne() |
| CM | 288 | request.registry = registry |
| 289 | resp = request.response | |
| 290 | self.assertEqual(resp.__class__, ResponseFactory) | |
| 0c29cf | 291 | self.assertTrue(request.response is resp) # reified |
| a7b1a9 | 292 | |
| CM | 293 | def test_response_without_responsefactory(self): |
| 294 | from pyramid.registry import Registry | |
| 295 | from pyramid.response import Response | |
| 0c29cf | 296 | |
| a7b1a9 | 297 | registry = Registry('this_test') |
| CM | 298 | request = self._makeOne() |
| 299 | request.registry = registry | |
| 300 | resp = request.response | |
| 301 | self.assertEqual(resp.__class__, Response) | |
| 0c29cf | 302 | self.assertTrue(request.response is resp) # reified |
| MM | 303 | |
| a7b1a9 | 304 | |
| 7d32df | 305 | class TestDummyTemplateRenderer(unittest.TestCase): |
| 0c29cf | 306 | def _getTargetClass(self,): |
| b60bdb | 307 | from pyramid.testing import DummyTemplateRenderer |
| 0c29cf | 308 | |
| 7d32df | 309 | return DummyTemplateRenderer |
| CM | 310 | |
| e02ba1 | 311 | def _makeOne(self, string_response=''): |
| CM | 312 | return self._getTargetClass()(string_response=string_response) |
| 7d32df | 313 | |
| CM | 314 | def test_implementation(self): |
| 315 | renderer = self._makeOne() | |
| 6eca54 | 316 | impl = renderer.implementation() |
| CM | 317 | impl(a=1, b=2) |
| 250c02 | 318 | self.assertEqual(renderer._implementation._received['a'], 1) |
| CM | 319 | self.assertEqual(renderer._implementation._received['b'], 2) |
| 7d32df | 320 | |
| CM | 321 | def test_getattr(self): |
| 322 | renderer = self._makeOne() | |
| 0c29cf | 323 | renderer({'a': 1}) |
| 7d32df | 324 | self.assertEqual(renderer.a, 1) |
| CM | 325 | self.assertRaises(AttributeError, renderer.__getattr__, 'b') |
| 326 | ||
| 327 | def test_assert_(self): | |
| 328 | renderer = self._makeOne() | |
| 0c29cf | 329 | renderer({'a': 1, 'b': 2}) |
| 7d32df | 330 | self.assertRaises(AssertionError, renderer.assert_, c=1) |
| CM | 331 | self.assertRaises(AssertionError, renderer.assert_, b=3) |
| a1d395 | 332 | self.assertTrue(renderer.assert_(a=1, b=2)) |
| 0c29cf | 333 | |
| e02ba1 | 334 | def test_nondefault_string_response(self): |
| CM | 335 | renderer = self._makeOne('abc') |
| 0c29cf | 336 | result = renderer({'a': 1, 'b': 2}) |
| e02ba1 | 337 | self.assertEqual(result, 'abc') |
| 0c29cf | 338 | |
| d322ac | 339 | |
| d0b398 | 340 | class Test_setUp(unittest.TestCase): |
| CM | 341 | def _callFUT(self, **kw): |
| b60bdb | 342 | from pyramid.testing import setUp |
| 0c29cf | 343 | |
| d0b398 | 344 | return setUp(**kw) |
| d322ac | 345 | |
| d97398 | 346 | def tearDown(self): |
| CM | 347 | from pyramid.threadlocal import manager |
| 0c29cf | 348 | |
| d97398 | 349 | manager.clear() |
| 6c3f4f | 350 | getSiteManager.reset() |
| d97398 | 351 | |
| CM | 352 | def _assertSMHook(self, hook): |
| 6c3f4f | 353 | result = getSiteManager.sethook(None) |
| MM | 354 | self.assertEqual(result, hook) |
| d97398 | 355 | |
| d0b398 | 356 | def test_it_defaults(self): |
| b60bdb | 357 | from pyramid.threadlocal import manager |
| CM | 358 | from pyramid.threadlocal import get_current_registry |
| 359 | from pyramid.registry import Registry | |
| 0c29cf | 360 | |
| d0b398 | 361 | old = True |
| CM | 362 | manager.push(old) |
| d97398 | 363 | config = self._callFUT() |
| CM | 364 | current = manager.get() |
| 365 | self.assertFalse(current is old) | |
| 366 | self.assertEqual(config.registry, current['registry']) | |
| 367 | self.assertEqual(current['registry'].__class__, Registry) | |
| 368 | self.assertEqual(current['request'], None) | |
| dd3cc8 | 369 | self.assertEqual(config.package.__name__, 'tests') |
| d97398 | 370 | self._assertSMHook(get_current_registry) |
| d322ac | 371 | |
| d0b398 | 372 | def test_it_with_registry(self): |
| c0d4a1 | 373 | from pyramid.registry import Registry |
| b60bdb | 374 | from pyramid.threadlocal import manager |
| 0c29cf | 375 | |
| c0d4a1 | 376 | registry = Registry() |
| d97398 | 377 | self._callFUT(registry=registry) |
| CM | 378 | current = manager.get() |
| 379 | self.assertEqual(current['registry'], registry) | |
| 0c29cf | 380 | |
| d0b398 | 381 | def test_it_with_request(self): |
| b60bdb | 382 | from pyramid.threadlocal import manager |
| 0c29cf | 383 | |
| d0b398 | 384 | request = object() |
| d97398 | 385 | self._callFUT(request=request) |
| CM | 386 | current = manager.get() |
| 387 | self.assertEqual(current['request'], request) | |
| d0b398 | 388 | |
| d24055 | 389 | def test_it_with_package(self): |
| MM | 390 | config = self._callFUT(package='pyramid') |
| 391 | self.assertEqual(config.package.__name__, 'pyramid') | |
| 392 | ||
| d0b398 | 393 | def test_it_with_hook_zca_false(self): |
| c0d4a1 | 394 | from pyramid.registry import Registry |
| 0c29cf | 395 | |
| c0d4a1 | 396 | registry = Registry() |
| d97398 | 397 | self._callFUT(registry=registry, hook_zca=False) |
| 6c3f4f | 398 | sm = getSiteManager() |
| MM | 399 | self.assertFalse(sm is registry) |
| d0b398 | 400 | |
| 2a13b0 | 401 | def test_it_with_settings_passed_explicit_registry(self): |
| CM | 402 | from pyramid.registry import Registry |
| 0c29cf | 403 | |
| 2a13b0 | 404 | registry = Registry() |
| d97398 | 405 | self._callFUT(registry=registry, hook_zca=False, settings=dict(a=1)) |
| CM | 406 | self.assertEqual(registry.settings['a'], 1) |
| 0c29cf | 407 | |
| 2a13b0 | 408 | def test_it_with_settings_passed_implicit_registry(self): |
| d97398 | 409 | config = self._callFUT(hook_zca=False, settings=dict(a=1)) |
| CM | 410 | self.assertEqual(config.registry.settings['a'], 1) |
| 2a13b0 | 411 | |
| 0c29cf | 412 | |
| d0b398 | 413 | class Test_cleanUp(Test_setUp): |
| CM | 414 | def _callFUT(self, *arg, **kw): |
| b60bdb | 415 | from pyramid.testing import cleanUp |
| 0c29cf | 416 | |
| d0b398 | 417 | return cleanUp(*arg, **kw) |
| 0c29cf | 418 | |
| MM | 419 | |
| d0b398 | 420 | class Test_tearDown(unittest.TestCase): |
| CM | 421 | def _callFUT(self, **kw): |
| b60bdb | 422 | from pyramid.testing import tearDown |
| 0c29cf | 423 | |
| d0b398 | 424 | return tearDown(**kw) |
| d322ac | 425 | |
| d97398 | 426 | def tearDown(self): |
| CM | 427 | from pyramid.threadlocal import manager |
| 0c29cf | 428 | |
| d97398 | 429 | manager.clear() |
| 6c3f4f | 430 | getSiteManager.reset() |
| d97398 | 431 | |
| CM | 432 | def _assertSMHook(self, hook): |
| 6c3f4f | 433 | result = getSiteManager.sethook(None) |
| MM | 434 | self.assertEqual(result, hook) |
| d97398 | 435 | |
| CM | 436 | def _setSMHook(self, hook): |
| 6c3f4f | 437 | getSiteManager.sethook(hook) |
| d97398 | 438 | |
| d0b398 | 439 | def test_defaults(self): |
| b60bdb | 440 | from pyramid.threadlocal import manager |
| 0c29cf | 441 | |
| d0b398 | 442 | registry = DummyRegistry() |
| 0c29cf | 443 | old = {'registry': registry} |
| d0b398 | 444 | hook = lambda *arg: None |
| CM | 445 | try: |
| d97398 | 446 | self._setSMHook(hook) |
| d0b398 | 447 | manager.push(old) |
| CM | 448 | self._callFUT() |
| 449 | current = manager.get() | |
| 450 | self.assertNotEqual(current, old) | |
| 451 | self.assertEqual(registry.inited, 2) | |
| 452 | finally: | |
| 6c3f4f | 453 | result = getSiteManager.sethook(None) |
| MM | 454 | self.assertNotEqual(result, hook) |
| d0b398 | 455 | |
| 7ac5aa | 456 | def test_registry_cannot_be_inited(self): |
| b60bdb | 457 | from pyramid.threadlocal import manager |
| 0c29cf | 458 | |
| 7ac5aa | 459 | registry = DummyRegistry() |
| 0c29cf | 460 | |
| 7ac5aa | 461 | def raiseit(name): |
| CM | 462 | raise TypeError |
| 0c29cf | 463 | |
| 7ac5aa | 464 | registry.__init__ = raiseit |
| 0c29cf | 465 | old = {'registry': registry} |
| 7ac5aa | 466 | try: |
| CM | 467 | manager.push(old) |
| 0c29cf | 468 | self._callFUT() # doesn't blow up |
| 7ac5aa | 469 | current = manager.get() |
| CM | 470 | self.assertNotEqual(current, old) |
| 471 | self.assertEqual(registry.inited, 1) | |
| 472 | finally: | |
| 473 | manager.clear() | |
| 474 | ||
| d0b398 | 475 | def test_unhook_zc_false(self): |
| CM | 476 | hook = lambda *arg: None |
| 477 | try: | |
| d97398 | 478 | self._setSMHook(hook) |
| d0b398 | 479 | self._callFUT(unhook_zca=False) |
| CM | 480 | finally: |
| d97398 | 481 | self._assertSMHook(hook) |
| d0b398 | 482 | |
| 0c29cf | 483 | |
| 250c02 | 484 | class TestDummyRendererFactory(unittest.TestCase): |
| CM | 485 | def _makeOne(self, name, factory): |
| b60bdb | 486 | from pyramid.testing import DummyRendererFactory |
| 0c29cf | 487 | |
| 250c02 | 488 | return DummyRendererFactory(name, factory) |
| CM | 489 | |
| 490 | def test_add_no_colon(self): | |
| 491 | f = self._makeOne('name', None) | |
| 492 | f.add('spec', 'renderer') | |
| 493 | self.assertEqual(f.renderers['spec'], 'renderer') | |
| 494 | ||
| 495 | def test_add_with_colon(self): | |
| 496 | f = self._makeOne('name', None) | |
| 497 | f.add('spec:spec2', 'renderer') | |
| 498 | self.assertEqual(f.renderers['spec:spec2'], 'renderer') | |
| 499 | self.assertEqual(f.renderers['spec2'], 'renderer') | |
| 500 | ||
| 501 | def test_call(self): | |
| 502 | f = self._makeOne('name', None) | |
| 503 | f.renderers['spec'] = 'renderer' | |
| 0c29cf | 504 | info = DummyRendererInfo({'name': 'spec'}) |
| 3d9dd0 | 505 | self.assertEqual(f(info), 'renderer') |
| 0c29cf | 506 | |
| 250c02 | 507 | def test_call2(self): |
| CM | 508 | f = self._makeOne('name', None) |
| 509 | f.renderers['spec'] = 'renderer' | |
| 0c29cf | 510 | info = DummyRendererInfo({'name': 'spec:spec'}) |
| 3d9dd0 | 511 | self.assertEqual(f(info), 'renderer') |
| 250c02 | 512 | |
| CM | 513 | def test_call3(self): |
| 514 | def factory(spec): | |
| 515 | return 'renderer' | |
| 0c29cf | 516 | |
| 250c02 | 517 | f = self._makeOne('name', factory) |
| 0c29cf | 518 | info = DummyRendererInfo({'name': 'spec'}) |
| 3d9dd0 | 519 | self.assertEqual(f(info), 'renderer') |
| 250c02 | 520 | |
| CM | 521 | def test_call_miss(self): |
| 522 | f = self._makeOne('name', None) | |
| 0c29cf | 523 | info = DummyRendererInfo({'name': 'spec'}) |
| 3d9dd0 | 524 | self.assertRaises(KeyError, f, info) |
| 0c29cf | 525 | |
| 250c02 | 526 | |
| CM | 527 | class TestMockTemplate(unittest.TestCase): |
| 528 | def _makeOne(self, response): | |
| b60bdb | 529 | from pyramid.testing import MockTemplate |
| 0c29cf | 530 | |
| 250c02 | 531 | return MockTemplate(response) |
| CM | 532 | |
| 533 | def test_getattr(self): | |
| 534 | template = self._makeOne(None) | |
| 535 | self.assertEqual(template.foo, template) | |
| 536 | ||
| 537 | def test_getitem(self): | |
| 538 | template = self._makeOne(None) | |
| 539 | self.assertEqual(template['foo'], template) | |
| 540 | ||
| 541 | def test_call(self): | |
| 542 | template = self._makeOne('123') | |
| 543 | self.assertEqual(template(), '123') | |
| 544 | ||
| 0c29cf | 545 | |
| 35c5a3 | 546 | class Test_skip_on(unittest.TestCase): |
| CM | 547 | def setUp(self): |
| 548 | from pyramid.testing import skip_on | |
| 0c29cf | 549 | |
| 35c5a3 | 550 | self.os_name = skip_on.os_name |
| CM | 551 | skip_on.os_name = 'wrong' |
| 552 | ||
| 553 | def tearDown(self): | |
| 554 | from pyramid.testing import skip_on | |
| 0c29cf | 555 | |
| 35c5a3 | 556 | skip_on.os_name = self.os_name |
| 0c29cf | 557 | |
| 35c5a3 | 558 | def _callFUT(self, *platforms): |
| CM | 559 | from pyramid.testing import skip_on |
| 0c29cf | 560 | |
| 35c5a3 | 561 | return skip_on(*platforms) |
| CM | 562 | |
| 563 | def test_wrong_platform(self): | |
| 0c29cf | 564 | def foo(): |
| MM | 565 | return True |
| 566 | ||
| 35c5a3 | 567 | decorated = self._callFUT('wrong')(foo) |
| CM | 568 | self.assertEqual(decorated(), None) |
| 0c29cf | 569 | |
| 35c5a3 | 570 | def test_ok_platform(self): |
| 0c29cf | 571 | def foo(): |
| MM | 572 | return True |
| 573 | ||
| 35c5a3 | 574 | decorated = self._callFUT('ok')(foo) |
| CM | 575 | self.assertEqual(decorated(), True) |
| 0c29cf | 576 | |
| 35c5a3 | 577 | |
| 51b2e8 | 578 | class TestDummySession(unittest.TestCase): |
| CM | 579 | def _makeOne(self): |
| 580 | from pyramid.testing import DummySession | |
| 0c29cf | 581 | |
| 51b2e8 | 582 | return DummySession() |
| CM | 583 | |
| 0c29cf | 584 | @testing.skip_on( |
| MM | 585 | 'pypy' |
| 586 | ) # see https://github.com/Pylons/pyramid/issues/3237 | |
| 51b2e8 | 587 | def test_instance_conforms(self): |
| CM | 588 | from zope.interface.verify import verifyObject |
| 589 | from pyramid.interfaces import ISession | |
| 0c29cf | 590 | |
| 51b2e8 | 591 | session = self._makeOne() |
| CM | 592 | verifyObject(ISession, session) |
| 593 | ||
| 594 | def test_changed(self): | |
| 595 | session = self._makeOne() | |
| 596 | self.assertEqual(session.changed(), None) | |
| 597 | ||
| 598 | def test_invalidate(self): | |
| 599 | session = self._makeOne() | |
| 600 | session['a'] = 1 | |
| 601 | self.assertEqual(session.invalidate(), None) | |
| a1d395 | 602 | self.assertFalse('a' in session) |
| 51b2e8 | 603 | |
| CM | 604 | def test_flash_default(self): |
| 605 | session = self._makeOne() | |
| 606 | session.flash('msg1') | |
| 607 | session.flash('msg2') | |
| 608 | self.assertEqual(session['_f_'], ['msg1', 'msg2']) | |
| 0c29cf | 609 | |
| 51b2e8 | 610 | def test_flash_mixed(self): |
| CM | 611 | session = self._makeOne() |
| 612 | session.flash('warn1', 'warn') | |
| 613 | session.flash('warn2', 'warn') | |
| 614 | session.flash('err1', 'error') | |
| 615 | session.flash('err2', 'error') | |
| 616 | self.assertEqual(session['_f_warn'], ['warn1', 'warn2']) | |
| 617 | ||
| 618 | def test_pop_flash_default_queue(self): | |
| 619 | session = self._makeOne() | |
| 620 | queue = ['one', 'two'] | |
| 621 | session['_f_'] = queue | |
| 622 | result = session.pop_flash() | |
| 623 | self.assertEqual(result, queue) | |
| 624 | self.assertEqual(session.get('_f_'), None) | |
| 625 | ||
| 626 | def test_pop_flash_nodefault_queue(self): | |
| 627 | session = self._makeOne() | |
| 628 | queue = ['one', 'two'] | |
| 629 | session['_f_error'] = queue | |
| 630 | result = session.pop_flash('error') | |
| 631 | self.assertEqual(result, queue) | |
| 632 | self.assertEqual(session.get('_f_error'), None) | |
| 633 | ||
| 634 | def test_peek_flash_default_queue(self): | |
| 635 | session = self._makeOne() | |
| 636 | queue = ['one', 'two'] | |
| 637 | session['_f_'] = queue | |
| 638 | result = session.peek_flash() | |
| 639 | self.assertEqual(result, queue) | |
| 640 | self.assertEqual(session.get('_f_'), queue) | |
| 641 | ||
| 642 | def test_peek_flash_nodefault_queue(self): | |
| 643 | session = self._makeOne() | |
| 644 | queue = ['one', 'two'] | |
| 645 | session['_f_error'] = queue | |
| 646 | result = session.peek_flash('error') | |
| 647 | self.assertEqual(result, queue) | |
| 648 | self.assertEqual(session.get('_f_error'), queue) | |
| 649 | ||
| 650 | def test_new_csrf_token(self): | |
| 651 | session = self._makeOne() | |
| 652 | token = session.new_csrf_token() | |
| 653 | self.assertEqual(token, session['_csrft_']) | |
| 654 | ||
| 655 | def test_get_csrf_token(self): | |
| 656 | session = self._makeOne() | |
| 657 | session['_csrft_'] = 'token' | |
| 658 | token = session.get_csrf_token() | |
| 659 | self.assertEqual(token, 'token') | |
| a1d395 | 660 | self.assertTrue('_csrft_' in session) |
| 51b2e8 | 661 | |
| 4d2003 | 662 | def test_get_csrf_token_generates_token(self): |
| RB | 663 | session = self._makeOne() |
| 664 | token = session.get_csrf_token() | |
| 665 | self.assertNotEqual(token, None) | |
| 666 | self.assertTrue(len(token) >= 1) | |
| 51b2e8 | 667 | |
| 0c29cf | 668 | |
| d0b398 | 669 | from zope.interface import Interface |
| 3b7334 | 670 | from zope.interface import implementer |
| 0c29cf | 671 | |
| MM | 672 | |
| d0b398 | 673 | class IDummy(Interface): |
| CM | 674 | pass |
| 0c29cf | 675 | |
| d0b398 | 676 | |
| 3b7334 | 677 | @implementer(IDummy) |
| d0b398 | 678 | class DummyEvent: |
| 3b7334 | 679 | pass |
| 0c29cf | 680 | |
| MM | 681 | |
| d0b398 | 682 | class DummyFactory: |
| CM | 683 | def __init__(self, environ): |
| 684 | """ """ | |
| 685 | ||
| 0c29cf | 686 | |
| d0b398 | 687 | class DummyRegistry(object): |
| CM | 688 | inited = 0 |
| 689 | __name__ = 'name' | |
| 0c29cf | 690 | |
| d0b398 | 691 | def __init__(self, name=''): |
| CM | 692 | self.inited = self.inited + 1 |
| 0c29cf | 693 | |
| MM | 694 | |
| f5fa3f | 695 | class DummyRendererInfo(object): |
| CM | 696 | def __init__(self, kw): |
| 697 | self.__dict__.update(kw) | |
| fbbb20 | 698 | |
| 0c29cf | 699 | |
| MM | 700 | class Test_testConfig(unittest.TestCase): |
| fbbb20 | 701 | def _setUp(self, **kw): |
| BS | 702 | self._log.append(('setUp', kw)) |
| 703 | return 'fake config' | |
| 704 | ||
| 705 | def _tearDown(self, **kw): | |
| 706 | self._log.append(('tearDown', kw)) | |
| 707 | ||
| 708 | def setUp(self): | |
| 709 | from pyramid import testing | |
| 0c29cf | 710 | |
| fbbb20 | 711 | self._log = [] |
| BS | 712 | self._orig_setUp = testing.setUp |
| 713 | testing.setUp = self._setUp | |
| 714 | self._orig_tearDown = testing.tearDown | |
| 715 | testing.tearDown = self._tearDown | |
| 716 | ||
| 717 | def tearDown(self): | |
| 718 | from pyramid import testing | |
| 0c29cf | 719 | |
| fbbb20 | 720 | testing.setUp = self._orig_setUp |
| BS | 721 | testing.tearDown = self._orig_tearDown |
| 722 | ||
| 723 | def _callFUT(self, inner, **kw): | |
| 724 | from pyramid.testing import testConfig | |
| 0c29cf | 725 | |
| fbbb20 | 726 | with testConfig(**kw) as config: |
| BS | 727 | inner(config) |
| 728 | ||
| 729 | def test_ok_calls(self): | |
| 730 | self.assertEqual(self._log, []) | |
| 0c29cf | 731 | |
| fbbb20 | 732 | def inner(config): |
| 0c29cf | 733 | self.assertEqual( |
| MM | 734 | self._log, |
| 735 | [ | |
| 736 | ( | |
| 737 | 'setUp', | |
| 738 | { | |
| 739 | 'autocommit': True, | |
| fbbb20 | 740 | 'hook_zca': True, |
| BS | 741 | 'registry': None, |
| 742 | 'request': None, | |
| 0c29cf | 743 | 'settings': None, |
| MM | 744 | }, |
| 745 | ) | |
| 746 | ], | |
| 747 | ) | |
| fbbb20 | 748 | self._log.pop() |
| 0c29cf | 749 | |
| fbbb20 | 750 | self._callFUT(inner) |
| 0c29cf | 751 | self.assertEqual(self._log, [('tearDown', {'unhook_zca': True})]) |
| fbbb20 | 752 | |
| BS | 753 | def test_teardown_called_on_exception(self): |
| 754 | class TestException(Exception): | |
| 755 | pass | |
| 0c29cf | 756 | |
| fbbb20 | 757 | def inner(config): |
| BS | 758 | self._log = [] |
| 759 | raise TestException('oops') | |
| 0c29cf | 760 | |
| fbbb20 | 761 | self.assertRaises(TestException, self._callFUT, inner) |
| BS | 762 | self.assertEqual(self._log[0][0], 'tearDown') |
| 763 | ||
| 764 | def test_ok_get_config(self): | |
| 765 | def inner(config): | |
| 766 | self.assertEqual(config, 'fake config') | |
| 0c29cf | 767 | |
| fbbb20 | 768 | self._callFUT(inner) |
