RedHatTraining/pyramid.git

Michael Merickel

2018-10-18 66a767f0e1911543b77a4dd768821ee2ed40390a

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
a7b1a9	306
7d32df	307	class TestDummyTemplateRenderer(unittest.TestCase):
0c29cf	308	def _getTargetClass(self,):
b60bdb	309	from pyramid.testing import DummyTemplateRenderer
0c29cf	310
7d32df	311	return DummyTemplateRenderer
CM	312
e02ba1	313	def _makeOne(self, string_response=''):
CM	314	return self._getTargetClass()(string_response=string_response)
7d32df	315
CM	316	def test_implementation(self):
	317	renderer = self._makeOne()
6eca54	318	impl = renderer.implementation()
CM	319	impl(a=1, b=2)
250c02	320	self.assertEqual(renderer._implementation._received['a'], 1)
CM	321	self.assertEqual(renderer._implementation._received['b'], 2)
7d32df	322
CM	323	def test_getattr(self):
	324	renderer = self._makeOne()
0c29cf	325	renderer({'a': 1})
7d32df	326	self.assertEqual(renderer.a, 1)
CM	327	self.assertRaises(AttributeError, renderer.__getattr__, 'b')
	328
	329	def test_assert_(self):
	330	renderer = self._makeOne()
0c29cf	331	renderer({'a': 1, 'b': 2})
7d32df	332	self.assertRaises(AssertionError, renderer.assert_, c=1)
CM	333	self.assertRaises(AssertionError, renderer.assert_, b=3)
a1d395	334	self.assertTrue(renderer.assert_(a=1, b=2))
0c29cf	335
e02ba1	336	def test_nondefault_string_response(self):
CM	337	renderer = self._makeOne('abc')
0c29cf	338	result = renderer({'a': 1, 'b': 2})
e02ba1	339	self.assertEqual(result, 'abc')
0c29cf	340
d322ac	341
d0b398	342	class Test_setUp(unittest.TestCase):
CM	343	def _callFUT(self, **kw):
b60bdb	344	from pyramid.testing import setUp
0c29cf	345
d0b398	346	return setUp(**kw)
d322ac	347
d97398	348	def tearDown(self):
CM	349	from pyramid.threadlocal import manager
0c29cf	350
d97398	351	manager.clear()
6c3f4f	352	getSiteManager.reset()
d97398	353
CM	354	def _assertSMHook(self, hook):
6c3f4f	355	result = getSiteManager.sethook(None)
MM	356	self.assertEqual(result, hook)
d97398	357
d0b398	358	def test_it_defaults(self):
b60bdb	359	from pyramid.threadlocal import manager
CM	360	from pyramid.threadlocal import get_current_registry
	361	from pyramid.registry import Registry
0c29cf	362
d0b398	363	old = True
CM	364	manager.push(old)
d97398	365	config = self._callFUT()
CM	366	current = manager.get()
	367	self.assertFalse(current is old)
	368	self.assertEqual(config.registry, current['registry'])
	369	self.assertEqual(current['registry'].__class__, Registry)
	370	self.assertEqual(current['request'], None)
dd3cc8	371	self.assertEqual(config.package.__name__, 'tests')
d97398	372	self._assertSMHook(get_current_registry)
d322ac	373
d0b398	374	def test_it_with_registry(self):
c0d4a1	375	from pyramid.registry import Registry
b60bdb	376	from pyramid.threadlocal import manager
0c29cf	377
c0d4a1	378	registry = Registry()
d97398	379	self._callFUT(registry=registry)
CM	380	current = manager.get()
	381	self.assertEqual(current['registry'], registry)
0c29cf	382
d0b398	383	def test_it_with_request(self):
b60bdb	384	from pyramid.threadlocal import manager
0c29cf	385
d0b398	386	request = object()
d97398	387	self._callFUT(request=request)
CM	388	current = manager.get()
	389	self.assertEqual(current['request'], request)
d0b398	390
d24055	391	def test_it_with_package(self):
MM	392	config = self._callFUT(package='pyramid')
	393	self.assertEqual(config.package.__name__, 'pyramid')
	394
