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