RedHatTraining/pyramid.git

Michael Merickel

2018-10-15 2b024920847481592b1a13d4006d2a9fa8881d72

commit \| author \| age
4e6f98	1	import os
262cea	2	import unittest
CM	3	from pyramid.tests.test_scripts import dummy
	4
1dfd12	5
JA	6	class DummyIntrospector(object):
	7	def __init__(self):
	8	self.relations = {}
	9	self.introspectables = {}
	10
	11	def get(self, name, discrim):
	12	pass
	13
	14
262cea	15	class TestPRoutesCommand(unittest.TestCase):
CM	16	def _getTargetClass(self):
	17	from pyramid.scripts.proutes import PRoutesCommand
	18	return PRoutesCommand
	19
	20	def _makeOne(self):
	21	cmd = self._getTargetClass()([])
678790	22	cmd.bootstrap = dummy.DummyBootstrap()
MM	23	cmd.get_config_loader = dummy.DummyLoader()
a63b0f	24	cmd.args.config_uri = '/foo/bar/myapp.ini#myapp'
a99d2d	25
262cea	26	return cmd
CM	27
1dfd12	28	def _makeRegistry(self):
JA	29	from pyramid.registry import Registry
	30	registry = Registry()
	31	registry.introspector = DummyIntrospector()
	32	return registry
	33
	34	def _makeConfig(self, arg, *kw):
	35	from pyramid.config import Configurator
	36	config = Configurator(arg, *kw)
	37	return config
	38
49fb77	39	def test_good_args(self):
JA	40	cmd = self._getTargetClass()([])
678790	41	cmd.bootstrap = dummy.DummyBootstrap()
MM	42	cmd.get_config_loader = dummy.DummyLoader()
aa1ce3	43	cmd.args.config_uri = '/foo/bar/myapp.ini#myapp'
0be0f1	44	cmd.args.config_args = ('a=1',)
49fb77	45	route = dummy.DummyRoute('a', '/a')
JA	46	mapper = dummy.DummyMapper(route)
	47	cmd._get_mapper = lambda *arg: mapper
1dfd12	48	registry = self._makeRegistry()
678790	49	cmd.bootstrap = dummy.DummyBootstrap(registry=registry)
c495e9	50	L = []
CM	51	cmd.out = lambda msg: L.append(msg)
49fb77	52	cmd.run()
c495e9	53	self.assertTrue('<unknown>' in ''.join(L))
49fb77	54
JA	55	def test_bad_args(self):
	56	cmd = self._getTargetClass()([])
678790	57	cmd.bootstrap = dummy.DummyBootstrap()
MM	58	cmd.get_config_loader = dummy.DummyLoader()
a63b0f	59	cmd.args.config_uri = '/foo/bar/myapp.ini#myapp'
SP	60	cmd.args.config_vars = ('a',)
49fb77	61	route = dummy.DummyRoute('a', '/a')
JA	62	mapper = dummy.DummyMapper(route)
	63	cmd._get_mapper = lambda *arg: mapper
	64
	65	self.assertRaises(ValueError, cmd.run)
	66
262cea	67	def test_no_routes(self):
CM	68	command = self._makeOne()
	69	mapper = dummy.DummyMapper()
	70	command._get_mapper = lambda *arg: mapper
	71	L = []
	72	command.out = L.append
	73	result = command.run()
d58614	74	self.assertEqual(result, 0)
262cea	75	self.assertEqual(L, [])
CM	76
	77	def test_no_mapper(self):
	78	command = self._makeOne()
	79	command._get_mapper = lambda *arg:None
	80	L = []
	81	command.out = L.append
	82	result = command.run()
d58614	83	self.assertEqual(result, 0)
262cea	84	self.assertEqual(L, [])
CM	85
	86	def test_single_route_no_route_registered(self):
	87	command = self._makeOne()
	88	route = dummy.DummyRoute('a', '/a')
	89	mapper = dummy.DummyMapper(route)
	90	command._get_mapper = lambda *arg: mapper
1dfd12	91	registry = self._makeRegistry()
678790	92	command.bootstrap = dummy.DummyBootstrap(registry=registry)
1dfd12	93
262cea	94	L = []
CM	95	command.out = L.append
	96	result = command.run()
