RedHatTraining/pyramid.git

Throw 401 for security denial for unauthenticated

Bowe Strickland

2018-10-27 323fa95deea50f49c119728fc2eeacb9e0c51241

commit \| author \| age
f52759	1	# -- coding: utf-8 --
8b2c67	2	import unittest
CM	3
b60bdb	4	from pyramid.testing import cleanUp
118ea0	5
0c29cf	6	from pyramid.compat import text_, native_, text_type, url_quote, PY2
MM	7
8f8869	8
e6e0ea	9	class TraversalPathTests(unittest.TestCase):
eb6afe	10	def _callFUT(self, path):
b60bdb	11	from pyramid.traversal import traversal_path
0c29cf	12
e6e0ea	13	return traversal_path(path)
51c305	14
f84147	15	def test_utf8(self):
CM	16	la = b'La Pe\xc3\xb1a'
	17	encoded = url_quote(la)
	18	decoded = text_(la, 'utf-8')
	19	path = '/'.join([encoded, encoded])
	20	result = self._callFUT(path)
	21	self.assertEqual(result, (decoded, decoded))
	22
	23	def test_utf16(self):
	24	from pyramid.exceptions import URLDecodeError
0c29cf	25
f84147	26	la = text_(b'La Pe\xc3\xb1a', 'utf-8').encode('utf-16')
CM	27	encoded = url_quote(la)
	28	path = '/'.join([encoded, encoded])
	29	self.assertRaises(URLDecodeError, self._callFUT, path)
	30
	31	def test_unicode_highorder_chars(self):
	32	path = text_('/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF')
0c29cf	33	self.assertEqual(
MM	34	self._callFUT(path),
	35	(text_('\u6d41\u884c\u8d8b\u52bf', 'unicode_escape'),),
	36	)
f84147	37
CM	38	def test_element_urllquoted(self):
0c29cf	39	self.assertEqual(
MM	40	self._callFUT('/foo/space%20thing/bar'),
	41	(text_('foo'), text_('space thing'), text_('bar')),
	42	)
f84147	43
CM	44	def test_unicode_undecodeable_to_ascii(self):
	45	path = text_(b'/La Pe\xc3\xb1a', 'utf-8')
	46	self.assertRaises(UnicodeEncodeError, self._callFUT, path)
	47
0c29cf	48
f84147	49	class TraversalPathInfoTests(unittest.TestCase):
CM	50	def _callFUT(self, path):
	51	from pyramid.traversal import traversal_path_info
0c29cf	52
f84147	53	return traversal_path_info(path)
CM	54
dc16fa	55	def test_path_startswith_endswith(self):
e6c2d2	56	self.assertEqual(self._callFUT('/foo/'), (text_('foo'),))
8b2c67	57
dc16fa	58	def test_empty_elements(self):
e6c2d2	59	self.assertEqual(self._callFUT('foo///'), (text_('foo'),))
8b2c67	60
dc16fa	61	def test_onedot(self):
0c29cf	62	self.assertEqual(
MM	63	self._callFUT('foo/./bar'), (text_('foo'), text_('bar'))
	64	)
8b2c67	65
dc16fa	66	def test_twodots(self):
e6c2d2	67	self.assertEqual(self._callFUT('foo/../bar'), (text_('bar'),))
8b2c67	68
f2ef79	69	def test_twodots_at_start(self):
e6c2d2	70	self.assertEqual(self._callFUT('../../bar'), (text_('bar'),))
f2ef79	71
dc16fa	72	def test_segments_are_unicode(self):
CM	73	result = self._callFUT('/foo/bar')
8e606d	74	self.assertEqual(type(result[0]), text_type)
CM	75	self.assertEqual(type(result[1]), text_type)
e281fa	76
CM	77	def test_same_value_returned_if_cached(self):
	78	result1 = self._callFUT('/foo/bar')
	79	result2 = self._callFUT('/foo/bar')
e6c2d2	80	self.assertEqual(result1, (text_('foo'), text_('bar')))
CM	81	self.assertEqual(result2, (text_('foo'), text_('bar')))
dc16fa	82
841313	83	def test_unicode_simple(self):
e6c2d2	84	path = text_('/abc')
CM	85	self.assertEqual(self._callFUT(path), (text_('abc'),))
841313	86
f84147	87	def test_highorder(self):
CM	88	la = b'La Pe\xc3\xb1a'
	89	latin1 = native_(la)
	90	result = self._callFUT(latin1)
	91	self.assertEqual(result, (text_(la, 'utf-8'),))
	92
	93	def test_highorder_undecodeable(self):
	94	from pyramid.exceptions import URLDecodeError
0c29cf	95
f84147	96	la = text_(b'La Pe\xc3\xb1a', 'utf-8')
CM	97	notlatin1 = native_(la)
	98	self.assertRaises(URLDecodeError, self._callFUT, notlatin1)
0c29cf	99
841313	100
92c3e5	101	class ResourceTreeTraverserTests(unittest.TestCase):
8f8869	102	def setUp(self):
ed2d14	103	cleanUp()
8f8869	104
CM	105	def tearDown(self):
ed2d14	106	cleanUp()
916f88	107
8b2c67	108	def _getTargetClass(self):
92c3e5	109	from pyramid.traversal import ResourceTreeTraverser
0c29cf	110
92c3e5	111	return ResourceTreeTraverser
8b2c67	112
CM	113	def _makeOne(self, arg, *kw):
	114	klass = self._getTargetClass()
	115	return klass(arg, *kw)
	116
281a7a	117	def _getEnviron(self, **kw):
CM	118	environ = {}
	119	environ.update(kw)
	120	return environ
	121
8392d7	122	def test_class_conforms_to_ITraverser(self):
8b2c67	123	from zope.interface.verify import verifyClass
b60bdb	124	from pyramid.interfaces import ITraverser
0c29cf	125
4df575	126	verifyClass(ITraverser, self._getTargetClass())
8b2c67	127
8392d7	128	def test_instance_conforms_to_ITraverser(self):
8b2c67	129	from zope.interface.verify import verifyObject
b60bdb	130	from pyramid.interfaces import ITraverser
0c29cf	131
7de404	132	context = DummyContext()
cc5e49	133	verifyObject(ITraverser, self._makeOne(context))
8b2c67	134
27d874	135	def test_call_with_empty_pathinfo(self):
de4969	136	policy = self._makeOne(None)
CM	137	environ = self._getEnviron()
27d874	138	request = DummyRequest(environ, path_info='')
CM	139	result = policy(request)
	140	self.assertEqual(result['context'], None)
	141	self.assertEqual(result['view_name'], '')
	142	self.assertEqual(result['subpath'], ())
	143	self.assertEqual(result['traversed'], ())
	144	self.assertEqual(result['root'], policy.root)
	145	self.assertEqual(result['virtual_root'], policy.root)
	146	self.assertEqual(result['virtual_root_path'], ())
	147
	148	def test_call_with_pathinfo_KeyError(self):
	149	policy = self._makeOne(None)
	150	environ = self._getEnviron()
	151	request = DummyRequest(environ, toraise=KeyError)
f426e5	152	result = policy(request)
916f88	153	self.assertEqual(result['context'], None)
CM	154	self.assertEqual(result['view_name'], '')
6ecdbc	155	self.assertEqual(result['subpath'], ())
1cd598	156	self.assertEqual(result['traversed'], ())
92dcb5	157	self.assertEqual(result['root'], policy.root)
CM	158	self.assertEqual(result['virtual_root'], policy.root)
	159	self.assertEqual(result['virtual_root_path'], ())
	160
	161	def test_call_with_pathinfo_highorder(self):
