RedHatTraining/pyramid.git

Michael Merickel

2018-10-15 2b024920847481592b1a13d4006d2a9fa8881d72

commit \| author \| age
8064bd	1	import os
7ae0c2	2	import unittest
c51896	3	import warnings
7ae0c2	4
a00621	5	from pyramid import testing
CM	6
f5b9e9	7	from pyramid.compat import (
CM	8	text_,
8064bd	9	WIN,
f5b9e9	10	)
925957	11
fb90f0	12	class TestURLMethodsMixin(unittest.TestCase):
e62e47	13	def setUp(self):
a00621	14	self.config = testing.setUp()
e62e47	15
CM	16	def tearDown(self):
a00621	17	testing.tearDown()
e62e47	18
c51896	19	def _makeOne(self, environ=None):
fb90f0	20	from pyramid.url import URLMethodsMixin
c51896	21	if environ is None:
CM	22	environ = {}
fb90f0	23	class Request(URLMethodsMixin):
CM	24	application_url = 'http://example.com:5432'
c51896	25	script_name = ''
CM	26	def __init__(self, environ):
	27	self.environ = environ
	28	request = Request(environ)
fb90f0	29	request.registry = self.config.registry
CM	30	return request
7ae0c2	31
c51896	32	def _registerResourceURL(self, reg):
CM	33	from pyramid.interfaces import IResourceURL
	34	from zope.interface import Interface
	35	class DummyResourceURL(object):
60aeef	36	physical_path = '/context/'
CM	37	virtual_path = '/context/'
	38	def __init__(self, context, request): pass
c51896	39	reg.registerAdapter(DummyResourceURL, (Interface, Interface),
CM	40	IResourceURL)
60aeef	41	return DummyResourceURL
c51896	42
fb90f0	43	def test_resource_url_root_default(self):
CM	44	request = self._makeOne()
c51896	45	self._registerResourceURL(request.registry)
7ae0c2	46	root = DummyContext()
fb90f0	47	result = request.resource_url(root)
c51896	48	self.assertEqual(result, 'http://example.com:5432/context/')
7ae0c2	49
fb90f0	50	def test_resource_url_extra_args(self):
CM	51	request = self._makeOne()
c51896	52	self._registerResourceURL(request.registry)
e62e47	53	context = DummyContext()
fb90f0	54	result = request.resource_url(context, 'this/theotherthing', 'that')
e62e47	55	self.assertEqual(
CM	56	result,
c51896	57	'http://example.com:5432/context/this%2Ftheotherthing/that')
7ae0c2	58
fb90f0	59	def test_resource_url_unicode_in_element_names(self):
CM	60	request = self._makeOne()
c51896	61	self._registerResourceURL(request.registry)
a84e17	62	uc = text_(b'La Pe\xc3\xb1a', 'utf-8')
e62e47	63	context = DummyContext()
fb90f0	64	result = request.resource_url(context, uc)
7ae0c2	65	self.assertEqual(result,
c51896	66	'http://example.com:5432/context/La%20Pe%C3%B1a')
7ae0c2	67
fb90f0	68	def test_resource_url_at_sign_in_element_names(self):
CM	69	request = self._makeOne()
c51896	70	self._registerResourceURL(request.registry)
ab19ea	71	context = DummyContext()
fb90f0	72	result = request.resource_url(context, '@@myview')
ab19ea	73	self.assertEqual(result,
c51896	74	'http://example.com:5432/context/@@myview')
ab19ea	75
fb90f0	76	def test_resource_url_element_names_url_quoted(self):
CM	77	request = self._makeOne()
c51896	78	self._registerResourceURL(request.registry)
e62e47	79	context = DummyContext()
fb90f0	80	result = request.resource_url(context, 'a b c')
c51896	81	self.assertEqual(result, 'http://example.com:5432/context/a%20b%20c')
7ae0c2	82
e967a9	83	def test_resource_url_with_query_str(self):
MM	84	request = self._makeOne()
	85	self._registerResourceURL(request.registry)
	86	context = DummyContext()
	87	result = request.resource_url(context, 'a', query='(openlayers)')
	88	self.assertEqual(result,
af3134	89	'http://example.com:5432/context/a?(openlayers)')
e967a9	90
fb90f0	91	def test_resource_url_with_query_dict(self):
CM	92	request = self._makeOne()
c51896	93	self._registerResourceURL(request.registry)
e62e47	94	context = DummyContext()
a84e17	95	uc = text_(b'La Pe\xc3\xb1a', 'utf-8')
fb90f0	96	result = request.resource_url(context, 'a', query={'a':uc})
7dbf40	97	self.assertEqual(result,
c51896	98	'http://example.com:5432/context/a?a=La+Pe%C3%B1a')
7ae0c2	99
fb90f0	100	def test_resource_url_with_query_seq(self):
CM	101	request = self._makeOne()
c51896	102	self._registerResourceURL(request.registry)
e62e47	103	context = DummyContext()
a84e17	104	uc = text_(b'La Pe\xc3\xb1a', 'utf-8')
fb90f0	105	result = request.resource_url(context, 'a', query=[('a', 'hi there'),
a84e17	106	('b', uc)])
7dbf40	107	self.assertEqual(result,
c51896	108	'http://example.com:5432/context/a?a=hi+there&b=La+Pe%C3%B1a')
7ae0c2	109
0e0c83	110	def test_resource_url_with_query_empty(self):
CL	111	request = self._makeOne()
	112	self._registerResourceURL(request.registry)
	113	context = DummyContext()
	114	result = request.resource_url(context, 'a', query=[])
	115	self.assertEqual(result,
	116	'http://example.com:5432/context/a')
	117
effe0e	118	def test_resource_url_with_query_None(self):
MM	119	request = self._makeOne()
	120	self._registerResourceURL(request.registry)
	121	context = DummyContext()
	122	result = request.resource_url(context, 'a', query=None)
	123	self.assertEqual(result,
	124	'http://example.com:5432/context/a')
	125
fb90f0	126	def test_resource_url_anchor_is_after_root_when_no_elements(self):
CM	127	request = self._makeOne()
c51896	128	self._registerResourceURL(request.registry)
e693ce	129	context = DummyContext()
fb90f0	130	result = request.resource_url(context, anchor='a')
e693ce	131	self.assertEqual(result,
c51896	132	'http://example.com:5432/context/#a')
e693ce	133
fb90f0	134	def test_resource_url_anchor_is_after_elements_when_no_qs(self):
CM	135	request = self._makeOne()
c51896	136	self._registerResourceURL(request.registry)
e693ce	137	context = DummyContext()
fb90f0	138	result = request.resource_url(context, 'a', anchor='b')
e693ce	139	self.assertEqual(result,
c51896	140	'http://example.com:5432/context/a#b')
e693ce	141
fb90f0	142	def test_resource_url_anchor_is_after_qs_when_qs_is_present(self):
CM	143	request = self._makeOne()
c51896	144	self._registerResourceURL(request.registry)
e693ce	145	context = DummyContext()
fb90f0	146	result = request.resource_url(context, 'a',
CM	147	query={'b':'c'}, anchor='d')
e693ce	148	self.assertEqual(result,
c51896	149	'http://example.com:5432/context/a?b=c#d')
e693ce	150
fb90f0	151	def test_resource_url_anchor_is_encoded_utf8_if_unicode(self):
CM	152	request = self._makeOne()
c51896	153	self._registerResourceURL(request.registry)
e693ce	154	context = DummyContext()
fc30e8	155	uc = text_(b'La Pe\xc3\xb1a', 'utf-8')
fb90f0	156	result = request.resource_url(context, anchor=uc)
fc30e8	157	self.assertEqual(result,
22f0eb	158	'http://example.com:5432/context/#La%20Pe%C3%B1a')
e693ce	159
af3134	160	def test_resource_url_anchor_is_urlencoded_safe(self):
fb90f0	161	request = self._makeOne()
c51896	162	self._registerResourceURL(request.registry)
e693ce	163	context = DummyContext()
af3134	164	result = request.resource_url(context, anchor=' /#?&+')
e693ce	165	self.assertEqual(result,
22f0eb	166	'http://example.com:5432/context/#%20/%23?&+')
effe0e	167
MM	168	def test_resource_url_anchor_is_None(self):
	169	request = self._makeOne()
	170	self._registerResourceURL(request.registry)
	171	context = DummyContext()
	172	result = request.resource_url(context, anchor=None)
	173	self.assertEqual(result, 'http://example.com:5432/context/')
