Merge branch 'master' of git://github.com/Pylons/pyramid

31 files changed, 748 insertions, 442 deletions

diff --git a/CHANGES.txt b/CHANGES.txt
index 15ec0d8e0..95387b03b 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -28,6 +28,14 @@ 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 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,
   request, 1, 2)`` (``1`` and ``2`` are the ``elements``) will now be
@@ -124,6 +132,47 @@ 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
+------------
+
+- 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.)
+
 1.0 (2011-01-30)
 ================
 
diff --git a/TODO.txt b/TODO.txt
index d5d676d21..eccfb34ed 100644
--- a/TODO.txt
+++ b/TODO.txt
@@ -24,11 +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(...)``.
-
 - Fix message catalog extraction / compilation documentation.
 
 - Review http://alexmarandon.com/articles/zodb_bfg_pyramid_notes .
@@ -36,6 +31,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.
diff --git a/docs/api/request.rst b/docs/api/request.rst
index d17441c0a..91bf0b858 100644
--- a/docs/api/request.rst
+++ b/docs/api/request.rst
@@ -85,6 +85,41 @@
      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 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
+     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
+
+     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
@@ -127,10 +162,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_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'),
                      '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
 
@@ -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'),
                      '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
         
@@ -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'),
                      '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
 
@@ -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'),
                      '<div xmlns="http://www.w3.org/1999/xhtml">\n</div>')
         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('<code></code>' in exc.app_iter[0])
+        self.assertTrue('<code></code>' 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('<code>abc&amp;123</code>' in exc.app_iter[0])
+        self.assertTrue('<code>abc&amp;123</code>' 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 "
                               "'<default deny>' in ACL "
                               "'<No ACL found on any object in resource "
                               "lineage>' 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 70c2c620e..0dbb0d821 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()
@@ -46,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):
@@ -190,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
@@ -221,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 = {}
@@ -237,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'
@@ -267,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
@@ -286,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):
@@ -312,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)
@@ -334,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)
@@ -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'
@@ -532,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')
 
