RedHatTraining/pyramid.git

Michael Merickel

2018-10-26 572e03c1e47385f093ffb701e21c226f99247837

commit \| author \| age
b0a241	1	import unittest
CM	2
b60bdb	3	from pyramid.testing import cleanUp
CM	4	from pyramid import testing
8e606d	5	from pyramid.compat import text_
b0a241	6
0c29cf	7
d81ea3	8	class TestJSON(unittest.TestCase):
a7b1a9	9	def setUp(self):
CM	10	self.config = testing.setUp()
	11
	12	def tearDown(self):
	13	testing.tearDown()
d81ea3	14
MM	15	def _makeOne(self, **kw):
	16	from pyramid.renderers import JSON
0c29cf	17
d81ea3	18	return JSON(**kw)
ef68a7	19
CM	20	def test_it(self):
d81ea3	21	renderer = self._makeOne()(None)
0c29cf	22	result = renderer({'a': 1}, {})
23b7a2	23	self.assertEqual(result, '{"a": 1}')
19473e	24
c4c9a8	25	def test_with_request_content_type_notset(self):
CM	26	request = testing.DummyRequest()
d81ea3	27	renderer = self._makeOne()(None)
0c29cf	28	renderer({'a': 1}, {'request': request})
a7b1a9	29	self.assertEqual(request.response.content_type, 'application/json')
c4c9a8	30
CM	31	def test_with_request_content_type_set(self):
	32	request = testing.DummyRequest()
a7b1a9	33	request.response.content_type = 'text/mishmash'
d81ea3	34	renderer = self._makeOne()(None)
0c29cf	35	renderer({'a': 1}, {'request': request})
a7b1a9	36	self.assertEqual(request.response.content_type, 'text/mishmash')
c4c9a8	37
677216	38	def test_with_custom_adapter(self):
e012aa	39	request = testing.DummyRequest()
d81ea3	40	from datetime import datetime
0c29cf	41
e012aa	42	def adapter(obj, req):
CM	43	self.assertEqual(req, request)
dfaf54	44	return obj.isoformat()
0c29cf	45
d81ea3	46	now = datetime.utcnow()
677216	47	renderer = self._makeOne()
MM	48	renderer.add_adapter(datetime, adapter)
0c29cf	49	result = renderer(None)({'a': now}, {'request': request})
23b7a2	50	self.assertEqual(result, '{"a": "%s"}' % now.isoformat())
d81ea3	51
677216	52	def test_with_custom_adapter2(self):
e012aa	53	request = testing.DummyRequest()
677216	54	from datetime import datetime
0c29cf	55
e012aa	56	def adapter(obj, req):
CM	57	self.assertEqual(req, request)
677216	58	return obj.isoformat()
0c29cf	59
677216	60	now = datetime.utcnow()
MM	61	renderer = self._makeOne(adapters=((datetime, adapter),))
0c29cf	62	result = renderer(None)({'a': now}, {'request': request})
23b7a2	63	self.assertEqual(result, '{"a": "%s"}' % now.isoformat())
677216	64
MM	65	def test_with_custom_serializer(self):
	66	class Serializer(object):
	67	def __call__(self, obj, **kw):
	68	self.obj = obj
	69	self.kw = kw
	70	return 'foo'
0c29cf	71
677216	72	serializer = Serializer()
MM	73	renderer = self._makeOne(serializer=serializer, baz=5)
0c29cf	74	obj = {'a': 'b'}
677216	75	result = renderer(None)(obj, {})
23b7a2	76	self.assertEqual(result, 'foo')
677216	77	self.assertEqual(serializer.obj, obj)
MM	78	self.assertEqual(serializer.kw['baz'], 5)
	79	self.assertTrue('default' in serializer.kw)
	80
	81	def test_with_object_adapter(self):
e012aa	82	request = testing.DummyRequest()
CM	83	outerself = self
0c29cf	84
ba6052	85	class MyObject(object):
WWI	86	def __init__(self, x):
	87	self.x = x
0c29cf	88
e012aa	89	def __json__(self, req):
CM	90	outerself.assertEqual(req, request)
ba6052	91	return {'x': self.x}
WWI	92
	93	objects = [MyObject(1), MyObject(2)]
	94	renderer = self._makeOne()(None)
