test_descriptors.py convert to assert from nose/unittest

1 files changed, 144 insertions, 137 deletions

diff --git a/tests/test_descriptors.py b/tests/test_descriptors.py
index eb3d316..0bfb7e6 100644
--- a/tests/test_descriptors.py
+++ b/tests/test_descriptors.py
@@ -1,5 +1,7 @@
-# -*- coding: utf-8 -*-
-import unittest
+from datetime import tzinfo
+from datetime import timedelta
+
+import pytest
 
 from webob.compat import (
     PY3,
@@ -7,16 +9,8 @@ from webob.compat import (
     native_,
     )
 
-from datetime import tzinfo
-from datetime import timedelta
-
-from nose.tools import eq_
-from nose.tools import ok_
-from nose.tools import assert_raises
-
 from webob.request import Request
 
-
 class GMT(tzinfo):
     """UTC"""
     ZERO = timedelta(0)
@@ -43,38 +37,39 @@ class MockDescriptor:
 def test_environ_getter_docstring():
     from webob.descriptors import environ_getter
     desc = environ_getter('akey')
-    eq_(desc.__doc__, "Gets and sets the ``akey`` key in the environment.")
+    assert desc.__doc__ == "Gets and sets the ``akey`` key in the environment."
 
 def test_environ_getter_nodefault_keyerror():
     from webob.descriptors import environ_getter
     req = Request.blank('/')
     desc = environ_getter('akey')
-    assert_raises(KeyError, desc.fget, req)
+    with pytest.raises(KeyError):
+        desc.fget(req)
 
 def test_environ_getter_nodefault_fget():
     from webob.descriptors import environ_getter
     req = Request.blank('/')
     desc = environ_getter('akey')
     desc.fset(req, 'bar')
-    eq_(req.environ['akey'], 'bar')
+    assert req.environ['akey'] == 'bar'
 
 def test_environ_getter_nodefault_fdel():
     from webob.descriptors import environ_getter
     desc = environ_getter('akey')
-    eq_(desc.fdel, None)
+    assert desc.fdel == None
 
 def test_environ_getter_default_fget():
     from webob.descriptors import environ_getter
     req = Request.blank('/')
     desc = environ_getter('akey', default='the_default')
-    eq_(desc.fget(req), 'the_default')
+    assert desc.fget(req) == 'the_default'
 
 def test_environ_getter_default_fset():
     from webob.descriptors import environ_getter
     req = Request.blank('/')
     desc = environ_getter('akey', default='the_default')
     desc.fset(req, 'bar')
-    eq_(req.environ['akey'], 'bar')
+    assert req.environ['akey'] == 'bar'
 
 def test_environ_getter_default_fset_none():
     from webob.descriptors import environ_getter
@@ -82,7 +77,7 @@ def test_environ_getter_default_fset_none():
     desc = environ_getter('akey', default='the_default')
     desc.fset(req, 'baz')
     desc.fset(req, None)
-    ok_('akey' not in req.environ)
+    assert 'akey' not in req.environ
 
 def test_environ_getter_default_fdel():
     from webob.descriptors import environ_getter
@@ -91,29 +86,28 @@ def test_environ_getter_default_fdel():
     desc.fset(req, 'baz')
     assert 'akey' in req.environ
     desc.fdel(req)
-    ok_('akey' not in req.environ)
+    assert 'akey' not in req.environ
 
 def test_environ_getter_rfc_section():
     from webob.descriptors import environ_getter
     desc = environ_getter('HTTP_X_AKEY', rfc_section='14.3')
-    eq_(desc.__doc__, "Gets and sets the ``X-Akey`` header "
-        "(`HTTP spec section 14.3 "
+    assert desc.__doc__ == "Gets and sets the ``X-Akey`` header "\
+        "(`HTTP spec section 14.3 "\
         "<http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3>`_)."
-    )
 
 
 def test_upath_property_fget():
     from webob.descriptors import upath_property
     req = Request.blank('/')
     desc = upath_property('akey')
-    eq_(desc.fget(req), '')
+    assert desc.fget(req) == ''
 
 def test_upath_property_fset():
     from webob.descriptors import upath_property
     req = Request.blank('/')
     desc = upath_property('akey')
     desc.fset(req, 'avalue')
-    eq_(desc.fget(req), 'avalue')
+    assert desc.fget(req) == 'avalue'
 
 def test_header_getter_doc():
     from webob.descriptors import header_getter
@@ -127,7 +121,7 @@ def test_header_getter_fget():
     from webob import Response
     resp = Response('aresp')
     desc = header_getter('AHEADER', '14.3')
-    eq_(desc.fget(resp), None)
+    assert desc.fget(resp) == None
 
 def test_header_getter_fset():
     from webob.descriptors import header_getter
@@ -135,7 +129,7 @@ def test_header_getter_fset():
     resp = Response('aresp')
     desc = header_getter('AHEADER', '14.3')
     desc.fset(resp, 'avalue')
-    eq_(desc.fget(resp), 'avalue')
+    assert desc.fget(resp) == 'avalue'
 
 def test_header_getter_fset_none():
     from webob.descriptors import header_getter
@@ -144,7 +138,7 @@ def test_header_getter_fset_none():
     desc = header_getter('AHEADER', '14.3')
     desc.fset(resp, 'avalue')
     desc.fset(resp, None)
-    eq_(desc.fget(resp), None)
+    assert desc.fget(resp) == None
 
 def test_header_getter_fset_text():
     from webob.compat import text_
@@ -153,7 +147,7 @@ def test_header_getter_fset_text():
     resp = Response('aresp')
     desc = header_getter('AHEADER', '14.3')
     desc.fset(resp, text_('avalue'))
-    eq_(desc.fget(resp), 'avalue')
+    assert desc.fget(resp) == 'avalue'
 
 def test_header_getter_fset_text_control_chars():
     from webob.compat import text_
@@ -161,7 +155,8 @@ def test_header_getter_fset_text_control_chars():
     from webob import Response
     resp = Response('aresp')
     desc = header_getter('AHEADER', '14.3')
-    assert_raises(ValueError, desc.fset, resp, text_('\n'))
+    with pytest.raises(ValueError):
+        desc.fset(resp, text_('\n'))
 
 def test_header_getter_fdel():
     from webob.descriptors import header_getter
@@ -170,14 +165,14 @@ def test_header_getter_fdel():
     desc = header_getter('AHEADER', '14.3')
     desc.fset(resp, 'avalue2')
     desc.fdel(resp)
-    eq_(desc.fget(resp), None)
+    assert desc.fget(resp) == None
 
 def test_header_getter_unicode_fget_none():
     from webob.descriptors import header_getter
     from webob import Response
     resp = Response('aresp')
     desc = header_getter('AHEADER', '14.3')
-    eq_(desc.fget(resp), None)
+    assert desc.fget(resp) == None
 
 def test_header_getter_unicode_fget():
     from webob.descriptors import header_getter
@@ -185,7 +180,7 @@ def test_header_getter_unicode_fget():
     resp = Response('aresp')
     desc = header_getter('AHEADER', '14.3')
     desc.fset(resp, 'avalue')
-    eq_(desc.fget(resp), 'avalue')
+    assert desc.fget(resp) == 'avalue'
 
 def test_header_getter_unicode_fset_none():
     from webob.descriptors import header_getter
@@ -193,7 +188,7 @@ def test_header_getter_unicode_fset_none():
     resp = Response('aresp')
     desc = header_getter('AHEADER', '14.3')
     desc.fset(resp, None)
-    eq_(desc.fget(resp), None)
+    assert desc.fget(resp) == None
 
 def test_header_getter_unicode_fset():
     from webob.descriptors import header_getter
@@ -201,7 +196,7 @@ def test_header_getter_unicode_fset():
     resp = Response('aresp')
     desc = header_getter('AHEADER', '14.3')
     desc.fset(resp, 'avalue2')
-    eq_(desc.fget(resp), 'avalue2')
+    assert desc.fget(resp) == 'avalue2'
 
 def test_header_getter_unicode_fdel():
     from webob.descriptors import header_getter
@@ -210,15 +205,17 @@ def test_header_getter_unicode_fdel():
     desc = header_getter('AHEADER', '14.3')
     desc.fset(resp, 'avalue3')
     desc.fdel(resp)
-    eq_(desc.fget(resp), None)
+    assert desc.fget(resp) == None
 
 def test_converter_not_prop():
     from webob.descriptors import converter
     from webob.descriptors import parse_int_safe
     from webob.descriptors import serialize_int
-    assert_raises(AssertionError,converter,
-        ('CONTENT_LENGTH', None, '14.13'),
-        parse_int_safe, serialize_int, 'int')
+    with pytest.raises(AssertionError):
+        converter(
+            ('CONTENT_LENGTH', None, '14.13'),
+            parse_int_safe, serialize_int,
+            'int')
 
 def test_converter_with_name_docstring():
     from webob.descriptors import converter
@@ -241,7 +238,7 @@ def test_converter_with_name_fget():
     desc = converter(
         environ_getter('CONTENT_LENGTH', '666', '14.13'),
         parse_int_safe, serialize_int, 'int')
-    eq_(desc.fget(req), 666)
+    assert desc.fget(req) == 666
 
 def test_converter_with_name_fset():
     from webob.descriptors import converter
@@ -253,7 +250,7 @@ def test_converter_with_name_fset():
         environ_getter('CONTENT_LENGTH', '666', '14.13'),
         parse_int_safe, serialize_int, 'int')
     desc.fset(req, '999')