d58614	97	self.assertEqual(result, 0)
262cea	98	self.assertEqual(len(L), 3)
1dfd12	99	self.assertEqual(L[-1].split(), ['a', '/a', '<unknown>', '*'])
262cea	100
d386e1	101	def test_route_with_no_slash_prefix(self):
MM	102	command = self._makeOne()
	103	route = dummy.DummyRoute('a', 'a')
	104	mapper = dummy.DummyMapper(route)
	105	command._get_mapper = lambda *arg: mapper
	106	L = []
	107	command.out = L.append
1dfd12	108	registry = self._makeRegistry()
678790	109	command.bootstrap = dummy.DummyBootstrap(registry=registry)
d386e1	110	result = command.run()
d58614	111	self.assertEqual(result, 0)
d386e1	112	self.assertEqual(len(L), 3)
1dfd12	113	self.assertEqual(L[-1].split(), ['a', '/a', '<unknown>', '*'])
d386e1	114
262cea	115	def test_single_route_no_views_registered(self):
CM	116	from zope.interface import Interface
	117	from pyramid.interfaces import IRouteRequest
1dfd12	118	registry = self._makeRegistry()
JA	119
262cea	120	def view():pass
CM	121	class IMyRoute(Interface):
	122	pass
	123	registry.registerUtility(IMyRoute, IRouteRequest, name='a')
	124	command = self._makeOne()
	125	route = dummy.DummyRoute('a', '/a')
	126	mapper = dummy.DummyMapper(route)
	127	command._get_mapper = lambda *arg: mapper
	128	L = []
	129	command.out = L.append
678790	130	command.bootstrap = dummy.DummyBootstrap(registry=registry)
262cea	131	result = command.run()
d58614	132	self.assertEqual(result, 0)
262cea	133	self.assertEqual(len(L), 3)
1dfd12	134	self.assertEqual(L[-1].split()[:3], ['a', '/a', '<unknown>'])
262cea	135
CM	136	def test_single_route_one_view_registered(self):
	137	from zope.interface import Interface
	138	from pyramid.interfaces import IRouteRequest
	139	from pyramid.interfaces import IViewClassifier
	140	from pyramid.interfaces import IView
1dfd12	141	registry = self._makeRegistry()
JA	142
262cea	143	def view():pass
CM	144	class IMyRoute(Interface):
	145	pass
	146	registry.registerAdapter(view,
	147	(IViewClassifier, IMyRoute, Interface),
	148	IView, '')
	149	registry.registerUtility(IMyRoute, IRouteRequest, name='a')
	150	command = self._makeOne()
	151	route = dummy.DummyRoute('a', '/a')
	152	mapper = dummy.DummyMapper(route)
	153	command._get_mapper = lambda *arg: mapper
	154	L = []
	155	command.out = L.append
678790	156	command.bootstrap = dummy.DummyBootstrap(registry=registry)
262cea	157	result = command.run()
d58614	158	self.assertEqual(result, 0)
262cea	159	self.assertEqual(len(L), 3)
ae5ab3	160	compare_to = L[-1].split()[:3]
e51dd0	161	self.assertEqual(
JA	162	compare_to,
	163	['a', '/a', 'pyramid.tests.test_scripts.test_proutes.view']
	164	)
	165
360463	166	def test_one_route_with_long_name_one_view_registered(self):
JA	167	from zope.interface import Interface
	168	from pyramid.interfaces import IRouteRequest
	169	from pyramid.interfaces import IViewClassifier
	170	from pyramid.interfaces import IView
1dfd12	171	registry = self._makeRegistry()
JA	172
360463	173	def view():pass
JA	174
	175	class IMyRoute(Interface):
	176	pass
	177
	178	registry.registerAdapter(
	179	view,
	180	(IViewClassifier, IMyRoute, Interface),
	181	IView, ''
	182	)
	183
	184	registry.registerUtility(IMyRoute, IRouteRequest,
	185	name='very_long_name_123')
	186
	187	command = self._makeOne()
	188	route = dummy.DummyRoute(
	189	'very_long_name_123',
	190	'/and_very_long_pattern_as_well'
	191	)
	192	mapper = dummy.DummyMapper(route)
	193	command._get_mapper = lambda *arg: mapper
	194	L = []
	195	command.out = L.append