0c29cf	95	result = renderer(objects, {'request': request})
23b7a2	96	self.assertEqual(result, '[{"x": 1}, {"x": 2}]')
ba6052	97
677216	98	def test_with_object_adapter_no___json__(self):
de797c	99	class MyObject(object):
CM	100	def __init__(self, x):
	101	self.x = x
0c29cf	102
de797c	103	objects = [MyObject(1), MyObject(2)]
CM	104	renderer = self._makeOne()(None)
	105	self.assertRaises(TypeError, renderer, objects, {})
	106
0c29cf	107
19473e	108	class Test_string_renderer_factory(unittest.TestCase):
CM	109	def _callFUT(self, name):
b60bdb	110	from pyramid.renderers import string_renderer_factory
0c29cf	111
19473e	112	return string_renderer_factory(name)
CM	113
	114	def test_it_unicode(self):
	115	renderer = self._callFUT(None)
8e606d	116	value = text_('La Pe\xc3\xb1a', 'utf-8')
e46105	117	result = renderer(value, {})
19473e	118	self.assertEqual(result, value)
b9457d	119
19473e	120	def test_it_str(self):
CM	121	renderer = self._callFUT(None)
	122	value = 'La Pe\xc3\xb1a'
e46105	123	result = renderer(value, {})
19473e	124	self.assertEqual(result, value)
CM	125
	126	def test_it_other(self):
	127	renderer = self._callFUT(None)
	128	value = None
e46105	129	result = renderer(value, {})
19473e	130	self.assertEqual(result, 'None')
ef68a7	131
c4c9a8	132	def test_with_request_content_type_notset(self):
CM	133	request = testing.DummyRequest()
	134	renderer = self._callFUT(None)
0c29cf	135	renderer('', {'request': request})
a7b1a9	136	self.assertEqual(request.response.content_type, 'text/plain')
c4c9a8	137
CM	138	def test_with_request_content_type_set(self):
	139	request = testing.DummyRequest()
a7b1a9	140	request.response.content_type = 'text/mishmash'
c4c9a8	141	renderer = self._callFUT(None)
0c29cf	142	renderer('', {'request': request})
a7b1a9	143	self.assertEqual(request.response.content_type, 'text/mishmash')
c4c9a8	144
62b479	145
CM	146	class TestRendererHelper(unittest.TestCase):
250c02	147	def setUp(self):
62b479	148	self.config = cleanUp()
250c02	149
CM	150	def tearDown(self):
62b479	151	cleanUp()
250c02	152
62b479	153	def _makeOne(self, arg, *kw):
b60bdb	154	from pyramid.renderers import RendererHelper
0c29cf	155
62b479	156	return RendererHelper(arg, *kw)
250c02	157
3a2af3	158	def test_instance_conforms(self):
CM	159	from zope.interface.verify import verifyObject
	160	from pyramid.interfaces import IRendererInfo
0c29cf	161
3a2af3	162	helper = self._makeOne()
CM	163	verifyObject(IRendererInfo, helper)
d99dc7	164
CM	165	def test_settings_registry_settings_is_None(self):
	166	class Dummy(object):
	167	settings = None
0c29cf	168
d99dc7	169	helper = self._makeOne(registry=Dummy)
CM	170	self.assertEqual(helper.settings, {})
	171
1939d0	172	def test_settings_registry_name_is_None(self):
CM	173	class Dummy(object):
	174	settings = None
0c29cf	175
1939d0	176	helper = self._makeOne(registry=Dummy)
CM	177	self.assertEqual(helper.name, None)
	178	self.assertEqual(helper.type, '')
	179
d99dc7	180	def test_settings_registry_settings_is_not_None(self):
CM	181	class Dummy(object):
0c29cf	182	settings = {'a': 1}
MM	183
d99dc7	184	helper = self._makeOne(registry=Dummy)
0c29cf	185	self.assertEqual(helper.settings, {'a': 1})
3a2af3	186
62b479	187	def _registerRendererFactory(self):
b60bdb	188	from pyramid.interfaces import IRendererFactory
0c29cf	189
62b479	190	def renderer(*arg):
CM	191	def respond(*arg):
	192	return arg
