Replace assertEquals by assertEqual.

1 files changed, 45 insertions, 45 deletions

diff --git a/tests/tests.py b/tests/tests.py
index dd7391d..67b67bf 100644
--- a/tests/tests.py
+++ b/tests/tests.py
@@ -64,7 +64,7 @@ class DebugToolbarTestCase(BaseTestCase):
     def test_middleware(self):
         with Settings(INTERNAL_IPS=['127.0.0.1'], DEBUG=True):
             resp = self.client.get('/execute_sql/')
-        self.assertEquals(resp.status_code, 200)
+        self.assertEqual(resp.status_code, 200)
 
     def test_show_toolbar_DEBUG(self):
         request = rf.get('/')
@@ -109,7 +109,7 @@ class DebugToolbarTestCase(BaseTestCase):
             self.assertFalse(isinstance(request.urlconf, six.string_types))
 
             self.assertTrue(hasattr(request.urlconf.urlpatterns[1], '_callback_str'))
-            self.assertEquals(request.urlconf.urlpatterns[-1]._callback_str, 'tests.views.execute_sql')
+            self.assertEqual(request.urlconf.urlpatterns[-1]._callback_str, 'tests.views.execute_sql')
 
     def test_request_urlconf_string_per_request(self):
         request = rf.get('/')
@@ -124,7 +124,7 @@ class DebugToolbarTestCase(BaseTestCase):
             self.assertFalse(isinstance(request.urlconf, six.string_types))
 
             self.assertTrue(hasattr(request.urlconf.urlpatterns[1], '_callback_str'))
-            self.assertEquals(request.urlconf.urlpatterns[-1]._callback_str, 'tests.views.execute_sql')
+            self.assertEqual(request.urlconf.urlpatterns[-1]._callback_str, 'tests.views.execute_sql')
 
     def test_request_urlconf_module(self):
         request = rf.get('/')
@@ -137,7 +137,7 @@ class DebugToolbarTestCase(BaseTestCase):
             self.assertFalse(isinstance(request.urlconf, six.string_types))
 
             self.assertTrue(hasattr(request.urlconf.urlpatterns[1], '_callback_str'))
-            self.assertEquals(request.urlconf.urlpatterns[-1]._callback_str, 'tests.views.execute_sql')
+            self.assertEqual(request.urlconf.urlpatterns[-1]._callback_str, 'tests.views.execute_sql')
 
     def test_tuple_urlconf(self):
         request = rf.get('/')
@@ -160,27 +160,27 @@ class DebugToolbarTestCase(BaseTestCase):
 
     def test_url_resolving_positional(self):
         stats = self._resolve_stats('/resolving1/a/b/')
-        self.assertEquals(stats['view_urlname'], 'positional-resolving')
-        self.assertEquals(stats['view_func'], 'tests.views.resolving_view')
-        self.assertEquals(stats['view_args'], ('a', 'b'))
-        self.assertEquals(stats['view_kwargs'], {})
+        self.assertEqual(stats['view_urlname'], 'positional-resolving')
+        self.assertEqual(stats['view_func'], 'tests.views.resolving_view')
+        self.assertEqual(stats['view_args'], ('a', 'b'))
+        self.assertEqual(stats['view_kwargs'], {})
 
     def test_url_resolving_named(self):
         stats = self._resolve_stats('/resolving2/a/b/')
-        self.assertEquals(stats['view_args'], ())
-        self.assertEquals(stats['view_kwargs'], {'arg1': 'a', 'arg2': 'b'})
+        self.assertEqual(stats['view_args'], ())
+        self.assertEqual(stats['view_kwargs'], {'arg1': 'a', 'arg2': 'b'})
 
     def test_url_resolving_mixed(self):
         stats = self._resolve_stats('/resolving3/a/')
-        self.assertEquals(stats['view_args'], ('a',))
-        self.assertEquals(stats['view_kwargs'], {'arg2': 'default'})
+        self.assertEqual(stats['view_args'], ('a',))
+        self.assertEqual(stats['view_kwargs'], {'arg2': 'default'})
 
     def test_url_resolving_bad(self):
         stats = self._resolve_stats('/non-existing-url/')
-        self.assertEquals(stats['view_urlname'], 'None')
-        self.assertEquals(stats['view_args'], 'None')
-        self.assertEquals(stats['view_kwargs'], 'None')
-        self.assertEquals(stats['view_func'], '<no view>')
+        self.assertEqual(stats['view_urlname'], 'None')
+        self.assertEqual(stats['view_args'], 'None')
+        self.assertEqual(stats['view_kwargs'], 'None')
+        self.assertEqual(stats['view_func'], '<no view>')
 
 
 class DebugToolbarNameFromObjectTest(BaseTestCase):