e693ce	174
c51896	175	def test_resource_url_no_IResourceURL_registered(self):
CM	176	# falls back to ResourceURL
21ad66	177	root = DummyContext()
CM	178	root.__name__ = ''
	179	root.__parent__ = None
fb90f0	180	request = self._makeOne()
21ad66	181	request.environ = {}
fb90f0	182	result = request.resource_url(root)
21ad66	183	self.assertEqual(result, 'http://example.com:5432/')
CM	184
fb90f0	185	def test_resource_url_no_registry_on_request(self):
CM	186	request = self._makeOne()
c51896	187	self._registerResourceURL(request.registry)
fb90f0	188	del request.registry
45d08c	189	root = DummyContext()
fb90f0	190	result = request.resource_url(root)
c51896	191	self.assertEqual(result, 'http://example.com:5432/context/')
CM	192
	193	def test_resource_url_with_app_url(self):
	194	request = self._makeOne()
	195	self._registerResourceURL(request.registry)
	196	root = DummyContext()
	197	result = request.resource_url(root, app_url='http://somewhere.com')
	198	self.assertEqual(result, 'http://somewhere.com/context/')
	199
	200	def test_resource_url_with_scheme(self):
	201	environ = {
	202	'wsgi.url_scheme':'http',
	203	'SERVER_PORT':'8080',
	204	'SERVER_NAME':'example.com',
	205	}
	206	request = self._makeOne(environ)
	207	self._registerResourceURL(request.registry)
	208	root = DummyContext()
	209	result = request.resource_url(root, scheme='https')
	210	self.assertEqual(result, 'https://example.com/context/')
	211
	212	def test_resource_url_with_host(self):
	213	environ = {
	214	'wsgi.url_scheme':'http',
	215	'SERVER_PORT':'8080',
	216	'SERVER_NAME':'example.com',
	217	}
	218	request = self._makeOne(environ)
	219	self._registerResourceURL(request.registry)
	220	root = DummyContext()
	221	result = request.resource_url(root, host='someotherhost.com')
	222	self.assertEqual(result, 'http://someotherhost.com:8080/context/')
	223
	224	def test_resource_url_with_port(self):
	225	environ = {
	226	'wsgi.url_scheme':'http',
	227	'SERVER_PORT':'8080',
	228	'SERVER_NAME':'example.com',
	229	}
	230	request = self._makeOne(environ)
	231	self._registerResourceURL(request.registry)
	232	root = DummyContext()
	233	result = request.resource_url(root, port='8181')
	234	self.assertEqual(result, 'http://example.com:8181/context/')
	235
	236	def test_resource_url_with_local_url(self):
	237	environ = {
	238	'wsgi.url_scheme':'http',
	239	'SERVER_PORT':'8080',
	240	'SERVER_NAME':'example.com',
	241	}
	242	request = self._makeOne(environ)
	243	self._registerResourceURL(request.registry)
	244	root = DummyContext()
	245	def resource_url(req, info):
	246	self.assertEqual(req, request)
	247	self.assertEqual(info['virtual_path'], '/context/')
	248	self.assertEqual(info['physical_path'], '/context/')
	249	self.assertEqual(info['app_url'], 'http://example.com:5432')
	250	return 'http://example.com/contextabc/'
	251	root.__resource_url__ = resource_url
	252	result = request.resource_url(root)
	253	self.assertEqual(result, 'http://example.com/contextabc/')
60aeef	254
CM	255	def test_resource_url_with_route_name_no_remainder_on_adapter(self):
	256	from pyramid.interfaces import IRoutesMapper
	257	environ = {
	258	'wsgi.url_scheme':'http',
	259	'SERVER_PORT':'8080',
	260	'SERVER_NAME':'example.com',
	261	}
	262	request = self._makeOne(environ)
	263	adapter = self._registerResourceURL(request.registry)
	264	# no virtual_path_tuple on adapter
	265	adapter.virtual_path = '/a/b/c/'
	266	route = DummyRoute('/1/2/3')
	267	mapper = DummyRoutesMapper(route)
	268	request.registry.registerUtility(mapper, IRoutesMapper)
	269	root = DummyContext()
	270	result = request.resource_url(root, route_name='foo')
	271	self.assertEqual(result, 'http://example.com:5432/1/2/3')
c29603	272	self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')})
60aeef	273
CM	274	def test_resource_url_with_route_name_remainder_on_adapter(self):
	275	from pyramid.interfaces import IRoutesMapper
	276	environ = {
	277	'wsgi.url_scheme':'http',
	278	'SERVER_PORT':'8080',
	279	'SERVER_NAME':'example.com',
	280	}
	281	request = self._makeOne(environ)
	282	adapter = self._registerResourceURL(request.registry)
	283	# virtual_path_tuple on adapter
	284	adapter.virtual_path_tuple = ('', 'a', 'b', 'c', '')
	285	route = DummyRoute('/1/2/3')
	286	mapper = DummyRoutesMapper(route)
	287	request.registry.registerUtility(mapper, IRoutesMapper)
	288	root = DummyContext()
	289	result = request.resource_url(root, route_name='foo')
	290	self.assertEqual(result, 'http://example.com:5432/1/2/3')
c29603	291	self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')})
60aeef	292
CM	293	def test_resource_url_with_route_name_and_app_url(self):
	294	from pyramid.interfaces import IRoutesMapper
	295	environ = {
	296	'wsgi.url_scheme':'http',
	297	'SERVER_PORT':'8080',
	298	'SERVER_NAME':'example.com',
	299	}
	300	request = self._makeOne(environ)
	301	adapter = self._registerResourceURL(request.registry)
	302	# virtual_path_tuple on adapter
	303	adapter.virtual_path_tuple = ('', 'a', 'b', 'c', '')
	304	route = DummyRoute('/1/2/3')
	305	mapper = DummyRoutesMapper(route)
	306	request.registry.registerUtility(mapper, IRoutesMapper)
	307	root = DummyContext()
	308	result = request.resource_url(root, route_name='foo', app_url='app_url')
	309	self.assertEqual(result, 'app_url/1/2/3')
c29603	310	self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')})
60aeef	311
CM	312	def test_resource_url_with_route_name_and_scheme_host_port_etc(self):
	313	from pyramid.interfaces import IRoutesMapper
	314	environ = {
	315	'wsgi.url_scheme':'http',
	316	'SERVER_PORT':'8080',
	317	'SERVER_NAME':'example.com',
	318	}
	319	request = self._makeOne(environ)
	320	adapter = self._registerResourceURL(request.registry)
	321	# virtual_path_tuple on adapter
	322	adapter.virtual_path_tuple = ('', 'a', 'b', 'c', '')
	323	route = DummyRoute('/1/2/3')
	324	mapper = DummyRoutesMapper(route)
	325	request.registry.registerUtility(mapper, IRoutesMapper)
	326	root = DummyContext()
	327	result = request.resource_url(root, route_name='foo', scheme='scheme',
	328	host='host', port='port', query={'a':'1'},
	329	anchor='anchor')
	330	self.assertEqual(result, 'scheme://host:port/1/2/3?a=1#anchor')