-    eq_(desc.fget(req), 999)
+    assert desc.fget(req) == 999
 
 def test_converter_without_name_fget():
     from webob.descriptors import converter
@@ -264,7 +261,7 @@ def test_converter_without_name_fget():
     desc = converter(
         environ_getter('CONTENT_LENGTH', '666', '14.13'),
         parse_int_safe, serialize_int)
-    eq_(desc.fget(req), 666)
+    assert desc.fget(req) == 666
 
 def test_converter_without_name_fset():
     from webob.descriptors import converter
@@ -276,7 +273,7 @@ def test_converter_without_name_fset():
         environ_getter('CONTENT_LENGTH', '666', '14.13'),
         parse_int_safe, serialize_int)
     desc.fset(req, '999')
-    eq_(desc.fget(req), 999)
+    assert desc.fget(req) == 999
 
 def test_converter_none_for_wrong_type():
     from webob.descriptors import converter
@@ -288,7 +285,7 @@ def test_converter_none_for_wrong_type():
         ## XXX: Should this fail  if the type is wrong?
         environ_getter('CONTENT_LENGTH', 'sixsixsix', '14.13'),
         parse_int_safe, serialize_int, 'int')
-    eq_(desc.fget(req), None)
+    assert desc.fget(req) == None
 
 def test_converter_delete():
     from webob.descriptors import converter
