Updated test assertions that have been deprecated by the move to unittest2. In summary, this means:

 assert_ -> assertTrue
 assertEquals -> assertEqual
 failUnless -> assertTrue

For full details, see http://www.voidspace.org.uk/python/articles/unittest2.shtml#deprecations

git-svn-id: http://code.djangoproject.com/svn/django/trunk@15728 bcc190cf-cafb-0310-a4f2-bffc1f526a37

1 files changed, 268 insertions, 268 deletions

diff --git a/tests/regressiontests/multiple_database/tests.py b/tests/regressiontests/multiple_database/tests.py
index a8a2156237..110ee1e4a4 100644
--- a/tests/regressiontests/multiple_database/tests.py
+++ b/tests/regressiontests/multiple_database/tests.py
@@ -25,13 +25,13 @@ class QueryTestCase(TestCase):
 
     def test_db_selection(self):
         "Check that querysets will use the default database by default"
-        self.assertEquals(Book.objects.db, DEFAULT_DB_ALIAS)
-        self.assertEquals(Book.objects.all().db, DEFAULT_DB_ALIAS)
+        self.assertEqual(Book.objects.db, DEFAULT_DB_ALIAS)
+        self.assertEqual(Book.objects.all().db, DEFAULT_DB_ALIAS)
 
-        self.assertEquals(Book.objects.using('other').db, 'other')
+        self.assertEqual(Book.objects.using('other').db, 'other')
 
-        self.assertEquals(Book.objects.db_manager('other').db, 'other')
-        self.assertEquals(Book.objects.db_manager('other').all().db, 'other')
+        self.assertEqual(Book.objects.db_manager('other').db, 'other')
+        self.assertEqual(Book.objects.db_manager('other').all().db, 'other')
 
     def test_default_creation(self):
         "Objects created on the default database don't leak onto other databases"
@@ -162,18 +162,18 @@ class QueryTestCase(TestCase):
 
         # Inspect the m2m tables directly.
         # There should be 1 entry in each database
-        self.assertEquals(Book.authors.through.objects.using('default').count(), 1)
-        self.assertEquals(Book.authors.through.objects.using('other').count(), 1)
+        self.assertEqual(Book.authors.through.objects.using('default').count(), 1)
+        self.assertEqual(Book.authors.through.objects.using('other').count(), 1)
 
         # Check that queries work across m2m joins
-        self.assertEquals(list(Book.objects.using('default').filter(authors__name='Marty Alchin').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('default').filter(authors__name='Marty Alchin').values_list('title', flat=True)),
                           [u'Pro Django'])
-        self.assertEquals(list(Book.objects.using('other').filter(authors__name='Marty Alchin').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('other').filter(authors__name='Marty Alchin').values_list('title', flat=True)),
                           [])
 