def68d	162	path = text_(b'/Qu\xc3\xa9bec', 'utf-8')
CM	163	foo = DummyContext(None, path)
92dcb5	164	root = DummyContext(foo, 'root')
CM	165	policy = self._makeOne(root)
def68d	166	environ = self._getEnviron()
CM	167	request = DummyRequest(environ, path_info=path)
92dcb5	168	result = policy(request)
CM	169	self.assertEqual(result['context'], foo)
	170	self.assertEqual(result['view_name'], '')
	171	self.assertEqual(result['subpath'], ())
def68d	172	self.assertEqual(result['traversed'], (path[1:],))
7fc6a3	173	self.assertEqual(result['root'], policy.root)
916f88	174	self.assertEqual(result['virtual_root'], policy.root)
1cd598	175	self.assertEqual(result['virtual_root_path'], ())
de4969	176
7de404	177	def test_call_pathel_with_no_getitem(self):
cc5e49	178	policy = self._makeOne(None)
def68d	179	environ = self._getEnviron()
ebcdc7	180	request = DummyRequest(environ, path_info=text_('/foo/bar'))
f426e5	181	result = policy(request)
916f88	182	self.assertEqual(result['context'], None)
CM	183	self.assertEqual(result['view_name'], 'foo')
6ecdbc	184	self.assertEqual(result['subpath'], ('bar',))
1cd598	185	self.assertEqual(result['traversed'], ())
7fc6a3	186	self.assertEqual(result['root'], policy.root)
916f88	187	self.assertEqual(result['virtual_root'], policy.root)
1cd598	188	self.assertEqual(result['virtual_root_path'], ())
8b2c67	189
CM	190	def test_call_withconn_getitem_emptypath_nosubpath(self):
7de404	191	root = DummyContext()
cc5e49	192	policy = self._makeOne(root)
def68d	193	environ = self._getEnviron()
ebcdc7	194	request = DummyRequest(environ, path_info=text_(''))
f426e5	195	result = policy(request)
916f88	196	self.assertEqual(result['context'], root)
CM	197	self.assertEqual(result['view_name'], '')
6ecdbc	198	self.assertEqual(result['subpath'], ())
1cd598	199	self.assertEqual(result['traversed'], ())
7fc6a3	200	self.assertEqual(result['root'], root)
916f88	201	self.assertEqual(result['virtual_root'], root)
1cd598	202	self.assertEqual(result['virtual_root_path'], ())
8b2c67	203
CM	204	def test_call_withconn_getitem_withpath_nosubpath(self):
7de404	205	foo = DummyContext()
CM	206	root = DummyContext(foo)
cc5e49	207	policy = self._makeOne(root)
def68d	208	environ = self._getEnviron()
ebcdc7	209	request = DummyRequest(environ, path_info=text_('/foo/bar'))
f426e5	210	result = policy(request)
916f88	211	self.assertEqual(result['context'], foo)
CM	212	self.assertEqual(result['view_name'], 'bar')
6ecdbc	213	self.assertEqual(result['subpath'], ())
e6c2d2	214	self.assertEqual(result['traversed'], (text_('foo'),))
7fc6a3	215	self.assertEqual(result['root'], root)
916f88	216	self.assertEqual(result['virtual_root'], root)
1cd598	217	self.assertEqual(result['virtual_root_path'], ())
8b2c67	218
CM	219	def test_call_withconn_getitem_withpath_withsubpath(self):
7de404	220	foo = DummyContext()
CM	221	root = DummyContext(foo)
cc5e49	222	policy = self._makeOne(root)
def68d	223	environ = self._getEnviron()
ebcdc7	224	request = DummyRequest(environ, path_info=text_('/foo/bar/baz/buz'))
f426e5	225	result = policy(request)
916f88	226	self.assertEqual(result['context'], foo)
CM	227	self.assertEqual(result['view_name'], 'bar')
6ecdbc	228	self.assertEqual(result['subpath'], ('baz', 'buz'))
e6c2d2	229	self.assertEqual(result['traversed'], (text_('foo'),))
7fc6a3	230	self.assertEqual(result['root'], root)
916f88	231	self.assertEqual(result['virtual_root'], root)
1cd598	232	self.assertEqual(result['virtual_root_path'], ())
8b2c67	233
8823e2	234	def test_call_with_explicit_viewname(self):
CM	235	foo = DummyContext()
	236	root = DummyContext(foo)
cc5e49	237	policy = self._makeOne(root)
def68d	238	environ = self._getEnviron()
ebcdc7	239	request = DummyRequest(environ, path_info=text_('/@@foo'))
f426e5	240	result = policy(request)
916f88	241	self.assertEqual(result['context'], root)
CM	242	self.assertEqual(result['view_name'], 'foo')
6ecdbc	243	self.assertEqual(result['subpath'], ())
1cd598	244	self.assertEqual(result['traversed'], ())
7fc6a3	245	self.assertEqual(result['root'], root)
916f88	246	self.assertEqual(result['virtual_root'], root)
1cd598	247	self.assertEqual(result['virtual_root_path'], ())
8823e2	248
65f3f8	249	def test_call_with_vh_root(self):
def68d	250	environ = self._getEnviron(HTTP_X_VHM_ROOT='/foo/bar')
7fc6a3	251	baz = DummyContext(None, 'baz')
CM	252	bar = DummyContext(baz, 'bar')
	253	foo = DummyContext(bar, 'foo')
	254	root = DummyContext(foo, 'root')
65f3f8	255	policy = self._makeOne(root)
ebcdc7	256	request = DummyRequest(environ, path_info=text_('/baz'))
f426e5	257	result = policy(request)
916f88	258	self.assertEqual(result['context'], baz)
CM	259	self.assertEqual(result['view_name'], '')
6ecdbc	260	self.assertEqual(result['subpath'], ())
0c29cf	261	self.assertEqual(
MM	262	result['traversed'], (text_('foo'), text_('bar'), text_('baz'))
	263	)
7fc6a3	264	self.assertEqual(result['root'], root)
916f88	265	self.assertEqual(result['virtual_root'], bar)
0c29cf	266	self.assertEqual(
MM	267	result['virtual_root_path'], (text_('foo'), text_('bar'))
	268	)
1cd598	269
CM	270	def test_call_with_vh_root2(self):
def68d	271	environ = self._getEnviron(HTTP_X_VHM_ROOT='/foo')
7fc6a3	272	baz = DummyContext(None, 'baz')
CM	273	bar = DummyContext(baz, 'bar')
	274	foo = DummyContext(bar, 'foo')
	275	root = DummyContext(foo, 'root')
1cd598	276	policy = self._makeOne(root)
ebcdc7	277	request = DummyRequest(environ, path_info=text_('/bar/baz'))
f426e5	278	result = policy(request)
1cd598	279	self.assertEqual(result['context'], baz)
CM	280	self.assertEqual(result['view_name'], '')
	281	self.assertEqual(result['subpath'], ())
0c29cf	282	self.assertEqual(
MM	283	result['traversed'], (text_('foo'), text_('bar'), text_('baz'))
	284	)
7fc6a3	285	self.assertEqual(result['root'], root)
1cd598	286	self.assertEqual(result['virtual_root'], foo)
e6c2d2	287	self.assertEqual(result['virtual_root_path'], (text_('foo'),))
1cd598	288
CM	289	def test_call_with_vh_root3(self):
def68d	290	environ = self._getEnviron(HTTP_X_VHM_ROOT='/')
1cd598	291	baz = DummyContext()
CM	292	bar = DummyContext(baz)
	293	foo = DummyContext(bar)
	294	root = DummyContext(foo)
	295	policy = self._makeOne(root)
ebcdc7	296	request = DummyRequest(environ, path_info=text_('/foo/bar/baz'))
f426e5	297	result = policy(request)
1cd598	298	self.assertEqual(result['context'], baz)
CM	299	self.assertEqual(result['view_name'], '')
	300	self.assertEqual(result['subpath'], ())