0c29cf	193
5cd392	194	renderer.respond = respond
62b479	195	return respond
0c29cf	196
MM	197	self.config.registry.registerUtility(
	198	renderer, IRendererFactory, name='.foo'
	199	)
62b479	200	return renderer
CM	201
a7b1a9	202	def _registerResponseFactory(self):
CM	203	from pyramid.interfaces import IResponseFactory
0c29cf	204
a7b1a9	205	class ResponseFactory(object):
CM	206	pass
32cb80	207
JA	208	self.config.registry.registerUtility(
	209	lambda r: ResponseFactory(), IResponseFactory
	210	)
a7b1a9	211
62b479	212	def test_render_to_response(self):
CM	213	self._registerRendererFactory()
a7b1a9	214	self._registerResponseFactory()
62b479	215	request = Dummy()
CM	216	helper = self._makeOne('loo.foo')
0c29cf	217	response = helper.render_to_response('values', {}, request=request)
f0a9df	218	self.assertEqual(response.app_iter[0], 'values')
LR	219	self.assertEqual(response.app_iter[1], {})
5cd392	220
CM	221	def test_get_renderer(self):
	222	factory = self._registerRendererFactory()
	223	helper = self._makeOne('loo.foo')
	224	self.assertEqual(helper.get_renderer(), factory.respond)
62b479	225
877904	226	def test_render_view(self):
7c0f09	227	import pyramid.csrf
0c29cf	228
877904	229	self._registerRendererFactory()
a7b1a9	230	self._registerResponseFactory()
877904	231	request = Dummy()
CM	232	helper = self._makeOne('loo.foo')
	233	view = 'view'
	234	context = 'context'
	235	request = testing.DummyRequest()
	236	response = 'response'
	237	response = helper.render_view(request, response, view, context)
7c0f09	238	get_csrf = response.app_iter[1].pop('get_csrf_token')
0c29cf	239	self.assertEqual(get_csrf.args, (request,))
7c0f09	240	self.assertEqual(get_csrf.func, pyramid.csrf.get_csrf_token)
f0a9df	241	self.assertEqual(response.app_iter[0], 'response')
0c29cf	242	self.assertEqual(
MM	243	response.app_iter[1],
	244	{
	245	'renderer_info': helper,
	246	'renderer_name': 'loo.foo',
	247	'request': request,
	248	'context': 'context',
	249	'view': 'view',
	250	'req': request,
	251	},
	252	)
877904	253
62b479	254	def test_render_explicit_registry(self):
CM	255	factory = self._registerRendererFactory()
0c29cf	256
62b479	257	class DummyRegistry(object):
CM	258	def __init__(self):
6f1973	259	self.responses = [factory, lambda *arg: {}, None]
0c29cf	260
62b479	261	def queryUtility(self, iface, name=None):
CM	262	self.queried = True
	263	return self.responses.pop(0)
0c29cf	264
a76e99	265	def notify(self, event):
CM	266	self.event = event
0c29cf	267
62b479	268	reg = DummyRegistry()
CM	269	helper = self._makeOne('loo.foo', registry=reg)
	270	result = helper.render('value', {})
68c813	271	self.assertEqual(result[0], 'value')
CM	272	self.assertEqual(result[1], {})
a1d395	273	self.assertTrue(reg.queried)
5c52da	274	self.assertEqual(reg.event, {})
a76e99	275	self.assertEqual(reg.event.__class__.__name__, 'BeforeRender')
62b479	276
CM	277	def test_render_system_values_is_None(self):
7c0f09	278	import pyramid.csrf
0c29cf	279
62b479	280	self._registerRendererFactory()
CM	281	request = Dummy()
	282	context = Dummy()
	283	request.context = context
	284	helper = self._makeOne('loo.foo')
	285	result = helper.render('values', None, request=request)
7c0f09	286	get_csrf = result[1].pop('get_csrf_token')
0c29cf	287	self.assertEqual(get_csrf.args, (request,))
7c0f09	288	self.assertEqual(get_csrf.func, pyramid.csrf.get_csrf_token)
0c29cf	289	system = {
MM	290	'request': request,
	291	'context': context,
	292	'renderer_name': 'loo.foo',
	293	'view': None,
	294	'renderer_info': helper,
	295	'req': request,
	296	}