d0b398	395	def test_it_with_hook_zca_false(self):
c0d4a1	396	from pyramid.registry import Registry
0c29cf	397
c0d4a1	398	registry = Registry()
d97398	399	self._callFUT(registry=registry, hook_zca=False)
6c3f4f	400	sm = getSiteManager()
MM	401	self.assertFalse(sm is registry)
d0b398	402
2a13b0	403	def test_it_with_settings_passed_explicit_registry(self):
CM	404	from pyramid.registry import Registry
0c29cf	405
2a13b0	406	registry = Registry()
d97398	407	self._callFUT(registry=registry, hook_zca=False, settings=dict(a=1))
CM	408	self.assertEqual(registry.settings['a'], 1)
0c29cf	409
2a13b0	410	def test_it_with_settings_passed_implicit_registry(self):
d97398	411	config = self._callFUT(hook_zca=False, settings=dict(a=1))
CM	412	self.assertEqual(config.registry.settings['a'], 1)
2a13b0	413
0c29cf	414
d0b398	415	class Test_cleanUp(Test_setUp):
CM	416	def _callFUT(self, arg, *kw):
b60bdb	417	from pyramid.testing import cleanUp
0c29cf	418
d0b398	419	return cleanUp(arg, *kw)
0c29cf	420
MM	421
d0b398	422	class Test_tearDown(unittest.TestCase):
CM	423	def _callFUT(self, **kw):
b60bdb	424	from pyramid.testing import tearDown
0c29cf	425
d0b398	426	return tearDown(**kw)
d322ac	427
d97398	428	def tearDown(self):
CM	429	from pyramid.threadlocal import manager
0c29cf	430
d97398	431	manager.clear()
6c3f4f	432	getSiteManager.reset()
d97398	433
CM	434	def _assertSMHook(self, hook):
6c3f4f	435	result = getSiteManager.sethook(None)
MM	436	self.assertEqual(result, hook)
d97398	437
CM	438	def _setSMHook(self, hook):
6c3f4f	439	getSiteManager.sethook(hook)
d97398	440
d0b398	441	def test_defaults(self):
b60bdb	442	from pyramid.threadlocal import manager
0c29cf	443
d0b398	444	registry = DummyRegistry()
0c29cf	445	old = {'registry': registry}
d0b398	446	hook = lambda *arg: None
CM	447	try:
d97398	448	self._setSMHook(hook)
d0b398	449	manager.push(old)
CM	450	self._callFUT()
	451	current = manager.get()
	452	self.assertNotEqual(current, old)
	453	self.assertEqual(registry.inited, 2)
	454	finally:
6c3f4f	455	result = getSiteManager.sethook(None)
MM	456	self.assertNotEqual(result, hook)
d0b398	457
7ac5aa	458	def test_registry_cannot_be_inited(self):
b60bdb	459	from pyramid.threadlocal import manager
0c29cf	460
7ac5aa	461	registry = DummyRegistry()
0c29cf	462
7ac5aa	463	def raiseit(name):
CM	464	raise TypeError
0c29cf	465
7ac5aa	466	registry.__init__ = raiseit
0c29cf	467	old = {'registry': registry}
7ac5aa	468	try:
CM	469	manager.push(old)
0c29cf	470	self._callFUT() # doesn't blow up
7ac5aa	471	current = manager.get()
CM	472	self.assertNotEqual(current, old)
	473	self.assertEqual(registry.inited, 1)
	474	finally:
	475	manager.clear()
	476
d0b398	477	def test_unhook_zc_false(self):
CM	478	hook = lambda *arg: None
	479	try:
d97398	480	self._setSMHook(hook)
d0b398	481	self._callFUT(unhook_zca=False)
CM	482	finally:
d97398	483	self._assertSMHook(hook)
d0b398	484
0c29cf	485
250c02	486	class TestDummyRendererFactory(unittest.TestCase):
CM	487	def _makeOne(self, name, factory):
b60bdb	488	from pyramid.testing import DummyRendererFactory
0c29cf	489
250c02	490	return DummyRendererFactory(name, factory)
CM	491
	492	def test_add_no_colon(self):
	493	f = self._makeOne('name', None)
	494	f.add('spec', 'renderer')
	495	self.assertEqual(f.renderers['spec'], 'renderer')
	496
	497	def test_add_with_colon(self):
	498	f = self._makeOne('name', None)
	499	f.add('spec:spec2', 'renderer')
	500	self.assertEqual(f.renderers['spec:spec2'], 'renderer')
	501	self.assertEqual(f.renderers['spec2'], 'renderer')
	502
	503	def test_call(self):
	504	f = self._makeOne('name', None)
	505	f.renderers['spec'] = 'renderer'
0c29cf	506	info = DummyRendererInfo({'name': 'spec'})
3d9dd0	507	self.assertEqual(f(info), 'renderer')
0c29cf	508
250c02	509	def test_call2(self):
CM	510	f = self._makeOne('name', None)
	511	f.renderers['spec'] = 'renderer'