678790	196	command.bootstrap = dummy.DummyBootstrap(registry=registry)
360463	197	result = command.run()
JA	198	self.assertEqual(result, 0)
	199	self.assertEqual(len(L), 3)
	200	compare_to = L[-1].split()[:3]
	201	self.assertEqual(
	202	compare_to,
	203	['very_long_name_123',
	204	'/and_very_long_pattern_as_well',
	205	'pyramid.tests.test_scripts.test_proutes.view']
	206	)
	207
1bdb55	208	def test_class_view(self):
JA	209	from pyramid.renderers import null_renderer as nr
	210
	211	config = self._makeConfig(autocommit=True)
	212	config.add_route('foo', '/a/b')
	213	config.add_view(
	214	route_name='foo',
	215	view=dummy.DummyView,
	216	attr='view',
	217	renderer=nr,
	218	request_method='POST'
	219	)
	220
	221	command = self._makeOne()
	222	L = []
	223	command.out = L.append
678790	224	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
1bdb55	225	result = command.run()
JA	226	self.assertEqual(result, 0)
	227	self.assertEqual(len(L), 3)
	228	compare_to = L[-1].split()
	229	expected = [
	230	'foo', '/a/b',
	231	'pyramid.tests.test_scripts.dummy.DummyView.view', 'POST'
	232	]
	233	self.assertEqual(compare_to, expected)
	234
262cea	235	def test_single_route_one_view_registered_with_factory(self):
CM	236	from zope.interface import Interface
	237	from pyramid.interfaces import IRouteRequest
	238	from pyramid.interfaces import IViewClassifier
	239	from pyramid.interfaces import IView
1dfd12	240	registry = self._makeRegistry()
JA	241
262cea	242	def view():pass
CM	243	class IMyRoot(Interface):
	244	pass
	245	class IMyRoute(Interface):
	246	pass
	247	registry.registerAdapter(view,
	248	(IViewClassifier, IMyRoute, IMyRoot),
	249	IView, '')
	250	registry.registerUtility(IMyRoute, IRouteRequest, name='a')
	251	command = self._makeOne()
	252	def factory(request): pass
	253	route = dummy.DummyRoute('a', '/a', factory=factory)
	254	mapper = dummy.DummyMapper(route)
	255	command._get_mapper = lambda *arg: mapper
	256	L = []
	257	command.out = L.append
678790	258	command.bootstrap = dummy.DummyBootstrap(registry=registry)
262cea	259	result = command.run()
d58614	260	self.assertEqual(result, 0)
262cea	261	self.assertEqual(len(L), 3)
CM	262	self.assertEqual(L[-1].split()[:3], ['a', '/a', '<unknown>'])
	263
360463	264	def test_single_route_multiview_registered(self):
JA	265	from zope.interface import Interface
	266	from pyramid.interfaces import IRouteRequest
	267	from pyramid.interfaces import IViewClassifier
	268	from pyramid.interfaces import IMultiView
	269
1dfd12	270	registry = self._makeRegistry()
360463	271
JA	272	def view(): pass
	273
	274	class IMyRoute(Interface):
	275	pass
	276
	277	multiview1 = dummy.DummyMultiView(
	278	view, context='context',
	279	view_name='a1'
	280	)
	281
	282	registry.registerAdapter(
	283	multiview1,
	284	(IViewClassifier, IMyRoute, Interface),
	285	IMultiView, ''
	286	)
	287	registry.registerUtility(IMyRoute, IRouteRequest, name='a')
	288	command = self._makeOne()
	289	route = dummy.DummyRoute('a', '/a')
	290	mapper = dummy.DummyMapper(route)
	291	command._get_mapper = lambda *arg: mapper
	292	L = []
	293	command.out = L.append
678790	294	command.bootstrap = dummy.DummyBootstrap(registry=registry)
360463	295	result = command.run()
JA	296	self.assertEqual(result, 0)
	297	self.assertEqual(len(L), 3)
	298	compare_to = L[-1].split()[:3]
1dfd12	299	view_module = 'pyramid.tests.test_scripts.dummy'
JA	300	view_str = '<pyramid.tests.test_scripts.dummy.DummyMultiView'
	301	final = '%s.%s' % (view_module, view_str)
	302