c29603	331	self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')})
60aeef	332
CM	333	def test_resource_url_with_route_name_and_route_kwargs(self):
	334	from pyramid.interfaces import IRoutesMapper
	335	environ = {
	336	'wsgi.url_scheme':'http',
	337	'SERVER_PORT':'8080',
	338	'SERVER_NAME':'example.com',
	339	}
	340	request = self._makeOne(environ)
	341	adapter = self._registerResourceURL(request.registry)
	342	# virtual_path_tuple on adapter
	343	adapter.virtual_path_tuple = ('', 'a', 'b', 'c', '')
	344	route = DummyRoute('/1/2/3')
	345	mapper = DummyRoutesMapper(route)
	346	request.registry.registerUtility(mapper, IRoutesMapper)
	347	root = DummyContext()
	348	result = request.resource_url(
	349	root, route_name='foo', route_kw={'a':'1', 'b':'2'})
	350	self.assertEqual(result, 'http://example.com:5432/1/2/3')
	351	self.assertEqual(
	352	route.kw,
c29603	353	{'traverse': ('', 'a', 'b', 'c', ''),
60aeef	354	'a':'1',
CM	355	'b':'2'}
	356	)
	357
	358	def test_resource_url_with_route_name_and_elements(self):
	359	from pyramid.interfaces import IRoutesMapper
	360	environ = {
	361	'wsgi.url_scheme':'http',
	362	'SERVER_PORT':'8080',
	363	'SERVER_NAME':'example.com',
	364	}
	365	request = self._makeOne(environ)
	366	adapter = self._registerResourceURL(request.registry)
	367	# virtual_path_tuple on adapter
	368	adapter.virtual_path_tuple = ('', 'a', 'b', 'c', '')
	369	route = DummyRoute('/1/2/3')
	370	mapper = DummyRoutesMapper(route)
	371	request.registry.registerUtility(mapper, IRoutesMapper)
	372	root = DummyContext()
	373	result = request.resource_url(root, 'e1', 'e2', route_name='foo')
	374	self.assertEqual(result, 'http://example.com:5432/1/2/3/e1/e2')
c29603	375	self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')})
CM	376
	377	def test_resource_url_with_route_name_and_remainder_name(self):
	378	from pyramid.interfaces import IRoutesMapper
	379	environ = {
	380	'wsgi.url_scheme':'http',
	381	'SERVER_PORT':'8080',
	382	'SERVER_NAME':'example.com',
	383	}
	384	request = self._makeOne(environ)
	385	adapter = self._registerResourceURL(request.registry)
	386	# virtual_path_tuple on adapter
	387	adapter.virtual_path_tuple = ('', 'a', 'b', 'c', '')
	388	route = DummyRoute('/1/2/3')
	389	mapper = DummyRoutesMapper(route)
	390	request.registry.registerUtility(mapper, IRoutesMapper)
	391	root = DummyContext()
	392	result = request.resource_url(root, route_name='foo',
	393	route_remainder_name='fred')
	394	self.assertEqual(result, 'http://example.com:5432/1/2/3')
60aeef	395	self.assertEqual(route.kw, {'fred': ('', 'a', 'b', 'c', '')})
c51896	396
CM	397	def test_resource_path(self):
	398	request = self._makeOne()
	399	self._registerResourceURL(request.registry)
	400	root = DummyContext()
	401	result = request.resource_path(root)
	402	self.assertEqual(result, '/context/')
	403
	404	def test_resource_path_kwarg(self):
	405	request = self._makeOne()
	406	self._registerResourceURL(request.registry)
	407	root = DummyContext()
	408	result = request.resource_path(root, anchor='abc')
	409	self.assertEqual(result, '/context/#abc')
	410
fb90f0	411	def test_route_url_with_elements(self):
b60bdb	412	from pyramid.interfaces import IRoutesMapper
fb90f0	413	request = self._makeOne()
70f1cd	414	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
6fec21	415	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	416	result = request.route_url('flub', 'extra1', 'extra2')
05c023	417	self.assertEqual(result,
c18e27	418	'http://example.com:5432/1/2/3/extra1/extra2')
CM	419
fb90f0	420	def test_route_url_with_elements_path_endswith_slash(self):
c18e27	421	from pyramid.interfaces import IRoutesMapper
fb90f0	422	request = self._makeOne()
c18e27	423	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3/'))
CM	424	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	425	result = request.route_url('flub', 'extra1', 'extra2')
c18e27	426	self.assertEqual(result,
CM	427	'http://example.com:5432/1/2/3/extra1/extra2')
05c023	428
fb90f0	429	def test_route_url_no_elements(self):
b60bdb	430	from pyramid.interfaces import IRoutesMapper
fb90f0	431	request = self._makeOne()
70f1cd	432	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
6fec21	433	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	434	result = request.route_url('flub', a=1, b=2, c=3, _query={'a':1},
a84e17	435	_anchor=text_(b"foo"))
05c023	436	self.assertEqual(result,
CM	437	'http://example.com:5432/1/2/3?a=1#foo')
c18e27	438
effe0e	439	def test_route_url_with_query_None(self):
MM	440	from pyramid.interfaces import IRoutesMapper
	441	request = self._makeOne()
	442	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
	443	request.registry.registerUtility(mapper, IRoutesMapper)
	444	result = request.route_url('flub', a=1, b=2, c=3, _query=None)
	445	self.assertEqual(result, 'http://example.com:5432/1/2/3')
	446
a7c67c	447	def test_route_url_with_anchor_binary(self):
c18e27	448	from pyramid.interfaces import IRoutesMapper
fb90f0	449	request = self._makeOne()
c18e27	450	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
CM	451	request.registry.registerUtility(mapper, IRoutesMapper)
a7c67c	452	result = request.route_url('flub', _anchor=b"La Pe\xc3\xb1a")
CM	453
fc30e8	454	self.assertEqual(result,
22f0eb	455	'http://example.com:5432/1/2/3#La%20Pe%C3%B1a')
c18e27	456
fb90f0	457	def test_route_url_with_anchor_unicode(self):
c18e27	458	from pyramid.interfaces import IRoutesMapper
fb90f0	459	request = self._makeOne()
c18e27	460	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
CM	461	request.registry.registerUtility(mapper, IRoutesMapper)
a84e17	462	anchor = text_(b'La Pe\xc3\xb1a', 'utf-8')
fb90f0	463	result = request.route_url('flub', _anchor=anchor)
a7c67c	464
fc30e8	465	self.assertEqual(result,
22f0eb	466	'http://example.com:5432/1/2/3#La%20Pe%C3%B1a')
c18e27	467
effe0e	468	def test_route_url_with_anchor_None(self):
MM	469	from pyramid.interfaces import IRoutesMapper
	470	request = self._makeOne()
	471	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
	472	request.registry.registerUtility(mapper, IRoutesMapper)
	473	result = request.route_url('flub', _anchor=None)
	474
	475	self.assertEqual(result, 'http://example.com:5432/1/2/3')
	476
fb90f0	477	def test_route_url_with_query(self):
c18e27	478	from pyramid.interfaces import IRoutesMapper
fb90f0	479	request = self._makeOne()
c18e27	480	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
CM	481	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	482	result = request.route_url('flub', _query={'q':'1'})
c18e27	483	self.assertEqual(result,
CM	484	'http://example.com:5432/1/2/3?q=1')
	485