0c29cf	512	info = DummyRendererInfo({'name': 'spec:spec'})
3d9dd0	513	self.assertEqual(f(info), 'renderer')
250c02	514
CM	515	def test_call3(self):
	516	def factory(spec):
	517	return 'renderer'
0c29cf	518
250c02	519	f = self._makeOne('name', factory)
0c29cf	520	info = DummyRendererInfo({'name': 'spec'})
3d9dd0	521	self.assertEqual(f(info), 'renderer')
250c02	522
CM	523	def test_call_miss(self):
	524	f = self._makeOne('name', None)
0c29cf	525	info = DummyRendererInfo({'name': 'spec'})
3d9dd0	526	self.assertRaises(KeyError, f, info)
0c29cf	527
250c02	528
CM	529	class TestMockTemplate(unittest.TestCase):
	530	def _makeOne(self, response):
b60bdb	531	from pyramid.testing import MockTemplate
0c29cf	532
250c02	533	return MockTemplate(response)
CM	534
	535	def test_getattr(self):
	536	template = self._makeOne(None)
	537	self.assertEqual(template.foo, template)
	538
	539	def test_getitem(self):
	540	template = self._makeOne(None)
	541	self.assertEqual(template['foo'], template)
	542
	543	def test_call(self):
	544	template = self._makeOne('123')
	545	self.assertEqual(template(), '123')
	546
0c29cf	547
35c5a3	548	class Test_skip_on(unittest.TestCase):
CM	549	def setUp(self):
	550	from pyramid.testing import skip_on
0c29cf	551
35c5a3	552	self.os_name = skip_on.os_name
CM	553	skip_on.os_name = 'wrong'
	554
	555	def tearDown(self):
	556	from pyramid.testing import skip_on
0c29cf	557
35c5a3	558	skip_on.os_name = self.os_name
0c29cf	559
35c5a3	560	def _callFUT(self, *platforms):
CM	561	from pyramid.testing import skip_on
0c29cf	562
35c5a3	563	return skip_on(*platforms)
CM	564
	565	def test_wrong_platform(self):
10ddb6	566	def foo(): # pragma: no cover
0c29cf	567	return True
MM	568
35c5a3	569	decorated = self._callFUT('wrong')(foo)
CM	570	self.assertEqual(decorated(), None)
0c29cf	571
35c5a3	572	def test_ok_platform(self):
0c29cf	573	def foo():
MM	574	return True
	575
35c5a3	576	decorated = self._callFUT('ok')(foo)
CM	577	self.assertEqual(decorated(), True)
0c29cf	578
35c5a3	579
51b2e8	580	class TestDummySession(unittest.TestCase):
CM	581	def _makeOne(self):
	582	from pyramid.testing import DummySession
0c29cf	583
51b2e8	584	return DummySession()
CM	585
0c29cf	586	@testing.skip_on(
MM	587	'pypy'
	588	) # see https://github.com/Pylons/pyramid/issues/3237
51b2e8	589	def test_instance_conforms(self):
CM	590	from zope.interface.verify import verifyObject
	591	from pyramid.interfaces import ISession
0c29cf	592
51b2e8	593	session = self._makeOne()
CM	594	verifyObject(ISession, session)
	595
	596	def test_changed(self):
	597	session = self._makeOne()
	598	self.assertEqual(session.changed(), None)
	599
	600	def test_invalidate(self):
	601	session = self._makeOne()
	602	session['a'] = 1
	603	self.assertEqual(session.invalidate(), None)
a1d395	604	self.assertFalse('a' in session)
51b2e8	605
CM	606	def test_flash_default(self):
	607	session = self._makeOne()
	608	session.flash('msg1')
	609	session.flash('msg2')
	610	self.assertEqual(session['_f_'], ['msg1', 'msg2'])
