openstack/deb-python-falcon
Code Issues Proposed changes

fix(tests): Use assertEqual instead of the deprecated assertEquals method

Browse Source
This commit is contained in:
kgriffs
2013-12-31 17:12:38 -06:00
parent 6963f627a1
commit 9eba0344ca
12 changed files with 180 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
falcon/tests/test_default_routing.py
View File

@@ -27,26 +27,26 @@ class TestDefaultRouting(testing.TestBase):
self.api.set_default_route(self.default_resource)
self.simulate_request('/')
self.assertEquals(self.srmock.status, falcon.HTTP_200)
self.assertEqual(self.srmock.status, falcon.HTTP_200)
self.simulate_request('/any')
self.assertEquals(self.srmock.status, falcon.HTTP_200)
self.assertEqual(self.srmock.status, falcon.HTTP_200)
def test_routing_prioritise(self):
self.api.set_default_route(self.default_resource)
self.api.add_route('/people/{name}', self.resource)
self.simulate_request('/people/asuka')
self.assertEquals(self.srmock.status, falcon.HTTP_402)
self.assertEqual(self.srmock.status, falcon.HTTP_402)
self.simulate_request('/person/asuka')
self.assertEquals(self.srmock.status, falcon.HTTP_200)
self.assertEqual(self.srmock.status, falcon.HTTP_200)
self.simulate_request('/people/asuka', method='DELETE')
self.assertEquals(self.srmock.status, falcon.HTTP_204)
self.assertEqual(self.srmock.status, falcon.HTTP_204)
self.simulate_request('/person/asuka', method='DELETE')
self.assertEquals(self.srmock.status, falcon.HTTP_405)
self.assertEqual(self.srmock.status, falcon.HTTP_405)
headers = self.srmock.headers
allow_header = ('Allow', 'GET, OPTIONS')
@@ -54,4 +54,4 @@ class TestDefaultRouting(testing.TestBase):
self.assertThat(headers, Contains(allow_header))
self.simulate_request('/person/asuka', method=self.getUniqueString())
self.assertEquals(self.srmock.status, falcon.HTTP_400)
self.assertEqual(self.srmock.status, falcon.HTTP_400)

20
falcon/tests/test_headers.py
View File