0c29cf	301	self.assertEqual(
MM	302	result['traversed'], (text_('foo'), text_('bar'), text_('baz'))
	303	)
7fc6a3	304	self.assertEqual(result['root'], root)
1cd598	305	self.assertEqual(result['virtual_root'], root)
CM	306	self.assertEqual(result['virtual_root_path'], ())
7fc6a3	307
CM	308	def test_call_with_vh_root4(self):
def68d	309	environ = self._getEnviron(HTTP_X_VHM_ROOT='/foo/bar/baz')
7fc6a3	310	baz = DummyContext(None, 'baz')
CM	311	bar = DummyContext(baz, 'bar')
	312	foo = DummyContext(bar, 'foo')
	313	root = DummyContext(foo, 'root')
	314	policy = self._makeOne(root)
ebcdc7	315	request = DummyRequest(environ, path_info=text_('/'))
f426e5	316	result = policy(request)
7fc6a3	317	self.assertEqual(result['context'], baz)
CM	318	self.assertEqual(result['view_name'], '')
	319	self.assertEqual(result['subpath'], ())
0c29cf	320	self.assertEqual(
MM	321	result['traversed'], (text_('foo'), text_('bar'), text_('baz'))
	322	)
7fc6a3	323	self.assertEqual(result['root'], root)
CM	324	self.assertEqual(result['virtual_root'], baz)
0c29cf	325	self.assertEqual(
MM	326	result['virtual_root_path'],
	327	(text_('foo'), text_('bar'), text_('baz')),
	328	)
1cd598	329
CM	330	def test_call_with_vh_root_path_root(self):
	331	policy = self._makeOne(None)
def68d	332	environ = self._getEnviron(HTTP_X_VHM_ROOT='/')
ebcdc7	333	request = DummyRequest(environ, path_info=text_('/'))
f426e5	334	result = policy(request)
1cd598	335	self.assertEqual(result['context'], None)
CM	336	self.assertEqual(result['view_name'], '')
	337	self.assertEqual(result['subpath'], ())
	338	self.assertEqual(result['traversed'], ())
7fc6a3	339	self.assertEqual(result['root'], policy.root)
1cd598	340	self.assertEqual(result['virtual_root'], policy.root)
CM	341	self.assertEqual(result['virtual_root_path'], ())
65f3f8	342
92dcb5	343	def test_call_with_vh_root_highorder(self):
def68d	344	path = text_(b'Qu\xc3\xa9bec', 'utf-8')
92dcb5	345	bar = DummyContext(None, 'bar')
def68d	346	foo = DummyContext(bar, path)
92dcb5	347	root = DummyContext(foo, 'root')
CM	348	policy = self._makeOne(root)
bc37a5	349	if PY2:
92dcb5	350	vhm_root = b'/Qu\xc3\xa9bec'
bc37a5	351	else:
MM	352	vhm_root = b'/Qu\xc3\xa9bec'.decode('latin-1')
def68d	353	environ = self._getEnviron(HTTP_X_VHM_ROOT=vhm_root)
ebcdc7	354	request = DummyRequest(environ, path_info=text_('/bar'))
92dcb5	355	result = policy(request)
CM	356	self.assertEqual(result['context'], bar)
	357	self.assertEqual(result['view_name'], '')
	358	self.assertEqual(result['subpath'], ())
0c29cf	359	self.assertEqual(result['traversed'], (path, text_('bar')))
92dcb5	360	self.assertEqual(result['root'], policy.root)
CM	361	self.assertEqual(result['virtual_root'], foo)
0c29cf	362	self.assertEqual(result['virtual_root_path'], (path,))
92dcb5	363
def68d	364	def test_path_info_raises_unicodedecodeerror(self):
f84147	365	from pyramid.exceptions import URLDecodeError
0c29cf	366
217070	367	foo = DummyContext()
TS	368	root = DummyContext(foo)
	369	policy = self._makeOne(root)
def68d	370	environ = self._getEnviron()
ebcdc7	371	toraise = UnicodeDecodeError('ascii', b'a', 2, 3, '5')
def68d	372	request = DummyRequest(environ, toraise=toraise)
CM	373	request.matchdict = None
f84147	374	self.assertRaises(URLDecodeError, policy, request)
217070	375
dfc2b6	376	def test_withroute_nothingfancy(self):
92c3e5	377	resource = DummyContext()
CM	378	traverser = self._makeOne(resource)
def68d	379	request = DummyRequest({})
CM	380	request.matchdict = {}
f426e5	381	result = traverser(request)
92c3e5	382	self.assertEqual(result['context'], resource)
dfc2b6	383	self.assertEqual(result['view_name'], '')
6ecdbc	384	self.assertEqual(result['subpath'], ())
1cd598	385	self.assertEqual(result['traversed'], ())
92c3e5	386	self.assertEqual(result['root'], resource)
CM	387	self.assertEqual(result['virtual_root'], resource)
1cd598	388	self.assertEqual(result['virtual_root_path'], ())
dfc2b6	389
25cbe1	390	def test_withroute_with_subpath_string(self):
92c3e5	391	resource = DummyContext()
CM	392	traverser = self._makeOne(resource)
0c29cf	393	matchdict = {'subpath': '/a/b/c'}
def68d	394	request = DummyRequest({})
CM	395	request.matchdict = matchdict
f426e5	396	result = traverser(request)
92c3e5	397	self.assertEqual(result['context'], resource)
dfc2b6	398	self.assertEqual(result['view_name'], '')
0c29cf	399	self.assertEqual(result['subpath'], ('a', 'b', 'c'))
1cd598	400	self.assertEqual(result['traversed'], ())
92c3e5	401	self.assertEqual(result['root'], resource)
CM	402	self.assertEqual(result['virtual_root'], resource)
1cd598	403	self.assertEqual(result['virtual_root_path'], ())
dfc2b6	404
25cbe1	405	def test_withroute_with_subpath_tuple(self):
92c3e5	406	resource = DummyContext()
CM	407	traverser = self._makeOne(resource)
0c29cf	408	matchdict = {'subpath': ('a', 'b', 'c')}
def68d	409	request = DummyRequest({})
CM	410	request.matchdict = matchdict
f426e5	411	result = traverser(request)
92c3e5	412	self.assertEqual(result['context'], resource)
25cbe1	413	self.assertEqual(result['view_name'], '')
0c29cf	414	self.assertEqual(result['subpath'], ('a', 'b', 'c'))
25cbe1	415	self.assertEqual(result['traversed'], ())
92c3e5	416	self.assertEqual(result['root'], resource)
CM	417	self.assertEqual(result['virtual_root'], resource)
25cbe1	418	self.assertEqual(result['virtual_root_path'], ())
CM	419
	420	def test_withroute_and_traverse_string(self):
92c3e5	421	resource = DummyContext()
CM	422	traverser = self._makeOne(resource)
0c29cf	423	matchdict = {'traverse': text_('foo/bar')}
def68d	424	request = DummyRequest({})
CM	425	request.matchdict = matchdict
f426e5	426	result = traverser(request)
92c3e5	427	self.assertEqual(result['context'], resource)
dfc2b6	428	self.assertEqual(result['view_name'], 'foo')
6ecdbc	429	self.assertEqual(result['subpath'], ('bar',))
1cd598	430	self.assertEqual(result['traversed'], ())
92c3e5	431	self.assertEqual(result['root'], resource)
CM	432	self.assertEqual(result['virtual_root'], resource)
1cd598	433	self.assertEqual(result['virtual_root_path'], ())
dfc2b6	434
25cbe1	435	def test_withroute_and_traverse_tuple(self):
92c3e5	436	resource = DummyContext()
CM	437	traverser = self._makeOne(resource)
0c29cf	438	matchdict = {'traverse': ('foo', 'bar')}
def68d	439	request = DummyRequest({})
CM	440	request.matchdict = matchdict
f426e5	441	result = traverser(request)
92c3e5	442	self.assertEqual(result['context'], resource)
25cbe1	443	self.assertEqual(result['view_name'], 'foo')
CM	444	self.assertEqual(result['subpath'], ('bar',))
	445	self.assertEqual(result['traversed'], ())
