From 9eba0344cacc23820ae659524df60c82c6b7c8c8 Mon Sep 17 00:00:00 2001 From: kgriffs Date: Tue, 31 Dec 2013 17:12:38 -0600 Subject: [PATCH] fix(tests): Use assertEqual instead of the deprecated assertEquals method --- falcon/tests/test_default_routing.py | 14 +-- falcon/tests/test_headers.py | 20 ++--- falcon/tests/test_hello.py | 38 ++++---- falcon/tests/test_http_method_routing.py | 18 ++-- falcon/tests/test_httperror.py | 2 +- falcon/tests/test_query_params.py | 106 +++++++++++------------ falcon/tests/test_req_vars.py | 44 +++++----- falcon/tests/test_request_body.py | 32 +++---- falcon/tests/test_response_body.py | 2 +- falcon/tests/test_sinks.py | 28 +++--- falcon/tests/test_uri_templates.py | 32 +++---- falcon/tests/test_utils.py | 24 ++--- 12 files changed, 180 insertions(+), 180 deletions(-) diff --git a/falcon/tests/test_default_routing.py b/falcon/tests/test_default_routing.py index 1c1d4f1..f25cdf9 100644 --- a/falcon/tests/test_default_routing.py +++ b/falcon/tests/test_default_routing.py @@ -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) diff --git a/falcon/tests/test_headers.py b/falcon/tests/test_headers.py index 16a4bc2..346614b 100644 --- a/falcon/tests/test_headers.py +++ b/falcon/tests/test_headers.py @@ -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) diff --git a/falcon/tests/test_hello.py b/falcon/tests/test_hello.py index 728c38a..08e59e5 100644 --- a/falcon/tests/test_hello.py +++ b/falcon/tests/test_hello.py @@ -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') diff --git a/falcon/tests/test_http_method_routing.py b/falcon/tests/test_http_method_routing.py index 6046dc4..d6bfbaf 100644 --- a/falcon/tests/test_http_method_routing.py +++ b/falcon/tests/test_http_method_routing.py @@ -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) diff --git a/falcon/tests/test_httperror.py b/falcon/tests/test_httperror.py index b79776e..ac7c69c 100644 --- a/falcon/tests/test_httperror.py +++ b/falcon/tests/test_httperror.py @@ -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()) diff --git a/falcon/tests/test_query_params.py b/falcon/tests/test_query_params.py index 2734892..8de387b 100644 --- a/falcon/tests/test_query_params.py +++ b/falcon/tests/test_query_params.py @@ -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) diff --git a/falcon/tests/test_req_vars.py b/falcon/tests/test_req_vars.py index c292420..606ed35 100644 --- a/falcon/tests/test_req_vars.py +++ b/falcon/tests/test_req_vars.py @@ -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) diff --git a/falcon/tests/test_request_body.py b/falcon/tests/test_request_body.py index 5100cb8..1839c11 100644 --- a/falcon/tests/test_request_body.py +++ b/falcon/tests/test_request_body.py @@ -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]) diff --git a/falcon/tests/test_response_body.py b/falcon/tests/test_response_body.py index 1c12ae2..ca00598 100644 --- a/falcon/tests/test_response_body.py +++ b/falcon/tests/test_response_body.py @@ -14,4 +14,4 @@ class TestResponseBody(testing.TestBase): resp.body += token resp.body += " " - self.assertEquals(resp.body, text) + self.assertEqual(resp.body, text) diff --git a/falcon/tests/test_sinks.py b/falcon/tests/test_sinks.py index e34362f..6c4efea 100644 --- a/falcon/tests/test_sinks.py +++ b/falcon/tests/test_sinks.py @@ -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\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) diff --git a/falcon/tests/test_uri_templates.py b/falcon/tests/test_uri_templates.py index b9e6b2a..4a0ae2d 100644 --- a/falcon/tests/test_uri_templates.py +++ b/falcon/tests/test_uri_templates.py @@ -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, diff --git a/falcon/tests/test_utils.py b/falcon/tests/test_utils.py index 1387b17..cef1d02 100644 --- a/falcon/tests/test_utils.py +++ b/falcon/tests/test_utils.py @@ -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)