-        self.assertEquals(list(Book.objects.using('default').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('default').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
                           [])
-        self.assertEquals(list(Book.objects.using('other').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('other').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
                           [u'Dive into Python'])
 
         # Reget the objects to clear caches
@@ -181,10 +181,10 @@ class QueryTestCase(TestCase):
         mark = Person.objects.using('other').get(name="Mark Pilgrim")
 
         # Retrive related object by descriptor. Related objects should be database-baound
-        self.assertEquals(list(dive.authors.all().values_list('name', flat=True)),
+        self.assertEqual(list(dive.authors.all().values_list('name', flat=True)),
                           [u'Mark Pilgrim'])
 
-        self.assertEquals(list(mark.book_set.all().values_list('title', flat=True)),
+        self.assertEqual(list(mark.book_set.all().values_list('title', flat=True)),
                           [u'Dive into Python'])
 
     def test_m2m_forward_operations(self):
@@ -200,35 +200,35 @@ class QueryTestCase(TestCase):
 
         # Add a second author
         john = Person.objects.using('other').create(name="John Smith")
-        self.assertEquals(list(Book.objects.using('other').filter(authors__name='John Smith').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('other').filter(authors__name='John Smith').values_list('title', flat=True)),
                           [])
 
 
         dive.authors.add(john)
-        self.assertEquals(list(Book.objects.using('other').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('other').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
                           [u'Dive into Python'])
-        self.assertEquals(list(Book.objects.using('other').filter(authors__name='John Smith').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('other').filter(authors__name='John Smith').values_list('title', flat=True)),
                           [u'Dive into Python'])
 
         # Remove the second author
         dive.authors.remove(john)
-        self.assertEquals(list(Book.objects.using('other').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('other').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
                           [u'Dive into Python'])
-        self.assertEquals(list(Book.objects.using('other').filter(authors__name='John Smith').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('other').filter(authors__name='John Smith').values_list('title', flat=True)),
                           [])
 
         # Clear all authors
         dive.authors.clear()
-        self.assertEquals(list(Book.objects.using('other').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('other').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
                           [])
-        self.assertEquals(list(Book.objects.using('other').filter(authors__name='John Smith').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('other').filter(authors__name='John Smith').values_list('title', flat=True)),
                           [])
 
         # Create an author through the m2m interface
         dive.authors.create(name='Jane Brown')
-        self.assertEquals(list(Book.objects.using('other').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('other').filter(authors__name='Mark Pilgrim').values_list('title', flat=True)),
                           [])
-        self.assertEquals(list(Book.objects.using('other').filter(authors__name='Jane Brown').values_list('title', flat=True)),
+        self.assertEqual(list(Book.objects.using('other').filter(authors__name='Jane Brown').values_list('title', flat=True)),
                           [u'Dive into Python'])
 
     def test_m2m_reverse_operations(self):
@@ -248,30 +248,30 @@ class QueryTestCase(TestCase):
 
         # Add a books to the m2m
         mark.book_set.add(grease)
-        self.assertEquals(list(Person.objects.using('other').filter(book__title='Dive into Python').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(book__title='Dive into Python').values_list('name', flat=True)),
                           [u'Mark Pilgrim'])
-        self.assertEquals(list(Person.objects.using('other').filter(book__title='Greasemonkey Hacks').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(book__title='Greasemonkey Hacks').values_list('name', flat=True)),
                           [u'Mark Pilgrim'])
 
         # Remove a book from the m2m
         mark.book_set.remove(grease)
-        self.assertEquals(list(Person.objects.using('other').filter(book__title='Dive into Python').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(book__title='Dive into Python').values_list('name', flat=True)),
                           [u'Mark Pilgrim'])
-        self.assertEquals(list(Person.objects.using('other').filter(book__title='Greasemonkey Hacks').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(book__title='Greasemonkey Hacks').values_list('name', flat=True)),
                           [])
 
         # Clear the books associated with mark
         mark.book_set.clear()
-        self.assertEquals(list(Person.objects.using('other').filter(book__title='Dive into Python').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(book__title='Dive into Python').values_list('name', flat=True)),
                           [])
-        self.assertEquals(list(Person.objects.using('other').filter(book__title='Greasemonkey Hacks').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(book__title='Greasemonkey Hacks').values_list('name', flat=True)),
                           [])
 
         # Create a book through the m2m interface
         mark.book_set.create(title="Dive into HTML5", published=datetime.date(2020, 1, 1))
-        self.assertEquals(list(Person.objects.using('other').filter(book__title='Dive into Python').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(book__title='Dive into Python').values_list('name', flat=True)),
                           [])
-        self.assertEquals(list(Person.objects.using('other').filter(book__title='Dive into HTML5').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(book__title='Dive into HTML5').values_list('name', flat=True)),
                           [u'Mark Pilgrim'])
 
     def test_m2m_cross_database_protection(self):
@@ -332,27 +332,27 @@ class QueryTestCase(TestCase):
         dive.authors = [mark]
 
         # Check the initial state
-        self.assertEquals(Person.objects.using('default').count(), 0)
-        self.assertEquals(Book.objects.using('default').count(), 0)
-        self.assertEquals(Book.authors.through.objects.using('default').count(), 0)
+        self.assertEqual(Person.objects.using('default').count(), 0)
+        self.assertEqual(Book.objects.using('default').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('default').count(), 0)
 
-        self.assertEquals(Person.objects.using('other').count(), 1)
-        self.assertEquals(Book.objects.using('other').count(), 1)
-        self.assertEquals(Book.authors.through.objects.using('other').count(), 1)
+        self.assertEqual(Person.objects.using('other').count(), 1)
+        self.assertEqual(Book.objects.using('other').count(), 1)
+        self.assertEqual(Book.authors.through.objects.using('other').count(), 1)
 
         # Delete the object on the other database
         dive.delete(using='other')
 
-        self.assertEquals(Person.objects.using('default').count(), 0)
-        self.assertEquals(Book.objects.using('default').count(), 0)
-        self.assertEquals(Book.authors.through.objects.using('default').count(), 0)
+        self.assertEqual(Person.objects.using('default').count(), 0)
+        self.assertEqual(Book.objects.using('default').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('default').count(), 0)
 
         # The person still exists ...
-        self.assertEquals(Person.objects.using('other').count(), 1)
+        self.assertEqual(Person.objects.using('other').count(), 1)
         # ... but the book has been deleted
-        self.assertEquals(Book.objects.using('other').count(), 0)
+        self.assertEqual(Book.objects.using('other').count(), 0)
         # ... and the relationship object has also been deleted.
-        self.assertEquals(Book.authors.through.objects.using('other').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('other').count(), 0)
 
         # Now try deletion in the reverse direction. Set up the relation again
         dive = Book.objects.using('other').create(title="Dive into Python",
@@ -360,27 +360,27 @@ class QueryTestCase(TestCase):
         dive.authors = [mark]
 
         # Check the initial state
-        self.assertEquals(Person.objects.using('default').count(), 0)
-        self.assertEquals(Book.objects.using('default').count(), 0)
-        self.assertEquals(Book.authors.through.objects.using('default').count(), 0)
+        self.assertEqual(Person.objects.using('default').count(), 0)
+        self.assertEqual(Book.objects.using('default').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('default').count(), 0)
 
-        self.assertEquals(Person.objects.using('other').count(), 1)
-        self.assertEquals(Book.objects.using('other').count(), 1)
-        self.assertEquals(Book.authors.through.objects.using('other').count(), 1)
+        self.assertEqual(Person.objects.using('other').count(), 1)
+        self.assertEqual(Book.objects.using('other').count(), 1)
+        self.assertEqual(Book.authors.through.objects.using('other').count(), 1)
 
         # Delete the object on the other database
         mark.delete(using='other')
 
-        self.assertEquals(Person.objects.using('default').count(), 0)
-        self.assertEquals(Book.objects.using('default').count(), 0)
-        self.assertEquals(Book.authors.through.objects.using('default').count(), 0)
+        self.assertEqual(Person.objects.using('default').count(), 0)
+        self.assertEqual(Book.objects.using('default').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('default').count(), 0)
 
         # The person has been deleted ...
-        self.assertEquals(Person.objects.using('other').count(), 0)
+        self.assertEqual(Person.objects.using('other').count(), 0)
         # ... but the book still exists
-        self.assertEquals(Book.objects.using('other').count(), 1)
+        self.assertEqual(Book.objects.using('other').count(), 1)
         # ... and the relationship object has been deleted.
-        self.assertEquals(Book.authors.through.objects.using('other').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('other').count(), 0)
 
     def test_foreign_key_separation(self):
         "FK fields are constrained to a single database"
@@ -406,20 +406,20 @@ class QueryTestCase(TestCase):
         dive.save()
 
         pro = Book.objects.using('default').get(title="Pro Django")
-        self.assertEquals(pro.editor.name, "George Vilches")
+        self.assertEqual(pro.editor.name, "George Vilches")
 
         dive = Book.objects.using('other').get(title="Dive into Python")
-        self.assertEquals(dive.editor.name, "Chris Mills")
+        self.assertEqual(dive.editor.name, "Chris Mills")
 
         # Check that queries work across foreign key joins
-        self.assertEquals(list(Person.objects.using('default').filter(edited__title='Pro Django').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('default').filter(edited__title='Pro Django').values_list('name', flat=True)),
                           [u'George Vilches'])
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Pro Django').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Pro Django').values_list('name', flat=True)),
                           [])
 
-        self.assertEquals(list(Person.objects.using('default').filter(edited__title='Dive into Python').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('default').filter(edited__title='Dive into Python').values_list('name', flat=True)),
                           [])
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Dive into Python').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Dive into Python').values_list('name', flat=True)),
                           [u'Chris Mills'])
 
         # Reget the objects to clear caches
@@ -427,7 +427,7 @@ class QueryTestCase(TestCase):
         dive = Book.objects.using('other').get(title="Dive into Python")
 
         # Retrive related object by descriptor. Related objects should be database-baound
-        self.assertEquals(list(chris.edited.values_list('title', flat=True)),
+        self.assertEqual(list(chris.edited.values_list('title', flat=True)),
                           [u'Dive into Python'])
 
     def test_foreign_key_reverse_operations(self):
@@ -444,36 +444,36 @@ class QueryTestCase(TestCase):
 
         # Add a second book edited by chris
         html5 = Book.objects.using('other').create(title="Dive into HTML5", published=datetime.date(2010, 3, 15))
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Dive into HTML5').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Dive into HTML5').values_list('name', flat=True)),
                           [])
 
         chris.edited.add(html5)
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Dive into HTML5').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Dive into HTML5').values_list('name', flat=True)),
                           [u'Chris Mills'])
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Dive into Python').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Dive into Python').values_list('name', flat=True)),
                           [u'Chris Mills'])
 
         # Remove the second editor
         chris.edited.remove(html5)
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Dive into HTML5').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Dive into HTML5').values_list('name', flat=True)),
                           [])
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Dive into Python').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Dive into Python').values_list('name', flat=True)),
                           [u'Chris Mills'])
 
         # Clear all edited books
         chris.edited.clear()
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Dive into HTML5').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Dive into HTML5').values_list('name', flat=True)),
                           [])
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Dive into Python').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Dive into Python').values_list('name', flat=True)),
                           [])
 
         # Create an author through the m2m interface
         chris.edited.create(title='Dive into Water', published=datetime.date(2010, 3, 15))
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Dive into HTML5').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Dive into HTML5').values_list('name', flat=True)),
                           [])
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Dive into Water').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Dive into Water').values_list('name', flat=True)),
                           [u'Chris Mills'])