e967a9	486	def test_route_url_with_query_str(self):
MM	487	from pyramid.interfaces import IRoutesMapper
	488	request = self._makeOne()
	489	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
	490	request.registry.registerUtility(mapper, IRoutesMapper)
	491	result = request.route_url('flub', _query='(openlayers)')
	492	self.assertEqual(result,
af3134	493	'http://example.com:5432/1/2/3?(openlayers)')
e967a9	494
0e0c83	495	def test_route_url_with_empty_query(self):
CL	496	from pyramid.interfaces import IRoutesMapper
	497	request = self._makeOne()
	498	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
	499	request.registry.registerUtility(mapper, IRoutesMapper)
	500	result = request.route_url('flub', _query={})
	501	self.assertEqual(result,
	502	'http://example.com:5432/1/2/3')
	503
fb90f0	504	def test_route_url_with_app_url(self):
c18e27	505	from pyramid.interfaces import IRoutesMapper
fb90f0	506	request = self._makeOne()
c18e27	507	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
CM	508	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	509	result = request.route_url('flub', _app_url='http://example2.com')
c18e27	510	self.assertEqual(result,
CM	511	'http://example2.com/1/2/3')
dc405b	512
c51896	513	def test_route_url_with_host(self):
CM	514	from pyramid.interfaces import IRoutesMapper
	515	environ = {
	516	'wsgi.url_scheme':'http',
	517	'SERVER_PORT':'5432',
	518	}
	519	request = self._makeOne(environ)
	520	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
	521	request.registry.registerUtility(mapper, IRoutesMapper)
	522	result = request.route_url('flub', _host='someotherhost.com')
	523	self.assertEqual(result,
	524	'http://someotherhost.com:5432/1/2/3')
	525
	526	def test_route_url_with_port(self):
	527	from pyramid.interfaces import IRoutesMapper
	528	environ = {
	529	'wsgi.url_scheme':'http',
	530	'SERVER_PORT':'5432',
	531	'SERVER_NAME':'example.com',
	532	}
	533	request = self._makeOne(environ)
	534	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
	535	request.registry.registerUtility(mapper, IRoutesMapper)
	536	result = request.route_url('flub', _port='8080')
	537	self.assertEqual(result,
	538	'http://example.com:8080/1/2/3')
	539
	540	def test_route_url_with_scheme(self):
	541	from pyramid.interfaces import IRoutesMapper
	542	environ = {
	543	'wsgi.url_scheme':'http',
	544	'SERVER_PORT':'5432',
	545	'SERVER_NAME':'example.com',
	546	}
	547	request = self._makeOne(environ)
	548	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
	549	request.registry.registerUtility(mapper, IRoutesMapper)
	550	result = request.route_url('flub', _scheme='https')
	551	self.assertEqual(result,
	552	'https://example.com/1/2/3')
	553
fb90f0	554	def test_route_url_generation_error(self):
b60bdb	555	from pyramid.interfaces import IRoutesMapper
fb90f0	556	request = self._makeOne()
05c023	557	mapper = DummyRoutesMapper(raise_exc=KeyError)
6fec21	558	request.registry.registerUtility(mapper, IRoutesMapper)
05c023	559	mapper.raise_exc = KeyError
fb90f0	560	self.assertRaises(KeyError, request.route_url, 'flub', request, a=1)
750ce4	561
fb90f0	562	def test_route_url_generate_doesnt_receive_query_or_anchor(self):
b60bdb	563	from pyramid.interfaces import IRoutesMapper
fb90f0	564	request = self._makeOne()
70f1cd	565	route = DummyRoute(result='')
CM	566	mapper = DummyRoutesMapper(route=route)
fb90f0	567	request.registry.registerUtility(mapper, IRoutesMapper)
CM	568	result = request.route_url('flub', _query=dict(name='some_name'))
70f1cd	569	self.assertEqual(route.kw, {}) # shouldnt have anchor/query
9d9ffb	570	self.assertEqual(result, 'http://example.com:5432?name=some_name')
CM	571
fb90f0	572	def test_route_url_with_pregenerator(self):
b60bdb	573	from pyramid.interfaces import IRoutesMapper
fb90f0	574	request = self._makeOne()
70f1cd	575	route = DummyRoute(result='/1/2/3')
CM	576	def pregenerator(request, elements, kw):
	577	return ('a',), {'_app_url':'http://example2.com'}
	578	route.pregenerator = pregenerator
	579	mapper = DummyRoutesMapper(route=route)
	580	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	581	result = request.route_url('flub')
70f1cd	582	self.assertEqual(result, 'http://example2.com/1/2/3/a')
CM	583	self.assertEqual(route.kw, {}) # shouldnt have anchor/query
b29429	584
fb90f0	585	def test_route_url_with_anchor_app_url_elements_and_query(self):
c18e27	586	from pyramid.interfaces import IRoutesMapper
fb90f0	587	request = self._makeOne()
c18e27	588	mapper = DummyRoutesMapper(route=DummyRoute(result='/1/2/3'))
CM	589	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	590	result = request.route_url('flub', 'element1',
CM	591	_app_url='http://example2.com',
	592	_anchor='anchor', _query={'q':'1'})
c18e27	593	self.assertEqual(result,
CM	594	'http://example2.com/1/2/3/element1?q=1#anchor')
db0185	595
fb90f0	596	def test_route_url_integration_with_real_request(self):
311ccc	597	# to try to replicate https://github.com/Pylons/pyramid/issues/213
CM	598	from pyramid.interfaces import IRoutesMapper
	599	from pyramid.request import Request
	600	request = Request.blank('/')
	601	request.registry = self.config.registry
	602	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
	603	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	604	result = request.route_url('flub', 'extra1', 'extra2')
311ccc	605	self.assertEqual(result,
CM	606	'http://localhost/1/2/3/extra1/extra2')
	607
	608
fb90f0	609	def test_current_route_url_current_request_has_no_route(self):
CM	610	request = self._makeOne()
	611	self.assertRaises(ValueError, request.current_route_url)
5653d1	612
fb90f0	613	def test_current_route_url_with_elements_query_and_anchor(self):
5653d1	614	from pyramid.interfaces import IRoutesMapper
fb90f0	615	request = self._makeOne()
5653d1	616	route = DummyRoute('/1/2/3')
CM	617	mapper = DummyRoutesMapper(route=route)
	618	request.matched_route = route
	619	request.matchdict = {}
	620	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	621	result = request.current_route_url('extra1', 'extra2', _query={'a':1},
a84e17	622	_anchor=text_(b"foo"))
5653d1	623	self.assertEqual(result,
CM	624	'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo')
	625
fb90f0	626	def test_current_route_url_with_route_name(self):
5653d1	627	from pyramid.interfaces import IRoutesMapper
fb90f0	628	request = self._makeOne()
5653d1	629	route = DummyRoute('/1/2/3')
CM	630	mapper = DummyRoutesMapper(route=route)
	631	request.matched_route = route
	632	request.matchdict = {}
	633	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	634	result = request.current_route_url('extra1', 'extra2', _query={'a':1},
a84e17	635	_anchor=text_(b"foo"),
e6c2d2	636	_route_name='bar')
5653d1	637	self.assertEqual(result,
CM	638	'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo')
	639
fe8c0f	640	def test_current_route_url_with_request_query(self):
JV	641	from pyramid.interfaces import IRoutesMapper
	642	from webob.multidict import GetDict
	643	request = self._makeOne()
	644	request.GET = GetDict([('q', '123')], {})
	645	route = DummyRoute('/1/2/3')
	646	mapper = DummyRoutesMapper(route=route)
	647	request.matched_route = route
	648	request.matchdict = {}
	649	request.registry.registerUtility(mapper, IRoutesMapper)
	650	result = request.current_route_url()
	651	self.assertEqual(result,
	652	'http://example.com:5432/1/2/3?q=123')
	653