@@ -122,7 +122,7 @@ class TestHeaders(testing.TestBase):
self.simulate_request(self.test_route)
value = self.resource.req.get_header('X-Not-Found') or '876'
self.assertEquals(value, '876')
self.assertEqual(value, '876')
def test_required_header(self):
self.simulate_request(self.test_route)
@@ -136,7 +136,7 @@ class TestHeaders(testing.TestBase):
# Make sure we picked up host from HTTP_HOST, not SERVER_NAME
host = self.resource.req.get_header('host')
self.assertEquals(host, testing.DEFAULT_HOST)
self.assertEqual(host, testing.DEFAULT_HOST)
def test_host_fallback(self):
# Set protocol to 1.0 so that we won't get a host header
@@ -144,7 +144,7 @@ class TestHeaders(testing.TestBase):
# Make sure we picked up host from HTTP_HOST, not SERVER_NAME
host = self.resource.req.get_header('host')
self.assertEquals(host, 'localhost')
self.assertEqual(host, 'localhost')
def test_host_fallback_port8000(self):
# Set protocol to 1.0 so that we won't get a host header
@@ -153,7 +153,7 @@ class TestHeaders(testing.TestBase):
# Make sure we picked up host from HTTP_HOST, not SERVER_NAME
host = self.resource.req.get_header('host')
self.assertEquals(host, 'localhost:8000')
self.assertEqual(host, 'localhost:8000')
def test_no_body_on_100(self):
self.resource = StatusTestResource(falcon.HTTP_100)
@@ -163,7 +163,7 @@ class TestHeaders(testing.TestBase):
self.assertThat(self.srmock.headers_dict,
Not(Contains('Content-Length')))
self.assertEquals(body, [])
self.assertEqual(body, [])
def test_no_body_on_101(self):
self.resource = StatusTestResource(falcon.HTTP_101)
@@ -173,7 +173,7 @@ class TestHeaders(testing.TestBase):
self.assertThat(self.srmock.headers_dict,
Not(Contains('Content-Length')))
self.assertEquals(body, [])
self.assertEqual(body, [])
def test_no_body_on_204(self):
self.resource = StatusTestResource(falcon.HTTP_204)
@@ -183,7 +183,7 @@ class TestHeaders(testing.TestBase):
self.assertThat(self.srmock.headers_dict,
Not(Contains('Content-Length')))
self.assertEquals(body, [])
self.assertEqual(body, [])
def test_no_body_on_304(self):
self.resource = StatusTestResource(falcon.HTTP_304)
@@ -193,7 +193,7 @@ class TestHeaders(testing.TestBase):
self.assertThat(self.srmock.headers_dict,
Not(Contains('Content-Length')))
self.assertEquals(body, [])
self.assertEqual(body, [])
def test_passthrough_req_headers(self):
req_headers = {
@@ -204,7 +204,7 @@ class TestHeaders(testing.TestBase):
for name, expected_value in req_headers.items():
actual_value = self.resource.req.get_header(name)
self.assertEquals(actual_value, expected_value)
self.assertEqual(actual_value, expected_value)
self.simulate_request(self.test_route,
headers=self.resource.req.headers)
@@ -212,7 +212,7 @@ class TestHeaders(testing.TestBase):
# Compare the request HTTP headers with the original headers
for name, expected_value in req_headers.items():
actual_value = self.resource.req.get_header(name)
self.assertEquals(actual_value, expected_value)
self.assertEqual(actual_value, expected_value)
def test_passthrough_resp_headers(self):
self.simulate_request(self.test_route)

38
falcon/tests/test_hello.py
View File

@@ -78,7 +78,7 @@ class TestHelloWorld(testing.TestBase):
def test_env_headers_list_of_tuples(self):
env = testing.create_environ(headers=[('User-Agent', 'Falcon-Test')])
self.assertEquals(env['HTTP_USER_AGENT'], 'Falcon-Test')
self.assertEqual(env['HTTP_USER_AGENT'], 'Falcon-Test')
def test_empty_route(self):
self.simulate_request('')
@@ -90,48 +90,48 @@ class TestHelloWorld(testing.TestBase):
# Ensure the request was NOT routed to resource
self.assertFalse(self.resource.called)
self.assertEquals(self.srmock.status, falcon.HTTP_404)
self.assertEqual(self.srmock.status, falcon.HTTP_404)
def test_body(self):
body = self.simulate_request(self.test_route)
resp = self.resource.resp
content_length = int(self.srmock.headers_dict['Content-Length'])
self.assertEquals(content_length, len(self.resource.sample_utf8))
self.assertEqual(content_length, len(self.resource.sample_utf8))
self.assertEquals(self.srmock.status, self.resource.sample_status)
self.assertEquals(resp.status, self.resource.sample_status)
self.assertEquals(resp.body_encoded, self.resource.sample_utf8)
self.assertEquals(body, [self.resource.sample_utf8])
self.assertEqual(self.srmock.status, self.resource.sample_status)
self.assertEqual(resp.status, self.resource.sample_status)
self.assertEqual(resp.body_encoded, self.resource.sample_utf8)
self.assertEqual(body, [self.resource.sample_utf8])
def test_body_bytes(self):
body = self.simulate_request('/bytes')
resp = self.bytes_resource.resp
content_length = int(self.srmock.headers_dict['Content-Length'])
self.assertEquals(content_length, len(self.resource.sample_utf8))
self.assertEqual(content_length, len(self.resource.sample_utf8))
self.assertEquals(self.srmock.status, self.resource.sample_status)
self.assertEquals(resp.status, self.resource.sample_status)
self.assertEquals(resp.body_encoded, self.resource.sample_utf8)
self.assertEquals(body, [self.resource.sample_utf8])
self.assertEqual(self.srmock.status, self.resource.sample_status)
self.assertEqual(resp.status, self.resource.sample_status)
self.assertEqual(resp.body_encoded, self.resource.sample_utf8)
self.assertEqual(body, [self.resource.sample_utf8])
def test_data(self):
body = self.simulate_request('/data')
resp = self.data_resource.resp
content_length = int(self.srmock.headers_dict['Content-Length'])
self.assertEquals(content_length, len(self.resource.sample_utf8))
self.assertEqual(content_length, len(self.resource.sample_utf8))
self.assertEquals(self.srmock.status, self.resource.sample_status)
self.assertEquals(resp.status, self.resource.sample_status)
self.assertEquals(resp.data, self.resource.sample_utf8)
self.assertEquals(body, [self.resource.sample_utf8])
self.assertEqual(self.srmock.status, self.resource.sample_status)
self.assertEqual(resp.status, self.resource.sample_status)
self.assertEqual(resp.data, self.resource.sample_utf8)
self.assertEqual(body, [self.resource.sample_utf8])
def test_no_body_on_head(self):
body = self.simulate_request(self.test_route, method='HEAD')
self.assertEquals(body, [])
self.assertEquals(self.srmock.status, falcon.HTTP_200)
self.assertEqual(body, [])
self.assertEqual(self.srmock.status, falcon.HTTP_200)
def test_stream_chunked(self):
src = self.simulate_request('/chunked-stream')

18
falcon/tests/test_http_method_routing.py
View File

@@ -126,17 +126,17 @@ class TestHttpMethodRouting(testing.TestBase):
def test_get(self):
self.simulate_request('/things/42/stuff/57')
self.assertEquals(self.srmock.status, falcon.HTTP_204)
self.assertEqual(self.srmock.status, falcon.HTTP_204)
self.assertTrue(self.resource_things.called)
def test_put(self):
self.simulate_request('/things/42/stuff/1337', method='PUT')
self.assertEquals(self.srmock.status, falcon.HTTP_201)
self.assertEqual(self.srmock.status, falcon.HTTP_201)
self.assertTrue(self.resource_things.called)
def test_post_not_allowed(self):
self.simulate_request('/things/42/stuff/1337', method='POST')
self.assertEquals(self.srmock.status, falcon.HTTP_405)
self.assertEqual(self.srmock.status, falcon.HTTP_405)
self.assertFalse(self.resource_things.called)
def test_misc(self):
@@ -144,12 +144,12 @@ class TestHttpMethodRouting(testing.TestBase):
self.resource_misc.called = False
self.simulate_request('/misc', method=method)
self.assertTrue(self.resource_misc.called)
self.assertEquals(self.resource_misc.req.method, method)
self.assertEqual(self.resource_misc.req.method, method)
def test_methods_not_allowed_simple(self):
for method in ['GET', 'HEAD', 'PUT', 'PATCH']:
self.simulate_request('/stonewall', method=method)
self.assertEquals(self.srmock.status, falcon.HTTP_405)
self.assertEqual(self.srmock.status, falcon.HTTP_405)
def test_methods_not_allowed_complex(self):
for method in HTTP_METHODS:
@@ -160,7 +160,7 @@ class TestHttpMethodRouting(testing.TestBase):
self.simulate_request('/things/84/stuff/65', method=method)
self.assertFalse(self.resource_things.called)
self.assertEquals(self.srmock.status, falcon.HTTP_405)
self.assertEqual(self.srmock.status, falcon.HTTP_405)
headers = self.srmock.headers
allow_header = ('Allow', 'GET, HEAD, PUT, OPTIONS')
@@ -177,7 +177,7 @@ class TestHttpMethodRouting(testing.TestBase):
'/get_with_param/bogus_param', method=method)
self.assertFalse(self.resource_get_with_faulty_put.called)
self.assertEquals(self.srmock.status, falcon.HTTP_405)
self.assertEqual(self.srmock.status, falcon.HTTP_405)
headers = self.srmock.headers
allow_header = ('Allow', 'GET, PUT, OPTIONS')
@@ -186,7 +186,7 @@ class TestHttpMethodRouting(testing.TestBase):
def test_default_on_options(self):
self.simulate_request('/things/84/stuff/65', method='OPTIONS')
self.assertEquals(self.srmock.status, falcon.HTTP_204)
self.assertEqual(self.srmock.status, falcon.HTTP_204)
headers = self.srmock.headers
allow_header = ('Allow', 'GET, HEAD, PUT')
@@ -196,4 +196,4 @@ class TestHttpMethodRouting(testing.TestBase):
def test_bogus_method(self):
self.simulate_request('/things', method=self.getUniqueString())
self.assertFalse(self.resource_things.called)
self.assertEquals(self.srmock.status, falcon.HTTP_400)
self.assertEqual(self.srmock.status, falcon.HTTP_400)