360463	303	self.assertEqual(
JA	304	compare_to,
1dfd12	305	['a', '/a', final]
360463	306	)
JA	307
262cea	308	def test__get_mapper(self):
CM	309	from pyramid.urldispatch import RoutesMapper
	310	command = self._makeOne()
1dfd12	311	registry = self._makeRegistry()
JA	312
262cea	313	result = command._get_mapper(registry)
CM	314	self.assertEqual(result.__class__, RoutesMapper)
e51dd0	315
1dfd12	316	def test_one_route_all_methods_view_only_post(self):
JA	317	from pyramid.renderers import null_renderer as nr
	318
	319	def view1(context, request): return 'view1'
	320
	321	config = self._makeConfig(autocommit=True)
	322	config.add_route('foo', '/a/b')
	323	config.add_view(
	324	route_name='foo',
	325	view=view1,
	326	renderer=nr,
	327	request_method='POST'
	328	)
	329
	330	command = self._makeOne()
	331	L = []
	332	command.out = L.append
678790	333	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
1dfd12	334	result = command.run()
JA	335	self.assertEqual(result, 0)
	336	self.assertEqual(len(L), 3)
	337	compare_to = L[-1].split()
	338	expected = [
	339	'foo', '/a/b',
	340	'pyramid.tests.test_scripts.test_proutes.view1', 'POST'
	341	]
	342	self.assertEqual(compare_to, expected)
	343
	344	def test_one_route_only_post_view_all_methods(self):
	345	from pyramid.renderers import null_renderer as nr
	346
	347	def view1(context, request): return 'view1'
	348
	349	config = self._makeConfig(autocommit=True)
	350	config.add_route('foo', '/a/b', request_method='POST')
	351	config.add_view(
	352	route_name='foo',
	353	view=view1,
	354	renderer=nr,
	355	)
	356
	357	command = self._makeOne()
	358	L = []
	359	command.out = L.append
678790	360	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
1dfd12	361	result = command.run()
JA	362	self.assertEqual(result, 0)
	363	self.assertEqual(len(L), 3)
	364	compare_to = L[-1].split()
	365	expected = [
	366	'foo', '/a/b',
	367	'pyramid.tests.test_scripts.test_proutes.view1', 'POST'
	368	]
	369	self.assertEqual(compare_to, expected)
	370
	371	def test_one_route_only_post_view_post_and_get(self):
	372	from pyramid.renderers import null_renderer as nr
	373
	374	def view1(context, request): return 'view1'
	375
	376	config = self._makeConfig(autocommit=True)
	377	config.add_route('foo', '/a/b', request_method='POST')
	378	config.add_view(
	379	route_name='foo',
	380	view=view1,
	381	renderer=nr,
	382	request_method=('POST', 'GET')
	383	)
	384
	385	command = self._makeOne()
	386	L = []
	387	command.out = L.append
678790	388	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
1dfd12	389	result = command.run()
JA	390	self.assertEqual(result, 0)
	391	self.assertEqual(len(L), 3)
	392	compare_to = L[-1].split()
	393	expected = [
	394	'foo', '/a/b',
	395	'pyramid.tests.test_scripts.test_proutes.view1', 'POST'
	396	]
	397	self.assertEqual(compare_to, expected)
	398
	399	def test_route_request_method_mismatch(self):
	400	from pyramid.renderers import null_renderer as nr
	401
	402	def view1(context, request): return 'view1'
	403
	404	config = self._makeConfig(autocommit=True)
	405	config.add_route('foo', '/a/b', request_method='POST')
	406	config.add_view(
	407	route_name='foo',
	408	view=view1,
	409	renderer=nr,
	410	request_method='GET'
	411	)
	412
	413	command = self._makeOne()
	414	L = []
	415	command.out = L.append
678790	416	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
1dfd12	417	result = command.run()
JA	418	self.assertEqual(result, 0)
	419	self.assertEqual(len(L), 3)
	420	compare_to = L[-1].split()
	421	expected = [
	422	'foo', '/a/b',
	423	'pyramid.tests.test_scripts.test_proutes.view1',
	424	'<route', 'mismatch>'
	425	]
	426	self.assertEqual(compare_to, expected)
	427
	428	def test_route_static_views(self):
	429	from pyramid.renderers import null_renderer as nr
	430	config = self._makeConfig(autocommit=True)
	431	config.add_static_view('static', 'static', cache_max_age=3600)