6a4a34	654	def test_current_route_url_with_request_query_duplicate_entries(self):
JV	655	from pyramid.interfaces import IRoutesMapper
	656	from webob.multidict import GetDict
	657	request = self._makeOne()
db0185	658	request.GET = GetDict(
CM	659	[('q', '123'), ('b', '2'), ('b', '2'), ('q', '456')], {})
6a4a34	660	route = DummyRoute('/1/2/3')
JV	661	mapper = DummyRoutesMapper(route=route)
	662	request.matched_route = route
	663	request.matchdict = {}
	664	request.registry.registerUtility(mapper, IRoutesMapper)
	665	result = request.current_route_url()
	666	self.assertEqual(result,
	667	'http://example.com:5432/1/2/3?q=123&b=2&b=2&q=456')
	668
fe8c0f	669	def test_current_route_url_with_query_override(self):
JV	670	from pyramid.interfaces import IRoutesMapper
	671	from webob.multidict import GetDict
	672	request = self._makeOne()
	673	request.GET = GetDict([('q', '123')], {})
	674	route = DummyRoute('/1/2/3')
	675	mapper = DummyRoutesMapper(route=route)
	676	request.matched_route = route
	677	request.matchdict = {}
	678	request.registry.registerUtility(mapper, IRoutesMapper)
	679	result = request.current_route_url(_query={'a':1})
	680	self.assertEqual(result,
	681	'http://example.com:5432/1/2/3?a=1')
	682
12cef0	683	def test_current_route_path(self):
CM	684	from pyramid.interfaces import IRoutesMapper
	685	request = self._makeOne()
	686	route = DummyRoute('/1/2/3')
	687	mapper = DummyRoutesMapper(route=route)
	688	request.matched_route = route
	689	request.matchdict = {}
5c6963	690	request.script_name = '/script_name'
12cef0	691	request.registry.registerUtility(mapper, IRoutesMapper)
CM	692	result = request.current_route_path('extra1', 'extra2', _query={'a':1},
a84e17	693	_anchor=text_(b"foo"))
5c6963	694	self.assertEqual(result, '/script_name/1/2/3/extra1/extra2?a=1#foo')
6a4a34	695
fb90f0	696	def test_route_path_with_elements(self):
2c9d14	697	from pyramid.interfaces import IRoutesMapper
fb90f0	698	request = self._makeOne()
2c9d14	699	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
CM	700	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	701	request.script_name = ''
CM	702	result = request.route_path('flub', 'extra1', 'extra2',
	703	a=1, b=2, c=3, _query={'a':1},
a84e17	704	_anchor=text_(b"foo"))
2c9d14	705	self.assertEqual(result, '/1/2/3/extra1/extra2?a=1#foo')
CM	706
fb90f0	707	def test_route_path_with_script_name(self):
0a0edf	708	from pyramid.interfaces import IRoutesMapper
fb90f0	709	request = self._makeOne()
0a0edf	710	request.script_name = '/foo'
CM	711	mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3'))
	712	request.registry.registerUtility(mapper, IRoutesMapper)
fb90f0	713	result = request.route_path('flub', 'extra1', 'extra2',
CM	714	a=1, b=2, c=3, _query={'a':1},
a84e17	715	_anchor=text_(b"foo"))
0a0edf	716	self.assertEqual(result, '/foo/1/2/3/extra1/extra2?a=1#foo')
CM	717
fb90f0	718	def test_static_url_staticurlinfo_notfound(self):
CM	719	request = self._makeOne()
	720	self.assertRaises(ValueError, request.static_url, 'static/foo.css')
750ce4	721
fb90f0	722	def test_static_url_abspath(self):
b8c797	723	from pyramid.interfaces import IStaticURLInfo
fb90f0	724	request = self._makeOne()
b8c797	725	info = DummyStaticURLInfo('abc')
CM	726	registry = request.registry
	727	registry.registerUtility(info, IStaticURLInfo)
	728	abspath = makeabs('static', 'foo.css')
	729	result = request.static_url(abspath)
	730	self.assertEqual(result, 'abc')
8064bd	731	self.assertEqual(info.args, (makeabs('static', 'foo.css'), request, {}))
b8c797	732	request = self._makeOne()
750ce4	733
fb90f0	734	def test_static_url_found_rel(self):
b60bdb	735	from pyramid.interfaces import IStaticURLInfo
fb90f0	736	request = self._makeOne()
b29429	737	info = DummyStaticURLInfo('abc')
CM	738	request.registry.registerUtility(info, IStaticURLInfo)
fb90f0	739	result = request.static_url('static/foo.css')
b29429	740	self.assertEqual(result, 'abc')
CM	741	self.assertEqual(info.args,
b60bdb	742	('pyramid.tests:static/foo.css', request, {}) )
750ce4	743
fb90f0	744	def test_static_url_abs(self):
b60bdb	745	from pyramid.interfaces import IStaticURLInfo
fb90f0	746	request = self._makeOne()
b29429	747	info = DummyStaticURLInfo('abc')
CM	748	request.registry.registerUtility(info, IStaticURLInfo)
fb90f0	749	result = request.static_url('pyramid.tests:static/foo.css')
b29429	750	self.assertEqual(result, 'abc')
CM	751	self.assertEqual(info.args,
b60bdb	752	('pyramid.tests:static/foo.css', request, {}) )
750ce4	753
fb90f0	754	def test_static_url_found_abs_no_registry_on_request(self):
b60bdb	755	from pyramid.interfaces import IStaticURLInfo
fb90f0	756	request = self._makeOne()
CM	757	registry = request.registry
b29429	758	info = DummyStaticURLInfo('abc')
CM	759	registry.registerUtility(info, IStaticURLInfo)
fb90f0	760	del request.registry
CM	761	result = request.static_url('pyramid.tests:static/foo.css')
b29429	762	self.assertEqual(result, 'abc')
CM	763	self.assertEqual(info.args,
b60bdb	764	('pyramid.tests:static/foo.css', request, {}) )
5c6963	765
b8c797	766	def test_static_url_abspath_integration_with_staticurlinfo(self):
CM	767	from pyramid.interfaces import IStaticURLInfo
53d9d4	768	from pyramid.config.views import StaticURLInfo
cda7f6	769	info = StaticURLInfo()
b8c797	770	here = os.path.abspath(os.path.dirname(__file__))
cda7f6	771	info.add(self.config, 'absstatic', here)
5c6963	772	request = self._makeOne()
b8c797	773	registry = request.registry
CM	774	registry.registerUtility(info, IStaticURLInfo)
	775	abspath = os.path.join(here, 'test_url.py')
	776	result = request.static_url(abspath)
	777	self.assertEqual(result,
	778	'http://example.com:5432/absstatic/test_url.py')
	779
ff41f8	780	def test_static_url_noscheme_uses_scheme_from_request(self):
WS	781	from pyramid.interfaces import IStaticURLInfo
	782	from pyramid.config.views import StaticURLInfo
	783	info = StaticURLInfo()
	784	here = os.path.abspath(os.path.dirname(__file__))
	785	info.add(self.config, '//subdomain.example.com/static', here)
	786	request = self._makeOne({'wsgi.url_scheme': 'https'})
	787	registry = request.registry
	788	registry.registerUtility(info, IStaticURLInfo)
	789	abspath = os.path.join(here, 'test_url.py')
	790	result = request.static_url(abspath)
	791	self.assertEqual(result,
	792	'https://subdomain.example.com/static/test_url.py')
	793
b8c797	794	def test_static_path_abspath(self):
CM	795	from pyramid.interfaces import IStaticURLInfo
	796	request = self._makeOne()
	797	request.script_name = '/foo'
	798	info = DummyStaticURLInfo('abc')
	799	registry = request.registry
	800	registry.registerUtility(info, IStaticURLInfo)
	801	abspath = makeabs('static', 'foo.css')
	802	result = request.static_path(abspath)
	803	self.assertEqual(result, 'abc')