92c3e5	446	self.assertEqual(result['root'], resource)
CM	447	self.assertEqual(result['virtual_root'], resource)
25cbe1	448	self.assertEqual(result['virtual_root_path'], ())
CM	449
1db5c4	450	def test_withroute_and_traverse_empty(self):
CM	451	resource = DummyContext()
	452	traverser = self._makeOne(resource)
0c29cf	453	matchdict = {'traverse': ''}
def68d	454	request = DummyRequest({})
CM	455	request.matchdict = matchdict
f426e5	456	result = traverser(request)
1db5c4	457	self.assertEqual(result['context'], resource)
CM	458	self.assertEqual(result['view_name'], '')
	459	self.assertEqual(result['subpath'], ())
	460	self.assertEqual(result['traversed'], ())
	461	self.assertEqual(result['root'], resource)
	462	self.assertEqual(result['virtual_root'], resource)
	463	self.assertEqual(result['virtual_root_path'], ())
f426e5	464
ece96f	465	def test_withroute_and_traverse_and_vroot(self):
CM	466	abc = DummyContext()
	467	resource = DummyContext(next=abc)
	468	environ = self._getEnviron(HTTP_X_VHM_ROOT='/abc')
	469	request = DummyRequest(environ)
	470	traverser = self._makeOne(resource)
0c29cf	471	matchdict = {'traverse': text_('/foo/bar')}
ece96f	472	request.matchdict = matchdict
CM	473	result = traverser(request)
	474	self.assertEqual(result['context'], abc)
	475	self.assertEqual(result['view_name'], 'foo')
	476	self.assertEqual(result['subpath'], ('bar',))
	477	self.assertEqual(result['traversed'], ('abc', 'foo'))
	478	self.assertEqual(result['root'], resource)
	479	self.assertEqual(result['virtual_root'], abc)
	480	self.assertEqual(result['virtual_root_path'], ('abc',))
0c29cf	481
MM	482
bb5d64	483	class FindInterfaceTests(unittest.TestCase):
eb6afe	484	def _callFUT(self, context, iface):
b60bdb	485	from pyramid.traversal import find_interface
0c29cf	486
eb6afe	487	return find_interface(context, iface)
bb5d64	488
0f5d8b	489	def test_it_interface(self):
bb5d64	490	baz = DummyContext()
CM	491	bar = DummyContext(baz)
	492	foo = DummyContext(bar)
	493	root = DummyContext(foo)
	494	root.__parent__ = None
	495	root.__name__ = 'root'
	496	foo.__parent__ = root
	497	foo.__name__ = 'foo'
	498	bar.__parent__ = foo
	499	bar.__name__ = 'bar'
	500	baz.__parent__ = bar
	501	baz.__name__ = 'baz'
	502	from zope.interface import directlyProvides
	503	from zope.interface import Interface
0c29cf	504
bb5d64	505	class IFoo(Interface):
CM	506	pass
0c29cf	507
bb5d64	508	directlyProvides(root, IFoo)
eb6afe	509	result = self._callFUT(baz, IFoo)
bb5d64	510	self.assertEqual(result.__name__, 'root')
CM	511
0f5d8b	512	def test_it_class(self):
CM	513	class DummyRoot(object):
	514	def __init__(self, child):
	515	self.child = child
0c29cf	516
0f5d8b	517	baz = DummyContext()
CM	518	bar = DummyContext(baz)
	519	foo = DummyContext(bar)
	520	root = DummyRoot(foo)
	521	root.__parent__ = None
	522	root.__name__ = 'root'
	523	foo.__parent__ = root
	524	foo.__name__ = 'foo'
	525	bar.__parent__ = foo
	526	bar.__name__ = 'bar'
	527	baz.__parent__ = bar
	528	baz.__name__ = 'baz'
	529	result = self._callFUT(baz, DummyRoot)
	530	self.assertEqual(result.__name__, 'root')
	531
0c29cf	532
cc5e49	533	class FindRootTests(unittest.TestCase):
eb6afe	534	def _callFUT(self, context):
b60bdb	535	from pyramid.traversal import find_root
0c29cf	536
eb6afe	537	return find_root(context)
cc5e49	538
CM	539	def test_it(self):
	540	dummy = DummyContext()
	541	baz = DummyContext()
	542	baz.__parent__ = dummy
	543	baz.__name__ = 'baz'
	544	dummy.__parent__ = None
	545	dummy.__name__ = None
eb6afe	546	result = self._callFUT(baz)
cc5e49	547	self.assertEqual(result, dummy)
CM	548
0c29cf	549
92c3e5	550	class FindResourceTests(unittest.TestCase):
eb6afe	551	def _callFUT(self, context, name):
92c3e5	552	from pyramid.traversal import find_resource
0c29cf	553
92c3e5	554	return find_resource(context, name)
cc5e49	555
077c3c	556	def _registerTraverser(self, traverser):
b60bdb	557	from pyramid.threadlocal import get_current_registry
0c29cf	558
6fec21	559	reg = get_current_registry()
b60bdb	560	from pyramid.interfaces import ITraverser
cc5e49	561	from zope.interface import Interface
0c29cf	562
6fec21	563	reg.registerAdapter(traverser, (Interface,), ITraverser)
cc5e49	564
dbab77	565	def test_list(self):
92c3e5	566	resource = DummyContext()
0c29cf	567	traverser = make_traverser({'context': resource, 'view_name': ''})
077c3c	568	self._registerTraverser(traverser)
92c3e5	569	result = self._callFUT(resource, [''])
CM	570	self.assertEqual(result, resource)
	571	self.assertEqual(resource.request.environ['PATH_INFO'], '/')
dbab77	572
CM	573	def test_generator(self):
92c3e5	574	resource = DummyContext()
0c29cf	575	traverser = make_traverser({'context': resource, 'view_name': ''})
077c3c	576	self._registerTraverser(traverser)
0c29cf	577
dbab77	578	def foo():
CM	579	yield ''
0c29cf	580
92c3e5	581	result = self._callFUT(resource, foo())
CM	582	self.assertEqual(result, resource)
	583	self.assertEqual(resource.request.environ['PATH_INFO'], '/')
dbab77	584
CM	585	def test_self_string_found(self):
92c3e5	586	resource = DummyContext()
0c29cf	587	traverser = make_traverser({'context': resource, 'view_name': ''})
077c3c	588	self._registerTraverser(traverser)
92c3e5	589	result = self._callFUT(resource, '')
CM	590	self.assertEqual(result, resource)
	591	self.assertEqual(resource.request.environ['PATH_INFO'], '')
dbab77	592
CM	593	def test_self_tuple_found(self):
92c3e5	594	resource = DummyContext()
0c29cf	595	traverser = make_traverser({'context': resource, 'view_name': ''})
077c3c	596	self._registerTraverser(traverser)
92c3e5	597	result = self._callFUT(resource, ())
CM	598	self.assertEqual(result, resource)
	599	self.assertEqual(resource.request.environ['PATH_INFO'], '')