@@ -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_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('<Allowed instance at ' in repr(allowed))
-        self.failUnless("with msg 'hello'>" in repr(allowed))
+        self.assertTrue('<Allowed instance at ' in repr(allowed))
+        self.assertTrue("with msg 'hello'>" 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('<Denied instance at ' in repr(denied))
-        self.failUnless("with msg 'hello'>" in repr(denied))
+        self.assertTrue('<Denied instance at ' in repr(denied))
+        self.assertTrue("with msg 'hello'>" 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('<ACLAllowed instance at ' in repr(allowed))
-        self.failUnless("with msg %r>" % msg in repr(allowed))
+        self.assertTrue('<ACLAllowed instance at ' in repr(allowed))
+        self.assertTrue("with msg %r>" % 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('<ACLDenied instance at ' in repr(denied))
-        self.failUnless("with msg %r>" % msg in repr(denied))
+        self.assertTrue('<ACLDenied instance at ' in repr(denied))
+        self.assertTrue("with msg %r>" % 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('<html>static</html>' in body)
+        self.assertTrue('<html>static</html>' 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('<html>subdir</html>' in body)
+        self.assertTrue('<html>subdir</html>' 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('<html>static</html>' in body)
+        self.assertTrue('<html>static</html>' 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('<html>static</html>' in body)
+        self.assertTrue('<html>static</html>' 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('<html>static</html>' in body)
+        self.assertTrue('<html>static</html>' 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('<html>static</html>' in body)
+        self.assertTrue('<html>static</html>' 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(
             '<PackageURLParser pyramid.tests:%s at'
                 % os.path.join('fixtures', 'static')))
@@ -179,7 +179,7 @@ class TestPackageURLParser(unittest.TestCase):
         sr = DummyStartResponse()
         response = inst.not_found(environ, sr, 'debug_message')
         body = response[0]
-        self.failUnless('404 Not Found' in body)
+        self.assertTrue('404 Not Found' in body)
         self.assertEqual(sr.status, '404 Not Found')
 
 class Test_static_view(unittest.TestCase):
diff --git a/pyramid/tests/test_testing.py b/pyramid/tests/test_testing.py
index 99b0a1911..0c94a2803 100644
--- a/pyramid/tests/test_testing.py
+++ b/pyramid/tests/test_testing.py
@@ -27,7 +27,7 @@ class Test_registerDummySecurityPolicy(TestBase):
         from pyramid.interfaces import IAuthorizationPolicy
         ut = self.registry.getUtility(IAuthenticationPolicy)
         from pyramid.testing import DummySecurityPolicy
-        self.failUnless(isinstance(ut, DummySecurityPolicy))
+        self.assertTrue(isinstance(ut, DummySecurityPolicy))
         ut = self.registry.getUtility(IAuthorizationPolicy)
         self.assertEqual(ut.userid, 'user')
         self.assertEqual(ut.groupids, ('group1', 'group2'))
@@ -65,7 +65,7 @@ class Test_registerTemplateRenderer(TestBase):
         from pyramid import testing
         renderer = testing.registerTemplateRenderer('templates/foo')
         from pyramid.testing import DummyTemplateRenderer
-        self.failUnless(isinstance(renderer, DummyTemplateRenderer))
+        self.assertTrue(isinstance(renderer, DummyTemplateRenderer))
         from pyramid.renderers import render_to_response
         render_to_response('templates/foo', dict(foo=1, bar=2))
         renderer.assert_(foo=1)
@@ -116,7 +116,7 @@ class Test_registerView(TestBase):
         from pyramid import testing
         view = testing.registerView('moo.html')
         import types
-        self.failUnless(isinstance(view, types.FunctionType))
+        self.assertTrue(isinstance(view, types.FunctionType))
         from pyramid.view import render_view_to_response
         request = DummyRequest()
         request.registry = self.registry
@@ -127,7 +127,7 @@ class Test_registerView(TestBase):
         from pyramid import testing
         view = testing.registerView('moo.html', 'yo')
         import types
-        self.failUnless(isinstance(view, types.FunctionType))
+        self.assertTrue(isinstance(view, types.FunctionType))
         from pyramid.view import render_view_to_response
         request = DummyRequest()
         request.registry = self.registry
@@ -141,7 +141,7 @@ class Test_registerView(TestBase):
             return Response('123')
         view = testing.registerView('moo.html', view=view)
         import types
-        self.failUnless(isinstance(view, types.FunctionType))
+        self.assertTrue(isinstance(view, types.FunctionType))
         from pyramid.view import render_view_to_response
         request = DummyRequest()
         request.registry = self.registry
@@ -156,7 +156,7 @@ class Test_registerView(TestBase):
         view = testing.registerView('moo.html', view=view, permission='bar')
         testing.registerDummySecurityPolicy(permissive=False)
         import types
-        self.failUnless(isinstance(view, types.FunctionType))
+        self.assertTrue(isinstance(view, types.FunctionType))
         from pyramid.view import render_view_to_response
         request = DummyRequest()
         request.registry = self.registry
@@ -171,7 +171,7 @@ class Test_registerView(TestBase):
         view = testing.registerView('moo.html', view=view, permission='bar')
         testing.registerDummySecurityPolicy(permissive=False)
         import types
-        self.failUnless(isinstance(view, types.FunctionType))
+        self.assertTrue(isinstance(view, types.FunctionType))
         result = view_execution_permitted(None, None, 'moo.html')
         self.assertEqual(result, False)
 
@@ -183,7 +183,7 @@ class Test_registerView(TestBase):
         view = testing.registerView('moo.html', view=view, permission='bar')
         testing.registerDummySecurityPolicy(permissive=True)
         import types
-        self.failUnless(isinstance(view, types.FunctionType))
+        self.assertTrue(isinstance(view, types.FunctionType))
         from pyramid.view import render_view_to_response
         request = DummyRequest()
         request.registry = self.registry
@@ -355,9 +355,9 @@ class TestDummyResource(unittest.TestCase):
         self.assertEqual(resource['abc'], dummy)
         self.assertEqual(resource.get('abc'), dummy)
         self.assertRaises(KeyError, resource.__getitem__, 'none')
-        self.failUnless('abc' in resource)
+        self.assertTrue('abc' in resource)
         del resource['abc']
-        self.failIf('abc' in resource)
+        self.assertFalse('abc' in resource)
         self.assertEqual(resource.get('abc', 'foo'), 'foo')
         self.assertEqual(resource.get('abc'), None)
 
@@ -390,7 +390,7 @@ class TestDummyResource(unittest.TestCase):
 
     def test_ctor_with__provides__(self):
         resource = self._makeOne(__provides__=IDummy)
-        self.failUnless(IDummy.providedBy(resource))
+        self.assertTrue(IDummy.providedBy(resource))
 
 class TestDummyRequest(unittest.TestCase):
     def _getTargetClass(self):
@@ -498,10 +498,55 @@ class TestDummyRequest(unittest.TestCase):
             registry = Registry('this_test')
             config = Configurator(registry=registry)
             config.begin()
-            self.failUnless(request.registry is registry)
+            self.assertTrue(request.registry is registry)
         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.assertTrue(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.assertTrue(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.assertTrue(request.response is resp) # reified
+        
+
 class TestDummyTemplateRenderer(unittest.TestCase):
     def _getTargetClass(self, ):
         from pyramid.testing import DummyTemplateRenderer
@@ -528,7 +573,7 @@ class TestDummyTemplateRenderer(unittest.TestCase):
         renderer({'a':1, 'b':2})
         self.assertRaises(AssertionError, renderer.assert_, c=1)
         self.assertRaises(AssertionError, renderer.assert_, b=3)
-        self.failUnless(renderer.assert_(a=1, b=2))
+        self.assertTrue(renderer.assert_(a=1, b=2))
         
     def test_nondefault_string_response(self):
         renderer = self._makeOne('abc')
@@ -550,7 +595,7 @@ class Test_setUp(unittest.TestCase):
         try:
             config = self._callFUT()
             current = manager.get()
-            self.failIf(current is old)
+            self.assertFalse(current is old)
             self.assertEqual(config.registry, current['registry'])
             self.assertEqual(current['registry'].__class__, Registry)
             self.assertEqual(current['request'], None)
@@ -593,7 +638,7 @@ class Test_setUp(unittest.TestCase):
         try:
             self._callFUT(registry=registry, hook_zca=False)
             sm = getSiteManager()
-            self.failIf(sm is registry)
+            self.assertFalse(sm is registry)
         finally:
             getSiteManager.reset()
             manager.clear()
@@ -780,7 +825,7 @@ class TestDummySession(unittest.TestCase):
         session = self._makeOne()
         session['a'] = 1
         self.assertEqual(session.invalidate(), None)
-        self.failIf('a' in session)
+        self.assertFalse('a' in session)
 
     def test_flash_default(self):
         session = self._makeOne()
@@ -838,7 +883,7 @@ class TestDummySession(unittest.TestCase):
         session['_csrft_'] = 'token'
         token = session.get_csrf_token()
         self.assertEqual(token, 'token')
-        self.failUnless('_csrft_' in session)
+        self.assertTrue('_csrft_' in session)
 
 
 from zope.interface import Interface
diff --git a/pyramid/tests/test_urldispatch.py b/pyramid/tests/test_urldispatch.py
index a3579cdd5..6e1474b1d 100644
--- a/pyramid/tests/test_urldispatch.py
+++ b/pyramid/tests/test_urldispatch.py
@@ -21,8 +21,8 @@ class TestRoute(unittest.TestCase):
         self.assertEqual(route.path, ':path')
         self.assertEqual(route.name, 'name')
         self.assertEqual(route.factory, 'factory')
-        self.failUnless(route.generate.__class__ is types.FunctionType)
-        self.failUnless(route.match.__class__ is types.FunctionType)
+        self.assertTrue(route.generate.__class__ is types.FunctionType)
+        self.assertTrue(route.match.__class__ is types.FunctionType)
 
     def test_ctor_defaults(self):
         import types
@@ -31,8 +31,8 @@ class TestRoute(unittest.TestCase):
         self.assertEqual(route.path, ':path')
         self.assertEqual(route.name, 'name')
         self.assertEqual(route.factory, None)
-        self.failUnless(route.generate.__class__ is types.FunctionType)
-        self.failUnless(route.match.__class__ is types.FunctionType)
+        self.assertTrue(route.generate.__class__ is types.FunctionType)
+        self.assertTrue(route.match.__class__ is types.FunctionType)
 
     def test_match(self):
         route = self._makeOne('name', ':path')
diff --git a/pyramid/tests/test_view.py b/pyramid/tests/test_view.py
index 826fc4290..b1d48b98b 100644
--- a/pyramid/tests/test_view.py
+++ b/pyramid/tests/test_view.py
@@ -267,7 +267,7 @@ class TestViewConfigDecorator(unittest.TestCase):
         decorator.venusian = venusian
         def foo(): pass
         wrapped = decorator(foo)
-        self.failUnless(wrapped is foo)
+        self.assertTrue(wrapped is foo)
         settings = call_venusian(venusian)
         self.assertEqual(len(settings), 1)
         self.assertEqual(settings[0]['permission'], None)
@@ -281,7 +281,7 @@ class TestViewConfigDecorator(unittest.TestCase):
         decorator.venusian.info.scope = 'class'
         class foo(object): pass
         wrapped = decorator(foo)
-        self.failUnless(wrapped is foo)
+        self.assertTrue(wrapped is foo)
         settings = call_venusian(venusian)
         self.assertEqual(len(settings), 1)
         self.assertEqual(settings[0]['permission'], None)
@@ -296,7 +296,7 @@ class TestViewConfigDecorator(unittest.TestCase):
         decorator.venusian.info.scope = 'class'
         class foo(object): pass
         wrapped = decorator(foo)
-        self.failUnless(wrapped is foo)
+        self.assertTrue(wrapped is foo)
         settings = call_venusian(venusian)
         self.assertEqual(len(settings), 1)
         self.assertEqual(settings[0]['permission'], None)
@@ -314,8 +314,8 @@ class TestViewConfigDecorator(unittest.TestCase):
         def foo(): pass
         wrapped1 = decorator1(foo)
         wrapped2 = decorator2(wrapped1)
-        self.failUnless(wrapped1 is foo)
-        self.failUnless(wrapped2 is foo)
+        self.assertTrue(wrapped1 is foo)
+        self.assertTrue(wrapped2 is foo)
         settings1 = call_venusian(venusian1)
         self.assertEqual(len(settings1), 1)
         self.assertEqual(settings1[0]['name'], '1')
@@ -344,7 +344,7 @@ class TestViewConfigDecorator(unittest.TestCase):
         decorator.venusian = venusian
         def foo(context, request): pass
         decorated = decorator(foo)
-        self.failUnless(decorated is foo)
+        self.assertTrue(decorated is foo)
         settings = call_venusian(venusian)
         self.assertEqual(settings[0]['custom_predicates'], (1,))
 
@@ -355,7 +355,7 @@ class TestViewConfigDecorator(unittest.TestCase):
         decorator.venusian = venusian
         def foo(): pass
         wrapped = decorator(foo)
-        self.failUnless(wrapped is foo)
+        self.assertTrue(wrapped is foo)
         settings = call_venusian(venusian)
         self.assertEqual(len(settings), 1)
         renderer = settings[0]['renderer']
@@ -369,7 +369,7 @@ class TestViewConfigDecorator(unittest.TestCase):
         decorator.venusian = venusian
         def foo(): pass
         wrapped = decorator(foo)
-        self.failUnless(wrapped is foo)
+        self.assertTrue(wrapped is foo)
         settings = call_venusian(venusian)
         self.assertEqual(len(settings), 1)
         self.assertEqual(settings[0]['renderer'], {'a':1})
@@ -477,20 +477,20 @@ class Test_default_exceptionresponse_view(unittest.TestCase):
     def test_is_exception(self):
         context = Exception()
         result = self._callFUT(context, None)
-        self.failUnless(result is context)
+        self.assertTrue(result is context)
 
     def test_is_not_exception_context_is_false_still_chose(self):
         request = DummyRequest()
         request.exception = 0
         result = self._callFUT(None, request)
-        self.failUnless(result is None)
+        self.assertTrue(result is None)
 
     def test_is_not_exception_no_request_exception(self):
         context = object()
         request = DummyRequest()
         request.exception = None
         result = self._callFUT(context, request)
-        self.failUnless(result is context)
+        self.assertTrue(result is context)
 
     def test_is_not_exception_request_exception(self):
         context = object()
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
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