From 62b4794bb4c52080aaccc8058147f4ebe34caba6 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Fri, 13 Aug 2010 09:56:20 +0000 Subject: svn merge -r9909:HEAD $REPOZE_SVN/repoze.bfg/branches/rendererhelper --- repoze/bfg/tests/test_configuration.py | 67 ++++++---- repoze/bfg/tests/test_renderers.py | 227 ++++++++++++++++----------------- repoze/bfg/tests/test_resource.py | 10 +- repoze/bfg/tests/test_testing.py | 4 +- 4 files changed, 165 insertions(+), 143 deletions(-) (limited to 'repoze/bfg/tests') diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py index 58a4a2eda..159429a06 100644 --- a/repoze/bfg/tests/test_configuration.py +++ b/repoze/bfg/tests/test_configuration.py @@ -1989,14 +1989,6 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(config.registry.getUtility(ITranslationDirectories), [locale]) - def test__renderer_from_name_default_renderer(self): - from repoze.bfg.interfaces import IRendererFactory - config = self._makeOne() - factory = lambda *arg: 'OK' - config.registry.registerUtility(factory, IRendererFactory) - result = config._renderer_from_name(None) - self.assertEqual(result, 'OK') - def test_derive_view_function(self): def view(request): return 'OK' @@ -2571,7 +2563,8 @@ class ConfiguratorTests(unittest.TestCase): # 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) + render_to_response( + 'templates/foo.pt', {'foo':1, 'bar':2}, request=request) renderer.assert_(foo=1) renderer.assert_(bar=2) renderer.assert_(request=request) @@ -2589,7 +2582,7 @@ class ConfiguratorTests(unittest.TestCase): request.registry = config.registry try: render_to_response( - 'templates/foo.pt', foo=1, bar=2, request=request) + 'templates/foo.pt', {'foo':1, 'bar':2}, request=request) except E: pass else: # pragma: no cover @@ -2604,7 +2597,8 @@ class ConfiguratorTests(unittest.TestCase): # 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) + render_to_response('templates/foo.pt', dict(foo=1, bar=2), + request=request) renderer.assert_(foo=1) renderer.assert_(bar=2) renderer.assert_(request=request) @@ -2613,22 +2607,25 @@ class Test__map_view(unittest.TestCase): def setUp(self): from repoze.bfg.registry import Registry self.registry = Registry() + testing.setUp(registry=self.registry) def tearDown(self): del self.registry + testing.tearDown() - def _registerRenderer(self, name='.txt'): + def _registerRenderer(self, typ='.txt'): from repoze.bfg.interfaces import IRendererFactory from repoze.bfg.interfaces import ITemplateRenderer from zope.interface import implements class Renderer: implements(ITemplateRenderer) + spec = 'abc' + typ def __init__(self, path): self.__class__.path = path def __call__(self, *arg): return 'Hello!' - self.registry.registerUtility(Renderer, IRendererFactory, name=name) - return Renderer(name) + self.registry.registerUtility(Renderer, IRendererFactory, name=typ) + return Renderer def _makeRequest(self): request = DummyRequest() @@ -2656,7 +2653,8 @@ class Test__map_view(unittest.TestCase): def test__map_view_as_function_with_attr_and_renderer(self): renderer = self._registerRenderer() view = lambda *arg: 'OK' - result = self._callFUT(view, attr='__name__', renderer=renderer) + result = self._callFUT(view, attr='__name__', + renderer_name=renderer.spec) self.failIf(result is view) self.assertRaises(TypeError, result, None, None) @@ -2714,7 +2712,7 @@ class Test__map_view(unittest.TestCase): pass def index(self): return {'a':'1'} - result = self._callFUT(view, attr='index', renderer = renderer) + result = self._callFUT(view, attr='index', renderer_name=renderer.spec) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) @@ -2755,7 +2753,7 @@ class Test__map_view(unittest.TestCase): pass def index(self): return {'a':'1'} - result = self._callFUT(view, attr='index', renderer = renderer) + result = self._callFUT(view, attr='index', renderer_name=renderer.spec) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) @@ -2796,7 +2794,7 @@ class Test__map_view(unittest.TestCase): pass def index(self): return {'a':'1'} - result = self._callFUT(view, attr='index', renderer = renderer) + result = self._callFUT(view, attr='index', renderer_name=renderer.spec) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) @@ -2837,7 +2835,7 @@ class Test__map_view(unittest.TestCase): pass def index(self): return {'a':'1'} - result = self._callFUT(view, attr='index', renderer = renderer) + result = self._callFUT(view, attr='index', renderer_name=renderer.spec) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) @@ -2869,7 +2867,7 @@ class Test__map_view(unittest.TestCase): def index(self, context, request): return {'a':'1'} view = View() - result = self._callFUT(view, attr='index', renderer=renderer) + result = self._callFUT(view, attr='index', renderer_name=renderer.spec) self.failIf(result is view) request = self._makeRequest() self.assertEqual(result(None, request).body, 'Hello!') @@ -2904,7 +2902,7 @@ class Test__map_view(unittest.TestCase): def index(self, request): return {'a':'1'} view = View() - result = self._callFUT(view, attr='index', renderer = renderer) + result = self._callFUT(view, attr='index', renderer_name=renderer.spec) self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) @@ -2916,12 +2914,37 @@ class Test__map_view(unittest.TestCase): renderer = self._registerRenderer() def view(context, request): return {'a':'1'} - result = self._callFUT(view, renderer=renderer) + result = self._callFUT(view, renderer_name=renderer.spec) + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + request = self._makeRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test__map_view_with_registry(self): + renderer = self._registerRenderer() + def view(context, request): + return {'a':'1'} + result = self._callFUT(view, renderer_name=renderer.spec, + registry=self.registry) + self.failIf(result is view) + self.assertEqual(view.__module__, result.__module__) + self.assertEqual(view.__doc__, result.__doc__) + request = self._makeRequest() + self.assertEqual(result(None, request).body, 'Hello!') + + def test__map_view_with_package(self): + renderer = self._registerRenderer() + def view(context, request): + return {'a':'1'} + result = self._callFUT(view, renderer_name=renderer.spec, + package='repoze.bfg') self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) request = self._makeRequest() self.assertEqual(result(None, request).body, 'Hello!') + self.assertEqual(renderer.path, 'repoze.bfg:abc.txt') class Test_decorate_view(unittest.TestCase): def _callFUT(self, wrapped, original): diff --git a/repoze/bfg/tests/test_renderers.py b/repoze/bfg/tests/test_renderers.py index 8a8a578eb..264b4a547 100644 --- a/repoze/bfg/tests/test_renderers.py +++ b/repoze/bfg/tests/test_renderers.py @@ -243,30 +243,106 @@ class Test_rendered_response(unittest.TestCase): result = self._callFUT(renderer, response) self.assertEqual(result.body, 'Hello!') -class Test__make_response(unittest.TestCase): + +class TestRendererHelper(unittest.TestCase): def setUp(self): - self.config = testing.setUp() + self.config = cleanUp() def tearDown(self): - testing.tearDown() + cleanUp() + + def _makeOne(self, *arg, **kw): + from repoze.bfg.renderers import RendererHelper + return RendererHelper(*arg, **kw) + + def _registerRendererFactory(self): + from repoze.bfg.interfaces import IRendererFactory + def renderer(*arg): + def respond(*arg): + return arg + return respond + self.config.registry.registerUtility(renderer, IRendererFactory, + name='.foo') + return renderer - def _callFUT(self, request, result): - from repoze.bfg.renderers import _make_response - return _make_response(request, result) + def test_resolve_spec_path_is_None(self): + helper = self._makeOne('loo.foo') + result = helper.resolve_spec(None) + self.assertEqual(result, None) - def test_with_content_type(self): + def test_resolve_spec_package_is_None(self): + helper = self._makeOne('loo.foo') + result = helper.resolve_spec('/foo/bar') + self.assertEqual(result, '/foo/bar') + + def test_resolve_spec_absolute(self): + helper = self._makeOne('loo.foo') + result = helper.resolve_spec('repoze.bfg:flub') + self.assertEqual(result, 'repoze.bfg:flub') + + def test_resolve_spec_relative(self): + helper = self._makeOne('loo.foo', package='repoze.bfg') + result = helper.resolve_spec('flub') + self.assertEqual(result, 'repoze.bfg:flub') + + def test_render_to_response(self): + self._registerRendererFactory() + request = Dummy() + helper = self._makeOne('loo.foo') + response = helper.render_to_response('values', 'system_values', + request=request) + self.assertEqual(response.body, ('values', 'system_values')) + + def test_render_explicit_registry(self): + factory = self._registerRendererFactory() + class DummyRegistry(object): + def __init__(self): + self.responses = [factory, lambda *arg: {}] + def queryUtility(self, iface, name=None): + self.queried = True + return self.responses.pop(0) + reg = DummyRegistry() + helper = self._makeOne('loo.foo', registry=reg) + result = helper.render('value', {}) + self.assertEqual(result, ('value', {})) + self.failUnless(reg.queried) + + def test_render_system_values_is_None(self): + self._registerRendererFactory() + request = Dummy() + context = Dummy() + request.context = context + helper = self._makeOne('loo.foo') + result = helper.render('values', None, request=request) + system = {'request':request, 'context':context, + 'renderer_name':'loo.foo', 'view':None} + self.assertEqual(result, ('values', system)) + + def test_render_renderer_globals_factory_active(self): + self._registerRendererFactory() + from repoze.bfg.interfaces import IRendererGlobalsFactory + def rg(system): + return {'a':1} + self.config.registry.registerUtility(rg, IRendererGlobalsFactory) + helper = self._makeOne('loo.foo') + result = helper.render('values', None) + self.assertEqual(result[1]['a'], 1) + + def test__make_response_with_content_type(self): request = testing.DummyRequest() attrs = {'response_content_type':'text/nonsense'} request.__dict__.update(attrs) - response = self._callFUT(request, 'abc') + helper = self._makeOne('loo.foo') + response = helper._make_response('abc', request) self.assertEqual(response.content_type, 'text/nonsense') self.assertEqual(response.body, 'abc') - def test_with_headerlist(self): + def test__make_response_with_headerlist(self): request = testing.DummyRequest() attrs = {'response_headerlist':[('a', '1'), ('b', '2')]} request.__dict__.update(attrs) - response = self._callFUT(request, 'abc') + helper = self._makeOne('loo.foo') + response = helper._make_response('abc', request) self.assertEqual(response.headerlist, [('Content-Type', 'text/html; charset=UTF-8'), ('Content-Length', '3'), @@ -274,26 +350,29 @@ class Test__make_response(unittest.TestCase): ('b', '2')]) self.assertEqual(response.body, 'abc') - def test_with_status(self): + def test__make_response_with_status(self): request = testing.DummyRequest() attrs = {'response_status':'406 You Lose'} request.__dict__.update(attrs) - response = self._callFUT(request, 'abc') + helper = self._makeOne('loo.foo') + response = helper._make_response('abc', request) self.assertEqual(response.status, '406 You Lose') self.assertEqual(response.body, 'abc') - def test_with_charset(self): + def test__make_response_with_charset(self): request = testing.DummyRequest() attrs = {'response_charset':'UTF-16'} request.__dict__.update(attrs) - response = self._callFUT(request, 'abc') + helper = self._makeOne('loo.foo') + response = helper._make_response('abc', request) self.assertEqual(response.charset, 'UTF-16') - def test_with_cache_for(self): + def test__make_response_with_cache_for(self): request = testing.DummyRequest() attrs = {'response_cache_for':100} request.__dict__.update(attrs) - response = self._callFUT(request, 'abc') + helper = self._makeOne('loo.foo') + response = helper._make_response('abc', request) self.assertEqual(response.cache_control.max_age, 100) def test_with_alternate_response_factory(self): @@ -303,111 +382,22 @@ class Test__make_response(unittest.TestCase): self.result = result self.config.registry.registerUtility(ResponseFactory, IResponseFactory) request = testing.DummyRequest() - response = self._callFUT(request, 'abc') + helper = self._makeOne('loo.foo') + response = helper._make_response('abc', request) self.assertEqual(response.__class__, ResponseFactory) self.assertEqual(response.result, 'abc') - def test_with_real_request(self): + def test__make_response_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') + helper = self._makeOne('loo.foo') + response = helper._make_response('abc', request) 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() @@ -415,15 +405,15 @@ class Test_render(unittest.TestCase): def tearDown(self): testing.tearDown() - def _callFUT(self, renderer_name, **kw): + def _callFUT(self, renderer_name, value, request=None, package=None): from repoze.bfg.renderers import render - return render(renderer_name, **kw) + return render(renderer_name, value, request=request, package=package) 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) + result = self._callFUT('abc/def.pt', dict(a=1)) self.assertEqual(result, 'abc') renderer.assert_(a=1) renderer.assert_(request=None) @@ -434,7 +424,7 @@ class Test_render(unittest.TestCase): renderer.string_response = 'abc' request = testing.DummyRequest() result = self._callFUT('abc/def.pt', - a=1, request=request) + dict(a=1), request=request) self.assertEqual(result, 'abc') renderer.assert_(a=1) renderer.assert_(request=request) @@ -446,15 +436,16 @@ class Test_render_to_response(unittest.TestCase): def tearDown(self): testing.tearDown() - def _callFUT(self, renderer_name, **kw): + def _callFUT(self, renderer_name, value, request=None, package=None): from repoze.bfg.renderers import render_to_response - return render_to_response(renderer_name, **kw) + return render_to_response(renderer_name, value, request=request, + package=package) 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) + response = self._callFUT('abc/def.pt', dict(a=1)) self.assertEqual(response.body, 'abc') renderer.assert_(a=1) renderer.assert_(request=None) @@ -465,7 +456,7 @@ class Test_render_to_response(unittest.TestCase): renderer.string_response = 'abc' request = testing.DummyRequest() response = self._callFUT('abc/def.pt', - a=1, request=request) + dict(a=1), request=request) self.assertEqual(response.body, 'abc') renderer.assert_(a=1) renderer.assert_(request=request) diff --git a/repoze/bfg/tests/test_resource.py b/repoze/bfg/tests/test_resource.py index 39f883ba1..191d72c8b 100644 --- a/repoze/bfg/tests/test_resource.py +++ b/repoze/bfg/tests/test_resource.py @@ -373,7 +373,15 @@ class Test_resolve_resource_spec(unittest.TestCase): package_name, filename = self._callFUT(path, pkg) self.assertEqual(package_name, None) self.assertEqual(filename, 'test_resource.py') - + + def test_package_name_is_package_object(self): + import repoze.bfg.tests + pkg = repoze.bfg.tests + path = 'test_resource.py' + package_name, filename = self._callFUT(path, pkg) + self.assertEqual(package_name, 'repoze.bfg.tests') + self.assertEqual(filename, 'test_resource.py') + class TestFileOverride(unittest.TestCase): def _getTargetClass(self): diff --git a/repoze/bfg/tests/test_testing.py b/repoze/bfg/tests/test_testing.py index fc3bd7c9e..b24843e77 100644 --- a/repoze/bfg/tests/test_testing.py +++ b/repoze/bfg/tests/test_testing.py @@ -67,7 +67,7 @@ class Test_registerTemplateRenderer(TestBase): from repoze.bfg.testing import DummyTemplateRenderer self.failUnless(isinstance(renderer, DummyTemplateRenderer)) from repoze.bfg.renderers import render_to_response - render_to_response('templates/foo', foo=1, bar=2) + render_to_response('templates/foo', dict(foo=1, bar=2)) renderer.assert_(foo=1) renderer.assert_(bar=2) @@ -77,7 +77,7 @@ class Test_registerTemplateRenderer(TestBase): self.assertEqual(kw, {'foo':1, 'bar':2}) renderer = testing.registerTemplateRenderer('templates/foo', renderer) from repoze.bfg.renderers import render_to_response - render_to_response('templates/foo', foo=1, bar=2) + render_to_response('templates/foo', dict(foo=1, bar=2)) class Test_registerEventListener(TestBase): def test_registerEventListener_single(self): -- cgit v1.2.3