8064bd	804	self.assertEqual(info.args, (makeabs('static', 'foo.css'), request,
b8c797	805	{'_app_url':'/foo'})
CM	806	)
5c6963	807
CM	808	def test_static_path_found_rel(self):
	809	from pyramid.interfaces import IStaticURLInfo
	810	request = self._makeOne()
	811	request.script_name = '/foo'
	812	info = DummyStaticURLInfo('abc')
	813	request.registry.registerUtility(info, IStaticURLInfo)
	814	result = request.static_path('static/foo.css')
	815	self.assertEqual(result, 'abc')
	816	self.assertEqual(info.args,
	817	('pyramid.tests:static/foo.css', request,
	818	{'_app_url':'/foo'})
	819	)
	820
	821	def test_static_path_abs(self):
	822	from pyramid.interfaces import IStaticURLInfo
	823	request = self._makeOne()
	824	request.script_name = '/foo'
	825	info = DummyStaticURLInfo('abc')
	826	request.registry.registerUtility(info, IStaticURLInfo)
	827	result = request.static_path('pyramid.tests:static/foo.css')
	828	self.assertEqual(result, 'abc')
	829	self.assertEqual(info.args,
	830	('pyramid.tests:static/foo.css', request,
	831	{'_app_url':'/foo'})
	832	)
	833
	834	def test_static_path(self):
	835	from pyramid.interfaces import IStaticURLInfo
	836	request = self._makeOne()
	837	request.script_name = '/foo'
	838	info = DummyStaticURLInfo('abc')
	839	request.registry.registerUtility(info, IStaticURLInfo)
	840	result = request.static_path('static/foo.css')
	841	self.assertEqual(result, 'abc')
	842	self.assertEqual(info.args,
	843	('pyramid.tests:static/foo.css', request,
	844	{'_app_url':'/foo'})
	845	)
fb90f0	846
c51896	847	def test_partial_application_url_with_http_host_default_port_http(self):
CM	848	environ = {
	849	'wsgi.url_scheme':'http',
	850	'HTTP_HOST':'example.com:80',
	851	}
	852	request = self._makeOne(environ)
5b1e2a	853	result = request._partial_application_url()
c51896	854	self.assertEqual(result, 'http://example.com')
CM	855
	856	def test_partial_application_url_with_http_host_default_port_https(self):
	857	environ = {
	858	'wsgi.url_scheme':'https',
	859	'HTTP_HOST':'example.com:443',
	860	}
	861	request = self._makeOne(environ)
5b1e2a	862	result = request._partial_application_url()
c51896	863	self.assertEqual(result, 'https://example.com')
CM	864
	865	def test_partial_application_url_with_http_host_nondefault_port_http(self):
	866	environ = {
	867	'wsgi.url_scheme':'http',
	868	'HTTP_HOST':'example.com:8080',
	869	}
	870	request = self._makeOne(environ)
5b1e2a	871	result = request._partial_application_url()
c51896	872	self.assertEqual(result, 'http://example.com:8080')
CM	873
	874	def test_partial_application_url_with_http_host_nondefault_port_https(self):
	875	environ = {
	876	'wsgi.url_scheme':'https',
	877	'HTTP_HOST':'example.com:4443',
	878	}
	879	request = self._makeOne(environ)
5b1e2a	880	result = request._partial_application_url()
c51896	881	self.assertEqual(result, 'https://example.com:4443')
CM	882
	883	def test_partial_application_url_with_http_host_no_colon(self):
	884	environ = {
	885	'wsgi.url_scheme':'http',
	886	'HTTP_HOST':'example.com',
	887	'SERVER_PORT':'80',
	888	}
	889	request = self._makeOne(environ)
5b1e2a	890	result = request._partial_application_url()
c51896	891	self.assertEqual(result, 'http://example.com')
CM	892
	893	def test_partial_application_url_no_http_host(self):
	894	environ = {
	895	'wsgi.url_scheme':'http',
	896	'SERVER_NAME':'example.com',
	897	'SERVER_PORT':'80',
	898	}
	899	request = self._makeOne(environ)
5b1e2a	900	result = request._partial_application_url()
c51896	901	self.assertEqual(result, 'http://example.com')
CM	902
	903	def test_partial_application_replace_port(self):
	904	environ = {
	905	'wsgi.url_scheme':'http',
	906	'SERVER_NAME':'example.com',
	907	'SERVER_PORT':'80',
	908	}
	909	request = self._makeOne(environ)
5b1e2a	910	result = request._partial_application_url(port=8080)
c51896	911	self.assertEqual(result, 'http://example.com:8080')
CM	912
	913	def test_partial_application_replace_scheme_https_special_case(self):
	914	environ = {
	915	'wsgi.url_scheme':'http',
	916	'SERVER_NAME':'example.com',
	917	'SERVER_PORT':'80',
	918	}
	919	request = self._makeOne(environ)
5b1e2a	920	result = request._partial_application_url(scheme='https')
c51896	921	self.assertEqual(result, 'https://example.com')
CM	922
	923	def test_partial_application_replace_scheme_https_special_case_avoid(self):
	924	environ = {
	925	'wsgi.url_scheme':'http',
	926	'SERVER_NAME':'example.com',
	927	'SERVER_PORT':'80',
	928	}
	929	request = self._makeOne(environ)
5b1e2a	930	result = request._partial_application_url(scheme='https', port='8080')
c51896	931	self.assertEqual(result, 'https://example.com:8080')
CM	932
	933	def test_partial_application_replace_scheme_http_special_case(self):
	934	environ = {
	935	'wsgi.url_scheme':'https',
	936	'SERVER_NAME':'example.com',
	937	'SERVER_PORT':'8080',
	938	}
	939	request = self._makeOne(environ)
5b1e2a	940	result = request._partial_application_url(scheme='http')
c51896	941	self.assertEqual(result, 'http://example.com')
CM	942
	943	def test_partial_application_replace_scheme_http_special_case_avoid(self):
	944	environ = {
	945	'wsgi.url_scheme':'https',
	946	'SERVER_NAME':'example.com',
	947	'SERVER_PORT':'8000',
	948	}
	949	request = self._makeOne(environ)
5b1e2a	950	result = request._partial_application_url(scheme='http', port='8080')
c51896	951	self.assertEqual(result, 'http://example.com:8080')
CM	952
	953	def test_partial_application_replace_host_no_port(self):
	954	environ = {
	955	'wsgi.url_scheme':'http',
	956	'SERVER_NAME':'example.com',
	957	'SERVER_PORT':'80',
	958	}
	959	request = self._makeOne(environ)
5b1e2a	960	result = request._partial_application_url(host='someotherhost.com')
c51896	961	self.assertEqual(result, 'http://someotherhost.com')
CM	962
	963	def test_partial_application_replace_host_with_port(self):
	964	environ = {
	965	'wsgi.url_scheme':'http',
	966	'SERVER_NAME':'example.com',
	967	'SERVER_PORT':'8000',
	968	}
	969	request = self._makeOne(environ)
5b1e2a	970	result = request._partial_application_url(host='someotherhost.com:8080')
c51896	971	self.assertEqual(result, 'http://someotherhost.com:8080')
CM	972
	973	def test_partial_application_replace_host_and_port(self):
	974	environ = {
	975	'wsgi.url_scheme':'http',
	976	'SERVER_NAME':'example.com',
	977	'SERVER_PORT':'80',
	978	}
	979	request = self._makeOne(environ)
