From a9fed7675d8da572dee840676714b2653e3f7f79 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Wed, 16 Sep 2009 04:56:49 +0000 Subject: Checkpoint. Not 100% test coverage. --- repoze/bfg/tests/test_chameleon_text.py | 4 +- repoze/bfg/tests/test_chameleon_zpt.py | 2 +- repoze/bfg/tests/test_renderers.py | 177 ++++++++++++++++++++++++++++++ repoze/bfg/tests/test_templating.py | 185 -------------------------------- repoze/bfg/tests/test_testing.py | 8 +- repoze/bfg/tests/test_view.py | 142 ++++++++++++++++++------ repoze/bfg/tests/test_zcml.py | 40 ++++--- 7 files changed, 320 insertions(+), 238 deletions(-) create mode 100644 repoze/bfg/tests/test_renderers.py delete mode 100644 repoze/bfg/tests/test_templating.py (limited to 'repoze/bfg/tests') diff --git a/repoze/bfg/tests/test_chameleon_text.py b/repoze/bfg/tests/test_chameleon_text.py index 139a77072..ddb6f717a 100644 --- a/repoze/bfg/tests/test_chameleon_text.py +++ b/repoze/bfg/tests/test_chameleon_text.py @@ -51,7 +51,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase): self._zcmlConfigure() minimal = self._getTemplatePath('minimal.txt') instance = self._makeOne(minimal) - result = instance() + result = instance({}) self.failUnless(isinstance(result, str)) self.assertEqual(result, 'Hello.\n') @@ -59,7 +59,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase): self._zcmlConfigure() nonminimal = self._getTemplatePath('nonminimal.txt') instance = self._makeOne(nonminimal) - result = instance(name='Chris') + result = instance({'name':'Chris'}) self.failUnless(isinstance(result, str)) self.assertEqual(result, 'Hello, Chris!\n') diff --git a/repoze/bfg/tests/test_chameleon_zpt.py b/repoze/bfg/tests/test_chameleon_zpt.py index 4a1cac166..f6d7c0da5 100644 --- a/repoze/bfg/tests/test_chameleon_zpt.py +++ b/repoze/bfg/tests/test_chameleon_zpt.py @@ -44,7 +44,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase): self._zcmlConfigure() minimal = self._getTemplatePath('minimal.pt') instance = self._makeOne(minimal) - result = instance() + result = instance({}) self.failUnless(isinstance(result, unicode)) self.assertEqual(result, '
\n
') diff --git a/repoze/bfg/tests/test_renderers.py b/repoze/bfg/tests/test_renderers.py new file mode 100644 index 000000000..aa159cc18 --- /dev/null +++ b/repoze/bfg/tests/test_renderers.py @@ -0,0 +1,177 @@ +import unittest + +from repoze.bfg.testing import cleanUp +from repoze.bfg import testing + +class TestTemplateRendererFactory(unittest.TestCase): + def setUp(self): + cleanUp() + + def tearDown(self): + cleanUp() + + def _callFUT(self, path, factory, level=3): + from repoze.bfg.renderers import template_renderer_factory + return template_renderer_factory(path, factory, level) + + def test_abspath_notfound(self): + from repoze.bfg.interfaces import ITemplateRenderer + abspath = '/wont/exist' + testing.registerUtility({}, ITemplateRenderer, name=abspath) + self.assertRaises(ValueError, self._callFUT, abspath, None) + + def test_abspath_alreadyregistered(self): + from repoze.bfg.interfaces import ITemplateRenderer + import os + abspath = os.path.abspath(__file__) + renderer = {} + testing.registerUtility(renderer, ITemplateRenderer, name=abspath) + result = self._callFUT(abspath, None) + self.failUnless(result is renderer) + + def test_abspath_notyetregistered(self): + from repoze.bfg.interfaces import ITemplateRenderer + import os + abspath = os.path.abspath(__file__) + renderer = {} + testing.registerUtility(renderer, ITemplateRenderer, name=abspath) + result = self._callFUT(abspath, None) + self.failUnless(result is renderer) + + def test_relpath_path_registered(self): + renderer = {} + from repoze.bfg.interfaces import ITemplateRenderer + testing.registerUtility(renderer, ITemplateRenderer, name='foo/bar') + result = self._callFUT('foo/bar', None) + self.failUnless(renderer is result) + + def test_relpath_is_package_registered(self): + renderer = {} + from repoze.bfg.interfaces import ITemplateRenderer + testing.registerUtility(renderer, ITemplateRenderer, name='foo:bar/baz') + result = self._callFUT('foo:bar/baz', None) + self.failUnless(renderer is result) + + def test_relpath_notfound(self): + self.assertRaises(ValueError, self._callFUT, 'wont/exist', None) + + def test_relpath_is_package_notfound(self): + from repoze.bfg import tests + module_name = tests.__name__ + self.assertRaises(ValueError, self._callFUT, + '%s:wont/exist' % module_name, None) + + def test_relpath_alreadyregistered(self): + from repoze.bfg.interfaces import ITemplateRenderer + from repoze.bfg import tests + module_name = tests.__name__ + relpath = 'test_templating.py' + spec = '%s:%s' % (module_name, relpath) + renderer = {} + testing.registerUtility(renderer, ITemplateRenderer, name=spec) + result = self._callFUT('test_templating.py', None) + self.failUnless(result is renderer) + + def test_relpath_is_package_alreadyregistered(self): + from repoze.bfg.interfaces import ITemplateRenderer + from repoze.bfg import tests + module_name = tests.__name__ + relpath = 'test_templating.py' + spec = '%s:%s' % (module_name, relpath) + renderer = {} + testing.registerUtility(renderer, ITemplateRenderer, name=spec) + result = self._callFUT(spec, None) + self.failUnless(result is renderer) + + def test_relpath_notyetregistered(self): + import os + from repoze.bfg.tests import test_templating + module_name = test_templating.__name__ + relpath = 'test_renderers.py' + renderer = {} + factory = DummyFactory(renderer) + result = self._callFUT('test_renderers.py', factory) + self.failUnless(result is renderer) + path = os.path.abspath(__file__) + if path.endswith('pyc'): # pragma: no cover + path = path[:-1] + self.assertEqual(factory.path, path) + self.assertEqual(factory.kw, {}) + + def test_relpath_is_package_notyetregistered(self): + import os + from repoze.bfg import tests + module_name = tests.__name__ + relpath = 'test_renderers.py' + renderer = {} + factory = DummyFactory(renderer) + spec = '%s:%s' % (module_name, relpath) + result = self._callFUT(spec, factory) + self.failUnless(result is renderer) + path = os.path.abspath(__file__) + if path.endswith('pyc'): # pragma: no cover + path = path[:-1] + self.assertEqual(factory.path, path) + self.assertEqual(factory.kw, {}) + + def test_reload_resources_true(self): + from zope.component import queryUtility + from repoze.bfg.interfaces import ISettings + from repoze.bfg.interfaces import ITemplateRenderer + settings = {'reload_resources':True} + testing.registerUtility(settings, ISettings) + renderer = {} + factory = DummyFactory(renderer) + result = self._callFUT('test_renderers.py', factory) + self.failUnless(result is renderer) + spec = '%s:%s' % ('repoze.bfg.tests', 'test_renderers.py') + self.assertEqual(queryUtility(ITemplateRenderer, name=spec), + None) + + def test_reload_resources_false(self): + from zope.component import queryUtility + from repoze.bfg.interfaces import ISettings + from repoze.bfg.interfaces import ITemplateRenderer + settings = {'reload_resources':False} + testing.registerUtility(settings, ISettings) + renderer = {} + factory = DummyFactory(renderer) + result = self._callFUT('test_renderers.py', factory) + self.failUnless(result is renderer) + spec = '%s:%s' % ('repoze.bfg.tests', 'test_renderers.py') + self.assertNotEqual(queryUtility(ITemplateRenderer, name=spec), + None) + +class TestRendererFromPath(unittest.TestCase): + def setUp(self): + cleanUp() + + def tearDown(self): + cleanUp() + + def _callFUT(self, path, level=4): + from repoze.bfg.renderers import renderer_from_name + return renderer_from_name(path, level) + + def test_it(self): + from repoze.bfg.interfaces import ITemplateRendererFactory + 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 + testing.registerUtility(factory, ITemplateRendererFactory, name='.pt') + result = self._callFUT(fixture) + self.assertEqual(result, renderer) + +class DummyFactory: + def __init__(self, renderer): + self.renderer = renderer + + def __call__(self, path, **kw): + self.path = path + self.kw = kw + return self.renderer + + diff --git a/repoze/bfg/tests/test_templating.py b/repoze/bfg/tests/test_templating.py deleted file mode 100644 index c3894cce4..000000000 --- a/repoze/bfg/tests/test_templating.py +++ /dev/null @@ -1,185 +0,0 @@ -import unittest - -from repoze.bfg.testing import cleanUp -from repoze.bfg import testing - -class TestRendererFromCache(unittest.TestCase): - def setUp(self): - cleanUp() - - def tearDown(self): - cleanUp() - - def _callFUT(self, path, factory, level=3, **kw): - from repoze.bfg.templating import renderer_from_cache - return renderer_from_cache(path, factory, level, **kw) - - def test_abspath_notfound(self): - from repoze.bfg.interfaces import ITemplateRenderer - abspath = '/wont/exist' - testing.registerUtility({}, ITemplateRenderer, name=abspath) - self.assertRaises(ValueError, self._callFUT, abspath, None) - - def test_abspath_alreadyregistered(self): - from repoze.bfg.interfaces import ITemplateRenderer - import os - abspath = os.path.abspath(__file__) - renderer = {} - testing.registerUtility(renderer, ITemplateRenderer, name=abspath) - result = self._callFUT(abspath, None) - self.failUnless(result is renderer) - - def test_abspath_notyetregistered(self): - from repoze.bfg.interfaces import ITemplateRenderer - import os - abspath = os.path.abspath(__file__) - renderer = {} - testing.registerUtility(renderer, ITemplateRenderer, name=abspath) - result = self._callFUT(abspath, None) - self.failUnless(result is renderer) - - def test_relpath_path_registered(self): - renderer = {} - from repoze.bfg.interfaces import ITemplateRenderer - testing.registerUtility(renderer, ITemplateRenderer, name='foo/bar') - result = self._callFUT('foo/bar', None) - self.failUnless(renderer is result) - - def test_relpath_is_package_registered(self): - renderer = {} - from repoze.bfg.interfaces import ITemplateRenderer - testing.registerUtility(renderer, ITemplateRenderer, name='foo:bar/baz') - result = self._callFUT('foo:bar/baz', None) - self.failUnless(renderer is result) - - def test_relpath_notfound(self): - self.assertRaises(ValueError, self._callFUT, 'wont/exist', None) - - def test_relpath_is_package_notfound(self): - from repoze.bfg import tests - module_name = tests.__name__ - self.assertRaises(ValueError, self._callFUT, - '%s:wont/exist' % module_name, None) - - def test_relpath_alreadyregistered(self): - from repoze.bfg.interfaces import ITemplateRenderer - from repoze.bfg import tests - module_name = tests.__name__ - relpath = 'test_templating.py' - spec = '%s:%s' % (module_name, relpath) - renderer = {} - testing.registerUtility(renderer, ITemplateRenderer, name=spec) - result = self._callFUT('test_templating.py', None) - self.failUnless(result is renderer) - - def test_relpath_is_package_alreadyregistered(self): - from repoze.bfg.interfaces import ITemplateRenderer - from repoze.bfg import tests - module_name = tests.__name__ - relpath = 'test_templating.py' - spec = '%s:%s' % (module_name, relpath) - renderer = {} - testing.registerUtility(renderer, ITemplateRenderer, name=spec) - result = self._callFUT(spec, None) - self.failUnless(result is renderer) - - def test_relpath_notyetregistered(self): - import os - from repoze.bfg.tests import test_templating - module_name = test_templating.__name__ - relpath = 'test_templating.py' - renderer = {} - factory = DummyFactory(renderer) - result = self._callFUT('test_templating.py', factory) - self.failUnless(result is renderer) - path = os.path.abspath(__file__) - if path.endswith('pyc'): # pragma: no cover - path = path[:-1] - self.assertEqual(factory.path, path) - self.assertEqual(factory.kw, {}) - - def test_relpath_is_package_notyetregistered(self): - import os - from repoze.bfg import tests - module_name = tests.__name__ - relpath = 'test_templating.py' - renderer = {} - factory = DummyFactory(renderer) - spec = '%s:%s' % (module_name, relpath) - result = self._callFUT(spec, factory) - self.failUnless(result is renderer) - path = os.path.abspath(__file__) - if path.endswith('pyc'): # pragma: no cover - path = path[:-1] - self.assertEqual(factory.path, path) - self.assertEqual(factory.kw, {}) - - def test_reload_resources_true(self): - from zope.component import queryUtility - from repoze.bfg.interfaces import ISettings - from repoze.bfg.interfaces import ITemplateRenderer - settings = {'reload_resources':True} - testing.registerUtility(settings, ISettings) - renderer = {} - factory = DummyFactory(renderer) - result = self._callFUT('test_templating.py', factory) - self.failUnless(result is renderer) - spec = '%s:%s' % ('repoze.bfg.tests', 'test_templating.py') - self.assertEqual(queryUtility(ITemplateRenderer, name=spec), - None) - - def test_reload_resources_false(self): - from zope.component import queryUtility - from repoze.bfg.interfaces import ISettings - from repoze.bfg.interfaces import ITemplateRenderer - settings = {'reload_resources':False} - testing.registerUtility(settings, ISettings) - renderer = {} - factory = DummyFactory(renderer) - result = self._callFUT('test_templating.py', factory) - self.failUnless(result is renderer) - spec = '%s:%s' % ('repoze.bfg.tests', 'test_templating.py') - self.assertNotEqual(queryUtility(ITemplateRenderer, name=spec), - None) - -class TestRendererFromPath(unittest.TestCase): - def setUp(self): - cleanUp() - - def tearDown(self): - cleanUp() - - def _callFUT(self, path, level=4, **kw): - from repoze.bfg.templating import renderer_from_path - return renderer_from_path(path, level, **kw) - - def test_with_default(self): - from repoze.bfg.templating import TextTemplateRenderer - import os - here = os.path.dirname(os.path.abspath(__file__)) - fixture = os.path.join(here, 'fixtures/minimal.txt') - result = self._callFUT(fixture) - self.assertEqual(result.__class__, TextTemplateRenderer) - - def test_with_nondefault(self): - from repoze.bfg.interfaces import ITemplateRendererFactory - 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 - testing.registerUtility(factory, ITemplateRendererFactory, name='.pt') - result = self._callFUT(fixture) - self.assertEqual(result, renderer) - -class DummyFactory: - def __init__(self, renderer): - self.renderer = renderer - - def __call__(self, path, **kw): - self.path = path - self.kw = kw - return self.renderer - - diff --git a/repoze/bfg/tests/test_testing.py b/repoze/bfg/tests/test_testing.py index e81a90219..9ebd8468a 100644 --- a/repoze/bfg/tests/test_testing.py +++ b/repoze/bfg/tests/test_testing.py @@ -65,7 +65,7 @@ class TestTestingFunctions(unittest.TestCase): def test_registerDummyRenderer_explicitrenderer(self): from repoze.bfg import testing - def renderer(**kw): + def renderer(kw): raise ValueError renderer = testing.registerDummyRenderer('templates/foo', renderer) from repoze.bfg.chameleon_zpt import render_template_to_response @@ -460,20 +460,20 @@ class TestDummyTemplateRenderer(unittest.TestCase): def test_getattr(self): renderer = self._makeOne() - renderer(a=1) + renderer({'a':1}) self.assertEqual(renderer.a, 1) self.assertRaises(AttributeError, renderer.__getattr__, 'b') def test_assert_(self): renderer = self._makeOne() - renderer(a=1, b=2) + renderer({'a':1, 'b':2}) self.assertRaises(AssertionError, renderer.assert_, c=1) self.assertRaises(AssertionError, renderer.assert_, b=3) self.failUnless(renderer.assert_(a=1, b=2)) def test_nondefault_string_response(self): renderer = self._makeOne('abc') - result = renderer(a=1, b=2) + result = renderer({'a':1, 'b':2}) self.assertEqual(result, 'abc') class CleanUpTests(object): diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py index 5639e9799..3106359a3 100644 --- a/repoze/bfg/tests/test_view.py +++ b/repoze/bfg/tests/test_view.py @@ -631,6 +631,25 @@ class Test_map_view(unittest.TestCase): from repoze.bfg.view import map_view return map_view(view, *arg, **kw) + def _registerRenderer(self): + from repoze.bfg.interfaces import IRendererFactory + from repoze.bfg.interfaces import ITemplateRenderer + from zope.interface import implements + from zope.component import getSiteManager + class Renderer: + implements(ITemplateRenderer) + def __call__(self, *arg): + return 'Hello!' + + class RendererFactory: + def __call__(self, path): + self.path = path + return Renderer() + + factory = RendererFactory() + sm = getSiteManager() + sm.registerUtility(factory, IRendererFactory, name='.txt') + def test_view_as_function_context_and_request(self): def view(context, request): return 'OK' @@ -646,10 +665,11 @@ class Test_map_view(unittest.TestCase): self.assertRaises(TypeError, result, None, None) def test_view_as_function_with_attr_and_template(self): + self._registerRenderer() def view(context, request): """ """ result = self._callFUT(view, attr='__name__', - template='fixtures/minimal.txt') + renderer='fixtures/minimal.txt') self.failIf(result is view) self.assertRaises(TypeError, result, None, None) @@ -701,18 +721,20 @@ class Test_map_view(unittest.TestCase): def test_view_as_newstyle_class_context_and_request_with_attr_and_template( self): + self._registerRenderer() class view(object): def __init__(self, context, request): pass def index(self): return {'a':'1'} result = self._callFUT(view, attr='index', - template='repoze.bfg.tests:fixtures/minimal.txt') + renderer='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None).body, 'Hello.\n') + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') def test_view_as_newstyle_class_requestonly(self): class view(object): @@ -741,18 +763,20 @@ class Test_map_view(unittest.TestCase): self.assertEqual(result(None, None), 'OK') def test_view_as_newstyle_class_requestonly_with_attr_and_template(self): + self._registerRenderer() class view(object): def __init__(self, request): pass def index(self): return {'a':'1'} result = self._callFUT(view, attr='index', - template='repoze.bfg.tests:fixtures/minimal.txt') + renderer='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None).body, 'Hello.\n') + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') def test_view_as_oldstyle_class_context_and_request(self): class view: @@ -782,18 +806,20 @@ class Test_map_view(unittest.TestCase): def test_view_as_oldstyle_class_context_and_request_with_attr_and_template( self): + self._registerRenderer() class view: def __init__(self, context, request): pass def index(self): return {'a':'1'} result = self._callFUT(view, attr='index', - template='repoze.bfg.tests:fixtures/minimal.txt') + renderer='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None).body, 'Hello.\n') + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') def test_view_as_oldstyle_class_requestonly(self): class view: @@ -822,18 +848,20 @@ class Test_map_view(unittest.TestCase): self.assertEqual(result(None, None), 'OK') def test_view_as_oldstyle_class_requestonly_with_attr_and_template(self): + self._registerRenderer() class view: def __init__(self, request): pass def index(self): return {'a':'1'} result = self._callFUT(view, attr='index', - template='repoze.bfg.tests:fixtures/minimal.txt') + renderer='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.assertEqual(result(None, None).body, 'Hello.\n') + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') def test_view_as_instance_context_and_request(self): class View: @@ -854,14 +882,16 @@ class Test_map_view(unittest.TestCase): self.assertEqual(result(None, None), 'OK') def test_view_as_instance_context_and_request_attr_and_template(self): + self._registerRenderer() class View: def index(self, context, request): return {'a':'1'} view = View() result = self._callFUT(view, attr='index', - template='repoze.bfg.tests:fixtures/minimal.txt') + renderer='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) - self.assertEqual(result(None, None).body, 'Hello.\n') + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') def test_view_as_instance_requestonly(self): class View: @@ -888,27 +918,31 @@ class Test_map_view(unittest.TestCase): self.assertEqual(result(None, None), 'OK') def test_view_as_instance_requestonly_with_attr_and_template(self): + self._registerRenderer() class View: def index(self, request): return {'a':'1'} view = View() result = self._callFUT(view, attr='index', - template='repoze.bfg.tests:fixtures/minimal.txt') + renderer='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.failUnless('instance' in result.__name__) - self.assertEqual(result(None, None).body, 'Hello.\n') + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') def test_view_templateonly(self): + self._registerRenderer() def view(context, request): return {'a':'1'} result = self._callFUT(view, - template='repoze.bfg.tests:fixtures/minimal.txt') + renderer='repoze.bfg.tests:fixtures/minimal.txt') self.failIf(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) - self.assertEqual(result(None, None).body, 'Hello.\n') + request = DummyRequest() + self.assertEqual(result(None, request).body, 'Hello!') class TestRequestOnly(unittest.TestCase): def _callFUT(self, arg): @@ -1112,7 +1146,7 @@ class TestDecorateView(unittest.TestCase): self.failUnless(view1.__predicated__.im_func is view2.__predicated__.im_func) -class Test_templated_response(unittest.TestCase): +class Test_rendered_response(unittest.TestCase): def setUp(self): cleanUp() @@ -1120,61 +1154,105 @@ class Test_templated_response(unittest.TestCase): cleanUp() def _callFUT(self, template_name, response, view=None, - context=None, request=None, auto_reload=False): - from repoze.bfg.view import templated_response - return templated_response(template_name, response, view, context, - request, auto_reload) + context=None, request=None): + from repoze.bfg.view import rendered_response + if request is None: + request = DummyRequest() + return rendered_response(template_name, response, view, context, + request) + + def _registerRenderer(self): + from repoze.bfg.interfaces import IRendererFactory + from repoze.bfg.interfaces import ITemplateRenderer + from zope.interface import implements + from zope.component import getSiteManager + class Renderer: + implements(ITemplateRenderer) + def __call__(self, *arg): + return 'Hello!' + + class RendererFactory: + def __call__(self, path): + self.path = path + return Renderer() + + factory = RendererFactory() + sm = getSiteManager() + sm.registerUtility(factory, IRendererFactory, name='.txt') def test_is_response(self): + self._registerRenderer() response = DummyResponse() result = self._callFUT( 'repoze.bfg.tests:fixtures/minimal.txt', response) self.assertEqual(result, response) def test_is_not_valid_dict(self): + self._registerRenderer() response = None result = self._callFUT( 'repoze.bfg.tests:fixtures/minimal.txt', response) self.assertEqual(result, response) def test_valid_dict(self): + self._registerRenderer() response = {'a':'1'} result = self._callFUT( 'repoze.bfg.tests:fixtures/minimal.txt', response) - self.assertEqual(result.body, 'Hello.\n') + self.assertEqual(result.body, 'Hello!') def test_with_content_type(self): - response = {'a':'1', 'content_type_':'text/nonsense'} + self._registerRenderer() + response = {'a':'1'} + request = DummyRequest() + attrs = {'response_content_type':'text/nonsense'} + request.environ['webob.adhoc_attrs'] = attrs result = self._callFUT( - 'repoze.bfg.tests:fixtures/minimal.txt', response) + 'repoze.bfg.tests:fixtures/minimal.txt', response, request=request) self.assertEqual(result.content_type, 'text/nonsense') def test_with_headerlist(self): - response = {'a':'1', 'headerlist_':[('a', '1'), ('b', '2')]} + self._registerRenderer() + response = {'a':'1'} + request = DummyRequest() + attrs = {'response_headerlist':[('a', '1'), ('b', '2')]} + request.environ['webob.adhoc_attrs'] = attrs result = self._callFUT( - 'repoze.bfg.tests:fixtures/minimal.txt', response) + 'repoze.bfg.tests:fixtures/minimal.txt', response, request=request) self.assertEqual(result.headerlist, [('Content-Type', 'text/html; charset=UTF-8'), - ('Content-Length', '7'), + ('Content-Length', '6'), ('a', '1'), ('b', '2')]) def test_with_status(self): - response = {'a':'1', 'status_':'406 You Lose'} + self._registerRenderer() + response = {'a':'1'} + request = DummyRequest() + attrs = {'response_status':'406 You Lose'} + request.environ['webob.adhoc_attrs'] = attrs result = self._callFUT( - 'repoze.bfg.tests:fixtures/minimal.txt', response) + 'repoze.bfg.tests:fixtures/minimal.txt', response, request=request) self.assertEqual(result.status, '406 You Lose') def test_with_charset(self): - response = {'a':'1', 'charset_':'UTF-16'} + self._registerRenderer() + response = {'a':'1'} + request = DummyRequest() + attrs = {'response_charset':'UTF-16'} + request.environ['webob.adhoc_attrs'] = attrs result = self._callFUT( - 'repoze.bfg.tests:fixtures/minimal.txt', response) + 'repoze.bfg.tests:fixtures/minimal.txt', response, request=request) self.assertEqual(result.charset, 'UTF-16') def test_with_cache_for(self): - response = {'a':'1', 'cache_for_':100} + self._registerRenderer() + response = {'a':'1'} + request = DummyRequest() + attrs = {'response_cache_for':100} + request.environ['webob.adhoc_attrs'] = attrs result = self._callFUT( - 'repoze.bfg.tests:fixtures/minimal.txt', response) + 'repoze.bfg.tests:fixtures/minimal.txt', response, request=request) self.assertEqual(result.cache_control.max_age, 100) class DummyContext: diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py index 208e8e754..21d55504d 100644 --- a/repoze/bfg/tests/test_zcml.py +++ b/repoze/bfg/tests/test_zcml.py @@ -320,8 +320,7 @@ class TestViewDirective(unittest.TestCase): from zope.component import getSiteManager from repoze.bfg.interfaces import IRequest from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IViewPermission - + from repoze.bfg.interfaces import IRendererFactory import repoze.bfg.tests context = DummyContext(repoze.bfg.tests) @@ -335,9 +334,17 @@ class TestViewDirective(unittest.TestCase): def __call__(self): return {'a':'1'} - import os + class Renderer: + def __call__(self, path): + self.path = path + return lambda *arg: 'Hello!' + + renderer = Renderer() + sm = getSiteManager() + sm.registerUtility(renderer, IRendererFactory, name='.txt') + fixture = 'fixtures/minimal.txt' - self._callFUT(context, 'repoze.view', IFoo, view=view, template=fixture) + self._callFUT(context, 'repoze.view', IFoo, view=view, renderer=fixture) actions = context.actions self.assertEqual(len(actions), 1) @@ -347,29 +354,33 @@ class TestViewDirective(unittest.TestCase): self.assertEqual(action['discriminator'], discrim) register = action['callable'] register() - sm = getSiteManager() wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') self.assertEqual(wrapper.__module__, view.__module__) self.assertEqual(wrapper.__name__, view.__name__) self.assertEqual(wrapper.__doc__, view.__doc__) - result = wrapper(None, None) - self.assertEqual(result.body, 'Hello.\n') + request = DummyRequest() + result = wrapper(None, request) + self.assertEqual(result.body, 'Hello!') + self.assertEqual(renderer.path, 'repoze.bfg.tests:fixtures/minimal.txt') def test_with_template_no_view_callable(self): from zope.interface import Interface from zope.component import getSiteManager from repoze.bfg.interfaces import IRequest from repoze.bfg.interfaces import IView - from repoze.bfg.interfaces import IViewPermission + from repoze.bfg.interfaces import IRendererFactory import repoze.bfg.tests context = DummyContext(repoze.bfg.tests) class IFoo(Interface): pass - import os - fixture = 'fixtures/minimal.txt' - self._callFUT(context, 'repoze.view', IFoo, template=fixture) + sm = getSiteManager() + def renderer_factory(path): + return lambda *arg: 'Hello!' + sm.registerUtility(renderer_factory, IRendererFactory, name='.txt') + + self._callFUT(context, 'repoze.view', IFoo, renderer='foo.txt') actions = context.actions self.assertEqual(len(actions), 1) @@ -379,10 +390,11 @@ class TestViewDirective(unittest.TestCase): self.assertEqual(action['discriminator'], discrim) register = action['callable'] register() - sm = getSiteManager() wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='') - result = wrapper(None, None) - self.assertEqual(result.body, 'Hello.\n') + request = DummyRequest() + request.environ = {} + result = wrapper(None, request) + self.assertEqual(result.body, 'Hello!') def test_request_type_asinterface(self): from zope.component import getSiteManager -- cgit v1.2.3