-        self.assertEquals(list(Person.objects.using('other').filter(edited__title='Dive into Python').values_list('name', flat=True)),
+        self.assertEqual(list(Person.objects.using('other').filter(edited__title='Dive into Python').values_list('name', flat=True)),
                           [])
 
     def test_foreign_key_cross_database_protection(self):
@@ -517,46 +517,46 @@ class QueryTestCase(TestCase):
         chris = Person(name="Chris Mills")
         html5 = Book(title="Dive into HTML5", published=datetime.date(2010, 3, 15))
         # initially, no db assigned
-        self.assertEquals(chris._state.db, None)
-        self.assertEquals(html5._state.db, None)
+        self.assertEqual(chris._state.db, None)
+        self.assertEqual(html5._state.db, None)
 
         # old object comes from 'other', so the new object is set to use 'other'...
         dive.editor = chris
         html5.editor = mark
-        self.assertEquals(chris._state.db, 'other')
-        self.assertEquals(html5._state.db, 'other')
+        self.assertEqual(chris._state.db, 'other')
+        self.assertEqual(html5._state.db, 'other')
         # ... but it isn't saved yet
-        self.assertEquals(list(Person.objects.using('other').values_list('name',flat=True)),
+        self.assertEqual(list(Person.objects.using('other').values_list('name',flat=True)),
                           [u'Mark Pilgrim'])
-        self.assertEquals(list(Book.objects.using('other').values_list('title',flat=True)),
+        self.assertEqual(list(Book.objects.using('other').values_list('title',flat=True)),
                            [u'Dive into Python'])
 
         # When saved (no using required), new objects goes to 'other'
         chris.save()
         html5.save()
-        self.assertEquals(list(Person.objects.using('default').values_list('name',flat=True)),
+        self.assertEqual(list(Person.objects.using('default').values_list('name',flat=True)),
                           [u'Marty Alchin'])
-        self.assertEquals(list(Person.objects.using('other').values_list('name',flat=True)),
+        self.assertEqual(list(Person.objects.using('other').values_list('name',flat=True)),
                           [u'Chris Mills', u'Mark Pilgrim'])
-        self.assertEquals(list(Book.objects.using('default').values_list('title',flat=True)),
+        self.assertEqual(list(Book.objects.using('default').values_list('title',flat=True)),
                           [u'Pro Django'])
-        self.assertEquals(list(Book.objects.using('other').values_list('title',flat=True)),
+        self.assertEqual(list(Book.objects.using('other').values_list('title',flat=True)),
                           [u'Dive into HTML5', u'Dive into Python'])
 
         # This also works if you assign the FK in the constructor
         water = Book(title="Dive into Water", published=datetime.date(2001, 1, 1), editor=mark)
-        self.assertEquals(water._state.db, 'other')
+        self.assertEqual(water._state.db, 'other')
         # ... but it isn't saved yet
-        self.assertEquals(list(Book.objects.using('default').values_list('title',flat=True)),
+        self.assertEqual(list(Book.objects.using('default').values_list('title',flat=True)),
                           [u'Pro Django'])
-        self.assertEquals(list(Book.objects.using('other').values_list('title',flat=True)),
+        self.assertEqual(list(Book.objects.using('other').values_list('title',flat=True)),
                           [u'Dive into HTML5', u'Dive into Python'])
 
         # When saved, the new book goes to 'other'
         water.save()
-        self.assertEquals(list(Book.objects.using('default').values_list('title',flat=True)),
+        self.assertEqual(list(Book.objects.using('default').values_list('title',flat=True)),
                           [u'Pro Django'])
-        self.assertEquals(list(Book.objects.using('other').values_list('title',flat=True)),
+        self.assertEqual(list(Book.objects.using('other').values_list('title',flat=True)),
                           [u'Dive into HTML5', u'Dive into Python', u'Dive into Water'])
 
     def test_foreign_key_deletion(self):
@@ -565,27 +565,27 @@ class QueryTestCase(TestCase):
         fido = Pet.objects.using('other').create(name="Fido", owner=mark)
 
         # Check the initial state
-        self.assertEquals(Person.objects.using('default').count(), 0)
-        self.assertEquals(Pet.objects.using('default').count(), 0)
+        self.assertEqual(Person.objects.using('default').count(), 0)
+        self.assertEqual(Pet.objects.using('default').count(), 0)
 
-        self.assertEquals(Person.objects.using('other').count(), 1)
-        self.assertEquals(Pet.objects.using('other').count(), 1)
+        self.assertEqual(Person.objects.using('other').count(), 1)
+        self.assertEqual(Pet.objects.using('other').count(), 1)
 
         # Delete the person object, which will cascade onto the pet
         mark.delete(using='other')
 
-        self.assertEquals(Person.objects.using('default').count(), 0)
-        self.assertEquals(Pet.objects.using('default').count(), 0)
+        self.assertEqual(Person.objects.using('default').count(), 0)
+        self.assertEqual(Pet.objects.using('default').count(), 0)
 
         # Both the pet and the person have been deleted from the right database
-        self.assertEquals(Person.objects.using('other').count(), 0)
-        self.assertEquals(Pet.objects.using('other').count(), 0)
+        self.assertEqual(Person.objects.using('other').count(), 0)
+        self.assertEqual(Pet.objects.using('other').count(), 0)
 
     def test_foreign_key_validation(self):
         "ForeignKey.validate() uses the correct database"
         mickey = Person.objects.using('other').create(name="Mickey")
         pluto = Pet.objects.using('other').create(name="Pluto", owner=mickey)
-        self.assertEquals(None, pluto.full_clean())
+        self.assertEqual(None, pluto.full_clean())
 
     def test_o2o_separation(self):
         "OneToOne fields are constrained to a single database"
@@ -599,20 +599,20 @@ class QueryTestCase(TestCase):
 
         # Retrieve related objects; queries should be database constrained
         alice = User.objects.using('default').get(username="alice")
-        self.assertEquals(alice.userprofile.flavor, "chocolate")
+        self.assertEqual(alice.userprofile.flavor, "chocolate")
 
         bob = User.objects.using('other').get(username="bob")
-        self.assertEquals(bob.userprofile.flavor, "crunchy frog")
+        self.assertEqual(bob.userprofile.flavor, "crunchy frog")
 
         # Check that queries work across joins
-        self.assertEquals(list(User.objects.using('default').filter(userprofile__flavor='chocolate').values_list('username', flat=True)),
+        self.assertEqual(list(User.objects.using('default').filter(userprofile__flavor='chocolate').values_list('username', flat=True)),
                           [u'alice'])
-        self.assertEquals(list(User.objects.using('other').filter(userprofile__flavor='chocolate').values_list('username', flat=True)),
+        self.assertEqual(list(User.objects.using('other').filter(userprofile__flavor='chocolate').values_list('username', flat=True)),
                           [])
 
-        self.assertEquals(list(User.objects.using('default').filter(userprofile__flavor='crunchy frog').values_list('username', flat=True)),
+        self.assertEqual(list(User.objects.using('default').filter(userprofile__flavor='crunchy frog').values_list('username', flat=True)),
                           [])
-        self.assertEquals(list(User.objects.using('other').filter(userprofile__flavor='crunchy frog').values_list('username', flat=True)),
+        self.assertEqual(list(User.objects.using('other').filter(userprofile__flavor='crunchy frog').values_list('username', flat=True)),
                           [u'bob'])
 
         # Reget the objects to clear caches
@@ -620,8 +620,8 @@ class QueryTestCase(TestCase):
         bob_profile = UserProfile.objects.using('other').get(flavor='crunchy frog')
 
         # Retrive related object by descriptor. Related objects should be database-baound
-        self.assertEquals(alice_profile.user.username, 'alice')
-        self.assertEquals(bob_profile.user.username, 'bob')
+        self.assertEqual(alice_profile.user.username, 'alice')
+        self.assertEqual(bob_profile.user.username, 'bob')
 
     def test_o2o_cross_database_protection(self):
         "Operations that involve sharing FK objects across databases raise an error"
@@ -650,50 +650,50 @@ class QueryTestCase(TestCase):
         charlie.set_unusable_password()
 
         # initially, no db assigned
-        self.assertEquals(new_bob_profile._state.db, None)
-        self.assertEquals(charlie._state.db, None)
+        self.assertEqual(new_bob_profile._state.db, None)
+        self.assertEqual(charlie._state.db, None)
 
         # old object comes from 'other', so the new object is set to use 'other'...
         new_bob_profile.user = bob
         charlie.userprofile = bob_profile
-        self.assertEquals(new_bob_profile._state.db, 'other')
-        self.assertEquals(charlie._state.db, 'other')
+        self.assertEqual(new_bob_profile._state.db, 'other')
+        self.assertEqual(charlie._state.db, 'other')
 
         # ... but it isn't saved yet
-        self.assertEquals(list(User.objects.using('other').values_list('username',flat=True)),
+        self.assertEqual(list(User.objects.using('other').values_list('username',flat=True)),
                           [u'bob'])
-        self.assertEquals(list(UserProfile.objects.using('other').values_list('flavor',flat=True)),
+        self.assertEqual(list(UserProfile.objects.using('other').values_list('flavor',flat=True)),
                            [u'crunchy frog'])
 
         # When saved (no using required), new objects goes to 'other'
         charlie.save()
         bob_profile.save()
         new_bob_profile.save()
-        self.assertEquals(list(User.objects.using('default').values_list('username',flat=True)),
+        self.assertEqual(list(User.objects.using('default').values_list('username',flat=True)),
                           [u'alice'])
-        self.assertEquals(list(User.objects.using('other').values_list('username',flat=True)),
+        self.assertEqual(list(User.objects.using('other').values_list('username',flat=True)),
                           [u'bob', u'charlie'])
-        self.assertEquals(list(UserProfile.objects.using('default').values_list('flavor',flat=True)),
+        self.assertEqual(list(UserProfile.objects.using('default').values_list('flavor',flat=True)),
                            [u'chocolate'])
-        self.assertEquals(list(UserProfile.objects.using('other').values_list('flavor',flat=True)),
+        self.assertEqual(list(UserProfile.objects.using('other').values_list('flavor',flat=True)),
                            [u'crunchy frog', u'spring surprise'])
 
         # This also works if you assign the O2O relation in the constructor
         denise = User.objects.db_manager('other').create_user('denise','denise@example.com')
         denise_profile = UserProfile(flavor="tofu", user=denise)
 
-        self.assertEquals(denise_profile._state.db, 'other')
+        self.assertEqual(denise_profile._state.db, 'other')
         # ... but it isn't saved yet
-        self.assertEquals(list(UserProfile.objects.using('default').values_list('flavor',flat=True)),
+        self.assertEqual(list(UserProfile.objects.using('default').values_list('flavor',flat=True)),
                            [u'chocolate'])
-        self.assertEquals(list(UserProfile.objects.using('other').values_list('flavor',flat=True)),
+        self.assertEqual(list(UserProfile.objects.using('other').values_list('flavor',flat=True)),
                            [u'crunchy frog', u'spring surprise'])
 
         # When saved, the new profile goes to 'other'
         denise_profile.save()
-        self.assertEquals(list(UserProfile.objects.using('default').values_list('flavor',flat=True)),
+        self.assertEqual(list(UserProfile.objects.using('default').values_list('flavor',flat=True)),
                            [u'chocolate'])
-        self.assertEquals(list(UserProfile.objects.using('other').values_list('flavor',flat=True)),
+        self.assertEqual(list(UserProfile.objects.using('other').values_list('flavor',flat=True)),
                            [u'crunchy frog', u'spring surprise', u'tofu'])
 
     def test_generic_key_separation(self):
@@ -711,16 +711,16 @@ class QueryTestCase(TestCase):
         review2 = Review.objects.using('other').create(source="Python Weekly", content_object=dive)
 
         review1 = Review.objects.using('default').get(source="Python Monthly")
-        self.assertEquals(review1.content_object.title, "Pro Django")
+        self.assertEqual(review1.content_object.title, "Pro Django")
 
         review2 = Review.objects.using('other').get(source="Python Weekly")
-        self.assertEquals(review2.content_object.title, "Dive into Python")
+        self.assertEqual(review2.content_object.title, "Dive into Python")
 
         # Reget the objects to clear caches
         dive = Book.objects.using('other').get(title="Dive into Python")
 
         # Retrive related object by descriptor. Related objects should be database-bound
-        self.assertEquals(list(dive.reviews.all().values_list('source', flat=True)),
+        self.assertEqual(list(dive.reviews.all().values_list('source', flat=True)),
                           [u'Python Weekly'])
 
     def test_generic_key_reverse_operations(self):
@@ -734,37 +734,37 @@ class QueryTestCase(TestCase):
         review1 = Review.objects.using('other').create(source="Python Weekly", content_object=dive)
         review2 = Review.objects.using('other').create(source="Python Monthly", content_object=temp)
 
-        self.assertEquals(list(Review.objects.using('default').filter(object_id=dive.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('default').filter(object_id=dive.pk).values_list('source', flat=True)),
                           [])
-        self.assertEquals(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
                           [u'Python Weekly'])
 
         # Add a second review
         dive.reviews.add(review2)
-        self.assertEquals(list(Review.objects.using('default').filter(object_id=dive.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('default').filter(object_id=dive.pk).values_list('source', flat=True)),
                           [])
-        self.assertEquals(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
                           [u'Python Monthly', u'Python Weekly'])
 
         # Remove the second author
         dive.reviews.remove(review1)
-        self.assertEquals(list(Review.objects.using('default').filter(object_id=dive.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('default').filter(object_id=dive.pk).values_list('source', flat=True)),
                           [])
-        self.assertEquals(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
                           [u'Python Monthly'])
 
         # Clear all reviews
         dive.reviews.clear()
-        self.assertEquals(list(Review.objects.using('default').filter(object_id=dive.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('default').filter(object_id=dive.pk).values_list('source', flat=True)),
                           [])
-        self.assertEquals(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
                           [])
 
         # Create an author through the generic interface
         dive.reviews.create(source='Python Daily')
-        self.assertEquals(list(Review.objects.using('default').filter(object_id=dive.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('default').filter(object_id=dive.pk).values_list('source', flat=True)),
                           [])
-        self.assertEquals(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
                           [u'Python Daily'])
 
     def test_generic_key_cross_database_protection(self):
@@ -800,22 +800,22 @@ class QueryTestCase(TestCase):
         # base object.
         review3 = Review(source="Python Daily")
         # initially, no db assigned
-        self.assertEquals(review3._state.db, None)
+        self.assertEqual(review3._state.db, None)
 
         # Dive comes from 'other', so review3 is set to use 'other'...
         review3.content_object = dive
-        self.assertEquals(review3._state.db, 'other')
+        self.assertEqual(review3._state.db, 'other')
         # ... but it isn't saved yet
-        self.assertEquals(list(Review.objects.using('default').filter(object_id=pro.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('default').filter(object_id=pro.pk).values_list('source', flat=True)),
                           [u'Python Monthly'])
-        self.assertEquals(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source',flat=True)),
+        self.assertEqual(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source',flat=True)),
                           [u'Python Weekly'])
 
         # When saved, John goes to 'other'
         review3.save()
-        self.assertEquals(list(Review.objects.using('default').filter(object_id=pro.pk).values_list('source', flat=True)),
+        self.assertEqual(list(Review.objects.using('default').filter(object_id=pro.pk).values_list('source', flat=True)),
                           [u'Python Monthly'])
-        self.assertEquals(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source',flat=True)),
+        self.assertEqual(list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source',flat=True)),
                           [u'Python Daily', u'Python Weekly'])
 
     def test_generic_key_deletion(self):
@@ -825,21 +825,21 @@ class QueryTestCase(TestCase):
         review = Review.objects.using('other').create(source="Python Weekly", content_object=dive)
 
         # Check the initial state
-        self.assertEquals(Book.objects.using('default').count(), 0)
-        self.assertEquals(Review.objects.using('default').count(), 0)
+        self.assertEqual(Book.objects.using('default').count(), 0)
+        self.assertEqual(Review.objects.using('default').count(), 0)
 
-        self.assertEquals(Book.objects.using('other').count(), 1)
-        self.assertEquals(Review.objects.using('other').count(), 1)
+        self.assertEqual(Book.objects.using('other').count(), 1)
+        self.assertEqual(Review.objects.using('other').count(), 1)
 
         # Delete the Book object, which will cascade onto the pet
         dive.delete(using='other')
 
-        self.assertEquals(Book.objects.using('default').count(), 0)
-        self.assertEquals(Review.objects.using('default').count(), 0)
+        self.assertEqual(Book.objects.using('default').count(), 0)
+        self.assertEqual(Review.objects.using('default').count(), 0)
 
         # Both the pet and the person have been deleted from the right database
-        self.assertEquals(Book.objects.using('other').count(), 0)
-        self.assertEquals(Review.objects.using('other').count(), 0)
+        self.assertEqual(Book.objects.using('other').count(), 0)
+        self.assertEqual(Review.objects.using('other').count(), 0)
 
     def test_ordering(self):
         "get_next_by_XXX commands stick to a single database"
@@ -852,8 +852,8 @@ class QueryTestCase(TestCase):
         learn = Book.objects.using('other').create(title="Learning Python",
                                                    published=datetime.date(2008, 7, 16))
 
-        self.assertEquals(learn.get_next_by_published().title, "Dive into Python")
-        self.assertEquals(dive.get_previous_by_published().title, "Learning Python")
+        self.assertEqual(learn.get_next_by_published().title, "Dive into Python")
+        self.assertEqual(dive.get_previous_by_published().title, "Learning Python")
 
     def test_raw(self):
         "test the raw() method across databases"
@@ -988,13 +988,13 @@ class RouterTestCase(TestCase):
 
     def test_db_selection(self):
         "Check that querysets obey the router for db suggestions"
-        self.assertEquals(Book.objects.db, 'other')
-        self.assertEquals(Book.objects.all().db, 'other')
+        self.assertEqual(Book.objects.db, 'other')
+        self.assertEqual(Book.objects.all().db, 'other')
 
-        self.assertEquals(Book.objects.using('default').db, 'default')
+        self.assertEqual(Book.objects.using('default').db, 'default')
 
-        self.assertEquals(Book.objects.db_manager('default').db, 'default')
-        self.assertEquals(Book.objects.db_manager('default').all().db, 'default')
+        self.assertEqual(Book.objects.db_manager('default').db, 'default')
+        self.assertEqual(Book.objects.db_manager('default').all().db, 'default')
 
     def test_syncdb_selection(self):
         "Synchronization behaviour is predicatable"
@@ -1031,11 +1031,11 @@ class RouterTestCase(TestCase):
 
         # First check the baseline behaviour
 
-        self.assertEquals(router.db_for_read(User), 'other')
-        self.assertEquals(router.db_for_read(Book), 'other')
+        self.assertEqual(router.db_for_read(User), 'other')
+        self.assertEqual(router.db_for_read(Book), 'other')
 
-        self.assertEquals(router.db_for_write(User), 'default')
-        self.assertEquals(router.db_for_write(Book), 'default')
+        self.assertEqual(router.db_for_write(User), 'default')
+        self.assertEqual(router.db_for_write(Book), 'default')
 
         self.assertTrue(router.allow_relation(dive, dive))
 
@@ -1044,11 +1044,11 @@ class RouterTestCase(TestCase):
 
         router.routers = [WriteRouter(), AuthRouter(), TestRouter()]
 
-        self.assertEquals(router.db_for_read(User), 'default')
-        self.assertEquals(router.db_for_read(Book), 'other')
+        self.assertEqual(router.db_for_read(User), 'default')
+        self.assertEqual(router.db_for_read(Book), 'other')
 
-        self.assertEquals(router.db_for_write(User), 'writer')
-        self.assertEquals(router.db_for_write(Book), 'writer')
+        self.assertEqual(router.db_for_write(User), 'writer')
+        self.assertEqual(router.db_for_write(Book), 'writer')
 
         self.assertTrue(router.allow_relation(dive, dive))
 
@@ -1081,17 +1081,17 @@ class RouterTestCase(TestCase):
         pro = Book.objects.using('default').get(title='Pro Django')
 
         # Check that the update worked.
-        self.assertEquals(pro.pages, 200)
+        self.assertEqual(pro.pages, 200)
 
         # An update query with an explicit using clause will be routed
         # to the requested database.
         Book.objects.using('other').filter(title='Dive into Python').update(pages=300)
-        self.assertEquals(Book.objects.get(title='Dive into Python').pages, 300)
+        self.assertEqual(Book.objects.get(title='Dive into Python').pages, 300)
 
         # Related object queries stick to the same database
         # as the original object, regardless of the router
-        self.assertEquals(list(pro.authors.values_list('name', flat=True)), [u'Marty Alchin'])
-        self.assertEquals(pro.editor.name, u'Marty Alchin')
+        self.assertEqual(list(pro.authors.values_list('name', flat=True)), [u'Marty Alchin'])
+        self.assertEqual(pro.editor.name, u'Marty Alchin')
 
         # get_or_create is a special case. The get needs to be targetted at
         # the write database in order to avoid potential transaction
@@ -1104,17 +1104,17 @@ class RouterTestCase(TestCase):
         self.assertTrue(created)
 
         # Check the head count of objects
-        self.assertEquals(Book.objects.using('default').count(), 2)
-        self.assertEquals(Book.objects.using('other').count(), 1)
+        self.assertEqual(Book.objects.using('default').count(), 2)
+        self.assertEqual(Book.objects.using('other').count(), 1)
         # If a database isn't specified, the read database is used
-        self.assertEquals(Book.objects.count(), 1)
+        self.assertEqual(Book.objects.count(), 1)
 
         # A delete query will also be routed to the default database
         Book.objects.filter(pages__gt=150).delete()
 
         # The default database has lost the book.
-        self.assertEquals(Book.objects.using('default').count(), 1)
-        self.assertEquals(Book.objects.using('other').count(), 1)
+        self.assertEqual(Book.objects.using('default').count(), 1)
+        self.assertEqual(Book.objects.using('other').count(), 1)
 
     def test_foreign_key_cross_database_protection(self):
         "Foreign keys can cross databases if they two databases have a common source"
@@ -1137,14 +1137,14 @@ class RouterTestCase(TestCase):
             self.fail("Assignment across master/slave databases with a common source should be ok")
 
         # Database assignments of original objects haven't changed...
-        self.assertEquals(marty._state.db, 'default')
-        self.assertEquals(pro._state.db, 'default')
-        self.assertEquals(dive._state.db, 'other')
-        self.assertEquals(mark._state.db, 'other')
+        self.assertEqual(marty._state.db, 'default')
+        self.assertEqual(pro._state.db, 'default')
+        self.assertEqual(dive._state.db, 'other')
+        self.assertEqual(mark._state.db, 'other')
 
         # ... but they will when the affected object is saved.
         dive.save()
-        self.assertEquals(dive._state.db, 'default')
+        self.assertEqual(dive._state.db, 'default')
 
         # ...and the source database now has a copy of any object saved
         try:
@@ -1154,7 +1154,7 @@ class RouterTestCase(TestCase):
 
         # This isn't a real master-slave database, so restore the original from other
         dive = Book.objects.using('other').get(title='Dive into Python')
-        self.assertEquals(dive._state.db, 'other')
+        self.assertEqual(dive._state.db, 'other')
 
         # Set a foreign key set with an object from a different database
         try:
@@ -1163,10 +1163,10 @@ class RouterTestCase(TestCase):
             self.fail("Assignment across master/slave databases with a common source should be ok")
 
         # Assignment implies a save, so database assignments of original objects have changed...
-        self.assertEquals(marty._state.db, 'default')
-        self.assertEquals(pro._state.db, 'default')
-        self.assertEquals(dive._state.db, 'default')
-        self.assertEquals(mark._state.db, 'other')
+        self.assertEqual(marty._state.db, 'default')
+        self.assertEqual(pro._state.db, 'default')
+        self.assertEqual(dive._state.db, 'default')
+        self.assertEqual(mark._state.db, 'other')
 
         # ...and the source database now has a copy of any object saved
         try:
@@ -1176,7 +1176,7 @@ class RouterTestCase(TestCase):
 
         # This isn't a real master-slave database, so restore the original from other
         dive = Book.objects.using('other').get(title='Dive into Python')
-        self.assertEquals(dive._state.db, 'other')
+        self.assertEqual(dive._state.db, 'other')
 
         # Add to a foreign key set with an object from a different database
         try:
@@ -1185,10 +1185,10 @@ class RouterTestCase(TestCase):
             self.fail("Assignment across master/slave databases with a common source should be ok")
 
         # Add implies a save, so database assignments of original objects have changed...
-        self.assertEquals(marty._state.db, 'default')
-        self.assertEquals(pro._state.db, 'default')
-        self.assertEquals(dive._state.db, 'default')
-        self.assertEquals(mark._state.db, 'other')
+        self.assertEqual(marty._state.db, 'default')
+        self.assertEqual(pro._state.db, 'default')
+        self.assertEqual(dive._state.db, 'default')
+        self.assertEqual(mark._state.db, 'other')
 
         # ...and the source database now has a copy of any object saved
         try:
@@ -1205,36 +1205,36 @@ class RouterTestCase(TestCase):
         chris = Person(name="Chris Mills")
         html5 = Book(title="Dive into HTML5", published=datetime.date(2010, 3, 15))
         # initially, no db assigned
-        self.assertEquals(chris._state.db, None)
-        self.assertEquals(html5._state.db, None)
+        self.assertEqual(chris._state.db, None)
+        self.assertEqual(html5._state.db, None)
 
         # old object comes from 'other', so the new object is set to use the
         # source of 'other'...
-        self.assertEquals(dive._state.db, 'other')
+        self.assertEqual(dive._state.db, 'other')
         dive.editor = chris
         html5.editor = mark
 
-        self.assertEquals(dive._state.db, 'other')
-        self.assertEquals(mark._state.db, 'other')
-        self.assertEquals(chris._state.db, 'default')
-        self.assertEquals(html5._state.db, 'default')
+        self.assertEqual(dive._state.db, 'other')
+        self.assertEqual(mark._state.db, 'other')
+        self.assertEqual(chris._state.db, 'default')
+        self.assertEqual(html5._state.db, 'default')
 
         # This also works if you assign the FK in the constructor
         water = Book(title="Dive into Water", published=datetime.date(2001, 1, 1), editor=mark)
-        self.assertEquals(water._state.db, 'default')
+        self.assertEqual(water._state.db, 'default')
 
         # If you create an object through a FK relation, it will be
         # written to the write database, even if the original object
         # was on the read database
         cheesecake = mark.edited.create(title='Dive into Cheesecake', published=datetime.date(2010, 3, 15))
-        self.assertEquals(cheesecake._state.db, 'default')
+        self.assertEqual(cheesecake._state.db, 'default')
 
         # Same goes for get_or_create, regardless of whether getting or creating
         cheesecake, created = mark.edited.get_or_create(title='Dive into Cheesecake', published=datetime.date(2010, 3, 15))
-        self.assertEquals(cheesecake._state.db, 'default')
+        self.assertEqual(cheesecake._state.db, 'default')
 
         puddles, created = mark.edited.get_or_create(title='Dive into Puddles', published=datetime.date(2010, 3, 15))
-        self.assertEquals(puddles._state.db, 'default')
+        self.assertEqual(puddles._state.db, 'default')
 
     def test_m2m_cross_database_protection(self):
         "M2M relations can cross databases if the database share a source"
@@ -1258,10 +1258,10 @@ class RouterTestCase(TestCase):
         mark.save(using='other')
 
         # Check that we have 2 of both types of object on both databases
-        self.assertEquals(Book.objects.using('default').count(), 2)
-        self.assertEquals(Book.objects.using('other').count(), 2)
-        self.assertEquals(Person.objects.using('default').count(), 2)
-        self.assertEquals(Person.objects.using('other').count(), 2)
+        self.assertEqual(Book.objects.using('default').count(), 2)
+        self.assertEqual(Book.objects.using('other').count(), 2)
+        self.assertEqual(Person.objects.using('default').count(), 2)
+        self.assertEqual(Person.objects.using('other').count(), 2)
 
         # Set a m2m set with an object from a different database
         try:
@@ -1270,14 +1270,14 @@ class RouterTestCase(TestCase):
             self.fail("Assignment across master/slave databases with a common source should be ok")
 
         # Database assignments don't change
-        self.assertEquals(marty._state.db, 'default')
-        self.assertEquals(pro._state.db, 'default')
-        self.assertEquals(dive._state.db, 'other')
-        self.assertEquals(mark._state.db, 'other')
+        self.assertEqual(marty._state.db, 'default')
+        self.assertEqual(pro._state.db, 'default')
+        self.assertEqual(dive._state.db, 'other')
+        self.assertEqual(mark._state.db, 'other')
 
         # All m2m relations should be saved on the default database
-        self.assertEquals(Book.authors.through.objects.using('default').count(), 2)
-        self.assertEquals(Book.authors.through.objects.using('other').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('default').count(), 2)
+        self.assertEqual(Book.authors.through.objects.using('other').count(), 0)
 
         # Reset relations
         Book.authors.through.objects.using('default').delete()
@@ -1289,14 +1289,14 @@ class RouterTestCase(TestCase):
             self.fail("Assignment across master/slave databases with a common source should be ok")
 
         # Database assignments don't change
-        self.assertEquals(marty._state.db, 'default')
-        self.assertEquals(pro._state.db, 'default')
-        self.assertEquals(dive._state.db, 'other')
-        self.assertEquals(mark._state.db, 'other')
+        self.assertEqual(marty._state.db, 'default')
+        self.assertEqual(pro._state.db, 'default')
+        self.assertEqual(dive._state.db, 'other')
+        self.assertEqual(mark._state.db, 'other')
 
         # All m2m relations should be saved on the default database
-        self.assertEquals(Book.authors.through.objects.using('default').count(), 1)
-        self.assertEquals(Book.authors.through.objects.using('other').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('default').count(), 1)
+        self.assertEqual(Book.authors.through.objects.using('other').count(), 0)
 
         # Reset relations
         Book.authors.through.objects.using('default').delete()
@@ -1308,20 +1308,20 @@ class RouterTestCase(TestCase):
             self.fail("Assignment across master/slave databases with a common source should be ok")
 
         # Database assignments don't change
-        self.assertEquals(marty._state.db, 'default')
-        self.assertEquals(pro._state.db, 'default')
-        self.assertEquals(dive._state.db, 'other')
-        self.assertEquals(mark._state.db, 'other')
+        self.assertEqual(marty._state.db, 'default')
+        self.assertEqual(pro._state.db, 'default')
+        self.assertEqual(dive._state.db, 'other')
+        self.assertEqual(mark._state.db, 'other')
 
         # All m2m relations should be saved on the default database
-        self.assertEquals(Book.authors.through.objects.using('default').count(), 2)
-        self.assertEquals(Book.authors.through.objects.using('other').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('default').count(), 2)
+        self.assertEqual(Book.authors.through.objects.using('other').count(), 0)
 
         # Reset relations
         Book.authors.through.objects.using('default').delete()
 
-        self.assertEquals(Book.authors.through.objects.using('default').count(), 0)
-        self.assertEquals(Book.authors.through.objects.using('other').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('default').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('other').count(), 0)
 
         # Add to a reverse m2m with an object from a different database
         try:
@@ -1330,27 +1330,27 @@ class RouterTestCase(TestCase):
             self.fail("Assignment across master/slave databases with a common source should be ok")
 
         # Database assignments don't change
-        self.assertEquals(marty._state.db, 'default')
-        self.assertEquals(pro._state.db, 'default')
-        self.assertEquals(dive._state.db, 'other')
-        self.assertEquals(mark._state.db, 'other')
+        self.assertEqual(marty._state.db, 'default')
+        self.assertEqual(pro._state.db, 'default')
+        self.assertEqual(dive._state.db, 'other')
+        self.assertEqual(mark._state.db, 'other')
 
         # All m2m relations should be saved on the default database
-        self.assertEquals(Book.authors.through.objects.using('default').count(), 1)
-        self.assertEquals(Book.authors.through.objects.using('other').count(), 0)
+        self.assertEqual(Book.authors.through.objects.using('default').count(), 1)
+        self.assertEqual(Book.authors.through.objects.using('other').count(), 0)
 
         # If you create an object through a M2M relation, it will be
         # written to the write database, even if the original object
         # was on the read database
         alice = dive.authors.create(name='Alice')
-        self.assertEquals(alice._state.db, 'default')
+        self.assertEqual(alice._state.db, 'default')
 
         # Same goes for get_or_create, regardless of whether getting or creating
         alice, created = dive.authors.get_or_create(name='Alice')
-        self.assertEquals(alice._state.db, 'default')
+        self.assertEqual(alice._state.db, 'default')
 
         bob, created = dive.authors.get_or_create(name='Bob')
-        self.assertEquals(bob._state.db, 'default')
+        self.assertEqual(bob._state.db, 'default')
 
     def test_o2o_cross_database_protection(self):
         "Operations that involve sharing FK objects across databases raise an error"
@@ -1368,13 +1368,13 @@ class RouterTestCase(TestCase):
             self.fail("Assignment across master/slave databases with a common source should be ok")
 
         # Database assignments of original objects haven't changed...
-        self.assertEquals(alice._state.db, 'default')
-        self.assertEquals(alice_profile._state.db, 'default')
-        self.assertEquals(bob._state.db, 'other')
+        self.assertEqual(alice._state.db, 'default')
+        self.assertEqual(alice_profile._state.db, 'default')
+        self.assertEqual(bob._state.db, 'other')
 
         # ... but they will when the affected object is saved.
         bob.save()
-        self.assertEquals(bob._state.db, 'default')
+        self.assertEqual(bob._state.db, 'default')
 
     def test_generic_key_cross_database_protection(self):
         "Generic Key operations can span databases if they share a source"
@@ -1399,15 +1399,15 @@ class RouterTestCase(TestCase):
             self.fail("Assignment across master/slave databases with a common source should be ok")
 
         # Database assignments of original objects haven't changed...
-        self.assertEquals(pro._state.db, 'default')
-        self.assertEquals(review1._state.db, 'default')
-        self.assertEquals(dive._state.db, 'other')
-        self.assertEquals(review2._state.db, 'other')
+        self.assertEqual(pro._state.db, 'default')
+        self.assertEqual(review1._state.db, 'default')
+        self.assertEqual(dive._state.db, 'other')
+        self.assertEqual(review2._state.db, 'other')
 
         # ... but they will when the affected object is saved.
         dive.save()
-        self.assertEquals(review1._state.db, 'default')
-        self.assertEquals(dive._state.db, 'default')
+        self.assertEqual(review1._state.db, 'default')
+        self.assertEqual(dive._state.db, 'default')
 
         # ...and the source database now has a copy of any object saved
         try:
@@ -1417,7 +1417,7 @@ class RouterTestCase(TestCase):
 
         # This isn't a real master-slave database, so restore the original from other
         dive = Book.objects.using('other').get(title='Dive into Python')
-        self.assertEquals(dive._state.db, 'other')
+        self.assertEqual(dive._state.db, 'other')
 
         # Add to a generic foreign key set with an object from a different database
         try:
@@ -1426,14 +1426,14 @@ class RouterTestCase(TestCase):
             self.fail("Assignment across master/slave databases with a common source should be ok")
 
         # Database assignments of original objects haven't changed...
-        self.assertEquals(pro._state.db, 'default')
-        self.assertEquals(review1._state.db, 'default')
-        self.assertEquals(dive._state.db, 'other')
-        self.assertEquals(review2._state.db, 'other')
+        self.assertEqual(pro._state.db, 'default')
+        self.assertEqual(review1._state.db, 'default')
+        self.assertEqual(dive._state.db, 'other')
+        self.assertEqual(review2._state.db, 'other')
 
         # ... but they will when the affected object is saved.
         dive.save()
-        self.assertEquals(dive._state.db, 'default')
+        self.assertEqual(dive._state.db, 'default')
 
         # ...and the source database now has a copy of any object saved
         try:
@@ -1446,18 +1446,18 @@ class RouterTestCase(TestCase):
         # base object.
         review3 = Review(source="Python Daily")
         # initially, no db assigned
-        self.assertEquals(review3._state.db, None)
+        self.assertEqual(review3._state.db, None)
 
         # Dive comes from 'other', so review3 is set to use the source of 'other'...
         review3.content_object = dive
-        self.assertEquals(review3._state.db, 'default')
+        self.assertEqual(review3._state.db, 'default')
 
         # If you create an object through a M2M relation, it will be
         # written to the write database, even if the original object
         # was on the read database
         dive = Book.objects.using('other').get(title='Dive into Python')
         nyt = dive.reviews.create(source="New York Times", content_object=dive)
-        self.assertEquals(nyt._state.db, 'default')
+        self.assertEqual(nyt._state.db, 'default')
 
     def test_m2m_managers(self):
         "M2M relations are represented by managers, and can be controlled like managers"
@@ -1467,13 +1467,13 @@ class RouterTestCase(TestCase):
         marty = Person.objects.using('other').create(pk=1, name="Marty Alchin")
         pro.authors = [marty]
 
-        self.assertEquals(pro.authors.db, 'other')
-        self.assertEquals(pro.authors.db_manager('default').db, 'default')
-        self.assertEquals(pro.authors.db_manager('default').all().db, 'default')
+        self.assertEqual(pro.authors.db, 'other')
+        self.assertEqual(pro.authors.db_manager('default').db, 'default')
+        self.assertEqual(pro.authors.db_manager('default').all().db, 'default')
 
-        self.assertEquals(marty.book_set.db, 'other')
-        self.assertEquals(marty.book_set.db_manager('default').db, 'default')
-        self.assertEquals(marty.book_set.db_manager('default').all().db, 'default')
+        self.assertEqual(marty.book_set.db, 'other')
+        self.assertEqual(marty.book_set.db_manager('default').db, 'default')
+        self.assertEqual(marty.book_set.db_manager('default').all().db, 'default')
 
     def test_foreign_key_managers(self):
         "FK reverse relations are represented by managers, and can be controlled like managers"
@@ -1482,9 +1482,9 @@ class RouterTestCase(TestCase):
                                                  published=datetime.date(2008, 12, 16),
                                                  editor=marty)
 
-        self.assertEquals(marty.edited.db, 'other')
-        self.assertEquals(marty.edited.db_manager('default').db, 'default')
-        self.assertEquals(marty.edited.db_manager('default').all().db, 'default')
+        self.assertEqual(marty.edited.db, 'other')
+        self.assertEqual(marty.edited.db_manager('default').db, 'default')
+        self.assertEqual(marty.edited.db_manager('default').all().db, 'default')
 
     def test_generic_key_managers(self):
         "Generic key relations are represented by managers, and can be controlled like managers"
@@ -1494,9 +1494,9 @@ class RouterTestCase(TestCase):
         review1 = Review.objects.using('other').create(source="Python Monthly",
                                                        content_object=pro)
 
-        self.assertEquals(pro.reviews.db, 'other')
-        self.assertEquals(pro.reviews.db_manager('default').db, 'default')
-        self.assertEquals(pro.reviews.db_manager('default').all().db, 'default')
+        self.assertEqual(pro.reviews.db, 'other')
+        self.assertEqual(pro.reviews.db_manager('default').db, 'default')
+        self.assertEqual(pro.reviews.db_manager('default').all().db, 'default')
 
     def test_subquery(self):
         """Make sure as_sql works with subqueries and master/slave."""
@@ -1516,7 +1516,7 @@ class RouterTestCase(TestCase):
         str(qs.query)
 
         # If you evaluate the query, it should work, running on 'other'
-        self.assertEquals(list(qs.values_list('title', flat=True)), [u'Dive into Python'])
+        self.assertEqual(list(qs.values_list('title', flat=True)), [u'Dive into Python'])
 
 class AuthTestCase(TestCase):
     multi_db = True
@@ -1541,22 +1541,22 @@ class AuthTestCase(TestCase):
         # The second user only exists on the other database
         alice = User.objects.using('other').get(username='alice')
 
-        self.assertEquals(alice.username, 'alice')
-        self.assertEquals(alice._state.db, 'other')
+        self.assertEqual(alice.username, 'alice')
+        self.assertEqual(alice._state.db, 'other')
 
         self.assertRaises(User.DoesNotExist, User.objects.using('default').get, username='alice')
 
         # The second user only exists on the default database
         bob = User.objects.using('default').get(username='bob')
 
-        self.assertEquals(bob.username, 'bob')
-        self.assertEquals(bob._state.db, 'default')
+        self.assertEqual(bob.username, 'bob')
+        self.assertEqual(bob._state.db, 'default')
 
         self.assertRaises(User.DoesNotExist, User.objects.using('other').get, username='bob')
 
         # That is... there is one user on each database
-        self.assertEquals(User.objects.using('default').count(), 1)
-        self.assertEquals(User.objects.using('other').count(), 1)
+        self.assertEqual(User.objects.using('default').count(), 1)
+        self.assertEqual(User.objects.using('other').count(), 1)
 
     def test_dumpdata(self):
         "Check that dumpdata honors allow_syncdb restrictions on the router"
@@ -1599,8 +1599,8 @@ class UserProfileTestCase(TestCase):
         bob_profile = UserProfile(user=bob, flavor='crunchy frog')
         bob_profile.save()
 
-        self.assertEquals(alice.get_profile().flavor, 'chocolate')
-        self.assertEquals(bob.get_profile().flavor, 'crunchy frog')
+        self.assertEqual(alice.get_profile().flavor, 'chocolate')
+        self.assertEqual(bob.get_profile().flavor, 'crunchy frog')
 
 class AntiPetRouter(object):
     # A router that only expresses an opinion on syncdb,