5b1e2a	980	result = request._partial_application_url(host='someotherhost.com:8080',
CM	981	port='8000')
c51896	982	self.assertEqual(result, 'http://someotherhost.com:8000')
CM	983
	984	def test_partial_application_replace_host_port_and_scheme(self):
	985	environ = {
	986	'wsgi.url_scheme':'http',
	987	'SERVER_NAME':'example.com',
	988	'SERVER_PORT':'80',
	989	}
	990	request = self._makeOne(environ)
5b1e2a	991	result = request._partial_application_url(
c51896	992	host='someotherhost.com:8080',
CM	993	port='8000',
	994	scheme='https',
	995	)
	996	self.assertEqual(result, 'https://someotherhost.com:8000')
	997
	998	def test_partial_application_url_with_custom_script_name(self):
	999	environ = {
	1000	'wsgi.url_scheme':'http',
	1001	'SERVER_NAME':'example.com',
	1002	'SERVER_PORT':'8000',
	1003	}
	1004	request = self._makeOne(environ)
	1005	request.script_name = '/abc'
5b1e2a	1006	result = request._partial_application_url()
c51896	1007	self.assertEqual(result, 'http://example.com:8000/abc')
CM	1008
fb90f0	1009	class Test_route_url(unittest.TestCase):
CM	1010	def _callFUT(self, route_name, request, elements, *kw):
	1011	from pyramid.url import route_url
	1012	return route_url(route_name, request, elements, *kw)
	1013
	1014	def _makeRequest(self):
	1015	class Request(object):
	1016	def route_url(self, route_name, elements, *kw):
	1017	self.route_name = route_name
	1018	self.elements = elements
	1019	self.kw = kw
	1020	return 'route url'
	1021	return Request()
	1022
	1023	def test_it(self):
	1024	request = self._makeRequest()
	1025	result = self._callFUT('abc', request, 'a', _app_url='')
	1026	self.assertEqual(result, 'route url')
	1027	self.assertEqual(request.route_name, 'abc')
	1028	self.assertEqual(request.elements, ('a',))
	1029	self.assertEqual(request.kw, {'_app_url':''})
	1030
	1031	class Test_route_path(unittest.TestCase):
	1032	def _callFUT(self, route_name, request, elements, *kw):
	1033	from pyramid.url import route_path
	1034	return route_path(route_name, request, elements, *kw)
	1035
	1036	def _makeRequest(self):
	1037	class Request(object):
	1038	def route_path(self, route_name, elements, *kw):
	1039	self.route_name = route_name
	1040	self.elements = elements
	1041	self.kw = kw
	1042	return 'route path'
	1043	return Request()
	1044
	1045	def test_it(self):
	1046	request = self._makeRequest()
	1047	result = self._callFUT('abc', request, 'a', _app_url='')
	1048	self.assertEqual(result, 'route path')
	1049	self.assertEqual(request.route_name, 'abc')
	1050	self.assertEqual(request.elements, ('a',))
	1051	self.assertEqual(request.kw, {'_app_url':''})
	1052
	1053	class Test_resource_url(unittest.TestCase):
	1054	def _callFUT(self, resource, request, elements, *kw):
	1055	from pyramid.url import resource_url
	1056	return resource_url(resource, request, elements, *kw)
	1057
	1058	def _makeRequest(self):
	1059	class Request(object):
	1060	def resource_url(self, resource, elements, *kw):
	1061	self.resource = resource
	1062	self.elements = elements
	1063	self.kw = kw
	1064	return 'resource url'
	1065	return Request()
	1066
	1067	def test_it(self):
	1068	request = self._makeRequest()
	1069	result = self._callFUT('abc', request, 'a', _app_url='')
	1070	self.assertEqual(result, 'resource url')
	1071	self.assertEqual(request.resource, 'abc')
	1072	self.assertEqual(request.elements, ('a',))
	1073	self.assertEqual(request.kw, {'_app_url':''})
	1074
	1075	class Test_static_url(unittest.TestCase):
	1076	def _callFUT(self, path, request, **kw):
	1077	from pyramid.url import static_url
	1078	return static_url(path, request, **kw)
	1079
	1080	def _makeRequest(self):
	1081	class Request(object):
	1082	def static_url(self, path, **kw):
	1083	self.path = path
	1084	self.kw = kw
	1085	return 'static url'
	1086	return Request()
	1087
b5c0cb	1088	def test_it_abs(self):
CM	1089	request = self._makeRequest()
	1090	result = self._callFUT('/foo/bar/abc', request, _app_url='')
	1091	self.assertEqual(result, 'static url')
	1092	self.assertEqual(request.path, '/foo/bar/abc')
	1093	self.assertEqual(request.kw, {'_app_url':''})
	1094
	1095	def test_it_absspec(self):
	1096	request = self._makeRequest()
	1097	result = self._callFUT('foo:abc', request, _anchor='anchor')
	1098	self.assertEqual(result, 'static url')
	1099	self.assertEqual(request.path, 'foo:abc')
	1100	self.assertEqual(request.kw, {'_anchor':'anchor'})
	1101
	1102	def test_it_rel(self):
fb90f0	1103	request = self._makeRequest()
CM	1104	result = self._callFUT('abc', request, _app_url='')
	1105	self.assertEqual(result, 'static url')
b5c0cb	1106	self.assertEqual(request.path, 'pyramid.tests:abc')
fb90f0	1107	self.assertEqual(request.kw, {'_app_url':''})
CM	1108
5c6963	1109	class Test_static_path(unittest.TestCase):
CM	1110	def _callFUT(self, path, request, **kw):
	1111	from pyramid.url import static_path
	1112	return static_path(path, request, **kw)
	1113
	1114	def _makeRequest(self):
	1115	class Request(object):
	1116	def static_path(self, path, **kw):
	1117	self.path = path
	1118	self.kw = kw
	1119	return 'static path'
	1120	return Request()
	1121
b5c0cb	1122	def test_it_abs(self):
5c6963	1123	request = self._makeRequest()
b5c0cb	1124	result = self._callFUT('/foo/bar/abc', request, _anchor='anchor')
5c6963	1125	self.assertEqual(result, 'static path')
b5c0cb	1126	self.assertEqual(request.path, '/foo/bar/abc')
5c6963	1127	self.assertEqual(request.kw, {'_anchor':'anchor'})
CM	1128
b5c0cb	1129	def test_it_absspec(self):
CM	1130	request = self._makeRequest()
	1131	result = self._callFUT('foo:abc', request, _anchor='anchor')
	1132	self.assertEqual(result, 'static path')
	1133	self.assertEqual(request.path, 'foo:abc')
	1134	self.assertEqual(request.kw, {'_anchor':'anchor'})
	1135
	1136	def test_it_rel(self):
	1137	request = self._makeRequest()
	1138	result = self._callFUT('abc', request, _app_url='')
	1139	self.assertEqual(result, 'static path')
	1140	self.assertEqual(request.path, 'pyramid.tests:abc')
	1141	self.assertEqual(request.kw, {'_app_url':''})
	1142
fb90f0	1143	class Test_current_route_url(unittest.TestCase):
CM	1144	def _callFUT(self, request, elements, *kw):
	1145	from pyramid.url import current_route_url
	1146	return current_route_url(request, elements, *kw)
	1147
	1148	def _makeRequest(self):
	1149	class Request(object):
	1150	def current_route_url(self, elements, *kw):
	1151	self.elements = elements
	1152	self.kw = kw
	1153	return 'current route url'
	1154	return Request()
	1155
	1156	def test_it(self):
	1157	request = self._makeRequest()
	1158	result = self._callFUT(request, 'abc', _app_url='')
	1159	self.assertEqual(result, 'current route url')
	1160	self.assertEqual(request.elements, ('abc',))
	1161	self.assertEqual(request.kw, {'_app_url':''})