68c813	297	self.assertEqual(result[0], 'values')
CM	298	self.assertEqual(result[1], system)
62b479	299
a7b1a9	300	def test__make_response_request_is_None(self):
CM	301	request = None
	302	helper = self._makeOne('loo.foo')
	303	response = helper._make_response('abc', request)
8e606d	304	self.assertEqual(response.body, b'abc')
a7b1a9	305
CM	306	def test__make_response_request_is_None_response_factory_exists(self):
	307	self._registerResponseFactory()
	308	request = None
	309	helper = self._makeOne('loo.foo')
0e131e	310	response = helper._make_response(b'abc', request)
a7b1a9	311	self.assertEqual(response.__class__.__name__, 'ResponseFactory')
8e606d	312	self.assertEqual(response.body, b'abc')
a7b1a9	313
CM	314	def test__make_response_result_is_unicode(self):
	315	from pyramid.response import Response
0c29cf	316
250c02	317	request = testing.DummyRequest()
a7b1a9	318	request.response = Response()
CM	319	helper = self._makeOne('loo.foo')
8e606d	320	la = text_('/La Pe\xc3\xb1a', 'utf-8')
a7b1a9	321	response = helper._make_response(la, request)
CM	322	self.assertEqual(response.body, la.encode('utf-8'))
	323
	324	def test__make_response_result_is_str(self):
	325	from pyramid.response import Response
0c29cf	326
a7b1a9	327	request = testing.DummyRequest()
CM	328	request.response = Response()
	329	helper = self._makeOne('loo.foo')
8e606d	330	la = text_('/La Pe\xc3\xb1a', 'utf-8')
a7b1a9	331	response = helper._make_response(la.encode('utf-8'), request)
CM	332	self.assertEqual(response.body, la.encode('utf-8'))
	333
f0a9df	334	def test__make_response_result_is_iterable(self):
LR	335	from pyramid.response import Response
0c29cf	336
f0a9df	337	request = testing.DummyRequest()
LR	338	request.response = Response()
	339	helper = self._makeOne('loo.foo')
	340	la = text_('/La Pe\xc3\xb1a', 'utf-8')
	341	response = helper._make_response([la.encode('utf-8')], request)
	342	self.assertEqual(response.body, la.encode('utf-8'))
	343
	344	def test__make_response_result_is_other(self):
	345	self._registerResponseFactory()
	346	request = None
	347	helper = self._makeOne('loo.foo')
	348	result = object()
	349	response = helper._make_response(result, request)
	350	self.assertEqual(response.body, result)
	351
a007a4	352	def test__make_response_result_is_None_no_body(self):
5cd392	353	from pyramid.response import Response
0c29cf	354
5cd392	355	request = testing.DummyRequest()
CM	356	request.response = Response()
	357	helper = self._makeOne('loo.foo')
	358	response = helper._make_response(None, request)
cf3d1e	359	self.assertEqual(response.body, b'')
a007a4	360
CM	361	def test__make_response_result_is_None_existing_body_not_molested(self):
	362	from pyramid.response import Response
0c29cf	363
a007a4	364	request = testing.DummyRequest()
CM	365	response = Response()
	366	response.body = b'abc'
	367	request.response = response
	368	helper = self._makeOne('loo.foo')
	369	response = helper._make_response(None, request)
	370	self.assertEqual(response.body, b'abc')
b9457d	371
250c02	372	def test_with_alternate_response_factory(self):
b60bdb	373	from pyramid.interfaces import IResponseFactory
0c29cf	374
250c02	375	class ResponseFactory(object):
a7b1a9	376	def __init__(self):
CM	377	pass
0c29cf	378
32cb80	379	self.config.registry.registerUtility(
JA	380	lambda r: ResponseFactory(), IResponseFactory
	381	)