4e6f98	432	path2 = os.path.normpath('/var/www/static')
CZ	433	config.add_static_view(name='static2', path=path2)
1dfd12	434	config.add_static_view(
JA	435	name='pyramid_scaffold',
	436	path='pyramid:scaffolds/starter/+package+/static'
	437	)
	438
	439	command = self._makeOne()
	440	L = []
	441	command.out = L.append
678790	442	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
1dfd12	443	result = command.run()
JA	444	self.assertEqual(result, 0)
	445	self.assertEqual(len(L), 5)
	446
	447	expected = [
	448	['__static/', '/static/*subpath',
	449	'pyramid.tests.test_scripts:static/', '*'],
4e6f98	450	['__static2/', '/static2/subpath', path2 + os.sep, ''],
1dfd12	451	['__pyramid_scaffold/', '/pyramid_scaffold/*subpath',
JA	452	'pyramid:scaffolds/starter/+package+/static/', '*'],
	453	]
	454
	455	for index, line in enumerate(L[2:]):
	456	data = line.split()
	457	self.assertEqual(data, expected[index])
	458
	459	def test_route_no_view(self):
	460	from pyramid.renderers import null_renderer as nr
	461	config = self._makeConfig(autocommit=True)
	462	config.add_route('foo', '/a/b', request_method='POST')
	463
	464	command = self._makeOne()
	465	L = []
	466	command.out = L.append
678790	467	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
1dfd12	468	result = command.run()
JA	469	self.assertEqual(result, 0)
	470	self.assertEqual(len(L), 3)
	471	compare_to = L[-1].split()
	472	expected = [
	473	'foo', '/a/b',
	474	'<unknown>',
	475	'POST',
	476	]
	477	self.assertEqual(compare_to, expected)
	478
	479	def test_route_as_wsgiapp(self):
	480	from pyramid.wsgi import wsgiapp2
	481
	482	config1 = self._makeConfig(autocommit=True)
	483	def view1(context, request): return 'view1'
	484	config1.add_route('foo', '/a/b', request_method='POST')
	485	config1.add_view(view=view1, route_name='foo')
	486
	487	config2 = self._makeConfig(autocommit=True)
	488	config2.add_route('foo', '/a/b', request_method='POST')
	489	config2.add_view(
	490	wsgiapp2(config1.make_wsgi_app()),
	491	route_name='foo',
	492	)
	493
	494	command = self._makeOne()
	495	L = []
	496	command.out = L.append
678790	497	command.bootstrap = dummy.DummyBootstrap(registry=config2.registry)
1dfd12	498	result = command.run()
JA	499	self.assertEqual(result, 0)
	500	self.assertEqual(len(L), 3)
	501	compare_to = L[-1].split()
	502	expected = [
	503	'foo', '/a/b',
	504	'<wsgiapp>',
	505	'POST',
	506	]
	507	self.assertEqual(compare_to, expected)
	508
228a5e	509	def test_route_is_get_view_request_method_not_post(self):
JA	510	from pyramid.renderers import null_renderer as nr
	511	from pyramid.config import not_
	512
	513	def view1(context, request): return 'view1'
	514
	515	config = self._makeConfig(autocommit=True)
	516	config.add_route('foo', '/a/b', request_method='GET')
	517	config.add_view(
	518	route_name='foo',
	519	view=view1,
	520	renderer=nr,
	521	request_method=not_('POST')
	522	)
	523
	524	command = self._makeOne()
	525	L = []
	526	command.out = L.append
678790	527	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
228a5e	528	result = command.run()
JA	529	self.assertEqual(result, 0)
	530	self.assertEqual(len(L), 3)
	531	compare_to = L[-1].split()
	532	expected = [
	533	'foo', '/a/b',
	534	'pyramid.tests.test_scripts.test_proutes.view1',
	535	'GET'
	536	]
	537	self.assertEqual(compare_to, expected)
	538
	539	def test_view_request_method_not_post(self):
	540	from pyramid.renderers import null_renderer as nr
	541	from pyramid.config import not_
	542
	543	def view1(context, request): return 'view1'
	544
	545	config = self._makeConfig(autocommit=True)
	546	config.add_route('foo', '/a/b')
	547	config.add_view(
	548	route_name='foo',
	549	view=view1,
	550	renderer=nr,
	551	request_method=not_('POST')
	552	)
	553
	554	command = self._makeOne()
	555	L = []
	556	command.out = L.append