2
falcon/tests/test_httperror.py
View File

@@ -252,7 +252,7 @@ class TestHTTPError(testing.TestBase):
self.assertTrue(unicode_resource.called)
#self.assertEqual(self.srmock.status, falcon.HTTP_792)
self.assertEquals(expected_body, body)
self.assertEqual(expected_body, body)
def test_401(self):
self.api.add_route('/401', UnauthorizedResource())

106
falcon/tests/test_query_params.py
View File

@@ -38,20 +38,20 @@ class TestQueryParams(testing.TestBase):
req = self.resource.req
store = {}
self.assertEquals(req.get_param('marker', store=store) or 'nada',
'deadbeef')
self.assertEquals(req.get_param('limit', store=store) or '0', '25')
self.assertEqual(req.get_param('marker', store=store) or 'nada',
'deadbeef')
self.assertEqual(req.get_param('limit', store=store) or '0', '25')
self.assertEquals(store['marker'], 'deadbeef')
self.assertEquals(store['limit'], '25')
self.assertEqual(store['marker'], 'deadbeef')
self.assertEqual(store['limit'], '25')
def test_percent_encoded(self):
query_string = 'id=23%2c42&q=%e8%b1%86+%e7%93%a3'
self.simulate_request('/', query_string=query_string)
req = self.resource.req
self.assertEquals(req.get_param('id'), u'23,42')
self.assertEquals(req.get_param('q'), u'\u8c46 \u74e3')
self.assertEqual(req.get_param('id'), u'23,42')
self.assertEqual(req.get_param('q'), u'\u8c46 \u74e3')
def test_allowed_names(self):
query_string = ('p=0&p1=23&2p=foo&some-thing=that&blank=&some_thing=x&'
@@ -59,14 +59,14 @@ class TestQueryParams(testing.TestBase):
self.simulate_request('/', query_string=query_string)
req = self.resource.req
self.assertEquals(req.get_param('p'), '0')
self.assertEquals(req.get_param('p1'), '23')
self.assertEqual(req.get_param('p'), '0')
self.assertEqual(req.get_param('p1'), '23')
self.assertIs(req.get_param('2p'), None)
self.assertEquals(req.get_param('some-thing'), 'that')
self.assertEqual(req.get_param('some-thing'), 'that')
self.assertIs(req.get_param('blank'), None)
self.assertEquals(req.get_param('some_thing'), 'x')
self.assertEqual(req.get_param('some_thing'), 'x')
self.assertIs(req.get_param('-bogus'), None)
self.assertEquals(req.get_param('more.things'), 'blah')
self.assertEqual(req.get_param('more.things'), 'blah')
def test_required(self):
query_string = ''
@@ -90,13 +90,13 @@ class TestQueryParams(testing.TestBase):
self.assertRaises(falcon.HTTPBadRequest, req.get_param_as_int,
'marker')
self.assertEquals(req.get_param_as_int('limit'), 25)
self.assertEqual(req.get_param_as_int('limit'), 25)
store = {}
self.assertEquals(req.get_param_as_int('limit', store=store), 25)
self.assertEquals(store['limit'], 25)
self.assertEqual(req.get_param_as_int('limit', store=store), 25)
self.assertEqual(store['limit'], 25)
self.assertEquals(
self.assertEqual(
req.get_param_as_int('limit', min=1, max=50), 25)
self.assertRaises(
@@ -115,25 +115,25 @@ class TestQueryParams(testing.TestBase):
falcon.HTTPBadRequest,
req.get_param_as_int, 'limit', min=30, max=50)
self.assertEquals(
self.assertEqual(
req.get_param_as_int('limit', min=1), 25)
self.assertEquals(
self.assertEqual(
req.get_param_as_int('limit', max=50), 25)
self.assertEquals(
self.assertEqual(
req.get_param_as_int('limit', max=25), 25)
self.assertEquals(
self.assertEqual(
req.get_param_as_int('limit', max=26), 25)
self.assertEquals(
self.assertEqual(
req.get_param_as_int('limit', min=25), 25)
self.assertEquals(
self.assertEqual(
req.get_param_as_int('limit', min=24), 25)
self.assertEquals(
self.assertEqual(
req.get_param_as_int('limit', min=-24), 25)
def test_int_neg(self):
@@ -141,12 +141,12 @@ class TestQueryParams(testing.TestBase):
self.simulate_request('/', query_string=query_string)
req = self.resource.req
self.assertEquals(req.get_param_as_int('pos'), -7)
self.assertEqual(req.get_param_as_int('pos'), -7)
self.assertEquals(
self.assertEqual(
req.get_param_as_int('pos', min=-10, max=10), -7)
self.assertEquals(
self.assertEqual(
req.get_param_as_int('pos', max=10), -7)
self.assertRaises(
@@ -176,17 +176,17 @@ class TestQueryParams(testing.TestBase):
self.assertRaises(falcon.HTTPBadRequest, req.get_param_as_bool,
'bogus2')
self.assertEquals(req.get_param_as_bool('echo'), True)
self.assertEquals(req.get_param_as_bool('doit'), False)
self.assertEqual(req.get_param_as_bool('echo'), True)
self.assertEqual(req.get_param_as_bool('doit'), False)
self.assertEquals(req.get_param_as_bool('t1'), True)
self.assertEquals(req.get_param_as_bool('t2'), True)
self.assertEquals(req.get_param_as_bool('f1'), False)
self.assertEquals(req.get_param_as_bool('f2'), False)
self.assertEqual(req.get_param_as_bool('t1'), True)
self.assertEqual(req.get_param_as_bool('t2'), True)
self.assertEqual(req.get_param_as_bool('f1'), False)
self.assertEqual(req.get_param_as_bool('f2'), False)
store = {}
self.assertEquals(req.get_param_as_bool('echo', store=store), True)
self.assertEquals(store['echo'], True)
self.assertEqual(req.get_param_as_bool('echo', store=store), True)
self.assertEqual(store['echo'], True)
def test_list_type(self):
query_string = ('colors=red,green,blue&limit=1'
@@ -195,49 +195,49 @@ class TestQueryParams(testing.TestBase):
self.simulate_request('/', query_string=query_string)
req = self.resource.req
self.assertEquals(req.get_param('colors'), 'red,green,blue')
self.assertEquals(req.get_param_as_list('colors'),
['red', 'green', 'blue'])
self.assertEquals(req.get_param_as_list('limit'), ['1'])
self.assertEqual(req.get_param('colors'), 'red,green,blue')
self.assertEqual(req.get_param_as_list('colors'),
['red', 'green', 'blue'])
self.assertEqual(req.get_param_as_list('limit'), ['1'])
self.assertIs(req.get_param_as_list('marker'), None)
self.assertEquals(req.get_param_as_list('empty1'), None)
self.assertEquals(req.get_param_as_list('empty2'), [None, None])
self.assertEquals(req.get_param_as_list('empty3'), [None, None, None])
self.assertEqual(req.get_param_as_list('empty1'), None)
self.assertEqual(req.get_param_as_list('empty2'), [None, None])
self.assertEqual(req.get_param_as_list('empty3'), [None, None, None])
self.assertEquals(req.get_param_as_list('list-ish1'),
['f', None, 'x'])
self.assertEqual(req.get_param_as_list('list-ish1'),
['f', None, 'x'])
# Ensure that '0' doesn't get translated to None
self.assertEquals(req.get_param_as_list('list-ish2'),
[None, '0'])
self.assertEqual(req.get_param_as_list('list-ish2'),
[None, '0'])
# Ensure that '0' doesn't get translated to None
self.assertEquals(req.get_param_as_list('list-ish3'),
['a', None, None, 'b'])
self.assertEqual(req.get_param_as_list('list-ish3'),
['a', None, None, 'b'])
store = {}
self.assertEquals(req.get_param_as_list('limit', store=store), ['1'])
self.assertEquals(store['limit'], ['1'])
self.assertEqual(req.get_param_as_list('limit', store=store), ['1'])
self.assertEqual(store['limit'], ['1'])
def test_list_transformer(self):
query_string = 'coord=1.4,13,15.1&limit=100&things=4,,1'
self.simulate_request('/', query_string=query_string)
req = self.resource.req
self.assertEquals(req.get_param('coord'), '1.4,13,15.1')
self.assertEqual(req.get_param('coord'), '1.4,13,15.1')
expected = [1.4, 13.0, 15.1]
actual = req.get_param_as_list('coord', transform=float)
self.assertEquals(actual, expected)
self.assertEqual(actual, expected)
expected = ['4', None, '1']
actual = req.get_param_as_list('things', transform=str)
self.assertEquals(actual, expected)
self.assertEqual(actual, expected)
expected = [4, None, 1]
actual = req.get_param_as_list('things', transform=int)
self.assertEquals(actual, expected)
self.assertEqual(actual, expected)
self.assertRaises(falcon.HTTPBadRequest,
req.get_param_as_list, 'coord', transform=int)

44
falcon/tests/test_req_vars.py
View File

@@ -56,13 +56,13 @@ class TestReqVars(testing.TestBase):
actual_url = ''.join([scheme, '://', host, app, path,
'?', query_string])
self.assertEquals(actual_url, self.uri)
self.assertEqual(actual_url, self.uri)
def test_uri(self):
self.assertEquals(self.req.url, self.uri)
self.assertEqual(self.req.url, self.uri)
self.assertEquals(self.req.uri, self.uri)
self.assertEquals(self.req_noqs.uri, self.uri_noqs)
self.assertEqual(self.req.uri, self.uri)
self.assertEqual(self.req_noqs.uri, self.uri_noqs)
def test_relative_uri(self):
self.assertEqual(self.req.relative_uri, self.app + self.relative_uri)
@@ -159,37 +159,37 @@ class TestReqVars(testing.TestBase):
headers = {'Accept': 'application/xml'}
req = Request(testing.create_environ(headers=headers))
preferred_type = req.client_prefers(['application/xml'])
self.assertEquals(preferred_type, 'application/xml')
self.assertEqual(preferred_type, 'application/xml')
headers = {'Accept': '*/*'}
preferred_type = req.client_prefers(('application/xml',
'application/json'))
# NOTE(kgriffs): If client doesn't care, "preferr" the first one
self.assertEquals(preferred_type, 'application/xml')
self.assertEqual(preferred_type, 'application/xml')
headers = {'Accept': 'text/*; q=0.1, application/xhtml+xml; q=0.5'}
req = Request(testing.create_environ(headers=headers))
preferred_type = req.client_prefers(['application/xhtml+xml'])
self.assertEquals(preferred_type, 'application/xhtml+xml')
self.assertEqual(preferred_type, 'application/xhtml+xml')
headers = {'Accept': '3p12845j;;;asfd;'}
req = Request(testing.create_environ(headers=headers))
preferred_type = req.client_prefers(['application/xhtml+xml'])
self.assertEquals(preferred_type, None)
self.assertEqual(preferred_type, None)
def test_range(self):
headers = {'Range': '10-'}
req = Request(testing.create_environ(headers=headers))
self.assertEquals(req.range, (10, -1))
self.assertEqual(req.range, (10, -1))
headers = {'Range': '10-20'}
req = Request(testing.create_environ(headers=headers))
self.assertEquals(req.range, (10, 20))
self.assertEqual(req.range, (10, 20))
headers = {'Range': '-10240'}
req = Request(testing.create_environ(headers=headers))
self.assertEquals(req.range, (-10240, -1))
self.assertEqual(req.range, (-10240, -1))
headers = {'Range': ''}
req = Request(testing.create_environ(headers=headers))
@@ -261,19 +261,19 @@ class TestReqVars(testing.TestBase):
def test_missing_attribute_header(self):
req = Request(testing.create_environ())
self.assertEquals(req.range, None)
self.assertEqual(req.range, None)
req = Request(testing.create_environ())
self.assertEquals(req.content_length, None)
self.assertEqual(req.content_length, None)
def test_content_length(self):
headers = {'content-length': '5656'}
req = Request(testing.create_environ(headers=headers))
self.assertEquals(req.content_length, 5656)
self.assertEqual(req.content_length, 5656)
headers = {'content-length': ''}
req = Request(testing.create_environ(headers=headers))
self.assertEquals(req.content_length, None)
self.assertEqual(req.content_length, None)
def test_bogus_content_length_nan(self):
headers = {'content-length': 'fuzzy-bunnies'}
@@ -289,7 +289,7 @@ class TestReqVars(testing.TestBase):
date = datetime.datetime(2013, 4, 4, 5, 19, 18)
headers = {'date': 'Thu, 04 Apr 2013 05:19:18 GMT'}
req = Request(testing.create_environ(headers=headers))
self.assertEquals(req.date, date)
self.assertEqual(req.date, date)
def test_date_invalid(self):
headers = {'date': 'Thu, 04 Apr 2013'}
@@ -324,20 +324,20 @@ class TestReqVars(testing.TestBase):
default=default_agent)
def test_method(self):
self.assertEquals(self.req.method, 'GET')
self.assertEqual(self.req.method, 'GET')
self.req = Request(testing.create_environ(path='', method='HEAD'))
self.assertEquals(self.req.method, 'HEAD')
self.assertEqual(self.req.method, 'HEAD')
def test_empty_path(self):
self.req = Request(testing.create_environ(path=''))
self.assertEquals(self.req.path, '/')
self.assertEqual(self.req.path, '/')
def test_content_type_method(self):
self.assertEquals(self.req.get_header('content-type'), 'text/plain')
self.assertEqual(self.req.get_header('content-type'), 'text/plain')
def test_content_length_method(self):
self.assertEquals(self.req.get_header('content-length'), '4829')
self.assertEqual(self.req.get_header('content-length'), '4829')
# -------------------------------------------------------------------------
# Helpers
@@ -346,7 +346,7 @@ class TestReqVars(testing.TestBase):
def _test_attribute_header(self, name, value, attr, default=None):
headers = {name: value}
req = Request(testing.create_environ(headers=headers))
self.assertEquals(getattr(req, attr), value)
self.assertEqual(getattr(req, attr), value)
req = Request(testing.create_environ())
self.assertEqual(getattr(req, attr), default)

32
falcon/tests/test_request_body.py
View File

@@ -22,7 +22,7 @@ class TestRequestBody(testing.TestBase):
stream = self.resource.req.stream
stream.seek(0, 2)
self.assertEquals(stream.tell(), 0)
self.assertEqual(stream.tell(), 0)
def test_tiny_body(self):
expected_body = '.'
@@ -30,10 +30,10 @@ class TestRequestBody(testing.TestBase):
stream = self.resource.req.stream
actual_body = stream.read(1)
self.assertEquals(actual_body, expected_body.encode('utf-8'))
self.assertEqual(actual_body, expected_body.encode('utf-8'))
stream.seek(0, 2)
self.assertEquals(stream.tell(), 1)
self.assertEqual(stream.tell(), 1)
def test_tiny_body_overflow(self):
expected_body = '.'
@@ -42,7 +42,7 @@ class TestRequestBody(testing.TestBase):
# Read too many bytes; shouldn't block
actual_body = stream.read(len(expected_body) + 1)
self.assertEquals(actual_body, expected_body.encode('utf-8'))
self.assertEqual(actual_body, expected_body.encode('utf-8'))
def test_read_body(self):
expected_body = testing.rand_string(SIZE_1_KB / 2, SIZE_1_KB)
@@ -57,12 +57,12 @@ class TestRequestBody(testing.TestBase):
stream = self.resource.req.stream
actual_body = stream.read()
self.assertEquals(actual_body, expected_body.encode('utf-8'))
self.assertEqual(actual_body, expected_body.encode('utf-8'))
stream.seek(0, 2)
self.assertEquals(stream.tell(), expected_len)
self.assertEqual(stream.tell(), expected_len)
self.assertEquals(stream.tell(), expected_len)
self.assertEqual(stream.tell(), expected_len)
def test_read_socket_body(self):
expected_body = testing.rand_string(SIZE_1_KB / 2, SIZE_1_KB)
@@ -96,10 +96,10 @@ class TestRequestBody(testing.TestBase):
url = 'http://127.0.0.1:8989/echo'
resp = requests.post(url, data=expected_body)
self.assertEquals(resp.text, expected_body)
self.assertEqual(resp.text, expected_body)
resp = requests.put(url, data=expected_body)
self.assertEquals(resp.text, expected_body)
self.assertEqual(resp.text, expected_body)
process.terminate()
@@ -119,29 +119,29 @@ class TestRequestBody(testing.TestBase):
stream = io.BytesIO(expected_body)
body = request_helpers.Body(stream, expected_len)
self.assertEquals(body.read(), expected_body)
self.assertEqual(body.read(), expected_body)
stream = io.BytesIO(expected_body)
body = request_helpers.Body(stream, expected_len)
self.assertEquals(body.read(2), expected_body[0:2])
self.assertEqual(body.read(2), expected_body[0:2])
stream = io.BytesIO(expected_body)
body = request_helpers.Body(stream, expected_len)
self.assertEquals(body.read(expected_len + 1), expected_body)
self.assertEqual(body.read(expected_len + 1), expected_body)
stream = io.BytesIO(expected_body)
body = request_helpers.Body(stream, expected_len)
self.assertEquals(body.readline(), expected_lines[0])
self.assertEqual(body.readline(), expected_lines[0])
stream = io.BytesIO(expected_body)
body = request_helpers.Body(stream, expected_len)
self.assertEquals(body.readlines(), expected_lines)
self.assertEqual(body.readlines(), expected_lines)
stream = io.BytesIO(expected_body)
body = request_helpers.Body(stream, expected_len)
self.assertEquals(next(body), expected_lines[0])
self.assertEqual(next(body), expected_lines[0])
stream = io.BytesIO(expected_body)
body = request_helpers.Body(stream, expected_len)
for i, line in enumerate(body):
self.assertEquals(line, expected_lines[i])
self.assertEqual(line, expected_lines[i])

2
falcon/tests/test_response_body.py
View File

@@ -14,4 +14,4 @@ class TestResponseBody(testing.TestBase):
resp.body += token
resp.body += " "
self.assertEquals(resp.body, text)
self.assertEqual(resp.body, text)

28
falcon/tests/test_sinks.py
View File

@@ -37,32 +37,32 @@ class TestDefaultRouting(testing.TestBase):
self.api.add_sink(self.sink)
self.simulate_request('/')
self.assertEquals(self.srmock.status, falcon.HTTP_503)
self.assertEqual(self.srmock.status, falcon.HTTP_503)
def test_single_simple_pattern(self):
self.api.add_sink(self.sink, r'/foo')
self.simulate_request('/foo/bar')
self.assertEquals(self.srmock.status, falcon.HTTP_503)
self.assertEqual(self.srmock.status, falcon.HTTP_503)
def test_single_compiled_pattern(self):
self.api.add_sink(self.sink, re.compile(r'/foo'))
self.simulate_request('/foo/bar')
self.assertEquals(self.srmock.status, falcon.HTTP_503)
self.assertEqual(self.srmock.status, falcon.HTTP_503)
self.simulate_request('/auth')
self.assertEquals(self.srmock.status, falcon.HTTP_404)
self.assertEqual(self.srmock.status, falcon.HTTP_404)
def test_named_groups(self):
self.api.add_sink(self.sink, r'/user/(?P<id>\d+)')
self.simulate_request('/user/309')
self.assertEquals(self.srmock.status, falcon.HTTP_503)
self.assertEquals(self.sink.kwargs['id'], '309')
self.assertEqual(self.srmock.status, falcon.HTTP_503)
self.assertEqual(self.sink.kwargs['id'], '309')
self.simulate_request('/user/sally')
self.assertEquals(self.srmock.status, falcon.HTTP_404)
self.assertEqual(self.srmock.status, falcon.HTTP_404)
def test_multiple_patterns(self):
self.api.add_sink(self.sink, r'/foo')
@@ -71,10 +71,10 @@ class TestDefaultRouting(testing.TestBase):
self.api.add_sink(self.sink, r'/katza')
self.simulate_request('/foo/bar')
self.assertEquals(self.srmock.status, falcon.HTTP_781)
self.assertEqual(self.srmock.status, falcon.HTTP_781)
self.simulate_request('/katza')
self.assertEquals(self.srmock.status, falcon.HTTP_503)
self.assertEqual(self.srmock.status, falcon.HTTP_503)
def test_with_route(self):
self.api.add_route('/books', self.resource)
@@ -82,11 +82,11 @@ class TestDefaultRouting(testing.TestBase):
self.simulate_request('/proxy/books')
self.assertFalse(self.resource.called)
self.assertEquals(self.srmock.status, falcon.HTTP_503)
self.assertEqual(self.srmock.status, falcon.HTTP_503)
self.simulate_request('/books')
self.assertTrue(self.resource.called)
self.assertEquals(self.srmock.status, falcon.HTTP_200)
self.assertEqual(self.srmock.status, falcon.HTTP_200)
def test_route_precedence(self):
# NOTE(kgriffs): In case of collision, the route takes precedence.
@@ -95,7 +95,7 @@ class TestDefaultRouting(testing.TestBase):
self.simulate_request('/books')
self.assertTrue(self.resource.called)
self.assertEquals(self.srmock.status, falcon.HTTP_200)
self.assertEqual(self.srmock.status, falcon.HTTP_200)
def test_route_precedence_with_id(self):
# NOTE(kgriffs): In case of collision, the route takes precedence.
@@ -104,7 +104,7 @@ class TestDefaultRouting(testing.TestBase):
self.simulate_request('/books')
self.assertFalse(self.resource.called)
self.assertEquals(self.srmock.status, falcon.HTTP_503)
self.assertEqual(self.srmock.status, falcon.HTTP_503)
def test_route_precedence_with_both_id(self):
# NOTE(kgriffs): In case of collision, the route takes precedence.
@@ -113,4 +113,4 @@ class TestDefaultRouting(testing.TestBase):
self.simulate_request('/books/123')
self.assertTrue(self.resource.called)
self.assertEquals(self.srmock.status, falcon.HTTP_200)
self.assertEqual(self.srmock.status, falcon.HTTP_200)

32
falcon/tests/test_uri_templates.py
View File

@@ -38,7 +38,7 @@ class TestUriTemplates(testing.TestBase):
self.assertTrue(self.resource.called)
req = self.resource.req
self.assertEquals(req.get_param('id'), None)
self.assertEqual(req.get_param('id'), None)
def test_not_str(self):
self.assertRaises(TypeError, self.api.add_route, {}, self.resource)
@@ -53,7 +53,7 @@ class TestUriTemplates(testing.TestBase):
self.assertTrue(self.resource.called)
req = self.resource.req
self.assertEquals(req.get_param('world'), None)
self.assertEqual(req.get_param('world'), None)
def test_special_chars(self):
self.api.add_route('/hello/world.json', self.resource)
@@ -76,38 +76,38 @@ class TestUriTemplates(testing.TestBase):
req = self.resource.req
kwargs = self.resource.kwargs
self.assertEquals(kwargs['id'], '123')
self.assertEqual(kwargs['id'], '123')
self.assertNotIn(kwargs, 'Id')
self.assertEquals(req.get_param('id'), None)
self.assertEqual(req.get_param('id'), None)
def test_single_trailing_slash(self):
resource1 = IDResource()
self.api.add_route('/1/{id}/', resource1)
self.simulate_request('/1/123')
self.assertEquals(self.srmock.status, falcon.HTTP_200)
self.assertEqual(self.srmock.status, falcon.HTTP_200)
self.assertTrue(resource1.called)
self.assertEquals(resource1.id, '123')
self.assertEquals(resource1.name, None)
self.assertEquals(resource1.req.path, '/1/123')
self.assertEqual(resource1.id, '123')
self.assertEqual(resource1.name, None)
self.assertEqual(resource1.req.path, '/1/123')
resource2 = IDResource()
self.api.add_route('/2/{id}/', resource2)
self.simulate_request('/2/123/')
self.assertTrue(resource2.called)
self.assertEquals(resource2.id, '123')
self.assertEquals(resource2.name, None)
self.assertEquals(resource2.req.path, '/2/123')
self.assertEqual(resource2.id, '123')
self.assertEqual(resource2.name, None)
self.assertEqual(resource2.req.path, '/2/123')
resource3 = IDResource()
self.api.add_route('/3/{id}', resource3)
self.simulate_request('/3/123/')
self.assertTrue(resource3.called)
self.assertEquals(resource3.id, '123')
self.assertEquals(resource3.name, None)
self.assertEquals(resource3.req.path, '/3/123')
self.assertEqual(resource3.id, '123')
self.assertEqual(resource3.name, None)
self.assertEqual(resource3.req.path, '/3/123')
def test_multiple(self):
resource = NameResource()
@@ -119,8 +119,8 @@ class TestUriTemplates(testing.TestBase):
self.simulate_request(path)
self.assertTrue(resource.called)
self.assertEquals(resource.id, test_id)
self.assertEquals(resource.name, test_name)
self.assertEqual(resource.id, test_id)
self.assertEqual(resource.name, test_name)
def test_empty_path_component(self):
self.assertRaises(ValueError, self.api.add_route,

24
falcon/tests/test_utils.py
View File

@@ -7,42 +7,42 @@ import falcon
class TestFalconUtils(testtools.TestCase):
def test_dt_to_http(self):
self.assertEquals(
self.assertEqual(
falcon.dt_to_http(datetime(2013, 4, 4)),
'Thu, 04 Apr 2013 00:00:00 GMT')
self.assertEquals(
self.assertEqual(
falcon.dt_to_http(datetime(2013, 4, 4, 10, 28, 54)),
'Thu, 04 Apr 2013 10:28:54 GMT')
def test_http_date_to_dt(self):
self.assertEquals(
self.assertEqual(
falcon.http_date_to_dt('Thu, 04 Apr 2013 00:00:00 GMT'),
datetime(2013, 4, 4))
self.assertEquals(
self.assertEqual(
falcon.http_date_to_dt('Thu, 04 Apr 2013 10:28:54 GMT'),
datetime(2013, 4, 4, 10, 28, 54))
def test_pack_query_params_none(self):
self.assertEquals(
self.assertEqual(
falcon.to_query_str({}),
'')
def test_pack_query_params_one(self):
self.assertEquals(
self.assertEqual(
falcon.to_query_str({'limit': 10}),
'?limit=10')
self.assertEquals(
self.assertEqual(
falcon.to_query_str({'things': [1, 2, 3]}),
'?things=1,2,3')
self.assertEquals(
self.assertEqual(
falcon.to_query_str({'things': ['a']}),
'?things=a')
self.assertEquals(
self.assertEqual(
falcon.to_query_str({'things': ['a', 'b']}),
'?things=a,b')
@@ -70,12 +70,12 @@ class TestFalconUtils(testtools.TestCase):
'y': '0.2',
'doit': 'false'}
self.assertEquals(expected, garbage_out)
self.assertEqual(expected, garbage_out)
def test_percent_escape(self):
url = 'http://example.com/v1/fizbit/messages?limit=3&echo=true'
self.assertEquals(falcon.percent_escape(url), url)
self.assertEqual(falcon.percent_escape(url), url)
url2a = u'http://example.com/v1/fizbit/messages?limit=3&e\u00e7ho=true'
url2b = 'http://example.com/v1/fizbit/messages?limit=3&e%C3%A7ho=true'
self.assertEquals(falcon.percent_escape(url2a), url2b)
self.assertEqual(falcon.percent_escape(url2a), url2b)