250c02	382	request = testing.DummyRequest()
62b479	383	helper = self._makeOne('loo.foo')
0e131e	384	response = helper._make_response(b'abc', request)
250c02	385	self.assertEqual(response.__class__, ResponseFactory)
8e606d	386	self.assertEqual(response.body, b'abc')
250c02	387
62b479	388	def test__make_response_with_real_request(self):
250c02	389	# functional
b60bdb	390	from pyramid.request import Request
0c29cf	391
250c02	392	request = Request({})
a7b1a9	393	request.registry = self.config.registry
CM	394	request.response.status = '406 You Lose'
62b479	395	helper = self._makeOne('loo.foo')
CM	396	response = helper._make_response('abc', request)
250c02	397	self.assertEqual(response.status, '406 You Lose')
8e606d	398	self.assertEqual(response.body, b'abc')
250c02	399
73c0ae	400	def test_clone_noargs(self):
CM	401	helper = self._makeOne('name', 'package', 'registry')
	402	cloned_helper = helper.clone()
	403	self.assertEqual(cloned_helper.name, 'name')
	404	self.assertEqual(cloned_helper.package, 'package')
	405	self.assertEqual(cloned_helper.registry, 'registry')
	406	self.assertFalse(helper is cloned_helper)
	407
	408	def test_clone_allargs(self):
	409	helper = self._makeOne('name', 'package', 'registry')
0c29cf	410	cloned_helper = helper.clone(
MM	411	name='name2', package='package2', registry='registry2'
	412	)
73c0ae	413	self.assertEqual(cloned_helper.name, 'name2')
CM	414	self.assertEqual(cloned_helper.package, 'package2')
	415	self.assertEqual(cloned_helper.registry, 'registry2')
	416	self.assertFalse(helper is cloned_helper)
	417
e307fc	418	def test_renderer_absolute_file(self):
CM	419	registry = self.config.registry
	420	settings = {}
	421	registry.settings = settings
	422	from pyramid.interfaces import IRendererFactory
	423	import os
0c29cf	424
e307fc	425	here = os.path.dirname(os.path.abspath(__file__))
CM	426	fixture = os.path.join(here, 'fixtures/minimal.pt')
0c29cf	427
e307fc	428	def factory(info, **kw):
CM	429	return info
0c29cf	430
e307fc	431	self.config.registry.registerUtility(
0c29cf	432	factory, IRendererFactory, name='.pt'
MM	433	)
e307fc	434	result = self._makeOne(fixture).renderer
CM	435	self.assertEqual(result.registry, registry)
	436	self.assertEqual(result.type, '.pt')
	437	self.assertEqual(result.package, None)
	438	self.assertEqual(result.name, fixture)
	439	self.assertEqual(result.settings, settings)
	440
	441	def test_renderer_with_package(self):
	442	import pyramid
0c29cf	443
e307fc	444	registry = self.config.registry
CM	445	settings = {}
	446	registry.settings = settings
	447	from pyramid.interfaces import IRendererFactory
	448	import os
0c29cf	449
e307fc	450	here = os.path.dirname(os.path.abspath(__file__))
CM	451	fixture = os.path.join(here, 'fixtures/minimal.pt')
0c29cf	452
e307fc	453	def factory(info, **kw):
CM	454	return info
0c29cf	455
e307fc	456	self.config.registry.registerUtility(
0c29cf	457	factory, IRendererFactory, name='.pt'
MM	458	)
e307fc	459	result = self._makeOne(fixture, pyramid).renderer
CM	460	self.assertEqual(result.registry, registry)
	461	self.assertEqual(result.type, '.pt')
	462	self.assertEqual(result.package, pyramid)
	463	self.assertEqual(result.name, fixture)
	464	self.assertEqual(result.settings, settings)
	465
	466	def test_renderer_missing(self):
	467	inst = self._makeOne('foo')
	468	self.assertRaises(ValueError, getattr, inst, 'renderer')
	469
0c29cf	470
aa2fe1	471	class TestNullRendererHelper(unittest.TestCase):
CM	472	def setUp(self):
	473	self.config = cleanUp()
	474
	475	def tearDown(self):
	476	cleanUp()
	477
	478	def _makeOne(self, arg, *kw):
	479	from pyramid.renderers import NullRendererHelper
0c29cf	480
aa2fe1	481	return NullRendererHelper(arg, *kw)
CM	482
	483	def test_instance_conforms(self):
	484	from zope.interface.verify import verifyObject
	485	from pyramid.interfaces import IRendererInfo