@@ -300,52 +297,53 @@ def test_converter_delete():
         ## XXX: Should this fail  if the type is wrong?
         environ_getter('CONTENT_LENGTH', '666', '14.13'),
         parse_int_safe, serialize_int, 'int')
-    assert_raises(KeyError, desc.fdel, req)
+    with pytest.raises(KeyError):
+        desc.fdel(req)
 
 def test_list_header():
     from webob.descriptors import list_header
     desc = list_header('CONTENT_LENGTH', '14.13')
-    eq_(type(desc), property)
+    assert type(desc) == property
 
 def test_parse_list_single():
     from webob.descriptors import parse_list
     result = parse_list('avalue')
-    eq_(result, ('avalue',))
+    assert result == ('avalue',)
 
 def test_parse_list_multiple():
     from webob.descriptors import parse_list
     result = parse_list('avalue,avalue2')
-    eq_(result, ('avalue', 'avalue2'))
+    assert result == ('avalue', 'avalue2')
 
 def test_parse_list_none():
     from webob.descriptors import parse_list
     result = parse_list(None)
-    eq_(result, None)
+    assert result == None
 
 def test_parse_list_unicode_single():
     from webob.descriptors import parse_list
     result = parse_list('avalue')
-    eq_(result, ('avalue',))
+    assert result == ('avalue',)
 
 def test_parse_list_unicode_multiple():
     from webob.descriptors import parse_list
     result = parse_list('avalue,avalue2')
-    eq_(result, ('avalue', 'avalue2'))
+    assert result == ('avalue', 'avalue2')
 
 def test_serialize_list():
     from webob.descriptors import serialize_list
     result = serialize_list(('avalue', 'avalue2'))