dbab77	600
CM	601	def test_relative_string_found(self):
92c3e5	602	resource = DummyContext()
cc5e49	603	baz = DummyContext()
0c29cf	604	traverser = make_traverser({'context': baz, 'view_name': ''})
077c3c	605	self._registerTraverser(traverser)
92c3e5	606	result = self._callFUT(resource, 'baz')
cc5e49	607	self.assertEqual(result, baz)
92c3e5	608	self.assertEqual(resource.request.environ['PATH_INFO'], 'baz')
cc5e49	609
dbab77	610	def test_relative_tuple_found(self):
92c3e5	611	resource = DummyContext()
dbab77	612	baz = DummyContext()
0c29cf	613	traverser = make_traverser({'context': baz, 'view_name': ''})
077c3c	614	self._registerTraverser(traverser)
92c3e5	615	result = self._callFUT(resource, ('baz',))
dbab77	616	self.assertEqual(result, baz)
92c3e5	617	self.assertEqual(resource.request.environ['PATH_INFO'], 'baz')
dbab77	618
CM	619	def test_relative_string_notfound(self):
92c3e5	620	resource = DummyContext()
cc5e49	621	baz = DummyContext()
0c29cf	622	traverser = make_traverser({'context': baz, 'view_name': 'bar'})
077c3c	623	self._registerTraverser(traverser)
92c3e5	624	self.assertRaises(KeyError, self._callFUT, resource, 'baz')
CM	625	self.assertEqual(resource.request.environ['PATH_INFO'], 'baz')
cc5e49	626
dbab77	627	def test_relative_tuple_notfound(self):
92c3e5	628	resource = DummyContext()
cc5e49	629	baz = DummyContext()
0c29cf	630	traverser = make_traverser({'context': baz, 'view_name': 'bar'})
077c3c	631	self._registerTraverser(traverser)
92c3e5	632	self.assertRaises(KeyError, self._callFUT, resource, ('baz',))
CM	633	self.assertEqual(resource.request.environ['PATH_INFO'], 'baz')
cc5e49	634
dbab77	635	def test_absolute_string_found(self):
CM	636	root = DummyContext()
92c3e5	637	resource = DummyContext()
CM	638	resource.__parent__ = root
	639	resource.__name__ = 'baz'
0c29cf	640	traverser = make_traverser({'context': root, 'view_name': ''})
077c3c	641	self._registerTraverser(traverser)
92c3e5	642	result = self._callFUT(resource, '/')
dbab77	643	self.assertEqual(result, root)
CM	644	self.assertEqual(root.wascontext, True)
6fec21	645	self.assertEqual(root.request.environ['PATH_INFO'], '/')
cc5e49	646
dbab77	647	def test_absolute_tuple_found(self):
CM	648	root = DummyContext()
92c3e5	649	resource = DummyContext()
CM	650	resource.__parent__ = root
	651	resource.__name__ = 'baz'
0c29cf	652	traverser = make_traverser({'context': root, 'view_name': ''})
077c3c	653	self._registerTraverser(traverser)
92c3e5	654	result = self._callFUT(resource, ('',))
dbab77	655	self.assertEqual(result, root)
CM	656	self.assertEqual(root.wascontext, True)
6fec21	657	self.assertEqual(root.request.environ['PATH_INFO'], '/')
dbab77	658
CM	659	def test_absolute_string_notfound(self):
	660	root = DummyContext()
92c3e5	661	resource = DummyContext()
CM	662	resource.__parent__ = root
	663	resource.__name__ = 'baz'
0c29cf	664	traverser = make_traverser({'context': root, 'view_name': 'fuz'})
077c3c	665	self._registerTraverser(traverser)
92c3e5	666	self.assertRaises(KeyError, self._callFUT, resource, '/')
dbab77	667	self.assertEqual(root.wascontext, True)
6fec21	668	self.assertEqual(root.request.environ['PATH_INFO'], '/')
dbab77	669
CM	670	def test_absolute_tuple_notfound(self):
	671	root = DummyContext()
92c3e5	672	resource = DummyContext()
CM	673	resource.__parent__ = root
	674	resource.__name__ = 'baz'
0c29cf	675	traverser = make_traverser({'context': root, 'view_name': 'fuz'})
077c3c	676	self._registerTraverser(traverser)
92c3e5	677	self.assertRaises(KeyError, self._callFUT, resource, ('',))
dbab77	678	self.assertEqual(root.wascontext, True)
6fec21	679	self.assertEqual(root.request.environ['PATH_INFO'], '/')
916f88	680
a66593	681	def test_absolute_unicode_found(self):
CM	682	# test for bug wiggy found in wild, traceback stack:
	683	# root = u'/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF'
92c3e5	684	# wiggy's code: section=find_resource(page, root)
CM	685	# find_resource L76: D = traverse(resource, path)
a66593	686	# traverse L291: return traverser(request)
CM	687	# __call__ line 568: vpath_tuple = traversal_path(vpath)
	688	# lru_cached line 91: f(*arg)
	689	# traversal_path line 443: path.encode('ascii')
	690	# UnicodeEncodeError: 'ascii' codec can't encode characters in
	691	# position 1-12: ordinal not in range(128)
	692	#
	693	# solution: encode string to ascii in pyramid.traversal.traverse
	694	# before passing it along to webob as path_info
92c3e5	695	from pyramid.traversal import ResourceTreeTraverser
0c29cf	696
a66593	697	unprintable = DummyContext()
CM	698	root = DummyContext(unprintable)
	699	unprintable.__parent__ = root
e6c2d2	700	unprintable.__name__ = text_(
0c29cf	701	b'/\xe6\xb5\x81\xe8\xa1\x8c\xe8\xb6\x8b\xe5\x8a\xbf', 'utf-8'
MM	702	)
a66593	703	root.__parent__ = None
CM	704	root.__name__ = None
92c3e5	705	traverser = ResourceTreeTraverser
a66593	706	self._registerTraverser(traverser)
e6c2d2	707	result = self._callFUT(
0c29cf	708	root, text_(b'/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF')
MM	709	)
a66593	710	self.assertEqual(result, unprintable)
0c29cf	711
358dc2	712
92c3e5	713	class ResourcePathTests(unittest.TestCase):
CM	714	def _callFUT(self, resource, *elements):
	715	from pyramid.traversal import resource_path
0c29cf	716
92c3e5	717	return resource_path(resource, *elements)
c750ba	718
CM	719	def test_it(self):
	720	baz = DummyContext()
	721	bar = DummyContext(baz)
	722	foo = DummyContext(bar)
	723	root = DummyContext(foo)
	724	root.__parent__ = None
	725	root.__name__ = None
	726	foo.__parent__ = root
	727	foo.__name__ = 'foo '
	728	bar.__parent__ = foo
	729	bar.__name__ = 'bar'
	730	baz.__parent__ = bar
	731	baz.__name__ = 'baz'
eb6afe	732	result = self._callFUT(baz, 'this/theotherthing', 'that')
a97a70	733	self.assertEqual(result, '/foo%20/bar/baz/this%2Ftheotherthing/that')
CM	734
	735	def test_root_default(self):
	736	root = DummyContext()
	737	root.__parent__ = None
	738	root.__name__ = None
	739	result = self._callFUT(root)
	740	self.assertEqual(result, '/')
8e037f	741
CM	742	def test_root_default_emptystring(self):
	743	root = DummyContext()
	744	root.__parent__ = None
	745	root.__name__ = ''
	746	result = self._callFUT(root)
	747	self.assertEqual(result, '/')
	748
	749	def test_root_object_nonnull_name_direct(self):
	750	root = DummyContext()
	751	root.__parent__ = None
	752	root.__name__ = 'flubadub'
	753	result = self._callFUT(root)
0c29cf	754	self.assertEqual(result, 'flubadub') # insane case
8e037f	755
CM	756	def test_root_object_nonnull_name_indirect(self):
	757	root = DummyContext()
	758	root.__parent__ = None
	759	root.__name__ = 'flubadub'
	760	other = DummyContext()
	761	other.__parent__ = root
	762	other.__name__ = 'barker'
	763	result = self._callFUT(other)
