RedHatTraining/pyramid.git

Michael Merickel

2018-10-15 2b024920847481592b1a13d4006d2a9fa8881d72

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