From 250c0218d0bd7dab6ea7e16c7051af71394f2a63 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Mon, 26 Jul 2010 00:26:10 +0000 Subject: merge generic_rendering branch --- repoze/bfg/tests/test_chameleon_text.py | 87 ++------- repoze/bfg/tests/test_chameleon_zpt.py | 86 +++------ repoze/bfg/tests/test_configuration.py | 158 +++++++--------- repoze/bfg/tests/test_renderers.py | 307 +++++++++++++++++++++++++++++++- repoze/bfg/tests/test_testing.py | 71 +++++++- 5 files changed, 468 insertions(+), 241 deletions(-) (limited to 'repoze/bfg/tests') diff --git a/repoze/bfg/tests/test_chameleon_text.py b/repoze/bfg/tests/test_chameleon_text.py index cb30f489a..d9cefbd67 100644 --- a/repoze/bfg/tests/test_chameleon_text.py +++ b/repoze/bfg/tests/test_chameleon_text.py @@ -166,88 +166,33 @@ class GetRendererTests(Base, unittest.TestCase): from repoze.bfg.chameleon_text import get_renderer return get_renderer(name) - def test_nonabs_registered(self): - from repoze.bfg.threadlocal import get_current_registry - from repoze.bfg.chameleon_text import TextTemplateRenderer - from repoze.bfg.interfaces import ITemplateRenderer - minimal = self._getTemplatePath('minimal.txt') - utility = TextTemplateRenderer(minimal) - self._registerUtility(utility, ITemplateRenderer, name=minimal) - result = self._callFUT(minimal) - self.assertEqual(result, utility) - reg = get_current_registry() - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility) - - def test_nonabs_unregistered(self): - from repoze.bfg.threadlocal import get_current_registry - from repoze.bfg.chameleon_text import TextTemplateRenderer - from repoze.bfg.interfaces import ITemplateRenderer - minimal = self._getTemplatePath('minimal.txt') - reg = get_current_registry() - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), None) - utility = TextTemplateRenderer(minimal) - self._registerUtility(utility, ITemplateRenderer, name=minimal) - result = self._callFUT(minimal) - self.assertEqual(result, utility) - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility) - - def test_explicit_registration(self): - from repoze.bfg.interfaces import ITemplateRenderer + def test_it(self): + from repoze.bfg.interfaces import IRendererFactory class Dummy: template = object() - utility = Dummy() - self._registerUtility(utility, ITemplateRenderer, name='foo') + def implementation(self): pass + renderer = Dummy() + def rf(spec): + return renderer + self._registerUtility(rf, IRendererFactory, name='foo') result = self._callFUT('foo') - self.failUnless(result is utility) - -class GetTemplateTests(unittest.TestCase, Base): - def setUp(self): - Base.setUp(self) - - def tearDown(self): - Base.tearDown(self) + self.failUnless(result is renderer) +class GetTemplateTests(Base, unittest.TestCase): def _callFUT(self, name): from repoze.bfg.chameleon_text import get_template return get_template(name) - def test_nonabs_registered(self): - from repoze.bfg.threadlocal import get_current_registry - from repoze.bfg.chameleon_text import TextTemplateRenderer - from repoze.bfg.interfaces import ITemplateRenderer - minimal = self._getTemplatePath('minimal.txt') - utility = TextTemplateRenderer(minimal) - self._registerUtility(utility, ITemplateRenderer, name=minimal) - result = self._callFUT(minimal) - self.assertEqual(result.filename, minimal) - reg = get_current_registry() - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility) - - def test_nonabs_unregistered(self): - from repoze.bfg.threadlocal import get_current_registry - from repoze.bfg.chameleon_text import TextTemplateRenderer - from repoze.bfg.interfaces import ITemplateRenderer - minimal = self._getTemplatePath('minimal.txt') - reg = get_current_registry() - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), None) - utility = TextTemplateRenderer(minimal) - self._registerUtility(utility, ITemplateRenderer, name=minimal) - result = self._callFUT(minimal) - self.assertEqual(result.filename, minimal) - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility) - - def test_explicit_registration(self): - from repoze.bfg.interfaces import ITemplateRenderer + def test_it(self): + from repoze.bfg.interfaces import IRendererFactory class Dummy: template = object() def implementation(self): return self.template - utility = Dummy() - self._registerUtility(utility, ITemplateRenderer, name='foo') + renderer = Dummy() + def rf(spec): + return renderer + self._registerUtility(rf, IRendererFactory, name='foo') result = self._callFUT('foo') - self.failUnless(result is utility.template) - - - - + self.failUnless(result is renderer.template) diff --git a/repoze/bfg/tests/test_chameleon_zpt.py b/repoze/bfg/tests/test_chameleon_zpt.py index 4ea5fc281..a0f01701a 100644 --- a/repoze/bfg/tests/test_chameleon_zpt.py +++ b/repoze/bfg/tests/test_chameleon_zpt.py @@ -128,6 +128,12 @@ class RenderTemplateTests(Base, unittest.TestCase): '
\n
') class RenderTemplateToResponseTests(Base, unittest.TestCase): + def setUp(self): + cleanUp() + + def tearDown(self): + cleanUp() + def _callFUT(self, name, **kw): from repoze.bfg.chameleon_zpt import render_template_to_response return render_template_to_response(name, **kw) @@ -157,82 +163,32 @@ class GetRendererTests(Base, unittest.TestCase): from repoze.bfg.chameleon_zpt import get_renderer return get_renderer(name) - def test_nonabs_registered(self): - from repoze.bfg.threadlocal import get_current_registry - from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer - from repoze.bfg.interfaces import ITemplateRenderer - minimal = self._getTemplatePath('minimal.pt') - utility = ZPTTemplateRenderer(minimal) - self._registerUtility(utility, ITemplateRenderer, name=minimal) - result = self._callFUT(minimal) - self.assertEqual(result, utility) - reg = get_current_registry() - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility) - - def test_nonabs_unregistered(self): - from repoze.bfg.threadlocal import get_current_registry - from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer - from repoze.bfg.interfaces import ITemplateRenderer - minimal = self._getTemplatePath('minimal.pt') - reg = get_current_registry() - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), None) - utility = ZPTTemplateRenderer(minimal) - self._registerUtility(utility, ITemplateRenderer, name=minimal) - result = self._callFUT(minimal) - self.assertEqual(result, utility) - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility) - - def test_explicit_registration(self): - from repoze.bfg.interfaces import ITemplateRenderer + def test_it(self): + from repoze.bfg.interfaces import IRendererFactory class Dummy: template = object() - utility = Dummy() - self._registerUtility(utility, ITemplateRenderer, name='foo') + def implementation(self): pass + renderer = Dummy() + def rf(spec): + return renderer + self._registerUtility(rf, IRendererFactory, name='foo') result = self._callFUT('foo') - self.failUnless(result is utility) + self.failUnless(result is renderer) class GetTemplateTests(Base, unittest.TestCase): def _callFUT(self, name): from repoze.bfg.chameleon_zpt import get_template return get_template(name) - def test_nonabs_registered(self): - from repoze.bfg.threadlocal import get_current_registry - from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer - from repoze.bfg.interfaces import ITemplateRenderer - minimal = self._getTemplatePath('minimal.pt') - utility = ZPTTemplateRenderer(minimal) - self._registerUtility(utility, ITemplateRenderer, name=minimal) - result = self._callFUT(minimal) - self.assertEqual(result.filename, minimal) - reg = get_current_registry() - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility) - - def test_nonabs_unregistered(self): - from repoze.bfg.threadlocal import get_current_registry - from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer - from repoze.bfg.interfaces import ITemplateRenderer - minimal = self._getTemplatePath('minimal.pt') - reg = get_current_registry() - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), None) - utility = ZPTTemplateRenderer(minimal) - self._registerUtility(utility, ITemplateRenderer, name=minimal) - result = self._callFUT(minimal) - self.assertEqual(result.filename, minimal) - self.assertEqual(reg.queryUtility(ITemplateRenderer, minimal), utility) - - def test_explicit_registration(self): - from repoze.bfg.interfaces import ITemplateRenderer + def test_it(self): + from repoze.bfg.interfaces import IRendererFactory class Dummy: template = object() def implementation(self): return self.template - utility = Dummy() - self._registerUtility(utility, ITemplateRenderer, name='foo') + renderer = Dummy() + def rf(spec): + return renderer + self._registerUtility(rf, IRendererFactory, name='foo') result = self._callFUT('foo') - self.failUnless(result is utility.template) - - - - - + self.failUnless(result is renderer.template) diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py index 25c5544b6..0cb8ff5e8 100644 --- a/repoze/bfg/tests/test_configuration.py +++ b/repoze/bfg/tests/test_configuration.py @@ -290,6 +290,15 @@ class ConfiguratorTests(unittest.TestCase): utility = reg.getUtility(IRequestFactory) self.assertEqual(utility, 'abc') + def test_setup_registry_renderer_globals_factory(self): + from repoze.bfg.registry import Registry + from repoze.bfg.interfaces import IRendererGlobalsFactory + reg = Registry() + config = self._makeOne(reg) + config.setup_registry(renderer_globals_factory='abc') + utility = reg.getUtility(IRendererGlobalsFactory) + self.assertEqual(utility, 'abc') + def test_setup_registry_alternate_renderers(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import IRendererFactory @@ -300,6 +309,19 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(reg.getUtility(IRendererFactory, 'yeah'), renderer) + def test_get_settings_nosettings(self): + from repoze.bfg.registry import Registry + reg = Registry() + config = self._makeOne(reg) + self.assertEqual(config.get_settings(), None) + + def test_get_settings_withsettings(self): + from repoze.bfg.interfaces import ISettings + settings = {'a':1} + config = self._makeOne() + config.registry.registerUtility(settings, ISettings) + self.assertEqual(config.get_settings(), settings) + def test_add_settings_settings_already_registered(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import ISettings @@ -2462,7 +2484,52 @@ class ConfiguratorTests(unittest.TestCase): config.unhook_zca(getSiteManager=gsm) self.assertEqual(gsm.unhooked, True) + def test_testing_add_renderer(self): + config = self._makeOne() + renderer = config.testing_add_renderer('templates/foo.pt') + from repoze.bfg.testing import DummyTemplateRenderer + self.failUnless(isinstance(renderer, DummyTemplateRenderer)) + from repoze.bfg.renderers import render_to_response + # must provide request to pass in registry (this is a functest) + request = DummyRequest() + request.registry = config.registry + render_to_response('templates/foo.pt', foo=1, bar=2, request=request) + renderer.assert_(foo=1) + renderer.assert_(bar=2) + renderer.assert_(request=request) + + def test_testing_add_renderer_explicitrenderer(self): + config = self._makeOne() + class E(Exception): pass + def renderer(kw, system): + self.assertEqual(kw, {'foo':1, 'bar':2}) + raise E + renderer = config.testing_add_renderer('templates/foo.pt', renderer) + from repoze.bfg.renderers import render_to_response + # must provide request to pass in registry (this is a functest) + request = DummyRequest() + request.registry = config.registry + try: + render_to_response( + 'templates/foo.pt', foo=1, bar=2, request=request) + except E: + pass + else: # pragma: no cover + raise AssertionError + def test_testing_add_template(self): + config = self._makeOne() + renderer = config.testing_add_template('templates/foo.pt') + from repoze.bfg.testing import DummyTemplateRenderer + self.failUnless(isinstance(renderer, DummyTemplateRenderer)) + from repoze.bfg.renderers import render_to_response + # must provide request to pass in registry (this is a functest) + request = DummyRequest() + request.registry = config.registry + render_to_response('templates/foo.pt', foo=1, bar=2, request=request) + renderer.assert_(foo=1) + renderer.assert_(bar=2) + renderer.assert_(request=request) class Test__map_view(unittest.TestCase): def setUp(self): @@ -2778,97 +2845,6 @@ class Test__map_view(unittest.TestCase): request = self._makeRequest() self.assertEqual(result(None, request).body, 'Hello!') -class Test_rendered_response(unittest.TestCase): - def setUp(self): - testing.setUp() - - def tearDown(self): - testing.tearDown() - - def _callFUT(self, renderer, response, view=None, - context=None, request=None, renderer_name=None): - from repoze.bfg.configuration import rendered_response - if request is None: - request = DummyRequest() - return rendered_response(renderer, response, view, - context, request, renderer_name) - - def _makeRenderer(self): - def renderer(*arg): - return 'Hello!' - return renderer - - def test_is_response(self): - renderer = self._makeRenderer() - response = DummyResponse() - result = self._callFUT(renderer, response) - self.assertEqual(result, response) - - def test_calls_renderer(self): - renderer = self._makeRenderer() - response = {'a':'1'} - result = self._callFUT(renderer, response) - self.assertEqual(result.body, 'Hello!') - - def test_with_content_type(self): - renderer = self._makeRenderer() - response = {'a':'1'} - request = DummyRequest() - attrs = {'response_content_type':'text/nonsense'} - request.__dict__.update(attrs) - result = self._callFUT(renderer, response, request=request) - self.assertEqual(result.content_type, 'text/nonsense') - - def test_with_headerlist(self): - renderer = self._makeRenderer() - response = {'a':'1'} - request = DummyRequest() - attrs = {'response_headerlist':[('a', '1'), ('b', '2')]} - request.__dict__.update(attrs) - result = self._callFUT(renderer, response, request=request) - self.assertEqual(result.headerlist, - [('Content-Type', 'text/html; charset=UTF-8'), - ('Content-Length', '6'), - ('a', '1'), - ('b', '2')]) - - def test_with_status(self): - renderer = self._makeRenderer() - response = {'a':'1'} - request = DummyRequest() - attrs = {'response_status':'406 You Lose'} - request.__dict__.update(attrs) - result = self._callFUT(renderer, response, request=request) - self.assertEqual(result.status, '406 You Lose') - - def test_with_charset(self): - renderer = self._makeRenderer() - response = {'a':'1'} - request = DummyRequest() - attrs = {'response_charset':'UTF-16'} - request.__dict__.update(attrs) - result = self._callFUT(renderer, response, request=request) - self.assertEqual(result.charset, 'UTF-16') - - def test_with_cache_for(self): - renderer = self._makeRenderer() - response = {'a':'1'} - request = DummyRequest() - attrs = {'response_cache_for':100} - request.__dict__.update(attrs) - result = self._callFUT(renderer, response, request=request) - self.assertEqual(result.cache_control.max_age, 100) - - def test_with_real_request(self): - # functional - from repoze.bfg.request import Request - renderer = self._makeRenderer() - response = {'a':'1'} - request = Request({}) - request.response_status = '406 You Lose' - result = self._callFUT(renderer, response, request=request) - self.assertEqual(result.status, '406 You Lose') - class Test_decorate_view(unittest.TestCase): def _callFUT(self, wrapped, original): from repoze.bfg.configuration import decorate_view diff --git a/repoze/bfg/tests/test_renderers.py b/repoze/bfg/tests/test_renderers.py index 1f4df3556..8a8a578eb 100644 --- a/repoze/bfg/tests/test_renderers.py +++ b/repoze/bfg/tests/test_renderers.py @@ -120,21 +120,29 @@ class TestRendererFromName(unittest.TestCase): def tearDown(self): cleanUp() - def _callFUT(self, path): + def _callFUT(self, path, package=None): from repoze.bfg.renderers import renderer_from_name - return renderer_from_name(path) + return renderer_from_name(path, package) def test_it(self): from repoze.bfg.interfaces import IRendererFactory import os here = os.path.dirname(os.path.abspath(__file__)) fixture = os.path.join(here, 'fixtures/minimal.pt') - renderer = {} def factory(path, **kw): - return renderer + return path testing.registerUtility(factory, IRendererFactory, name='.pt') result = self._callFUT(fixture) - self.assertEqual(result, renderer) + self.assertEqual(result, fixture) + + def test_with_package(self): + from repoze.bfg.interfaces import IRendererFactory + def factory(path, **kw): + return path + testing.registerUtility(factory, IRendererFactory, name='.pt') + import repoze.bfg.tests + result = self._callFUT('fixtures/minimal.pt', repoze.bfg.tests) + self.assertEqual(result, 'repoze.bfg.tests:fixtures/minimal.pt') def test_it_no_renderer(self): self.assertRaises(ValueError, self._callFUT, 'foo') @@ -199,6 +207,295 @@ class Test_string_renderer_factory(unittest.TestCase): renderer(None, {'request':request}) self.assertEqual(request.response_content_type, 'text/mishmash') +class Test_rendered_response(unittest.TestCase): + def setUp(self): + testing.setUp() + from zope.deprecation import __show__ + __show__.off() + + def tearDown(self): + testing.tearDown() + from zope.deprecation import __show__ + __show__.on() + + def _callFUT(self, renderer, response, view=None, + context=None, request=None, renderer_name=None): + from repoze.bfg.renderers import rendered_response + if request is None: + request = testing.DummyRequest() + return rendered_response(renderer, response, view, + context, request, renderer_name) + + def _makeRenderer(self): + def renderer(*arg): + return 'Hello!' + return renderer + + def test_is_response(self): + renderer = self._makeRenderer() + response = DummyResponse() + result = self._callFUT(renderer, response) + self.assertEqual(result, response) + + def test_calls_renderer(self): + renderer = self._makeRenderer() + response = {'a':'1'} + result = self._callFUT(renderer, response) + self.assertEqual(result.body, 'Hello!') + +class Test__make_response(unittest.TestCase): + def setUp(self): + self.config = testing.setUp() + + def tearDown(self): + testing.tearDown() + + def _callFUT(self, request, result): + from repoze.bfg.renderers import _make_response + return _make_response(request, result) + + def test_with_content_type(self): + request = testing.DummyRequest() + attrs = {'response_content_type':'text/nonsense'} + request.__dict__.update(attrs) + response = self._callFUT(request, 'abc') + self.assertEqual(response.content_type, 'text/nonsense') + self.assertEqual(response.body, 'abc') + + def test_with_headerlist(self): + request = testing.DummyRequest() + attrs = {'response_headerlist':[('a', '1'), ('b', '2')]} + request.__dict__.update(attrs) + response = self._callFUT(request, 'abc') + self.assertEqual(response.headerlist, + [('Content-Type', 'text/html; charset=UTF-8'), + ('Content-Length', '3'), + ('a', '1'), + ('b', '2')]) + self.assertEqual(response.body, 'abc') + + def test_with_status(self): + request = testing.DummyRequest() + attrs = {'response_status':'406 You Lose'} + request.__dict__.update(attrs) + response = self._callFUT(request, 'abc') + self.assertEqual(response.status, '406 You Lose') + self.assertEqual(response.body, 'abc') + + def test_with_charset(self): + request = testing.DummyRequest() + attrs = {'response_charset':'UTF-16'} + request.__dict__.update(attrs) + response = self._callFUT(request, 'abc') + self.assertEqual(response.charset, 'UTF-16') + + def test_with_cache_for(self): + request = testing.DummyRequest() + attrs = {'response_cache_for':100} + request.__dict__.update(attrs) + response = self._callFUT(request, 'abc') + self.assertEqual(response.cache_control.max_age, 100) + + def test_with_alternate_response_factory(self): + from repoze.bfg.interfaces import IResponseFactory + class ResponseFactory(object): + def __init__(self, result): + self.result = result + self.config.registry.registerUtility(ResponseFactory, IResponseFactory) + request = testing.DummyRequest() + response = self._callFUT(request, 'abc') + self.assertEqual(response.__class__, ResponseFactory) + self.assertEqual(response.result, 'abc') + + def test_with_real_request(self): + # functional + from repoze.bfg.request import Request + request = Request({}) + attrs = {'response_status':'406 You Lose'} + request.__dict__.update(attrs) + response = self._callFUT(request, 'abc') + self.assertEqual(response.status, '406 You Lose') + self.assertEqual(response.body, 'abc') + +class Test__render(unittest.TestCase): + def setUp(self): + self.config = cleanUp() + + def tearDown(self): + cleanUp() + + def _callFUT(self, renderer_name, request, values, system_values, renderer, + package): + from repoze.bfg.renderers import _render + return _render(renderer_name, request, values, system_values, renderer, + package) + + def test_explicit_renderer(self): + def renderer(*arg): + return arg + result = self._callFUT( + 'name', 'request', 'values', 'system_values', renderer, None) + self.assertEqual(result, ('values', 'system_values')) + + def test_request_has_registry(self): + request = Dummy() + class DummyRegistry(object): + def queryUtility(self, iface): + self.queried = True + return None + reg = DummyRegistry() + request.registry = reg + def renderer(*arg): + return arg + result = self._callFUT( + 'name', request, 'values', 'system_values', renderer, None) + self.assertEqual(result, ('values', 'system_values')) + self.failUnless(reg.queried) + + def test_renderer_is_None(self): + from repoze.bfg.interfaces import IRendererFactory + def renderer(values, system): + return rf + def rf(spec): + return renderer + self.config.registry.registerUtility(rf, IRendererFactory, name='name') + result = self._callFUT( + 'name', 'request', 'values', 'system_values', None, None) + self.assertEqual(result, rf) + + def test_system_values_is_None(self): + def renderer(*arg): + return arg + request = Dummy() + context = Dummy() + request.context = context + result = self._callFUT( + 'name', request, 'values', None, renderer, None) + system = {'request':request, 'context':context, + 'renderer_name':'name', 'view':None} + self.assertEqual(result, ('values', system)) + + def test_renderer_globals_factory_active(self): + from repoze.bfg.interfaces import IRendererGlobalsFactory + def rg(system): + return {'a':1} + self.config.registry.registerUtility(rg, IRendererGlobalsFactory) + def renderer(*arg): + return arg + result = self._callFUT( + 'name', 'request', 'values', {'a':2}, renderer, None) + self.assertEqual(result, ('values', {'a':1})) + +class Test__render_to_response(unittest.TestCase): + def setUp(self): + self.config = cleanUp() + + def tearDown(self): + cleanUp() + + def _callFUT(self, renderer_name, request, values, system_values, renderer, + package): + from repoze.bfg.renderers import _render_to_response + return _render_to_response( + renderer_name, request, values, system_values, renderer, + package) + + def test_it(self): + def renderer(*arg): + return 'hello' + request = Dummy() + result = self._callFUT( + 'name', request, 'values', 'system_values', renderer, None) + self.assertEqual(result.body, 'hello') + +class Test_render(unittest.TestCase): + def setUp(self): + self.config = testing.setUp() + + def tearDown(self): + testing.tearDown() + + def _callFUT(self, renderer_name, **kw): + from repoze.bfg.renderers import render + return render(renderer_name, **kw) + + def test_it_no_request(self): + renderer = self.config.testing_add_renderer( + 'repoze.bfg.tests:abc/def.pt') + renderer.string_response = 'abc' + result = self._callFUT('abc/def.pt', a=1) + self.assertEqual(result, 'abc') + renderer.assert_(a=1) + renderer.assert_(request=None) + + def test_it_with_request(self): + renderer = self.config.testing_add_renderer( + 'repoze.bfg.tests:abc/def.pt') + renderer.string_response = 'abc' + request = testing.DummyRequest() + result = self._callFUT('abc/def.pt', + a=1, request=request) + self.assertEqual(result, 'abc') + renderer.assert_(a=1) + renderer.assert_(request=request) + +class Test_render_to_response(unittest.TestCase): + def setUp(self): + self.config = testing.setUp() + + def tearDown(self): + testing.tearDown() + + def _callFUT(self, renderer_name, **kw): + from repoze.bfg.renderers import render_to_response + return render_to_response(renderer_name, **kw) + + def test_it_no_request(self): + renderer = self.config.testing_add_renderer( + 'repoze.bfg.tests:abc/def.pt') + renderer.string_response = 'abc' + response = self._callFUT('abc/def.pt', a=1) + self.assertEqual(response.body, 'abc') + renderer.assert_(a=1) + renderer.assert_(request=None) + + def test_it_with_request(self): + renderer = self.config.testing_add_renderer( + 'repoze.bfg.tests:abc/def.pt') + renderer.string_response = 'abc' + request = testing.DummyRequest() + response = self._callFUT('abc/def.pt', + a=1, request=request) + self.assertEqual(response.body, 'abc') + renderer.assert_(a=1) + renderer.assert_(request=request) + +class Test_get_renderer(unittest.TestCase): + def setUp(self): + self.config = testing.setUp() + + def tearDown(self): + testing.tearDown() + + def _callFUT(self, renderer_name, **kw): + from repoze.bfg.renderers import get_renderer + return get_renderer(renderer_name) + + def test_it(self): + renderer = self.config.testing_add_renderer( + 'repoze.bfg.tests:abc/def.pt') + result = self._callFUT('abc/def.pt') + self.assertEqual(result, renderer) + +class Dummy: + pass + +class DummyResponse: + status = '200 OK' + headerlist = () + app_iter = () + body = '' + class DummyFactory: def __init__(self, renderer): self.renderer = renderer diff --git a/repoze/bfg/tests/test_testing.py b/repoze/bfg/tests/test_testing.py index 1b3d731fa..fc3bd7c9e 100644 --- a/repoze/bfg/tests/test_testing.py +++ b/repoze/bfg/tests/test_testing.py @@ -66,18 +66,18 @@ class Test_registerTemplateRenderer(TestBase): renderer = testing.registerTemplateRenderer('templates/foo') from repoze.bfg.testing import DummyTemplateRenderer self.failUnless(isinstance(renderer, DummyTemplateRenderer)) - from repoze.bfg.chameleon_zpt import render_template_to_response - render_template_to_response('templates/foo', foo=1, bar=2) - self.assertEqual(dict(foo=1, bar=2), renderer._received) + from repoze.bfg.renderers import render_to_response + render_to_response('templates/foo', foo=1, bar=2) + renderer.assert_(foo=1) + renderer.assert_(bar=2) def test_registerTemplateRenderer_explicitrenderer(self): from repoze.bfg import testing def renderer(kw, system): - raise ValueError + self.assertEqual(kw, {'foo':1, 'bar':2}) renderer = testing.registerTemplateRenderer('templates/foo', renderer) - from repoze.bfg.chameleon_zpt import render_template_to_response - self.assertRaises(ValueError, render_template_to_response, - 'templates/foo', foo=1, bar=2) + from repoze.bfg.renderers import render_to_response + render_to_response('templates/foo', foo=1, bar=2) class Test_registerEventListener(TestBase): def test_registerEventListener_single(self): @@ -526,8 +526,8 @@ class TestDummyTemplateRenderer(unittest.TestCase): renderer = self._makeOne() impl = renderer.implementation() impl(a=1, b=2) - self.assertEqual(renderer._received['a'], 1) - self.assertEqual(renderer._received['b'], 2) + self.assertEqual(renderer._implementation._received['a'], 1) + self.assertEqual(renderer._implementation._received['b'], 2) def test_getattr(self): renderer = self._makeOne() @@ -666,6 +666,59 @@ class Test_tearDown(unittest.TestCase): getSiteManager.reset() manager.clear() +class TestDummyRendererFactory(unittest.TestCase): + def _makeOne(self, name, factory): + from repoze.bfg.testing import DummyRendererFactory + return DummyRendererFactory(name, factory) + + def test_add_no_colon(self): + f = self._makeOne('name', None) + f.add('spec', 'renderer') + self.assertEqual(f.renderers['spec'], 'renderer') + + def test_add_with_colon(self): + f = self._makeOne('name', None) + f.add('spec:spec2', 'renderer') + self.assertEqual(f.renderers['spec:spec2'], 'renderer') + self.assertEqual(f.renderers['spec2'], 'renderer') + + def test_call(self): + f = self._makeOne('name', None) + f.renderers['spec'] = 'renderer' + self.assertEqual(f('spec'), 'renderer') + + def test_call2(self): + f = self._makeOne('name', None) + f.renderers['spec'] = 'renderer' + self.assertEqual(f('spec:spec'), 'renderer') + + def test_call3(self): + def factory(spec): + return 'renderer' + f = self._makeOne('name', factory) + self.assertEqual(f('spec'), 'renderer') + + def test_call_miss(self): + f = self._makeOne('name', None) + self.assertRaises(KeyError, f, 'spec') + +class TestMockTemplate(unittest.TestCase): + def _makeOne(self, response): + from repoze.bfg.testing import MockTemplate + return MockTemplate(response) + + def test_getattr(self): + template = self._makeOne(None) + self.assertEqual(template.foo, template) + + def test_getitem(self): + template = self._makeOne(None) + self.assertEqual(template['foo'], template) + + def test_call(self): + template = self._makeOne('123') + self.assertEqual(template(), '123') + from zope.interface import Interface from zope.interface import implements -- cgit v1.2.3