-    eq_(result, 'avalue, avalue2')
+    assert result == 'avalue, avalue2'
 
 def test_serialize_list_string():
     from webob.descriptors import serialize_list
     result = serialize_list('avalue')
-    eq_(result, 'avalue')
+    assert result == 'avalue'
 
 def test_serialize_list_unicode():
     from webob.descriptors import serialize_list
     result = serialize_list('avalue')
-    eq_(result, 'avalue')
+    assert result == 'avalue'
 
 def test_converter_date():
     import datetime
@@ -355,8 +353,7 @@ def test_converter_date():
     UTC = GMT()
     desc = converter_date(environ_getter(
         "HTTP_DATE", "Tue, 15 Nov 1994 08:12:31 GMT", "14.8"))
-    eq_(desc.fget(req),
-        datetime.datetime(1994, 11, 15, 8, 12, 31, tzinfo=UTC))
+    assert desc.fget(req) == datetime.datetime(1994, 11, 15, 8, 12, 31, tzinfo=UTC)
 
 def test_converter_date_docstring():
     from webob.descriptors import converter_date
@@ -372,7 +369,7 @@ def test_date_header_fget_none():
     from webob.descriptors import date_header
     resp = Response('aresponse')
     desc = date_header('HTTP_DATE', "14.8")
-    eq_(desc.fget(resp), None)
+    assert desc.fget(resp) == None
 
 def test_date_header_fset_fget():
     import datetime
@@ -382,7 +379,7 @@ def test_date_header_fset_fget():
     UTC = GMT()
     desc = date_header('HTTP_DATE', "14.8")
     desc.fset(resp, "Tue, 15 Nov 1994 08:12:31 GMT")
-    eq_(desc.fget(resp), datetime.datetime(1994, 11, 15, 8, 12, 31, tzinfo=UTC))
+    assert desc.fget(resp) == datetime.datetime(1994, 11, 15, 8, 12, 31, tzinfo=UTC)
 
 def test_date_header_fdel():
     from webob import Response
@@ -391,7 +388,7 @@ def test_date_header_fdel():
     desc = date_header('HTTP_DATE', "14.8")
     desc.fset(resp, "Tue, 15 Nov 1994 08:12:31 GMT")
     desc.fdel(resp)
-    eq_(desc.fget(resp), None)
+    assert desc.fget(resp) == None
 
 def test_deprecated_property():
     from webob.descriptors import deprecated_property
@@ -399,112 +396,116 @@ def test_deprecated_property():
         pass
     Foo.attr = deprecated_property('attr', 'attr', 'whatever', '1.2')
     foo = Foo()
-    assert_raises(DeprecationWarning, getattr, foo, 'attr')
-    assert_raises(DeprecationWarning, setattr, foo, 'attr', {})
-    assert_raises(DeprecationWarning, delattr, foo, 'attr')
+    with pytest.raises(DeprecationWarning):
+        getattr(foo, 'attr')
+    with pytest.raises(DeprecationWarning):
+        setattr(foo, 'attr', {})
+    with pytest.raises(DeprecationWarning):
+        delattr(foo, 'attr')
 
 def test_parse_etag_response():
     from webob.descriptors import parse_etag_response
     etresp = parse_etag_response("etag")
-    eq_(etresp, "etag")
+    assert etresp == "etag"
 
 def test_parse_etag_response_quoted():
     from webob.descriptors import parse_etag_response
     etresp = parse_etag_response('"etag"')
-    eq_(etresp, "etag")
+    assert etresp == "etag"
 
 def test_parse_etag_response_is_none():
     from webob.descriptors import parse_etag_response
     etresp = parse_etag_response(None)
-    eq_(etresp, None)
+    assert etresp == None
 
 def test_serialize_etag_response():
     from webob.descriptors import serialize_etag_response
     etresp = serialize_etag_response("etag")
-    eq_(etresp, '"etag"')
+    assert etresp == '"etag"'
 
 def test_serialize_if_range_string():
     from webob.descriptors import serialize_if_range
     val = serialize_if_range("avalue")
-    eq_(val, "avalue")
+    assert val == "avalue"
 
 def test_serialize_if_range_unicode():
     from webob.descriptors import serialize_if_range
     val = serialize_if_range("avalue")