0c29cf	764	self.assertEqual(result, 'flubadub/barker') # insane case
8e037f	765
a97a70	766	def test_nonroot_default(self):
CM	767	root = DummyContext()
	768	root.__parent__ = None
	769	root.__name__ = None
	770	other = DummyContext()
	771	other.__parent__ = root
	772	other.__name__ = 'other'
	773	result = self._callFUT(other)
	774	self.assertEqual(result, '/other')
b1de62	775
CM	776	def test_path_with_None_itermediate_names(self):
	777	root = DummyContext()
	778	root.__parent__ = None
	779	root.__name__ = None
	780	other = DummyContext()
	781	other.__parent__ = root
	782	other.__name__ = None
	783	other2 = DummyContext()
	784	other2.__parent__ = other
	785	other2.__name__ = 'other2'
	786	result = self._callFUT(other2)
	787	self.assertEqual(result, '//other2')
a97a70	788
0c29cf	789
92c3e5	790	class ResourcePathTupleTests(unittest.TestCase):
CM	791	def _callFUT(self, resource, *elements):
	792	from pyramid.traversal import resource_path_tuple
0c29cf	793
92c3e5	794	return resource_path_tuple(resource, *elements)
a97a70	795
CM	796	def test_it(self):
	797	baz = DummyContext()
	798	bar = DummyContext(baz)
	799	foo = DummyContext(bar)
	800	root = DummyContext(foo)
	801	root.__parent__ = None
	802	root.__name__ = None
	803	foo.__parent__ = root
	804	foo.__name__ = 'foo '
	805	bar.__parent__ = foo
	806	bar.__name__ = 'bar'
	807	baz.__parent__ = bar
	808	baz.__name__ = 'baz'
	809	result = self._callFUT(baz, 'this/theotherthing', 'that')
0c29cf	810	self.assertEqual(
MM	811	result, ('', 'foo ', 'bar', 'baz', 'this/theotherthing', 'that')
	812	)
c750ba	813
eb6afe	814	def test_root_default(self):
6d4015	815	root = DummyContext()
CM	816	root.__parent__ = None
	817	root.__name__ = None
eb6afe	818	result = self._callFUT(root)
dbab77	819	self.assertEqual(result, ('',))
51c305	820
1db5c4	821	def test_root_default_emptystring_name(self):
CM	822	root = DummyContext()
	823	root.__parent__ = None
	824	root.__name__ = ''
	825	other = DummyContext()
	826	other.__parent__ = root
	827	other.__name__ = 'other'
	828	result = self._callFUT(other)
0c29cf	829	self.assertEqual(result, ('', 'other'))
1db5c4	830
eb6afe	831	def test_nonroot_default(self):
CM	832	root = DummyContext()
	833	root.__parent__ = None
	834	root.__name__ = None
	835	other = DummyContext()
	836	other.__parent__ = root
	837	other.__name__ = 'other'
	838	result = self._callFUT(other)
dbab77	839	self.assertEqual(result, ('', 'other'))
c750ba	840
b1de62	841	def test_path_with_None_itermediate_names(self):
CM	842	root = DummyContext()
	843	root.__parent__ = None
	844	root.__name__ = None
	845	other = DummyContext()
	846	other.__parent__ = root
	847	other.__name__ = None
	848	other2 = DummyContext()
	849	other2.__parent__ = other
	850	other2.__name__ = 'other2'
	851	result = self._callFUT(other2)
	852	self.assertEqual(result, ('', '', 'other2'))
	853
0c29cf	854
a97a70	855	class QuotePathSegmentTests(unittest.TestCase):
CM	856	def _callFUT(self, s):
b60bdb	857	from pyramid.traversal import quote_path_segment
0c29cf	858
a97a70	859	return quote_path_segment(s)
CM	860
	861	def test_unicode(self):
a84e17	862	la = text_(b'/La Pe\xc3\xb1a', 'utf-8')
a97a70	863	result = self._callFUT(la)
CM	864	self.assertEqual(result, '%2FLa%20Pe%C3%B1a')
	865
	866	def test_string(self):
	867	s = '/ hello!'
	868	result = self._callFUT(s)
f52759	869	self.assertEqual(result, '%2F%20hello!')
a97a70	870
fcbd7b	871	def test_int(self):
CM	872	s = 12345
	873	result = self._callFUT(s)
	874	self.assertEqual(result, '12345')
0c29cf	875
fcbd7b	876	def test_long(self):
475532	877	from pyramid.compat import long
fcbd7b	878	import sys
0c29cf	879
a84e17	880	s = long(sys.maxsize + 1)
fcbd7b	881	result = self._callFUT(s)
CM	882	expected = str(s)
	883	self.assertEqual(result, expected)
	884
	885	def test_other(self):
	886	class Foo(object):
	887	def __str__(self):
	888	return 'abc'
0c29cf	889
fcbd7b	890	s = Foo()
CM	891	result = self._callFUT(s)
	892	self.assertEqual(result, 'abc')
0c29cf	893
fcbd7b	894
118ea0	895	class ResourceURLTests(unittest.TestCase):
e62e47	896	def _makeOne(self, context, url):
CM	897	return self._getTargetClass()(context, url)
	898
	899	def _getTargetClass(self):
118ea0	900	from pyramid.traversal import ResourceURL
0c29cf	901
118ea0	902	return ResourceURL
e62e47	903
118ea0	904	def test_instance_conforms_to_IResourceURL(self):
CM	905	from pyramid.interfaces import IResourceURL
	906	from zope.interface.verify import verifyObject
0c29cf	907
118ea0	908	context = DummyContext()
CM	909	request = DummyRequest()
	910	verifyObject(IResourceURL, self._makeOne(context, request))
bac5b3	911
118ea0	912	def test_IResourceURL_attributes_with_vroot(self):
CM	913	from pyramid.interfaces import VH_ROOT_KEY
0c29cf	914
118ea0	915	root = DummyContext()
CM	916	root.__parent__ = None
	917	root.__name__ = None
	918	one = DummyContext()
	919	one.__parent__ = root
	920	one.__name__ = 'one'
	921	two = DummyContext()
	922	two.__parent__ = one
	923	two.__name__ = 'two'
0c29cf	924	environ = {VH_ROOT_KEY: '/one'}
118ea0	925	request = DummyRequest(environ)
CM	926	context_url = self._makeOne(two, request)
	927	self.assertEqual(context_url.physical_path, '/one/two/')
	928	self.assertEqual(context_url.virtual_path, '/two/')
0c29cf	929	self.assertEqual(
MM	930	context_url.physical_path_tuple, ('', 'one', 'two', '')
	931	)
db0185	932	self.assertEqual(context_url.virtual_path_tuple, ('', 'two', ''))
0c29cf	933
db0185	934	def test_IResourceURL_attributes_vroot_ends_with_slash(self):
CM	935	from pyramid.interfaces import VH_ROOT_KEY
0c29cf	936
db0185	937	root = DummyContext()
CM	938	root.__parent__ = None
	939	root.__name__ = None
	940	one = DummyContext()
	941	one.__parent__ = root
	942	one.__name__ = 'one'
	943	two = DummyContext()
	944	two.__parent__ = one
	945	two.__name__ = 'two'
0c29cf	946	environ = {VH_ROOT_KEY: '/one/'}
db0185	947	request = DummyRequest(environ)
CM	948	context_url = self._makeOne(two, request)
	949	self.assertEqual(context_url.physical_path, '/one/two/')
	950	self.assertEqual(context_url.virtual_path, '/two/')
0c29cf	951	self.assertEqual(
MM	952	context_url.physical_path_tuple, ('', 'one', 'two', '')
	953	)