0c29cf	486
aa2fe1	487	helper = self._makeOne()
CM	488	verifyObject(IRendererInfo, helper)
	489
	490	def test_render_view(self):
	491	helper = self._makeOne()
	492	self.assertEqual(helper.render_view(None, True, None, None), True)
	493
	494	def test_render(self):
	495	helper = self._makeOne()
	496	self.assertEqual(helper.render(True, None, None), True)
	497
	498	def test_render_to_response(self):
	499	helper = self._makeOne()
	500	self.assertEqual(helper.render_to_response(True, None, None), True)
	501
	502	def test_clone(self):
	503	helper = self._makeOne()
	504	self.assertTrue(helper.clone() is helper)
	505
0c29cf	506
250c02	507	class Test_render(unittest.TestCase):
CM	508	def setUp(self):
	509	self.config = testing.setUp()
	510
	511	def tearDown(self):
	512	testing.tearDown()
	513
62b479	514	def _callFUT(self, renderer_name, value, request=None, package=None):
b60bdb	515	from pyramid.renderers import render
0c29cf	516
62b479	517	return render(renderer_name, value, request=request, package=package)
250c02	518
3db6c0	519	def _registerRenderer(self):
0c29cf	520	renderer = self.config.testing_add_renderer('tests:abc/def.pt')
250c02	521	renderer.string_response = 'abc'
3db6c0	522	return renderer
CM	523
	524	def test_it_no_request(self):
	525	renderer = self._registerRenderer()
62b479	526	result = self._callFUT('abc/def.pt', dict(a=1))
250c02	527	self.assertEqual(result, 'abc')
CM	528	renderer.assert_(a=1)
	529	renderer.assert_(request=None)
b9457d	530
250c02	531	def test_it_with_request(self):
3db6c0	532	renderer = self._registerRenderer()
250c02	533	request = testing.DummyRequest()
0c29cf	534	result = self._callFUT('abc/def.pt', dict(a=1), request=request)
250c02	535	self.assertEqual(result, 'abc')
CM	536	renderer.assert_(a=1)
	537	renderer.assert_(request=request)
	538
d99dc7	539	def test_it_with_package(self):
dd3cc8	540	import tests
0c29cf	541
3db6c0	542	renderer = self._registerRenderer()
d99dc7	543	request = testing.DummyRequest()
0c29cf	544	result = self._callFUT(
MM	545	'abc/def.pt', dict(a=1), request=request, package=tests
	546	)
d99dc7	547	self.assertEqual(result, 'abc')
CM	548	renderer.assert_(a=1)
	549	renderer.assert_(request=request)
	550
3db6c0	551	def test_response_preserved(self):
3803d9	552	request = testing.DummyRequest()
0c29cf	553	response = object() # should error if mutated
3803d9	554	request.response = response
3db6c0	555	# use a json renderer, which will mutate the response
3803d9	556	result = self._callFUT('json', dict(a=1), request=request)
23b7a2	557	self.assertEqual(result, '{"a": 1}')
3803d9	558	self.assertEqual(request.response, response)
MM	559
3db6c0	560	def test_no_response_to_preserve(self):
CM	561	from pyramid.decorator import reify
0c29cf	562
3db6c0	563	class DummyRequestWithClassResponse(object):
CM	564	_response = DummyResponse()
	565	_response.content_type = None
	566	_response.default_content_type = None
0c29cf	567
3db6c0	568	@reify
CM	569	def response(self):
	570	return self._response
0c29cf	571
3db6c0	572	request = DummyRequestWithClassResponse()
CM	573	# use a json renderer, which will mutate the response
816703	574	result = self._callFUT('json', dict(a=1), request=request)
23b7a2	575	self.assertEqual(result, '{"a": 1}')
3db6c0	576	self.assertFalse('response' in request.__dict__)
0c29cf	577
816703	578
250c02	579	class Test_render_to_response(unittest.TestCase):
CM	580	def setUp(self):
	581	self.config = testing.setUp()
	582
	583	def tearDown(self):
	584	testing.tearDown()
	585
0c29cf	586	def _callFUT(
MM	587	self, renderer_name, value, request=None, package=None, response=None
	588	):
b60bdb	589	from pyramid.renderers import render_to_response
0c29cf	590
MM	591	return render_to_response(
	592	renderer_name,
	593	value,
	594	request=request,
	595	package=package,
	596	response=response,
	597	)