-    eq_(val, "avalue")
+    assert val == "avalue"
 
 def test_serialize_if_range_datetime():
     import datetime
     from webob.descriptors import serialize_if_range
     UTC = GMT()
     val = serialize_if_range(datetime.datetime(1994, 11, 15, 8, 12, 31, tzinfo=UTC))
-    eq_(val, "Tue, 15 Nov 1994 08:12:31 GMT")
+    assert val, "Tue == 15 Nov 1994 08:12:31 GMT"
 
 def test_serialize_if_range_other():
     from webob.descriptors import serialize_if_range
     val = serialize_if_range(123456)
-    eq_(val, '123456')
+    assert val == '123456'
 
 def test_parse_range_none():
     from webob.descriptors import parse_range
-    eq_(parse_range(None), None)
+    assert parse_range(None) == None
 
 def test_parse_range_type():
     from webob.byterange import Range
     from webob.descriptors import parse_range
     val = parse_range("bytes=1-500")
-    eq_(type(val), type(Range.parse("bytes=1-500")))
+    assert type(val) == type(Range.parse("bytes=1-500"))
 
 def test_parse_range_values():
     from webob.byterange import Range
     range = Range.parse("bytes=1-500")
-    eq_(range.start, 1)
-    eq_(range.end, 501)
+    assert range.start == 1
+    assert range.end == 501
 
 def test_serialize_range_none():
     from webob.descriptors import serialize_range
     val = serialize_range(None)
-    eq_(val, None)
+    assert val == None
 
 def test_serialize_range():
     from webob.descriptors import serialize_range
     val = serialize_range((1,500))
-    eq_(val, 'bytes=1-499')
+    assert val == 'bytes=1-499'
 
 def test_parse_int_none():
     from webob.descriptors import parse_int
     val = parse_int(None)
-    eq_(val, None)
+    assert val == None
 
 def test_parse_int_emptystr():
     from webob.descriptors import parse_int
     val = parse_int('')
-    eq_(val, None)
+    assert val == None
 
 def test_parse_int():
     from webob.descriptors import parse_int
     val = parse_int('123')
-    eq_(val, 123)
+    assert val == 123
 
 def test_parse_int_invalid():
     from webob.descriptors import parse_int
-    assert_raises(ValueError, parse_int, 'abc')
+    with pytest.raises(ValueError):
+        parse_int('abc')
 
 def test_parse_int_safe_none():
     from webob.descriptors import parse_int_safe
-    eq_(parse_int_safe(None), None)
+    assert parse_int_safe(None) == None
 
 def test_parse_int_safe_emptystr():
     from webob.descriptors import parse_int_safe
-    eq_(parse_int_safe(''), None)
+    assert parse_int_safe('') == None
 
 def test_parse_int_safe():
     from webob.descriptors import parse_int_safe
-    eq_(parse_int_safe('123'), 123)
+    assert parse_int_safe('123') == 123
 
 def test_parse_int_safe_invalid():
     from webob.descriptors import parse_int_safe
-    eq_(parse_int_safe('abc'), None)
+    assert parse_int_safe('abc') == None
 
 def test_serialize_int():
     from webob.descriptors import serialize_int
@@ -512,82 +513,87 @@ def test_serialize_int():
 
 def test_parse_content_range_none():
     from webob.descriptors import parse_content_range
-    eq_(parse_content_range(None), None)
+    assert parse_content_range(None) == None
 
 def test_parse_content_range_emptystr():
     from webob.descriptors import parse_content_range
-    eq_(parse_content_range(' '), None)
+    assert parse_content_range(' ') == None
 
 def test_parse_content_range_length():
     from webob.byterange import ContentRange
     from webob.descriptors import parse_content_range
     val = parse_content_range("bytes 0-499/1234")
-    eq_(val.length, ContentRange.parse("bytes 0-499/1234").length)
+    assert val.length == ContentRange.parse("bytes 0-499/1234").length
 
 def test_parse_content_range_start():
     from webob.byterange import ContentRange
     from webob.descriptors import parse_content_range
     val = parse_content_range("bytes 0-499/1234")
