RedHatTraining/pyramid.git

Michael Merickel

2018-10-10 4a9f4f43684c3a754f43935b97013057340c305d

commit \| author \| age
a0b2c6	1	import unittest
CM	2
	3	from pyramid.tests.test_config import dummyfactory
	4	from pyramid.tests.test_config import DummyContext
a5d994	5	from pyramid.compat import text_
a0b2c6	6
CM	7	class RoutesConfiguratorMixinTests(unittest.TestCase):
	8	def _makeOne(self, arg, *kw):
	9	from pyramid.config import Configurator
	10	config = Configurator(arg, *kw)
	11	return config
	12
	13	def _assertRoute(self, config, name, path, num_predicates=0):
	14	from pyramid.interfaces import IRoutesMapper
	15	mapper = config.registry.getUtility(IRoutesMapper)
	16	routes = mapper.get_routes()
	17	route = routes[0]
	18	self.assertEqual(len(routes), 1)
	19	self.assertEqual(route.name, name)
	20	self.assertEqual(route.path, path)
	21	self.assertEqual(len(routes[0].predicates), num_predicates)
	22	return route
	23
	24	def _makeRequest(self, config):
	25	request = DummyRequest()
	26	request.registry = config.registry
	27	return request
	28
	29	def test_get_routes_mapper_not_yet_registered(self):
	30	config = self._makeOne()
	31	mapper = config.get_routes_mapper()
	32	self.assertEqual(mapper.routelist, [])
	33
	34	def test_get_routes_mapper_already_registered(self):
	35	from pyramid.interfaces import IRoutesMapper
	36	config = self._makeOne()
	37	mapper = object()
	38	config.registry.registerUtility(mapper, IRoutesMapper)
	39	result = config.get_routes_mapper()
	40	self.assertEqual(result, mapper)
	41
	42	def test_add_route_defaults(self):
	43	config = self._makeOne(autocommit=True)
	44	config.add_route('name', 'path')
	45	self._assertRoute(config, 'name', 'path')
	46
	47	def test_add_route_with_route_prefix(self):
	48	config = self._makeOne(autocommit=True)
	49	config.route_prefix = 'root'
	50	config.add_route('name', 'path')
	51	self._assertRoute(config, 'name', 'root/path')
	52
	53	def test_add_route_discriminator(self):
	54	config = self._makeOne()
	55	config.add_route('name', 'path')
412b4a	56	self.assertEqual(config.action_state.actions[-1]['discriminator'],
CM	57	('route', 'name'))
a0b2c6	58
CM	59	def test_add_route_with_factory(self):
	60	config = self._makeOne(autocommit=True)
	61	factory = object()
	62	config.add_route('name', 'path', factory=factory)
	63	route = self._assertRoute(config, 'name', 'path')
	64	self.assertEqual(route.factory, factory)
	65
	66	def test_add_route_with_static(self):
	67	config = self._makeOne(autocommit=True)
	68	config.add_route('name', 'path/{foo}', static=True)
	69	mapper = config.get_routes_mapper()
	70	self.assertEqual(len(mapper.get_routes()), 0)
	71	self.assertEqual(mapper.generate('name', {"foo":"a"}), '/path/a')
	72
	73	def test_add_route_with_factory_dottedname(self):
	74	config = self._makeOne(autocommit=True)
	75	config.add_route(
	76	'name', 'path',
	77	factory='pyramid.tests.test_config.dummyfactory')
	78	route = self._assertRoute(config, 'name', 'path')
	79	self.assertEqual(route.factory, dummyfactory)
	80
	81	def test_add_route_with_xhr(self):
	82	config = self._makeOne(autocommit=True)
	83	config.add_route('name', 'path', xhr=True)
	84	route = self._assertRoute(config, 'name', 'path', 1)
	85	predicate = route.predicates[0]
	86	request = self._makeRequest(config)
	87	request.is_xhr = True
	88	self.assertEqual(predicate(None, request), True)
	89	request = self._makeRequest(config)
	90	request.is_xhr = False
	91	self.assertEqual(predicate(None, request), False)
	92
	93	def test_add_route_with_request_method(self):
	94	config = self._makeOne(autocommit=True)
	95	config.add_route('name', 'path', request_method='GET')
	96	route = self._assertRoute(config, 'name', 'path', 1)
	97	predicate = route.predicates[0]
	98	request = self._makeRequest(config)
	99	request.method = 'GET'
	100	self.assertEqual(predicate(None, request), True)
	101	request = self._makeRequest(config)
	102	request.method = 'POST'
	103	self.assertEqual(predicate(None, request), False)
	104
	105	def test_add_route_with_path_info(self):
	106	config = self._makeOne(autocommit=True)
	107	config.add_route('name', 'path', path_info='/foo')
	108	route = self._assertRoute(config, 'name', 'path', 1)
	109	predicate = route.predicates[0]
	110	request = self._makeRequest(config)