45d08c	1162
12cef0	1163	class Test_current_route_path(unittest.TestCase):
CM	1164	def _callFUT(self, request, elements, *kw):
	1165	from pyramid.url import current_route_path
	1166	return current_route_path(request, elements, *kw)
	1167
	1168	def _makeRequest(self):
	1169	class Request(object):
	1170	def current_route_path(self, elements, *kw):
	1171	self.elements = elements
	1172	self.kw = kw
	1173	return 'current route path'
	1174	return Request()
	1175
	1176	def test_it(self):
	1177	request = self._makeRequest()
	1178	result = self._callFUT(request, 'abc', _anchor='abc')
	1179	self.assertEqual(result, 'current route path')
	1180	self.assertEqual(request.elements, ('abc',))
	1181	self.assertEqual(request.kw, {'_anchor':'abc'})
	1182
33b638	1183	class Test_external_static_url_integration(unittest.TestCase):
TL	1184
	1185	def setUp(self):
	1186	self.config = testing.setUp()
	1187
	1188	def tearDown(self):
	1189	testing.tearDown()
	1190
	1191	def _makeRequest(self):
84367e	1192	from pyramid.request import Request
33b638	1193	return Request.blank('/')
TL	1194
	1195	def test_generate_external_url(self):
	1196	self.config.add_route('acme', 'https://acme.org/path/{foo}')
	1197	request = self._makeRequest()
	1198	request.registry = self.config.registry
84367e	1199	self.assertEqual(
MM	1200	request.route_url('acme', foo='bar'),
33b638	1201	'https://acme.org/path/bar')
TL	1202
	1203	def test_generate_external_url_without_scheme(self):
	1204	self.config.add_route('acme', '//acme.org/path/{foo}')
	1205	request = self._makeRequest()
	1206	request.registry = self.config.registry
84367e	1207	self.assertEqual(
MM	1208	request.route_url('acme', foo='bar'),
33b638	1209	'http://acme.org/path/bar')
TL	1210
	1211	def test_generate_external_url_with_explicit_scheme(self):
	1212	self.config.add_route('acme', '//acme.org/path/{foo}')
	1213	request = self._makeRequest()
	1214	request.registry = self.config.registry
84367e	1215	self.assertEqual(
MM	1216	request.route_url('acme', foo='bar', _scheme='https'),
33b638	1217	'https://acme.org/path/bar')
TL	1218
edbc1d	1219	def test_generate_external_url_with_explicit_app_url(self):
TL	1220	self.config.add_route('acme', 'http://acme.org/path/{foo}')
	1221	request = self._makeRequest()
	1222	request.registry = self.config.registry
d07d16	1223	self.assertRaises(ValueError,
CM	1224	request.route_url, 'acme', foo='bar', _app_url='http://fakeme.com')
edbc1d	1225
df413c	1226	def test_generate_external_url_route_path(self):
TL	1227	self.config.add_route('acme', 'https://acme.org/path/{foo}')
	1228	request = self._makeRequest()
	1229	request.registry = self.config.registry
d07d16	1230	self.assertRaises(ValueError, request.route_path, 'acme', foo='bar')
df413c	1231
84367e	1232	def test_generate_external_url_with_pregenerator(self):
MM	1233	def pregenerator(request, elements, kw):
	1234	kw['_query'] = {'q': 'foo'}
	1235	return elements, kw
	1236	self.config.add_route('acme', 'https://acme.org/path/{foo}',
	1237	pregenerator=pregenerator)
	1238	request = self._makeRequest()
	1239	request.registry = self.config.registry
	1240	self.assertEqual(
	1241	request.route_url('acme', foo='bar'),
	1242	'https://acme.org/path/bar?q=foo')
	1243
	1244	def test_external_url_with_route_prefix(self):
	1245	def includeme(config):
	1246	config.add_route('acme', '//acme.org/{foo}')
	1247	self.config.include(includeme, route_prefix='some_prefix')
	1248	request = self._makeRequest()
	1249	request.registry = self.config.registry
	1250	self.assertEqual(
	1251	request.route_url('acme', foo='bar'),
	1252	'http://acme.org/bar')
df413c	1253
efd61e	1254	class Test_with_route_prefix(unittest.TestCase):
HS	1255
	1256	def setUp(self):
	1257	self.config = testing.setUp()
	1258
	1259	def tearDown(self):
	1260	testing.tearDown()
	1261
	1262	def _makeRequest(self, route):
	1263	from pyramid.request import Request
	1264	return Request.blank(route)
	1265
	1266	def test_old_route_is_preserved(self):
	1267	self.config.route_prefix = 'old_prefix'
	1268	with self.config.route_prefix_context('new_addon'):
	1269	assert 'new_addon' in self.config.route_prefix
	1270
	1271	assert 'old_prefix' == self.config.route_prefix
	1272
	1273	def test_route_prefix_none(self):
	1274	self.config.route_prefix = 'old_prefix'
	1275	with self.config.route_prefix_context(None):
	1276	assert 'old_prefix' == self.config.route_prefix
	1277
	1278	assert 'old_prefix' == self.config.route_prefix
	1279
	1280	def test_route_prefix_empty(self):
	1281	self.config.route_prefix = 'old_prefix'
	1282	with self.config.route_prefix_context(''):
	1283	assert 'old_prefix' == self.config.route_prefix
	1284
	1285	assert 'old_prefix' == self.config.route_prefix
	1286
	1287	def test_route_has_prefix(self):
	1288	with self.config.route_prefix_context('bar'):
	1289	self.config.add_route('acme', '/foo')
	1290	request = self._makeRequest('/')
	1291	self.assertEqual(
	1292	request.route_url('acme'),
	1293	'http://localhost/bar/foo',
	1294	)
	1295
	1296	def test_route_does_not_have_prefix(self):
	1297	with self.config.route_prefix_context('bar'):
	1298	pass
	1299
	1300	self.config.add_route('acme', '/foo')
	1301	request = self._makeRequest('/')
	1302	self.assertEqual(
	1303	request.route_url('acme'),
	1304	'http://localhost/foo',
	1305	)
	1306
	1307	def test_error_reset_prefix(self):
	1308	self.config.route_prefix = 'old_prefix'
	1309
	1310	try:
	1311	with self.config.route_prefix_context('new_prefix'):
	1312	raise RuntimeError
	1313	except RuntimeError:
	1314	pass
	1315
	1316	assert self.config.route_prefix == 'old_prefix'
	1317
7ae0c2	1318	class DummyContext(object):
CM	1319	def __init__(self, next=None):
	1320	self.next = next
	1321
5a11c0	1322	class DummyRoutesMapper:
05c023	1323	raise_exc = None
70f1cd	1324	def __init__(self, route=None, raise_exc=False):
CM	1325	self.route = route
750ce4	1326
70f1cd	1327	def get_route(self, route_name):
CM	1328	return self.route
	1329
	1330	class DummyRoute:
	1331	pregenerator = None
5653d1	1332	name = 'route'
70f1cd	1333	def __init__(self, result='/1/2/3'):
CM	1334	self.result = result
	1335
	1336	def generate(self, kw):
f0b74a	1337	self.kw = kw
05c023	1338	return self.result
5a11c0	1339
b29429	1340	class DummyStaticURLInfo:
CM	1341	def __init__(self, result):
	1342	self.result = result
	1343
	1344	def generate(self, path, request, **kw):
	1345	self.args = path, request, kw
	1346	return self.result
	1347
b8c797	1348	def makeabs(*elements):
a4a8a5	1349	if WIN: # pragma: no cover
8064bd	1350	return r'c:\\' + os.path.sep.join(elements)
CM	1351	else:
	1352	return os.path.sep + os.path.sep.join(elements)