0c29cf	611
51b2e8	612	def test_flash_mixed(self):
CM	613	session = self._makeOne()
	614	session.flash('warn1', 'warn')
	615	session.flash('warn2', 'warn')
	616	session.flash('err1', 'error')
	617	session.flash('err2', 'error')
	618	self.assertEqual(session['_f_warn'], ['warn1', 'warn2'])
	619
	620	def test_pop_flash_default_queue(self):
	621	session = self._makeOne()
	622	queue = ['one', 'two']
	623	session['_f_'] = queue
	624	result = session.pop_flash()
	625	self.assertEqual(result, queue)
	626	self.assertEqual(session.get('_f_'), None)
	627
	628	def test_pop_flash_nodefault_queue(self):
	629	session = self._makeOne()
	630	queue = ['one', 'two']
	631	session['_f_error'] = queue
	632	result = session.pop_flash('error')
	633	self.assertEqual(result, queue)
	634	self.assertEqual(session.get('_f_error'), None)
	635
	636	def test_peek_flash_default_queue(self):
	637	session = self._makeOne()
	638	queue = ['one', 'two']
	639	session['_f_'] = queue
	640	result = session.peek_flash()
	641	self.assertEqual(result, queue)
	642	self.assertEqual(session.get('_f_'), queue)
	643
	644	def test_peek_flash_nodefault_queue(self):
	645	session = self._makeOne()
	646	queue = ['one', 'two']
	647	session['_f_error'] = queue
	648	result = session.peek_flash('error')
	649	self.assertEqual(result, queue)
	650	self.assertEqual(session.get('_f_error'), queue)
	651
	652	def test_new_csrf_token(self):
	653	session = self._makeOne()
	654	token = session.new_csrf_token()
	655	self.assertEqual(token, session['_csrft_'])
	656
	657	def test_get_csrf_token(self):
	658	session = self._makeOne()
	659	session['_csrft_'] = 'token'
	660	token = session.get_csrf_token()
	661	self.assertEqual(token, 'token')
a1d395	662	self.assertTrue('_csrft_' in session)
51b2e8	663
4d2003	664	def test_get_csrf_token_generates_token(self):
RB	665	session = self._makeOne()
	666	token = session.get_csrf_token()
	667	self.assertNotEqual(token, None)
	668	self.assertTrue(len(token) >= 1)
0c29cf	669
MM	670
d0b398	671	class IDummy(Interface):
CM	672	pass
0c29cf	673
d0b398	674
3b7334	675	@implementer(IDummy)
d0b398	676	class DummyEvent:
3b7334	677	pass
0c29cf	678
MM	679
d0b398	680	class DummyFactory:
CM	681	def __init__(self, environ):
	682	""" """
	683
0c29cf	684
d0b398	685	class DummyRegistry(object):
CM	686	inited = 0
	687	__name__ = 'name'
0c29cf	688
d0b398	689	def __init__(self, name=''):
CM	690	self.inited = self.inited + 1
0c29cf	691
MM	692
f5fa3f	693	class DummyRendererInfo(object):
CM	694	def __init__(self, kw):
	695	self.__dict__.update(kw)
fbbb20	696
0c29cf	697
MM	698	class Test_testConfig(unittest.TestCase):
fbbb20	699	def _setUp(self, **kw):
BS	700	self._log.append(('setUp', kw))
	701	return 'fake config'
	702
	703	def _tearDown(self, **kw):
	704	self._log.append(('tearDown', kw))
	705
	706	def setUp(self):
	707	from pyramid import testing
0c29cf	708
fbbb20	709	self._log = []
BS	710	self._orig_setUp = testing.setUp
	711	testing.setUp = self._setUp
	712	self._orig_tearDown = testing.tearDown
	713	testing.tearDown = self._tearDown
	714
	715	def tearDown(self):
	716	from pyramid import testing
0c29cf	717
fbbb20	718	testing.setUp = self._orig_setUp
BS	719	testing.tearDown = self._orig_tearDown
	720
	721	def _callFUT(self, inner, **kw):
	722	from pyramid.testing import testConfig
0c29cf	723
fbbb20	724	with testConfig(**kw) as config:
BS	725	inner(config)
	726
	727	def test_ok_calls(self):
	728	self.assertEqual(self._log, [])
0c29cf	729
fbbb20	730	def inner(config):
0c29cf	731	self.assertEqual(
MM	732	self._log,
	733	[
	734	(
	735	'setUp',
	736	{
	737	'autocommit': True,
fbbb20	738	'hook_zca': True,
BS	739	'registry': None,
	740	'request': None,
0c29cf	741	'settings': None,
MM	742	},
	743	)
	744	],
	745	)
fbbb20	746	self._log.pop()
0c29cf	747
fbbb20	748	self._callFUT(inner)
0c29cf	749	self.assertEqual(self._log, [('tearDown', {'unhook_zca': True})])
fbbb20	750
BS	751	def test_teardown_called_on_exception(self):
	752	class TestException(Exception):
	753	pass
0c29cf	754
fbbb20	755	def inner(config):
BS	756	self._log = []
	757	raise TestException('oops')
0c29cf	758
fbbb20	759	self.assertRaises(TestException, self._callFUT, inner)
BS	760	self.assertEqual(self._log[0][0], 'tearDown')
	761
	762	def test_ok_get_config(self):
	763	def inner(config):
	764	self.assertEqual(config, 'fake config')
0c29cf	765
fbbb20	766	self._callFUT(inner)