a5d994	111	request.upath_info = '/foo'
a0b2c6	112	self.assertEqual(predicate(None, request), True)
CM	113	request = self._makeRequest(config)
a5d994	114	request.upath_info = '/'
CM	115	self.assertEqual(predicate(None, request), False)
	116
	117	def test_add_route_with_path_info_highorder(self):
	118	config = self._makeOne(autocommit=True)
	119	config.add_route('name', 'path',
	120	path_info=text_(b'/La Pe\xc3\xb1a', 'utf-8'))
	121	route = self._assertRoute(config, 'name', 'path', 1)
	122	predicate = route.predicates[0]
	123	request = self._makeRequest(config)
	124	request.upath_info = text_(b'/La Pe\xc3\xb1a', 'utf-8')
	125	self.assertEqual(predicate(None, request), True)
	126	request = self._makeRequest(config)
	127	request.upath_info = text_('/')
	128	self.assertEqual(predicate(None, request), False)
	129
	130	def test_add_route_with_path_info_regex(self):
	131	config = self._makeOne(autocommit=True)
	132	config.add_route('name', 'path',
	133	path_info=text_(br'/La Pe\w*', 'utf-8'))
	134	route = self._assertRoute(config, 'name', 'path', 1)
	135	predicate = route.predicates[0]
	136	request = self._makeRequest(config)
	137	request.upath_info = text_(b'/La Pe\xc3\xb1a', 'utf-8')
	138	self.assertEqual(predicate(None, request), True)
	139	request = self._makeRequest(config)
	140	request.upath_info = text_('/')
a0b2c6	141	self.assertEqual(predicate(None, request), False)
CM	142
	143	def test_add_route_with_request_param(self):
	144	config = self._makeOne(autocommit=True)
	145	config.add_route('name', 'path', request_param='abc')
	146	route = self._assertRoute(config, 'name', 'path', 1)
	147	predicate = route.predicates[0]
	148	request = self._makeRequest(config)
	149	request.params = {'abc':'123'}
	150	self.assertEqual(predicate(None, request), True)
	151	request = self._makeRequest(config)
	152	request.params = {}
	153	self.assertEqual(predicate(None, request), False)
	154
	155	def test_add_route_with_custom_predicates(self):
b01f1d	156	import warnings
a0b2c6	157	config = self._makeOne(autocommit=True)
CM	158	def pred1(context, request): pass
	159	def pred2(context, request): pass
b01f1d	160	with warnings.catch_warnings(record=True) as w:
CM	161	warnings.filterwarnings('always')
	162	config.add_route('name', 'path', custom_predicates=(pred1, pred2))
	163	self.assertEqual(len(w), 1)
a0b2c6	164	route = self._assertRoute(config, 'name', 'path', 2)
9c8ec5	165	self.assertEqual(len(route.predicates), 2)
a0b2c6	166
CM	167	def test_add_route_with_header(self):
	168	config = self._makeOne(autocommit=True)
	169	config.add_route('name', 'path', header='Host')
	170	route = self._assertRoute(config, 'name', 'path', 1)
	171	predicate = route.predicates[0]
	172	request = self._makeRequest(config)
	173	request.headers = {'Host':'example.com'}
	174	self.assertEqual(predicate(None, request), True)
	175	request = self._makeRequest(config)
	176	request.headers = {}
	177	self.assertEqual(predicate(None, request), False)
	178
	179	def test_add_route_with_accept(self):
	180	config = self._makeOne(autocommit=True)
	181	config.add_route('name', 'path', accept='text/xml')
	182	route = self._assertRoute(config, 'name', 'path', 1)
	183	predicate = route.predicates[0]
	184	request = self._makeRequest(config)