250c02	598
CM	599	def test_it_no_request(self):
0c29cf	600	renderer = self.config.testing_add_renderer('tests:abc/def.pt')
250c02	601	renderer.string_response = 'abc'
62b479	602	response = self._callFUT('abc/def.pt', dict(a=1))
8e606d	603	self.assertEqual(response.body, b'abc')
250c02	604	renderer.assert_(a=1)
CM	605	renderer.assert_(request=None)
b9457d	606
250c02	607	def test_it_with_request(self):
0c29cf	608	renderer = self.config.testing_add_renderer('tests:abc/def.pt')
250c02	609	renderer.string_response = 'abc'
CM	610	request = testing.DummyRequest()
0c29cf	611	response = self._callFUT('abc/def.pt', dict(a=1), request=request)
8e606d	612	self.assertEqual(response.body, b'abc')
250c02	613	renderer.assert_(a=1)
CM	614	renderer.assert_(request=request)
d99dc7	615
CM	616	def test_it_with_package(self):
dd3cc8	617	import tests
0c29cf	618
MM	619	renderer = self.config.testing_add_renderer('tests:abc/def.pt')
d99dc7	620	renderer.string_response = 'abc'
CM	621	request = testing.DummyRequest()
0c29cf	622	response = self._callFUT(
MM	623	'abc/def.pt', dict(a=1), request=request, package=tests
	624	)
8e606d	625	self.assertEqual(response.body, b'abc')
d99dc7	626	renderer.assert_(a=1)
CM	627	renderer.assert_(request=request)
	628
dd2231	629	def test_response_preserved(self):
MM	630	request = testing.DummyRequest()
0c29cf	631	response = object() # should error if mutated
dd2231	632	request.response = response
MM	633	# use a json renderer, which will mutate the response
	634	result = self._callFUT('json', dict(a=1), request=request)
	635	self.assertEqual(result.body, b'{"a": 1}')
	636	self.assertNotEqual(request.response, result)
	637	self.assertEqual(request.response, response)
	638
	639	def test_no_response_to_preserve(self):
	640	from pyramid.decorator import reify
0c29cf	641
dd2231	642	class DummyRequestWithClassResponse(object):
MM	643	_response = DummyResponse()
	644	_response.content_type = None
	645	_response.default_content_type = None
0c29cf	646
dd2231	647	@reify
MM	648	def response(self):
	649	return self._response
0c29cf	650
dd2231	651	request = DummyRequestWithClassResponse()
MM	652	# use a json renderer, which will mutate the response
	653	result = self._callFUT('json', dict(a=1), request=request)
72bf6b	654	self.assertEqual(result.body, b'{"a": 1}')
MM	655	self.assertFalse('response' in request.__dict__)
	656
	657	def test_custom_response_object(self):
	658	class DummyRequestWithClassResponse(object):
	659	pass
0c29cf	660
72bf6b	661	request = DummyRequestWithClassResponse()
MM	662	response = DummyResponse()
	663	# use a json renderer, which will mutate the response
0c29cf	664	result = self._callFUT(
MM	665	'json', dict(a=1), request=request, response=response
	666	)
72bf6b	667	self.assertTrue(result is response)
dd2231	668	self.assertEqual(result.body, b'{"a": 1}')
MM	669	self.assertFalse('response' in request.__dict__)
0c29cf	670
dd2231	671
250c02	672	class Test_get_renderer(unittest.TestCase):
CM	673	def setUp(self):
	674	self.config = testing.setUp()
	675
	676	def tearDown(self):
	677	testing.tearDown()
	678
	679	def _callFUT(self, renderer_name, **kw):
b60bdb	680	from pyramid.renderers import get_renderer
0c29cf	681
d99dc7	682	return get_renderer(renderer_name, **kw)
250c02	683
d99dc7	684	def test_it_no_package(self):
0c29cf	685	renderer = self.config.testing_add_renderer('tests:abc/def.pt')
250c02	686	result = self._callFUT('abc/def.pt')
CM	687	self.assertEqual(result, renderer)
	688
