From 6f0805ec33252d391338972eaadea25262b6d71c Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Mon, 18 Apr 2011 13:28:52 -0400 Subject: garden --- TODO.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/TODO.txt b/TODO.txt index d5d676d21..dd2947477 100644 --- a/TODO.txt +++ b/TODO.txt @@ -27,7 +27,8 @@ Should-Have - Provide a response_set_cookie method on the request for rendered responses that can be used as input to response.set_cookie? Or maybe accessing ``request.response`` creates a Response, and you do - ``request.response.set_cookie(...)``. + ``request.response.set_cookie(...)``. See also + https://github.com/Pylons/pyramid/issues/175 - Fix message catalog extraction / compilation documentation. -- cgit v1.2.3 From a7b1a933a263ee99426fda642c379d942f8f852b Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Mon, 18 Apr 2011 17:07:38 -0400 Subject: - Deprecated all assignments to ``request.response_*`` attributes such as ``request.response_content_type = 'foo'``. Assignments and mutations of the following request attributes that were considered by the framework for response influence are now deprecated: ``response_content_type``, ``response_headerlist``, ``response_status``, ``response_charset``, and ``response_cache_for``. Instead of assigning these to the request object for detection by the rendering machinery, users should use the appropriate API of the Response object created by accessing ``request.response`` (e.g. ``request.response_content_type = 'abc'`` -> ``request.response.content_type = 'abc'``). - Custom request objects are now required to have a ``response`` attribute (or reified property) if they are meant to be used with renderers. This ``response`` attribute should be an instance of the class ``pyramid.response.Response``. - The JSON and string renderer factories now use ``request.response.content_type`` rather than ``request.response_content_type``. They determine whether they should set the content type of the response by comparing the response's content type against the default (usually ``text/html``); if the content type is not the default, the renderer changes the content type (to ``application/json`` or ``text/plain`` for JSON and string renderers respectively). - Made it possible to assign to and delete ``pyramid.testing.DummyRequest.registry`` (bugfix). --- CHANGES.txt | 30 +++++++++++++ docs/api/request.rst | 42 +++++++++++++++++- docs/narr/renderers.rst | 74 ++++++++++++++++++++------------ docs/narr/templates.rst | 14 +++--- pyramid/renderers.py | 46 ++++++++++++++++---- pyramid/request.py | 22 ++++++++++ pyramid/testing.py | 24 +++++++++-- pyramid/tests/test_renderers.py | 95 ++++++++++++++++++++++++++++++++++++----- pyramid/tests/test_testing.py | 45 +++++++++++++++++++ 9 files changed, 335 insertions(+), 57 deletions(-) diff --git a/CHANGES.txt b/CHANGES.txt index 3ae834d93..e613e021d 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -1,6 +1,36 @@ Next release ============ +Requestresponse branch +---------------------- + +- Deprecated all assignments to ``request.response_*`` attributes such as + ``request.response_content_type = 'foo'``. Assignments and mutations of + the following request attributes that were considered by the framework for + response influence are now deprecated: ``response_content_type``, + ``response_headerlist``, ``response_status``, ``response_charset``, and + ``response_cache_for``. Instead of assigning these to the request object + for detection by the rendering machinery, users should use the appropriate + API of the Response object created by accessing ``request.response`` + (e.g. ``request.response_content_type = 'abc'`` -> + ``request.response.content_type = 'abc'``). + +- Custom request objects are now required to have a ``response`` attribute + (or reified property) if they are meant to be used with renderers. This + ``response`` attribute should be an instance of the class + ``pyramid.response.Response``. + +- The JSON and string renderer factories now use + ``request.response.content_type`` rather than + ``request.response_content_type``. They determine whether they should set + the content type of the response by comparing the response's content type + against the default (usually ``text/html``); if the content type is not the + default, the renderer changes the content type (to ``application/json`` or + ``text/plain`` for JSON and string renderers respectively). + +- Made it possible to assign to and delete + ``pyramid.testing.DummyRequest.registry`` (bugfix). + Documentation ------------- diff --git a/docs/api/request.rst b/docs/api/request.rst index d17441c0a..80b41badb 100644 --- a/docs/api/request.rst +++ b/docs/api/request.rst @@ -85,6 +85,38 @@ of ``request.exception`` will be ``None`` within response and finished callbacks. + .. attribute:: response + + This attribute is actually a "reified" property which returns an + instance of the :class:`pyramid.response.Response` class. The response + object returned does not exist until this attribute is accessed. Once + it is accessed, subsequent accesses to this request object will return + the same :class:`~pyramid.response.Response` object. + + The ``request.response`` API is used by renderers. A render obtains the + response object it will return from a view that uses that renderer by + accessing ``request.response``. Therefore, it's possible to use the + ``request.response`` API to set up a response object with "the right" + attributes (e.g. by calling ``request.response.set_cookie(...)`` or + ``request.response.content_type = 'text/plain'``, etc) within a view + that uses a renderer. For example, within a view that uses a + :term:`renderer`: + + response = request.response + response.set_cookie('mycookie', 'mine, all mine!') + return {'text':'Value that will be used by the renderer'} + + Mutations to this response object will be preserved in the response sent + to the client after rendering. + + Non-renderer code can also make use of request.response instead of + creating a response "by hand". For example, in view code:: + + response = request.response + response.body = 'Hello!' + response.content_type = 'text/plain' + return response + .. attribute:: session If a :term:`session factory` has been configured, this attribute @@ -127,10 +159,18 @@ .. attribute:: response_* + .. warning:: As of Pyramid 1.1, assignment to ``response_*`` attrs are + deprecated. Assigning to one will cause a deprecation warning to be + emitted. Instead of assigning ``response_*`` attributes to the + request, use the API of the :class:`pyramid.response.Response` + object exposed as ``request.response`` to influence response + behavior. + You can set attributes on a :class:`pyramid.request.Request` which will influence the behavor of *rendered* responses (views which use a :term:`renderer` and which don't directly return a response). These attributes begin with ``response_``, such as ``response_headerlist``. If you need to influence response values from a view that uses a renderer (such as the status code, a header, the content type, etc) see, - :ref:`response_request_attrs`. + :ref:`response_prefixed_attrs`. + diff --git a/docs/narr/renderers.rst b/docs/narr/renderers.rst index 0b7cdb834..c3533648b 100644 --- a/docs/narr/renderers.rst +++ b/docs/narr/renderers.rst @@ -92,8 +92,8 @@ will be employed. return HTTPFound(location='http://example.com') # any renderer avoided Views which use a renderer can vary non-body response attributes (such as -headers and the HTTP status code) by attaching properties to the request. -See :ref:`response_request_attrs`. +headers and the HTTP status code) by attaching a property to the +``request.response`` attribute See :ref:`request_response_attr`. Additional renderers can be added by developers to the system as necessary (see :ref:`adding_and_overriding_renderers`). @@ -147,7 +147,8 @@ representing the ``str()`` serialization of the return value: {'content': 'Hello!'} Views which use the string renderer can vary non-body response attributes by -attaching properties to the request. See :ref:`response_request_attrs`. +using the API of the ``request.response`` attribute. See +:ref:`request_response_attr`. .. index:: pair: renderer; JSON @@ -199,7 +200,8 @@ You can configure a view to use the JSON renderer by naming ``json`` as the Views which use the JSON renderer can vary non-body response attributes by -attaching properties to the request. See :ref:`response_request_attrs`. +using the api of the ``request.response`` attribute. See +:ref:`request_response_attr`. .. index:: pair: renderer; chameleon @@ -269,8 +271,9 @@ Here's an example view configuration which uses a Chameleon text renderer: context='myproject.resources.Hello', renderer='myproject:templates/foo.txt') -Views which use a Chameleon renderer can vary response attributes by -attaching properties to the request. See :ref:`response_request_attrs`. +Views which use a Chameleon renderer can vary response attributes by using +the API of the ``request.response`` attribute. See +:ref:`request_response_attr`. .. index:: pair: renderer; mako @@ -333,7 +336,7 @@ additional :ref:`mako_template_renderer_settings`. single: response headers (from a renderer) single: renderer response headers -.. _response_request_attrs: +.. _request_response_attr: Varying Attributes of Rendered Responses ---------------------------------------- @@ -342,9 +345,43 @@ Before a response constructed by a :term:`renderer` is returned to :app:`Pyramid`, several attributes of the request are examined which have the potential to influence response behavior. -View callables that don't directly return a response should set these -attributes on the ``request`` object via ``setattr`` during their execution, -to influence associated response attributes. +View callables that don't directly return a response should use the API of +the :class:`pyramid.response.Response` attribute available as +``request.response`` during their execution, to influence associated response +behavior. + +For example, if you need to change the response status from within a view +callable that uses a renderer, assign the ``status`` attribute to the +``response`` attribute of the request before returning a result: + +.. code-block:: python + :linenos: + + from pyramid.view import view_config + + @view_config(name='gone', renderer='templates/gone.pt') + def myview(request): + request.response.status = '404 Not Found' + return {'URL':request.URL} + +For more information on attributes of the request, see the API documentation +in :ref:`request_module`. For more information on the API of +``request.response``, see :class:`pyramid.response.Response`. + +.. _response_prefixed_attrs: + +Deprecated Mechanism to Vary Attributes of Rendered Responses +------------------------------------------------------------- + +.. warning:: This section describes behavior deprecated in Pyramid 1.1. + +In previous releases of Pyramid (1.0 and before), the ``request.response`` +attribute did not exist. Instead, Pyramid required users to set special +``response_`` -prefixed attributes of the request to influence response +behavior. As of Pyramid 1.1, those request attributes are deprecated and +their use will cause a deprecation warning to be issued when used. Until +their existence is removed completely, we document them below, for benefit of +people with older code bases. ``response_content_type`` Defines the content-type of the resulting response, @@ -367,23 +404,6 @@ to influence associated response attributes. returning various values in the ``response_headerlist``, this is purely a convenience. -For example, if you need to change the response status from within a view -callable that uses a renderer, assign the ``response_status`` attribute to -the request before returning a result: - -.. code-block:: python - :linenos: - - from pyramid.view import view_config - - @view_config(name='gone', renderer='templates/gone.pt') - def myview(request): - request.response_status = '404 Not Found' - return {'URL':request.URL} - -For more information on attributes of the request, see the API -documentation in :ref:`request_module`. - .. index:: single: renderer (adding) diff --git a/docs/narr/templates.rst b/docs/narr/templates.rst index 426ec229b..150b173e3 100644 --- a/docs/narr/templates.rst +++ b/docs/narr/templates.rst @@ -367,13 +367,13 @@ templates as renderers. See :ref:`available_template_system_bindings`. render a view without needing to fork your code to do so. See :ref:`extending_chapter` for more information. -By default, views rendered via a template renderer return a -:term:`Response` object which has a *status code* of ``200 OK``, and a -*content-type* of ``text/html``. To vary attributes of the response -of a view that uses a renderer, such as the content-type, headers, or -status attributes, you must set attributes on the *request* object -within the view before returning the dictionary. See -:ref:`response_request_attrs` for more information. +By default, views rendered via a template renderer return a :term:`Response` +object which has a *status code* of ``200 OK``, and a *content-type* of +``text/html``. To vary attributes of the response of a view that uses a +renderer, such as the content-type, headers, or status attributes, you must +use the API of the :class:`pyramid.response.Response` object exposed as +``request.response`` within the view before returning the dictionary. See +:ref:`request_response_attr` for more information. The same set of system values are provided to templates rendered via a renderer view configuration as those provided to templates rendered diff --git a/pyramid/renderers.py b/pyramid/renderers.py index c8771709a..a6dce9b3a 100644 --- a/pyramid/renderers.py +++ b/pyramid/renderers.py @@ -1,6 +1,7 @@ import os import pkg_resources import threading +import warnings from zope.interface import implements @@ -134,8 +135,10 @@ def json_renderer_factory(info): def _render(value, system): request = system.get('request') if request is not None: - if not hasattr(request, 'response_content_type'): - request.response_content_type = 'application/json' + response = request.response + ct = response.content_type + if ct == response.default_content_type: + response.content_type = 'application/json' return json.dumps(value) return _render @@ -145,8 +148,10 @@ def string_renderer_factory(info): value = str(value) request = system.get('request') if request is not None: - if not hasattr(request, 'response_content_type'): - request.response_content_type = 'text/plain' + response = request.response + ct = response.content_type + if ct == response.default_content_type: + response.content_type = 'text/plain' return value return _render @@ -344,29 +349,54 @@ class RendererHelper(object): return self._make_response(result, request) def _make_response(self, result, request): - registry = self.registry - response_factory = registry.queryUtility(IResponseFactory, - default=Response) + response = getattr(request, 'response', None) + if response is None: + # request is None or request is not a pyramid.response.Response + registry = self.registry + response_factory = registry.queryUtility(IResponseFactory, + default=Response) + + response = response_factory() - response = response_factory(result) + if result is None: + result = '' + + if isinstance(result, unicode): + response.unicode_body = result + else: + response.body = result if request is not None: + # deprecated mechanism to set up request.response_* attrs attrs = request.__dict__ content_type = attrs.get('response_content_type', None) if content_type is not None: response.content_type = content_type + deprecate_req_attr('Setting', 'content_type', + 'set', 'content_type') headerlist = attrs.get('response_headerlist', None) if headerlist is not None: for k, v in headerlist: response.headers.add(k, v) + deprecate_req_attr('Setting or mutating', 'headerlist', + 'set or mutate', 'headerlist') status = attrs.get('response_status', None) if status is not None: response.status = status + deprecate_req_attr('Setting', 'status', 'set', 'status') charset = attrs.get('response_charset', None) if charset is not None: response.charset = charset + deprecate_req_attr('Setting', 'charset', 'set', 'charset') cache_for = attrs.get('response_cache_for', None) if cache_for is not None: response.cache_expires = cache_for + deprecate_req_attr('Setting', 'cache_for', + 'set', 'cache_expires') return response + +def deprecate_req_attr(*args): + depwarn = ('%s "request.response_%s" is deprecated as of Pyramid 1.1; %s ' + '"request.response.%s" instead.') + warnings.warn(depwarn % args, DeprecationWarning, 3) diff --git a/pyramid/request.py b/pyramid/request.py index b607f159f..9d2b9344b 100644 --- a/pyramid/request.py +++ b/pyramid/request.py @@ -5,9 +5,11 @@ from webob import Request as WebobRequest from pyramid.interfaces import IRequest from pyramid.interfaces import ISessionFactory +from pyramid.interfaces import IResponseFactory from pyramid.exceptions import ConfigurationError from pyramid.decorator import reify +from pyramid.response import Response from pyramid.url import resource_url from pyramid.url import route_url from pyramid.url import static_url @@ -298,6 +300,26 @@ class Request(WebobRequest): """ return route_path(route_name, self, *elements, **kw) + @reify + def response(self): + """This attribute is actually a "reified" property which returns an + instance of the :class:`pyramid.response.Response`. class. The + response object returned does not exist until this attribute is + accessed. Once it is accessed, subsequent accesses will return the + same Response object. + + The ``request.response`` API is used by renderers. A render obtains + the response object it will return from a view that uses that renderer + by accessing ``request.response``. Therefore, it's possible to use the + ``request.response`` API to set up a response object with "the + right" attributes (e.g. by calling ``request.response.set_cookie()``) + within a view that uses a renderer. Mutations to this response object + will be preserved in the response sent to the client.""" + registry = self.registry + response_factory = registry.queryUtility(IResponseFactory, + default=Response) + return response_factory() + # override default WebOb "environ['adhoc_attr']" mutation behavior __getattr__ = object.__getattribute__ __setattr__ = object.__setattr__ diff --git a/pyramid/testing.py b/pyramid/testing.py index a98807a19..36cc38830 100644 --- a/pyramid/testing.py +++ b/pyramid/testing.py @@ -9,12 +9,14 @@ from zope.interface import Interface from zope.interface import alsoProvides from pyramid.interfaces import IRequest +from pyramid.interfaces import IResponseFactory from pyramid.interfaces import ISecuredView from pyramid.interfaces import IView from pyramid.interfaces import IViewClassifier from pyramid.interfaces import ISession from pyramid.config import Configurator +from pyramid.decorator import reify from pyramid.exceptions import Forbidden from pyramid.response import Response from pyramid.registry import Registry @@ -653,6 +655,8 @@ class DummyRequest(object): response_callbacks = () charset = 'UTF-8' script_name = '' + _registry = None + def __init__(self, params=None, environ=None, headers=None, path='/', cookies=None, post=None, **kw): if environ is None: @@ -698,9 +702,23 @@ class DummyRequest(object): self.response_callbacks = [] self.response_callbacks.append(callback) - @property - def registry(self): - return get_current_registry() + def _get_registry(self): + if self._registry is None: + return get_current_registry() + return self._registry + + def _set_registry(self, registry): + self._registry = registry + + def _del_registry(self): + self._registry = None + + registry = property(_get_registry, _set_registry, _del_registry) + + @reify + def response(self): + f = self.registry.queryUtility(IResponseFactory, default=Response) + return f() def setUp(registry=None, request=None, hook_zca=True, autocommit=True, settings=None): diff --git a/pyramid/tests/test_renderers.py b/pyramid/tests/test_renderers.py index 70c2c620e..b0baaee0d 100644 --- a/pyramid/tests/test_renderers.py +++ b/pyramid/tests/test_renderers.py @@ -3,6 +3,18 @@ import unittest from pyramid.testing import cleanUp from pyramid import testing +def hide_warnings(wrapped): + import warnings + def wrapper(*arg, **kw): + warnings.filterwarnings('ignore') + try: + wrapped(*arg, **kw) + finally: + warnings.resetwarnings() + wrapper.__name__ = wrapped.__name__ + wrapper.__doc__ = wrapped.__doc__ + return wrapper + class TestTemplateRendererFactory(unittest.TestCase): def setUp(self): self.config = cleanUp() @@ -394,6 +406,12 @@ class TestRendererFromName(unittest.TestCase): class Test_json_renderer_factory(unittest.TestCase): + def setUp(self): + self.config = testing.setUp() + + def tearDown(self): + testing.tearDown() + def _callFUT(self, name): from pyramid.renderers import json_renderer_factory return json_renderer_factory(name) @@ -407,14 +425,14 @@ class Test_json_renderer_factory(unittest.TestCase): request = testing.DummyRequest() renderer = self._callFUT(None) renderer({'a':1}, {'request':request}) - self.assertEqual(request.response_content_type, 'application/json') + self.assertEqual(request.response.content_type, 'application/json') def test_with_request_content_type_set(self): request = testing.DummyRequest() - request.response_content_type = 'text/mishmash' + request.response.content_type = 'text/mishmash' renderer = self._callFUT(None) renderer({'a':1}, {'request':request}) - self.assertEqual(request.response_content_type, 'text/mishmash') + self.assertEqual(request.response.content_type, 'text/mishmash') class Test_string_renderer_factory(unittest.TestCase): def _callFUT(self, name): @@ -443,14 +461,14 @@ class Test_string_renderer_factory(unittest.TestCase): request = testing.DummyRequest() renderer = self._callFUT(None) renderer(None, {'request':request}) - self.assertEqual(request.response_content_type, 'text/plain') + self.assertEqual(request.response.content_type, 'text/plain') def test_with_request_content_type_set(self): request = testing.DummyRequest() - request.response_content_type = 'text/mishmash' + request.response.content_type = 'text/mishmash' renderer = self._callFUT(None) renderer(None, {'request':request}) - self.assertEqual(request.response_content_type, 'text/mishmash') + self.assertEqual(request.response.content_type, 'text/mishmash') class TestRendererHelper(unittest.TestCase): @@ -492,8 +510,15 @@ class TestRendererHelper(unittest.TestCase): name='.foo') return renderer + def _registerResponseFactory(self): + from pyramid.interfaces import IResponseFactory + class ResponseFactory(object): + pass + self.config.registry.registerUtility(ResponseFactory, IResponseFactory) + def test_render_to_response(self): self._registerRendererFactory() + self._registerResponseFactory() request = Dummy() helper = self._makeOne('loo.foo') response = helper.render_to_response('values', 'system_values', @@ -502,6 +527,7 @@ class TestRendererHelper(unittest.TestCase): def test_render_view(self): self._registerRendererFactory() + self._registerResponseFactory() request = Dummy() helper = self._makeOne('loo.foo') view = 'view' @@ -561,8 +587,43 @@ class TestRendererHelper(unittest.TestCase): result = helper.render('values', None) self.assertEqual(result[1]['a'], 1) + def test__make_response_request_is_None(self): + request = None + helper = self._makeOne('loo.foo') + response = helper._make_response('abc', request) + self.assertEqual(response.body, 'abc') + + def test__make_response_request_is_None_response_factory_exists(self): + self._registerResponseFactory() + request = None + helper = self._makeOne('loo.foo') + response = helper._make_response('abc', request) + self.assertEqual(response.__class__.__name__, 'ResponseFactory') + self.assertEqual(response.body, 'abc') + + def test__make_response_result_is_unicode(self): + from pyramid.response import Response + request = testing.DummyRequest() + request.response = Response() + helper = self._makeOne('loo.foo') + la = unicode('/La Pe\xc3\xb1a', 'utf-8') + response = helper._make_response(la, request) + self.assertEqual(response.body, la.encode('utf-8')) + + def test__make_response_result_is_str(self): + from pyramid.response import Response + request = testing.DummyRequest() + request.response = Response() + helper = self._makeOne('loo.foo') + la = unicode('/La Pe\xc3\xb1a', 'utf-8') + response = helper._make_response(la.encode('utf-8'), request) + self.assertEqual(response.body, la.encode('utf-8')) + + @hide_warnings def test__make_response_with_content_type(self): + from pyramid.response import Response request = testing.DummyRequest() + request.response = Response() attrs = {'response_content_type':'text/nonsense'} request.__dict__.update(attrs) helper = self._makeOne('loo.foo') @@ -570,8 +631,11 @@ class TestRendererHelper(unittest.TestCase): self.assertEqual(response.content_type, 'text/nonsense') self.assertEqual(response.body, 'abc') + @hide_warnings def test__make_response_with_headerlist(self): + from pyramid.response import Response request = testing.DummyRequest() + request.response = Response() attrs = {'response_headerlist':[('a', '1'), ('b', '2')]} request.__dict__.update(attrs) helper = self._makeOne('loo.foo') @@ -583,8 +647,11 @@ class TestRendererHelper(unittest.TestCase): ('b', '2')]) self.assertEqual(response.body, 'abc') + @hide_warnings def test__make_response_with_status(self): + from pyramid.response import Response request = testing.DummyRequest() + request.response = Response() attrs = {'response_status':'406 You Lose'} request.__dict__.update(attrs) helper = self._makeOne('loo.foo') @@ -592,16 +659,22 @@ class TestRendererHelper(unittest.TestCase): self.assertEqual(response.status, '406 You Lose') self.assertEqual(response.body, 'abc') + @hide_warnings def test__make_response_with_charset(self): + from pyramid.response import Response request = testing.DummyRequest() + request.response = Response() attrs = {'response_charset':'UTF-16'} request.__dict__.update(attrs) helper = self._makeOne('loo.foo') response = helper._make_response('abc', request) self.assertEqual(response.charset, 'UTF-16') + @hide_warnings def test__make_response_with_cache_for(self): + from pyramid.response import Response request = testing.DummyRequest() + request.response = Response() attrs = {'response_cache_for':100} request.__dict__.update(attrs) helper = self._makeOne('loo.foo') @@ -611,21 +684,21 @@ class TestRendererHelper(unittest.TestCase): def test_with_alternate_response_factory(self): from pyramid.interfaces import IResponseFactory class ResponseFactory(object): - def __init__(self, result): - self.result = result + def __init__(self): + pass self.config.registry.registerUtility(ResponseFactory, IResponseFactory) request = testing.DummyRequest() helper = self._makeOne('loo.foo') response = helper._make_response('abc', request) self.assertEqual(response.__class__, ResponseFactory) - self.assertEqual(response.result, 'abc') + self.assertEqual(response.body, 'abc') def test__make_response_with_real_request(self): # functional from pyramid.request import Request request = Request({}) - attrs = {'response_status':'406 You Lose'} - request.__dict__.update(attrs) + request.registry = self.config.registry + request.response.status = '406 You Lose' helper = self._makeOne('loo.foo') response = helper._make_response('abc', request) self.assertEqual(response.status, '406 You Lose') diff --git a/pyramid/tests/test_testing.py b/pyramid/tests/test_testing.py index 99b0a1911..ccf4edbc5 100644 --- a/pyramid/tests/test_testing.py +++ b/pyramid/tests/test_testing.py @@ -502,6 +502,51 @@ class TestDummyRequest(unittest.TestCase): finally: config.end() + def test_set_registry(self): + request = self._makeOne() + request.registry = 'abc' + self.assertEqual(request.registry, 'abc') + + def test_del_registry(self): + # see https://github.com/Pylons/pyramid/issues/165 + from pyramid.registry import Registry + from pyramid.config import Configurator + request = self._makeOne() + request.registry = 'abc' + self.assertEqual(request.registry, 'abc') + del request.registry + try: + registry = Registry('this_test') + config = Configurator(registry=registry) + config.begin() + self.failUnless(request.registry is registry) + finally: + config.end() + + def test_response_with_responsefactory(self): + from pyramid.registry import Registry + from pyramid.interfaces import IResponseFactory + registry = Registry('this_test') + class ResponseFactory(object): + pass + registry.registerUtility(ResponseFactory, IResponseFactory) + request = self._makeOne() + request.registry = registry + resp = request.response + self.assertEqual(resp.__class__, ResponseFactory) + self.failUnless(request.response is resp) # reified + + def test_response_without_responsefactory(self): + from pyramid.registry import Registry + from pyramid.response import Response + registry = Registry('this_test') + request = self._makeOne() + request.registry = registry + resp = request.response + self.assertEqual(resp.__class__, Response) + self.failUnless(request.response is resp) # reified + + class TestDummyTemplateRenderer(unittest.TestCase): def _getTargetClass(self, ): from pyramid.testing import DummyTemplateRenderer -- cgit v1.2.3 From d07e169f89ead3ce41ae35a6c30df2964685c93e Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Mon, 18 Apr 2011 22:28:11 -0400 Subject: garden change message --- CHANGES.txt | 35 +++++++++++++++++++---------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/CHANGES.txt b/CHANGES.txt index e613e021d..38bdd382d 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -4,28 +4,31 @@ Next release Requestresponse branch ---------------------- -- Deprecated all assignments to ``request.response_*`` attributes such as - ``request.response_content_type = 'foo'``. Assignments and mutations of - the following request attributes that were considered by the framework for - response influence are now deprecated: ``response_content_type``, - ``response_headerlist``, ``response_status``, ``response_charset``, and - ``response_cache_for``. Instead of assigning these to the request object - for detection by the rendering machinery, users should use the appropriate - API of the Response object created by accessing ``request.response`` - (e.g. ``request.response_content_type = 'abc'`` -> +- Deprecated all assignments to ``request.response_*`` attributes (for + example ``request.response_content_type = 'foo'`` is now deprecated). + Assignments and mutations of the following assignable request attributes + that were considered by the framework for response influence are now + deprecated: ``response_content_type``, ``response_headerlist``, + ``response_status``, ``response_charset``, and ``response_cache_for``. + Instead of assigning these to the request object for later detection by the + rendering machinery, users should use the appropriate API of the Response + object created by accessing ``request.response`` (e.g. code which does + ``request.response_content_type = 'abc'`` should be changed to ``request.response.content_type = 'abc'``). -- Custom request objects are now required to have a ``response`` attribute - (or reified property) if they are meant to be used with renderers. This +- A custom request factory is now required to return a response object that + has a ``response`` attribute (or "reified"/lazy property) if they the + request is meant to be used in a view that uses a renderer. This ``response`` attribute should be an instance of the class ``pyramid.response.Response``. -- The JSON and string renderer factories now use +- The JSON and string renderer factories now assign to ``request.response.content_type`` rather than - ``request.response_content_type``. They determine whether they should set - the content type of the response by comparing the response's content type - against the default (usually ``text/html``); if the content type is not the - default, the renderer changes the content type (to ``application/json`` or + ``request.response_content_type``. Each renderer factory adetermines + whether it should change the content type of the response by comparing the + response's content type against the response's default content type; if the + content type is not the default content type (usually ``text/html``), the + renderer changes the content type (to ``application/json`` or ``text/plain`` for JSON and string renderers respectively). - Made it possible to assign to and delete -- cgit v1.2.3 From 0f7831e3ee2d8504120005bd82cc0eb03d39c73d Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Mon, 18 Apr 2011 23:18:58 -0400 Subject: - Pyramid now depends on WebOb >= 1.0.2 (tests depend on the bugfix in that release: "Fix handling of WSGI environs with missing ``SCRIPT_NAME``"). (Note that in reality, everyone should probably be using 1.0.4 or better though, as WebOb 1.0.2 and 1.0.3 were effectively brownbag releases.) --- CHANGES.txt | 8 ++++++++ setup.py | 2 +- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/CHANGES.txt b/CHANGES.txt index 3ae834d93..a59218eff 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -114,6 +114,14 @@ Bug Fixes - Redirects issued by a static view did not take into account any existing ``SCRIPT_NAME`` (such as one set by a url mapping composite). Now they do. +Dependencies +------------ + +- Pyramid now depends on WebOb >= 1.0.2 (tests depend on the bugfix in that + release: "Fix handling of WSGI environs with missing ``SCRIPT_NAME``"). + (Note that in reality, everyone should probably be using 1.0.4 or better + though, as WebOb 1.0.2 and 1.0.3 were effectively brownbag releases.) + 1.0 (2011-01-30) ================ diff --git a/setup.py b/setup.py index 7c7c80040..ac9db9ab7 100644 --- a/setup.py +++ b/setup.py @@ -31,7 +31,7 @@ install_requires=[ 'Paste > 1.7', # temp version pin to prevent PyPi install failure :-( 'PasteDeploy', 'PasteScript', - 'WebOb >= 1.0', # no "default_charset" + 'WebOb >= 1.0.2', # no "default_charset"; request.script_name doesnt error 'repoze.lru', 'setuptools', 'zope.component >= 3.6.0', # independent of zope.hookable -- cgit v1.2.3 From dad904380fd3f53a82e5c48316cc0e7bfa199b74 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Mon, 18 Apr 2011 23:20:22 -0400 Subject: Fix parens. --- CHANGES.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGES.txt b/CHANGES.txt index a59218eff..66103fbc1 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -117,8 +117,8 @@ Bug Fixes Dependencies ------------ -- Pyramid now depends on WebOb >= 1.0.2 (tests depend on the bugfix in that - release: "Fix handling of WSGI environs with missing ``SCRIPT_NAME``"). +- Pyramid now depends on WebOb >= 1.0.2 as tests depend on the bugfix in that + release: "Fix handling of WSGI environs with missing ``SCRIPT_NAME``". (Note that in reality, everyone should probably be using 1.0.4 or better though, as WebOb 1.0.2 and 1.0.3 were effectively brownbag releases.) -- cgit v1.2.3 From 4d92609add1da64fb50afdd634b87186b94f6a95 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Mon, 18 Apr 2011 23:47:44 -0400 Subject: merge requestresponse section into various changes subsections --- CHANGES.txt | 72 +++++++++++++++++++++++++++++++++---------------------------- 1 file changed, 39 insertions(+), 33 deletions(-) diff --git a/CHANGES.txt b/CHANGES.txt index 83d71e2b7..5f450fdcd 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -1,39 +1,6 @@ Next release ============ -Requestresponse branch ----------------------- - -- Deprecated all assignments to ``request.response_*`` attributes (for - example ``request.response_content_type = 'foo'`` is now deprecated). - Assignments and mutations of the following assignable request attributes - that were considered by the framework for response influence are now - deprecated: ``response_content_type``, ``response_headerlist``, - ``response_status``, ``response_charset``, and ``response_cache_for``. - Instead of assigning these to the request object for later detection by the - rendering machinery, users should use the appropriate API of the Response - object created by accessing ``request.response`` (e.g. code which does - ``request.response_content_type = 'abc'`` should be changed to - ``request.response.content_type = 'abc'``). - -- A custom request factory is now required to return a response object that - has a ``response`` attribute (or "reified"/lazy property) if they the - request is meant to be used in a view that uses a renderer. This - ``response`` attribute should be an instance of the class - ``pyramid.response.Response``. - -- The JSON and string renderer factories now assign to - ``request.response.content_type`` rather than - ``request.response_content_type``. Each renderer factory adetermines - whether it should change the content type of the response by comparing the - response's content type against the response's default content type; if the - content type is not the default content type (usually ``text/html``), the - renderer changes the content type (to ``application/json`` or - ``text/plain`` for JSON and string renderers respectively). - -- Made it possible to assign to and delete - ``pyramid.testing.DummyRequest.registry`` (bugfix). - Documentation ------------- @@ -61,6 +28,12 @@ Documentation Features -------- +- Accessing the ``response`` attribute of a ``pyramid.request.Request`` + object (e.g. ``request.response`` within a view) now produces a new + ``pyramid.response.Response`` object. This feature is meant to be used + mainly when a view configured with a renderer needs to set response + attributes, but it can be used by any code. + - Integers and longs passed as ``elements`` to ``pyramid.url.resource_url`` or ``pyramid.request.Request.resource_url`` e.g. ``resource_url(context, request, 1, 2)`` (``1`` and ``2`` are the ``elements``) will now be @@ -147,6 +120,39 @@ Bug Fixes - Redirects issued by a static view did not take into account any existing ``SCRIPT_NAME`` (such as one set by a url mapping composite). Now they do. +Deprecations +------------ + +- Deprecated all assignments to ``request.response_*`` attributes (for + example ``request.response_content_type = 'foo'`` is now deprecated). + Assignments and mutations of assignable request attributes that were + considered by the framework for response influence are now deprecated: + ``response_content_type``, ``response_headerlist``, ``response_status``, + ``response_charset``, and ``response_cache_for``. Instead of assigning + these to the request object for later detection by the rendering machinery, + users should use the appropriate API of the Response object created by + accessing ``request.response`` (e.g. code which does + ``request.response_content_type = 'abc'`` should be changed to + ``request.response.content_type = 'abc'``). + +Behavior Changes +---------------- + +- A custom request factory is now required to return a response object that + has a ``response`` attribute (or "reified"/lazy property) if they the + request is meant to be used in a view that uses a renderer. This + ``response`` attribute should be an instance of the class + ``pyramid.response.Response``. + +- The JSON and string renderer factories now assign to + ``request.response.content_type`` rather than + ``request.response_content_type``. Each renderer factory determines + whether it should change the content type of the response by comparing the + response's content type against the response's default content type; if the + content type is not the default content type (usually ``text/html``), the + renderer changes the content type (to ``application/json`` or + ``text/plain`` for JSON and string renderers respectively). + Dependencies ------------ -- cgit v1.2.3 From a1d3955d10b7b6f62ccbc7f61082a487d8af5655 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Mon, 18 Apr 2011 23:58:25 -0400 Subject: appease python gods by converting failIf*/failUnless* to assert* equivalents --- pyramid/tests/test_asset.py | 6 +- pyramid/tests/test_authentication.py | 88 +++++------ pyramid/tests/test_chameleon_text.py | 26 +-- pyramid/tests/test_chameleon_zpt.py | 26 +-- pyramid/tests/test_config.py | 288 +++++++++++++++++----------------- pyramid/tests/test_events.py | 4 +- pyramid/tests/test_exceptions.py | 8 +- pyramid/tests/test_i18n.py | 10 +- pyramid/tests/test_integration.py | 46 +++--- pyramid/tests/test_mako_templating.py | 10 +- pyramid/tests/test_paster.py | 22 +-- pyramid/tests/test_path.py | 4 +- pyramid/tests/test_renderers.py | 20 +-- pyramid/tests/test_request.py | 4 +- pyramid/tests/test_router.py | 44 +++--- pyramid/tests/test_security.py | 38 ++--- pyramid/tests/test_session.py | 12 +- pyramid/tests/test_static.py | 30 ++-- pyramid/tests/test_testing.py | 40 ++--- pyramid/tests/test_urldispatch.py | 8 +- pyramid/tests/test_view.py | 22 +-- 21 files changed, 378 insertions(+), 378 deletions(-) diff --git a/pyramid/tests/test_asset.py b/pyramid/tests/test_asset.py index 4a93b14a0..1bd855cdb 100644 --- a/pyramid/tests/test_asset.py +++ b/pyramid/tests/test_asset.py @@ -74,7 +74,7 @@ class TestOverrideProvider(unittest.TestCase): import pyramid.tests provider = self._makeOne(pyramid.tests) result = provider.resource_listdir(resource_name) - self.failUnless(result) + self.assertTrue(result) def test_get_resource_filename_override_returns_None(self): overrides = DummyOverrides(None) @@ -137,7 +137,7 @@ class TestOverrideProvider(unittest.TestCase): import pyramid.tests provider = self._makeOne(pyramid.tests) result = provider.resource_listdir(resource_name) - self.failUnless(result) + self.assertTrue(result) def test_get_resource_filename_override_returns_value(self): overrides = DummyOverrides('value') @@ -371,7 +371,7 @@ class TestPackageOverrides(unittest.TestCase): package = DummyPackage('package') po = self._makeOne(package) po.overrides= overrides - self.failUnless(po.listdir('whatever')) + self.assertTrue(po.listdir('whatever')) def test_listdir_doesnt_exist(self): overrides = [ DummyOverride(None), DummyOverride( diff --git a/pyramid/tests/test_authentication.py b/pyramid/tests/test_authentication.py index 1d2b939b7..ecd76a71c 100644 --- a/pyramid/tests/test_authentication.py +++ b/pyramid/tests/test_authentication.py @@ -470,7 +470,7 @@ class TestAuthTktCookieHelper(unittest.TestCase): plugin.now = now + 1 request = self._makeRequest({'HTTP_COOKIE':'auth_tkt=bogus'}) result = plugin.identify(request) - self.failUnless(result) + self.assertTrue(result) self.assertEqual(len(request.callbacks), 1) response = DummyResponse() request.callbacks[0](None, response) @@ -486,7 +486,7 @@ class TestAuthTktCookieHelper(unittest.TestCase): request = self._makeRequest({'HTTP_COOKIE':'auth_tkt=bogus'}) request._authtkt_reissued = True result = plugin.identify(request) - self.failUnless(result) + self.assertTrue(result) self.assertEqual(len(request.callbacks), 0) def test_identify_cookie_reissue_notyet(self): @@ -497,7 +497,7 @@ class TestAuthTktCookieHelper(unittest.TestCase): plugin.now = now + 1 request = self._makeRequest({'HTTP_COOKIE':'auth_tkt=bogus'}) result = plugin.identify(request) - self.failUnless(result) + self.assertTrue(result) self.assertEqual(len(request.callbacks), 0) def test_identify_cookie_reissue_with_tokens_default(self): @@ -510,13 +510,13 @@ class TestAuthTktCookieHelper(unittest.TestCase): plugin.now = now + 1 request = self._makeRequest({'HTTP_COOKIE':'auth_tkt=bogus'}) result = plugin.identify(request) - self.failUnless(result) + self.assertTrue(result) self.assertEqual(len(request.callbacks), 1) response = DummyResponse() request.callbacks[0](None, response) self.assertEqual(len(response.headerlist), 3) self.assertEqual(response.headerlist[0][0], 'Set-Cookie') - self.failUnless("'tokens': []" in response.headerlist[0][1]) + self.assertTrue("'tokens': []" in response.headerlist[0][1]) def test_remember(self): plugin = self._makeOne('secret') @@ -525,16 +525,16 @@ class TestAuthTktCookieHelper(unittest.TestCase): self.assertEqual(len(result), 3) self.assertEqual(result[0][0], 'Set-Cookie') - self.failUnless(result[0][1].endswith('; Path=/')) - self.failUnless(result[0][1].startswith('auth_tkt=')) + self.assertTrue(result[0][1].endswith('; Path=/')) + self.assertTrue(result[0][1].startswith('auth_tkt=')) self.assertEqual(result[1][0], 'Set-Cookie') - self.failUnless(result[1][1].endswith('; Path=/; Domain=localhost')) - self.failUnless(result[1][1].startswith('auth_tkt=')) + self.assertTrue(result[1][1].endswith('; Path=/; Domain=localhost')) + self.assertTrue(result[1][1].startswith('auth_tkt=')) self.assertEqual(result[2][0], 'Set-Cookie') - self.failUnless(result[2][1].endswith('; Path=/; Domain=.localhost')) - self.failUnless(result[2][1].startswith('auth_tkt=')) + self.assertTrue(result[2][1].endswith('; Path=/; Domain=.localhost')) + self.assertTrue(result[2][1].startswith('auth_tkt=')) def test_remember_include_ip(self): plugin = self._makeOne('secret', include_ip=True) @@ -543,16 +543,16 @@ class TestAuthTktCookieHelper(unittest.TestCase): self.assertEqual(len(result), 3) self.assertEqual(result[0][0], 'Set-Cookie') - self.failUnless(result[0][1].endswith('; Path=/')) - self.failUnless(result[0][1].startswith('auth_tkt=')) + self.assertTrue(result[0][1].endswith('; Path=/')) + self.assertTrue(result[0][1].startswith('auth_tkt=')) self.assertEqual(result[1][0], 'Set-Cookie') - self.failUnless(result[1][1].endswith('; Path=/; Domain=localhost')) - self.failUnless(result[1][1].startswith('auth_tkt=')) + self.assertTrue(result[1][1].endswith('; Path=/; Domain=localhost')) + self.assertTrue(result[1][1].startswith('auth_tkt=')) self.assertEqual(result[2][0], 'Set-Cookie') - self.failUnless(result[2][1].endswith('; Path=/; Domain=.localhost')) - self.failUnless(result[2][1].startswith('auth_tkt=')) + self.assertTrue(result[2][1].endswith('; Path=/; Domain=.localhost')) + self.assertTrue(result[2][1].startswith('auth_tkt=')) def test_remember_path(self): plugin = self._makeOne('secret', include_ip=True, @@ -562,18 +562,18 @@ class TestAuthTktCookieHelper(unittest.TestCase): self.assertEqual(len(result), 3) self.assertEqual(result[0][0], 'Set-Cookie') - self.failUnless(result[0][1].endswith('; Path=/cgi-bin/app.cgi/')) - self.failUnless(result[0][1].startswith('auth_tkt=')) + self.assertTrue(result[0][1].endswith('; Path=/cgi-bin/app.cgi/')) + self.assertTrue(result[0][1].startswith('auth_tkt=')) self.assertEqual(result[1][0], 'Set-Cookie') - self.failUnless(result[1][1].endswith( + self.assertTrue(result[1][1].endswith( '; Path=/cgi-bin/app.cgi/; Domain=localhost')) - self.failUnless(result[1][1].startswith('auth_tkt=')) + self.assertTrue(result[1][1].startswith('auth_tkt=')) self.assertEqual(result[2][0], 'Set-Cookie') - self.failUnless(result[2][1].endswith( + self.assertTrue(result[2][1].endswith( '; Path=/cgi-bin/app.cgi/; Domain=.localhost')) - self.failUnless(result[2][1].startswith('auth_tkt=')) + self.assertTrue(result[2][1].startswith('auth_tkt=')) def test_remember_http_only(self): plugin = self._makeOne('secret', include_ip=True, http_only=True) @@ -582,16 +582,16 @@ class TestAuthTktCookieHelper(unittest.TestCase): self.assertEqual(len(result), 3) self.assertEqual(result[0][0], 'Set-Cookie') - self.failUnless(result[0][1].endswith('; HttpOnly')) - self.failUnless(result[0][1].startswith('auth_tkt=')) + self.assertTrue(result[0][1].endswith('; HttpOnly')) + self.assertTrue(result[0][1].startswith('auth_tkt=')) self.assertEqual(result[1][0], 'Set-Cookie') - self.failUnless(result[1][1].endswith('; HttpOnly')) - self.failUnless(result[1][1].startswith('auth_tkt=')) + self.assertTrue(result[1][1].endswith('; HttpOnly')) + self.assertTrue(result[1][1].startswith('auth_tkt=')) self.assertEqual(result[2][0], 'Set-Cookie') - self.failUnless(result[2][1].endswith('; HttpOnly')) - self.failUnless(result[2][1].startswith('auth_tkt=')) + self.assertTrue(result[2][1].endswith('; HttpOnly')) + self.assertTrue(result[2][1].startswith('auth_tkt=')) def test_remember_secure(self): plugin = self._makeOne('secret', include_ip=True, secure=True) @@ -600,16 +600,16 @@ class TestAuthTktCookieHelper(unittest.TestCase): self.assertEqual(len(result), 3) self.assertEqual(result[0][0], 'Set-Cookie') - self.failUnless('; Secure' in result[0][1]) - self.failUnless(result[0][1].startswith('auth_tkt=')) + self.assertTrue('; Secure' in result[0][1]) + self.assertTrue(result[0][1].startswith('auth_tkt=')) self.assertEqual(result[1][0], 'Set-Cookie') - self.failUnless('; Secure' in result[1][1]) - self.failUnless(result[1][1].startswith('auth_tkt=')) + self.assertTrue('; Secure' in result[1][1]) + self.assertTrue(result[1][1].startswith('auth_tkt=')) self.assertEqual(result[2][0], 'Set-Cookie') - self.failUnless('; Secure' in result[2][1]) - self.failUnless(result[2][1].startswith('auth_tkt=')) + self.assertTrue('; Secure' in result[2][1]) + self.assertTrue(result[2][1].startswith('auth_tkt=')) def test_remember_wild_domain_disabled(self): plugin = self._makeOne('secret', wild_domain=False) @@ -619,11 +619,11 @@ class TestAuthTktCookieHelper(unittest.TestCase): self.assertEqual(result[0][0], 'Set-Cookie') self.assertTrue(result[0][1].endswith('; Path=/')) - self.failUnless(result[0][1].startswith('auth_tkt=')) + self.assertTrue(result[0][1].startswith('auth_tkt=')) self.assertEqual(result[1][0], 'Set-Cookie') self.assertTrue(result[1][1].endswith('; Path=/; Domain=localhost')) - self.failUnless(result[1][1].startswith('auth_tkt=')) + self.assertTrue(result[1][1].startswith('auth_tkt=')) def test_remember_domain_has_port(self): plugin = self._makeOne('secret', wild_domain=False) @@ -634,11 +634,11 @@ class TestAuthTktCookieHelper(unittest.TestCase): self.assertEqual(result[0][0], 'Set-Cookie') self.assertTrue(result[0][1].endswith('; Path=/')) - self.failUnless(result[0][1].startswith('auth_tkt=')) + self.assertTrue(result[0][1].startswith('auth_tkt=')) self.assertEqual(result[1][0], 'Set-Cookie') self.assertTrue(result[1][1].endswith('; Path=/; Domain=example.com')) - self.failUnless(result[1][1].startswith('auth_tkt=')) + self.assertTrue(result[1][1].startswith('auth_tkt=')) def test_remember_string_userid(self): plugin = self._makeOne('secret') @@ -690,7 +690,7 @@ class TestAuthTktCookieHelper(unittest.TestCase): values = self._parseHeaders(result) self.assertEqual(len(result), 3) value = values[0] - self.failUnless('userid' in value.value) + self.assertTrue('userid' in value.value) def test_remember_max_age(self): plugin = self._makeOne('secret') @@ -700,7 +700,7 @@ class TestAuthTktCookieHelper(unittest.TestCase): self.assertEqual(len(result), 3) self.assertEqual(values[0]['max-age'], '500') - self.failUnless(values[0]['expires']) + self.assertTrue(values[0]['expires']) def test_remember_tokens(self): plugin = self._makeOne('secret') @@ -709,13 +709,13 @@ class TestAuthTktCookieHelper(unittest.TestCase): self.assertEqual(len(result), 3) self.assertEqual(result[0][0], 'Set-Cookie') - self.failUnless("'tokens': ('foo', 'bar')" in result[0][1]) + self.assertTrue("'tokens': ('foo', 'bar')" in result[0][1]) self.assertEqual(result[1][0], 'Set-Cookie') - self.failUnless("'tokens': ('foo', 'bar')" in result[1][1]) + self.assertTrue("'tokens': ('foo', 'bar')" in result[1][1]) self.assertEqual(result[2][0], 'Set-Cookie') - self.failUnless("'tokens': ('foo', 'bar')" in result[2][1]) + self.assertTrue("'tokens': ('foo', 'bar')" in result[2][1]) def test_remember_non_string_token(self): plugin = self._makeOne('secret') diff --git a/pyramid/tests/test_chameleon_text.py b/pyramid/tests/test_chameleon_text.py index dcc4f8344..213f25f51 100644 --- a/pyramid/tests/test_chameleon_text.py +++ b/pyramid/tests/test_chameleon_text.py @@ -49,7 +49,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase): minimal = self._getTemplatePath('minimal.txt') lookup = DummyLookup() instance = self._makeOne(minimal, lookup) - self.failIf('template' in instance.__dict__) + self.assertFalse('template' in instance.__dict__) template = instance.template self.assertEqual(template, instance.__dict__['template']) @@ -58,7 +58,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase): minimal = self._getTemplatePath('minimal.txt') lookup = DummyLookup() instance = self._makeOne(minimal, lookup) - self.failIf('template' in instance.__dict__) + self.assertFalse('template' in instance.__dict__) template = instance.template self.assertEqual(template.translate, lookup.translate) @@ -68,7 +68,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() lookup.debug = True instance = self._makeOne(minimal, lookup) - self.failIf('template' in instance.__dict__) + self.assertFalse('template' in instance.__dict__) template = instance.template self.assertEqual(template.debug, True) @@ -78,7 +78,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() lookup.auto_reload = True instance = self._makeOne(minimal, lookup) - self.failIf('template' in instance.__dict__) + self.assertFalse('template' in instance.__dict__) template = instance.template self.assertEqual(template.auto_reload, True) @@ -88,7 +88,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() lookup.auto_reload = False instance = self._makeOne(minimal, lookup) - self.failIf('template' in instance.__dict__) + self.assertFalse('template' in instance.__dict__) template = instance.template self.assertEqual(template.auto_reload, False) @@ -98,7 +98,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() instance = self._makeOne(minimal, lookup) result = instance({}, {}) - self.failUnless(isinstance(result, str)) + self.assertTrue(isinstance(result, str)) self.assertEqual(result, 'Hello.\n') @skip_on('java') @@ -114,7 +114,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() instance = self._makeOne(nonminimal, lookup) result = instance({'name':'Chris'}, {}) - self.failUnless(isinstance(result, str)) + self.assertTrue(isinstance(result, str)) self.assertEqual(result, 'Hello, Chris!\n') @skip_on('java') @@ -123,7 +123,7 @@ class TextTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() instance = self._makeOne(minimal, lookup) result = instance.implementation()() - self.failUnless(isinstance(result, str)) + self.assertTrue(isinstance(result, str)) self.assertEqual(result, 'Hello.\n') class RenderTemplateTests(Base, unittest.TestCase): @@ -135,7 +135,7 @@ class RenderTemplateTests(Base, unittest.TestCase): def test_it(self): minimal = self._getTemplatePath('minimal.txt') result = self._callFUT(minimal) - self.failUnless(isinstance(result, str)) + self.assertTrue(isinstance(result, str)) self.assertEqual(result, 'Hello.\n') class RenderTemplateToResponseTests(Base, unittest.TestCase): @@ -148,7 +148,7 @@ class RenderTemplateToResponseTests(Base, unittest.TestCase): minimal = self._getTemplatePath('minimal.txt') result = self._callFUT(minimal) from webob import Response - self.failUnless(isinstance(result, Response)) + self.assertTrue(isinstance(result, Response)) self.assertEqual(result.app_iter, ['Hello.\n']) self.assertEqual(result.status, '200 OK') self.assertEqual(len(result.headerlist), 2) @@ -162,7 +162,7 @@ class RenderTemplateToResponseTests(Base, unittest.TestCase): self._registerUtility(Response2, IResponseFactory) minimal = self._getTemplatePath('minimal.txt') result = self._callFUT(minimal) - self.failUnless(isinstance(result, Response2)) + self.assertTrue(isinstance(result, Response2)) class GetRendererTests(Base, unittest.TestCase): def _callFUT(self, name): @@ -180,7 +180,7 @@ class GetRendererTests(Base, unittest.TestCase): return renderer self._registerUtility(rf, IRendererFactory, name='foo') result = self._callFUT('foo') - self.failUnless(result is renderer) + self.assertTrue(result is renderer) class GetTemplateTests(Base, unittest.TestCase): def _callFUT(self, name): @@ -199,7 +199,7 @@ class GetTemplateTests(Base, unittest.TestCase): return renderer self._registerUtility(rf, IRendererFactory, name='foo') result = self._callFUT('foo') - self.failUnless(result is renderer.template) + self.assertTrue(result is renderer.template) class DummyLookup(object): auto_reload=True diff --git a/pyramid/tests/test_chameleon_zpt.py b/pyramid/tests/test_chameleon_zpt.py index 9bdb47776..84eaedcf4 100644 --- a/pyramid/tests/test_chameleon_zpt.py +++ b/pyramid/tests/test_chameleon_zpt.py @@ -51,7 +51,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() instance = self._makeOne(minimal, lookup) result = instance({}, {}) - self.failUnless(isinstance(result, unicode)) + self.assertTrue(isinstance(result, unicode)) self.assertEqual(result.rstrip('\n'), '
\n
') @@ -60,7 +60,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase): minimal = self._getTemplatePath('minimal.pt') lookup = DummyLookup() instance = self._makeOne(minimal, lookup) - self.failIf('template' in instance.__dict__) + self.assertFalse('template' in instance.__dict__) template = instance.template self.assertEqual(template, instance.__dict__['template']) @@ -69,7 +69,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase): minimal = self._getTemplatePath('minimal.pt') lookup = DummyLookup() instance = self._makeOne(minimal, lookup) - self.failIf('template' in instance.__dict__) + self.assertFalse('template' in instance.__dict__) template = instance.template self.assertEqual(template.translate, lookup.translate) @@ -79,7 +79,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() lookup.debug = True instance = self._makeOne(minimal, lookup) - self.failIf('template' in instance.__dict__) + self.assertFalse('template' in instance.__dict__) template = instance.template self.assertEqual(template.debug, True) @@ -89,7 +89,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() lookup.debug = False instance = self._makeOne(minimal, lookup) - self.failIf('template' in instance.__dict__) + self.assertFalse('template' in instance.__dict__) template = instance.template self.assertEqual(template.debug, False) @@ -99,7 +99,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() lookup.auto_reload = True instance = self._makeOne(minimal, lookup) - self.failIf('template' in instance.__dict__) + self.assertFalse('template' in instance.__dict__) template = instance.template self.assertEqual(template.auto_reload, True) @@ -109,7 +109,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() lookup.auto_reload = False instance = self._makeOne(minimal, lookup) - self.failIf('template' in instance.__dict__) + self.assertFalse('template' in instance.__dict__) template = instance.template self.assertEqual(template.auto_reload, False) @@ -126,7 +126,7 @@ class ZPTTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() instance = self._makeOne(minimal, lookup) result = instance.implementation()() - self.failUnless(isinstance(result, unicode)) + self.assertTrue(isinstance(result, unicode)) self.assertEqual(result.rstrip('\n'), '
\n
') @@ -140,7 +140,7 @@ class RenderTemplateTests(Base, unittest.TestCase): def test_it(self): minimal = self._getTemplatePath('minimal.pt') result = self._callFUT(minimal) - self.failUnless(isinstance(result, unicode)) + self.assertTrue(isinstance(result, unicode)) self.assertEqual(result.rstrip('\n'), '
\n
') @@ -154,7 +154,7 @@ class RenderTemplateToResponseTests(Base, unittest.TestCase): minimal = self._getTemplatePath('minimal.pt') result = self._callFUT(minimal) from webob import Response - self.failUnless(isinstance(result, Response)) + self.assertTrue(isinstance(result, Response)) self.assertEqual(result.app_iter[0].rstrip('\n'), '
\n
') self.assertEqual(result.status, '200 OK') @@ -169,7 +169,7 @@ class RenderTemplateToResponseTests(Base, unittest.TestCase): self._registerUtility(Response2, IResponseFactory) minimal = self._getTemplatePath('minimal.pt') result = self._callFUT(minimal) - self.failUnless(isinstance(result, Response2)) + self.assertTrue(isinstance(result, Response2)) class GetRendererTests(Base, unittest.TestCase): def _callFUT(self, name): @@ -187,7 +187,7 @@ class GetRendererTests(Base, unittest.TestCase): return renderer self._registerUtility(rf, IRendererFactory, name='foo') result = self._callFUT('foo') - self.failUnless(result is renderer) + self.assertTrue(result is renderer) class GetTemplateTests(Base, unittest.TestCase): def _callFUT(self, name): @@ -206,7 +206,7 @@ class GetTemplateTests(Base, unittest.TestCase): return renderer self._registerUtility(rf, IRendererFactory, name='foo') result = self._callFUT('foo') - self.failUnless(result is renderer.template) + self.assertTrue(result is renderer.template) class DummyLookup(object): auto_reload=True diff --git a/pyramid/tests/test_config.py b/pyramid/tests/test_config.py index d2ff65878..5818f248b 100644 --- a/pyramid/tests/test_config.py +++ b/pyramid/tests/test_config.py @@ -75,20 +75,20 @@ class ConfiguratorTests(unittest.TestCase): from pyramid.interfaces import IRendererFactory config = Configurator() this_pkg = sys.modules['pyramid.tests'] - self.failUnless(config.registry.getUtility(ISettings)) + self.assertTrue(config.registry.getUtility(ISettings)) self.assertEqual(config.package, this_pkg) - self.failUnless(config.registry.getUtility(IRendererFactory, 'json')) - self.failUnless(config.registry.getUtility(IRendererFactory, 'string')) + self.assertTrue(config.registry.getUtility(IRendererFactory, 'json')) + self.assertTrue(config.registry.getUtility(IRendererFactory, 'string')) if not __pypy__: - self.failUnless(config.registry.getUtility(IRendererFactory, '.pt')) - self.failUnless(config.registry.getUtility(IRendererFactory,'.txt')) - self.failUnless(config.registry.getUtility(IRendererFactory, '.mak')) - self.failUnless(config.registry.getUtility(IRendererFactory, '.mako')) + self.assertTrue(config.registry.getUtility(IRendererFactory, '.pt')) + self.assertTrue(config.registry.getUtility(IRendererFactory,'.txt')) + self.assertTrue(config.registry.getUtility(IRendererFactory, '.mak')) + self.assertTrue(config.registry.getUtility(IRendererFactory, '.mako')) def test__set_settings_as_None(self): config = self._makeOne() settings = config._set_settings(None) - self.failUnless(settings) + self.assertTrue(settings) def test__set_settings_as_dictwithvalues(self): config = self._makeOne() @@ -171,7 +171,7 @@ class ConfiguratorTests(unittest.TestCase): def test_ctor_no_root_factory(self): from pyramid.interfaces import IRootFactory config = self._makeOne() - self.failUnless(config.registry.getUtility(IRootFactory)) + self.assertTrue(config.registry.getUtility(IRootFactory)) def test_ctor_alternate_renderers(self): from pyramid.interfaces import IRendererFactory @@ -390,7 +390,7 @@ class ConfiguratorTests(unittest.TestCase): reg = Registry() config = self._makeOne(reg) config.setup_registry() - self.failUnless(reg.getUtility(IRootFactory)) + self.assertTrue(reg.getUtility(IRootFactory)) def test_setup_registry_dottedname_root_factory(self): from pyramid.registry import Registry @@ -591,9 +591,9 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(app.__class__, Router) self.assertEqual(manager.pushed['registry'], config.registry) self.assertEqual(manager.pushed['request'], None) - self.failUnless(manager.popped) + self.assertTrue(manager.popped) self.assertEqual(len(subscriber), 1) - self.failUnless(IApplicationCreated.providedBy(subscriber[0])) + self.assertTrue(IApplicationCreated.providedBy(subscriber[0])) def test_include_with_dotted_name(self): from pyramid import tests @@ -610,7 +610,7 @@ class ConfiguratorTests(unittest.TestCase): ) self.assertEqual(context_after.basepath, None) self.assertEqual(context_after.includepath, ()) - self.failUnless(context_after is context_before) + self.assertTrue(context_after is context_before) def test_include_with_python_callable(self): from pyramid import tests @@ -627,7 +627,7 @@ class ConfiguratorTests(unittest.TestCase): ) self.assertEqual(context_after.basepath, None) self.assertEqual(context_after.includepath, ()) - self.failUnless(context_after is context_before) + self.assertTrue(context_after is context_before) def test_include_with_module_defaults_to_includeme(self): from pyramid import tests @@ -644,7 +644,7 @@ class ConfiguratorTests(unittest.TestCase): ) self.assertEqual(context_after.basepath, None) self.assertEqual(context_after.includepath, ()) - self.failUnless(context_after is context_before) + self.assertTrue(context_after is context_before) def test_with_context(self): config = self._makeOne() @@ -683,7 +683,7 @@ class ConfiguratorTests(unittest.TestCase): self._registerRenderer(config, name='dummy') config.add_view(renderer='dummy') view = self._getViewCallable(config) - self.failUnless('Hello!' in view(None, None).body) + self.assertTrue('Hello!' in view(None, None).body) def test_add_view_wrapped_view_is_decorated(self): def view(request): # request-only wrapper @@ -729,7 +729,7 @@ class ConfiguratorTests(unittest.TestCase): config = self._makeOne(autocommit=True) config.add_view(view=view, decorator=view_wrapper) wrapper = self._getViewCallable(config) - self.failIf(wrapper is view) + self.assertFalse(wrapper is view) self.assertEqual(wrapper.__doc__, view.__doc__) result = wrapper(None, None) self.assertEqual(result, 'OK') @@ -900,7 +900,7 @@ class ConfiguratorTests(unittest.TestCase): return 'OK' config.add_view(view=newview, xhr=True) wrapper = self._getViewCallable(config) - self.failIf(IMultiView.providedBy(wrapper)) + self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True self.assertEqual(wrapper(None, request), 'OK') @@ -926,7 +926,7 @@ class ConfiguratorTests(unittest.TestCase): config.add_view(view=newview, xhr=True, context=RuntimeError) wrapper = self._getViewCallable( config, ctx_iface=implementedBy(RuntimeError), exception_view=True) - self.failIf(IMultiView.providedBy(wrapper)) + self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True self.assertEqual(wrapper(None, request), 'OK') @@ -945,7 +945,7 @@ class ConfiguratorTests(unittest.TestCase): return 'OK' config.add_view(view=newview) wrapper = self._getViewCallable(config) - self.failIf(IMultiView.providedBy(wrapper)) + self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True self.assertEqual(wrapper(None, request), 'OK') @@ -967,7 +967,7 @@ class ConfiguratorTests(unittest.TestCase): config.add_view(view=newview, context=RuntimeError) wrapper = self._getViewCallable( config, ctx_iface=implementedBy(RuntimeError), exception_view=True) - self.failIf(IMultiView.providedBy(wrapper)) + self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True self.assertEqual(wrapper(None, request), 'OK') @@ -988,7 +988,7 @@ class ConfiguratorTests(unittest.TestCase): return 'OK' config.add_view(view=newview) wrapper = self._getViewCallable(config) - self.failIf(IMultiView.providedBy(wrapper)) + self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True self.assertEqual(wrapper(None, request), 'OK') @@ -1012,7 +1012,7 @@ class ConfiguratorTests(unittest.TestCase): config.add_view(view=newview, context=RuntimeError) wrapper = self._getViewCallable( config, ctx_iface=implementedBy(RuntimeError), exception_view=True) - self.failIf(IMultiView.providedBy(wrapper)) + self.assertFalse(IMultiView.providedBy(wrapper)) request = DummyRequest() request.is_xhr = True self.assertEqual(wrapper(None, request), 'OK') @@ -1030,7 +1030,7 @@ class ConfiguratorTests(unittest.TestCase): view, (IViewClassifier, IRequest, Interface), IView, name='') config.add_view(view=view) wrapper = self._getViewCallable(config) - self.failUnless(IMultiView.providedBy(wrapper)) + self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK') def test_add_view_exc_multiview_replaces_existing_view(self): @@ -1054,7 +1054,7 @@ class ConfiguratorTests(unittest.TestCase): config.add_view(view=view, context=RuntimeError) wrapper = self._getViewCallable( config, ctx_iface=implementedBy(RuntimeError), exception_view=True) - self.failUnless(IMultiView.providedBy(wrapper)) + self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK') def test_add_view_multiview_replaces_existing_securedview(self): @@ -1071,7 +1071,7 @@ class ConfiguratorTests(unittest.TestCase): ISecuredView, name='') config.add_view(view=view) wrapper = self._getViewCallable(config) - self.failUnless(IMultiView.providedBy(wrapper)) + self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK') def test_add_view_exc_multiview_replaces_existing_securedview(self): @@ -1095,7 +1095,7 @@ class ConfiguratorTests(unittest.TestCase): config.add_view(view=view, context=RuntimeError) wrapper = self._getViewCallable( config, ctx_iface=implementedBy(RuntimeError), exception_view=True) - self.failUnless(IMultiView.providedBy(wrapper)) + self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK') def test_add_view_with_accept_multiview_replaces_existing_view(self): @@ -1113,7 +1113,7 @@ class ConfiguratorTests(unittest.TestCase): view, (IViewClassifier, IRequest, Interface), IView, name='') config.add_view(view=view2, accept='text/html') wrapper = self._getViewCallable(config) - self.failUnless(IMultiView.providedBy(wrapper)) + self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(len(wrapper.views), 1) self.assertEqual(len(wrapper.media_views), 1) self.assertEqual(wrapper(None, None), 'OK') @@ -1144,7 +1144,7 @@ class ConfiguratorTests(unittest.TestCase): config.add_view(view=view2, accept='text/html', context=RuntimeError) wrapper = self._getViewCallable( config, ctx_iface=implementedBy(RuntimeError), exception_view=True) - self.failUnless(IMultiView.providedBy(wrapper)) + self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(len(wrapper.views), 1) self.assertEqual(len(wrapper.media_views), 1) self.assertEqual(wrapper(None, None), 'OK') @@ -1169,7 +1169,7 @@ class ConfiguratorTests(unittest.TestCase): view, (IViewClassifier, IRequest, Interface), IView, name='') config.add_view(view=view2) wrapper = self._getViewCallable(config) - self.failUnless(IMultiView.providedBy(wrapper)) + self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(len(wrapper.views), 1) self.assertEqual(len(wrapper.media_views), 1) self.assertEqual(wrapper(None, None), 'OK2') @@ -1202,7 +1202,7 @@ class ConfiguratorTests(unittest.TestCase): config.add_view(view=view2, context=RuntimeError) wrapper = self._getViewCallable( config, ctx_iface=implementedBy(RuntimeError), exception_view=True) - self.failUnless(IMultiView.providedBy(wrapper)) + self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual(len(wrapper.views), 1) self.assertEqual(len(wrapper.media_views), 1) self.assertEqual(wrapper(None, None), 'OK2') @@ -1223,7 +1223,7 @@ class ConfiguratorTests(unittest.TestCase): view2 = lambda *arg: 'OK2' config.add_view(view=view2) wrapper = self._getViewCallable(config) - self.failUnless(IMultiView.providedBy(wrapper)) + self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual([x[:2] for x in wrapper.views], [(view2, None)]) self.assertEqual(wrapper(None, None), 'OK1') @@ -1247,7 +1247,7 @@ class ConfiguratorTests(unittest.TestCase): config.add_view(view=view2, context=RuntimeError) wrapper = self._getViewCallable( config, ctx_iface=implementedBy(RuntimeError), exception_view=True) - self.failUnless(IMultiView.providedBy(wrapper)) + self.assertTrue(IMultiView.providedBy(wrapper)) self.assertEqual([x[:2] for x in wrapper.views], [(view2, None)]) self.assertEqual(wrapper(None, None), 'OK1') @@ -1268,10 +1268,10 @@ class ConfiguratorTests(unittest.TestCase): view, (IViewClassifier, IRequest, ISuper), IView, name='') config.add_view(view=view2, for_=ISub) wrapper = self._getViewCallable(config, ISuper, IRequest) - self.failIf(IMultiView.providedBy(wrapper)) + self.assertFalse(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK') wrapper = self._getViewCallable(config, ISub, IRequest) - self.failIf(IMultiView.providedBy(wrapper)) + self.assertFalse(IMultiView.providedBy(wrapper)) self.assertEqual(wrapper(None, None), 'OK2') def test_add_view_multiview_exception_superclass_then_subclass(self): @@ -1298,14 +1298,14 @@ class ConfiguratorTests(unittest.TestCase): wrapper_exc_view = self._getViewCallable( config, implementedBy(Super), IRequest, exception_view=True) self.assertEqual(wrapper_exc_view, wrapper) - self.failIf(IMultiView.providedBy(wrapper_exc_view)) + self.assertFalse(IMultiView.providedBy(wrapper_exc_view)) self.assertEqual(wrapper_exc_view(None, None), 'OK') wrapper = self._getViewCallable( config, implementedBy(Sub), IRequest) wrapper_exc_view = self._getViewCallable( config, implementedBy(Sub), IRequest, exception_view=True) self.assertEqual(wrapper_exc_view, wrapper) - self.failIf(IMultiView.providedBy(wrapper_exc_view)) + self.assertFalse(IMultiView.providedBy(wrapper_exc_view)) self.assertEqual(wrapper_exc_view(None, None), 'OK2') def test_add_view_multiview_call_ordering(self): @@ -1486,9 +1486,9 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(wrapper, None) config.add_route('foo', '/a/b') request_iface = self._getRouteRequestIface(config, 'foo') - self.failIfEqual(request_iface, None) + self.assertNotEqual(request_iface, None) wrapper = self._getViewCallable(config, request_iface=request_iface) - self.failIfEqual(wrapper, None) + self.assertNotEqual(wrapper, None) self.assertEqual(wrapper(None, None), 'OK') def test_add_view_with_route_name_deferred_views_already_exist(self): @@ -1532,11 +1532,11 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(wrapper_exc_view, None) config.add_route('foo', '/a/b') request_iface = self._getRouteRequestIface(config, 'foo') - self.failIfEqual(request_iface, None) + self.assertNotEqual(request_iface, None) wrapper_exc_view = self._getViewCallable( config, ctx_iface=implementedBy(RuntimeError), request_iface=request_iface, exception_view=True) - self.failIfEqual(wrapper_exc_view, None) + self.assertNotEqual(wrapper_exc_view, None) wrapper = self._getViewCallable( config, ctx_iface=implementedBy(RuntimeError), request_iface=request_iface) @@ -2086,7 +2086,7 @@ class ConfiguratorTests(unittest.TestCase): request_type = self._getRouteRequestIface(config, 'name') wrapper = self._getViewCallable(config, None, request_type) self._assertRoute(config, 'name', 'path') - self.failUnless(hasattr(wrapper, '__call_permissive__')) + self.assertTrue(hasattr(wrapper, '__call_permissive__')) def test_add_route_with_view_permission_alias(self): from pyramid.interfaces import IAuthenticationPolicy @@ -2100,7 +2100,7 @@ class ConfiguratorTests(unittest.TestCase): request_type = self._getRouteRequestIface(config, 'name') wrapper = self._getViewCallable(config, None, request_type) self._assertRoute(config, 'name', 'path') - self.failUnless(hasattr(wrapper, '__call_permissive__')) + self.assertTrue(hasattr(wrapper, '__call_permissive__')) def test_add_route_no_pattern_with_path(self): config = self._makeOne(autocommit=True) @@ -2163,14 +2163,14 @@ class ConfiguratorTests(unittest.TestCase): return 'OK' config = self._makeOne() result = config.derive_view(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(result(None, None), 'OK') def test_derive_view_dottedname(self): config = self._makeOne() result = config.derive_view( 'pyramid.tests.test_config.dummy_view') - self.failIf(result is dummy_view) + self.assertFalse(result is dummy_view) self.assertEqual(result(None, None), 'OK') def test_derive_view_with_default_renderer_no_explicit_renderer(self): @@ -2184,7 +2184,7 @@ class ConfiguratorTests(unittest.TestCase): def view(request): return 'OK' result = config.derive_view(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(result(None, None).body, 'moo') def test_derive_view_with_default_renderer_with_explicit_renderer(self): @@ -2200,7 +2200,7 @@ class ConfiguratorTests(unittest.TestCase): config.add_renderer(None, moo) config.add_renderer('foo', foo) result = config.derive_view(view, renderer='foo') - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest(config) self.assertEqual(result(None, request).body, 'foo') @@ -2350,7 +2350,7 @@ class ConfiguratorTests(unittest.TestCase): result = view(None, request) finally: config.end() - self.failUnless('div' in result.body) + self.assertTrue('div' in result.body) def test_set_forbidden_view(self): from zope.interface import implementedBy @@ -2397,7 +2397,7 @@ class ConfiguratorTests(unittest.TestCase): result = view(None, request) finally: config.end() - self.failUnless('div' in result.body) + self.assertTrue('div' in result.body) def test__set_authentication_policy(self): from pyramid.interfaces import IAuthenticationPolicy @@ -2791,7 +2791,7 @@ class ConfiguratorTests(unittest.TestCase): from pyramid.interfaces import IAuthenticationPolicy from pyramid.interfaces import IAuthorizationPolicy ut = config.registry.getUtility(IAuthenticationPolicy) - self.failUnless(isinstance(ut, DummySecurityPolicy)) + self.assertTrue(isinstance(ut, DummySecurityPolicy)) ut = config.registry.getUtility(IAuthorizationPolicy) self.assertEqual(ut.userid, 'user') self.assertEqual(ut.groupids, ('group1', 'group2')) @@ -2899,7 +2899,7 @@ class ConfiguratorTests(unittest.TestCase): config = self._makeOne(autocommit=True) renderer = config.testing_add_renderer('templates/foo.pt') from pyramid.testing import DummyTemplateRenderer - self.failUnless(isinstance(renderer, DummyTemplateRenderer)) + self.assertTrue(isinstance(renderer, DummyTemplateRenderer)) from pyramid.renderers import render_to_response # must provide request to pass in registry (this is a functest) request = DummyRequest() @@ -2915,8 +2915,8 @@ class ConfiguratorTests(unittest.TestCase): renderer1 = config.testing_add_renderer('templates/foo.pt') renderer2 = config.testing_add_renderer('templates/bar.pt') from pyramid.testing import DummyTemplateRenderer - self.failUnless(isinstance(renderer1, DummyTemplateRenderer)) - self.failUnless(isinstance(renderer2, DummyTemplateRenderer)) + self.assertTrue(isinstance(renderer1, DummyTemplateRenderer)) + self.assertTrue(isinstance(renderer2, DummyTemplateRenderer)) from pyramid.renderers import render_to_response # must provide request to pass in registry (this is a functest) request = DummyRequest() @@ -2955,7 +2955,7 @@ class ConfiguratorTests(unittest.TestCase): config = self._makeOne(autocommit=True) renderer = config.testing_add_template('templates/foo.pt') from pyramid.testing import DummyTemplateRenderer - self.failUnless(isinstance(renderer, DummyTemplateRenderer)) + self.assertTrue(isinstance(renderer, DummyTemplateRenderer)) from pyramid.renderers import render_to_response # must provide request to pass in registry (this is a functest) request = DummyRequest() @@ -3102,8 +3102,8 @@ class ConfiguratorTests(unittest.TestCase): yield confinst[3] which = list(scanconflicts(why)) self.assertEqual(len(which), 4) - self.failUnless("@view_config(renderer='string')" in which) - self.failUnless("@view_config(name='two', renderer='string')" in + self.assertTrue("@view_config(renderer='string')" in which) + self.assertTrue("@view_config(name='two', renderer='string')" in which) def _conflictFunctions(self, e): @@ -3128,7 +3128,7 @@ class ConfiguratorTests(unittest.TestCase): directives = {'foo':(foo, True)} config.registry._directives = directives foo_meth = config.foo - self.failUnless(foo_meth.im_func.__docobj__ is foo) + self.assertTrue(foo_meth.im_func.__docobj__ is foo) def test___getattr__matches_no_action_wrap(self): config = self._makeOne() @@ -3136,7 +3136,7 @@ class ConfiguratorTests(unittest.TestCase): directives = {'foo':(foo, False)} config.registry._directives = directives foo_meth = config.foo - self.failUnless(foo_meth.im_func is foo) + self.assertTrue(foo_meth.im_func is foo) class TestConfigurator_add_directive(unittest.TestCase): @@ -3250,7 +3250,7 @@ class TestViewDeriver(unittest.TestCase): return 'OK' deriver = self._makeOne() result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(result(None, None), 'OK') def test_requestonly_function_with_renderer(self): @@ -3265,7 +3265,7 @@ class TestViewDeriver(unittest.TestCase): return 'OK' deriver = self._makeOne(renderer=moo()) result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() context = testing.DummyResource() self.assertEqual(result(context, request), 'moo') @@ -3283,7 +3283,7 @@ class TestViewDeriver(unittest.TestCase): self.config.add_renderer('moo', moo) deriver = self._makeOne(renderer='string') result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() request.override_renderer = 'moo' context = testing.DummyResource() @@ -3301,12 +3301,12 @@ class TestViewDeriver(unittest.TestCase): return 'OK' deriver = self._makeOne(renderer=moo()) result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() request.__view__ = 'view' context = testing.DummyResource() self.assertEqual(result(context, request), 'moo') - self.failIf(hasattr(request, '__view__')) + self.assertFalse(hasattr(request, '__view__')) def test_class_without_attr(self): class View(object): @@ -3337,8 +3337,8 @@ class TestViewDeriver(unittest.TestCase): return 'OK' deriver = self._makeOne() result = deriver(view) - self.failUnless(result is view) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertTrue(result is view) + self.assertFalse(hasattr(result, '__call_permissive__')) self.assertEqual(view(None, None), 'OK') def test_as_function_requestonly(self): @@ -3346,11 +3346,11 @@ class TestViewDeriver(unittest.TestCase): return 'OK' deriver = self._makeOne() result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') def test_as_newstyle_class_context_and_request(self): @@ -3361,11 +3361,11 @@ class TestViewDeriver(unittest.TestCase): return 'OK' deriver = self._makeOne() result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') self.assertEqual(request.__view__.__class__, view) @@ -3378,11 +3378,11 @@ class TestViewDeriver(unittest.TestCase): return 'OK' deriver = self._makeOne() result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') self.assertEqual(request.__view__.__class__, view) @@ -3395,11 +3395,11 @@ class TestViewDeriver(unittest.TestCase): return 'OK' deriver = self._makeOne() result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') self.assertEqual(request.__view__.__class__, view) @@ -3412,11 +3412,11 @@ class TestViewDeriver(unittest.TestCase): return 'OK' deriver = self._makeOne() result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') self.assertEqual(request.__view__.__class__, view) @@ -3428,8 +3428,8 @@ class TestViewDeriver(unittest.TestCase): view = View() deriver = self._makeOne() result = deriver(view) - self.failUnless(result is view) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertTrue(result is view) + self.assertFalse(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') def test_as_instance_requestonly(self): @@ -3439,11 +3439,11 @@ class TestViewDeriver(unittest.TestCase): view = View() deriver = self._makeOne() result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) - self.failUnless('instance' in result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertTrue('instance' in result.__name__) + self.assertFalse(hasattr(result, '__call_permissive__')) self.assertEqual(result(None, None), 'OK') def test_with_debug_authorization_no_authpol(self): @@ -3456,7 +3456,7 @@ class TestViewDeriver(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) request = self._makeRequest() request.view_name = 'view_name' request.url = 'url' @@ -3479,7 +3479,7 @@ class TestViewDeriver(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) request = self._makeRequest() request.view_name = 'view_name' request.url = 'url' @@ -3502,7 +3502,7 @@ class TestViewDeriver(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) request = self._makeRequest() request.view_name = 'view_name' request.url = 'url' @@ -3524,7 +3524,7 @@ class TestViewDeriver(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) request = self._makeRequest() request.view_name = 'view_name' request.url = 'url' @@ -3624,7 +3624,7 @@ class TestViewDeriver(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) request = self._makeRequest() request.view_name = 'view_name' request.url = 'url' @@ -3645,7 +3645,7 @@ class TestViewDeriver(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) request = self._makeRequest() request.view_name = 'view_name' request.url = 'url' @@ -3662,7 +3662,7 @@ class TestViewDeriver(unittest.TestCase): self.assertEqual(view.__module__, result.__module__) self.assertEqual(view.__doc__, result.__doc__) self.assertEqual(view.__name__, result.__name__) - self.failIf(hasattr(result, '__call_permissive__')) + self.assertFalse(hasattr(result, '__call_permissive__')) request = self._makeRequest() request.view_name = 'view_name' request.url = 'url' @@ -3736,7 +3736,7 @@ class TestViewDeriver(unittest.TestCase): deriver = self._makeOne(viewname='inner', wrapper_viewname='owrap') result = deriver(inner_view) - self.failIf(result is inner_view) + self.assertFalse(result is inner_view) self.assertEqual(inner_view.__module__, result.__module__) self.assertEqual(inner_view.__doc__, result.__doc__) request = self._makeRequest() @@ -3768,7 +3768,7 @@ class TestViewDeriver(unittest.TestCase): return {'a':'1'} deriver = self._makeOne(renderer=renderer(), attr='index') result = deriver(View) - self.failIf(result is View) + self.assertFalse(result is View) self.assertEqual(result.__module__, View.__module__) self.assertEqual(result.__doc__, View.__doc__) self.assertEqual(result.__name__, View.__name__) @@ -3791,7 +3791,7 @@ class TestViewDeriver(unittest.TestCase): return {'a':'1'} deriver = self._makeOne(renderer=renderer(), attr='index') result = deriver(View) - self.failIf(result is View) + self.assertFalse(result is View) self.assertEqual(result.__module__, View.__module__) self.assertEqual(result.__doc__, View.__doc__) self.assertEqual(result.__name__, View.__name__) @@ -3814,7 +3814,7 @@ class TestViewDeriver(unittest.TestCase): return {'a':'1'} deriver = self._makeOne(renderer=renderer(), attr='index') result = deriver(View) - self.failIf(result is View) + self.assertFalse(result is View) self.assertEqual(result.__module__, View.__module__) self.assertEqual(result.__doc__, View.__doc__) self.assertEqual(result.__name__, View.__name__) @@ -3837,7 +3837,7 @@ class TestViewDeriver(unittest.TestCase): return {'a':'1'} deriver = self._makeOne(renderer=renderer(), attr='index') result = deriver(View) - self.failIf(result is View) + self.assertFalse(result is View) self.assertEqual(result.__module__, View.__module__) self.assertEqual(result.__doc__, View.__doc__) self.assertEqual(result.__name__, View.__name__) @@ -3859,7 +3859,7 @@ class TestViewDeriver(unittest.TestCase): deriver = self._makeOne(renderer=renderer(), attr='index') view = View() result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(result.__module__, view.__module__) self.assertEqual(result.__doc__, view.__doc__) request = self._makeRequest() @@ -3880,7 +3880,7 @@ class TestViewDeriver(unittest.TestCase): deriver = self._makeOne(renderer=renderer(), attr='index') view = View() result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(result.__module__, view.__module__) self.assertEqual(result.__doc__, view.__doc__) request = self._makeRequest() @@ -3898,7 +3898,7 @@ class TestViewDeriver(unittest.TestCase): def view(context, request): return 'NOTOK' deriver = self._makeOne(mapper=mapper) result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(result(None, None), 'OK') def test_with_view_mapper_view_specified(self): @@ -3913,7 +3913,7 @@ class TestViewDeriver(unittest.TestCase): view.__view_mapper__ = mapper deriver = self._makeOne() result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(result(None, None), 'OK') def test_with_view_mapper_default_mapper_specified(self): @@ -3928,7 +3928,7 @@ class TestViewDeriver(unittest.TestCase): def view(context, request): return 'NOTOK' deriver = self._makeOne() result = deriver(view) - self.failIf(result is view) + self.assertFalse(result is view) self.assertEqual(result(None, None), 'OK') def test_attr_wrapped_view_branching_default_phash(self): @@ -3968,7 +3968,7 @@ class TestDefaultViewMapper(unittest.TestCase): return 'OK' mapper = self._makeOne() result = mapper(view) - self.failUnless(result is view) + self.assertTrue(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -3977,7 +3977,7 @@ class TestDefaultViewMapper(unittest.TestCase): """ """ mapper = self._makeOne(attr='__name__') result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertRaises(TypeError, result, None, request) @@ -3986,7 +3986,7 @@ class TestDefaultViewMapper(unittest.TestCase): return 'OK' mapper = self._makeOne() result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -3995,7 +3995,7 @@ class TestDefaultViewMapper(unittest.TestCase): """ """ mapper = self._makeOne(attr='__name__') result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertRaises(TypeError, result, None, request) @@ -4007,7 +4007,7 @@ class TestDefaultViewMapper(unittest.TestCase): return 'OK' mapper = self._makeOne() result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4019,7 +4019,7 @@ class TestDefaultViewMapper(unittest.TestCase): return 'OK' mapper = self._makeOne(attr='index') result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4031,7 +4031,7 @@ class TestDefaultViewMapper(unittest.TestCase): return 'OK' mapper = self._makeOne() result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4043,7 +4043,7 @@ class TestDefaultViewMapper(unittest.TestCase): return 'OK' mapper = self._makeOne(attr='index') result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4055,7 +4055,7 @@ class TestDefaultViewMapper(unittest.TestCase): return 'OK' mapper = self._makeOne() result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4067,7 +4067,7 @@ class TestDefaultViewMapper(unittest.TestCase): return 'OK' mapper = self._makeOne(attr='index') result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4079,7 +4079,7 @@ class TestDefaultViewMapper(unittest.TestCase): return 'OK' mapper = self._makeOne() result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4091,7 +4091,7 @@ class TestDefaultViewMapper(unittest.TestCase): return 'OK' mapper = self._makeOne(attr='index') result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4102,7 +4102,7 @@ class TestDefaultViewMapper(unittest.TestCase): view = View() mapper = self._makeOne() result = mapper(view) - self.failUnless(result is view) + self.assertTrue(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4113,7 +4113,7 @@ class TestDefaultViewMapper(unittest.TestCase): view = View() mapper = self._makeOne(attr='index') result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4124,7 +4124,7 @@ class TestDefaultViewMapper(unittest.TestCase): view = View() mapper = self._makeOne() result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4135,7 +4135,7 @@ class TestDefaultViewMapper(unittest.TestCase): view = View() mapper = self._makeOne(attr='index') result = mapper(view) - self.failIf(result is view) + self.assertFalse(result is view) request = self._makeRequest() self.assertEqual(result(None, request), 'OK') @@ -4148,7 +4148,7 @@ class Test_preserve_view_attrs(unittest.TestCase): def view(context, request): """ """ result = self._callFUT(view, view) - self.failUnless(result is view) + self.assertTrue(result is view) def test_it_different_with_existing_original_view(self): def view1(context, request): pass @@ -4156,7 +4156,7 @@ class Test_preserve_view_attrs(unittest.TestCase): def view2(context, request): pass result = self._callFUT(view1, view2) self.assertEqual(result.__original_view__, 'abc') - self.failIf(result is view1) + self.assertFalse(result is view1) def test_it_different(self): class DummyView1: @@ -4187,15 +4187,15 @@ class Test_preserve_view_attrs(unittest.TestCase): view2 = DummyView2() result = self._callFUT(view2, view1) self.assertEqual(result, view1) - self.failUnless(view1.__original_view__ is view2) - self.failUnless(view1.__doc__ is view2.__doc__) - self.failUnless(view1.__module__ is view2.__module__) - self.failUnless(view1.__name__ is view2.__name__) - self.failUnless(view1.__call_permissive__.im_func is + self.assertTrue(view1.__original_view__ is view2) + self.assertTrue(view1.__doc__ is view2.__doc__) + self.assertTrue(view1.__module__ is view2.__module__) + self.assertTrue(view1.__name__ is view2.__name__) + self.assertTrue(view1.__call_permissive__.im_func is view2.__call_permissive__.im_func) - self.failUnless(view1.__permitted__.im_func is + self.assertTrue(view1.__permitted__.im_func is view2.__permitted__.im_func) - self.failUnless(view1.__predicated__.im_func is + self.assertTrue(view1.__predicated__.im_func is view2.__predicated__.im_func) class Test__make_predicates(unittest.TestCase): @@ -4206,7 +4206,7 @@ class Test__make_predicates(unittest.TestCase): def test_ordering_xhr_and_request_method_trump_only_containment(self): order1, _, _ = self._callFUT(xhr=True, request_method='GET') order2, _, _ = self._callFUT(containment=True) - self.failUnless(order1 < order2) + self.assertTrue(order1 < order2) def test_ordering_number_of_predicates(self): order1, _, _ = self._callFUT( @@ -4286,15 +4286,15 @@ class Test__make_predicates(unittest.TestCase): order11, _, _ = self._callFUT( ) self.assertEqual(order1, order2) - self.failUnless(order3 > order2) - self.failUnless(order4 > order3) - self.failUnless(order5 > order4) - self.failUnless(order6 > order5) - self.failUnless(order7 > order6) - self.failUnless(order8 > order7) - self.failUnless(order9 > order8) - self.failUnless(order10 > order9) - self.failUnless(order11 > order10) + self.assertTrue(order3 > order2) + self.assertTrue(order4 > order3) + self.assertTrue(order5 > order4) + self.assertTrue(order6 > order5) + self.assertTrue(order7 > order6) + self.assertTrue(order8 > order7) + self.assertTrue(order9 > order8) + self.assertTrue(order10 > order9) + self.assertTrue(order11 > order10) def test_ordering_importance_of_predicates(self): order1, _, _ = self._callFUT( @@ -4324,14 +4324,14 @@ class Test__make_predicates(unittest.TestCase): order9, _, _ = self._callFUT( custom=('a',), ) - self.failUnless(order1 > order2) - self.failUnless(order2 > order3) - self.failUnless(order3 > order4) - self.failUnless(order4 > order5) - self.failUnless(order5 > order6) - self.failUnless(order6 > order7) - self.failUnless(order7 > order8) - self.failUnless(order8 > order9) + self.assertTrue(order1 > order2) + self.assertTrue(order2 > order3) + self.assertTrue(order3 > order4) + self.assertTrue(order4 > order5) + self.assertTrue(order5 > order6) + self.assertTrue(order6 > order7) + self.assertTrue(order7 > order8) + self.assertTrue(order8 > order9) def test_ordering_importance_and_number(self): order1, _, _ = self._callFUT( @@ -4341,7 +4341,7 @@ class Test__make_predicates(unittest.TestCase): order2, _, _ = self._callFUT( custom=('a',), ) - self.failUnless(order1 < order2) + self.assertTrue(order1 < order2) order1, _, _ = self._callFUT( xhr='xhr', @@ -4351,7 +4351,7 @@ class Test__make_predicates(unittest.TestCase): request_method='request_method', custom=('a',), ) - self.failUnless(order1 > order2) + self.assertTrue(order1 > order2) order1, _, _ = self._callFUT( xhr='xhr', @@ -4362,7 +4362,7 @@ class Test__make_predicates(unittest.TestCase): request_method='request_method', custom=('a',), ) - self.failUnless(order1 < order2) + self.assertTrue(order1 < order2) order1, _, _ = self._callFUT( xhr='xhr', @@ -4374,7 +4374,7 @@ class Test__make_predicates(unittest.TestCase): request_method='request_method', custom=('a',), ) - self.failUnless(order1 > order2) + self.assertTrue(order1 > order2) def test_different_custom_predicates_with_same_hash(self): class PredicateWithHash(object): diff --git a/pyramid/tests/test_events.py b/pyramid/tests/test_events.py index 9f655959d..22a42758a 100644 --- a/pyramid/tests/test_events.py +++ b/pyramid/tests/test_events.py @@ -190,12 +190,12 @@ class TestBeforeRender(unittest.TestCase): def test__contains__True(self): system = {'a':1} event = self._makeOne(system) - self.failUnless('a' in event) + self.assertTrue('a' in event) def test__contains__False(self): system = {} event = self._makeOne(system) - self.failIf('a' in event) + self.assertFalse('a' in event) def test__getitem__success(self): system = {'a':1} diff --git a/pyramid/tests/test_exceptions.py b/pyramid/tests/test_exceptions.py index 15eaa8698..5d0fa1e1a 100644 --- a/pyramid/tests/test_exceptions.py +++ b/pyramid/tests/test_exceptions.py @@ -7,7 +7,7 @@ class TestExceptionResponse(unittest.TestCase): def test_app_iter(self): exc = self._makeOne('') - self.failUnless('' in exc.app_iter[0]) + self.assertTrue('' in exc.app_iter[0]) def test_headerlist(self): exc = self._makeOne('') @@ -20,7 +20,7 @@ class TestExceptionResponse(unittest.TestCase): def test_withmessage(self): exc = self._makeOne('abc&123') - self.failUnless('abc&123' in exc.app_iter[0]) + self.assertTrue('abc&123' in exc.app_iter[0]) class TestNotFound(unittest.TestCase): def _makeOne(self, message): @@ -30,7 +30,7 @@ class TestNotFound(unittest.TestCase): def test_it(self): from pyramid.exceptions import ExceptionResponse e = self._makeOne('notfound') - self.failUnless(isinstance(e, ExceptionResponse)) + self.assertTrue(isinstance(e, ExceptionResponse)) self.assertEqual(e.status, '404 Not Found') class TestForbidden(unittest.TestCase): @@ -41,5 +41,5 @@ class TestForbidden(unittest.TestCase): def test_it(self): from pyramid.exceptions import ExceptionResponse e = self._makeOne('unauthorized') - self.failUnless(isinstance(e, ExceptionResponse)) + self.assertTrue(isinstance(e, ExceptionResponse)) self.assertEqual(e.status, '403 Forbidden') diff --git a/pyramid/tests/test_i18n.py b/pyramid/tests/test_i18n.py index 3155f0ba1..588f0a7cc 100644 --- a/pyramid/tests/test_i18n.py +++ b/pyramid/tests/test_i18n.py @@ -41,7 +41,7 @@ class TestLocalizer(unittest.TestCase): localizer = self._makeOne(None, translations) self.assertEqual(localizer.translate('123', domain='1', mapping={}), '123') - self.failUnless(localizer.translator) + self.assertTrue(localizer.translator) def test_pluralize(self): translations = DummyTranslations() @@ -49,7 +49,7 @@ class TestLocalizer(unittest.TestCase): self.assertEqual(localizer.pluralize('singular', 'plural', 1, domain='1', mapping={}), 'singular') - self.failUnless(localizer.pluralizer) + self.assertTrue(localizer.pluralizer) def test_pluralize_pluralizer_already_added(self): translations = DummyTranslations() @@ -63,7 +63,7 @@ class TestLocalizer(unittest.TestCase): result, (('singular', 'plural', 1), {'domain': '1', 'mapping': {}}) ) - self.failUnless(localizer.pluralizer is pluralizer) + self.assertTrue(localizer.pluralizer is pluralizer) class Test_negotiate_locale_name(unittest.TestCase): def setUp(self): @@ -174,7 +174,7 @@ class Test_make_localizer(unittest.TestCase): self.assertEqual(result.translate('Approve', 'deformsite'), 'Genehmigen') self.assertEqual(result.translate('Approve'), 'Approve') - self.failUnless(hasattr(result, 'pluralize')) + self.assertTrue(hasattr(result, 'pluralize')) def test_locale_from_mo_bad_mo(self): import os @@ -260,7 +260,7 @@ class Test_get_localizer(unittest.TestCase): self.assertEqual(result.translate('Approve', 'deformsite'), 'Genehmigen') self.assertEqual(result.translate('Approve'), 'Approve') - self.failUnless(hasattr(result, 'pluralize')) + self.assertTrue(hasattr(result, 'pluralize')) def test_locale_from_mo_bad_mo(self): import os diff --git a/pyramid/tests/test_integration.py b/pyramid/tests/test_integration.py index 095f22f41..1f9484279 100644 --- a/pyramid/tests/test_integration.py +++ b/pyramid/tests/test_integration.py @@ -20,8 +20,8 @@ class WGSIAppPlusViewConfigTests(unittest.TestCase): def test_it(self): from venusian import ATTACH_ATTR import types - self.failUnless(getattr(wsgiapptest, ATTACH_ATTR)) - self.failUnless(type(wsgiapptest) is types.FunctionType) + self.assertTrue(getattr(wsgiapptest, ATTACH_ATTR)) + self.assertTrue(type(wsgiapptest) is types.FunctionType) context = DummyContext() request = DummyRequest() result = wsgiapptest(context, request) @@ -256,13 +256,13 @@ class TestForbiddenAppHasResult(IntegrationBase): def test_it(self): res = self.testapp.get('/x', status=403) message, result = [x.strip() for x in res.body.split('\n')] - self.failUnless(message.endswith('failed permission check')) - self.failUnless( + self.assertTrue(message.endswith('failed permission check')) + self.assertTrue( result.startswith("ACLDenied permission 'private' via ACE " "'' in ACL " "'' on context")) - self.failUnless( + self.assertTrue( result.endswith("for principals ['system.Everyone']")) class TestViewDecoratorApp(IntegrationBase): @@ -276,20 +276,20 @@ class TestViewDecoratorApp(IntegrationBase): # we use mako here instead of chameleon because it works on Jython self._configure_mako() res = self.testapp.get('/first', status=200) - self.failUnless('OK' in res.body) + self.assertTrue('OK' in res.body) def test_second(self): # we use mako here instead of chameleon because it works on Jython self._configure_mako() res = self.testapp.get('/second', status=200) - self.failUnless('OK2' in res.body) + self.assertTrue('OK2' in res.body) class TestViewPermissionBug(IntegrationBase): # view_execution_permitted bug as reported by Shane at http://lists.repoze.org/pipermail/repoze-dev/2010-October/003603.html package = 'pyramid.tests.permbugapp' def test_test(self): res = self.testapp.get('/test', status=200) - self.failUnless('ACLDenied' in res.body) + self.assertTrue('ACLDenied' in res.body) def test_x(self): self.testapp.get('/x', status=403) @@ -299,15 +299,15 @@ class TestDefaultViewPermissionBug(IntegrationBase): package = 'pyramid.tests.defpermbugapp' def test_x(self): res = self.testapp.get('/x', status=403) - self.failUnless('failed permission check' in res.body) + self.assertTrue('failed permission check' in res.body) def test_y(self): res = self.testapp.get('/y', status=403) - self.failUnless('failed permission check' in res.body) + self.assertTrue('failed permission check' in res.body) def test_z(self): res = self.testapp.get('/z', status=200) - self.failUnless('public' in res.body) + self.assertTrue('public' in res.body) from pyramid.tests.exceptionviewapp.models import AnException, NotAnException excroot = {'anexception':AnException(), @@ -318,31 +318,31 @@ class TestExceptionViewsApp(IntegrationBase): root_factory = lambda *arg: excroot def test_root(self): res = self.testapp.get('/', status=200) - self.failUnless('maybe' in res.body) + self.assertTrue('maybe' in res.body) def test_notanexception(self): res = self.testapp.get('/notanexception', status=200) - self.failUnless('no' in res.body) + self.assertTrue('no' in res.body) def test_anexception(self): res = self.testapp.get('/anexception', status=200) - self.failUnless('yes' in res.body) + self.assertTrue('yes' in res.body) def test_route_raise_exception(self): res = self.testapp.get('/route_raise_exception', status=200) - self.failUnless('yes' in res.body) + self.assertTrue('yes' in res.body) def test_route_raise_exception2(self): res = self.testapp.get('/route_raise_exception2', status=200) - self.failUnless('yes' in res.body) + self.assertTrue('yes' in res.body) def test_route_raise_exception3(self): res = self.testapp.get('/route_raise_exception3', status=200) - self.failUnless('whoa' in res.body) + self.assertTrue('whoa' in res.body) def test_route_raise_exception4(self): res = self.testapp.get('/route_raise_exception4', status=200) - self.failUnless('whoa' in res.body) + self.assertTrue('whoa' in res.body) class ImperativeIncludeConfigurationTest(unittest.TestCase): def setUp(self): @@ -360,15 +360,15 @@ class ImperativeIncludeConfigurationTest(unittest.TestCase): def test_root(self): res = self.testapp.get('/', status=200) - self.failUnless('root' in res.body) + self.assertTrue('root' in res.body) def test_two(self): res = self.testapp.get('/two', status=200) - self.failUnless('two' in res.body) + self.assertTrue('two' in res.body) def test_three(self): res = self.testapp.get('/three', status=200) - self.failUnless('three' in res.body) + self.assertTrue('three' in res.body) class SelfScanAppTest(unittest.TestCase): def setUp(self): @@ -384,11 +384,11 @@ class SelfScanAppTest(unittest.TestCase): def test_root(self): res = self.testapp.get('/', status=200) - self.failUnless('root' in res.body) + self.assertTrue('root' in res.body) def test_two(self): res = self.testapp.get('/two', status=200) - self.failUnless('two' in res.body) + self.assertTrue('two' in res.body) class DummyContext(object): pass diff --git a/pyramid/tests/test_mako_templating.py b/pyramid/tests/test_mako_templating.py index 8a03d4b5c..054c83d2b 100644 --- a/pyramid/tests/test_mako_templating.py +++ b/pyramid/tests/test_mako_templating.py @@ -260,7 +260,7 @@ class MakoLookupTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() instance = self._makeOne('path', lookup) result = instance({}, {'system':1}) - self.failUnless(isinstance(result, unicode)) + self.assertTrue(isinstance(result, unicode)) self.assertEqual(result, u'result') def test_call_with_system_context(self): @@ -268,7 +268,7 @@ class MakoLookupTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() instance = self._makeOne('path', lookup) result = instance({}, {'context':1}) - self.failUnless(isinstance(result, unicode)) + self.assertTrue(isinstance(result, unicode)) self.assertEqual(result, u'result') self.assertEqual(lookup.values, {'_context':1}) @@ -289,7 +289,7 @@ class MakoLookupTemplateRendererTests(Base, unittest.TestCase): lookup = DummyLookup() instance = self._makeOne('path', lookup) result = instance.implementation().render_unicode() - self.failUnless(isinstance(result, unicode)) + self.assertTrue(isinstance(result, unicode)) self.assertEqual(result, u'result') class TestIntegration(unittest.TestCase): @@ -378,12 +378,12 @@ class TestPkgResourceTemplateLookup(unittest.TestCase): fixturedir = self.get_fixturedir() inst = self._makeOne(directories=[fixturedir]) result = inst.get_template('helloworld.mak') - self.failIf(result is None) + self.assertFalse(result is None) def test_get_template_asset_spec_with_filesystem_checks(self): inst = self._makeOne(filesystem_checks=True) result = inst.get_template('pyramid.tests:fixtures/helloworld.mak') - self.failIf(result is None) + self.assertFalse(result is None) def test_get_template_asset_spec_missing(self): from mako.exceptions import TopLevelLookupException diff --git a/pyramid/tests/test_paster.py b/pyramid/tests/test_paster.py index 07ec4f7b7..d1082fc51 100644 --- a/pyramid/tests/test_paster.py +++ b/pyramid/tests/test_paster.py @@ -15,7 +15,7 @@ class TestPyramidTemplate(unittest.TestCase): result = tmpl.pre(None, None, vars) self.assertEqual(result, None) self.assertEqual(vars['package_logger'], 'app') - self.failUnless(len(vars['random_string']) == 40) + self.assertTrue(len(vars['random_string']) == 40) def test_pre_logger_noteq_root(self): tmpl = self._makeOne('name') @@ -23,7 +23,7 @@ class TestPyramidTemplate(unittest.TestCase): result = tmpl.pre(None, None, vars) self.assertEqual(result, None) self.assertEqual(vars['package_logger'], 'notroot') - self.failUnless(len(vars['random_string']) == 40) + self.assertTrue(len(vars['random_string']) == 40) def test_post(self): tmpl = self._makeOne('name') @@ -56,14 +56,14 @@ class TestPShellCommand(unittest.TestCase): command.command(IPShell=None) self.assertEqual(loadapp.config_name, 'config:/foo/bar/myapp.ini') self.assertEqual(loadapp.section_name, 'myapp') - self.failUnless(loadapp.relative_to) + self.assertTrue(loadapp.relative_to) self.assertEqual(len(app.threadlocal_manager.pushed), 1) pushed = app.threadlocal_manager.pushed[0] self.assertEqual(pushed['registry'], dummy_registry) self.assertEqual(pushed['request'].registry, dummy_registry) self.assertEqual(interact.local, {'root':dummy_root, 'registry':dummy_registry}) - self.failUnless(interact.banner) + self.assertTrue(interact.banner) self.assertEqual(len(app.threadlocal_manager.popped), 1) def test_command_ipshell_is_not_None_ipython_disabled(self): @@ -80,14 +80,14 @@ class TestPShellCommand(unittest.TestCase): command.command(IPShell='notnone') self.assertEqual(loadapp.config_name, 'config:/foo/bar/myapp.ini') self.assertEqual(loadapp.section_name, 'myapp') - self.failUnless(loadapp.relative_to) + self.assertTrue(loadapp.relative_to) self.assertEqual(len(app.threadlocal_manager.pushed), 1) pushed = app.threadlocal_manager.pushed[0] self.assertEqual(pushed['registry'], dummy_registry) self.assertEqual(pushed['request'].registry, dummy_registry) self.assertEqual(interact.local, {'root':dummy_root, 'registry':dummy_registry}) - self.failUnless(interact.banner) + self.assertTrue(interact.banner) self.assertEqual(len(app.threadlocal_manager.popped), 1) def test_command_ipython_enabled(self): @@ -103,7 +103,7 @@ class TestPShellCommand(unittest.TestCase): command.command(IPShell=dummy_shell_factory) self.assertEqual(loadapp.config_name, 'config:/foo/bar/myapp.ini') self.assertEqual(loadapp.section_name, 'myapp') - self.failUnless(loadapp.relative_to) + self.assertTrue(loadapp.relative_to) self.assertEqual(len(app.threadlocal_manager.pushed), 1) pushed = app.threadlocal_manager.pushed[0] self.assertEqual(pushed['registry'], dummy_registry) @@ -111,7 +111,7 @@ class TestPShellCommand(unittest.TestCase): self.assertEqual(dummy_shell_factory.shell.local_ns, {'root':dummy_root, 'registry':dummy_registry}) self.assertEqual(dummy_shell_factory.shell.global_ns, {}) - self.failUnless('\n\n' in dummy_shell_factory.shell.IP.BANNER) + self.assertTrue('\n\n' in dummy_shell_factory.shell.IP.BANNER) self.assertEqual(len(app.threadlocal_manager.popped), 1) def test_command_get_app_hookable(self): @@ -137,7 +137,7 @@ class TestPShellCommand(unittest.TestCase): self.assertEqual(pushed['request'].registry, dummy_registry) self.assertEqual(interact.local, {'root':dummy_root, 'registry':dummy_registry}) - self.failUnless(interact.banner) + self.assertTrue(interact.banner) self.assertEqual(len(app.threadlocal_manager.popped), 1) self.assertEqual(apped, [(('/foo/bar/myapp.ini', 'myapp'), {'loadapp': loadapp})]) @@ -162,11 +162,11 @@ class TestPShellCommand(unittest.TestCase): command.command(IPShell=None) self.assertEqual(loadapp.config_name, 'config:/foo/bar/myapp.ini') self.assertEqual(loadapp.section_name, 'myapp') - self.failUnless(loadapp.relative_to) + self.assertTrue(loadapp.relative_to) self.assertEqual(len(app.threadlocal_manager.pushed), 0) self.assertEqual(interact.local, {'root':root, 'registry':dummy_registry}) - self.failUnless(interact.banner) + self.assertTrue(interact.banner) self.assertEqual(apps, [app]) class TestPRoutesCommand(unittest.TestCase): diff --git a/pyramid/tests/test_path.py b/pyramid/tests/test_path.py index 5619aafa1..c2261d223 100644 --- a/pyramid/tests/test_path.py +++ b/pyramid/tests/test_path.py @@ -53,7 +53,7 @@ class TestCallerModule(unittest.TestCase): def test_it_level_3(self): from pyramid.tests import test_path result = self._callFUT(3) - self.failIfEqual(result, test_path) + self.assertNotEqual(result, test_path) def test_it_no___name__(self): class DummyFrame(object): @@ -121,7 +121,7 @@ class TestPackagePath(unittest.TestCase): from pyramid.tests import test_path module = DummyPackageOrModule(test_path, raise_exc=TypeError) result = self._callFUT(module) - self.failIf(hasattr(module, '__abspath__')) + self.assertFalse(hasattr(module, '__abspath__')) self.assertEqual(result, module.package_path) class TestPackageOf(unittest.TestCase): diff --git a/pyramid/tests/test_renderers.py b/pyramid/tests/test_renderers.py index b0baaee0d..0dbb0d821 100644 --- a/pyramid/tests/test_renderers.py +++ b/pyramid/tests/test_renderers.py @@ -58,7 +58,7 @@ class TestTemplateRendererFactory(unittest.TestCase): 'type':'type', }) result = self._callFUT(info, None) - self.failUnless(result is renderer) + self.assertTrue(result is renderer) class TestChameleonRendererLookup(unittest.TestCase): def setUp(self): @@ -202,7 +202,7 @@ class TestChameleonRendererLookup(unittest.TestCase): }) lookup = self._makeOne(None) result = lookup(info) - self.failUnless(result is renderer) + self.assertTrue(result is renderer) def test___call__abspath_notyetregistered(self): import os @@ -233,7 +233,7 @@ class TestChameleonRendererLookup(unittest.TestCase): }) lookup = self._makeOne(None) result = lookup(info) - self.failUnless(renderer is result) + self.assertTrue(renderer is result) def test___call__relpath_has_package_registered(self): renderer = {} @@ -249,7 +249,7 @@ class TestChameleonRendererLookup(unittest.TestCase): }) lookup = self._makeOne(None) result = lookup(info) - self.failUnless(renderer is result) + self.assertTrue(renderer is result) def test___call__spec_notfound(self): spec = 'pyramid.tests:wont/exist' @@ -279,7 +279,7 @@ class TestChameleonRendererLookup(unittest.TestCase): self._registerTemplateRenderer(renderer, spec) lookup = self._makeOne(None) result = lookup(info) - self.failUnless(result is renderer) + self.assertTrue(result is renderer) def test___call__spec_notyetregistered(self): import os @@ -298,11 +298,11 @@ class TestChameleonRendererLookup(unittest.TestCase): }) lookup = self._makeOne(factory) result = lookup(info) - self.failUnless(result is renderer) + self.assertTrue(result is renderer) path = os.path.abspath(__file__).split('$')[0] # jython if path.endswith('.pyc'): # pragma: no cover path = path[:-1] - self.failUnless(factory.path.startswith(path)) + self.assertTrue(factory.path.startswith(path)) self.assertEqual(factory.kw, {}) def test___call__reload_assets_true(self): @@ -324,7 +324,7 @@ class TestChameleonRendererLookup(unittest.TestCase): }) lookup = self._makeOne(factory) result = lookup(info) - self.failUnless(result is renderer) + self.assertTrue(result is renderer) spec = '%s:%s' % ('pyramid.tests', 'test_renderers.py') self.assertEqual(reg.queryUtility(ITemplateRenderer, name=spec), None) @@ -346,7 +346,7 @@ class TestChameleonRendererLookup(unittest.TestCase): }) lookup = self._makeOne(factory) result = lookup(info) - self.failUnless(result is renderer) + self.assertTrue(result is renderer) spec = '%s:%s' % ('pyramid.tests', 'test_renderers.py') self.assertNotEqual(reg.queryUtility(ITemplateRenderer, name=spec), None) @@ -558,7 +558,7 @@ class TestRendererHelper(unittest.TestCase): helper = self._makeOne('loo.foo', registry=reg) result = helper.render('value', {}) self.assertEqual(result, ('value', {})) - self.failUnless(reg.queried) + self.assertTrue(reg.queried) self.assertEqual(reg.event._system, {}) self.assertEqual(reg.event.__class__.__name__, 'BeforeRender') diff --git a/pyramid/tests/test_request.py b/pyramid/tests/test_request.py index 40940cfc9..66a451220 100644 --- a/pyramid/tests/test_request.py +++ b/pyramid/tests/test_request.py @@ -98,13 +98,13 @@ class TestRequest(unittest.TestCase): def test___contains__(self): environ ={'zooma':1} inst = self._makeOne(environ) - self.failUnless('zooma' in inst) + self.assertTrue('zooma' in inst) def test___delitem__(self): environ = {'zooma':1} inst = self._makeOne(environ) del inst['zooma'] - self.failIf('zooma' in environ) + self.assertFalse('zooma' in environ) def test___getitem__(self): environ = {'zooma':1} diff --git a/pyramid/tests/test_router.py b/pyramid/tests/test_router.py index ffda14738..b869a3830 100644 --- a/pyramid/tests/test_router.py +++ b/pyramid/tests/test_router.py @@ -117,8 +117,8 @@ class TestRouter(unittest.TestCase): router = self._makeOne() self.assertEqual(router.debug_notfound, False) self.assertEqual(router.debug_routematch, False) - self.failIf('debug_notfound' in router.__dict__) - self.failIf('debug_routematch' in router.__dict__) + self.assertFalse('debug_notfound' in router.__dict__) + self.assertFalse('debug_routematch' in router.__dict__) def test_root_policy(self): context = DummyContext() @@ -142,8 +142,8 @@ class TestRouter(unittest.TestCase): router = self._makeOne() start_response = DummyStartResponse() why = exc_raised(NotFound, router, environ, start_response) - self.failUnless('/' in why[0], why) - self.failIf('debug_notfound' in why[0]) + self.assertTrue('/' in why[0], why) + self.assertFalse('debug_notfound' in why[0]) self.assertEqual(len(logger.messages), 0) def test_traverser_raises_notfound_class(self): @@ -163,7 +163,7 @@ class TestRouter(unittest.TestCase): router = self._makeOne() start_response = DummyStartResponse() why = exc_raised(NotFound, router, environ, start_response) - self.failUnless('foo' in why[0], why) + self.assertTrue('foo' in why[0], why) def test_traverser_raises_forbidden_class(self): from pyramid.exceptions import Forbidden @@ -182,7 +182,7 @@ class TestRouter(unittest.TestCase): router = self._makeOne() start_response = DummyStartResponse() why = exc_raised(Forbidden, router, environ, start_response) - self.failUnless('foo' in why[0], why) + self.assertTrue('foo' in why[0], why) def test_call_no_view_registered_no_isettings(self): from pyramid.exceptions import NotFound @@ -193,8 +193,8 @@ class TestRouter(unittest.TestCase): router = self._makeOne() start_response = DummyStartResponse() why = exc_raised(NotFound, router, environ, start_response) - self.failUnless('/' in why[0], why) - self.failIf('debug_notfound' in why[0]) + self.assertTrue('/' in why[0], why) + self.assertFalse('debug_notfound' in why[0]) self.assertEqual(len(logger.messages), 0) def test_call_no_view_registered_debug_notfound_false(self): @@ -207,8 +207,8 @@ class TestRouter(unittest.TestCase): router = self._makeOne() start_response = DummyStartResponse() why = exc_raised(NotFound, router, environ, start_response) - self.failUnless('/' in why[0], why) - self.failIf('debug_notfound' in why[0]) + self.assertTrue('/' in why[0], why) + self.assertFalse('debug_notfound' in why[0]) self.assertEqual(len(logger.messages), 0) def test_call_no_view_registered_debug_notfound_true(self): @@ -221,19 +221,19 @@ class TestRouter(unittest.TestCase): router = self._makeOne() start_response = DummyStartResponse() why = exc_raised(NotFound, router, environ, start_response) - self.failUnless( + self.assertTrue( "debug_notfound of url http://localhost:8080/; path_info: '/', " "context:" in why[0]) - self.failUnless("view_name: '', subpath: []" in why[0]) - self.failUnless('http://localhost:8080' in why[0], why) + self.assertTrue("view_name: '', subpath: []" in why[0]) + self.assertTrue('http://localhost:8080' in why[0], why) self.assertEqual(len(logger.messages), 1) message = logger.messages[0] - self.failUnless('of url http://localhost:8080' in message) - self.failUnless("path_info: '/'" in message) - self.failUnless('DummyContext instance at' in message) - self.failUnless("view_name: ''" in message) - self.failUnless("subpath: []" in message) + self.assertTrue('of url http://localhost:8080' in message) + self.assertTrue("path_info: '/'" in message) + self.assertTrue('DummyContext instance at' in message) + self.assertTrue("view_name: ''" in message) + self.assertTrue("subpath: []" in message) def test_call_view_returns_nonresponse(self): from pyramid.interfaces import IViewClassifier @@ -557,7 +557,7 @@ class TestRouter(unittest.TestCase): self.assertEqual(request.matched_route.name, 'foo') self.assertEqual(len(logger.messages), 1) - self.failUnless( + self.assertTrue( logger.messages[0].startswith( "route matched for url http://localhost:8080" "/archives/action1/article1; " @@ -623,7 +623,7 @@ class TestRouter(unittest.TestCase): self.assertEqual(environ['bfg.routes.route'].name, 'foo') self.assertEqual(request.matchdict, matchdict) self.assertEqual(request.matched_route.name, 'foo') - self.failUnless(IFoo.providedBy(request)) + self.assertTrue(IFoo.providedBy(request)) def test_root_factory_raises_notfound(self): from pyramid.interfaces import IRootFactory @@ -641,7 +641,7 @@ class TestRouter(unittest.TestCase): router = self._makeOne() start_response = DummyStartResponse() why = exc_raised(NotFound, router, environ, start_response) - self.failUnless('from root factory' in why[0]) + self.assertTrue('from root factory' in why[0]) def test_root_factory_raises_forbidden(self): from pyramid.interfaces import IRootFactory @@ -659,7 +659,7 @@ class TestRouter(unittest.TestCase): router = self._makeOne() start_response = DummyStartResponse() why = exc_raised(Forbidden, router, environ, start_response) - self.failUnless('from root factory' in why[0]) + self.assertTrue('from root factory' in why[0]) def test_root_factory_exception_propagating(self): from pyramid.interfaces import IRootFactory diff --git a/pyramid/tests/test_security.py b/pyramid/tests/test_security.py index 94cefa642..86149d554 100644 --- a/pyramid/tests/test_security.py +++ b/pyramid/tests/test_security.py @@ -19,9 +19,9 @@ class TestAllPermissionsList(unittest.TestCase): def test_it(self): thing = self._makeOne() - self.failUnless(thing.__eq__(thing)) + self.assertTrue(thing.__eq__(thing)) self.assertEqual(thing.__iter__(), ()) - self.failUnless('anything' in thing) + self.assertTrue('anything' in thing) def test_singleton(self): from pyramid.security import ALL_PERMISSIONS @@ -40,10 +40,10 @@ class TestAllowed(unittest.TestCase): allowed = self._makeOne('hello') self.assertEqual(allowed.msg, 'hello') self.assertEqual(allowed, True) - self.failUnless(allowed) + self.assertTrue(allowed) self.assertEqual(str(allowed), 'hello') - self.failUnless('" in repr(allowed)) + self.assertTrue('" in repr(allowed)) class TestDenied(unittest.TestCase): def _getTargetClass(self): @@ -58,10 +58,10 @@ class TestDenied(unittest.TestCase): denied = self._makeOne('hello') self.assertEqual(denied.msg, 'hello') self.assertEqual(denied, False) - self.failIf(denied) + self.assertFalse(denied) self.assertEqual(str(denied), 'hello') - self.failUnless('" in repr(denied)) + self.assertTrue('" in repr(denied)) class TestACLAllowed(unittest.TestCase): def _getTargetClass(self): @@ -76,12 +76,12 @@ class TestACLAllowed(unittest.TestCase): msg = ("ACLAllowed permission 'permission' via ACE 'ace' in ACL 'acl' " "on context 'ctx' for principals 'principals'") allowed = self._makeOne('ace', 'acl', 'permission', 'principals', 'ctx') - self.failUnless(msg in allowed.msg) + self.assertTrue(msg in allowed.msg) self.assertEqual(allowed, True) - self.failUnless(allowed) + self.assertTrue(allowed) self.assertEqual(str(allowed), msg) - self.failUnless('" % msg in repr(allowed)) + self.assertTrue('" % msg in repr(allowed)) class TestACLDenied(unittest.TestCase): def _getTargetClass(self): @@ -96,12 +96,12 @@ class TestACLDenied(unittest.TestCase): msg = ("ACLDenied permission 'permission' via ACE 'ace' in ACL 'acl' " "on context 'ctx' for principals 'principals'") denied = self._makeOne('ace', 'acl', 'permission', 'principals', 'ctx') - self.failUnless(msg in denied.msg) + self.assertTrue(msg in denied.msg) self.assertEqual(denied, False) - self.failIf(denied) + self.assertFalse(denied) self.assertEqual(str(denied), msg) - self.failUnless('" % msg in repr(denied)) + self.assertTrue('" % msg in repr(denied)) class TestViewExecutionPermitted(unittest.TestCase): def setUp(self): @@ -140,8 +140,8 @@ class TestViewExecutionPermitted(unittest.TestCase): request = DummyRequest({}) result = self._callFUT(context, request, '') msg = result.msg - self.failUnless("Allowed: view name '' in context" in msg) - self.failUnless('(no permission defined)' in msg) + self.assertTrue("Allowed: view name '' in context" in msg) + self.assertTrue('(no permission defined)' in msg) self.assertEqual(result, True) def test_with_permission(self): @@ -156,7 +156,7 @@ class TestViewExecutionPermitted(unittest.TestCase): request = DummyRequest({}) directlyProvides(request, IRequest) result = self._callFUT(context, request, '') - self.failUnless(result is True) + self.assertTrue(result is True) class TestHasPermission(unittest.TestCase): def setUp(self): diff --git a/pyramid/tests/test_session.py b/pyramid/tests/test_session.py index e8a3318ea..17a437af6 100644 --- a/pyramid/tests/test_session.py +++ b/pyramid/tests/test_session.py @@ -54,7 +54,7 @@ class TestUnencryptedCookieSession(unittest.TestCase): session = self._makeOne(request) session['a'] = 1 self.assertEqual(session.invalidate(), None) - self.failIf('a' in session) + self.assertFalse('a' in session) def test__set_cookie_on_exception(self): request = testing.DummyRequest() @@ -116,7 +116,7 @@ class TestUnencryptedCookieSession(unittest.TestCase): cookieval= response.headerlist[0][1] val, domain, path, secure, httponly = [x.strip() for x in cookieval.split(';')] - self.failUnless(val.startswith('abc=')) + self.assertTrue(val.startswith('abc=')) self.assertEqual(domain, 'Domain=localhost') self.assertEqual(path, 'Path=/foo') self.assertEqual(secure, 'secure') @@ -205,14 +205,14 @@ class TestUnencryptedCookieSession(unittest.TestCase): session['_csrft_'] = 'token' token = session.get_csrf_token() self.assertEqual(token, 'token') - self.failUnless('_csrft_' in session) + self.assertTrue('_csrft_' in session) def test_get_csrf_token_new(self): request = testing.DummyRequest() session = self._makeOne(request) token = session.get_csrf_token() - self.failUnless(token) - self.failUnless('_csrft_' in session) + self.assertTrue(token) + self.assertTrue('_csrft_' in session) class Test_manage_accessed(unittest.TestCase): def _makeOne(self, wrapped): @@ -254,7 +254,7 @@ class Test_manage_accessed(unittest.TestCase): response = webob.Response() result = callbacks[0](request, response) self.assertEqual(result, None) - self.failIf('Set-Cookie' in dict(response.headerlist)) + self.assertFalse('Set-Cookie' in dict(response.headerlist)) def test_cookie_is_set(self): request = testing.DummyRequest() diff --git a/pyramid/tests/test_static.py b/pyramid/tests/test_static.py index 9c4c4a1c8..b9d464bf1 100644 --- a/pyramid/tests/test_static.py +++ b/pyramid/tests/test_static.py @@ -46,8 +46,8 @@ class TestPackageURLParser(unittest.TestCase): sr = DummyStartResponse() response = inst(environ, sr) body = response[0] - self.failUnless('301 Moved Permanently' in body) - self.failUnless('http://example.com:6543/' in body) + self.assertTrue('301 Moved Permanently' in body) + self.assertTrue('http://example.com:6543/' in body) def test_path_info_slash_means_index_html(self): environ = self._makeEnviron() @@ -55,7 +55,7 @@ class TestPackageURLParser(unittest.TestCase): sr = DummyStartResponse() response = inst(environ, sr) body = response[0] - self.failUnless('static' in body) + self.assertTrue('static' in body) def test_resource_out_of_bounds(self): environ = self._makeEnviron() @@ -64,8 +64,8 @@ class TestPackageURLParser(unittest.TestCase): sr = DummyStartResponse() response = inst(environ, sr) body = response[0] - self.failUnless('404 Not Found' in body) - self.failUnless('http://example.com:6543/' in body) + self.assertTrue('404 Not Found' in body) + self.assertTrue('http://example.com:6543/' in body) def test_resource_doesnt_exist(self): environ = self._makeEnviron(PATH_INFO='/notthere') @@ -73,8 +73,8 @@ class TestPackageURLParser(unittest.TestCase): sr = DummyStartResponse() response = inst(environ, sr) body = response[0] - self.failUnless('404 Not Found' in body) - self.failUnless('http://example.com:6543/' in body) + self.assertTrue('404 Not Found' in body) + self.assertTrue('http://example.com:6543/' in body) def test_resource_isdir(self): environ = self._makeEnviron(PATH_INFO='/subdir/') @@ -82,7 +82,7 @@ class TestPackageURLParser(unittest.TestCase): sr = DummyStartResponse() response = inst(environ, sr) body = response[0] - self.failUnless('subdir' in body) + self.assertTrue('subdir' in body) def test_resource_is_file(self): environ = self._makeEnviron(PATH_INFO='/index.html') @@ -90,7 +90,7 @@ class TestPackageURLParser(unittest.TestCase): sr = DummyStartResponse() response = inst(environ, sr) body = response[0] - self.failUnless('static' in body) + self.assertTrue('static' in body) def test_resource_has_extra_path_info(self): environ = self._makeEnviron(PATH_INFO='/static/index.html/more') @@ -98,7 +98,7 @@ class TestPackageURLParser(unittest.TestCase): sr = DummyStartResponse() response = inst(environ, sr) body = response[0] - self.failUnless("The trailing path '/more' is not allowed" in body) + self.assertTrue("The trailing path '/more' is not allowed" in body) def test_resource_is_file_with_cache_max_age(self): environ = self._makeEnviron(PATH_INFO='/index.html') @@ -107,7 +107,7 @@ class TestPackageURLParser(unittest.TestCase): sr = DummyStartResponse() response = inst(environ, sr) body = response[0] - self.failUnless('static' in body) + self.assertTrue('static' in body) self.assertEqual(len(sr.headerlist), 8) header_names = [ x[0] for x in sr.headerlist ] header_names.sort() @@ -122,7 +122,7 @@ class TestPackageURLParser(unittest.TestCase): sr = DummyStartResponse() response = inst(environ, sr) body = response[0] - self.failUnless('static' in body) + self.assertTrue('static' in body) self.assertEqual(len(sr.headerlist), 6) header_names = [ x[0] for x in sr.headerlist ] header_names.sort() @@ -137,7 +137,7 @@ class TestPackageURLParser(unittest.TestCase): sr = DummyStartResponse() response = inst(environ, sr) body = response[0] - self.failUnless('static' in body) + self.assertTrue('static' in body) def test_if_none_match(self): class DummyEq(object): @@ -168,7 +168,7 @@ class TestPackageURLParser(unittest.TestCase): def test_repr(self): import os.path inst = self._makeOne('pyramid.tests', 'fixtures/static') - self.failUnless( + self.assertTrue( repr(inst).startswith( ' Date: Tue, 19 Apr 2011 00:05:24 -0400 Subject: clarify --- CHANGES.txt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGES.txt b/CHANGES.txt index 5f450fdcd..affacb7d4 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -32,7 +32,9 @@ Features object (e.g. ``request.response`` within a view) now produces a new ``pyramid.response.Response`` object. This feature is meant to be used mainly when a view configured with a renderer needs to set response - attributes, but it can be used by any code. + attributes, but it can be used by any code to produce a response object + (although the response object produced must still be returned unless a + renderer is used). - Integers and longs passed as ``elements`` to ``pyramid.url.resource_url`` or ``pyramid.request.Request.resource_url`` e.g. ``resource_url(context, -- cgit v1.2.3 From b330c74e58c46d20f97b5340f1eadc1865cfebc4 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Tue, 19 Apr 2011 00:08:37 -0400 Subject: clarify --- docs/api/request.rst | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/docs/api/request.rst b/docs/api/request.rst index 80b41badb..38971295f 100644 --- a/docs/api/request.rst +++ b/docs/api/request.rst @@ -93,9 +93,9 @@ it is accessed, subsequent accesses to this request object will return the same :class:`~pyramid.response.Response` object. - The ``request.response`` API is used by renderers. A render obtains the - response object it will return from a view that uses that renderer by - accessing ``request.response``. Therefore, it's possible to use the + The ``request.response`` API can is used by renderers. A render obtains + the response object it will return from a view that uses that renderer + by accessing ``request.response``. Therefore, it's possible to use the ``request.response`` API to set up a response object with "the right" attributes (e.g. by calling ``request.response.set_cookie(...)`` or ``request.response.content_type = 'text/plain'``, etc) within a view @@ -117,6 +117,9 @@ response.content_type = 'text/plain' return response + Note that the response in this circumstance is not "global"; it still + must be returned from the view code if a renderer is not used. + .. attribute:: session If a :term:`session factory` has been configured, this attribute -- cgit v1.2.3 From c3709de99988b7f9ca2ef2e86c3617ce1de5f4ed Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Tue, 19 Apr 2011 00:17:57 -0400 Subject: garden --- TODO.txt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/TODO.txt b/TODO.txt index dd2947477..63f0414aa 100644 --- a/TODO.txt +++ b/TODO.txt @@ -37,6 +37,9 @@ Should-Have Nice-to-Have ------------ +- Response.RequestClass should probably be pyramid.request.Request but this + may imply actually subclassing webob.Response + - Consider per-form_id CSRF instead of per-session global CSRF token. - Better "Extending" chapter. -- cgit v1.2.3 From f06b2d255e67ee6a78a6420bde521d99b021d336 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Tue, 19 Apr 2011 00:59:12 -0400 Subject: garden --- TODO.txt | 6 ------ 1 file changed, 6 deletions(-) diff --git a/TODO.txt b/TODO.txt index 63f0414aa..eccfb34ed 100644 --- a/TODO.txt +++ b/TODO.txt @@ -24,12 +24,6 @@ Should-Have - translationdir ZCML directive use of ``path_spec`` should maybe die. -- Provide a response_set_cookie method on the request for rendered responses - that can be used as input to response.set_cookie? Or maybe accessing - ``request.response`` creates a Response, and you do - ``request.response.set_cookie(...)``. See also - https://github.com/Pylons/pyramid/issues/175 - - Fix message catalog extraction / compilation documentation. - Review http://alexmarandon.com/articles/zodb_bfg_pyramid_notes . -- cgit v1.2.3 From f0c8473e2c0c7ea45bc169d59291ea68a0855259 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Tue, 19 Apr 2011 00:59:25 -0400 Subject: readd py2.4 testing (using chameleon 1) --- tox.ini | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/tox.ini b/tox.ini index 56307bacf..73a487ac8 100644 --- a/tox.ini +++ b/tox.ini @@ -1,19 +1,27 @@ [tox] envlist = - py25,py26,py27,jython,pypy,cover + py24,py25,py26,py27,jython,pypy,cover [testenv] commands = python setup.py test -q -# if we ever want to run the paster template tests, we could also use: -# python template_tests.py -# they take forever, though deps = Sphinx WebTest repoze.sphinx.autointerface virtualenv +[testenv:py24] +# Chameleon 2 doesnt work under py2.4 +commands = + python setup.py test -q +deps = + Sphinx + WebTest + repoze.sphinx.autointerface + virtualenv + Chameleon<=1.999 + [testenv:jython] commands = jython setup.py test -q -- cgit v1.2.3 From 6717ccbcd7f481e2a15c4ba318ccf6d63a1b7649 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Tue, 19 Apr 2011 01:06:10 -0400 Subject: rendering --- docs/api/request.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/api/request.rst b/docs/api/request.rst index 38971295f..91bf0b858 100644 --- a/docs/api/request.rst +++ b/docs/api/request.rst @@ -100,7 +100,7 @@ attributes (e.g. by calling ``request.response.set_cookie(...)`` or ``request.response.content_type = 'text/plain'``, etc) within a view that uses a renderer. For example, within a view that uses a - :term:`renderer`: + :term:`renderer`:: response = request.response response.set_cookie('mycookie', 'mine, all mine!') @@ -117,8 +117,8 @@ response.content_type = 'text/plain' return response - Note that the response in this circumstance is not "global"; it still - must be returned from the view code if a renderer is not used. + Note that the response in this circumstance is not "global"; it still + must be returned from the view code if a renderer is not used. .. attribute:: session -- cgit v1.2.3