-    eq_(val.start, ContentRange.parse("bytes 0-499/1234").start)
+    assert val.start == ContentRange.parse("bytes 0-499/1234").start
 
 def test_parse_content_range_stop():
     from webob.byterange import ContentRange
     from webob.descriptors import parse_content_range
     val = parse_content_range("bytes 0-499/1234")
-    eq_(val.stop, ContentRange.parse("bytes 0-499/1234").stop)
+    assert val.stop == ContentRange.parse("bytes 0-499/1234").stop
 
 def test_serialize_content_range_none():
     from webob.descriptors import serialize_content_range
-    eq_(serialize_content_range(None), 'None') ### XXX: Seems wrong
+    assert serialize_content_range(None) == 'None' ### XXX: Seems wrong
 
 def test_serialize_content_range_emptystr():
     from webob.descriptors import serialize_content_range
-    eq_(serialize_content_range(''), None)
+    assert serialize_content_range('') == None
 
 def test_serialize_content_range_invalid():
     from webob.descriptors import serialize_content_range
-    assert_raises(ValueError, serialize_content_range, (1,))
+    with pytest.raises(ValueError):
+        serialize_content_range((1,))
 
 def test_serialize_content_range_asterisk():
     from webob.descriptors import serialize_content_range
-    eq_(serialize_content_range((0, 500)), 'bytes 0-499/*')
+    assert serialize_content_range((0, 500)) == 'bytes 0-499/*'
 
 def test_serialize_content_range_defined():
     from webob.descriptors import serialize_content_range
-    eq_(serialize_content_range((0, 500, 1234)), 'bytes 0-499/1234')
+    assert serialize_content_range((0, 500, 1234)) == 'bytes 0-499/1234'
 
 def test_parse_auth_params_leading_capital_letter():
     from webob.descriptors import parse_auth_params
     val = parse_auth_params('Basic Realm=WebOb')
-    eq_(val, {'ealm': 'WebOb'})
+    assert val == {'ealm': 'WebOb'}
 
 def test_parse_auth_params_trailing_capital_letter():
     from webob.descriptors import parse_auth_params
     val = parse_auth_params('Basic realM=WebOb')
-    eq_(val, {})
+    assert val == {}
 
 def test_parse_auth_params_doublequotes():
     from webob.descriptors import parse_auth_params
     val = parse_auth_params('Basic realm="Web Object"')
-    eq_(val, {'realm': 'Web Object'})
+    assert val == {'realm': 'Web Object'}
 
 def test_parse_auth_params_multiple_values():
     from webob.descriptors import parse_auth_params
     val = parse_auth_params("foo='blah &&234', qop=foo, nonce='qwerty1234'")
-    eq_(val, {'nonce': "'qwerty1234'", 'foo': "'blah &&234'", 'qop': 'foo'})
+    assert val == {'nonce': "'qwerty1234'", 'foo': "'blah &&234'", 'qop': 'foo'}
 
 def test_parse_auth_params_truncate_on_comma():
     from webob.descriptors import parse_auth_params
     val = parse_auth_params("Basic realm=WebOb,this_will_truncate")
-    eq_(val, {'realm': 'WebOb'})
+    assert val == {'realm': 'WebOb'}
 
 def test_parse_auth_params_emptystr():
     from webob.descriptors import parse_auth_params
-    eq_(parse_auth_params(''), {})
-    
+    assert parse_auth_params('') == {}
+
 def test_parse_auth_params_bad_whitespace():
     from webob.descriptors import parse_auth_params
-    eq_(parse_auth_params('a= "2 ", b =3, c=4 '), {'a': '2 ', 'b': '3', 'c': '4'})
+    assert parse_auth_params('a= "2 ", b =3, c=4 ') == {
+        'a': '2 ',
+        'b': '3',
+        'c': '4'
+    }
 
 def test_authorization2():
     from webob.descriptors import parse_auth_params
@@ -600,60 +606,65 @@ def test_authorization2():
             ('x="y", z=z', {'x': 'y', 'z': 'z'}),
             ('x="y,x", z=z', {'x': 'y,x', 'z': 'z'}),
             ]:
-        eq_(parse_auth_params(s), d)
+        assert parse_auth_params(s) == d
 
 def test_parse_auth_none():
     from webob.descriptors import parse_auth
-    eq_(parse_auth(None), None)
+    assert parse_auth(None) is None
 
 def test_parse_auth_emptystr():
     from webob.descriptors import parse_auth