d99dc7	689	def test_it_with_package(self):
dd3cc8	690	import tests
0c29cf	691
MM	692	renderer = self.config.testing_add_renderer('tests:abc/def.pt')
dd3cc8	693	result = self._callFUT('abc/def.pt', package=tests)
d99dc7	694	self.assertEqual(result, renderer)
CM	695
1281a5	696	def test_it_with_registry(self):
0c29cf	697	renderer = self.config.testing_add_renderer('tests:abc/def.pt')
1281a5	698	result = self._callFUT('abc/def.pt', registry=self.config.registry)
CD	699	self.assertEqual(result, renderer)
	700
2cc524	701	def test_it_with_isolated_registry(self):
CD	702	from pyramid.config import Configurator
0c29cf	703
2cc524	704	isolated_config = Configurator()
0c29cf	705	renderer = isolated_config.testing_add_renderer('tests:abc/def.pt')
2cc524	706	result = self._callFUT('abc/def.pt', registry=isolated_config.registry)
CD	707	self.assertEqual(result, renderer)
0c29cf	708
2cc524	709
c1f3d0	710	class TestJSONP(unittest.TestCase):
CM	711	def _makeOne(self, param_name='callback'):
	712	from pyramid.renderers import JSONP
0c29cf	713
c1f3d0	714	return JSONP(param_name)
CM	715
	716	def test_render_to_jsonp(self):
	717	renderer_factory = self._makeOne()
	718	renderer = renderer_factory(None)
	719	request = testing.DummyRequest()
	720	request.GET['callback'] = 'callback'
0c29cf	721	result = renderer({'a': '1'}, {'request': request})
23b7a2	722	self.assertEqual(result, '/**/callback({"a": "1"});')
0c29cf	723	self.assertEqual(
MM	724	request.response.content_type, 'application/javascript'
	725	)
ed4bba	726
MM	727	def test_render_to_jsonp_with_dot(self):
	728	renderer_factory = self._makeOne()
	729	renderer = renderer_factory(None)
	730	request = testing.DummyRequest()
	731	request.GET['callback'] = 'angular.callbacks._0'
0c29cf	732	result = renderer({'a': '1'}, {'request': request})
23b7a2	733	self.assertEqual(result, '/**/angular.callbacks._0({"a": "1"});')
0c29cf	734	self.assertEqual(
MM	735	request.response.content_type, 'application/javascript'
	736	)
c1f3d0	737
CM	738	def test_render_to_json(self):
	739	renderer_factory = self._makeOne()
	740	renderer = renderer_factory(None)
	741	request = testing.DummyRequest()
0c29cf	742	result = renderer({'a': '1'}, {'request': request})
c1f3d0	743	self.assertEqual(result, '{"a": "1"}')
0c29cf	744	self.assertEqual(request.response.content_type, 'application/json')
c1f3d0	745
fcb6cc	746	def test_render_without_request(self):
MM	747	renderer_factory = self._makeOne()
	748	renderer = renderer_factory(None)
0c29cf	749	result = renderer({'a': '1'}, {})
fcb6cc	750	self.assertEqual(result, '{"a": "1"}')
MM	751
b6ffe5	752	def test_render_to_jsonp_invalid_callback(self):
BJR	753	from pyramid.httpexceptions import HTTPBadRequest
0c29cf	754
b6ffe5	755	renderer_factory = self._makeOne()
BJR	756	renderer = renderer_factory(None)
	757	request = testing.DummyRequest()
	758	request.GET['callback'] = '78mycallback'
0c29cf	759	self.assertRaises(
MM	760	HTTPBadRequest, renderer, {'a': '1'}, {'request': request}
	761	)
b6ffe5	762
c1f3d0	763
250c02	764	class Dummy:
CM	765	pass
0c29cf	766
250c02	767
CM	768	class DummyResponse:
	769	status = '200 OK'
72bf6b	770	default_content_type = 'text/html'
MM	771	content_type = default_content_type
250c02	772	headerlist = ()
CM	773	app_iter = ()
72bf6b	774	body = b''
MM	775
	776	# compat for renderer that will set unicode on py3
0c29cf	777	def _set_text(self, val): # pragma: no cover
72bf6b	778	self.body = val.encode('utf8')
250c02	779
0c29cf	780	text = property(fset=_set_text)