c3c83e	185	request.accept = DummyAccept('text/xml')
a0b2c6	186	self.assertEqual(predicate(None, request), True)
CM	187	request = self._makeRequest(config)
c3c83e	188	request.accept = DummyAccept('text/html')
MM	189	self.assertEqual(predicate(None, request), False)
	190
	191	def test_add_route_with_accept_list(self):
	192	config = self._makeOne(autocommit=True)
	193	config.add_route('name', 'path', accept=['text/xml', 'text/plain'])
	194	route = self._assertRoute(config, 'name', 'path', 1)
	195	predicate = route.predicates[0]
	196	request = self._makeRequest(config)
	197	request.accept = DummyAccept('text/xml')
	198	self.assertEqual(predicate(None, request), True)
	199	request = self._makeRequest(config)
	200	request.accept = DummyAccept('text/plain')
	201	self.assertEqual(predicate(None, request), True)
	202	request = self._makeRequest(config)
	203	request.accept = DummyAccept('text/html')
a0b2c6	204	self.assertEqual(predicate(None, request), False)
CM	205
4a9f4f	206	def test_add_route_with_wildcard_accept(self):
MM	207	config = self._makeOne(autocommit=True)
	208	config.add_route('name', 'path', accept='text/*')
	209	route = self._assertRoute(config, 'name', 'path', 1)
	210	predicate = route.predicates[0]
	211	request = self._makeRequest(config)
	212	request.accept = DummyAccept('text/xml', contains=True)
	213	self.assertEqual(predicate(None, request), True)
	214	request = self._makeRequest(config)
	215	request.accept = DummyAccept('application/json', contains=False)
	216	self.assertEqual(predicate(None, request), False)
	217
a0b2c6	218	def test_add_route_no_pattern_with_path(self):
CM	219	config = self._makeOne(autocommit=True)
	220	config.add_route('name', path='path')
	221	self._assertRoute(config, 'name', 'path')
	222
	223	def test_add_route_no_path_no_pattern(self):
	224	from pyramid.exceptions import ConfigurationError
	225	config = self._makeOne()
	226	self.assertRaises(ConfigurationError, config.add_route, 'name')
	227
	228	def test_add_route_with_pregenerator(self):
	229	config = self._makeOne(autocommit=True)
	230	config.add_route('name', 'pattern', pregenerator='123')
	231	route = self._assertRoute(config, 'name', 'pattern')
	232	self.assertEqual(route.pregenerator, '123')
	233
	234	def test_add_route_no_view_with_view_attr(self):
	235	config = self._makeOne(autocommit=True)
	236	from pyramid.exceptions import ConfigurationError
	237	try:
	238	config.add_route('name', '/pattern', view_attr='abc')
	239	except ConfigurationError:
	240	pass
	241	else: # pragma: no cover
	242	raise AssertionError
	243
	244	def test_add_route_no_view_with_view_context(self):
	245	config = self._makeOne(autocommit=True)
	246	from pyramid.exceptions import ConfigurationError
	247	try:
	248	config.add_route('name', '/pattern', view_context=DummyContext)
	249	except ConfigurationError:
	250	pass
	251	else: # pragma: no cover
	252	raise AssertionError
	253
	254	def test_add_route_no_view_with_view_permission(self):
	255	config = self._makeOne(autocommit=True)
	256	from pyramid.exceptions import ConfigurationError
	257	try:
	258	config.add_route('name', '/pattern', view_permission='edit')
	259	except ConfigurationError:
	260	pass
	261	else: # pragma: no cover
	262	raise AssertionError
	263
	264	def test_add_route_no_view_with_view_renderer(self):
	265	config = self._makeOne(autocommit=True)
	266	from pyramid.exceptions import ConfigurationError
	267	try:
	268	config.add_route('name', '/pattern', view_renderer='json')
	269	except ConfigurationError:
	270	pass
	271	else: # pragma: no cover
	272	raise AssertionError
	273
	274	class DummyRequest:
	275	subpath = ()
	276	matchdict = None
	277	def __init__(self, environ=None):
	278	if environ is None:
	279	environ = {}
	280	self.environ = environ
	281	self.params = {}
	282	self.cookies = {}
c3c83e	283
MM	284	class DummyAccept(object):
4a9f4f	285	def __init__(self, matches, *kw):
c3c83e	286	self.matches = list(matches)
4a9f4f	287	self.contains = kw.pop('contains', False)
c3c83e	288
MM	289	def acceptable_offers(self, offers):
	290	results = []
	291	for match in self.matches:
	292	if match in offers:
	293	results.append((match, 1.0))
	294	return results
4a9f4f	295
MM	296	def __contains__(self, value):
	297	return self.contains