-    assert_raises(ValueError, parse_auth, '')
+    with pytest.raises(ValueError):
+        parse_auth('')
 
 def test_parse_auth_basic():
     from webob.descriptors import parse_auth
-    eq_(parse_auth("Basic realm=WebOb"), ('Basic', 'realm=WebOb'))
+    assert parse_auth("Basic realm=WebOb") == ('Basic', 'realm=WebOb')
 
 def test_parse_auth_basic_quoted():
     from webob.descriptors import parse_auth
-    eq_(parse_auth('Basic realm="Web Ob"'), ('Basic', {'realm': 'Web Ob'}))
+    assert parse_auth('Basic realm="Web Ob"') == ('Basic', {'realm': 'Web Ob'})
 
 def test_parse_auth_basic_quoted_multiple_unknown():
     from webob.descriptors import parse_auth
-    eq_(parse_auth("foo='blah &&234', qop=foo, nonce='qwerty1234'"),
-        ("foo='blah", "&&234', qop=foo, nonce='qwerty1234'"))
+    assert parse_auth("foo='blah &&234', qop=foo, nonce='qwerty1234'") == (
+        "foo='blah",
+        "&&234', qop=foo, nonce='qwerty1234'"
+    )
 
 def test_parse_auth_basic_quoted_known_multiple():
     from webob.descriptors import parse_auth
-    eq_(parse_auth("Basic realm='blah &&234', qop=foo, nonce='qwerty1234'"),
-        ('Basic', "realm='blah &&234', qop=foo, nonce='qwerty1234'"))
+    assert parse_auth("Basic realm='blah &&234', qop=foo, nonce='qwerty1234'") == (
+        'Basic',
+        "realm='blah &&234', qop=foo, nonce='qwerty1234'"
+    )
 
 def test_serialize_auth_none():
     from webob.descriptors import serialize_auth
-    eq_(serialize_auth(None), None)
+    assert serialize_auth(None) is None
 
 def test_serialize_auth_emptystr():
     from webob.descriptors import serialize_auth
-    eq_(serialize_auth(''), '')
+    assert serialize_auth('') == ''
 
 def test_serialize_auth_basic_quoted():
     from webob.descriptors import serialize_auth
     val = serialize_auth(('Basic', 'realm="WebOb"'))
-    eq_(val, 'Basic realm="WebOb"')
+    assert val == 'Basic realm="WebOb"'
 
 def test_serialize_auth_digest_multiple():
     from webob.descriptors import serialize_auth
     val = serialize_auth(('Digest', 'realm="WebOb", nonce=abcde12345, qop=foo'))
     flags = val[len('Digest'):]
     result = sorted([ x.strip() for x in flags.split(',') ])
-    eq_(result, ['nonce=abcde12345', 'qop=foo', 'realm="WebOb"'])
+    assert result == ['nonce=abcde12345', 'qop=foo', 'realm="WebOb"']
 
 def test_serialize_auth_digest_tuple():
     from webob.descriptors import serialize_auth
     val = serialize_auth(('Digest', {'realm':'"WebOb"', 'nonce':'abcde12345', 'qop':'foo'}))
     flags = val[len('Digest'):]
     result = sorted([ x.strip() for x in flags.split(',') ])
-    eq_(result, ['nonce="abcde12345"', 'qop="foo"', 'realm=""WebOb""'])
+    assert result == ['nonce="abcde12345"', 'qop="foo"', 'realm=""WebOb""']
 
 
 _nodefault = object()
@@ -671,71 +682,67 @@ class _TestEnvironDecoder(object):
 
     def test_docstring(self):
         desc = self._callFUT('akey')
-        self.assertEqual(desc.__doc__,
-                         "Gets and sets the ``akey`` key in the environment.")
+        assert desc.__doc__ == "Gets and sets the ``akey`` key in the environment."
 
     def test_nodefault_keyerror(self):
         req = self._makeRequest()
         desc = self._callFUT('akey')
-        self.assertRaises(KeyError, desc.fget, req)
+        with pytest.raises(KeyError):
+            desc.fget(req)
 
     def test_nodefault_fget(self):
         req = self._makeRequest()
         desc = self._callFUT('akey')
         desc.fset(req, 'bar')