678790	557	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
228a5e	558	result = command.run()
JA	559	self.assertEqual(result, 0)
	560	self.assertEqual(len(L), 3)
	561	compare_to = L[-1].split()
	562	expected = [
	563	'foo', '/a/b',
	564	'pyramid.tests.test_scripts.test_proutes.view1',
	565	'!POST,*'
	566	]
	567	self.assertEqual(compare_to, expected)
	568
c966a9	569	def test_view_glob(self):
JA	570	from pyramid.renderers import null_renderer as nr
	571	from pyramid.config import not_
	572
	573	def view1(context, request): return 'view1'
	574	def view2(context, request): return 'view2'
	575
	576	config = self._makeConfig(autocommit=True)
	577	config.add_route('foo', '/a/b')
	578	config.add_view(
	579	route_name='foo',
	580	view=view1,
	581	renderer=nr,
	582	request_method=not_('POST')
	583	)
	584
	585	config.add_route('bar', '/b/a')
	586	config.add_view(
	587	route_name='bar',
	588	view=view2,
	589	renderer=nr,
	590	request_method=not_('POST')
	591	)
	592
	593	command = self._makeOne()
0be0f1	594	command.args.glob = 'foo'
c966a9	595
JA	596	L = []
	597	command.out = L.append
678790	598	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
c966a9	599	result = command.run()
JA	600	self.assertEqual(result, 0)
	601	self.assertEqual(len(L), 3)
	602	compare_to = L[-1].split()
	603	expected = [
	604	'foo', '/a/b',
	605	'pyramid.tests.test_scripts.test_proutes.view1',
	606	'!POST,*'
	607	]
	608	self.assertEqual(compare_to, expected)
	609
a99d2d	610	def test_good_format(self):
JA	611	from pyramid.renderers import null_renderer as nr
	612	from pyramid.config import not_
	613
	614	def view1(context, request): return 'view1'
	615
	616	config = self._makeConfig(autocommit=True)
	617	config.add_route('foo', '/a/b')
	618	config.add_view(
	619	route_name='foo',
	620	view=view1,
	621	renderer=nr,
	622	request_method=not_('POST')
	623	)
	624
	625	command = self._makeOne()
0be0f1	626	command.args.glob = 'foo'
SP	627	command.args.format = 'method,name'
a99d2d	628	L = []
JA	629	command.out = L.append
678790	630	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
a99d2d	631	result = command.run()
JA	632	self.assertEqual(result, 0)
	633	self.assertEqual(len(L), 3)
	634	compare_to = L[-1].split()
	635	expected = ['!POST,*', 'foo']
	636
	637	self.assertEqual(compare_to, expected)
	638	self.assertEqual(L[0].split(), ['Method', 'Name'])
	639
	640	def test_bad_format(self):
	641	from pyramid.renderers import null_renderer as nr
	642	from pyramid.config import not_
	643
	644	def view1(context, request): return 'view1'
	645
	646	config = self._makeConfig(autocommit=True)
	647	config.add_route('foo', '/a/b')
	648	config.add_view(
	649	route_name='foo',
	650	view=view1,
	651	renderer=nr,
	652	request_method=not_('POST')
	653	)
	654
	655	command = self._makeOne()
0be0f1	656	command.args.glob = 'foo'
SP	657	command.args.format = 'predicates,name,pattern'
a99d2d	658	L = []
JA	659	command.out = L.append
678790	660	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
a99d2d	661	expected = (
JA	662	"You provided invalid formats ['predicates'], "
	663	"Available formats are ['name', 'pattern', 'view', 'method']"
	664	)
	665	result = command.run()
	666	self.assertEqual(result, 2)
	667	self.assertEqual(L[0], expected)
	668