@@ -188,30 +188,30 @@ class DebugToolbarNameFromObjectTest(BaseTestCase):
         def x():
             return 1
         res = get_name_from_obj(x)
-        self.assertEquals(res, 'tests.tests.x')
+        self.assertEqual(res, 'tests.tests.x')
 
     def test_lambda(self):
         res = get_name_from_obj(lambda: 1)
-        self.assertEquals(res, 'tests.tests.<lambda>')
+        self.assertEqual(res, 'tests.tests.<lambda>')
 
     def test_class(self):
         class A:
             pass
         res = get_name_from_obj(A)
-        self.assertEquals(res, 'tests.tests.A')
+        self.assertEqual(res, 'tests.tests.A')
 
 
 class SQLPanelTestCase(BaseTestCase):
     def test_recording(self):
         panel = self.toolbar.get_panel(SQLDebugPanel)
-        self.assertEquals(len(panel._queries), 0)
+        self.assertEqual(len(panel._queries), 0)
 
         list(User.objects.all())
 
         # ensure query was logged
-        self.assertEquals(len(panel._queries), 1)
+        self.assertEqual(len(panel._queries), 1)
         query = panel._queries[0]
-        self.assertEquals(query[0], 'default')
+        self.assertEqual(query[0], 'default')
         self.assertTrue('sql' in query[1])
         self.assertTrue('duration' in query[1])
         self.assertTrue('stacktrace' in query[1])
@@ -234,21 +234,21 @@ class SQLPanelTestCase(BaseTestCase):
 
     def test_disable_stacktraces(self):
         panel = self.toolbar.get_panel(SQLDebugPanel)
-        self.assertEquals(len(panel._queries), 0)
+        self.assertEqual(len(panel._queries), 0)
 
         with Settings(DEBUG_TOOLBAR_CONFIG={'ENABLE_STACKTRACES': False}):
             list(User.objects.all())
 
         # ensure query was logged
-        self.assertEquals(len(panel._queries), 1)
+        self.assertEqual(len(panel._queries), 1)
         query = panel._queries[0]
-        self.assertEquals(query[0], 'default')
+        self.assertEqual(query[0], 'default')
         self.assertTrue('sql' in query[1])
         self.assertTrue('duration' in query[1])
         self.assertTrue('stacktrace' in query[1])
 
         # ensure the stacktrace is empty
-        self.assertEquals([], query[1]['stacktrace'])
+        self.assertEqual([], query[1]['stacktrace'])
 
 
 class TemplatePanelTestCase(BaseTestCase):
@@ -264,7 +264,7 @@ class TemplatePanelTestCase(BaseTestCase):
         })
         t.render(c)
         # ensure the query was NOT logged
-        self.assertEquals(len(sql_panel._queries), 0)
+        self.assertEqual(len(sql_panel._queries), 0)
         base_ctx_idx = 1 if django.VERSION[:2] >= (1, 5) else 0
         ctx = template_panel.templates[0]['context'][base_ctx_idx]
         self.assertIn('<<queryset of auth.User>>', ctx)
@@ -293,23 +293,23 @@ class TrackingTestCase(BaseTestCase):
             foo.update(kwargs)
 
         self.assertTrue(hasattr(module_func, '__wrapped__'))
-        self.assertEquals(len(callbacks['before']), 1)
+        self.assertEqual(len(callbacks['before']), 1)
 
         module_func('hi', foo='bar')
 
         self.assertTrue('sender' in foo, foo)
         # best we can do
-        self.assertEquals(foo['sender'].__name__, 'module_func')
+        self.assertEqual(foo['sender'].__name__, 'module_func')
         self.assertTrue('start' in foo, foo)
         self.assertTrue(foo['start'] > 0)
         self.assertTrue('stop' not in foo, foo)
         self.assertTrue('args' in foo, foo)
         self.assertTrue(len(foo['args']), 1)
-        self.assertEquals(foo['args'][0], 'hi')
+        self.assertEqual(foo['args'][0], 'hi')
         self.assertTrue('kwargs' in foo, foo)
         self.assertTrue(len(foo['kwargs']), 1)
         self.assertTrue('foo' in foo['kwargs'])
-        self.assertEquals(foo['kwargs']['foo'], 'bar')
+        self.assertEqual(foo['kwargs']['foo'], 'bar')
 
         callbacks['before'] = {}
 
@@ -318,23 +318,23 @@ class TrackingTestCase(BaseTestCase):
             foo.update(kwargs)
 
         self.assertTrue(hasattr(TrackingTestCase.class_func, '__wrapped__'))