db0185	954	self.assertEqual(context_url.virtual_path_tuple, ('', 'two', ''))
0c29cf	955
118ea0	956	def test_IResourceURL_attributes_no_vroot(self):
CM	957	root = DummyContext()
	958	root.__parent__ = None
	959	root.__name__ = None
	960	one = DummyContext()
	961	one.__parent__ = root
	962	one.__name__ = 'one'
	963	two = DummyContext()
	964	two.__parent__ = one
	965	two.__name__ = 'two'
	966	environ = {}
	967	request = DummyRequest(environ)
	968	context_url = self._makeOne(two, request)
	969	self.assertEqual(context_url.physical_path, '/one/two/')
	970	self.assertEqual(context_url.virtual_path, '/one/two/')
0c29cf	971	self.assertEqual(
MM	972	context_url.physical_path_tuple, ('', 'one', 'two', '')
	973	)
	974	self.assertEqual(
	975	context_url.virtual_path_tuple, ('', 'one', 'two', '')
	976	)
	977
db0185	978
e62e47	979	class TestVirtualRoot(unittest.TestCase):
CM	980	def setUp(self):
	981	cleanUp()
	982
	983	def tearDown(self):
	984	cleanUp()
	985
92c3e5	986	def _callFUT(self, resource, request):
b60bdb	987	from pyramid.traversal import virtual_root
0c29cf	988
92c3e5	989	return virtual_root(resource, request)
e62e47	990
7ba907	991	def _registerTraverser(self, traverser):
MM	992	from pyramid.threadlocal import get_current_registry
0c29cf	993
7ba907	994	reg = get_current_registry()
MM	995	from pyramid.interfaces import ITraverser
e62e47	996	from zope.interface import Interface
0c29cf	997
7ba907	998	reg.registerAdapter(traverser, (Interface,), ITraverser)
MM	999
	1000	def test_virtual_root_no_virtual_root_path(self):
	1001	root = DummyContext()
	1002	root.__name__ = None
	1003	root.__parent__ = None
	1004	one = DummyContext()
	1005	one.__name__ = 'one'
	1006	one.__parent__ = root
	1007	request = DummyRequest()
	1008	result = self._callFUT(one, request)
	1009	self.assertEqual(result, root)
	1010
	1011	def test_virtual_root_no_virtual_root_path_with_root_on_request(self):
e62e47	1012	context = DummyContext()
7ba907	1013	context.__parent__ = None
MM	1014	request = DummyRequest()
	1015	request.root = DummyContext()
e62e47	1016	result = self._callFUT(context, request)
7ba907	1017	self.assertEqual(result, request.root)
MM	1018
	1019	def test_virtual_root_with_virtual_root_path(self):
	1020	from pyramid.interfaces import VH_ROOT_KEY
0c29cf	1021
7ba907	1022	root = DummyContext()
MM	1023	root.__parent__ = None
	1024	context = DummyContext()
	1025	context.__name__ = 'one'
	1026	context.__parent__ = root
	1027	traversed_to = DummyContext()
0c29cf	1028	environ = {VH_ROOT_KEY: '/one'}
7ba907	1029	request = DummyRequest(environ)
0c29cf	1030	traverser = make_traverser({'context': traversed_to, 'view_name': ''})
7ba907	1031	self._registerTraverser(traverser)
MM	1032	result = self._callFUT(context, request)
	1033	self.assertEqual(result, traversed_to)
	1034	self.assertEqual(root.request.environ['PATH_INFO'], '/one')
e62e47	1035
160f01	1036	def test_default(self):
CM	1037	context = DummyContext()
6fec21	1038	request = _makeRequest()
160f01	1039	request.environ['PATH_INFO'] = '/'
CM	1040	result = self._callFUT(context, request)
	1041	self.assertEqual(result, context)
	1042
45d08c	1043	def test_default_no_registry_on_request(self):
CM	1044	context = DummyContext()
	1045	request = _makeRequest()
	1046	del request.registry
	1047	request.environ['PATH_INFO'] = '/'
	1048	result = self._callFUT(context, request)
	1049	self.assertEqual(result, context)
	1050
0c29cf	1051
916f88	1052	class TraverseTests(unittest.TestCase):
CM	1053	def setUp(self):
	1054	cleanUp()
	1055
	1056	def tearDown(self):
	1057	cleanUp()
	1058
	1059	def _callFUT(self, context, name):
b60bdb	1060	from pyramid.traversal import traverse
0c29cf	1061
916f88	1062	return traverse(context, name)
CM	1063
077c3c	1064	def _registerTraverser(self, traverser):
b60bdb	1065	from pyramid.threadlocal import get_current_registry
0c29cf	1066
6fec21	1067	reg = get_current_registry()
b60bdb	1068	from pyramid.interfaces import ITraverser
916f88	1069	from zope.interface import Interface
0c29cf	1070
6fec21	1071	reg.registerAdapter(traverser, (Interface,), ITraverser)
CM	1072
	1073	def test_request_has_registry(self):
b60bdb	1074	from pyramid.threadlocal import get_current_registry
0c29cf	1075
92c3e5	1076	resource = DummyContext()
0c29cf	1077	traverser = make_traverser({'context': resource, 'view_name': ''})
6fec21	1078	self._registerTraverser(traverser)
92c3e5	1079	self._callFUT(resource, [''])
CM	1080	self.assertEqual(resource.request.registry, get_current_registry())
916f88	1081
CM	1082	def test_list(self):
92c3e5	1083	resource = DummyContext()
0c29cf	1084	traverser = make_traverser({'context': resource, 'view_name': ''})
077c3c	1085	self._registerTraverser(traverser)
92c3e5	1086	self._callFUT(resource, [''])
CM	1087	self.assertEqual(resource.request.environ['PATH_INFO'], '/')
916f88	1088
CM	1089	def test_generator(self):
92c3e5	1090	resource = DummyContext()
0c29cf	1091	traverser = make_traverser({'context': resource, 'view_name': ''})
077c3c	1092	self._registerTraverser(traverser)
0c29cf	1093
916f88	1094	def foo():
CM	1095	yield ''
0c29cf	1096
92c3e5	1097	self._callFUT(resource, foo())
CM	1098	self.assertEqual(resource.request.environ['PATH_INFO'], '/')
916f88	1099
CM	1100	def test_self_string_found(self):
92c3e5	1101	resource = DummyContext()
0c29cf	1102	traverser = make_traverser({'context': resource, 'view_name': ''})
077c3c	1103	self._registerTraverser(traverser)
92c3e5	1104	self._callFUT(resource, '')
CM	1105	self.assertEqual(resource.request.environ['PATH_INFO'], '')
916f88	1106
f84147	1107	def test_self_unicode_found(self):
CM	1108	resource = DummyContext()
0c29cf	1109	traverser = make_traverser({'context': resource, 'view_name': ''})
f84147	1110	self._registerTraverser(traverser)
CM	1111	self._callFUT(resource, text_(''))
	1112	self.assertEqual(resource.request.environ['PATH_INFO'], '')
	1113
916f88	1114	def test_self_tuple_found(self):
92c3e5	1115	resource = DummyContext()
0c29cf	1116	traverser = make_traverser({'context': resource, 'view_name': ''})
077c3c	1117	self._registerTraverser(traverser)
92c3e5	1118	self._callFUT(resource, ())
CM	1119	self.assertEqual(resource.request.environ['PATH_INFO'], '')
916f88	1120
CM	1121	def test_relative_string_found(self):
92c3e5	1122	resource = DummyContext()
916f88	1123	baz = DummyContext()
0c29cf	1124	traverser = make_traverser({'context': baz, 'view_name': ''})
077c3c	1125	self._registerTraverser(traverser)
92c3e5	1126	self._callFUT(resource, 'baz')
CM	1127	self.assertEqual(resource.request.environ['PATH_INFO'], 'baz')
916f88	1128
CM	1129	def test_relative_tuple_found(self):
92c3e5	1130	resource = DummyContext()
916f88	1131	baz = DummyContext()
0c29cf	1132	traverser = make_traverser({'context': baz, 'view_name': ''})
077c3c	1133	self._registerTraverser(traverser)
92c3e5	1134	self._callFUT(resource, ('baz',))
CM	1135	self.assertEqual(resource.request.environ['PATH_INFO'], 'baz')
916f88	1136
CM	1137	def test_absolute_string_found(self):
	1138	root = DummyContext()