b8ba0f	669	def test_config_format_ini_newlines(self):
a99d2d	670	from pyramid.renderers import null_renderer as nr
JA	671	from pyramid.config import not_
	672
	673	def view1(context, request): return 'view1'
	674
	675	config = self._makeConfig(autocommit=True)
	676	config.add_route('foo', '/a/b')
	677	config.add_view(
	678	route_name='foo',
	679	view=view1,
	680	renderer=nr,
	681	request_method=not_('POST')
	682	)
	683
	684	command = self._makeOne()
b8ba0f	685
a99d2d	686	L = []
JA	687	command.out = L.append
678790	688	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
MM	689	command.get_config_loader = dummy.DummyLoader(
	690	{'proutes': {'format': 'method\nname'}})
b8ba0f	691
JA	692	result = command.run()
	693	self.assertEqual(result, 0)
	694	self.assertEqual(len(L), 3)
	695	compare_to = L[-1].split()
	696	expected = ['!POST,*', 'foo']
	697
	698	self.assertEqual(compare_to, expected)
	699	self.assertEqual(L[0].split(), ['Method', 'Name'])
	700
	701	def test_config_format_ini_spaces(self):
	702	from pyramid.renderers import null_renderer as nr
	703	from pyramid.config import not_
	704
	705	def view1(context, request): return 'view1'
	706
	707	config = self._makeConfig(autocommit=True)
	708	config.add_route('foo', '/a/b')
	709	config.add_view(
	710	route_name='foo',
	711	view=view1,
	712	renderer=nr,
	713	request_method=not_('POST')
	714	)
	715
	716	command = self._makeOne()
	717
	718	L = []
	719	command.out = L.append
678790	720	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
MM	721	command.get_config_loader = dummy.DummyLoader(
	722	{'proutes': {'format': 'method name'}})
b8ba0f	723
JA	724	result = command.run()
	725	self.assertEqual(result, 0)
	726	self.assertEqual(len(L), 3)
	727	compare_to = L[-1].split()
	728	expected = ['!POST,*', 'foo']
	729
	730	self.assertEqual(compare_to, expected)
	731	self.assertEqual(L[0].split(), ['Method', 'Name'])
	732
	733	def test_config_format_ini_commas(self):
	734	from pyramid.renderers import null_renderer as nr
	735	from pyramid.config import not_
	736
	737	def view1(context, request): return 'view1'
	738
	739	config = self._makeConfig(autocommit=True)
	740	config.add_route('foo', '/a/b')
	741	config.add_view(
	742	route_name='foo',
	743	view=view1,
	744	renderer=nr,
	745	request_method=not_('POST')
	746	)
	747
	748	command = self._makeOne()
	749
	750	L = []
	751	command.out = L.append
678790	752	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
MM	753	command.get_config_loader = dummy.DummyLoader(
	754	{'proutes': {'format': 'method,name'}})
a99d2d	755
JA	756	result = command.run()
	757	self.assertEqual(result, 0)
	758	self.assertEqual(len(L), 3)
	759	compare_to = L[-1].split()
	760	expected = ['!POST,*', 'foo']
	761
	762	self.assertEqual(compare_to, expected)
	763	self.assertEqual(L[0].split(), ['Method', 'Name'])
	764
582c2e	765	def test_static_routes_included_in_list(self):
JA	766	from pyramid.renderers import null_renderer as nr
	767
	768	config = self._makeConfig(autocommit=True)
	769	config.add_route('foo', 'http://example.com/bar.aspx', static=True)
	770
	771	command = self._makeOne()
	772	L = []
	773	command.out = L.append
678790	774	command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
582c2e	775	result = command.run()
JA	776	self.assertEqual(result, 0)
	777	self.assertEqual(len(L), 3)
	778	compare_to = L[-1].split()
	779	expected = [
	780	'foo', 'http://example.com/bar.aspx',
	781	'<unknown>', '*',
	782	]
	783	self.assertEqual(compare_to, expected)
	784
d29151	785	class Test_main(unittest.TestCase):
CM	786	def _callFUT(self, argv):
	787	from pyramid.scripts.proutes import main
	788	return main(argv, quiet=True)
	789
	790	def test_it(self):
	791	result = self._callFUT(['proutes'])
d58614	792	self.assertEqual(result, 2)