-        self.assertEquals(len(callbacks['before']), 1)
+        self.assertEqual(len(callbacks['before']), 1)
 
         self.class_func('hello', foo='bar')
 
         self.assertTrue('sender' in foo, foo)
         # best we can do
-        self.assertEquals(foo['sender'].__name__, 'class_func')
+        self.assertEqual(foo['sender'].__name__, 'class_func')
         self.assertTrue('start' in foo, foo)
         self.assertTrue(foo['start'] > 0)
         self.assertTrue('stop' not in foo, foo)
         self.assertTrue('args' in foo, foo)
         self.assertTrue(len(foo['args']), 2)
-        self.assertEquals(foo['args'][1], 'hello')
+        self.assertEqual(foo['args'][1], 'hello')
         self.assertTrue('kwargs' in foo, foo)
         self.assertTrue(len(foo['kwargs']), 1)
         self.assertTrue('foo' in foo['kwargs'])
-        self.assertEquals(foo['kwargs']['foo'], 'bar')
+        self.assertEqual(foo['kwargs']['foo'], 'bar')
 
         callbacks['before'] = {}
 
@@ -343,13 +343,13 @@ class TrackingTestCase(BaseTestCase):
             foo.update(kwargs)
 
         self.assertTrue(hasattr(TrackingTestCase.class_method, '__wrapped__'))
-        self.assertEquals(len(callbacks['before']), 1)
+        self.assertEqual(len(callbacks['before']), 1)
 
         TrackingTestCase.class_method()
 
         self.assertTrue('sender' in foo, foo)
         # best we can do
-        self.assertEquals(foo['sender'].__name__, 'class_method')
+        self.assertEqual(foo['sender'].__name__, 'class_method')
         self.assertTrue('start' in foo, foo)
         self.assertTrue('stop' not in foo, foo)
         self.assertTrue('args' in foo, foo)
@@ -362,24 +362,24 @@ class TrackingTestCase(BaseTestCase):
             foo.update(kwargs)
 
         self.assertTrue(hasattr(module_func, '__wrapped__'))
-        self.assertEquals(len(callbacks['after']), 1)
+        self.assertEqual(len(callbacks['after']), 1)
 
         module_func('hi', foo='bar')
 
         self.assertTrue('sender' in foo, foo)
         # best we can do
-        self.assertEquals(foo['sender'].__name__, 'module_func')
+        self.assertEqual(foo['sender'].__name__, 'module_func')
         self.assertTrue('start' in foo, foo)
         self.assertTrue(foo['start'] > 0)
         self.assertTrue('stop' in foo, foo)
         self.assertTrue(foo['stop'] > foo['start'])
         self.assertTrue('args' in foo, foo)
         self.assertTrue(len(foo['args']), 1)
-        self.assertEquals(foo['args'][0], 'hi')
+        self.assertEqual(foo['args'][0], 'hi')
         self.assertTrue('kwargs' in foo, foo)
         self.assertTrue(len(foo['kwargs']), 1)
         self.assertTrue('foo' in foo['kwargs'])
-        self.assertEquals(foo['kwargs']['foo'], 'bar')
+        self.assertEqual(foo['kwargs']['foo'], 'bar')
 
         callbacks['after'] = {}
 
@@ -388,21 +388,21 @@ class TrackingTestCase(BaseTestCase):
             foo.update(kwargs)
 
         self.assertTrue(hasattr(TrackingTestCase.class_func, '__wrapped__'))
-        self.assertEquals(len(callbacks['after']), 1)
+        self.assertEqual(len(callbacks['after']), 1)
 
         self.class_func('hello', foo='bar')
 
         self.assertTrue('sender' in foo, foo)
         # best we can do
-        self.assertEquals(foo['sender'].__name__, 'class_func')
+        self.assertEqual(foo['sender'].__name__, 'class_func')
         self.assertTrue('start' in foo, foo)
         self.assertTrue(foo['start'] > 0)
         self.assertTrue('stop' in foo, foo)
         self.assertTrue(foo['stop'] > foo['start'])
         self.assertTrue('args' in foo, foo)
         self.assertTrue(len(foo['args']), 2)
-        self.assertEquals(foo['args'][1], 'hello')
+        self.assertEqual(foo['args'][1], 'hello')
         self.assertTrue('kwargs' in foo, foo)
         self.assertTrue(len(foo['kwargs']), 1)
         self.assertTrue('foo' in foo['kwargs'])
-        self.assertEquals(foo['kwargs']['foo'], 'bar')
+        self.assertEqual(foo['kwargs']['foo'], 'bar')