-        self.assertEqual(req.environ['akey'], 'bar')
+        assert req.environ['akey'] == 'bar'
 
     def test_nodefault_fdel(self):
         desc = self._callFUT('akey')
-        self.assertEqual(desc.fdel, None)
+        assert desc.fdel == None
 
     def test_default_fget(self):
         req = self._makeRequest()
         desc = self._callFUT('akey', default='the_default')
-        self.assertEqual(desc.fget(req), 'the_default')
+        assert desc.fget(req) == 'the_default'
 
     def test_default_fset(self):
         req = self._makeRequest()
         desc = self._callFUT('akey', default='the_default')
         desc.fset(req, 'bar')
-        self.assertEqual(req.environ['akey'], 'bar')
+        assert req.environ['akey'] == 'bar'
 
     def test_default_fset_none(self):
         req = self._makeRequest()
         desc = self._callFUT('akey', default='the_default')
         desc.fset(req, 'baz')
         desc.fset(req, None)
-        self.assertTrue('akey' not in req.environ)
+        assert 'akey' not in req.environ
 
     def test_default_fdel(self):
         req = self._makeRequest()
         desc = self._callFUT('akey', default='the_default')
         desc.fset(req, 'baz')
-        self.assertTrue('akey' in req.environ)
+        assert 'akey' in req.environ
         desc.fdel(req)
-        self.assertTrue('akey' not in req.environ)
+        assert 'akey' not in req.environ
 
     def test_rfc_section(self):
         desc = self._callFUT('HTTP_X_AKEY', rfc_section='14.3')
-        self.assertEqual(
-            desc.__doc__,
-            "Gets and sets the ``X-Akey`` header "
-            "(`HTTP spec section 14.3 "
+        assert desc.__doc__ == "Gets and sets the ``X-Akey`` header "\
+            "(`HTTP spec section 14.3 "\
             "<http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3>`_)."
-        )
 
     def test_fset_nonascii(self):
         desc = self._callFUT('HTTP_X_AKEY', encattr='url_encoding')
         req = self._makeRequest()
         desc.fset(req, text_(b'\xc3\xab', 'utf-8'))
         if PY3:
-            self.assertEqual(req.environ['HTTP_X_AKEY'],
-                             b'\xc3\xab'.decode('latin-1'))
+            assert req.environ['HTTP_X_AKEY'] == b'\xc3\xab'.decode('latin-1')
         else:
-            self.assertEqual(req.environ['HTTP_X_AKEY'], b'\xc3\xab')
+            assert req.environ['HTTP_X_AKEY'] == b'\xc3\xab'
 
 
-class TestEnvironDecoder(unittest.TestCase, _TestEnvironDecoder):
+class TestEnvironDecoder(_TestEnvironDecoder):
     def _makeRequest(self):
         from webob.request import BaseRequest
         req = BaseRequest.blank('/')
@@ -749,9 +756,9 @@ class TestEnvironDecoder(unittest.TestCase, _TestEnvironDecoder):
         else:
             req.environ['HTTP_X_AKEY'] = b'\xc3\xab'
         result = desc.fget(req)
-        self.assertEqual(result, text_(b'\xc3\xab', 'utf-8'))
+        assert result == text_(b'\xc3\xab', 'utf-8')
 
-class TestEnvironDecoderLegacy(unittest.TestCase, _TestEnvironDecoder):
+class TestEnvironDecoderLegacy(_TestEnvironDecoder):
     def _makeRequest(self):
         from webob.request import LegacyRequest
         req = LegacyRequest.blank('/')
@@ -765,9 +772,9 @@ class TestEnvironDecoderLegacy(unittest.TestCase, _TestEnvironDecoder):
         else:
             req.environ['HTTP_X_AKEY'] = b'\xc3\xab'
         result = desc.fget(req)
-        self.assertEqual(result, native_(b'\xc3\xab', 'latin-1'))
+        assert result == native_(b'\xc3\xab', 'latin-1')
 
     def test_default_fget_nonascii(self):
         req = self._makeRequest()
         desc = self._callFUT('akey', default=b'the_default')
-        self.assertEqual(desc.fget(req).__class__, bytes)
+        assert desc.fget(req).__class__ == bytes