92c3e5	1139	resource = DummyContext()
CM	1140	resource.__parent__ = root
	1141	resource.__name__ = 'baz'
0c29cf	1142	traverser = make_traverser({'context': root, 'view_name': ''})
077c3c	1143	self._registerTraverser(traverser)
92c3e5	1144	self._callFUT(resource, '/')
916f88	1145	self.assertEqual(root.wascontext, True)
6fec21	1146	self.assertEqual(root.request.environ['PATH_INFO'], '/')
916f88	1147
CM	1148	def test_absolute_tuple_found(self):
	1149	root = DummyContext()
92c3e5	1150	resource = DummyContext()
CM	1151	resource.__parent__ = root
	1152	resource.__name__ = 'baz'
0c29cf	1153	traverser = make_traverser({'context': root, 'view_name': ''})
077c3c	1154	self._registerTraverser(traverser)
92c3e5	1155	self._callFUT(resource, ('',))
916f88	1156	self.assertEqual(root.wascontext, True)
6fec21	1157	self.assertEqual(root.request.environ['PATH_INFO'], '/')
916f88	1158
391afe	1159	def test_empty_sequence(self):
CM	1160	root = DummyContext()
92c3e5	1161	resource = DummyContext()
CM	1162	resource.__parent__ = root
	1163	resource.__name__ = 'baz'
0c29cf	1164	traverser = make_traverser({'context': root, 'view_name': ''})
077c3c	1165	self._registerTraverser(traverser)
92c3e5	1166	self._callFUT(resource, [])
CM	1167	self.assertEqual(resource.wascontext, True)
	1168	self.assertEqual(resource.request.environ['PATH_INFO'], '')
391afe	1169
164677	1170	def test_default_traverser(self):
92c3e5	1171	resource = DummyContext()
CM	1172	result = self._callFUT(resource, '')
e46105	1173	self.assertEqual(result['view_name'], '')
92c3e5	1174	self.assertEqual(result['context'], resource)
c32af0	1175
81a833	1176	def test_requestfactory_overridden(self):
b60bdb	1177	from pyramid.interfaces import IRequestFactory
CM	1178	from pyramid.request import Request
	1179	from pyramid.threadlocal import get_current_registry
0c29cf	1180
81a833	1181	reg = get_current_registry()
0c29cf	1182
81a833	1183	class MyRequest(Request):
CM	1184	pass
0c29cf	1185
81a833	1186	reg.registerUtility(MyRequest, IRequestFactory)
92c3e5	1187	resource = DummyContext()
0c29cf	1188	traverser = make_traverser({'context': resource, 'view_name': ''})
81a833	1189	self._registerTraverser(traverser)
92c3e5	1190	self._callFUT(resource, [''])
CM	1191	self.assertEqual(resource.request.__class__, MyRequest)
81a833	1192
0c29cf	1193
eac7c4	1194	class TestDefaultRootFactory(unittest.TestCase):
CM	1195	def _getTargetClass(self):
b60bdb	1196	from pyramid.traversal import DefaultRootFactory
0c29cf	1197
eac7c4	1198	return DefaultRootFactory
CM	1199
	1200	def _makeOne(self, environ):
	1201	return self._getTargetClass()(environ)
	1202
95e971	1203	def test_it(self):
CM	1204	class DummyRequest(object):
	1205	pass
0c29cf	1206
51c305	1207	root = self._makeOne(DummyRequest())
eac7c4	1208	self.assertEqual(root.__parent__, None)
CM	1209	self.assertEqual(root.__name__, None)
	1210
0c29cf	1211
1db5c4	1212	class Test__join_path_tuple(unittest.TestCase):
CM	1213	def _callFUT(self, tup):
	1214	from pyramid.traversal import _join_path_tuple
0c29cf	1215
1db5c4	1216	return _join_path_tuple(tup)
CM	1217
	1218	def test_empty_tuple(self):
	1219	# tests "or '/'" case
	1220	result = self._callFUT(())
	1221	self.assertEqual(result, '/')
	1222
	1223	def test_nonempty_tuple(self):
	1224	result = self._callFUT(('x',))
	1225	self.assertEqual(result, 'x')
eac7c4	1226
f52759	1227	def test_segments_with_unsafes(self):
0c29cf	1228	safe_segments = tuple(
10ddb6	1229	u"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
MM	1230	u"-._~!$&'()*+,;=:@"
0c29cf	1231	)
f52759	1232	result = self._callFUT(safe_segments)
MK	1233	self.assertEqual(result, u'/'.join(safe_segments))
0c29cf	1234	unsafe_segments = tuple(
MM	1235	chr(i) for i in range(0x20, 0x80) if not chr(i) in safe_segments
	1236	) + (u'あ',)
f52759	1237	result = self._callFUT(unsafe_segments)
0c29cf	1238	self.assertEqual(
MM	1239	result,
	1240	u'/'.join(
	1241	''.join(
	1242	'%%%02X' % (ord(c) if isinstance(c, str) else c)
	1243	for c in unsafe_segment.encode('utf-8')
	1244	)
	1245	for unsafe_segment in unsafe_segments
	1246	),
	1247	)
f52759	1248
MK	1249
916f88	1250	def make_traverser(result):
cc5e49	1251	class DummyTraverser(object):
CM	1252	def __init__(self, context):
358dc2	1253	self.context = context
cc5e49	1254	context.wascontext = True
0c29cf	1255
6fec21	1256	def __call__(self, request):
CM	1257	self.context.request = request
916f88	1258	return result
0c29cf	1259
cc5e49	1260	return DummyTraverser
0c29cf	1261
51c305	1262
e60985	1263	class DummyContext(object):
dbab77	1264	__parent__ = None
0c29cf	1265
7fc6a3	1266	def __init__(self, next=None, name=None):
8b2c67	1267	self.next = next
7fc6a3	1268	self.__name__ = name
51c305	1269
8b2c67	1270	def __getitem__(self, name):
CM	1271	if self.next is None:
e6c2d2	1272	raise KeyError(name)
8b2c67	1273	return self.next
7de404	1274
7fc6a3	1275	def __repr__(self):
0c29cf	1276	return '<DummyContext with name %s at id %s>' % (
MM	1277	self.__name__,
	1278	id(self),
	1279	)
	1280
7fc6a3	1281
7de404	1282	class DummyRequest:
def68d	1283
0c29cf	1284	application_url = (
MM	1285	'http://example.com:5432'
	1286	) # app_url never ends with slash
def68d	1287	matchdict = None
CM	1288	matched_route = None
	1289
ebcdc7	1290	def __init__(self, environ=None, path_info=text_('/'), toraise=None):
e62e47	1291	if environ is None:
CM	1292	environ = {}
	1293	self.environ = environ
def68d	1294	self._set_path_info(path_info)
CM	1295	self.toraise = toraise
	1296
	1297	def _get_path_info(self):
	1298	if self.toraise:
	1299	raise self.toraise
	1300	return self._path_info
	1301
	1302	def _set_path_info(self, v):
	1303	self._path_info = v
	1304
	1305	path_info = property(_get_path_info, _set_path_info)
0c29cf	1306
dfc2b6	1307
6fec21	1308	def _makeRequest(environ=None):
b60bdb	1309	from pyramid.registry import Registry
0c29cf	1310
6fec21	1311	request = DummyRequest()
CM	1312	request.registry = Registry()
	1313	return request