p31829507
/
django
mirror of https://github.com/django/django.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

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
This commit is contained in:
Russell Keith-Magee 2011-03-03 15:04:39 +00:00
parent b7c41c1fbb
commit afd040d4d3
110 changed files with 1197 additions and 1197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
django/contrib/auth/tests/basic.py
View File

@ -61,7 +61,7 @@ class BasicTestCase(TestCase):
command_output = new_io.getvalue().strip() command_output = new_io.getvalue().strip()
self.assertEqual(command_output, 'Superuser created successfully.') self.assertEqual(command_output, 'Superuser created successfully.')
u = User.objects.get(username="joe") u = User.objects.get(username="joe")
self.assertEquals(u.email, 'joe@somewhere.org') self.assertEqual(u.email, 'joe@somewhere.org')
# created password should be unusable # created password should be unusable
self.assertFalse(u.has_usable_password()) self.assertFalse(u.has_usable_password())
@ -78,7 +78,7 @@ class BasicTestCase(TestCase):
command_output = new_io.getvalue().strip() command_output = new_io.getvalue().strip()
self.assertEqual(command_output, '') self.assertEqual(command_output, '')
u = User.objects.get(username="joe2") u = User.objects.get(username="joe2")
self.assertEquals(u.email, 'joe2@somewhere.org') self.assertEqual(u.email, 'joe2@somewhere.org')
self.assertFalse(u.has_usable_password()) self.assertFalse(u.has_usable_password())
@ -90,6 +90,6 @@ class BasicTestCase(TestCase):
stdout=new_io stdout=new_io
) )
u = User.objects.get(username="joe+admin@somewhere.org") u = User.objects.get(username="joe+admin@somewhere.org")
self.assertEquals(u.email, 'joe@somewhere.org') self.assertEqual(u.email, 'joe@somewhere.org')
self.assertFalse(u.has_usable_password()) self.assertFalse(u.has_usable_password())

2
django/contrib/auth/tests/decorators.py
View File

@ -32,7 +32,7 @@ class LoginRequiredTestCase(AuthViewsTestCase):
""" """
response = self.client.get(view_url) response = self.client.get(view_url)
self.assertEqual(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assert_(login_url in response['Location']) self.assertTrue(login_url in response['Location'])
self.login() self.login()
response = self.client.get(view_url) response = self.client.get(view_url)
self.assertEqual(response.status_code, 200) self.assertEqual(response.status_code, 200)

8
django/contrib/auth/tests/remote_user.py
View File

@ -30,15 +30,15 @@ class RemoteUserTest(TestCase):
num_users = User.objects.count() num_users = User.objects.count()
response = self.client.get('/remote_user/') response = self.client.get('/remote_user/')
self.assert_(response.context['user'].is_anonymous()) self.assertTrue(response.context['user'].is_anonymous())
self.assertEqual(User.objects.count(), num_users) self.assertEqual(User.objects.count(), num_users)
response = self.client.get('/remote_user/', REMOTE_USER=None) response = self.client.get('/remote_user/', REMOTE_USER=None)
self.assert_(response.context['user'].is_anonymous()) self.assertTrue(response.context['user'].is_anonymous())
self.assertEqual(User.objects.count(), num_users) self.assertEqual(User.objects.count(), num_users)
response = self.client.get('/remote_user/', REMOTE_USER='') response = self.client.get('/remote_user/', REMOTE_USER='')
self.assert_(response.context['user'].is_anonymous()) self.assertTrue(response.context['user'].is_anonymous())
self.assertEqual(User.objects.count(), num_users) self.assertEqual(User.objects.count(), num_users)
def test_unknown_user(self): def test_unknown_user(self):
@ -115,7 +115,7 @@ class RemoteUserNoCreateTest(RemoteUserTest):
def test_unknown_user(self): def test_unknown_user(self):
num_users = User.objects.count() num_users = User.objects.count()
response = self.client.get('/remote_user/', REMOTE_USER='newuser') response = self.client.get('/remote_user/', REMOTE_USER='newuser')
self.assert_(response.context['user'].is_anonymous()) self.assertTrue(response.context['user'].is_anonymous())
self.assertEqual(User.objects.count(), num_users) self.assertEqual(User.objects.count(), num_users)

114
django/contrib/auth/tests/views.py
View File

@ -40,53 +40,53 @@ class AuthViewsTestCase(TestCase):
'password': password 'password': password
} }
) )
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assert_(response['Location'].endswith(settings.LOGIN_REDIRECT_URL)) self.assertTrue(response['Location'].endswith(settings.LOGIN_REDIRECT_URL))
self.assert_(SESSION_KEY in self.client.session) self.assertTrue(SESSION_KEY in self.client.session)
class PasswordResetTest(AuthViewsTestCase): class PasswordResetTest(AuthViewsTestCase):
def test_email_not_found(self): def test_email_not_found(self):
"Error is raised if the provided email address isn't currently registered" "Error is raised if the provided email address isn't currently registered"
response = self.client.get('/password_reset/') response = self.client.get('/password_reset/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
response = self.client.post('/password_reset/', {'email': 'not_a_real_email@email.com'}) response = self.client.post('/password_reset/', {'email': 'not_a_real_email@email.com'})
self.assertContains(response, "That e-mail address doesn't have an associated user account") self.assertContains(response, "That e-mail address doesn't have an associated user account")
self.assertEquals(len(mail.outbox), 0) self.assertEqual(len(mail.outbox), 0)
def test_email_found(self): def test_email_found(self):
"Email is sent if a valid email address is provided for password reset" "Email is sent if a valid email address is provided for password reset"
response = self.client.post('/password_reset/', {'email': 'staffmember@example.com'}) response = self.client.post('/password_reset/', {'email': 'staffmember@example.com'})
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assertEquals(len(mail.outbox), 1) self.assertEqual(len(mail.outbox), 1)
self.assert_("http://" in mail.outbox[0].body) self.assertTrue("http://" in mail.outbox[0].body)
self.assertEquals(settings.DEFAULT_FROM_EMAIL, mail.outbox[0].from_email) self.assertEqual(settings.DEFAULT_FROM_EMAIL, mail.outbox[0].from_email)
def test_email_found_custom_from(self): def test_email_found_custom_from(self):
"Email is sent if a valid email address is provided for password reset when a custom from_email is provided." "Email is sent if a valid email address is provided for password reset when a custom from_email is provided."
response = self.client.post('/password_reset_from_email/', {'email': 'staffmember@example.com'}) response = self.client.post('/password_reset_from_email/', {'email': 'staffmember@example.com'})
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assertEquals(len(mail.outbox), 1) self.assertEqual(len(mail.outbox), 1)
self.assertEquals("staffmember@example.com", mail.outbox[0].from_email) self.assertEqual("staffmember@example.com", mail.outbox[0].from_email)
def _test_confirm_start(self): def _test_confirm_start(self):
# Start by creating the email # Start by creating the email
response = self.client.post('/password_reset/', {'email': 'staffmember@example.com'}) response = self.client.post('/password_reset/', {'email': 'staffmember@example.com'})
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assertEquals(len(mail.outbox), 1) self.assertEqual(len(mail.outbox), 1)
return self._read_signup_email(mail.outbox[0]) return self._read_signup_email(mail.outbox[0])
def _read_signup_email(self, email): def _read_signup_email(self, email):
urlmatch = re.search(r"https?://[^/]*(/.*reset/\S*)", email.body) urlmatch = re.search(r"https?://[^/]*(/.*reset/\S*)", email.body)
self.assert_(urlmatch is not None, "No URL found in sent email") self.assertTrue(urlmatch is not None, "No URL found in sent email")
return urlmatch.group(), urlmatch.groups()[0] return urlmatch.group(), urlmatch.groups()[0]
def test_confirm_valid(self): def test_confirm_valid(self):
url, path = self._test_confirm_start() url, path = self._test_confirm_start()
response = self.client.get(path) response = self.client.get(path)
# redirect to a 'complete' page: # redirect to a 'complete' page:
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assert_("Please enter your new password" in response.content) self.assertTrue("Please enter your new password" in response.content)
def test_confirm_invalid(self): def test_confirm_invalid(self):
url, path = self._test_confirm_start() url, path = self._test_confirm_start()
@ -95,20 +95,20 @@ class PasswordResetTest(AuthViewsTestCase):
path = path[:-5] + ("0"*4) + path[-1] path = path[:-5] + ("0"*4) + path[-1]
response = self.client.get(path) response = self.client.get(path)
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assert_("The password reset link was invalid" in response.content) self.assertTrue("The password reset link was invalid" in response.content)
def test_confirm_invalid_user(self): def test_confirm_invalid_user(self):
# Ensure that we get a 200 response for a non-existant user, not a 404 # Ensure that we get a 200 response for a non-existant user, not a 404
response = self.client.get('/reset/123456-1-1/') response = self.client.get('/reset/123456-1-1/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assert_("The password reset link was invalid" in response.content) self.assertTrue("The password reset link was invalid" in response.content)
def test_confirm_overflow_user(self): def test_confirm_overflow_user(self):
# Ensure that we get a 200 response for a base36 user id that overflows int # Ensure that we get a 200 response for a base36 user id that overflows int
response = self.client.get('/reset/zzzzzzzzzzzzz-1-1/') response = self.client.get('/reset/zzzzzzzzzzzzz-1-1/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assert_("The password reset link was invalid" in response.content) self.assertTrue("The password reset link was invalid" in response.content)
def test_confirm_invalid_post(self): def test_confirm_invalid_post(self):
# Same as test_confirm_invalid, but trying # Same as test_confirm_invalid, but trying
@ -120,29 +120,29 @@ class PasswordResetTest(AuthViewsTestCase):
'new_password2':' anewpassword'}) 'new_password2':' anewpassword'})
# Check the password has not been changed # Check the password has not been changed
u = User.objects.get(email='staffmember@example.com') u = User.objects.get(email='staffmember@example.com')
self.assert_(not u.check_password("anewpassword")) self.assertTrue(not u.check_password("anewpassword"))
def test_confirm_complete(self): def test_confirm_complete(self):
url, path = self._test_confirm_start() url, path = self._test_confirm_start()
response = self.client.post(path, {'new_password1': 'anewpassword', response = self.client.post(path, {'new_password1': 'anewpassword',
'new_password2': 'anewpassword'}) 'new_password2': 'anewpassword'})
# It redirects us to a 'complete' page: # It redirects us to a 'complete' page:
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
# Check the password has been changed # Check the password has been changed
u = User.objects.get(email='staffmember@example.com') u = User.objects.get(email='staffmember@example.com')
self.assert_(u.check_password("anewpassword")) self.assertTrue(u.check_password("anewpassword"))
# Check we can't use the link again # Check we can't use the link again
response = self.client.get(path) response = self.client.get(path)
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assert_("The password reset link was invalid" in response.content) self.assertTrue("The password reset link was invalid" in response.content)
def test_confirm_different_passwords(self): def test_confirm_different_passwords(self):
url, path = self._test_confirm_start() url, path = self._test_confirm_start()
response = self.client.post(path, {'new_password1': 'anewpassword', response = self.client.post(path, {'new_password1': 'anewpassword',
'new_password2':' x'}) 'new_password2':' x'})
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assert_("The two password fields didn't match" in response.content) self.assertTrue("The two password fields didn't match" in response.content)
class ChangePasswordTest(AuthViewsTestCase): class ChangePasswordTest(AuthViewsTestCase):
@ -152,8 +152,8 @@ class ChangePasswordTest(AuthViewsTestCase):
'password': password 'password': password
} }
) )
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assert_("Please enter a correct username and password. Note that both fields are case-sensitive." in response.content) self.assertTrue("Please enter a correct username and password. Note that both fields are case-sensitive." in response.content)
def logout(self): def logout(self):
response = self.client.get('/logout/') response = self.client.get('/logout/')
@ -166,8 +166,8 @@ class ChangePasswordTest(AuthViewsTestCase):
'new_password2': 'password1', 'new_password2': 'password1',
} }
) )
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assert_("Your old password was entered incorrectly. Please enter it again." in response.content) self.assertTrue("Your old password was entered incorrectly. Please enter it again." in response.content)
def test_password_change_fails_with_mismatched_passwords(self): def test_password_change_fails_with_mismatched_passwords(self):
self.login() self.login()
@ -177,8 +177,8 @@ class ChangePasswordTest(AuthViewsTestCase):
'new_password2': 'donuts', 'new_password2': 'donuts',
} }
) )
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assert_("The two password fields didn't match." in response.content) self.assertTrue("The two password fields didn't match." in response.content)
def test_password_change_succeeds(self): def test_password_change_succeeds(self):
self.login() self.login()
@ -188,8 +188,8 @@ class ChangePasswordTest(AuthViewsTestCase):
'new_password2': 'password1', 'new_password2': 'password1',
} }
) )
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assert_(response['Location'].endswith('/password_change/done/')) self.assertTrue(response['Location'].endswith('/password_change/done/'))
self.fail_login() self.fail_login()
self.login(password='password1') self.login(password='password1')
@ -197,14 +197,14 @@ class LoginTest(AuthViewsTestCase):
def test_current_site_in_context_after_login(self): def test_current_site_in_context_after_login(self):
response = self.client.get(reverse('django.contrib.auth.views.login')) response = self.client.get(reverse('django.contrib.auth.views.login'))
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
if Site._meta.installed: if Site._meta.installed:
site = Site.objects.get_current() site = Site.objects.get_current()
self.assertEquals(response.context['site'], site) self.assertEqual(response.context['site'], site)
self.assertEquals(response.context['site_name'], site.name) self.assertEqual(response.context['site_name'], site.name)
else: else:
self.assertIsInstance(response.context['site'], RequestSite) self.assertIsInstance(response.context['site'], RequestSite)
self.assert_(isinstance(response.context['form'], AuthenticationForm), self.assertTrue(isinstance(response.context['form'], AuthenticationForm),
'Login form is not an AuthenticationForm') 'Login form is not an AuthenticationForm')
def test_security_check(self, password='password'): def test_security_check(self, password='password'):
@ -226,7 +226,7 @@ class LoginTest(AuthViewsTestCase):
'password': password, 'password': password,
} }
) )
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assertFalse(bad_url in response['Location'], self.assertFalse(bad_url in response['Location'],
"%s should be blocked" % bad_url) "%s should be blocked" % bad_url)
@ -249,14 +249,14 @@ class LoginTest(AuthViewsTestCase):
'password': password, 'password': password,
} }
) )
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assertTrue(good_url in response['Location'], self.assertTrue(good_url in response['Location'],
"%s should be allowed" % good_url) "%s should be allowed" % good_url)
class LoginURLSettings(AuthViewsTestCase): class LoginURLSettings(AuthViewsTestCase):
urls = 'django.contrib.auth.tests.urls' urls = 'django.contrib.auth.tests.urls'
def setUp(self): def setUp(self):
super(LoginURLSettings, self).setUp() super(LoginURLSettings, self).setUp()
self.old_LOGIN_URL = settings.LOGIN_URL self.old_LOGIN_URL = settings.LOGIN_URL
@ -268,7 +268,7 @@ class LoginURLSettings(AuthViewsTestCase):
def get_login_required_url(self, login_url): def get_login_required_url(self, login_url):
settings.LOGIN_URL = login_url settings.LOGIN_URL = login_url
response = self.client.get('/login_required/') response = self.client.get('/login_required/')
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
return response['Location'] return response['Location']
def test_standard_login_url(self): def test_standard_login_url(self):
@ -317,14 +317,14 @@ class LogoutTest(AuthViewsTestCase):
urls = 'django.contrib.auth.tests.urls' urls = 'django.contrib.auth.tests.urls'
def confirm_logged_out(self): def confirm_logged_out(self):
self.assert_(SESSION_KEY not in self.client.session) self.assertTrue(SESSION_KEY not in self.client.session)
def test_logout_default(self): def test_logout_default(self):
"Logout without next_page option renders the default template" "Logout without next_page option renders the default template"
self.login() self.login()
response = self.client.get('/logout/') response = self.client.get('/logout/')
self.assertEquals(200, response.status_code) self.assertEqual(200, response.status_code)
self.assert_('Logged out' in response.content) self.assertTrue('Logged out' in response.content)
self.confirm_logged_out() self.confirm_logged_out()
def test_14377(self): def test_14377(self):
@ -338,20 +338,20 @@ class LogoutTest(AuthViewsTestCase):
self.login() self.login()
response = self.client.get('/logout/next_page/') response = self.client.get('/logout/next_page/')
self.assertEqual(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assert_(response['Location'].endswith('/somewhere/')) self.assertTrue(response['Location'].endswith('/somewhere/'))
response = self.client.get('/logout/next_page/?next=/login/') response = self.client.get('/logout/next_page/?next=/login/')
self.assertEqual(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assert_(response['Location'].endswith('/login/')) self.assertTrue(response['Location'].endswith('/login/'))
self.confirm_logged_out() self.confirm_logged_out()
def test_logout_with_next_page_specified(self): def test_logout_with_next_page_specified(self):
"Logout with next_page option given redirects to specified resource" "Logout with next_page option given redirects to specified resource"
self.login() self.login()
response = self.client.get('/logout/next_page/') response = self.client.get('/logout/next_page/')
self.assertEqual(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assert_(response['Location'].endswith('/somewhere/')) self.assertTrue(response['Location'].endswith('/somewhere/'))
self.confirm_logged_out() self.confirm_logged_out()
def test_logout_with_redirect_argument(self): def test_logout_with_redirect_argument(self):
@ -359,7 +359,7 @@ class LogoutTest(AuthViewsTestCase):
self.login() self.login()
response = self.client.get('/logout/?next=/login/') response = self.client.get('/logout/?next=/login/')
self.assertEqual(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assert_(response['Location'].endswith('/login/')) self.assertTrue(response['Location'].endswith('/login/'))
self.confirm_logged_out() self.confirm_logged_out()
def test_logout_with_custom_redirect_argument(self): def test_logout_with_custom_redirect_argument(self):
@ -367,7 +367,7 @@ class LogoutTest(AuthViewsTestCase):
self.login() self.login()
response = self.client.get('/logout/custom_query/?follow=/somewhere/') response = self.client.get('/logout/custom_query/?follow=/somewhere/')
self.assertEqual(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assert_(response['Location'].endswith('/somewhere/')) self.assertTrue(response['Location'].endswith('/somewhere/'))
self.confirm_logged_out() self.confirm_logged_out()
def test_security_check(self, password='password'): def test_security_check(self, password='password'):
@ -386,7 +386,7 @@ class LogoutTest(AuthViewsTestCase):
} }
self.login() self.login()
response = self.client.get(nasty_url) response = self.client.get(nasty_url)
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assertFalse(bad_url in response['Location'], self.assertFalse(bad_url in response['Location'],
"%s should be blocked" % bad_url) "%s should be blocked" % bad_url)
self.confirm_logged_out() self.confirm_logged_out()
@ -407,7 +407,7 @@ class LogoutTest(AuthViewsTestCase):
} }
self.login() self.login()
response = self.client.get(safe_url) response = self.client.get(safe_url)
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assertTrue(good_url in response['Location'], self.assertTrue(good_url in response['Location'],
"%s should be allowed" % good_url) "%s should be allowed" % good_url)
self.confirm_logged_out() self.confirm_logged_out()

16
django/contrib/flatpages/tests/csrf.py
View File

@ -34,13 +34,13 @@ class FlatpageCSRFTests(TestCase):
def test_view_flatpage(self): def test_view_flatpage(self):
"A flatpage can be served through a view, even when the middleware is in use" "A flatpage can be served through a view, even when the middleware is in use"
response = self.client.get('/flatpage_root/flatpage/') response = self.client.get('/flatpage_root/flatpage/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertContains(response, "<p>Isn't it flat!</p>") self.assertContains(response, "<p>Isn't it flat!</p>")
def test_view_non_existent_flatpage(self): def test_view_non_existent_flatpage(self):
"A non-existent flatpage raises 404 when served through a view, even when the middleware is in use" "A non-existent flatpage raises 404 when served through a view, even when the middleware is in use"
response = self.client.get('/flatpage_root/no_such_flatpage/') response = self.client.get('/flatpage_root/no_such_flatpage/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)
def test_view_authenticated_flatpage(self): def test_view_authenticated_flatpage(self):
"A flatpage served through a view can require authentication" "A flatpage served through a view can require authentication"
@ -49,31 +49,31 @@ class FlatpageCSRFTests(TestCase):
User.objects.create_user('testuser', 'test@example.com', 's3krit') User.objects.create_user('testuser', 'test@example.com', 's3krit')
self.client.login(username='testuser',password='s3krit') self.client.login(username='testuser',password='s3krit')
response = self.client.get('/flatpage_root/sekrit/') response = self.client.get('/flatpage_root/sekrit/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertContains(response, "<p>Isn't it sekrit!</p>") self.assertContains(response, "<p>Isn't it sekrit!</p>")
def test_fallback_flatpage(self): def test_fallback_flatpage(self):
"A flatpage can be served by the fallback middlware" "A flatpage can be served by the fallback middlware"
response = self.client.get('/flatpage/') response = self.client.get('/flatpage/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertContains(response, "<p>Isn't it flat!</p>") self.assertContains(response, "<p>Isn't it flat!</p>")
def test_fallback_non_existent_flatpage(self): def test_fallback_non_existent_flatpage(self):
"A non-existent flatpage raises a 404 when served by the fallback middlware" "A non-existent flatpage raises a 404 when served by the fallback middlware"
response = self.client.get('/no_such_flatpage/') response = self.client.get('/no_such_flatpage/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)
def test_post_view_flatpage(self): def test_post_view_flatpage(self):
"POSTing to a flatpage served through a view will raise a CSRF error if no token is provided (Refs #14156)" "POSTing to a flatpage served through a view will raise a CSRF error if no token is provided (Refs #14156)"
response = self.client.post('/flatpage_root/flatpage/') response = self.client.post('/flatpage_root/flatpage/')
self.assertEquals(response.status_code, 403) self.assertEqual(response.status_code, 403)
def test_post_fallback_flatpage(self): def test_post_fallback_flatpage(self):
"POSTing to a flatpage served by the middleware will raise a CSRF error if no token is provided (Refs #14156)" "POSTing to a flatpage served by the middleware will raise a CSRF error if no token is provided (Refs #14156)"
response = self.client.post('/flatpage/') response = self.client.post('/flatpage/')
self.assertEquals(response.status_code, 403) self.assertEqual(response.status_code, 403)
def test_post_unknown_page(self): def test_post_unknown_page(self):
"POSTing to an unknown page isn't caught as a 403 CSRF error" "POSTing to an unknown page isn't caught as a 403 CSRF error"
response = self.client.post('/no_such_page/') response = self.client.post('/no_such_page/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)

12
django/contrib/flatpages/tests/middleware.py
View File

@ -30,13 +30,13 @@ class FlatpageMiddlewareTests(TestCase):
def test_view_flatpage(self): def test_view_flatpage(self):
"A flatpage can be served through a view, even when the middleware is in use" "A flatpage can be served through a view, even when the middleware is in use"
response = self.client.get('/flatpage_root/flatpage/') response = self.client.get('/flatpage_root/flatpage/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertContains(response, "<p>Isn't it flat!</p>") self.assertContains(response, "<p>Isn't it flat!</p>")
def test_view_non_existent_flatpage(self): def test_view_non_existent_flatpage(self):
"A non-existent flatpage raises 404 when served through a view, even when the middleware is in use" "A non-existent flatpage raises 404 when served through a view, even when the middleware is in use"
response = self.client.get('/flatpage_root/no_such_flatpage/') response = self.client.get('/flatpage_root/no_such_flatpage/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)
def test_view_authenticated_flatpage(self): def test_view_authenticated_flatpage(self):
"A flatpage served through a view can require authentication" "A flatpage served through a view can require authentication"
@ -45,19 +45,19 @@ class FlatpageMiddlewareTests(TestCase):
User.objects.create_user('testuser', 'test@example.com', 's3krit') User.objects.create_user('testuser', 'test@example.com', 's3krit')
self.client.login(username='testuser',password='s3krit') self.client.login(username='testuser',password='s3krit')
response = self.client.get('/flatpage_root/sekrit/') response = self.client.get('/flatpage_root/sekrit/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertContains(response, "<p>Isn't it sekrit!</p>") self.assertContains(response, "<p>Isn't it sekrit!</p>")
def test_fallback_flatpage(self): def test_fallback_flatpage(self):
"A flatpage can be served by the fallback middlware" "A flatpage can be served by the fallback middlware"
response = self.client.get('/flatpage/') response = self.client.get('/flatpage/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertContains(response, "<p>Isn't it flat!</p>") self.assertContains(response, "<p>Isn't it flat!</p>")
def test_fallback_non_existent_flatpage(self): def test_fallback_non_existent_flatpage(self):
"A non-existent flatpage raises a 404 when served by the fallback middlware" "A non-existent flatpage raises a 404 when served by the fallback middlware"
response = self.client.get('/no_such_flatpage/') response = self.client.get('/no_such_flatpage/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)
def test_fallback_authenticated_flatpage(self): def test_fallback_authenticated_flatpage(self):
"A flatpage served by the middleware can require authentication" "A flatpage served by the middleware can require authentication"
@ -66,5 +66,5 @@ class FlatpageMiddlewareTests(TestCase):
User.objects.create_user('testuser', 'test@example.com', 's3krit') User.objects.create_user('testuser', 'test@example.com', 's3krit')
self.client.login(username='testuser',password='s3krit') self.client.login(username='testuser',password='s3krit')
response = self.client.get('/sekrit/') response = self.client.get('/sekrit/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertContains(response, "<p>Isn't it sekrit!</p>") self.assertContains(response, "<p>Isn't it sekrit!</p>")

14
django/contrib/flatpages/tests/templatetags.py
View File

@ -35,7 +35,7 @@ class FlatpageTemplateTagTests(TestCase):
"{{ page.title }}," "{{ page.title }},"
"{% endfor %}" "{% endfor %}"
).render(Context()) ).render(Context())
self.assertEquals(out, "A Flatpage,A Nested Flatpage,") self.assertEqual(out, "A Flatpage,A Nested Flatpage,")
def test_get_flatpages_tag_for_anon_user(self): def test_get_flatpages_tag_for_anon_user(self):
"The flatpage template tag retrives unregistered flatpages for an anonymous user" "The flatpage template tag retrives unregistered flatpages for an anonymous user"
@ -48,7 +48,7 @@ class FlatpageTemplateTagTests(TestCase):
).render(Context({ ).render(Context({
'anonuser': AnonymousUser() 'anonuser': AnonymousUser()
})) }))
self.assertEquals(out, "A Flatpage,A Nested Flatpage,") self.assertEqual(out, "A Flatpage,A Nested Flatpage,")
def test_get_flatpages_tag_for_user(self): def test_get_flatpages_tag_for_user(self):
"The flatpage template tag retrives all flatpages for an authenticated user" "The flatpage template tag retrives all flatpages for an authenticated user"
@ -61,7 +61,7 @@ class FlatpageTemplateTagTests(TestCase):
).render(Context({ ).render(Context({
'me': self.me 'me': self.me
})) }))
self.assertEquals(out, "A Flatpage,A Nested Flatpage,Sekrit Nested Flatpage,Sekrit Flatpage,") self.assertEqual(out, "A Flatpage,A Nested Flatpage,Sekrit Nested Flatpage,Sekrit Flatpage,")
def test_get_flatpages_with_prefix(self): def test_get_flatpages_with_prefix(self):
"The flatpage template tag retrives unregistered prefixed flatpages by default" "The flatpage template tag retrives unregistered prefixed flatpages by default"
@ -72,7 +72,7 @@ class FlatpageTemplateTagTests(TestCase):
"{{ page.title }}," "{{ page.title }},"
"{% endfor %}" "{% endfor %}"
).render(Context()) ).render(Context())
self.assertEquals(out, "A Nested Flatpage,") self.assertEqual(out, "A Nested Flatpage,")
def test_get_flatpages_with_prefix_for_anon_user(self): def test_get_flatpages_with_prefix_for_anon_user(self):
"The flatpage template tag retrives unregistered prefixed flatpages for an anonymous user" "The flatpage template tag retrives unregistered prefixed flatpages for an anonymous user"
@ -85,7 +85,7 @@ class FlatpageTemplateTagTests(TestCase):
).render(Context({ ).render(Context({
'anonuser': AnonymousUser() 'anonuser': AnonymousUser()
})) }))
self.assertEquals(out, "A Nested Flatpage,") self.assertEqual(out, "A Nested Flatpage,")
def test_get_flatpages_with_prefix_for_user(self): def test_get_flatpages_with_prefix_for_user(self):
"The flatpage template tag retrive prefixed flatpages for an authenticated user" "The flatpage template tag retrive prefixed flatpages for an authenticated user"
@ -98,7 +98,7 @@ class FlatpageTemplateTagTests(TestCase):
).render(Context({ ).render(Context({
'me': self.me 'me': self.me
})) }))
self.assertEquals(out, "A Nested Flatpage,Sekrit Nested Flatpage,") self.assertEqual(out, "A Nested Flatpage,Sekrit Nested Flatpage,")
def test_get_flatpages_with_variable_prefix(self): def test_get_flatpages_with_variable_prefix(self):
"The prefix for the flatpage template tag can be a template variable" "The prefix for the flatpage template tag can be a template variable"
@ -111,7 +111,7 @@ class FlatpageTemplateTagTests(TestCase):
).render(Context({ ).render(Context({
'location_prefix': '/location/' 'location_prefix': '/location/'
})) }))
self.assertEquals(out, "A Nested Flatpage,") self.assertEqual(out, "A Nested Flatpage,")
def test_parsing_errors(self): def test_parsing_errors(self):
"There are various ways that the flatpages template tag won't parse" "There are various ways that the flatpages template tag won't parse"

12
django/contrib/flatpages/tests/views.py
View File

@ -31,13 +31,13 @@ class FlatpageViewTests(TestCase):
def test_view_flatpage(self): def test_view_flatpage(self):
"A flatpage can be served through a view" "A flatpage can be served through a view"
response = self.client.get('/flatpage_root/flatpage/') response = self.client.get('/flatpage_root/flatpage/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertContains(response, "<p>Isn't it flat!</p>") self.assertContains(response, "<p>Isn't it flat!</p>")
def test_view_non_existent_flatpage(self): def test_view_non_existent_flatpage(self):
"A non-existent flatpage raises 404 when served through a view" "A non-existent flatpage raises 404 when served through a view"
response = self.client.get('/flatpage_root/no_such_flatpage/') response = self.client.get('/flatpage_root/no_such_flatpage/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)
def test_view_authenticated_flatpage(self): def test_view_authenticated_flatpage(self):
"A flatpage served through a view can require authentication" "A flatpage served through a view can require authentication"
@ -46,18 +46,18 @@ class FlatpageViewTests(TestCase):
User.objects.create_user('testuser', 'test@example.com', 's3krit') User.objects.create_user('testuser', 'test@example.com', 's3krit')
self.client.login(username='testuser',password='s3krit') self.client.login(username='testuser',password='s3krit')
response = self.client.get('/flatpage_root/sekrit/') response = self.client.get('/flatpage_root/sekrit/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertContains(response, "<p>Isn't it sekrit!</p>") self.assertContains(response, "<p>Isn't it sekrit!</p>")
def test_fallback_flatpage(self): def test_fallback_flatpage(self):
"A fallback flatpage won't be served if the middleware is disabled" "A fallback flatpage won't be served if the middleware is disabled"
response = self.client.get('/flatpage/') response = self.client.get('/flatpage/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)
def test_fallback_non_existent_flatpage(self): def test_fallback_non_existent_flatpage(self):
"A non-existent flatpage won't be served if the fallback middlware is disabled" "A non-existent flatpage won't be served if the fallback middlware is disabled"
response = self.client.get('/no_such_flatpage/') response = self.client.get('/no_such_flatpage/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)
def test_view_flatpage_special_chars(self): def test_view_flatpage_special_chars(self):
"A flatpage with special chars in the URL can be served through a view" "A flatpage with special chars in the URL can be served through a view"
@ -71,5 +71,5 @@ class FlatpageViewTests(TestCase):
fp.sites.add(1) fp.sites.add(1)
response = self.client.get('/flatpage_root/some.very_special~chars-here/') response = self.client.get('/flatpage_root/some.very_special~chars-here/')
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertContains(response, "<p>Isn't it special!</p>") self.assertContains(response, "<p>Isn't it special!</p>")

16
django/contrib/formtools/tests/__init__.py
View File

@ -65,8 +65,8 @@ class PreviewTests(TestCase):
response = self.client.get('/test1/') response = self.client.get('/test1/')
stage = self.input % 1 stage = self.input % 1
self.assertContains(response, stage, 1) self.assertContains(response, stage, 1)
self.assertEquals(response.context['custom_context'], True) self.assertEqual(response.context['custom_context'], True)
self.assertEquals(response.context['form'].initial, {'field1': 'Works!'}) self.assertEqual(response.context['form'].initial, {'field1': 'Works!'})
def test_form_preview(self): def test_form_preview(self):
""" """
@ -291,14 +291,14 @@ class WizardTests(TestCase):
step should be zero for the first form step should be zero for the first form
""" """
response = self.client.get('/wizard/') response = self.client.get('/wizard/')
self.assertEquals(0, response.context['step0']) self.assertEqual(0, response.context['step0'])
def test_step_increments(self): def test_step_increments(self):
""" """
step should be incremented when we go to the next page step should be incremented when we go to the next page
""" """
response = self.client.post('/wizard/', {"0-field":"test", "wizard_step":"0"}) response = self.client.post('/wizard/', {"0-field":"test", "wizard_step":"0"})
self.assertEquals(1, response.context['step0']) self.assertEqual(1, response.context['step0'])
def test_bad_hash(self): def test_bad_hash(self):
""" """
@ -308,7 +308,7 @@ class WizardTests(TestCase):
{"0-field":"test", {"0-field":"test",
"1-field":"test2", "1-field":"test2",
"wizard_step": "1"}) "wizard_step": "1"})
self.assertEquals(0, response.context['step0']) self.assertEqual(0, response.context['step0'])
def test_good_hash_django12(self): def test_good_hash_django12(self):
""" """
@ -322,7 +322,7 @@ class WizardTests(TestCase):
"hash_0": "2fdbefd4c0cad51509478fbacddf8b13", "hash_0": "2fdbefd4c0cad51509478fbacddf8b13",
"wizard_step": "1"} "wizard_step": "1"}
response = self.client.post('/wizard/', data) response = self.client.post('/wizard/', data)
self.assertEquals(2, response.context['step0']) self.assertEqual(2, response.context['step0'])
def test_good_hash_django12_subclass(self): def test_good_hash_django12_subclass(self):
""" """
@ -337,7 +337,7 @@ class WizardTests(TestCase):
"hash_0": "2fdbefd4c0cad51509478fbacddf8b13", "hash_0": "2fdbefd4c0cad51509478fbacddf8b13",
"wizard_step": "1"} "wizard_step": "1"}
response = self.client.post('/wizard2/', data) response = self.client.post('/wizard2/', data)
self.assertEquals(0, response.context['step0']) self.assertEqual(0, response.context['step0'])
def test_good_hash_current(self): def test_good_hash_current(self):
""" """
@ -349,7 +349,7 @@ class WizardTests(TestCase):
"hash_0": "7e9cea465f6a10a6fb47fcea65cb9a76350c9a5c", "hash_0": "7e9cea465f6a10a6fb47fcea65cb9a76350c9a5c",
"wizard_step": "1"} "wizard_step": "1"}
response = self.client.post('/wizard/', data) response = self.client.post('/wizard/', data)
self.assertEquals(2, response.context['step0']) self.assertEqual(2, response.context['step0'])
def test_14498(self): def test_14498(self):
""" """

4
django/contrib/gis/gdal/tests/test_geom.py
View File

@ -49,8 +49,8 @@ class OGRGeomTest(unittest.TestCase, TestDataMixin):
def test00b_geomtype_25d(self): def test00b_geomtype_25d(self):
"Testing OGRGeomType object with 25D types." "Testing OGRGeomType object with 25D types."
wkb25bit = OGRGeomType.wkb25bit wkb25bit = OGRGeomType.wkb25bit
self.failUnless(OGRGeomType(wkb25bit + 1) == 'Point25D') self.assertTrue(OGRGeomType(wkb25bit + 1) == 'Point25D')
self.failUnless(OGRGeomType('MultiLineString25D') == (5 + wkb25bit)) self.assertTrue(OGRGeomType('MultiLineString25D') == (5 + wkb25bit))
self.assertEqual('GeometryCollectionField', OGRGeomType('GeometryCollection25D').django) self.assertEqual('GeometryCollectionField', OGRGeomType('GeometryCollection25D').django)
def test01a_wkt(self): def test01a_wkt(self):

18
django/contrib/gis/geos/tests/test_geos.py
View File

@ -867,7 +867,7 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
g1 = g.transform(4326, clone=True) g1 = g.transform(4326, clone=True)
self.assertEqual(g1.tuple, g.tuple) self.assertEqual(g1.tuple, g.tuple)
self.assertEqual(g1.srid, 4326) self.assertEqual(g1.srid, 4326)
self.assert_(g1 is not g, "Clone didn't happen") self.assertTrue(g1 is not g, "Clone didn't happen")
old_has_gdal = gdal.HAS_GDAL old_has_gdal = gdal.HAS_GDAL
try: try:
@ -883,7 +883,7 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
g1 = g.transform(4326, clone=True) g1 = g.transform(4326, clone=True)
self.assertEqual(g1.tuple, g.tuple) self.assertEqual(g1.tuple, g.tuple)
self.assertEqual(g1.srid, 4326) self.assertEqual(g1.srid, 4326)
self.assert_(g1 is not g, "Clone didn't happen") self.assertTrue(g1 is not g, "Clone didn't happen")
finally: finally:
gdal.HAS_GDAL = old_has_gdal gdal.HAS_GDAL = old_has_gdal
@ -907,7 +907,7 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
g = GEOSGeometry('POINT (-104.609 38.255)', srid=None) g = GEOSGeometry('POINT (-104.609 38.255)', srid=None)
g1 = g.transform(2774, clone=True) g1 = g.transform(2774, clone=True)
self.assert_(g1 is None) self.assertTrue(g1 is None)
g = GEOSGeometry('POINT (-104.609 38.255)', srid=-1) g = GEOSGeometry('POINT (-104.609 38.255)', srid=-1)
g.transform(2774) g.transform(2774)
@ -916,7 +916,7 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
g = GEOSGeometry('POINT (-104.609 38.255)', srid=-1) g = GEOSGeometry('POINT (-104.609 38.255)', srid=-1)
g1 = g.transform(2774, clone=True) g1 = g.transform(2774, clone=True)
self.assert_(g1 is None) self.assertTrue(g1 is None)
finally: finally:
warnings.simplefilter('default', UserWarning) warnings.simplefilter('default', UserWarning)
@ -1032,17 +1032,17 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
if not GEOS_PREPARE: return if not GEOS_PREPARE: return
g = GEOSGeometry("POINT(0 0)") g = GEOSGeometry("POINT(0 0)")
self.assert_(g.valid) self.assertTrue(g.valid)
self.assert_(isinstance(g.valid_reason, basestring)) self.assertTrue(isinstance(g.valid_reason, basestring))
self.assertEqual(g.valid_reason, "Valid Geometry") self.assertEqual(g.valid_reason, "Valid Geometry")
print "\nBEGIN - expecting GEOS_NOTICE; safe to ignore.\n" print "\nBEGIN - expecting GEOS_NOTICE; safe to ignore.\n"
g = GEOSGeometry("LINESTRING(0 0, 0 0)") g = GEOSGeometry("LINESTRING(0 0, 0 0)")
self.assert_(not g.valid) self.assertTrue(not g.valid)
self.assert_(isinstance(g.valid_reason, basestring)) self.assertTrue(isinstance(g.valid_reason, basestring))
self.assert_(g.valid_reason.startswith("Too few points in geometry component")) self.assertTrue(g.valid_reason.startswith("Too few points in geometry component"))
print "\nEND - expecting GEOS_NOTICE; safe to ignore.\n" print "\nEND - expecting GEOS_NOTICE; safe to ignore.\n"

32
django/contrib/gis/geos/tests/test_mutable_list.py
View File

@ -362,26 +362,26 @@ class ListMixinTest(unittest.TestCase):
pl, ul = self.lists_of_len() pl, ul = self.lists_of_len()
self.assertEqual(pl, ul, 'cmp for equal') self.assertEqual(pl, ul, 'cmp for equal')
self.assert_(pl >= ul, 'cmp for gte self') self.assertTrue(pl >= ul, 'cmp for gte self')
self.assert_(pl <= ul, 'cmp for lte self') self.assertTrue(pl <= ul, 'cmp for lte self')
self.assert_(ul >= pl, 'cmp for self gte') self.assertTrue(ul >= pl, 'cmp for self gte')
self.assert_(ul <= pl, 'cmp for self lte') self.assertTrue(ul <= pl, 'cmp for self lte')
self.assert_(pl + [5] > ul, 'cmp') self.assertTrue(pl + [5] > ul, 'cmp')
self.assert_(pl + [5] >= ul, 'cmp') self.assertTrue(pl + [5] >= ul, 'cmp')
self.assert_(pl < ul + [2], 'cmp') self.assertTrue(pl < ul + [2], 'cmp')
self.assert_(pl <= ul + [2], 'cmp') self.assertTrue(pl <= ul + [2], 'cmp')
self.assert_(ul + [5] > pl, 'cmp') self.assertTrue(ul + [5] > pl, 'cmp')
self.assert_(ul + [5] >= pl, 'cmp') self.assertTrue(ul + [5] >= pl, 'cmp')
self.assert_(ul < pl + [2], 'cmp') self.assertTrue(ul < pl + [2], 'cmp')
self.assert_(ul <= pl + [2], 'cmp') self.assertTrue(ul <= pl + [2], 'cmp')
pl[1] = 20 pl[1] = 20
self.assert_(pl > ul, 'cmp for gt self') self.assertTrue(pl > ul, 'cmp for gt self')
self.assert_(ul < pl, 'cmp for self lt') self.assertTrue(ul < pl, 'cmp for self lt')
pl[1] = -20 pl[1] = -20
self.assert_(pl < ul, 'cmp for lt self') self.assertTrue(pl < ul, 'cmp for lt self')
self.assert_(pl < ul, 'cmp for lt self') self.assertTrue(pl < ul, 'cmp for lt self')
class ListMixinTestSingle(ListMixinTest): class ListMixinTestSingle(ListMixinTest):
listType = UserListB listType = UserListB

12
django/contrib/gis/tests/geo3d/tests.py
View File

@ -72,7 +72,7 @@ class Geo3DTest(TestCase):
pnt = Point(x, y, z, srid=4326) pnt = Point(x, y, z, srid=4326)
City3D.objects.create(name=name, point=pnt) City3D.objects.create(name=name, point=pnt)
city = City3D.objects.get(name=name) city = City3D.objects.get(name=name)
self.failUnless(city.point.hasz) self.assertTrue(city.point.hasz)
self.assertEqual(z, city.point.z) self.assertEqual(z, city.point.z)
# Interstate (2D / 3D and Geographic/Projected variants) # Interstate (2D / 3D and Geographic/Projected variants)
@ -93,7 +93,7 @@ class Geo3DTest(TestCase):
interstate = Interstate3D.objects.get(name=name) interstate = Interstate3D.objects.get(name=name)
interstate_proj = InterstateProj3D.objects.get(name=name) interstate_proj = InterstateProj3D.objects.get(name=name)
for i in [interstate, interstate_proj]: for i in [interstate, interstate_proj]:
self.failUnless(i.line.hasz) self.assertTrue(i.line.hasz)
self.assertEqual(exp_z, tuple(i.line.z)) self.assertEqual(exp_z, tuple(i.line.z))
# Creating 3D Polygon. # Creating 3D Polygon.
@ -101,7 +101,7 @@ class Geo3DTest(TestCase):
Polygon2D.objects.create(name='2D BBox', poly=bbox2d) Polygon2D.objects.create(name='2D BBox', poly=bbox2d)
Polygon3D.objects.create(name='3D BBox', poly=bbox3d) Polygon3D.objects.create(name='3D BBox', poly=bbox3d)
p3d = Polygon3D.objects.get(name='3D BBox') p3d = Polygon3D.objects.get(name='3D BBox')
self.failUnless(p3d.poly.hasz) self.assertTrue(p3d.poly.hasz)
self.assertEqual(bbox3d, p3d.poly) self.assertEqual(bbox3d, p3d.poly)
def test01a_3d_layermapping(self): def test01a_3d_layermapping(self):
@ -138,7 +138,7 @@ class Geo3DTest(TestCase):
# KML should be 3D. # KML should be 3D.
# `SELECT ST_AsKML(point, 6) FROM geo3d_city3d WHERE name = 'Houston';` # `SELECT ST_AsKML(point, 6) FROM geo3d_city3d WHERE name = 'Houston';`
ref_kml_regex = re.compile(r'^<Point><coordinates>-95.363\d+,29.763\d+,18</coordinates></Point>$') ref_kml_regex = re.compile(r'^<Point><coordinates>-95.363\d+,29.763\d+,18</coordinates></Point>$')
self.failUnless(ref_kml_regex.match(h.kml)) self.assertTrue(ref_kml_regex.match(h.kml))
def test02b_geojson(self): def test02b_geojson(self):
"Test GeoQuerySet.geojson() with Z values." "Test GeoQuerySet.geojson() with Z values."
@ -146,7 +146,7 @@ class Geo3DTest(TestCase):
# GeoJSON should be 3D # GeoJSON should be 3D
# `SELECT ST_AsGeoJSON(point, 6) FROM geo3d_city3d WHERE name='Houston';` # `SELECT ST_AsGeoJSON(point, 6) FROM geo3d_city3d WHERE name='Houston';`
ref_json_regex = re.compile(r'^{"type":"Point","coordinates":\[-95.363151,29.763374,18(\.0+)?\]}$') ref_json_regex = re.compile(r'^{"type":"Point","coordinates":\[-95.363151,29.763374,18(\.0+)?\]}$')
self.failUnless(ref_json_regex.match(h.geojson)) self.assertTrue(ref_json_regex.match(h.geojson))
def test03a_union(self): def test03a_union(self):
"Testing the Union aggregate of 3D models." "Testing the Union aggregate of 3D models."
@ -155,7 +155,7 @@ class Geo3DTest(TestCase):
ref_ewkt = 'SRID=4326;MULTIPOINT(-123.305196 48.462611 15,-104.609252 38.255001 1433,-97.521157 34.464642 380,-96.801611 32.782057 147,-95.363151 29.763374 18,-95.23506 38.971823 251,-87.650175 41.850385 181,174.783117 -41.315268 14)' ref_ewkt = 'SRID=4326;MULTIPOINT(-123.305196 48.462611 15,-104.609252 38.255001 1433,-97.521157 34.464642 380,-96.801611 32.782057 147,-95.363151 29.763374 18,-95.23506 38.971823 251,-87.650175 41.850385 181,174.783117 -41.315268 14)'
ref_union = GEOSGeometry(ref_ewkt) ref_union = GEOSGeometry(ref_ewkt)
union = City3D.objects.aggregate(Union('point'))['point__union'] union = City3D.objects.aggregate(Union('point'))['point__union']
self.failUnless(union.hasz) self.assertTrue(union.hasz)
self.assertEqual(ref_union, union) self.assertEqual(ref_union, union)
def test03b_extent(self): def test03b_extent(self):

10
django/contrib/gis/tests/geoapp/tests.py
View File

@ -133,11 +133,11 @@ class GeoModelTest(TestCase):
# No precision parameter for Oracle :-/ # No precision parameter for Oracle :-/
gml_regex = re.compile(r'^<gml:Point srsName="SDO:4326" xmlns:gml="http://www.opengis.net/gml"><gml:coordinates decimal="\." cs="," ts=" ">-104.60925\d+,38.25500\d+ </gml:coordinates></gml:Point>') gml_regex = re.compile(r'^<gml:Point srsName="SDO:4326" xmlns:gml="http://www.opengis.net/gml"><gml:coordinates decimal="\." cs="," ts=" ">-104.60925\d+,38.25500\d+ </gml:coordinates></gml:Point>')
for ptown in [ptown1, ptown2]: for ptown in [ptown1, ptown2]:
self.failUnless(gml_regex.match(ptown.gml)) self.assertTrue(gml_regex.match(ptown.gml))
else: else:
gml_regex = re.compile(r'^<gml:Point srsName="EPSG:4326"><gml:coordinates>-104\.60925\d+,38\.255001</gml:coordinates></gml:Point>') gml_regex = re.compile(r'^<gml:Point srsName="EPSG:4326"><gml:coordinates>-104\.60925\d+,38\.255001</gml:coordinates></gml:Point>')
for ptown in [ptown1, ptown2]: for ptown in [ptown1, ptown2]:
self.failUnless(gml_regex.match(ptown.gml)) self.assertTrue(gml_regex.match(ptown.gml))
def test03c_geojson(self): def test03c_geojson(self):
"Testing GeoJSON output from the database using GeoQuerySet.geojson()." "Testing GeoJSON output from the database using GeoQuerySet.geojson()."
@ -678,15 +678,15 @@ class GeoModelTest(TestCase):
# SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.1)) FROM "geoapp_country" WHERE "geoapp_country"."name" = 'San Marino'; # SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.1)) FROM "geoapp_country" WHERE "geoapp_country"."name" = 'San Marino';
ref = fromstr('MULTIPOLYGON(((12.4 44,12.5 44,12.5 43.9,12.4 43.9,12.4 44)))') ref = fromstr('MULTIPOLYGON(((12.4 44,12.5 44,12.5 43.9,12.4 43.9,12.4 44)))')
self.failUnless(ref.equals_exact(Country.objects.snap_to_grid(0.1).get(name='San Marino').snap_to_grid, tol)) self.assertTrue(ref.equals_exact(Country.objects.snap_to_grid(0.1).get(name='San Marino').snap_to_grid, tol))
# SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.05, 0.23)) FROM "geoapp_country" WHERE "geoapp_country"."name" = 'San Marino'; # SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.05, 0.23)) FROM "geoapp_country" WHERE "geoapp_country"."name" = 'San Marino';
ref = fromstr('MULTIPOLYGON(((12.4 43.93,12.45 43.93,12.5 43.93,12.45 43.93,12.4 43.93)))') ref = fromstr('MULTIPOLYGON(((12.4 43.93,12.45 43.93,12.5 43.93,12.45 43.93,12.4 43.93)))')
self.failUnless(ref.equals_exact(Country.objects.snap_to_grid(0.05, 0.23).get(name='San Marino').snap_to_grid, tol)) self.assertTrue(ref.equals_exact(Country.objects.snap_to_grid(0.05, 0.23).get(name='San Marino').snap_to_grid, tol))
# SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.5, 0.17, 0.05, 0.23)) FROM "geoapp_country" WHERE "geoapp_country"."name" = 'San Marino'; # SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.5, 0.17, 0.05, 0.23)) FROM "geoapp_country" WHERE "geoapp_country"."name" = 'San Marino';
ref = fromstr('MULTIPOLYGON(((12.4 43.87,12.45 43.87,12.45 44.1,12.5 44.1,12.5 43.87,12.45 43.87,12.4 43.87)))') ref = fromstr('MULTIPOLYGON(((12.4 43.87,12.45 43.87,12.45 44.1,12.5 44.1,12.5 43.87,12.45 43.87,12.4 43.87)))')
self.failUnless(ref.equals_exact(Country.objects.snap_to_grid(0.05, 0.23, 0.5, 0.17).get(name='San Marino').snap_to_grid, tol)) self.assertTrue(ref.equals_exact(Country.objects.snap_to_grid(0.05, 0.23, 0.5, 0.17).get(name='San Marino').snap_to_grid, tol))
@no_mysql @no_mysql
@no_spatialite @no_spatialite

8
django/contrib/gis/tests/relatedapp/tests.py
View File

@ -173,8 +173,8 @@ class RelatedGeoModelTest(TestCase):
for m, d, t in zip(gqs, gvqs, gvlqs): for m, d, t in zip(gqs, gvqs, gvlqs):
# The values should be Geometry objects and not raw strings returned # The values should be Geometry objects and not raw strings returned
# by the spatial database. # by the spatial database.
self.failUnless(isinstance(d['point'], Geometry)) self.assertTrue(isinstance(d['point'], Geometry))
self.failUnless(isinstance(t[1], Geometry)) self.assertTrue(isinstance(t[1], Geometry))
self.assertEqual(m.point, d['point']) self.assertEqual(m.point, d['point'])
self.assertEqual(m.point, t[1]) self.assertEqual(m.point, t[1])
@ -207,8 +207,8 @@ class RelatedGeoModelTest(TestCase):
combined = qs1 | qs2 combined = qs1 | qs2
names = [c.name for c in combined] names = [c.name for c in combined]
self.assertEqual(2, len(names)) self.assertEqual(2, len(names))
self.failUnless('Aurora' in names) self.assertTrue('Aurora' in names)
self.failUnless('Kecksburg' in names) self.assertTrue('Kecksburg' in names)
def test11_geoquery_pickle(self): def test11_geoquery_pickle(self):
"Ensuring GeoQuery objects are unpickled correctly. See #10839." "Ensuring GeoQuery objects are unpickled correctly. See #10839."

2
django/contrib/gis/tests/test_geoforms.py
View File

@ -26,7 +26,7 @@ class GeometryFieldTest(unittest.TestCase):
xform_geom = GEOSGeometry('POINT (951640.547328465 4219369.26171664)', srid=32140) xform_geom = GEOSGeometry('POINT (951640.547328465 4219369.26171664)', srid=32140)
# The cleaned geometry should be transformed to 32140. # The cleaned geometry should be transformed to 32140.
cleaned_geom = fld.clean('SRID=4326;POINT (-95.363151 29.763374)') cleaned_geom = fld.clean('SRID=4326;POINT (-95.363151 29.763374)')
self.failUnless(xform_geom.equals_exact(cleaned_geom, tol)) self.assertTrue(xform_geom.equals_exact(cleaned_geom, tol))
def test02_null(self): def test02_null(self):
"Testing GeometryField's handling of null (None) geometries." "Testing GeometryField's handling of null (None) geometries."

14
django/contrib/gis/tests/test_measure.py
View File

@ -107,7 +107,7 @@ class DistanceTest(unittest.TestCase):
self.assertEqual(d4.m, 10) self.assertEqual(d4.m, 10)
a5 = d1 * D(m=10) a5 = d1 * D(m=10)
self.assert_(isinstance(a5, Area)) self.assertTrue(isinstance(a5, Area))
self.assertEqual(a5.sq_m, 100*10) self.assertEqual(a5.sq_m, 100*10)
try: try:
@ -151,9 +151,9 @@ class DistanceTest(unittest.TestCase):
d2 = D(km=1) d2 = D(km=1)
d3 = D(km=0) d3 = D(km=0)
self.assert_(d2 > d1) self.assertTrue(d2 > d1)
self.assert_(d1 == d1) self.assertTrue(d1 == d1)
self.assert_(d1 < d2) self.assertTrue(d1 < d2)
self.failIf(d3) self.failIf(d3)
def testUnitsStr(self): def testUnitsStr(self):
@ -309,9 +309,9 @@ class AreaTest(unittest.TestCase):
a2 = A(sq_km=1) a2 = A(sq_km=1)
a3 = A(sq_km=0) a3 = A(sq_km=0)
self.assert_(a2 > a1) self.assertTrue(a2 > a1)
self.assert_(a1 == a1) self.assertTrue(a1 == a1)
self.assert_(a1 < a2) self.assertTrue(a1 < a2)
self.failIf(a3) self.failIf(a3)
def testUnitsStr(self): def testUnitsStr(self):

8
django/contrib/messages/tests/base.py
View File

@ -349,7 +349,7 @@ class BaseTest(TestCase):
self.assertFalse(storage.used) self.assertFalse(storage.used)
# After iterating the storage engine directly, the used flag is set. # After iterating the storage engine directly, the used flag is set.
data = list(storage) data = list(storage)
self.assert_(storage.used) self.assertTrue(storage.used)
# The data does not disappear because it has been iterated. # The data does not disappear because it has been iterated.
self.assertEqual(data, list(storage)) self.assertEqual(data, list(storage))
@ -357,7 +357,7 @@ class BaseTest(TestCase):
storage = self.get_existing_storage() storage = self.get_existing_storage()
self.assertFalse(storage.added_new) self.assertFalse(storage.added_new)
storage.add(constants.INFO, 'Test message 3') storage.add(constants.INFO, 'Test message 3')
self.assert_(storage.added_new) self.assertTrue(storage.added_new)
def test_default_level(self): def test_default_level(self):
# get_level works even with no storage on the request. # get_level works even with no storage on the request.
@ -378,7 +378,7 @@ class BaseTest(TestCase):
storage = self.storage_class(request) storage = self.storage_class(request)
request._messages = storage request._messages = storage
self.assert_(set_level(request, 5)) self.assertTrue(set_level(request, 5))
self.assertEqual(get_level(request), 5) self.assertEqual(get_level(request), 5)
add_level_messages(storage) add_level_messages(storage)
@ -389,7 +389,7 @@ class BaseTest(TestCase):
storage = self.storage_class(request) storage = self.storage_class(request)
request._messages = storage request._messages = storage
self.assert_(set_level(request, 30)) self.assertTrue(set_level(request, 30))
self.assertEqual(get_level(request), 30) self.assertEqual(get_level(request), 30)
add_level_messages(storage) add_level_messages(storage)

2
django/contrib/messages/tests/cookie.py
View File

@ -83,7 +83,7 @@ class CookieTest(BaseTest):
self.assertEqual(cookie_storing, 4) self.assertEqual(cookie_storing, 4)
self.assertEqual(len(unstored_messages), 1) self.assertEqual(len(unstored_messages), 1)
self.assert_(unstored_messages[0].message == '0' * msg_size) self.assertTrue(unstored_messages[0].message == '0' * msg_size)
def test_json_encoder_decoder(self): def test_json_encoder_decoder(self):
""" """

12
django/contrib/sitemaps/tests/basic.py
View File

@ -40,7 +40,7 @@ class SitemapTests(TestCase):
# Retrieve the sitemap. # Retrieve the sitemap.
response = self.client.get('/simple/index.xml') response = self.client.get('/simple/index.xml')
# Check for all the important bits: # Check for all the important bits:
self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?> self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<sitemap><loc>%s/simple/sitemap-simple.xml</loc></sitemap> <sitemap><loc>%s/simple/sitemap-simple.xml</loc></sitemap>
</sitemapindex> </sitemapindex>
@ -51,7 +51,7 @@ class SitemapTests(TestCase):
# Retrieve the sitemap. # Retrieve the sitemap.
response = self.client.get('/simple/custom-index.xml') response = self.client.get('/simple/custom-index.xml')
# Check for all the important bits: # Check for all the important bits:
self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?> self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
<!-- This is a customised template --> <!-- This is a customised template -->
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<sitemap><loc>%s/simple/sitemap-simple.xml</loc></sitemap> <sitemap><loc>%s/simple/sitemap-simple.xml</loc></sitemap>
@ -63,7 +63,7 @@ class SitemapTests(TestCase):
# Retrieve the sitemap. # Retrieve the sitemap.
response = self.client.get('/simple/sitemap.xml') response = self.client.get('/simple/sitemap.xml')
# Check for all the important bits: # Check for all the important bits:
self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?> self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<url><loc>%s/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url> <url><loc>%s/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url>
</urlset> </urlset>
@ -74,7 +74,7 @@ class SitemapTests(TestCase):
# Retrieve the sitemap. # Retrieve the sitemap.
response = self.client.get('/simple/custom-sitemap.xml') response = self.client.get('/simple/custom-sitemap.xml')
# Check for all the important bits: # Check for all the important bits:
self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?> self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
<!-- This is a customised template --> <!-- This is a customised template -->
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<url><loc>%s/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url> <url><loc>%s/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url>
@ -105,7 +105,7 @@ class SitemapTests(TestCase):
for username in User.objects.values_list("username", flat=True): for username in User.objects.values_list("username", flat=True):
expected += "<url><loc>%s/users/%s/</loc></url>" % (self.base_url, username) expected += "<url><loc>%s/users/%s/</loc></url>" % (self.base_url, username)
# Check for all the important bits: # Check for all the important bits:
self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?> self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
%s %s
</urlset> </urlset>
@ -148,7 +148,7 @@ class SitemapTests(TestCase):
# Retrieve the sitemap. # Retrieve the sitemap.
response = self.client.get('/simple/sitemap.xml') response = self.client.get('/simple/sitemap.xml')
# Check for all the important bits: # Check for all the important bits:
self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?> self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<url><loc>http://testserver/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url> <url><loc>http://testserver/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url>
</urlset> </urlset>

6
django/contrib/sites/tests.py
View File

@ -18,7 +18,7 @@ class SitesFrameworkTests(TestCase):
def test_site_manager(self): def test_site_manager(self):
# Make sure that get_current() does not return a deleted Site object. # Make sure that get_current() does not return a deleted Site object.
s = Site.objects.get_current() s = Site.objects.get_current()
self.assert_(isinstance(s, Site)) self.assertTrue(isinstance(s, Site))
s.delete() s.delete()
self.assertRaises(ObjectDoesNotExist, Site.objects.get_current) self.assertRaises(ObjectDoesNotExist, Site.objects.get_current)
@ -41,7 +41,7 @@ class SitesFrameworkTests(TestCase):
"SERVER_PORT": "80", "SERVER_PORT": "80",
} }
site = get_current_site(request) site = get_current_site(request)
self.assert_(isinstance(site, Site)) self.assertTrue(isinstance(site, Site))
self.assertEqual(site.id, settings.SITE_ID) self.assertEqual(site.id, settings.SITE_ID)
# Test that an exception is raised if the sites framework is installed # Test that an exception is raised if the sites framework is installed
@ -52,5 +52,5 @@ class SitesFrameworkTests(TestCase):
# A RequestSite is returned if the sites framework is not installed # A RequestSite is returned if the sites framework is not installed
Site._meta.installed = False Site._meta.installed = False
site = get_current_site(request) site = get_current_site(request)
self.assert_(isinstance(site, RequestSite)) self.assertTrue(isinstance(site, RequestSite))
self.assertEqual(site.name, u"example.com") self.assertEqual(site.name, u"example.com")

8
django/utils/unittest/case.py
View File

@ -831,8 +831,8 @@ class TestCase(unittest.TestCase):
self.fail(self._formatMessage(msg, standardMsg)) self.fail(self._formatMessage(msg, standardMsg))
def assertDictEqual(self, d1, d2, msg=None): def assertDictEqual(self, d1, d2, msg=None):
self.assert_(isinstance(d1, dict), 'First argument is not a dictionary') self.assertTrue(isinstance(d1, dict), 'First argument is not a dictionary')
self.assert_(isinstance(d2, dict), 'Second argument is not a dictionary') self.assertTrue(isinstance(d2, dict), 'Second argument is not a dictionary')
if d1 != d2: if d1 != d2:
standardMsg = '%s != %s' % (safe_repr(d1, True), safe_repr(d2, True)) standardMsg = '%s != %s' % (safe_repr(d1, True), safe_repr(d2, True))
@ -909,9 +909,9 @@ class TestCase(unittest.TestCase):
def assertMultiLineEqual(self, first, second, msg=None): def assertMultiLineEqual(self, first, second, msg=None):
"""Assert that two multi-line strings are equal.""" """Assert that two multi-line strings are equal."""
self.assert_(isinstance(first, basestring), ( self.assertTrue(isinstance(first, basestring), (
'First argument is not a string')) 'First argument is not a string'))
self.assert_(isinstance(second, basestring), ( self.assertTrue(isinstance(second, basestring), (
'Second argument is not a string')) 'Second argument is not a string'))
if first != second: if first != second:

2
docs/topics/testing.txt
View File

@ -1079,7 +1079,7 @@ The following is a simple unit test using the request factory::
# Test my_view() as if it were deployed at /customer/details # Test my_view() as if it were deployed at /customer/details
response = my_view(request) response = my_view(request)
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
TestCase TestCase
-------- --------

2
tests/modeltests/aggregation/tests.py
View File

@ -41,7 +41,7 @@ class BaseAggregateTestCase(TestCase):
vals = Book.objects.aggregate(Sum("publisher__num_awards")) vals = Book.objects.aggregate(Sum("publisher__num_awards"))
self.assertEqual(len(vals), 1) self.assertEqual(len(vals), 1)
self.assertEquals(vals["publisher__num_awards__sum"], 30) self.assertEqual(vals["publisher__num_awards__sum"], 30)
vals = Publisher.objects.aggregate(Sum("book__price")) vals = Publisher.objects.aggregate(Sum("book__price"))
self.assertEqual(len(vals), 1) self.assertEqual(len(vals), 1)

2
tests/modeltests/model_formsets/tests.py
View File

@ -946,7 +946,7 @@ class ModelFormsetTest(TestCase):
# default. This is required to ensure the value is tested for change correctly # default. This is required to ensure the value is tested for change correctly
# when determine what extra forms have changed to save. # when determine what extra forms have changed to save.
self.assertEquals(len(formset.forms), 1) # this formset only has one form self.assertEqual(len(formset.forms), 1) # this formset only has one form
form = formset.forms[0] form = formset.forms[0]
now = form.fields['date_joined'].initial() now = form.fields['date_joined'].initial()
result = form.as_p() result = form.as_p()

4
tests/modeltests/model_inheritance_same_model_name/tests.py
View File

@ -11,7 +11,7 @@ class InheritanceSameModelNameTests(TestCase):
def test_inheritance_related_name(self): def test_inheritance_related_name(self):
from modeltests.model_inheritance.models import Copy from modeltests.model_inheritance.models import Copy
self.assertEquals( self.assertEqual(
self.title.attached_model_inheritance_copy_set.create( self.title.attached_model_inheritance_copy_set.create(
content='Save $ on V1agr@', content='Save $ on V1agr@',
url='http://v1agra.com/', url='http://v1agra.com/',
@ -20,7 +20,7 @@ class InheritanceSameModelNameTests(TestCase):
def test_inheritance_with_same_model_name(self): def test_inheritance_with_same_model_name(self):
from modeltests.model_inheritance_same_model_name.models import Copy from modeltests.model_inheritance_same_model_name.models import Copy
self.assertEquals( self.assertEqual(
self.title.attached_model_inheritance_same_model_name_copy_set.create( self.title.attached_model_inheritance_same_model_name_copy_set.create(
content='The Web framework for perfectionists with deadlines.', content='The Web framework for perfectionists with deadlines.',
url='http://www.djangoproject.com/', url='http://www.djangoproject.com/',

4
tests/modeltests/proxy_model_inheritance/tests.py
View File

@ -32,5 +32,5 @@ class ProxyModelInheritanceTests(TransactionTestCase):
sys.path = self.old_sys_path sys.path = self.old_sys_path
def test_table_exists(self): def test_table_exists(self):
self.assertEquals(NiceModel.objects.all().count(), 0) self.assertEqual(NiceModel.objects.all().count(), 0)
self.assertEquals(ProxyModel.objects.all().count(), 0) self.assertEqual(ProxyModel.objects.all().count(), 0)

10
tests/modeltests/raw_query/tests.py
View File

@ -30,10 +30,10 @@ class RawQueryTests(TestCase):
for field in model._meta.fields: for field in model._meta.fields:
# Check that all values on the model are equal # Check that all values on the model are equal
self.assertEquals(getattr(item,field.attname), self.assertEqual(getattr(item,field.attname),
getattr(orig_item,field.attname)) getattr(orig_item,field.attname))
# This includes checking that they are the same type # This includes checking that they are the same type
self.assertEquals(type(getattr(item,field.attname)), self.assertEqual(type(getattr(item,field.attname)),
type(getattr(orig_item,field.attname))) type(getattr(orig_item,field.attname)))
def assertNoAnnotations(self, results): def assertNoAnnotations(self, results):
@ -67,9 +67,9 @@ class RawQueryTests(TestCase):
iterated over. iterated over.
""" """
q = Author.objects.raw('SELECT * FROM raw_query_author') q = Author.objects.raw('SELECT * FROM raw_query_author')
self.assert_(q.query.cursor is None) self.assertTrue(q.query.cursor is None)
list(q) list(q)
self.assert_(q.query.cursor is not None) self.assertTrue(q.query.cursor is not None)
def testFkeyRawQuery(self): def testFkeyRawQuery(self):
""" """
@ -204,7 +204,7 @@ class RawQueryTests(TestCase):
self.assertEqual(third_author.first_name, 'Bob') self.assertEqual(third_author.first_name, 'Bob')
first_two = Author.objects.raw(query)[0:2] first_two = Author.objects.raw(query)[0:2]
self.assertEquals(len(first_two), 2) self.assertEqual(len(first_two), 2)
self.assertRaises(TypeError, lambda: Author.objects.raw(query)['test']) self.assertRaises(TypeError, lambda: Author.objects.raw(query)['test'])

2
tests/modeltests/serializers/tests.py
View File

@ -225,7 +225,7 @@ class SerializersTestBase(object):
serial_str = serializers.serialize(self.serializer_name, [a]) serial_str = serializers.serialize(self.serializer_name, [a])
date_values = self._get_field_values(serial_str, "pub_date") date_values = self._get_field_values(serial_str, "pub_date")
self.assertEquals(date_values[0], "0001-02-03 04:05:06") self.assertEqual(date_values[0], "0001-02-03 04:05:06")
def test_pkless_serialized_strings(self): def test_pkless_serialized_strings(self):
""" """

6
tests/modeltests/test_client/models.py
View File

@ -79,7 +79,7 @@ class ClientTest(TestCase):
"Check the value of HTTP headers returned in a response" "Check the value of HTTP headers returned in a response"
response = self.client.get("/test_client/header_view/") response = self.client.get("/test_client/header_view/")
self.assertEquals(response['X-DJANGO-TEST'], 'Slartibartfast') self.assertEqual(response['X-DJANGO-TEST'], 'Slartibartfast')
def test_raw_post(self): def test_raw_post(self):
"POST raw data (with a content type) to a view" "POST raw data (with a content type) to a view"
@ -140,7 +140,7 @@ class ClientTest(TestCase):
"A URL that redirects can be followed to termination." "A URL that redirects can be followed to termination."
response = self.client.get('/test_client/double_redirect_view/', follow=True) response = self.client.get('/test_client/double_redirect_view/', follow=True)
self.assertRedirects(response, 'http://testserver/test_client/get_view/', status_code=302, target_status_code=200) self.assertRedirects(response, 'http://testserver/test_client/get_view/', status_code=302, target_status_code=200)
self.assertEquals(len(response.redirect_chain), 2) self.assertEqual(len(response.redirect_chain), 2)
def test_redirect_http(self): def test_redirect_http(self):
"GET a URL that redirects to an http URI" "GET a URL that redirects to an http URI"
@ -400,7 +400,7 @@ class ClientTest(TestCase):
response = self.client.post('/test_client/session_view/') response = self.client.post('/test_client/session_view/')
# Check that the session was modified # Check that the session was modified
self.assertEquals(self.client.session['tobacconist'], 'hovercraft') self.assertEqual(self.client.session['tobacconist'], 'hovercraft')
def test_view_with_exception(self): def test_view_with_exception(self):
"Request a page that is known to throw an error" "Request a page that is known to throw an error"

4
tests/modeltests/unmanaged_models/tests.py
View File

@ -47,7 +47,7 @@ class ManyToManyUnmanagedTests(TestCase):
""" """
table = Unmanaged2._meta.get_field('mm').m2m_db_table() table = Unmanaged2._meta.get_field('mm').m2m_db_table()
tables = connection.introspection.table_names() tables = connection.introspection.table_names()
self.assert_(table not in tables, "Table '%s' should not exist, but it does." % table) self.assertTrue(table not in tables, "Table '%s' should not exist, but it does." % table)
def test_many_to_many_between_unmanaged_and_managed(self): def test_many_to_many_between_unmanaged_and_managed(self):
""" """
@ -55,4 +55,4 @@ class ManyToManyUnmanagedTests(TestCase):
""" """
table = Managed1._meta.get_field('mm').m2m_db_table() table = Managed1._meta.get_field('mm').m2m_db_table()
tables = connection.introspection.table_names() tables = connection.introspection.table_names()
self.assert_(table in tables, "Table '%s' does not exist." % table) self.assertTrue(table in tables, "Table '%s' does not exist." % table)

4
tests/modeltests/user_commands/tests.py
View File

@ -8,13 +8,13 @@ class CommandTests(TestCase):
def test_command(self): def test_command(self):
out = StringIO() out = StringIO()
management.call_command('dance', stdout=out) management.call_command('dance', stdout=out)
self.assertEquals(out.getvalue(), self.assertEqual(out.getvalue(),
"I don't feel like dancing Rock'n'Roll.") "I don't feel like dancing Rock'n'Roll.")
def test_command_style(self): def test_command_style(self):
out = StringIO() out = StringIO()
management.call_command('dance', style='Jive', stdout=out) management.call_command('dance', style='Jive', stdout=out)
self.assertEquals(out.getvalue(), self.assertEqual(out.getvalue(),
"I don't feel like dancing Jive.") "I don't feel like dancing Jive.")
def test_explode(self): def test_explode(self):

4
tests/modeltests/validation/__init__.py
View File

@ -8,7 +8,7 @@ class ValidationTestCase(unittest.TestCase):
try: try:
clean() clean()
except ValidationError, e: except ValidationError, e:
self.assertEquals(sorted(failed_fields), sorted(e.message_dict.keys())) self.assertEqual(sorted(failed_fields), sorted(e.message_dict.keys()))
def assertFieldFailsValidationWithMessage(self, clean, field_name, message): def assertFieldFailsValidationWithMessage(self, clean, field_name, message):
self.assertRaises(ValidationError, clean) self.assertRaises(ValidationError, clean)
@ -16,6 +16,6 @@ class ValidationTestCase(unittest.TestCase):
clean() clean()
except ValidationError, e: except ValidationError, e:
self.assertTrue(field_name in e.message_dict) self.assertTrue(field_name in e.message_dict)
self.assertEquals(message, e.message_dict[field_name]) self.assertEqual(message, e.message_dict[field_name])

12
tests/modeltests/validators/tests.py
View File

@ -141,18 +141,18 @@ def create_simple_test_method(validator, expected, value, num):
class TestSimpleValidators(TestCase): class TestSimpleValidators(TestCase):
def test_single_message(self): def test_single_message(self):
v = ValidationError('Not Valid') v = ValidationError('Not Valid')
self.assertEquals(str(v), "[u'Not Valid']") self.assertEqual(str(v), "[u'Not Valid']")
self.assertEquals(repr(v), "ValidationError([u'Not Valid'])") self.assertEqual(repr(v), "ValidationError([u'Not Valid'])")
def test_message_list(self): def test_message_list(self):
v = ValidationError(['First Problem', 'Second Problem']) v = ValidationError(['First Problem', 'Second Problem'])
self.assertEquals(str(v), "[u'First Problem', u'Second Problem']") self.assertEqual(str(v), "[u'First Problem', u'Second Problem']")
self.assertEquals(repr(v), "ValidationError([u'First Problem', u'Second Problem'])") self.assertEqual(repr(v), "ValidationError([u'First Problem', u'Second Problem'])")
def test_message_dict(self): def test_message_dict(self):
v = ValidationError({'first': 'First Problem'}) v = ValidationError({'first': 'First Problem'})
self.assertEquals(str(v), "{'first': 'First Problem'}") self.assertEqual(str(v), "{'first': 'First Problem'}")
self.assertEquals(repr(v), "ValidationError({'first': 'First Problem'})") self.assertEqual(repr(v), "ValidationError({'first': 'First Problem'})")
test_counter = 0 test_counter = 0
for validator, value, expected in TEST_DATA: for validator, value, expected in TEST_DATA:

60
tests/regressiontests/admin_filterspecs/tests.py
View File

@ -42,20 +42,20 @@ class FilterSpecsTests(TestCase):
# Make sure the last choice is None and is selected # Make sure the last choice is None and is selected
filterspec = changelist.get_filters(request)[0][0] filterspec = changelist.get_filters(request)[0][0]
self.assertEquals(force_unicode(filterspec.title()), u'year') self.assertEqual(force_unicode(filterspec.title()), u'year')
choices = list(filterspec.choices(changelist)) choices = list(filterspec.choices(changelist))
self.assertEquals(choices[-1]['selected'], True) self.assertEqual(choices[-1]['selected'], True)
self.assertEquals(choices[-1]['query_string'], '?year__isnull=True') self.assertEqual(choices[-1]['query_string'], '?year__isnull=True')
request = self.request_factory.get('/', {'year': '2002'}) request = self.request_factory.get('/', {'year': '2002'})
changelist = self.get_changelist(request, Book, modeladmin) changelist = self.get_changelist(request, Book, modeladmin)
# Make sure the correct choice is selected # Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][0] filterspec = changelist.get_filters(request)[0][0]
self.assertEquals(force_unicode(filterspec.title()), u'year') self.assertEqual(force_unicode(filterspec.title()), u'year')
choices = list(filterspec.choices(changelist)) choices = list(filterspec.choices(changelist))
self.assertEquals(choices[2]['selected'], True) self.assertEqual(choices[2]['selected'], True)
self.assertEquals(choices[2]['query_string'], '?year=2002') self.assertEqual(choices[2]['query_string'], '?year=2002')
def test_RelatedFilterSpec_ForeignKey(self): def test_RelatedFilterSpec_ForeignKey(self):
modeladmin = BookAdmin(Book, admin.site) modeladmin = BookAdmin(Book, admin.site)
@ -70,20 +70,20 @@ class FilterSpecsTests(TestCase):
# Make sure the last choice is None and is selected # Make sure the last choice is None and is selected
filterspec = changelist.get_filters(request)[0][1] filterspec = changelist.get_filters(request)[0][1]
self.assertEquals(force_unicode(filterspec.title()), u'author') self.assertEqual(force_unicode(filterspec.title()), u'author')
choices = list(filterspec.choices(changelist)) choices = list(filterspec.choices(changelist))
self.assertEquals(choices[-1]['selected'], True) self.assertEqual(choices[-1]['selected'], True)
self.assertEquals(choices[-1]['query_string'], '?author__isnull=True') self.assertEqual(choices[-1]['query_string'], '?author__isnull=True')
request = self.request_factory.get('/', {'author__id__exact': '1'}) request = self.request_factory.get('/', {'author__id__exact': '1'})
changelist = self.get_changelist(request, Book, modeladmin) changelist = self.get_changelist(request, Book, modeladmin)
# Make sure the correct choice is selected # Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][1] filterspec = changelist.get_filters(request)[0][1]
self.assertEquals(force_unicode(filterspec.title()), u'author') self.assertEqual(force_unicode(filterspec.title()), u'author')
choices = list(filterspec.choices(changelist)) choices = list(filterspec.choices(changelist))
self.assertEquals(choices[1]['selected'], True) self.assertEqual(choices[1]['selected'], True)
self.assertEquals(choices[1]['query_string'], '?author__id__exact=1') self.assertEqual(choices[1]['query_string'], '?author__id__exact=1')
def test_RelatedFilterSpec_ManyToMany(self): def test_RelatedFilterSpec_ManyToMany(self):
modeladmin = BookAdmin(Book, admin.site) modeladmin = BookAdmin(Book, admin.site)
@ -96,20 +96,20 @@ class FilterSpecsTests(TestCase):
# Make sure the last choice is None and is selected # Make sure the last choice is None and is selected
filterspec = changelist.get_filters(request)[0][2] filterspec = changelist.get_filters(request)[0][2]
self.assertEquals(force_unicode(filterspec.title()), u'user') self.assertEqual(force_unicode(filterspec.title()), u'user')
choices = list(filterspec.choices(changelist)) choices = list(filterspec.choices(changelist))
self.assertEquals(choices[-1]['selected'], True) self.assertEqual(choices[-1]['selected'], True)
self.assertEquals(choices[-1]['query_string'], '?contributors__isnull=True') self.assertEqual(choices[-1]['query_string'], '?contributors__isnull=True')
request = self.request_factory.get('/', {'contributors__id__exact': '2'}) request = self.request_factory.get('/', {'contributors__id__exact': '2'})
changelist = self.get_changelist(request, Book, modeladmin) changelist = self.get_changelist(request, Book, modeladmin)
# Make sure the correct choice is selected # Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][2] filterspec = changelist.get_filters(request)[0][2]
self.assertEquals(force_unicode(filterspec.title()), u'user') self.assertEqual(force_unicode(filterspec.title()), u'user')
choices = list(filterspec.choices(changelist)) choices = list(filterspec.choices(changelist))
self.assertEquals(choices[2]['selected'], True) self.assertEqual(choices[2]['selected'], True)
self.assertEquals(choices[2]['query_string'], '?contributors__id__exact=2') self.assertEqual(choices[2]['query_string'], '?contributors__id__exact=2')
def test_RelatedFilterSpec_reverse_relationships(self): def test_RelatedFilterSpec_reverse_relationships(self):
@ -124,20 +124,20 @@ class FilterSpecsTests(TestCase):
# Make sure the last choice is None and is selected # Make sure the last choice is None and is selected
filterspec = changelist.get_filters(request)[0][0] filterspec = changelist.get_filters(request)[0][0]
self.assertEquals(force_unicode(filterspec.title()), u'book') self.assertEqual(force_unicode(filterspec.title()), u'book')
choices = list(filterspec.choices(changelist)) choices = list(filterspec.choices(changelist))
self.assertEquals(choices[-1]['selected'], True) self.assertEqual(choices[-1]['selected'], True)
self.assertEquals(choices[-1]['query_string'], '?books_authored__isnull=True') self.assertEqual(choices[-1]['query_string'], '?books_authored__isnull=True')
request = self.request_factory.get('/', {'books_authored__id__exact': '1'}) request = self.request_factory.get('/', {'books_authored__id__exact': '1'})
changelist = self.get_changelist(request, User, modeladmin) changelist = self.get_changelist(request, User, modeladmin)
# Make sure the correct choice is selected # Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][0] filterspec = changelist.get_filters(request)[0][0]
self.assertEquals(force_unicode(filterspec.title()), u'book') self.assertEqual(force_unicode(filterspec.title()), u'book')
choices = list(filterspec.choices(changelist)) choices = list(filterspec.choices(changelist))
self.assertEquals(choices[1]['selected'], True) self.assertEqual(choices[1]['selected'], True)
self.assertEquals(choices[1]['query_string'], '?books_authored__id__exact=1') self.assertEqual(choices[1]['query_string'], '?books_authored__id__exact=1')
# M2M relationship ----- # M2M relationship -----
request = self.request_factory.get('/', {'books_contributed__isnull': 'True'}) request = self.request_factory.get('/', {'books_contributed__isnull': 'True'})
@ -148,20 +148,20 @@ class FilterSpecsTests(TestCase):
# Make sure the last choice is None and is selected # Make sure the last choice is None and is selected
filterspec = changelist.get_filters(request)[0][1] filterspec = changelist.get_filters(request)[0][1]
self.assertEquals(force_unicode(filterspec.title()), u'book') self.assertEqual(force_unicode(filterspec.title()), u'book')
choices = list(filterspec.choices(changelist)) choices = list(filterspec.choices(changelist))
self.assertEquals(choices[-1]['selected'], True) self.assertEqual(choices[-1]['selected'], True)
self.assertEquals(choices[-1]['query_string'], '?books_contributed__isnull=True') self.assertEqual(choices[-1]['query_string'], '?books_contributed__isnull=True')
request = self.request_factory.get('/', {'books_contributed__id__exact': '2'}) request = self.request_factory.get('/', {'books_contributed__id__exact': '2'})
changelist = self.get_changelist(request, User, modeladmin) changelist = self.get_changelist(request, User, modeladmin)
# Make sure the correct choice is selected # Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][1] filterspec = changelist.get_filters(request)[0][1]
self.assertEquals(force_unicode(filterspec.title()), u'book') self.assertEqual(force_unicode(filterspec.title()), u'book')
choices = list(filterspec.choices(changelist)) choices = list(filterspec.choices(changelist))
self.assertEquals(choices[2]['selected'], True) self.assertEqual(choices[2]['selected'], True)
self.assertEquals(choices[2]['query_string'], '?books_contributed__id__exact=2') self.assertEqual(choices[2]['query_string'], '?books_contributed__id__exact=2')
class CustomUserAdmin(UserAdmin): class CustomUserAdmin(UserAdmin):
list_filter = ('books_authored', 'books_contributed') list_filter = ('books_authored', 'books_contributed')

4
tests/regressiontests/admin_scripts/tests.py
View File

@ -155,7 +155,7 @@ class AdminScriptTestCase(unittest.TestCase):
def assertNoOutput(self, stream): def assertNoOutput(self, stream):
"Utility assertion: assert that the given stream is empty" "Utility assertion: assert that the given stream is empty"
self.assertEquals(len(stream), 0, "Stream should be empty: actually contains '%s'" % stream) self.assertEqual(len(stream), 0, "Stream should be empty: actually contains '%s'" % stream)
def assertOutput(self, stream, msg): def assertOutput(self, stream, msg):
"Utility assertion: assert that the given message exists in the output" "Utility assertion: assert that the given message exists in the output"
self.assertTrue(msg in stream, "'%s' does not match actual output text '%s'" % (msg, stream)) self.assertTrue(msg in stream, "'%s' does not match actual output text '%s'" % (msg, stream))
@ -545,7 +545,7 @@ class DjangoAdminSettingsDirectory(AdminScriptTestCase):
args = ['startapp','settings_test'] args = ['startapp','settings_test']
out, err = self.run_django_admin(args,'settings') out, err = self.run_django_admin(args,'settings')
self.assertNoOutput(err) self.assertNoOutput(err)
self.assert_(os.path.exists(os.path.join(test_dir, 'settings_test'))) self.assertTrue(os.path.exists(os.path.join(test_dir, 'settings_test')))
shutil.rmtree(os.path.join(test_dir, 'settings_test')) shutil.rmtree(os.path.join(test_dir, 'settings_test'))
def test_builtin_command(self): def test_builtin_command(self):

34
tests/regressiontests/admin_util/tests.py
View File

@ -24,7 +24,7 @@ class NestedObjectsTests(TestCase):
self.objs = [Count.objects.create(num=i) for i in range(5)] self.objs = [Count.objects.create(num=i) for i in range(5)]
def _check(self, target): def _check(self, target):
self.assertEquals(self.n.nested(lambda obj: obj.num), target) self.assertEqual(self.n.nested(lambda obj: obj.num), target)
def _connect(self, i, j): def _connect(self, i, j):
self.objs[i].parent = self.objs[j] self.objs[i].parent = self.objs[j]
@ -146,24 +146,24 @@ class UtilTests(unittest.TestCase):
""" """
Tests for label_for_field Tests for label_for_field
""" """
self.assertEquals( self.assertEqual(
label_for_field("title", Article), label_for_field("title", Article),
"title" "title"
) )
self.assertEquals( self.assertEqual(
label_for_field("title2", Article), label_for_field("title2", Article),
"another name" "another name"
) )
self.assertEquals( self.assertEqual(
label_for_field("title2", Article, return_attr=True), label_for_field("title2", Article, return_attr=True),
("another name", None) ("another name", None)
) )
self.assertEquals( self.assertEqual(
label_for_field("__unicode__", Article), label_for_field("__unicode__", Article),
"article" "article"
) )
self.assertEquals( self.assertEqual(
label_for_field("__str__", Article), label_for_field("__str__", Article),
"article" "article"
) )
@ -175,29 +175,29 @@ class UtilTests(unittest.TestCase):
def test_callable(obj): def test_callable(obj):
return "nothing" return "nothing"
self.assertEquals( self.assertEqual(
label_for_field(test_callable, Article), label_for_field(test_callable, Article),
"Test callable" "Test callable"
) )
self.assertEquals( self.assertEqual(
label_for_field(test_callable, Article, return_attr=True), label_for_field(test_callable, Article, return_attr=True),
("Test callable", test_callable) ("Test callable", test_callable)
) )
self.assertEquals( self.assertEqual(
label_for_field("test_from_model", Article), label_for_field("test_from_model", Article),
"Test from model" "Test from model"
) )
self.assertEquals( self.assertEqual(
label_for_field("test_from_model", Article, return_attr=True), label_for_field("test_from_model", Article, return_attr=True),
("Test from model", Article.test_from_model) ("Test from model", Article.test_from_model)
) )
self.assertEquals( self.assertEqual(
label_for_field("test_from_model_with_override", Article), label_for_field("test_from_model_with_override", Article),
"not What you Expect" "not What you Expect"
) )
self.assertEquals( self.assertEqual(
label_for_field(lambda x: "nothing", Article), label_for_field(lambda x: "nothing", Article),
"--" "--"
) )
@ -207,11 +207,11 @@ class UtilTests(unittest.TestCase):
return "nothing" return "nothing"
test_from_model.short_description = "not Really the Model" test_from_model.short_description = "not Really the Model"
self.assertEquals( self.assertEqual(
label_for_field("test_from_model", Article, model_admin=MockModelAdmin), label_for_field("test_from_model", Article, model_admin=MockModelAdmin),
"not Really the Model" "not Really the Model"
) )
self.assertEquals( self.assertEqual(
label_for_field("test_from_model", Article, label_for_field("test_from_model", Article,
model_admin = MockModelAdmin, model_admin = MockModelAdmin,
return_attr = True return_attr = True
@ -223,15 +223,15 @@ class UtilTests(unittest.TestCase):
""" """
Regression test for #13963 Regression test for #13963
""" """
self.assertEquals( self.assertEqual(
label_for_field('location', Event, return_attr=True), label_for_field('location', Event, return_attr=True),
('location', None), ('location', None),
) )
self.assertEquals( self.assertEqual(
label_for_field('event', Location, return_attr=True), label_for_field('event', Location, return_attr=True),
('awesome event', None), ('awesome event', None),
) )
self.assertEquals( self.assertEqual(
label_for_field('guest', Event, return_attr=True), label_for_field('guest', Event, return_attr=True),
('awesome guest', None), ('awesome guest', None),
) )

62
tests/regressiontests/admin_views/tests.py
View File

@ -478,7 +478,7 @@ class SaveAsTests(TestCase):
initial model. initial model.
""" """
response = self.client.get('/test_admin/admin/admin_views/person/1/') response = self.client.get('/test_admin/admin/admin_views/person/1/')
self.assert_(response.context['save_as']) self.assertTrue(response.context['save_as'])
post_data = {'_saveasnew':'', 'name':'John M', 'gender':3, 'alive':'checked'} post_data = {'_saveasnew':'', 'name':'John M', 'gender':3, 'alive':'checked'}
response = self.client.post('/test_admin/admin/admin_views/person/1/', post_data) response = self.client.post('/test_admin/admin/admin_views/person/1/', post_data)
self.assertEqual(response.context['form_url'], '../add/') self.assertEqual(response.context['form_url'], '../add/')
@ -503,32 +503,32 @@ class CustomModelAdminTest(AdminViewBasicTest):
self.client.logout() self.client.logout()
request = self.client.get('/test_admin/admin2/') request = self.client.get('/test_admin/admin2/')
self.assertTemplateUsed(request, 'custom_admin/login.html') self.assertTemplateUsed(request, 'custom_admin/login.html')
self.assert_('Hello from a custom login template' in request.content) self.assertTrue('Hello from a custom login template' in request.content)
def testCustomAdminSiteLogoutTemplate(self): def testCustomAdminSiteLogoutTemplate(self):
request = self.client.get('/test_admin/admin2/logout/') request = self.client.get('/test_admin/admin2/logout/')
self.assertTemplateUsed(request, 'custom_admin/logout.html') self.assertTemplateUsed(request, 'custom_admin/logout.html')
self.assert_('Hello from a custom logout template' in request.content) self.assertTrue('Hello from a custom logout template' in request.content)
def testCustomAdminSiteIndexViewAndTemplate(self): def testCustomAdminSiteIndexViewAndTemplate(self):
request = self.client.get('/test_admin/admin2/') request = self.client.get('/test_admin/admin2/')
self.assertTemplateUsed(request, 'custom_admin/index.html') self.assertTemplateUsed(request, 'custom_admin/index.html')
self.assert_('Hello from a custom index template *bar*' in request.content) self.assertTrue('Hello from a custom index template *bar*' in request.content)
def testCustomAdminSitePasswordChangeTemplate(self): def testCustomAdminSitePasswordChangeTemplate(self):
request = self.client.get('/test_admin/admin2/password_change/') request = self.client.get('/test_admin/admin2/password_change/')
self.assertTemplateUsed(request, 'custom_admin/password_change_form.html') self.assertTemplateUsed(request, 'custom_admin/password_change_form.html')
self.assert_('Hello from a custom password change form template' in request.content) self.assertTrue('Hello from a custom password change form template' in request.content)
def testCustomAdminSitePasswordChangeDoneTemplate(self): def testCustomAdminSitePasswordChangeDoneTemplate(self):
request = self.client.get('/test_admin/admin2/password_change/done/') request = self.client.get('/test_admin/admin2/password_change/done/')
self.assertTemplateUsed(request, 'custom_admin/password_change_done.html') self.assertTemplateUsed(request, 'custom_admin/password_change_done.html')
self.assert_('Hello from a custom password change done template' in request.content) self.assertTrue('Hello from a custom password change done template' in request.content)
def testCustomAdminSiteView(self): def testCustomAdminSiteView(self):
self.client.login(username='super', password='secret') self.client.login(username='super', password='secret')
response = self.client.get('/test_admin/%s/my_view/' % self.urlbit) response = self.client.get('/test_admin/%s/my_view/' % self.urlbit)
self.assert_(response.content == "Django is a magical pony!", response.content) self.assertTrue(response.content == "Django is a magical pony!", response.content)
def get_perm(Model, perm): def get_perm(Model, perm):
"""Return the permission object, for the Model""" """Return the permission object, for the Model"""
@ -725,8 +725,8 @@ class AdminViewPermissionsTest(TestCase):
post = self.client.post('/test_admin/admin/admin_views/article/add/', add_dict) post = self.client.post('/test_admin/admin/admin_views/article/add/', add_dict)
self.assertRedirects(post, '/test_admin/admin/') self.assertRedirects(post, '/test_admin/admin/')
self.assertEqual(Article.objects.all().count(), 4) self.assertEqual(Article.objects.all().count(), 4)
self.assertEquals(len(mail.outbox), 1) self.assertEqual(len(mail.outbox), 1)
self.assertEquals(mail.outbox[0].subject, 'Greetings from a created object') self.assertEqual(mail.outbox[0].subject, 'Greetings from a created object')
self.client.get('/test_admin/admin/logout/') self.client.get('/test_admin/admin/logout/')
# Super can add too, but is redirected to the change list view # Super can add too, but is redirected to the change list view
@ -801,12 +801,12 @@ class AdminViewPermissionsTest(TestCase):
request = self.client.get('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/1/') request = self.client.get('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/1/')
self.assertEqual(request.status_code, 403) self.assertEqual(request.status_code, 403)
request = self.client.post('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/1/', {'name': 'changed'}) request = self.client.post('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/1/', {'name': 'changed'})
self.assertEquals(RowLevelChangePermissionModel.objects.get(id=1).name, 'odd id') self.assertEqual(RowLevelChangePermissionModel.objects.get(id=1).name, 'odd id')
self.assertEqual(request.status_code, 403) self.assertEqual(request.status_code, 403)
request = self.client.get('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/2/') request = self.client.get('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/2/')
self.assertEqual(request.status_code, 200) self.assertEqual(request.status_code, 200)
request = self.client.post('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/2/', {'name': 'changed'}) request = self.client.post('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/2/', {'name': 'changed'})
self.assertEquals(RowLevelChangePermissionModel.objects.get(id=2).name, 'changed') self.assertEqual(RowLevelChangePermissionModel.objects.get(id=2).name, 'changed')
self.assertRedirects(request, '/test_admin/admin/') self.assertRedirects(request, '/test_admin/admin/')
self.client.get('/test_admin/admin/logout/') self.client.get('/test_admin/admin/logout/')
for login_dict in [self.joepublic_login, self.no_username_login]: for login_dict in [self.joepublic_login, self.no_username_login]:
@ -815,14 +815,14 @@ class AdminViewPermissionsTest(TestCase):
self.assertEqual(request.status_code, 200) self.assertEqual(request.status_code, 200)
self.assertContains(request, 'login-form') self.assertContains(request, 'login-form')
request = self.client.post('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/1/', {'name': 'changed'}) request = self.client.post('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/1/', {'name': 'changed'})
self.assertEquals(RowLevelChangePermissionModel.objects.get(id=1).name, 'odd id') self.assertEqual(RowLevelChangePermissionModel.objects.get(id=1).name, 'odd id')
self.assertEqual(request.status_code, 200) self.assertEqual(request.status_code, 200)
self.assertContains(request, 'login-form') self.assertContains(request, 'login-form')
request = self.client.get('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/2/') request = self.client.get('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/2/')
self.assertEqual(request.status_code, 200) self.assertEqual(request.status_code, 200)
self.assertContains(request, 'login-form') self.assertContains(request, 'login-form')
request = self.client.post('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/2/', {'name': 'changed again'}) request = self.client.post('/test_admin/admin/admin_views/rowlevelchangepermissionmodel/2/', {'name': 'changed again'})
self.assertEquals(RowLevelChangePermissionModel.objects.get(id=2).name, 'changed') self.assertEqual(RowLevelChangePermissionModel.objects.get(id=2).name, 'changed')
self.assertEqual(request.status_code, 200) self.assertEqual(request.status_code, 200)
self.assertContains(request, 'login-form') self.assertContains(request, 'login-form')
self.client.get('/test_admin/admin/logout/') self.client.get('/test_admin/admin/logout/')
@ -856,7 +856,7 @@ class AdminViewPermissionsTest(TestCase):
# Test custom change list template with custom extra context # Test custom change list template with custom extra context
request = self.client.get('/test_admin/admin/admin_views/customarticle/') request = self.client.get('/test_admin/admin/admin_views/customarticle/')
self.assertEqual(request.status_code, 200) self.assertEqual(request.status_code, 200)
self.assert_("var hello = 'Hello!';" in request.content) self.assertTrue("var hello = 'Hello!';" in request.content)
self.assertTemplateUsed(request, 'custom_admin/change_list.html') self.assertTemplateUsed(request, 'custom_admin/change_list.html')
# Test custom add form template # Test custom add form template
@ -916,8 +916,8 @@ class AdminViewPermissionsTest(TestCase):
post = self.client.post('/test_admin/admin/admin_views/article/1/delete/', delete_dict) post = self.client.post('/test_admin/admin/admin_views/article/1/delete/', delete_dict)
self.assertRedirects(post, '/test_admin/admin/') self.assertRedirects(post, '/test_admin/admin/')
self.assertEqual(Article.objects.all().count(), 2) self.assertEqual(Article.objects.all().count(), 2)
self.assertEquals(len(mail.outbox), 1) self.assertEqual(len(mail.outbox), 1)
self.assertEquals(mail.outbox[0].subject, 'Greetings from a deleted object') self.assertEqual(mail.outbox[0].subject, 'Greetings from a deleted object')
article_ct = ContentType.objects.get_for_model(Article) article_ct = ContentType.objects.get_for_model(Article)
logged = LogEntry.objects.get(content_type=article_ct, action_flag=DELETION) logged = LogEntry.objects.get(content_type=article_ct, action_flag=DELETION)
self.assertEqual(logged.object_id, u'1') self.assertEqual(logged.object_id, u'1')
@ -1108,7 +1108,7 @@ class AdminViewStringPrimaryKeyTest(TestCase):
counted_presence_before = response.content.count(should_contain) counted_presence_before = response.content.count(should_contain)
response = self.client.get('/test_admin/admin/') response = self.client.get('/test_admin/admin/')
counted_presence_after = response.content.count(should_contain) counted_presence_after = response.content.count(should_contain)
self.assertEquals(counted_presence_before - 1, self.assertEqual(counted_presence_before - 1,
counted_presence_after) counted_presence_after)
def test_deleteconfirmation_link(self): def test_deleteconfirmation_link(self):
@ -1568,7 +1568,7 @@ class AdminViewListEditable(TestCase):
} }
response = self.client.post('/test_admin/admin/admin_views/person/', data) response = self.client.post('/test_admin/admin/admin_views/person/', data)
non_form_errors = response.context['cl'].formset.non_form_errors() non_form_errors = response.context['cl'].formset.non_form_errors()
self.assert_(isinstance(non_form_errors, ErrorList)) self.assertTrue(isinstance(non_form_errors, ErrorList))
self.assertEqual(str(non_form_errors), str(ErrorList(["Grace is not a Zombie"]))) self.assertEqual(str(non_form_errors), str(ErrorList(["Grace is not a Zombie"])))
def test_list_editable_ordering(self): def test_list_editable_ordering(self):
@ -1853,8 +1853,8 @@ class AdminActionsTest(TestCase):
'index': 0, 'index': 0,
} }
response = self.client.post('/test_admin/admin/admin_views/subscriber/', action_data) response = self.client.post('/test_admin/admin/admin_views/subscriber/', action_data)
self.assertEquals(len(mail.outbox), 1) self.assertEqual(len(mail.outbox), 1)
self.assertEquals(mail.outbox[0].subject, 'Greetings from a ModelAdmin action') self.assertEqual(mail.outbox[0].subject, 'Greetings from a ModelAdmin action')
def test_model_admin_default_delete_action(self): def test_model_admin_default_delete_action(self):
"Tests the default delete action defined as a ModelAdmin method" "Tests the default delete action defined as a ModelAdmin method"
@ -1927,8 +1927,8 @@ class AdminActionsTest(TestCase):
'index': 0, 'index': 0,
} }
response = self.client.post('/test_admin/admin/admin_views/externalsubscriber/', action_data) response = self.client.post('/test_admin/admin/admin_views/externalsubscriber/', action_data)
self.assertEquals(len(mail.outbox), 1) self.assertEqual(len(mail.outbox), 1)
self.assertEquals(mail.outbox[0].subject, 'Greetings from a function action') self.assertEqual(mail.outbox[0].subject, 'Greetings from a function action')
def test_custom_function_action_with_redirect(self): def test_custom_function_action_with_redirect(self):
"Tests a custom action defined in a function" "Tests a custom action defined in a function"
@ -1958,19 +1958,19 @@ class AdminActionsTest(TestCase):
def test_model_without_action(self): def test_model_without_action(self):
"Tests a ModelAdmin without any action" "Tests a ModelAdmin without any action"
response = self.client.get('/test_admin/admin/admin_views/oldsubscriber/') response = self.client.get('/test_admin/admin/admin_views/oldsubscriber/')
self.assertEquals(response.context["action_form"], None) self.assertEqual(response.context["action_form"], None)
self.assert_( self.assertTrue(
'<input type="checkbox" class="action-select"' not in response.content, '<input type="checkbox" class="action-select"' not in response.content,
"Found an unexpected action toggle checkboxbox in response" "Found an unexpected action toggle checkboxbox in response"
) )
self.assert_('action-checkbox-column' not in response.content, self.assertTrue('action-checkbox-column' not in response.content,
"Found unexpected action-checkbox-column class in response") "Found unexpected action-checkbox-column class in response")
def test_model_without_action_still_has_jquery(self): def test_model_without_action_still_has_jquery(self):
"Tests that a ModelAdmin without any actions still gets jQuery included in page" "Tests that a ModelAdmin without any actions still gets jQuery included in page"
response = self.client.get('/test_admin/admin/admin_views/oldsubscriber/') response = self.client.get('/test_admin/admin/admin_views/oldsubscriber/')
self.assertEquals(response.context["action_form"], None) self.assertEqual(response.context["action_form"], None)
self.assert_('jquery.min.js' in response.content, self.assertTrue('jquery.min.js' in response.content,
"jQuery missing from admin pages for model with no admin actions" "jQuery missing from admin pages for model with no admin actions"
) )
@ -1978,7 +1978,7 @@ class AdminActionsTest(TestCase):
"Tests that the checkbox column class is present in the response" "Tests that the checkbox column class is present in the response"
response = self.client.get('/test_admin/admin/admin_views/subscriber/') response = self.client.get('/test_admin/admin/admin_views/subscriber/')
self.assertNotEqual(response.context["action_form"], None) self.assertNotEqual(response.context["action_form"], None)
self.assert_('action-checkbox-column' in response.content, self.assertTrue('action-checkbox-column' in response.content,
"Expected an action-checkbox-column in response") "Expected an action-checkbox-column in response")
def test_multiple_actions_form(self): def test_multiple_actions_form(self):
@ -1995,8 +1995,8 @@ class AdminActionsTest(TestCase):
response = self.client.post('/test_admin/admin/admin_views/externalsubscriber/', action_data) response = self.client.post('/test_admin/admin/admin_views/externalsubscriber/', action_data)
# Send mail, don't delete. # Send mail, don't delete.
self.assertEquals(len(mail.outbox), 1) self.assertEqual(len(mail.outbox), 1)
self.assertEquals(mail.outbox[0].subject, 'Greetings from a function action') self.assertEqual(mail.outbox[0].subject, 'Greetings from a function action')
def test_user_message_on_none_selected(self): def test_user_message_on_none_selected(self):
""" """
@ -2039,7 +2039,7 @@ class AdminActionsTest(TestCase):
self.assertNotEquals(response.context["action_form"], None) self.assertNotEquals(response.context["action_form"], None)
response = self.client.get( response = self.client.get(
'/test_admin/admin/admin_views/subscriber/?%s' % IS_POPUP_VAR) '/test_admin/admin/admin_views/subscriber/?%s' % IS_POPUP_VAR)
self.assertEquals(response.context["action_form"], None) self.assertEqual(response.context["action_form"], None)
class TestCustomChangeList(TestCase): class TestCustomChangeList(TestCase):

6
tests/regressiontests/admin_widgets/tests.py
View File

@ -47,7 +47,7 @@ class AdminFormfieldForDBFieldTests(TestCase):
widget = ff.widget widget = ff.widget
# Check that we got a field of the right type # Check that we got a field of the right type
self.assert_( self.assertTrue(
isinstance(widget, widgetclass), isinstance(widget, widgetclass),
"Wrong widget for %s.%s: expected %s, got %s" % \ "Wrong widget for %s.%s: expected %s, got %s" % \
(model.__class__.__name__, fieldname, widgetclass, type(widget)) (model.__class__.__name__, fieldname, widgetclass, type(widget))
@ -127,8 +127,8 @@ class AdminFormfieldForDBFieldWithRequestTests(DjangoTestCase):
""" """
self.client.login(username="super", password="secret") self.client.login(username="super", password="secret")
response = self.client.get("/widget_admin/admin_widgets/cartire/add/") response = self.client.get("/widget_admin/admin_widgets/cartire/add/")
self.assert_("BMW M3" not in response.content) self.assertTrue("BMW M3" not in response.content)
self.assert_("Volkswagon Passat" in response.content) self.assertTrue("Volkswagon Passat" in response.content)
class AdminForeignKeyWidgetChangeList(DjangoTestCase): class AdminForeignKeyWidgetChangeList(DjangoTestCase):

18
tests/regressiontests/aggregation_regress/tests.py
View File

@ -480,21 +480,21 @@ class AggregationTests(TestCase):
# age is a field on Author, so it shouldn't be allowed as an aggregate. # age is a field on Author, so it shouldn't be allowed as an aggregate.
# But age isn't included in the ValuesQuerySet, so it is. # But age isn't included in the ValuesQuerySet, so it is.
results = Author.objects.values('name').annotate(age=Count('book_contact_set')).order_by('name') results = Author.objects.values('name').annotate(age=Count('book_contact_set')).order_by('name')
self.assertEquals(len(results), 9) self.assertEqual(len(results), 9)
self.assertEquals(results[0]['name'], u'Adrian Holovaty') self.assertEqual(results[0]['name'], u'Adrian Holovaty')
self.assertEquals(results[0]['age'], 1) self.assertEqual(results[0]['age'], 1)
# Same problem, but aggregating over m2m fields # Same problem, but aggregating over m2m fields
results = Author.objects.values('name').annotate(age=Avg('friends__age')).order_by('name') results = Author.objects.values('name').annotate(age=Avg('friends__age')).order_by('name')
self.assertEquals(len(results), 9) self.assertEqual(len(results), 9)
self.assertEquals(results[0]['name'], u'Adrian Holovaty') self.assertEqual(results[0]['name'], u'Adrian Holovaty')
self.assertEquals(results[0]['age'], 32.0) self.assertEqual(results[0]['age'], 32.0)
# Same problem, but colliding with an m2m field # Same problem, but colliding with an m2m field
results = Author.objects.values('name').annotate(friends=Count('friends')).order_by('name') results = Author.objects.values('name').annotate(friends=Count('friends')).order_by('name')
self.assertEquals(len(results), 9) self.assertEqual(len(results), 9)
self.assertEquals(results[0]['name'], u'Adrian Holovaty') self.assertEqual(results[0]['name'], u'Adrian Holovaty')
self.assertEquals(results[0]['friends'], 2) self.assertEqual(results[0]['friends'], 2)
def test_reverse_relation_name_conflict(self): def test_reverse_relation_name_conflict(self):
# Regression for #11256 - providing an aggregate name that conflicts with a reverse-related name on the model raises ValueError # Regression for #11256 - providing an aggregate name that conflicts with a reverse-related name on the model raises ValueError

2
tests/regressiontests/app_loading/tests.py
View File

@ -16,7 +16,7 @@ class InstalledAppsGlobbingTest(TestCase):
def test_globbing(self): def test_globbing(self):
settings = Settings('test_settings') settings = Settings('test_settings')
self.assertEquals(settings.INSTALLED_APPS, ['parent.app', 'parent.app1', 'parent.app_2']) self.assertEqual(settings.INSTALLED_APPS, ['parent.app', 'parent.app1', 'parent.app_2'])
def tearDown(self): def tearDown(self):
sys.path = self.OLD_SYS_PATH sys.path = self.OLD_SYS_PATH

2
tests/regressiontests/builtin_server/tests.py
View File

@ -41,7 +41,7 @@ class WSGIFileWrapperTests(TestCase):
err = StringIO() err = StringIO()
handler = FileWrapperHandler(None, StringIO(), err, env) handler = FileWrapperHandler(None, StringIO(), err, env)
handler.run(wsgi_app_file_wrapper) handler.run(wsgi_app_file_wrapper)
self.assert_(handler._used_sendfile) self.assertTrue(handler._used_sendfile)
def test_file_wrapper_no_sendfile(self): def test_file_wrapper_no_sendfile(self):
env = {'SERVER_PROTOCOL': 'HTTP/1.0'} env = {'SERVER_PROTOCOL': 'HTTP/1.0'}

84
tests/regressiontests/cache/tests.py vendored
View File

@ -767,8 +767,8 @@ class LocMemCacheTests(unittest.TestCase, BaseCacheTests):
other_cache = get_cache('django.core.cache.backends.locmem.LocMemCache', LOCATION='other') other_cache = get_cache('django.core.cache.backends.locmem.LocMemCache', LOCATION='other')
self.cache.set('value1', 42) self.cache.set('value1', 42)
self.assertEquals(mirror_cache.get('value1'), 42) self.assertEqual(mirror_cache.get('value1'), 42)
self.assertEquals(other_cache.get('value1'), None) self.assertEqual(other_cache.get('value1'), None)
# memcached backend isn't guaranteed to be available. # memcached backend isn't guaranteed to be available.
# To check the memcached backend, the test settings file will # To check the memcached backend, the test settings file will
@ -824,7 +824,7 @@ class FileBasedCacheTests(unittest.TestCase, BaseCacheTests):
key = self.cache.make_key("foo") key = self.cache.make_key("foo")
keyhash = md5_constructor(key).hexdigest() keyhash = md5_constructor(key).hexdigest()
keypath = os.path.join(self.dirname, keyhash[:2], keyhash[2:4], keyhash[4:]) keypath = os.path.join(self.dirname, keyhash[:2], keyhash[2:4], keyhash[4:])
self.assert_(os.path.exists(keypath)) self.assertTrue(os.path.exists(keypath))
def test_subdirectory_removal(self): def test_subdirectory_removal(self):
""" """
@ -834,12 +834,12 @@ class FileBasedCacheTests(unittest.TestCase, BaseCacheTests):
key = self.cache.make_key("foo") key = self.cache.make_key("foo")
keyhash = md5_constructor(key).hexdigest() keyhash = md5_constructor(key).hexdigest()
keypath = os.path.join(self.dirname, keyhash[:2], keyhash[2:4], keyhash[4:]) keypath = os.path.join(self.dirname, keyhash[:2], keyhash[2:4], keyhash[4:])
self.assert_(os.path.exists(keypath)) self.assertTrue(os.path.exists(keypath))
self.cache.delete("foo") self.cache.delete("foo")
self.assert_(not os.path.exists(keypath)) self.assertTrue(not os.path.exists(keypath))
self.assert_(not os.path.exists(os.path.dirname(keypath))) self.assertTrue(not os.path.exists(os.path.dirname(keypath)))
self.assert_(not os.path.exists(os.path.dirname(os.path.dirname(keypath)))) self.assertTrue(not os.path.exists(os.path.dirname(os.path.dirname(keypath))))
def test_cull(self): def test_cull(self):
self.perform_cull_test(50, 29) self.perform_cull_test(50, 29)
@ -1208,27 +1208,27 @@ class CacheMiddlewareTest(unittest.TestCase):
middleware = CacheMiddleware() middleware = CacheMiddleware()
# Now test object attributes against values defined in setUp above # Now test object attributes against values defined in setUp above
self.assertEquals(middleware.cache_timeout, 30) self.assertEqual(middleware.cache_timeout, 30)
self.assertEquals(middleware.key_prefix, 'middlewareprefix') self.assertEqual(middleware.key_prefix, 'middlewareprefix')
self.assertEquals(middleware.cache_alias, 'other') self.assertEqual(middleware.cache_alias, 'other')
self.assertEquals(middleware.cache_anonymous_only, False) self.assertEqual(middleware.cache_anonymous_only, False)
# If arguments are being passed in construction, it's being used as a decorator. # If arguments are being passed in construction, it's being used as a decorator.
# First, test with "defaults": # First, test with "defaults":
as_view_decorator = CacheMiddleware(cache_alias=None, key_prefix=None) as_view_decorator = CacheMiddleware(cache_alias=None, key_prefix=None)
self.assertEquals(as_view_decorator.cache_timeout, 300) # Timeout value for 'default' cache, i.e. 300 self.assertEqual(as_view_decorator.cache_timeout, 300) # Timeout value for 'default' cache, i.e. 300
self.assertEquals(as_view_decorator.key_prefix, '') self.assertEqual(as_view_decorator.key_prefix, '')
self.assertEquals(as_view_decorator.cache_alias, 'default') # Value of DEFAULT_CACHE_ALIAS from django.core.cache self.assertEqual(as_view_decorator.cache_alias, 'default') # Value of DEFAULT_CACHE_ALIAS from django.core.cache
self.assertEquals(as_view_decorator.cache_anonymous_only, False) self.assertEqual(as_view_decorator.cache_anonymous_only, False)
# Next, test with custom values: # Next, test with custom values:
as_view_decorator_with_custom = CacheMiddleware(cache_anonymous_only=True, cache_timeout=60, cache_alias='other', key_prefix='foo') as_view_decorator_with_custom = CacheMiddleware(cache_anonymous_only=True, cache_timeout=60, cache_alias='other', key_prefix='foo')
self.assertEquals(as_view_decorator_with_custom.cache_timeout, 60) self.assertEqual(as_view_decorator_with_custom.cache_timeout, 60)
self.assertEquals(as_view_decorator_with_custom.key_prefix, 'foo') self.assertEqual(as_view_decorator_with_custom.key_prefix, 'foo')
self.assertEquals(as_view_decorator_with_custom.cache_alias, 'other') self.assertEqual(as_view_decorator_with_custom.cache_alias, 'other')
self.assertEquals(as_view_decorator_with_custom.cache_anonymous_only, True) self.assertEqual(as_view_decorator_with_custom.cache_anonymous_only, True)
def test_middleware(self): def test_middleware(self):
middleware = CacheMiddleware() middleware = CacheMiddleware()
@ -1239,7 +1239,7 @@ class CacheMiddlewareTest(unittest.TestCase):
# Put the request through the request middleware # Put the request through the request middleware
result = middleware.process_request(request) result = middleware.process_request(request)
self.assertEquals(result, None) self.assertEqual(result, None)
response = hello_world_view(request, '1') response = hello_world_view(request, '1')
@ -1249,16 +1249,16 @@ class CacheMiddlewareTest(unittest.TestCase):
# Repeating the request should result in a cache hit # Repeating the request should result in a cache hit
result = middleware.process_request(request) result = middleware.process_request(request)
self.assertNotEquals(result, None) self.assertNotEquals(result, None)
self.assertEquals(result.content, 'Hello World 1') self.assertEqual(result.content, 'Hello World 1')
# The same request through a different middleware won't hit # The same request through a different middleware won't hit
result = prefix_middleware.process_request(request) result = prefix_middleware.process_request(request)
self.assertEquals(result, None) self.assertEqual(result, None)
# The same request with a timeout _will_ hit # The same request with a timeout _will_ hit
result = timeout_middleware.process_request(request) result = timeout_middleware.process_request(request)
self.assertNotEquals(result, None) self.assertNotEquals(result, None)
self.assertEquals(result.content, 'Hello World 1') self.assertEqual(result.content, 'Hello World 1')
def test_cache_middleware_anonymous_only_wont_cause_session_access(self): def test_cache_middleware_anonymous_only_wont_cause_session_access(self):
""" The cache middleware shouldn't cause a session access due to """ The cache middleware shouldn't cause a session access due to
@ -1279,7 +1279,7 @@ class CacheMiddlewareTest(unittest.TestCase):
session_middleware.process_request(request) session_middleware.process_request(request)
auth_middleware.process_request(request) auth_middleware.process_request(request)
result = middleware.process_request(request) result = middleware.process_request(request)
self.assertEquals(result, None) self.assertEqual(result, None)
response = hello_world_view(request, '1') response = hello_world_view(request, '1')
@ -1327,43 +1327,43 @@ class CacheMiddlewareTest(unittest.TestCase):
# Request the view once # Request the view once
response = default_view(request, '1') response = default_view(request, '1')
self.assertEquals(response.content, 'Hello World 1') self.assertEqual(response.content, 'Hello World 1')
# Request again -- hit the cache # Request again -- hit the cache
response = default_view(request, '2') response = default_view(request, '2')
self.assertEquals(response.content, 'Hello World 1') self.assertEqual(response.content, 'Hello World 1')
# Requesting the same view with the explicit cache should yield the same result # Requesting the same view with the explicit cache should yield the same result
response = explicit_default_view(request, '3') response = explicit_default_view(request, '3')
self.assertEquals(response.content, 'Hello World 1') self.assertEqual(response.content, 'Hello World 1')
# Requesting with a prefix will hit a different cache key # Requesting with a prefix will hit a different cache key
response = explicit_default_with_prefix_view(request, '4') response = explicit_default_with_prefix_view(request, '4')
self.assertEquals(response.content, 'Hello World 4') self.assertEqual(response.content, 'Hello World 4')
# Hitting the same view again gives a cache hit # Hitting the same view again gives a cache hit
response = explicit_default_with_prefix_view(request, '5') response = explicit_default_with_prefix_view(request, '5')
self.assertEquals(response.content, 'Hello World 4') self.assertEqual(response.content, 'Hello World 4')
# And going back to the implicit cache will hit the same cache # And going back to the implicit cache will hit the same cache
response = default_with_prefix_view(request, '6') response = default_with_prefix_view(request, '6')
self.assertEquals(response.content, 'Hello World 4') self.assertEqual(response.content, 'Hello World 4')
# Requesting from an alternate cache won't hit cache # Requesting from an alternate cache won't hit cache
response = other_view(request, '7') response = other_view(request, '7')
self.assertEquals(response.content, 'Hello World 7') self.assertEqual(response.content, 'Hello World 7')
# But a repeated hit will hit cache # But a repeated hit will hit cache
response = other_view(request, '8') response = other_view(request, '8')
self.assertEquals(response.content, 'Hello World 7') self.assertEqual(response.content, 'Hello World 7')
# And prefixing the alternate cache yields yet another cache entry # And prefixing the alternate cache yields yet another cache entry
response = other_with_prefix_view(request, '9') response = other_with_prefix_view(request, '9')
self.assertEquals(response.content, 'Hello World 9') self.assertEqual(response.content, 'Hello World 9')
# Request from the alternate cache with a new prefix and a custom timeout # Request from the alternate cache with a new prefix and a custom timeout
response = other_with_timeout_view(request, '10') response = other_with_timeout_view(request, '10')
self.assertEquals(response.content, 'Hello World 10') self.assertEqual(response.content, 'Hello World 10')
# But if we wait a couple of seconds... # But if we wait a couple of seconds...
time.sleep(2) time.sleep(2)
@ -1371,38 +1371,38 @@ class CacheMiddlewareTest(unittest.TestCase):
# ... the default cache will still hit # ... the default cache will still hit
cache = get_cache('default') cache = get_cache('default')
response = default_view(request, '11') response = default_view(request, '11')
self.assertEquals(response.content, 'Hello World 1') self.assertEqual(response.content, 'Hello World 1')
# ... the default cache with a prefix will still hit # ... the default cache with a prefix will still hit
response = default_with_prefix_view(request, '12') response = default_with_prefix_view(request, '12')
self.assertEquals(response.content, 'Hello World 4') self.assertEqual(response.content, 'Hello World 4')
# ... the explicit default cache will still hit # ... the explicit default cache will still hit
response = explicit_default_view(request, '13') response = explicit_default_view(request, '13')
self.assertEquals(response.content, 'Hello World 1') self.assertEqual(response.content, 'Hello World 1')
# ... the explicit default cache with a prefix will still hit # ... the explicit default cache with a prefix will still hit
response = explicit_default_with_prefix_view(request, '14') response = explicit_default_with_prefix_view(request, '14')
self.assertEquals(response.content, 'Hello World 4') self.assertEqual(response.content, 'Hello World 4')
# .. but a rapidly expiring cache won't hit # .. but a rapidly expiring cache won't hit
response = other_view(request, '15') response = other_view(request, '15')
self.assertEquals(response.content, 'Hello World 15') self.assertEqual(response.content, 'Hello World 15')
# .. even if it has a prefix # .. even if it has a prefix
response = other_with_prefix_view(request, '16') response = other_with_prefix_view(request, '16')
self.assertEquals(response.content, 'Hello World 16') self.assertEqual(response.content, 'Hello World 16')
# ... but a view with a custom timeout will still hit # ... but a view with a custom timeout will still hit
response = other_with_timeout_view(request, '17') response = other_with_timeout_view(request, '17')
self.assertEquals(response.content, 'Hello World 10') self.assertEqual(response.content, 'Hello World 10')
# And if we wait a few more seconds # And if we wait a few more seconds
time.sleep(2) time.sleep(2)
# the custom timeouot cache will miss # the custom timeouot cache will miss
response = other_with_timeout_view(request, '18') response = other_with_timeout_view(request, '18')
self.assertEquals(response.content, 'Hello World 18') self.assertEqual(response.content, 'Hello World 18')
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

6
tests/regressiontests/comment_tests/tests/comment_form_tests.py
View File

@ -20,7 +20,7 @@ class CommentFormTests(CommentTestCase):
def testValidPost(self): def testValidPost(self):
a = Article.objects.get(pk=1) a = Article.objects.get(pk=1)
f = CommentForm(a, data=self.getValidData(a)) f = CommentForm(a, data=self.getValidData(a))
self.assert_(f.is_valid(), f.errors) self.assertTrue(f.is_valid(), f.errors)
return f return f
def tamperWithForm(self, **kwargs): def tamperWithForm(self, **kwargs):
@ -65,12 +65,12 @@ class CommentFormTests(CommentTestCase):
def testSecurityErrors(self): def testSecurityErrors(self):
f = self.tamperWithForm(honeypot="I am a robot") f = self.tamperWithForm(honeypot="I am a robot")
self.assert_("honeypot" in f.security_errors()) self.assertTrue("honeypot" in f.security_errors())
def testGetCommentObject(self): def testGetCommentObject(self):
f = self.testValidPost() f = self.testValidPost()
c = f.get_comment_object() c = f.get_comment_object()
self.assert_(isinstance(c, Comment)) self.assertTrue(isinstance(c, Comment))
self.assertEqual(c.content_object, Article.objects.get(pk=1)) self.assertEqual(c.content_object, Article.objects.get(pk=1))
self.assertEqual(c.comment, "This is my comment") self.assertEqual(c.comment, "This is my comment")
c.save() c.save()

12
tests/regressiontests/comment_tests/tests/comment_utils_moderators_tests.py
View File

@ -65,29 +65,29 @@ class CommentUtilsModeratorTests(CommentTestCase):
def testEmailNotification(self): def testEmailNotification(self):
moderator.register(Entry, EntryModerator1) moderator.register(Entry, EntryModerator1)
self.createSomeComments() self.createSomeComments()
self.assertEquals(len(mail.outbox), 2) self.assertEqual(len(mail.outbox), 2)
def testCommentsEnabled(self): def testCommentsEnabled(self):
moderator.register(Entry, EntryModerator2) moderator.register(Entry, EntryModerator2)
self.createSomeComments() self.createSomeComments()
self.assertEquals(Comment.objects.all().count(), 1) self.assertEqual(Comment.objects.all().count(), 1)
def testAutoCloseField(self): def testAutoCloseField(self):
moderator.register(Entry, EntryModerator3) moderator.register(Entry, EntryModerator3)
self.createSomeComments() self.createSomeComments()
self.assertEquals(Comment.objects.all().count(), 0) self.assertEqual(Comment.objects.all().count(), 0)
def testAutoModerateField(self): def testAutoModerateField(self):
moderator.register(Entry, EntryModerator4) moderator.register(Entry, EntryModerator4)
c1, c2 = self.createSomeComments() c1, c2 = self.createSomeComments()
self.assertEquals(c2.is_public, False) self.assertEqual(c2.is_public, False)
def testAutoModerateFieldImmediate(self): def testAutoModerateFieldImmediate(self):
moderator.register(Entry, EntryModerator5) moderator.register(Entry, EntryModerator5)
c1, c2 = self.createSomeComments() c1, c2 = self.createSomeComments()
self.assertEquals(c2.is_public, False) self.assertEqual(c2.is_public, False)
def testAutoCloseFieldImmediate(self): def testAutoCloseFieldImmediate(self):
moderator.register(Entry, EntryModerator6) moderator.register(Entry, EntryModerator6)
c1, c2 = self.createSomeComments() c1, c2 = self.createSomeComments()
self.assertEquals(Comment.objects.all().count(), 0) self.assertEqual(Comment.objects.all().count(), 0)

6
tests/regressiontests/comment_tests/tests/comment_view_tests.py
View File

@ -155,7 +155,7 @@ class CommentViewTests(CommentTestCase):
# callback # callback
def receive(sender, **kwargs): def receive(sender, **kwargs):
self.assertEqual(kwargs['comment'].comment, "This is my comment") self.assertEqual(kwargs['comment'].comment, "This is my comment")
self.assert_('request' in kwargs) self.assertTrue('request' in kwargs)
received_signals.append(kwargs.get('signal')) received_signals.append(kwargs.get('signal'))
# Connect signals and keep track of handled ones # Connect signals and keep track of handled ones
@ -269,7 +269,7 @@ class CommentViewTests(CommentTestCase):
response = self.client.post("/post/", data) response = self.client.post("/post/", data)
location = response["Location"] location = response["Location"]
match = re.search(r"^http://testserver/somewhere/else/\?foo=bar&c=\d+#baz$", location) match = re.search(r"^http://testserver/somewhere/else/\?foo=bar&c=\d+#baz$", location)
self.failUnless(match != None, "Unexpected redirect location: %s" % location) self.assertTrue(match != None, "Unexpected redirect location: %s" % location)
# Without a query string # Without a query string
a = Article.objects.get(pk=1) a = Article.objects.get(pk=1)
@ -279,4 +279,4 @@ class CommentViewTests(CommentTestCase):
response = self.client.post("/post/", data) response = self.client.post("/post/", data)
location = response["Location"] location = response["Location"]
match = re.search(r"^http://testserver/somewhere/else/\?c=\d+#baz$", location) match = re.search(r"^http://testserver/somewhere/else/\?c=\d+#baz$", location)
self.failUnless(match != None, "Unexpected redirect location: %s" % location) self.assertTrue(match != None, "Unexpected redirect location: %s" % location)

4
tests/regressiontests/comment_tests/tests/feed_tests.py
View File

@ -11,8 +11,8 @@ class CommentFeedTests(CommentTestCase):
def test_feed(self): def test_feed(self):
response = self.client.get(self.feed_url) response = self.client.get(self.feed_url)
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertEquals(response['Content-Type'], 'application/rss+xml') self.assertEqual(response['Content-Type'], 'application/rss+xml')
self.assertContains(response, '<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0">') self.assertContains(response, '<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0">')
self.assertContains(response, '<title>example.com comments</title>') self.assertContains(response, '<title>example.com comments</title>')
self.assertContains(response, '<link>http://example.com/</link>') self.assertContains(response, '<link>http://example.com/</link>')

6
tests/regressiontests/comment_tests/tests/moderation_view_tests.py
View File

@ -182,14 +182,14 @@ class AdminActionsTests(CommentTestCase):
comments = self.createSomeComments() comments = self.createSomeComments()
self.client.login(username="normaluser", password="normaluser") self.client.login(username="normaluser", password="normaluser")
response = self.client.get("/admin/comments/comment/") response = self.client.get("/admin/comments/comment/")
self.assertEquals("approve_comments" in response.content, False) self.assertEqual("approve_comments" in response.content, False)
def testActionsModerator(self): def testActionsModerator(self):
comments = self.createSomeComments() comments = self.createSomeComments()
makeModerator("normaluser") makeModerator("normaluser")
self.client.login(username="normaluser", password="normaluser") self.client.login(username="normaluser", password="normaluser")
response = self.client.get("/admin/comments/comment/") response = self.client.get("/admin/comments/comment/")
self.assertEquals("approve_comments" in response.content, True) self.assertEqual("approve_comments" in response.content, True)
def testActionsDisabledDelete(self): def testActionsDisabledDelete(self):
"Tests a CommentAdmin where 'delete_selected' has been disabled." "Tests a CommentAdmin where 'delete_selected' has been disabled."
@ -197,7 +197,7 @@ class AdminActionsTests(CommentTestCase):
self.client.login(username="normaluser", password="normaluser") self.client.login(username="normaluser", password="normaluser")
response = self.client.get('/admin2/comments/comment/') response = self.client.get('/admin2/comments/comment/')
self.assertEqual(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assert_( self.assertTrue(
'<option value="delete_selected">' not in response.content, '<option value="delete_selected">' not in response.content,
"Found an unexpected delete_selected in response" "Found an unexpected delete_selected in response"
) )

10
tests/regressiontests/comment_tests/tests/templatetag_tests.py
View File

@ -20,7 +20,7 @@ class CommentTemplateTagTests(CommentTestCase):
t = "{% load comments %}" + (tag or "{% get_comment_form for comment_tests.article a.id as form %}") t = "{% load comments %}" + (tag or "{% get_comment_form for comment_tests.article a.id as form %}")
ctx, out = self.render(t, a=Article.objects.get(pk=1)) ctx, out = self.render(t, a=Article.objects.get(pk=1))
self.assertEqual(out, "") self.assertEqual(out, "")
self.assert_(isinstance(ctx["form"], CommentForm)) self.assertTrue(isinstance(ctx["form"], CommentForm))
def testGetCommentFormFromLiteral(self): def testGetCommentFormFromLiteral(self):
self.testGetCommentForm("{% get_comment_form for comment_tests.article 1 as form %}") self.testGetCommentForm("{% get_comment_form for comment_tests.article 1 as form %}")
@ -31,8 +31,8 @@ class CommentTemplateTagTests(CommentTestCase):
def testRenderCommentForm(self, tag=None): def testRenderCommentForm(self, tag=None):
t = "{% load comments %}" + (tag or "{% render_comment_form for comment_tests.article a.id %}") t = "{% load comments %}" + (tag or "{% render_comment_form for comment_tests.article a.id %}")
ctx, out = self.render(t, a=Article.objects.get(pk=1)) ctx, out = self.render(t, a=Article.objects.get(pk=1))
self.assert_(out.strip().startswith("<form action=")) self.assertTrue(out.strip().startswith("<form action="))
self.assert_(out.strip().endswith("</form>")) self.assertTrue(out.strip().endswith("</form>"))
def testRenderCommentFormFromLiteral(self): def testRenderCommentFormFromLiteral(self):
self.testRenderCommentForm("{% render_comment_form for comment_tests.article 1 %}") self.testRenderCommentForm("{% render_comment_form for comment_tests.article 1 %}")
@ -86,8 +86,8 @@ class CommentTemplateTagTests(CommentTestCase):
def testRenderCommentList(self, tag=None): def testRenderCommentList(self, tag=None):
t = "{% load comments %}" + (tag or "{% render_comment_list for comment_tests.article a.id %}") t = "{% load comments %}" + (tag or "{% render_comment_list for comment_tests.article a.id %}")
ctx, out = self.render(t, a=Article.objects.get(pk=1)) ctx, out = self.render(t, a=Article.objects.get(pk=1))
self.assert_(out.strip().startswith("<dl id=\"comments\">")) self.assertTrue(out.strip().startswith("<dl id=\"comments\">"))
self.assert_(out.strip().endswith("</dl>")) self.assertTrue(out.strip().endswith("</dl>"))
def testRenderCommentListFromLiteral(self): def testRenderCommentListFromLiteral(self):
self.testRenderCommentList("{% render_comment_list for comment_tests.article 1 %}") self.testRenderCommentList("{% render_comment_list for comment_tests.article 1 %}")

20
tests/regressiontests/conditional_processing/models.py
View File

@ -17,16 +17,16 @@ EXPIRED_ETAG = '7fae4cd4b0f81e7d2914700043aa8ed6'
class ConditionalGet(TestCase): class ConditionalGet(TestCase):
def assertFullResponse(self, response, check_last_modified=True, check_etag=True): def assertFullResponse(self, response, check_last_modified=True, check_etag=True):
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.assertEquals(response.content, FULL_RESPONSE) self.assertEqual(response.content, FULL_RESPONSE)
if check_last_modified: if check_last_modified:
self.assertEquals(response['Last-Modified'], LAST_MODIFIED_STR) self.assertEqual(response['Last-Modified'], LAST_MODIFIED_STR)
if check_etag: if check_etag:
self.assertEquals(response['ETag'], '"%s"' % ETAG) self.assertEqual(response['ETag'], '"%s"' % ETAG)
def assertNotModified(self, response): def assertNotModified(self, response):
self.assertEquals(response.status_code, 304) self.assertEqual(response.status_code, 304)
self.assertEquals(response.content, '') self.assertEqual(response.content, '')
def testWithoutConditions(self): def testWithoutConditions(self):
response = self.client.get('/condition/') response = self.client.get('/condition/')
@ -62,10 +62,10 @@ class ConditionalGet(TestCase):
def testIfMatch(self): def testIfMatch(self):
self.client.defaults['HTTP_IF_MATCH'] = '"%s"' % ETAG self.client.defaults['HTTP_IF_MATCH'] = '"%s"' % ETAG
response = self.client.put('/condition/etag/', {'data': ''}) response = self.client.put('/condition/etag/', {'data': ''})
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
self.client.defaults['HTTP_IF_MATCH'] = '"%s"' % EXPIRED_ETAG self.client.defaults['HTTP_IF_MATCH'] = '"%s"' % EXPIRED_ETAG
response = self.client.put('/condition/etag/', {'data': ''}) response = self.client.put('/condition/etag/', {'data': ''})
self.assertEquals(response.status_code, 412) self.assertEqual(response.status_code, 412)
def testBothHeaders(self): def testBothHeaders(self):
self.client.defaults['HTTP_IF_MODIFIED_SINCE'] = LAST_MODIFIED_STR self.client.defaults['HTTP_IF_MODIFIED_SINCE'] = LAST_MODIFIED_STR
@ -130,11 +130,11 @@ class ConditionalGet(TestCase):
class ETagProcessing(unittest.TestCase): class ETagProcessing(unittest.TestCase):
def testParsing(self): def testParsing(self):
etags = parse_etags(r'"", "etag", "e\"t\"ag", "e\\tag", W/"weak"') etags = parse_etags(r'"", "etag", "e\"t\"ag", "e\\tag", W/"weak"')
self.assertEquals(etags, ['', 'etag', 'e"t"ag', r'e\tag', 'weak']) self.assertEqual(etags, ['', 'etag', 'e"t"ag', r'e\tag', 'weak'])
def testQuoting(self): def testQuoting(self):
quoted_etag = quote_etag(r'e\t"ag') quoted_etag = quote_etag(r'e\t"ag')
self.assertEquals(quoted_etag, r'"e\\t\"ag"') self.assertEqual(quoted_etag, r'"e\\t\"ag"')
class HttpDateProcessing(unittest.TestCase): class HttpDateProcessing(unittest.TestCase):

26
tests/regressiontests/csrf_tests/tests.py
View File

@ -133,7 +133,7 @@ class CsrfMiddlewareTest(TestCase):
self.assertNotEqual(resp_content, resp2.content) self.assertNotEqual(resp_content, resp2.content)
self._check_token_present(resp2, csrf_cookie.value) self._check_token_present(resp2, csrf_cookie.value)
# Check the Vary header got patched correctly # Check the Vary header got patched correctly
self.assert_('Cookie' in resp2.get('Vary','')) self.assertTrue('Cookie' in resp2.get('Vary',''))
def test_process_response_for_exempt_view(self): def test_process_response_for_exempt_view(self):
""" """
@ -210,7 +210,7 @@ class CsrfMiddlewareTest(TestCase):
resp = post_form_response_non_html() resp = post_form_response_non_html()
resp_content = resp.content # needed because process_response modifies resp resp_content = resp.content # needed because process_response modifies resp
resp2 = CsrfMiddleware().process_response(req, resp) resp2 = CsrfMiddleware().process_response(req, resp)
self.assertEquals(resp_content, resp2.content) self.assertEqual(resp_content, resp2.content)
def test_process_response_exempt_view(self): def test_process_response_exempt_view(self):
""" """
@ -223,7 +223,7 @@ class CsrfMiddlewareTest(TestCase):
resp = view(req) resp = view(req)
resp_content = resp.content resp_content = resp.content
resp2 = CsrfMiddleware().process_response(req, resp) resp2 = CsrfMiddleware().process_response(req, resp)
self.assertEquals(resp_content, resp2.content) self.assertEqual(resp_content, resp2.content)
# Check the request processing # Check the request processing
def test_process_request_no_session_no_csrf_cookie(self): def test_process_request_no_session_no_csrf_cookie(self):
@ -233,7 +233,7 @@ class CsrfMiddlewareTest(TestCase):
""" """
req = self._get_POST_no_csrf_cookie_request() req = self._get_POST_no_csrf_cookie_request()
req2 = CsrfMiddleware().process_view(req, post_form_view, (), {}) req2 = CsrfMiddleware().process_view(req, post_form_view, (), {})
self.assertEquals(403, req2.status_code) self.assertEqual(403, req2.status_code)
def test_process_request_csrf_cookie_no_token(self): def test_process_request_csrf_cookie_no_token(self):
""" """
@ -242,7 +242,7 @@ class CsrfMiddlewareTest(TestCase):
""" """
req = self._get_POST_csrf_cookie_request() req = self._get_POST_csrf_cookie_request()
req2 = CsrfMiddleware().process_view(req, post_form_view, (), {}) req2 = CsrfMiddleware().process_view(req, post_form_view, (), {})
self.assertEquals(403, req2.status_code) self.assertEqual(403, req2.status_code)
def test_process_request_csrf_cookie_and_token(self): def test_process_request_csrf_cookie_and_token(self):
""" """
@ -250,7 +250,7 @@ class CsrfMiddlewareTest(TestCase):
""" """
req = self._get_POST_request_with_token() req = self._get_POST_request_with_token()
req2 = CsrfMiddleware().process_view(req, post_form_view, (), {}) req2 = CsrfMiddleware().process_view(req, post_form_view, (), {})
self.assertEquals(None, req2) self.assertEqual(None, req2)
def test_process_request_session_cookie_no_csrf_cookie_token(self): def test_process_request_session_cookie_no_csrf_cookie_token(self):
""" """
@ -262,7 +262,7 @@ class CsrfMiddlewareTest(TestCase):
try: try:
req = self._get_POST_session_request_with_token() req = self._get_POST_session_request_with_token()
req2 = CsrfMiddleware().process_view(req, post_form_view, (), {}) req2 = CsrfMiddleware().process_view(req, post_form_view, (), {})
self.assertEquals(None, req2) self.assertEqual(None, req2)
finally: finally:
settings.SECRET_KEY = orig_secret_key settings.SECRET_KEY = orig_secret_key
@ -273,7 +273,7 @@ class CsrfMiddlewareTest(TestCase):
""" """
req = self._get_POST_session_request_no_token() req = self._get_POST_session_request_no_token()
req2 = CsrfMiddleware().process_view(req, post_form_view, (), {}) req2 = CsrfMiddleware().process_view(req, post_form_view, (), {})
self.assertEquals(403, req2.status_code) self.assertEqual(403, req2.status_code)
def test_process_request_csrf_cookie_no_token_exempt_view(self): def test_process_request_csrf_cookie_no_token_exempt_view(self):
""" """
@ -282,7 +282,7 @@ class CsrfMiddlewareTest(TestCase):
""" """
req = self._get_POST_csrf_cookie_request() req = self._get_POST_csrf_cookie_request()
req2 = CsrfMiddleware().process_view(req, csrf_exempt(post_form_view), (), {}) req2 = CsrfMiddleware().process_view(req, csrf_exempt(post_form_view), (), {})
self.assertEquals(None, req2) self.assertEqual(None, req2)
def test_csrf_token_in_header(self): def test_csrf_token_in_header(self):
""" """
@ -291,7 +291,7 @@ class CsrfMiddlewareTest(TestCase):
req = self._get_POST_csrf_cookie_request() req = self._get_POST_csrf_cookie_request()
req.META['HTTP_X_CSRFTOKEN'] = self._csrf_id req.META['HTTP_X_CSRFTOKEN'] = self._csrf_id
req2 = CsrfMiddleware().process_view(req, post_form_view, (), {}) req2 = CsrfMiddleware().process_view(req, post_form_view, (), {})
self.assertEquals(None, req2) self.assertEqual(None, req2)
# Tests for the template tag method # Tests for the template tag method
def test_token_node_no_csrf_cookie(self): def test_token_node_no_csrf_cookie(self):
@ -300,7 +300,7 @@ class CsrfMiddlewareTest(TestCase):
""" """
req = self._get_GET_no_csrf_cookie_request() req = self._get_GET_no_csrf_cookie_request()
resp = token_view(req) resp = token_view(req)
self.assertEquals(u"", resp.content) self.assertEqual(u"", resp.content)
def test_token_node_empty_csrf_cookie(self): def test_token_node_empty_csrf_cookie(self):
""" """
@ -370,7 +370,7 @@ class CsrfMiddlewareTest(TestCase):
req.META['HTTP_REFERER'] = 'https://www.evil.org/somepage' req.META['HTTP_REFERER'] = 'https://www.evil.org/somepage'
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {}) req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertNotEqual(None, req2) self.assertNotEqual(None, req2)
self.assertEquals(403, req2.status_code) self.assertEqual(403, req2.status_code)
def test_https_good_referer(self): def test_https_good_referer(self):
""" """
@ -381,4 +381,4 @@ class CsrfMiddlewareTest(TestCase):
req.META['HTTP_HOST'] = 'www.example.com' req.META['HTTP_HOST'] = 'www.example.com'
req.META['HTTP_REFERER'] = 'https://www.example.com/somepage' req.META['HTTP_REFERER'] = 'https://www.example.com/somepage'
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {}) req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEquals(None, req2) self.assertEqual(None, req2)

6
tests/regressiontests/datatypes/tests.py
View File

@ -72,7 +72,7 @@ class DataTypesTestCase(TestCase):
database should be unicode.""" database should be unicode."""
d = Donut.objects.create(name=u'Jelly Donut', review=u'Outstanding') d = Donut.objects.create(name=u'Jelly Donut', review=u'Outstanding')
newd = Donut.objects.get(id=d.id) newd = Donut.objects.get(id=d.id)
self.assert_(isinstance(newd.review, unicode)) self.assertTrue(isinstance(newd.review, unicode))
@skipIfDBFeature('supports_timezones') @skipIfDBFeature('supports_timezones')
def test_error_on_timezone(self): def test_error_on_timezone(self):
@ -88,7 +88,7 @@ class DataTypesTestCase(TestCase):
a Python datetime.date, not a datetime.datetime""" a Python datetime.date, not a datetime.datetime"""
b = RumBaba.objects.create() b = RumBaba.objects.create()
# Verify we didn't break DateTimeField behavior # Verify we didn't break DateTimeField behavior
self.assert_(isinstance(b.baked_timestamp, datetime.datetime)) self.assertTrue(isinstance(b.baked_timestamp, datetime.datetime))
# We need to test this this way because datetime.datetime inherits # We need to test this this way because datetime.datetime inherits
# from datetime.date: # from datetime.date:
self.assert_(isinstance(b.baked_date, datetime.date) and not isinstance(b.baked_date, datetime.datetime)) self.assertTrue(isinstance(b.baked_date, datetime.date) and not isinstance(b.baked_date, datetime.datetime))

6
tests/regressiontests/decorators/tests.py
View File

@ -56,9 +56,9 @@ class DecoratorsTest(TestCase):
Tests that django decorators set certain attributes of the wrapped Tests that django decorators set certain attributes of the wrapped
function. function.
""" """
self.assertEquals(fully_decorated.__name__, 'fully_decorated') self.assertEqual(fully_decorated.__name__, 'fully_decorated')
self.assertEquals(fully_decorated.__doc__, 'Expected __doc__') self.assertEqual(fully_decorated.__doc__, 'Expected __doc__')
self.assertEquals(fully_decorated.__dict__['anything'], 'Expected __dict__') self.assertEqual(fully_decorated.__dict__['anything'], 'Expected __dict__')
def test_user_passes_test_composition(self): def test_user_passes_test_composition(self):
""" """

14
tests/regressiontests/delete_regress/tests.py
View File

@ -76,11 +76,11 @@ class DeleteCascadeTests(TestCase):
award = Award.objects.create(name='Nobel', content_object=person) award = Award.objects.create(name='Nobel', content_object=person)
note = AwardNote.objects.create(note='a peace prize', note = AwardNote.objects.create(note='a peace prize',
award=award) award=award)
self.assertEquals(AwardNote.objects.count(), 1) self.assertEqual(AwardNote.objects.count(), 1)
person.delete() person.delete()
self.assertEquals(Award.objects.count(), 0) self.assertEqual(Award.objects.count(), 0)
# first two asserts are just sanity checks, this is the kicker: # first two asserts are just sanity checks, this is the kicker:
self.assertEquals(AwardNote.objects.count(), 0) self.assertEqual(AwardNote.objects.count(), 0)
def test_fk_to_m2m_through(self): def test_fk_to_m2m_through(self):
""" """
@ -96,11 +96,11 @@ class DeleteCascadeTests(TestCase):
date=datetime.date.today()) date=datetime.date.today())
note = PlayedWithNote.objects.create(played=played, note = PlayedWithNote.objects.create(played=played,
note='the next Jackson Pollock') note='the next Jackson Pollock')
self.assertEquals(PlayedWithNote.objects.count(), 1) self.assertEqual(PlayedWithNote.objects.count(), 1)
paints.delete() paints.delete()
self.assertEquals(PlayedWith.objects.count(), 0) self.assertEqual(PlayedWith.objects.count(), 0)
# first two asserts just sanity checks, this is the kicker: # first two asserts just sanity checks, this is the kicker:
self.assertEquals(PlayedWithNote.objects.count(), 0) self.assertEqual(PlayedWithNote.objects.count(), 0)
class DeleteCascadeTransactionTests(TransactionTestCase): class DeleteCascadeTransactionTests(TransactionTestCase):
@ -136,4 +136,4 @@ class LargeDeleteTests(TestCase):
for x in range(300): for x in range(300):
track = Book.objects.create(pagecount=x+100) track = Book.objects.create(pagecount=x+100)
Book.objects.all().delete() Book.objects.all().delete()
self.assertEquals(Book.objects.count(), 0) self.assertEqual(Book.objects.count(), 0)

2
tests/regressiontests/dispatch/tests/test_dispatcher.py
View File

@ -99,7 +99,7 @@ class DispatcherTests(unittest.TestCase):
a_signal.connect(fails) a_signal.connect(fails)
result = a_signal.send_robust(sender=self, val="test") result = a_signal.send_robust(sender=self, val="test")
err = result[0][1] err = result[0][1]
self.assert_(isinstance(err, ValueError)) self.assertTrue(isinstance(err, ValueError))
self.assertEqual(err.args, ('this',)) self.assertEqual(err.args, ('this',))
a_signal.disconnect(fails) a_signal.disconnect(fails)
self._testIsClean(a_signal) self._testIsClean(a_signal)

12
tests/regressiontests/dispatch/tests/test_saferef.py
View File

@ -40,12 +40,12 @@ class Tester(unittest.TestCase):
def testIn(self): def testIn(self):
"""Test the "in" operator for safe references (cmp)""" """Test the "in" operator for safe references (cmp)"""
for t in self.ts[:50]: for t in self.ts[:50]:
self.assert_(safeRef(t.x) in self.ss) self.assertTrue(safeRef(t.x) in self.ss)
def testValid(self): def testValid(self):
"""Test that the references are valid (return instance methods)""" """Test that the references are valid (return instance methods)"""
for s in self.ss: for s in self.ss:
self.assert_(s()) self.assertTrue(s())
def testShortCircuit (self): def testShortCircuit (self):
"""Test that creation short-circuits to reuse existing references""" """Test that creation short-circuits to reuse existing references"""
@ -54,11 +54,11 @@ class Tester(unittest.TestCase):
sd[s] = 1 sd[s] = 1
for t in self.ts: for t in self.ts:
if hasattr(t, 'x'): if hasattr(t, 'x'):
self.assert_(sd.has_key(safeRef(t.x))) self.assertTrue(sd.has_key(safeRef(t.x)))
self.assert_(safeRef(t.x) in sd) self.assertTrue(safeRef(t.x) in sd)
else: else:
self.assert_(sd.has_key(safeRef(t))) self.assertTrue(sd.has_key(safeRef(t)))
self.assert_(safeRef(t) in sd) self.assertTrue(safeRef(t) in sd)
def testRepresentation (self): def testRepresentation (self):
"""Test that the reference object's representation works """Test that the reference object's representation works

24
tests/regressiontests/file_storage/tests.py
View File

@ -106,7 +106,7 @@ class FileStorageTests(unittest.TestCase):
f = self.storage.open('storage_test', 'w') f = self.storage.open('storage_test', 'w')
f.write('storage contents') f.write('storage contents')
f.close() f.close()
self.assert_(self.storage.exists('storage_test')) self.assertTrue(self.storage.exists('storage_test'))
f = self.storage.open('storage_test', 'r') f = self.storage.open('storage_test', 'r')
self.assertEqual(f.read(), 'storage contents') self.assertEqual(f.read(), 'storage contents')
@ -179,7 +179,7 @@ class FileStorageTests(unittest.TestCase):
self.assertEqual(storage_f_name, f.name) self.assertEqual(storage_f_name, f.name)
self.assert_(os.path.exists(os.path.join(self.temp_dir, f.name))) self.assertTrue(os.path.exists(os.path.join(self.temp_dir, f.name)))
self.storage.delete(storage_f_name) self.storage.delete(storage_f_name)
@ -229,7 +229,7 @@ class FileStorageTests(unittest.TestCase):
f = ContentFile('custom contents') f = ContentFile('custom contents')
f_name = self.storage.save('test.file', f) f_name = self.storage.save('test.file', f)
self.assert_(isinstance( self.assertTrue(isinstance(
self.storage.open('test.file', mixin=TestFileMixin), self.storage.open('test.file', mixin=TestFileMixin),
TestFileMixin TestFileMixin
)) ))
@ -325,8 +325,8 @@ class FileSaveRaceConditionTest(unittest.TestCase):
self.thread.start() self.thread.start()
name = self.save_file('conflict') name = self.save_file('conflict')
self.thread.join() self.thread.join()
self.assert_(self.storage.exists('conflict')) self.assertTrue(self.storage.exists('conflict'))
self.assert_(self.storage.exists('conflict_1')) self.assertTrue(self.storage.exists('conflict_1'))
self.storage.delete('conflict') self.storage.delete('conflict')
self.storage.delete('conflict_1') self.storage.delete('conflict_1')
@ -366,8 +366,8 @@ class FileStoragePathParsing(unittest.TestCase):
self.storage.save('dotted.path/test', ContentFile("2")) self.storage.save('dotted.path/test', ContentFile("2"))
self.assertFalse(os.path.exists(os.path.join(self.storage_dir, 'dotted_.path'))) self.assertFalse(os.path.exists(os.path.join(self.storage_dir, 'dotted_.path')))
self.assert_(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/test'))) self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/test')))
self.assert_(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/test_1'))) self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/test_1')))
def test_first_character_dot(self): def test_first_character_dot(self):
""" """
@ -377,13 +377,13 @@ class FileStoragePathParsing(unittest.TestCase):
self.storage.save('dotted.path/.test', ContentFile("1")) self.storage.save('dotted.path/.test', ContentFile("1"))
self.storage.save('dotted.path/.test', ContentFile("2")) self.storage.save('dotted.path/.test', ContentFile("2"))
self.assert_(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test'))) self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test')))
# Before 2.6, a leading dot was treated as an extension, and so # Before 2.6, a leading dot was treated as an extension, and so
# underscore gets added to beginning instead of end. # underscore gets added to beginning instead of end.
if sys.version_info < (2, 6): if sys.version_info < (2, 6):
self.assert_(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/_1.test'))) self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/_1.test')))
else: else:
self.assert_(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test_1'))) self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test_1')))
class DimensionClosingBug(unittest.TestCase): class DimensionClosingBug(unittest.TestCase):
""" """
@ -398,7 +398,7 @@ class DimensionClosingBug(unittest.TestCase):
try: try:
get_image_dimensions(empty_io) get_image_dimensions(empty_io)
finally: finally:
self.assert_(not empty_io.closed) self.assertTrue(not empty_io.closed)
@unittest.skipUnless(Image, "PIL not installed") @unittest.skipUnless(Image, "PIL not installed")
def test_closing_of_filenames(self): def test_closing_of_filenames(self):
@ -430,7 +430,7 @@ class DimensionClosingBug(unittest.TestCase):
get_image_dimensions(os.path.join(os.path.dirname(__file__), "test1.png")) get_image_dimensions(os.path.join(os.path.dirname(__file__), "test1.png"))
finally: finally:
del images.open del images.open
self.assert_(FileWrapper._closed) self.assertTrue(FileWrapper._closed)
class InconsistentGetImageDimensionsBug(unittest.TestCase): class InconsistentGetImageDimensionsBug(unittest.TestCase):
""" """

10
tests/regressiontests/file_uploads/tests.py
View File

@ -148,7 +148,7 @@ class FileUploadTests(TestCase):
'wsgi.input': client.FakePayload(payload), 'wsgi.input': client.FakePayload(payload),
} }
got = simplejson.loads(self.client.request(**r).content) got = simplejson.loads(self.client.request(**r).content)
self.assert_(len(got['file']) < 256, "Got a long file name (%s characters)." % len(got['file'])) self.assertTrue(len(got['file']) < 256, "Got a long file name (%s characters)." % len(got['file']))
def test_custom_upload_handler(self): def test_custom_upload_handler(self):
# A small file (under the 5M quota) # A small file (under the 5M quota)
@ -164,12 +164,12 @@ class FileUploadTests(TestCase):
# Small file posting should work. # Small file posting should work.
response = self.client.post('/file_uploads/quota/', {'f': smallfile}) response = self.client.post('/file_uploads/quota/', {'f': smallfile})
got = simplejson.loads(response.content) got = simplejson.loads(response.content)
self.assert_('f' in got) self.assertTrue('f' in got)
# Large files don't go through. # Large files don't go through.
response = self.client.post("/file_uploads/quota/", {'f': bigfile}) response = self.client.post("/file_uploads/quota/", {'f': bigfile})
got = simplejson.loads(response.content) got = simplejson.loads(response.content)
self.assert_('f' not in got) self.assertTrue('f' not in got)
def test_broken_custom_upload_handler(self): def test_broken_custom_upload_handler(self):
f = tempfile.NamedTemporaryFile() f = tempfile.NamedTemporaryFile()
@ -275,7 +275,7 @@ class DirectoryCreationTests(unittest.TestCase):
try: try:
self.obj.testfile.save('foo.txt', SimpleUploadedFile('foo.txt', 'x')) self.obj.testfile.save('foo.txt', SimpleUploadedFile('foo.txt', 'x'))
except OSError, err: except OSError, err:
self.assertEquals(err.errno, errno.EACCES) self.assertEqual(err.errno, errno.EACCES)
except Exception, err: except Exception, err:
self.fail("OSError [Errno %s] not raised." % errno.EACCES) self.fail("OSError [Errno %s] not raised." % errno.EACCES)
@ -289,7 +289,7 @@ class DirectoryCreationTests(unittest.TestCase):
except IOError, err: except IOError, err:
# The test needs to be done on a specific string as IOError # The test needs to be done on a specific string as IOError
# is raised even without the patch (just not early enough) # is raised even without the patch (just not early enough)
self.assertEquals(err.args[0], self.assertEqual(err.args[0],
"%s exists and is not a directory." % UPLOAD_TO) "%s exists and is not a directory." % UPLOAD_TO)
except: except:
self.fail("IOError not raised") self.fail("IOError not raised")

2
tests/regressiontests/forms/localflavor/fi.py
View File

@ -351,7 +351,7 @@ class FILocalFlavorTests(LocalFlavorTestCase):
<option value="ahtari">\xc4ht\xe4ri</option> <option value="ahtari">\xc4ht\xe4ri</option>
<option value="aanekoski">\xc4\xe4nekoski</option> <option value="aanekoski">\xc4\xe4nekoski</option>
</select>''' </select>'''
self.assertEquals(f.render('municipalities', 'turku'), out) self.assertEqual(f.render('municipalities', 'turku'), out)
def test_FIZipCodeField(self): def test_FIZipCodeField(self):
error_format = [u'Enter a zip code in the format XXXXX.'] error_format = [u'Enter a zip code in the format XXXXX.']

2
tests/regressiontests/forms/localflavor/us.py
View File

@ -68,7 +68,7 @@ class USLocalFlavorTests(LocalFlavorTestCase):
<option value="WI">Wisconsin</option> <option value="WI">Wisconsin</option>
<option value="WY">Wyoming</option> <option value="WY">Wyoming</option>
</select>''' </select>'''
self.assertEquals(f.render('state', 'IL'), out) self.assertEqual(f.render('state', 'IL'), out)
def test_USZipCodeField(self): def test_USZipCodeField(self):
error_format = [u'Enter a zip code in the format XXXXX or XXXXX-XXXX.'] error_format = [u'Enter a zip code in the format XXXXX or XXXXX-XXXX.']

8
tests/regressiontests/forms/tests/formsets.py
View File

@ -856,13 +856,13 @@ class TestIsBoundBehavior(TestCase):
'form-INITIAL_FORMS': u'0', 'form-INITIAL_FORMS': u'0',
} }
formset = ArticleFormSet(data) formset = ArticleFormSet(data)
self.assertEquals(0, formset.initial_form_count()) self.assertEqual(0, formset.initial_form_count())
self.assertEquals(1, formset.total_form_count()) self.assertEqual(1, formset.total_form_count())
self.assertTrue(formset.is_bound) self.assertTrue(formset.is_bound)
self.assertTrue(formset.forms[0].is_bound) self.assertTrue(formset.forms[0].is_bound)
self.assertTrue(formset.is_valid()) self.assertTrue(formset.is_valid())
self.assertTrue(formset.forms[0].is_valid()) self.assertTrue(formset.forms[0].is_valid())
self.assertEquals([{}], formset.cleaned_data) self.assertEqual([{}], formset.cleaned_data)
def test_form_errors_are_cought_by_formset(self): def test_form_errors_are_cought_by_formset(self):
@ -876,7 +876,7 @@ class TestIsBoundBehavior(TestCase):
} }
formset = ArticleFormSet(data) formset = ArticleFormSet(data)
self.assertFalse(formset.is_valid()) self.assertFalse(formset.is_valid())
self.assertEquals([{}, {'pub_date': [u'This field is required.']}], formset.errors) self.assertEqual([{}, {'pub_date': [u'This field is required.']}], formset.errors)
def test_empty_forms_are_unbound(self): def test_empty_forms_are_unbound(self):
data = { data = {

8
tests/regressiontests/forms/tests/models.py
View File

@ -33,15 +33,15 @@ class ModelFormCallableModelDefault(TestCase):
option = ChoiceOptionModel.objects.create(name='default') option = ChoiceOptionModel.objects.create(name='default')
choices = list(ChoiceFieldForm().fields['choice'].choices) choices = list(ChoiceFieldForm().fields['choice'].choices)
self.assertEquals(len(choices), 1) self.assertEqual(len(choices), 1)
self.assertEquals(choices[0], (option.pk, unicode(option))) self.assertEqual(choices[0], (option.pk, unicode(option)))
def test_callable_initial_value(self): def test_callable_initial_value(self):
"The initial value for a callable default returning a queryset is the pk (refs #13769)" "The initial value for a callable default returning a queryset is the pk (refs #13769)"
obj1 = ChoiceOptionModel.objects.create(id=1, name='default') obj1 = ChoiceOptionModel.objects.create(id=1, name='default')
obj2 = ChoiceOptionModel.objects.create(id=2, name='option 2') obj2 = ChoiceOptionModel.objects.create(id=2, name='option 2')
obj3 = ChoiceOptionModel.objects.create(id=3, name='option 3') obj3 = ChoiceOptionModel.objects.create(id=3, name='option 3')
self.assertEquals(ChoiceFieldForm().as_p(), """<p><label for="id_choice">Choice:</label> <select name="choice" id="id_choice"> self.assertEqual(ChoiceFieldForm().as_p(), """<p><label for="id_choice">Choice:</label> <select name="choice" id="id_choice">
<option value="1" selected="selected">ChoiceOption 1</option> <option value="1" selected="selected">ChoiceOption 1</option>
<option value="2">ChoiceOption 2</option> <option value="2">ChoiceOption 2</option>
<option value="3">ChoiceOption 3</option> <option value="3">ChoiceOption 3</option>
@ -67,7 +67,7 @@ class ModelFormCallableModelDefault(TestCase):
obj1 = ChoiceOptionModel.objects.create(id=1, name='default') obj1 = ChoiceOptionModel.objects.create(id=1, name='default')
obj2 = ChoiceOptionModel.objects.create(id=2, name='option 2') obj2 = ChoiceOptionModel.objects.create(id=2, name='option 2')
obj3 = ChoiceOptionModel.objects.create(id=3, name='option 3') obj3 = ChoiceOptionModel.objects.create(id=3, name='option 3')
self.assertEquals(ChoiceFieldForm(initial={ self.assertEqual(ChoiceFieldForm(initial={
'choice': obj2, 'choice': obj2,
'choice_int': obj2, 'choice_int': obj2,
'multi_choice': [obj2,obj3], 'multi_choice': [obj2,obj3],

22
tests/regressiontests/generic_inline_admin/tests.py
View File

@ -92,24 +92,24 @@ class GenericAdminViewTest(TestCase):
# Works with no queryset # Works with no queryset
formset = EpisodeMediaFormSet(instance=e) formset = EpisodeMediaFormSet(instance=e)
self.assertEquals(len(formset.forms), 5) self.assertEqual(len(formset.forms), 5)
self.assertEquals(formset.forms[0].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-0-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-0-url" type="text" name="generic_inline_admin-media-content_type-object_id-0-url" value="http://example.com/podcast.mp3" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-0-id" value="%s" id="id_generic_inline_admin-media-content_type-object_id-0-id" /></p>' % self.mp3_media_pk) self.assertEqual(formset.forms[0].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-0-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-0-url" type="text" name="generic_inline_admin-media-content_type-object_id-0-url" value="http://example.com/podcast.mp3" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-0-id" value="%s" id="id_generic_inline_admin-media-content_type-object_id-0-id" /></p>' % self.mp3_media_pk)
self.assertEquals(formset.forms[1].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-1-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-1-url" type="text" name="generic_inline_admin-media-content_type-object_id-1-url" value="http://example.com/logo.png" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-1-id" value="%s" id="id_generic_inline_admin-media-content_type-object_id-1-id" /></p>' % self.png_media_pk) self.assertEqual(formset.forms[1].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-1-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-1-url" type="text" name="generic_inline_admin-media-content_type-object_id-1-url" value="http://example.com/logo.png" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-1-id" value="%s" id="id_generic_inline_admin-media-content_type-object_id-1-id" /></p>' % self.png_media_pk)
self.assertEquals(formset.forms[2].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-2-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-2-url" type="text" name="generic_inline_admin-media-content_type-object_id-2-url" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-2-id" id="id_generic_inline_admin-media-content_type-object_id-2-id" /></p>') self.assertEqual(formset.forms[2].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-2-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-2-url" type="text" name="generic_inline_admin-media-content_type-object_id-2-url" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-2-id" id="id_generic_inline_admin-media-content_type-object_id-2-id" /></p>')
# A queryset can be used to alter display ordering # A queryset can be used to alter display ordering
formset = EpisodeMediaFormSet(instance=e, queryset=Media.objects.order_by('url')) formset = EpisodeMediaFormSet(instance=e, queryset=Media.objects.order_by('url'))
self.assertEquals(len(formset.forms), 5) self.assertEqual(len(formset.forms), 5)
self.assertEquals(formset.forms[0].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-0-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-0-url" type="text" name="generic_inline_admin-media-content_type-object_id-0-url" value="http://example.com/logo.png" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-0-id" value="%s" id="id_generic_inline_admin-media-content_type-object_id-0-id" /></p>' % self.png_media_pk) self.assertEqual(formset.forms[0].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-0-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-0-url" type="text" name="generic_inline_admin-media-content_type-object_id-0-url" value="http://example.com/logo.png" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-0-id" value="%s" id="id_generic_inline_admin-media-content_type-object_id-0-id" /></p>' % self.png_media_pk)
self.assertEquals(formset.forms[1].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-1-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-1-url" type="text" name="generic_inline_admin-media-content_type-object_id-1-url" value="http://example.com/podcast.mp3" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-1-id" value="%s" id="id_generic_inline_admin-media-content_type-object_id-1-id" /></p>' % self.mp3_media_pk) self.assertEqual(formset.forms[1].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-1-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-1-url" type="text" name="generic_inline_admin-media-content_type-object_id-1-url" value="http://example.com/podcast.mp3" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-1-id" value="%s" id="id_generic_inline_admin-media-content_type-object_id-1-id" /></p>' % self.mp3_media_pk)
self.assertEquals(formset.forms[2].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-2-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-2-url" type="text" name="generic_inline_admin-media-content_type-object_id-2-url" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-2-id" id="id_generic_inline_admin-media-content_type-object_id-2-id" /></p>') self.assertEqual(formset.forms[2].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-2-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-2-url" type="text" name="generic_inline_admin-media-content_type-object_id-2-url" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-2-id" id="id_generic_inline_admin-media-content_type-object_id-2-id" /></p>')
# Works with a queryset that omits items # Works with a queryset that omits items
formset = EpisodeMediaFormSet(instance=e, queryset=Media.objects.filter(url__endswith=".png")) formset = EpisodeMediaFormSet(instance=e, queryset=Media.objects.filter(url__endswith=".png"))
self.assertEquals(len(formset.forms), 4) self.assertEqual(len(formset.forms), 4)
self.assertEquals(formset.forms[0].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-0-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-0-url" type="text" name="generic_inline_admin-media-content_type-object_id-0-url" value="http://example.com/logo.png" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-0-id" value="%s" id="id_generic_inline_admin-media-content_type-object_id-0-id" /></p>' % self.png_media_pk) self.assertEqual(formset.forms[0].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-0-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-0-url" type="text" name="generic_inline_admin-media-content_type-object_id-0-url" value="http://example.com/logo.png" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-0-id" value="%s" id="id_generic_inline_admin-media-content_type-object_id-0-id" /></p>' % self.png_media_pk)
self.assertEquals(formset.forms[1].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-1-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-1-url" type="text" name="generic_inline_admin-media-content_type-object_id-1-url" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-1-id" id="id_generic_inline_admin-media-content_type-object_id-1-id" /></p>') self.assertEqual(formset.forms[1].as_p(), '<p><label for="id_generic_inline_admin-media-content_type-object_id-1-url">Url:</label> <input id="id_generic_inline_admin-media-content_type-object_id-1-url" type="text" name="generic_inline_admin-media-content_type-object_id-1-url" maxlength="200" /><input type="hidden" name="generic_inline_admin-media-content_type-object_id-1-id" id="id_generic_inline_admin-media-content_type-object_id-1-id" /></p>')
def testGenericInlineFormsetFactory(self): def testGenericInlineFormsetFactory(self):
# Regression test for #10522. # Regression test for #10522.

22
tests/regressiontests/generic_views/base.py
View File

@ -232,32 +232,32 @@ class RedirectViewTest(unittest.TestCase):
def test_no_url(self): def test_no_url(self):
"Without any configuration, returns HTTP 410 GONE" "Without any configuration, returns HTTP 410 GONE"
response = RedirectView.as_view()(self.rf.get('/foo/')) response = RedirectView.as_view()(self.rf.get('/foo/'))
self.assertEquals(response.status_code, 410) self.assertEqual(response.status_code, 410)
def test_permanaent_redirect(self): def test_permanaent_redirect(self):
"Default is a permanent redirect" "Default is a permanent redirect"
response = RedirectView.as_view(url='/bar/')(self.rf.get('/foo/')) response = RedirectView.as_view(url='/bar/')(self.rf.get('/foo/'))
self.assertEquals(response.status_code, 301) self.assertEqual(response.status_code, 301)
self.assertEquals(response['Location'], '/bar/') self.assertEqual(response['Location'], '/bar/')
def test_temporary_redirect(self): def test_temporary_redirect(self):
"Permanent redirects are an option" "Permanent redirects are an option"
response = RedirectView.as_view(url='/bar/', permanent=False)(self.rf.get('/foo/')) response = RedirectView.as_view(url='/bar/', permanent=False)(self.rf.get('/foo/'))
self.assertEquals(response.status_code, 302) self.assertEqual(response.status_code, 302)
self.assertEquals(response['Location'], '/bar/') self.assertEqual(response['Location'], '/bar/')
def test_include_args(self): def test_include_args(self):
"GET arguments can be included in the redirected URL" "GET arguments can be included in the redirected URL"
response = RedirectView.as_view(url='/bar/')(self.rf.get('/foo/')) response = RedirectView.as_view(url='/bar/')(self.rf.get('/foo/'))
self.assertEquals(response.status_code, 301) self.assertEqual(response.status_code, 301)
self.assertEquals(response['Location'], '/bar/') self.assertEqual(response['Location'], '/bar/')
response = RedirectView.as_view(url='/bar/', query_string=True)(self.rf.get('/foo/?pork=spam')) response = RedirectView.as_view(url='/bar/', query_string=True)(self.rf.get('/foo/?pork=spam'))
self.assertEquals(response.status_code, 301) self.assertEqual(response.status_code, 301)
self.assertEquals(response['Location'], '/bar/?pork=spam') self.assertEqual(response['Location'], '/bar/?pork=spam')
def test_parameter_substitution(self): def test_parameter_substitution(self):
"Redirection URLs can be parameterized" "Redirection URLs can be parameterized"
response = RedirectView.as_view(url='/bar/%(object_id)d/')(self.rf.get('/foo/42/'), object_id=42) response = RedirectView.as_view(url='/bar/%(object_id)d/')(self.rf.get('/foo/42/'), object_id=42)
self.assertEquals(response.status_code, 301) self.assertEqual(response.status_code, 301)
self.assertEquals(response['Location'], '/bar/42/') self.assertEqual(response['Location'], '/bar/42/')

4
tests/regressiontests/httpwrappers/tests.py
View File

@ -253,8 +253,8 @@ class CookieTests(unittest.TestCase):
# That's not the bug this test is looking for, so ignore it. # That's not the bug this test is looking for, so ignore it.
c = SimpleCookie() c = SimpleCookie()
c['test'] = "An,awkward;value" c['test'] = "An,awkward;value"
self.assert_(";" not in c.output().rstrip(';')) # IE compat self.assertTrue(";" not in c.output().rstrip(';')) # IE compat
self.assert_("," not in c.output().rstrip(';')) # Safari compat self.assertTrue("," not in c.output().rstrip(';')) # Safari compat
def test_decode(self): def test_decode(self):
""" """

34
tests/regressiontests/i18n/commands/extraction.py
View File

@ -30,12 +30,12 @@ class ExtractorTests(TestCase):
def assertMsgId(self, msgid, s, use_quotes=True): def assertMsgId(self, msgid, s, use_quotes=True):
if use_quotes: if use_quotes:
msgid = '"%s"' % msgid msgid = '"%s"' % msgid
return self.assert_(re.search('^msgid %s' % msgid, s, re.MULTILINE)) return self.assertTrue(re.search('^msgid %s' % msgid, s, re.MULTILINE))
def assertNotMsgId(self, msgid, s, use_quotes=True): def assertNotMsgId(self, msgid, s, use_quotes=True):
if use_quotes: if use_quotes:
msgid = '"%s"' % msgid msgid = '"%s"' % msgid
return self.assert_(not re.search('^msgid %s' % msgid, s, re.MULTILINE)) return self.assertTrue(not re.search('^msgid %s' % msgid, s, re.MULTILINE))
class BasicExtractorTests(ExtractorTests): class BasicExtractorTests(ExtractorTests):
@ -43,18 +43,18 @@ class BasicExtractorTests(ExtractorTests):
def test_comments_extractor(self): def test_comments_extractor(self):
os.chdir(self.test_dir) os.chdir(self.test_dir)
management.call_command('makemessages', locale=LOCALE, verbosity=0) management.call_command('makemessages', locale=LOCALE, verbosity=0)
self.assert_(os.path.exists(self.PO_FILE)) self.assertTrue(os.path.exists(self.PO_FILE))
po_contents = open(self.PO_FILE, 'r').read() po_contents = open(self.PO_FILE, 'r').read()
self.assert_('#. Translators: This comment should be extracted' in po_contents) self.assertTrue('#. Translators: This comment should be extracted' in po_contents)
self.assert_('This comment should not be extracted' not in po_contents) self.assertTrue('This comment should not be extracted' not in po_contents)
# Comments in templates # Comments in templates
self.assert_('#. Translators: Django template comment for translators' in po_contents) self.assertTrue('#. Translators: Django template comment for translators' in po_contents)
self.assert_('#. Translators: Django comment block for translators' in po_contents) self.assertTrue('#. Translators: Django comment block for translators' in po_contents)
def test_templatize(self): def test_templatize(self):
os.chdir(self.test_dir) os.chdir(self.test_dir)
management.call_command('makemessages', locale=LOCALE, verbosity=0) management.call_command('makemessages', locale=LOCALE, verbosity=0)
self.assert_(os.path.exists(self.PO_FILE)) self.assertTrue(os.path.exists(self.PO_FILE))
po_contents = open(self.PO_FILE, 'r').read() po_contents = open(self.PO_FILE, 'r').read()
self.assertMsgId('I think that 100%% is more that 50%% of anything.', po_contents) self.assertMsgId('I think that 100%% is more that 50%% of anything.', po_contents)
self.assertMsgId('I think that 100%% is more that 50%% of %\(obj\)s.', po_contents) self.assertMsgId('I think that 100%% is more that 50%% of %\(obj\)s.', po_contents)
@ -80,7 +80,7 @@ class JavascriptExtractorTests(ExtractorTests):
def test_javascript_literals(self): def test_javascript_literals(self):
os.chdir(self.test_dir) os.chdir(self.test_dir)
management.call_command('makemessages', domain='djangojs', locale=LOCALE, verbosity=0) management.call_command('makemessages', domain='djangojs', locale=LOCALE, verbosity=0)
self.assert_(os.path.exists(self.PO_FILE)) self.assertTrue(os.path.exists(self.PO_FILE))
po_contents = open(self.PO_FILE, 'r').read() po_contents = open(self.PO_FILE, 'r').read()
self.assertMsgId('This literal should be included.', po_contents) self.assertMsgId('This literal should be included.', po_contents)
self.assertMsgId('This one as well.', po_contents) self.assertMsgId('This one as well.', po_contents)
@ -91,7 +91,7 @@ class IgnoredExtractorTests(ExtractorTests):
def test_ignore_option(self): def test_ignore_option(self):
os.chdir(self.test_dir) os.chdir(self.test_dir)
management.call_command('makemessages', locale=LOCALE, verbosity=0, ignore_patterns=['ignore_dir/*']) management.call_command('makemessages', locale=LOCALE, verbosity=0, ignore_patterns=['ignore_dir/*'])
self.assert_(os.path.exists(self.PO_FILE)) self.assertTrue(os.path.exists(self.PO_FILE))
po_contents = open(self.PO_FILE, 'r').read() po_contents = open(self.PO_FILE, 'r').read()
self.assertMsgId('This literal should be included.', po_contents) self.assertMsgId('This literal should be included.', po_contents)
self.assertNotMsgId('This should be ignored.', po_contents) self.assertNotMsgId('This should be ignored.', po_contents)
@ -116,15 +116,15 @@ class SymlinkExtractorTests(ExtractorTests):
def test_symlink(self): def test_symlink(self):
if hasattr(os, 'symlink'): if hasattr(os, 'symlink'):
if os.path.exists(self.symlinked_dir): if os.path.exists(self.symlinked_dir):
self.assert_(os.path.islink(self.symlinked_dir)) self.assertTrue(os.path.islink(self.symlinked_dir))
else: else:
os.symlink(os.path.join(self.test_dir, 'templates'), self.symlinked_dir) os.symlink(os.path.join(self.test_dir, 'templates'), self.symlinked_dir)
os.chdir(self.test_dir) os.chdir(self.test_dir)
management.call_command('makemessages', locale=LOCALE, verbosity=0, symlinks=True) management.call_command('makemessages', locale=LOCALE, verbosity=0, symlinks=True)
self.assert_(os.path.exists(self.PO_FILE)) self.assertTrue(os.path.exists(self.PO_FILE))
po_contents = open(self.PO_FILE, 'r').read() po_contents = open(self.PO_FILE, 'r').read()
self.assertMsgId('This literal should be included.', po_contents) self.assertMsgId('This literal should be included.', po_contents)
self.assert_('templates_symlinked/test.html' in po_contents) self.assertTrue('templates_symlinked/test.html' in po_contents)
class CopyPluralFormsExtractorTests(ExtractorTests): class CopyPluralFormsExtractorTests(ExtractorTests):
@ -132,9 +132,9 @@ class CopyPluralFormsExtractorTests(ExtractorTests):
def test_copy_plural_forms(self): def test_copy_plural_forms(self):
os.chdir(self.test_dir) os.chdir(self.test_dir)
management.call_command('makemessages', locale=LOCALE, verbosity=0) management.call_command('makemessages', locale=LOCALE, verbosity=0)
self.assert_(os.path.exists(self.PO_FILE)) self.assertTrue(os.path.exists(self.PO_FILE))
po_contents = open(self.PO_FILE, 'r').read() po_contents = open(self.PO_FILE, 'r').read()
self.assert_('Plural-Forms: nplurals=2; plural=(n != 1)' in po_contents) self.assertTrue('Plural-Forms: nplurals=2; plural=(n != 1)' in po_contents)
class NoWrapExtractorTests(ExtractorTests): class NoWrapExtractorTests(ExtractorTests):
@ -142,13 +142,13 @@ class NoWrapExtractorTests(ExtractorTests):
def test_no_wrap_enabled(self): def test_no_wrap_enabled(self):
os.chdir(self.test_dir) os.chdir(self.test_dir)
management.call_command('makemessages', locale=LOCALE, verbosity=0, no_wrap=True) management.call_command('makemessages', locale=LOCALE, verbosity=0, no_wrap=True)
self.assert_(os.path.exists(self.PO_FILE)) self.assertTrue(os.path.exists(self.PO_FILE))
po_contents = open(self.PO_FILE, 'r').read() po_contents = open(self.PO_FILE, 'r').read()
self.assertMsgId('This literal should also be included wrapped or not wrapped depending on the use of the --no-wrap option.', po_contents) self.assertMsgId('This literal should also be included wrapped or not wrapped depending on the use of the --no-wrap option.', po_contents)
def test_no_wrap_disabled(self): def test_no_wrap_disabled(self):
os.chdir(self.test_dir) os.chdir(self.test_dir)
management.call_command('makemessages', locale=LOCALE, verbosity=0, no_wrap=False) management.call_command('makemessages', locale=LOCALE, verbosity=0, no_wrap=False)
self.assert_(os.path.exists(self.PO_FILE)) self.assertTrue(os.path.exists(self.PO_FILE))
po_contents = open(self.PO_FILE, 'r').read() po_contents = open(self.PO_FILE, 'r').read()
self.assertMsgId('""\n"This literal should also be included wrapped or not wrapped depending on the "\n"use of the --no-wrap option."', po_contents, use_quotes=False) self.assertMsgId('""\n"This literal should also be included wrapped or not wrapped depending on the "\n"use of the --no-wrap option."', po_contents, use_quotes=False)

2
tests/regressiontests/i18n/tests.py
View File

@ -460,7 +460,7 @@ class FormattingTests(TestCase):
self.assertEqual(datetime.datetime(2009, 12, 31, 6, 0, 0), form6.cleaned_data['date_added']) self.assertEqual(datetime.datetime(2009, 12, 31, 6, 0, 0), form6.cleaned_data['date_added'])
settings.USE_THOUSAND_SEPARATOR = True settings.USE_THOUSAND_SEPARATOR = True
# Checking for the localized "products_delivered" field # Checking for the localized "products_delivered" field
self.assert_(u'<input type="text" name="products_delivered" value="12.000" id="id_products_delivered" />' in form6.as_ul()) self.assertTrue(u'<input type="text" name="products_delivered" value="12.000" id="id_products_delivered" />' in form6.as_ul())
finally: finally:
deactivate() deactivate()

8
tests/regressiontests/introspection/tests.py
View File

@ -38,9 +38,9 @@ class IntrospectionTests(TestCase):
def test_table_names(self): def test_table_names(self):
tl = connection.introspection.table_names() tl = connection.introspection.table_names()
self.assert_(Reporter._meta.db_table in tl, self.assertTrue(Reporter._meta.db_table in tl,
"'%s' isn't in table_list()." % Reporter._meta.db_table) "'%s' isn't in table_list()." % Reporter._meta.db_table)
self.assert_(Article._meta.db_table in tl, self.assertTrue(Article._meta.db_table in tl,
"'%s' isn't in table_list()." % Article._meta.db_table) "'%s' isn't in table_list()." % Article._meta.db_table)
def test_django_table_names(self): def test_django_table_names(self):
@ -48,7 +48,7 @@ class IntrospectionTests(TestCase):
cursor.execute('CREATE TABLE django_ixn_test_table (id INTEGER);'); cursor.execute('CREATE TABLE django_ixn_test_table (id INTEGER);');
tl = connection.introspection.django_table_names() tl = connection.introspection.django_table_names()
cursor.execute("DROP TABLE django_ixn_test_table;") cursor.execute("DROP TABLE django_ixn_test_table;")
self.assert_('django_ixn_testcase_table' not in tl, self.assertTrue('django_ixn_testcase_table' not in tl,
"django_table_names() returned a non-Django table") "django_table_names() returned a non-Django table")
def test_installed_models(self): def test_installed_models(self):
@ -59,7 +59,7 @@ class IntrospectionTests(TestCase):
def test_sequence_list(self): def test_sequence_list(self):
sequences = connection.introspection.sequence_list() sequences = connection.introspection.sequence_list()
expected = {'table': Reporter._meta.db_table, 'column': 'id'} expected = {'table': Reporter._meta.db_table, 'column': 'id'}
self.assert_(expected in sequences, self.assertTrue(expected in sequences,
'Reporter sequence not found in sequence_list()') 'Reporter sequence not found in sequence_list()')
def test_get_table_description_names(self): def test_get_table_description_names(self):

2
tests/regressiontests/mail/tests.py
View File

@ -332,7 +332,7 @@ class BaseEmailBackendTests(object):
num_sent = mail.get_connection().send_messages([email1, email2]) num_sent = mail.get_connection().send_messages([email1, email2])
self.assertEqual(num_sent, 2) self.assertEqual(num_sent, 2)
messages = self.get_mailbox_content() messages = self.get_mailbox_content()
self.assertEquals(len(messages), 2) self.assertEqual(len(messages), 2)
self.assertEqual(messages[0].get_payload(), "Content1") self.assertEqual(messages[0].get_payload(), "Content1")
self.assertEqual(messages[1].get_payload(), "Content2") self.assertEqual(messages[1].get_payload(), "Content2")

2
tests/regressiontests/max_lengths/tests.py
View File

@ -5,7 +5,7 @@ from regressiontests.max_lengths.models import PersonWithDefaultMaxLengths, Pers
class MaxLengthArgumentsTests(unittest.TestCase): class MaxLengthArgumentsTests(unittest.TestCase):
def verify_max_length(self, model,field,length): def verify_max_length(self, model,field,length):
self.assertEquals(model._meta.get_field(field).max_length,length) self.assertEqual(model._meta.get_field(field).max_length,length)
def test_default_max_lengths(self): def test_default_max_lengths(self):
self.verify_max_length(PersonWithDefaultMaxLengths, 'email', 75) self.verify_max_length(PersonWithDefaultMaxLengths, 'email', 75)

74
tests/regressiontests/middleware/tests.py
View File

@ -31,7 +31,7 @@ class CommonMiddlewareTest(TestCase):
""" """
settings.APPEND_SLASH = True settings.APPEND_SLASH = True
request = self._get_request('slash/') request = self._get_request('slash/')
self.assertEquals(CommonMiddleware().process_request(request), None) self.assertEqual(CommonMiddleware().process_request(request), None)
def test_append_slash_slashless_resource(self): def test_append_slash_slashless_resource(self):
""" """
@ -39,7 +39,7 @@ class CommonMiddlewareTest(TestCase):
""" """
settings.APPEND_SLASH = True settings.APPEND_SLASH = True
request = self._get_request('noslash') request = self._get_request('noslash')
self.assertEquals(CommonMiddleware().process_request(request), None) self.assertEqual(CommonMiddleware().process_request(request), None)
def test_append_slash_slashless_unknown(self): def test_append_slash_slashless_unknown(self):
""" """
@ -47,7 +47,7 @@ class CommonMiddlewareTest(TestCase):
""" """
settings.APPEND_SLASH = True settings.APPEND_SLASH = True
request = self._get_request('unknown') request = self._get_request('unknown')
self.assertEquals(CommonMiddleware().process_request(request), None) self.assertEqual(CommonMiddleware().process_request(request), None)
def test_append_slash_redirect(self): def test_append_slash_redirect(self):
""" """
@ -56,8 +56,8 @@ class CommonMiddlewareTest(TestCase):
settings.APPEND_SLASH = True settings.APPEND_SLASH = True
request = self._get_request('slash') request = self._get_request('slash')
r = CommonMiddleware().process_request(request) r = CommonMiddleware().process_request(request)
self.assertEquals(r.status_code, 301) self.assertEqual(r.status_code, 301)
self.assertEquals(r['Location'], 'http://testserver/middleware/slash/') self.assertEqual(r['Location'], 'http://testserver/middleware/slash/')
def test_append_slash_no_redirect_on_POST_in_DEBUG(self): def test_append_slash_no_redirect_on_POST_in_DEBUG(self):
""" """
@ -85,7 +85,7 @@ class CommonMiddlewareTest(TestCase):
""" """
settings.APPEND_SLASH = False settings.APPEND_SLASH = False
request = self._get_request('slash') request = self._get_request('slash')
self.assertEquals(CommonMiddleware().process_request(request), None) self.assertEqual(CommonMiddleware().process_request(request), None)
def test_append_slash_quoted(self): def test_append_slash_quoted(self):
""" """
@ -95,8 +95,8 @@ class CommonMiddlewareTest(TestCase):
settings.APPEND_SLASH = True settings.APPEND_SLASH = True
request = self._get_request('needsquoting#') request = self._get_request('needsquoting#')
r = CommonMiddleware().process_request(request) r = CommonMiddleware().process_request(request)
self.assertEquals(r.status_code, 301) self.assertEqual(r.status_code, 301)
self.assertEquals( self.assertEqual(
r['Location'], r['Location'],
'http://testserver/middleware/needsquoting%23/') 'http://testserver/middleware/needsquoting%23/')
@ -105,8 +105,8 @@ class CommonMiddlewareTest(TestCase):
settings.APPEND_SLASH = False settings.APPEND_SLASH = False
request = self._get_request('path/') request = self._get_request('path/')
r = CommonMiddleware().process_request(request) r = CommonMiddleware().process_request(request)
self.assertEquals(r.status_code, 301) self.assertEqual(r.status_code, 301)
self.assertEquals( self.assertEqual(
r['Location'], r['Location'],
'http://www.testserver/middleware/path/') 'http://www.testserver/middleware/path/')
@ -115,8 +115,8 @@ class CommonMiddlewareTest(TestCase):
settings.APPEND_SLASH = True settings.APPEND_SLASH = True
request = self._get_request('slash/') request = self._get_request('slash/')
r = CommonMiddleware().process_request(request) r = CommonMiddleware().process_request(request)
self.assertEquals(r.status_code, 301) self.assertEqual(r.status_code, 301)
self.assertEquals(r['Location'], self.assertEqual(r['Location'],
'http://www.testserver/middleware/slash/') 'http://www.testserver/middleware/slash/')
def test_prepend_www_append_slash_slashless(self): def test_prepend_www_append_slash_slashless(self):
@ -124,8 +124,8 @@ class CommonMiddlewareTest(TestCase):
settings.APPEND_SLASH = True settings.APPEND_SLASH = True
request = self._get_request('slash') request = self._get_request('slash')
r = CommonMiddleware().process_request(request) r = CommonMiddleware().process_request(request)
self.assertEquals(r.status_code, 301) self.assertEqual(r.status_code, 301)
self.assertEquals(r['Location'], self.assertEqual(r['Location'],
'http://www.testserver/middleware/slash/') 'http://www.testserver/middleware/slash/')
@ -139,7 +139,7 @@ class CommonMiddlewareTest(TestCase):
settings.APPEND_SLASH = True settings.APPEND_SLASH = True
request = self._get_request('customurlconf/slash/') request = self._get_request('customurlconf/slash/')
request.urlconf = 'regressiontests.middleware.extra_urls' request.urlconf = 'regressiontests.middleware.extra_urls'
self.assertEquals(CommonMiddleware().process_request(request), None) self.assertEqual(CommonMiddleware().process_request(request), None)
def test_append_slash_slashless_resource_custom_urlconf(self): def test_append_slash_slashless_resource_custom_urlconf(self):
""" """
@ -148,7 +148,7 @@ class CommonMiddlewareTest(TestCase):
settings.APPEND_SLASH = True settings.APPEND_SLASH = True
request = self._get_request('customurlconf/noslash') request = self._get_request('customurlconf/noslash')
request.urlconf = 'regressiontests.middleware.extra_urls' request.urlconf = 'regressiontests.middleware.extra_urls'
self.assertEquals(CommonMiddleware().process_request(request), None) self.assertEqual(CommonMiddleware().process_request(request), None)
def test_append_slash_slashless_unknown_custom_urlconf(self): def test_append_slash_slashless_unknown_custom_urlconf(self):
""" """
@ -157,7 +157,7 @@ class CommonMiddlewareTest(TestCase):
settings.APPEND_SLASH = True settings.APPEND_SLASH = True
request = self._get_request('customurlconf/unknown') request = self._get_request('customurlconf/unknown')
request.urlconf = 'regressiontests.middleware.extra_urls' request.urlconf = 'regressiontests.middleware.extra_urls'
self.assertEquals(CommonMiddleware().process_request(request), None) self.assertEqual(CommonMiddleware().process_request(request), None)
def test_append_slash_redirect_custom_urlconf(self): def test_append_slash_redirect_custom_urlconf(self):
""" """
@ -169,8 +169,8 @@ class CommonMiddlewareTest(TestCase):
r = CommonMiddleware().process_request(request) r = CommonMiddleware().process_request(request)
self.assertFalse(r is None, self.assertFalse(r is None,
"CommonMiddlware failed to return APPEND_SLASH redirect using request.urlconf") "CommonMiddlware failed to return APPEND_SLASH redirect using request.urlconf")
self.assertEquals(r.status_code, 301) self.assertEqual(r.status_code, 301)
self.assertEquals(r['Location'], 'http://testserver/middleware/customurlconf/slash/') self.assertEqual(r['Location'], 'http://testserver/middleware/customurlconf/slash/')
def test_append_slash_no_redirect_on_POST_in_DEBUG_custom_urlconf(self): def test_append_slash_no_redirect_on_POST_in_DEBUG_custom_urlconf(self):
""" """
@ -200,7 +200,7 @@ class CommonMiddlewareTest(TestCase):
settings.APPEND_SLASH = False settings.APPEND_SLASH = False
request = self._get_request('customurlconf/slash') request = self._get_request('customurlconf/slash')
request.urlconf = 'regressiontests.middleware.extra_urls' request.urlconf = 'regressiontests.middleware.extra_urls'
self.assertEquals(CommonMiddleware().process_request(request), None) self.assertEqual(CommonMiddleware().process_request(request), None)
def test_append_slash_quoted_custom_urlconf(self): def test_append_slash_quoted_custom_urlconf(self):
""" """
@ -213,8 +213,8 @@ class CommonMiddlewareTest(TestCase):
r = CommonMiddleware().process_request(request) r = CommonMiddleware().process_request(request)
self.assertFalse(r is None, self.assertFalse(r is None,
"CommonMiddlware failed to return APPEND_SLASH redirect using request.urlconf") "CommonMiddlware failed to return APPEND_SLASH redirect using request.urlconf")
self.assertEquals(r.status_code, 301) self.assertEqual(r.status_code, 301)
self.assertEquals( self.assertEqual(
r['Location'], r['Location'],
'http://testserver/middleware/customurlconf/needsquoting%23/') 'http://testserver/middleware/customurlconf/needsquoting%23/')
@ -224,8 +224,8 @@ class CommonMiddlewareTest(TestCase):
request = self._get_request('customurlconf/path/') request = self._get_request('customurlconf/path/')
request.urlconf = 'regressiontests.middleware.extra_urls' request.urlconf = 'regressiontests.middleware.extra_urls'
r = CommonMiddleware().process_request(request) r = CommonMiddleware().process_request(request)
self.assertEquals(r.status_code, 301) self.assertEqual(r.status_code, 301)
self.assertEquals( self.assertEqual(
r['Location'], r['Location'],
'http://www.testserver/middleware/customurlconf/path/') 'http://www.testserver/middleware/customurlconf/path/')
@ -235,8 +235,8 @@ class CommonMiddlewareTest(TestCase):
request = self._get_request('customurlconf/slash/') request = self._get_request('customurlconf/slash/')
request.urlconf = 'regressiontests.middleware.extra_urls' request.urlconf = 'regressiontests.middleware.extra_urls'
r = CommonMiddleware().process_request(request) r = CommonMiddleware().process_request(request)
self.assertEquals(r.status_code, 301) self.assertEqual(r.status_code, 301)
self.assertEquals(r['Location'], self.assertEqual(r['Location'],
'http://www.testserver/middleware/customurlconf/slash/') 'http://www.testserver/middleware/customurlconf/slash/')
def test_prepend_www_append_slash_slashless_custom_urlconf(self): def test_prepend_www_append_slash_slashless_custom_urlconf(self):
@ -245,8 +245,8 @@ class CommonMiddlewareTest(TestCase):
request = self._get_request('customurlconf/slash') request = self._get_request('customurlconf/slash')
request.urlconf = 'regressiontests.middleware.extra_urls' request.urlconf = 'regressiontests.middleware.extra_urls'
r = CommonMiddleware().process_request(request) r = CommonMiddleware().process_request(request)
self.assertEquals(r.status_code, 301) self.assertEqual(r.status_code, 301)
self.assertEquals(r['Location'], self.assertEqual(r['Location'],
'http://www.testserver/middleware/customurlconf/slash/') 'http://www.testserver/middleware/customurlconf/slash/')
class ConditionalGetMiddlewareTest(TestCase): class ConditionalGetMiddlewareTest(TestCase):
@ -287,50 +287,50 @@ class ConditionalGetMiddlewareTest(TestCase):
def test_if_none_match_and_no_etag(self): def test_if_none_match_and_no_etag(self):
self.req.META['HTTP_IF_NONE_MATCH'] = 'spam' self.req.META['HTTP_IF_NONE_MATCH'] = 'spam'
self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp) self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
self.assertEquals(self.resp.status_code, 200) self.assertEqual(self.resp.status_code, 200)
def test_no_if_none_match_and_etag(self): def test_no_if_none_match_and_etag(self):
self.resp['ETag'] = 'eggs' self.resp['ETag'] = 'eggs'
self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp) self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
self.assertEquals(self.resp.status_code, 200) self.assertEqual(self.resp.status_code, 200)
def test_if_none_match_and_same_etag(self): def test_if_none_match_and_same_etag(self):
self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = 'spam' self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = 'spam'
self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp) self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
self.assertEquals(self.resp.status_code, 304) self.assertEqual(self.resp.status_code, 304)
def test_if_none_match_and_different_etag(self): def test_if_none_match_and_different_etag(self):
self.req.META['HTTP_IF_NONE_MATCH'] = 'spam' self.req.META['HTTP_IF_NONE_MATCH'] = 'spam'
self.resp['ETag'] = 'eggs' self.resp['ETag'] = 'eggs'
self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp) self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
self.assertEquals(self.resp.status_code, 200) self.assertEqual(self.resp.status_code, 200)
# Tests for the Last-Modified header # Tests for the Last-Modified header
def test_if_modified_since_and_no_last_modified(self): def test_if_modified_since_and_no_last_modified(self):
self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT' self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp) self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
self.assertEquals(self.resp.status_code, 200) self.assertEqual(self.resp.status_code, 200)
def test_no_if_modified_since_and_last_modified(self): def test_no_if_modified_since_and_last_modified(self):
self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:38:44 GMT' self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp) self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
self.assertEquals(self.resp.status_code, 200) self.assertEqual(self.resp.status_code, 200)
def test_if_modified_since_and_same_last_modified(self): def test_if_modified_since_and_same_last_modified(self):
self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT' self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:38:44 GMT' self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp) self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
self.assertEquals(self.resp.status_code, 304) self.assertEqual(self.resp.status_code, 304)
def test_if_modified_since_and_last_modified_in_the_past(self): def test_if_modified_since_and_last_modified_in_the_past(self):
self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT' self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT' self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp) self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
self.assertEquals(self.resp.status_code, 304) self.assertEqual(self.resp.status_code, 304)
def test_if_modified_since_and_last_modified_in_the_future(self): def test_if_modified_since_and_last_modified_in_the_future(self):
self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT' self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:41:44 GMT' self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:41:44 GMT'
self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp) self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
self.assertEquals(self.resp.status_code, 200) self.assertEqual(self.resp.status_code, 200)

4
tests/regressiontests/middleware_exceptions/tests.py
View File

@ -125,10 +125,10 @@ class BaseMiddlewareExceptionTest(TestCase):
except Exception, e: except Exception, e:
if type(extra_error) != type(e): if type(extra_error) != type(e):
self.fail("Unexpected exception: %s" % e) self.fail("Unexpected exception: %s" % e)
self.assertEquals(len(self.exceptions), len(errors)) self.assertEqual(len(self.exceptions), len(errors))
for i, error in enumerate(errors): for i, error in enumerate(errors):
exception, value, tb = self.exceptions[i] exception, value, tb = self.exceptions[i]
self.assertEquals(value.args, (error, )) self.assertEqual(value.args, (error, ))
def assert_middleware_usage(self, middleware, request, view, template_response, response, exception): def assert_middleware_usage(self, middleware, request, view, template_response, response, exception):
self.assertEqual(middleware.process_request_called, request) self.assertEqual(middleware.process_request_called, request)

4
tests/regressiontests/model_fields/tests.py
View File

@ -324,10 +324,10 @@ class TypeCoercionTests(test.TestCase):
""" """
def test_lookup_integer_in_charfield(self): def test_lookup_integer_in_charfield(self):
self.assertEquals(Post.objects.filter(title=9).count(), 0) self.assertEqual(Post.objects.filter(title=9).count(), 0)
def test_lookup_integer_in_textfield(self): def test_lookup_integer_in_textfield(self):
self.assertEquals(Post.objects.filter(body=24).count(), 0) self.assertEqual(Post.objects.filter(body=24).count(), 0)
class FileFieldTests(unittest.TestCase): class FileFieldTests(unittest.TestCase):
def test_clearable(self): def test_clearable(self):

38
tests/regressiontests/model_forms_regress/tests.py
View File

@ -80,7 +80,7 @@ class OverrideCleanTests(TestCase):
self.assertTrue(form.is_valid()) self.assertTrue(form.is_valid())
# form.instance.left will be None if the instance was not constructed # form.instance.left will be None if the instance was not constructed
# by form.full_clean(). # by form.full_clean().
self.assertEquals(form.instance.left, 1) self.assertEqual(form.instance.left, 1)
# Regression test for #12960. # Regression test for #12960.
# Make sure the cleaned_data returned from ModelForm.clean() is applied to the # Make sure the cleaned_data returned from ModelForm.clean() is applied to the
@ -133,7 +133,7 @@ class ManyToManyCallableInitialTests(TestCase):
# Create a ModelForm, instantiate it, and check that the output is as expected # Create a ModelForm, instantiate it, and check that the output is as expected
ModelForm = modelform_factory(Article, formfield_callback=formfield_for_dbfield) ModelForm = modelform_factory(Article, formfield_callback=formfield_for_dbfield)
form = ModelForm() form = ModelForm()
self.assertEquals(form.as_ul(), u"""<li><label for="id_headline">Headline:</label> <input id="id_headline" type="text" name="headline" maxlength="100" /></li> self.assertEqual(form.as_ul(), u"""<li><label for="id_headline">Headline:</label> <input id="id_headline" type="text" name="headline" maxlength="100" /></li>
<li><label for="id_publications">Publications:</label> <select multiple="multiple" name="publications" id="id_publications"> <li><label for="id_publications">Publications:</label> <select multiple="multiple" name="publications" id="id_publications">
<option value="1" selected="selected">First Book</option> <option value="1" selected="selected">First Book</option>
<option value="2" selected="selected">Second Book</option> <option value="2" selected="selected">Second Book</option>
@ -193,7 +193,7 @@ class OneToOneFieldTests(TestCase):
date_published=date(1991, 8, 22)) date_published=date(1991, 8, 22))
author = Author.objects.create(publication=publication, full_name='John Doe') author = Author.objects.create(publication=publication, full_name='John Doe')
form = AuthorForm({'publication':u'', 'full_name':'John Doe'}, instance=author) form = AuthorForm({'publication':u'', 'full_name':'John Doe'}, instance=author)
self.assert_(form.is_valid()) self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data['publication'], None) self.assertEqual(form.cleaned_data['publication'], None)
author = form.save() author = form.save()
# author object returned from form still retains original publication object # author object returned from form still retains original publication object
@ -211,7 +211,7 @@ class OneToOneFieldTests(TestCase):
date_published=date(1991, 8, 22)) date_published=date(1991, 8, 22))
author = Author1.objects.create(publication=publication, full_name='John Doe') author = Author1.objects.create(publication=publication, full_name='John Doe')
form = AuthorForm({'publication':u'', 'full_name':'John Doe'}, instance=author) form = AuthorForm({'publication':u'', 'full_name':'John Doe'}, instance=author)
self.assert_(not form.is_valid()) self.assertTrue(not form.is_valid())
class ModelChoiceForm(forms.Form): class ModelChoiceForm(forms.Form):
@ -224,8 +224,8 @@ class TestTicket11183(TestCase):
field1 = form1.fields['person'] field1 = form1.fields['person']
# To allow the widget to change the queryset of field1.widget.choices correctly, # To allow the widget to change the queryset of field1.widget.choices correctly,
# without affecting other forms, the following must hold: # without affecting other forms, the following must hold:
self.assert_(field1 is not ModelChoiceForm.base_fields['person']) self.assertTrue(field1 is not ModelChoiceForm.base_fields['person'])
self.assert_(field1.widget.choices.field is field1) self.assertTrue(field1.widget.choices.field is field1)
class HomepageForm(forms.ModelForm): class HomepageForm(forms.ModelForm):
class Meta: class Meta:
@ -253,12 +253,12 @@ class URLFieldTests(TestCase):
form = HomepageForm({'url': 'example.com'}) form = HomepageForm({'url': 'example.com'})
form.is_valid() form.is_valid()
# self.assertTrue(form.is_valid()) # self.assertTrue(form.is_valid())
# self.assertEquals(form.cleaned_data['url'], 'http://example.com/') # self.assertEqual(form.cleaned_data['url'], 'http://example.com/')
form = HomepageForm({'url': 'example.com/test'}) form = HomepageForm({'url': 'example.com/test'})
form.is_valid() form.is_valid()
# self.assertTrue(form.is_valid()) # self.assertTrue(form.is_valid())
# self.assertEquals(form.cleaned_data['url'], 'http://example.com/test') # self.assertEqual(form.cleaned_data['url'], 'http://example.com/test')
class FormFieldCallbackTests(TestCase): class FormFieldCallbackTests(TestCase):
@ -376,14 +376,14 @@ class FileFieldTests(unittest.TestCase):
""" """
form = DocumentForm() form = DocumentForm()
self.assert_('name="myfile"' in unicode(form)) self.assertTrue('name="myfile"' in unicode(form))
self.assert_('myfile-clear' not in unicode(form)) self.assertTrue('myfile-clear' not in unicode(form))
form = DocumentForm(files={'myfile': SimpleUploadedFile('something.txt', 'content')}) form = DocumentForm(files={'myfile': SimpleUploadedFile('something.txt', 'content')})
self.assert_(form.is_valid()) self.assertTrue(form.is_valid())
doc = form.save(commit=False) doc = form.save(commit=False)
self.assertEqual(doc.myfile.name, 'something.txt') self.assertEqual(doc.myfile.name, 'something.txt')
form = DocumentForm(instance=doc) form = DocumentForm(instance=doc)
self.assert_('myfile-clear' in unicode(form)) self.assertTrue('myfile-clear' in unicode(form))
form = DocumentForm(instance=doc, data={'myfile-clear': 'true'}) form = DocumentForm(instance=doc, data={'myfile-clear': 'true'})
doc = form.save(commit=False) doc = form.save(commit=False)
self.assertEqual(bool(doc.myfile), False) self.assertEqual(bool(doc.myfile), False)
@ -396,17 +396,17 @@ class FileFieldTests(unittest.TestCase):
""" """
form = DocumentForm(files={'myfile': SimpleUploadedFile('something.txt', 'content')}) form = DocumentForm(files={'myfile': SimpleUploadedFile('something.txt', 'content')})
self.assert_(form.is_valid()) self.assertTrue(form.is_valid())
doc = form.save(commit=False) doc = form.save(commit=False)
form = DocumentForm(instance=doc, form = DocumentForm(instance=doc,
files={'myfile': SimpleUploadedFile('something.txt', 'content')}, files={'myfile': SimpleUploadedFile('something.txt', 'content')},
data={'myfile-clear': 'true'}) data={'myfile-clear': 'true'})
self.assert_(not form.is_valid()) self.assertTrue(not form.is_valid())
self.assertEqual(form.errors['myfile'], self.assertEqual(form.errors['myfile'],
[u'Please either submit a file or check the clear checkbox, not both.']) [u'Please either submit a file or check the clear checkbox, not both.'])
rendered = unicode(form) rendered = unicode(form)
self.assert_('something.txt' in rendered) self.assertTrue('something.txt' in rendered)
self.assert_('myfile-clear' in rendered) self.assertTrue('myfile-clear' in rendered)
class EditionForm(forms.ModelForm): class EditionForm(forms.ModelForm):
author = forms.ModelChoiceField(queryset=Person.objects.all()) author = forms.ModelChoiceField(queryset=Person.objects.all())
@ -428,13 +428,13 @@ class UniqueErrorsTests(TestCase):
def test_unique_error_message(self): def test_unique_error_message(self):
form = EditionForm(data={'author': self.author1.pk, 'publication': self.pub2.pk, 'edition': 1, 'isbn': '9783161484100'}) form = EditionForm(data={'author': self.author1.pk, 'publication': self.pub2.pk, 'edition': 1, 'isbn': '9783161484100'})
self.assertEquals(form.errors, {'isbn': [u'Edition with this Isbn already exists.']}) self.assertEqual(form.errors, {'isbn': [u'Edition with this Isbn already exists.']})
def test_unique_together_error_message(self): def test_unique_together_error_message(self):
form = EditionForm(data={'author': self.author1.pk, 'publication': self.pub1.pk, 'edition': 2, 'isbn': '9783161489999'}) form = EditionForm(data={'author': self.author1.pk, 'publication': self.pub1.pk, 'edition': 2, 'isbn': '9783161489999'})
self.assertEquals(form.errors, {'__all__': [u'Edition with this Author and Publication already exists.']}) self.assertEqual(form.errors, {'__all__': [u'Edition with this Author and Publication already exists.']})
form = EditionForm(data={'author': self.author2.pk, 'publication': self.pub1.pk, 'edition': 1, 'isbn': '9783161487777'}) form = EditionForm(data={'author': self.author2.pk, 'publication': self.pub1.pk, 'edition': 1, 'isbn': '9783161487777'})
self.assertEquals(form.errors, {'__all__': [u'Edition with this Publication and Edition already exists.']}) self.assertEqual(form.errors, {'__all__': [u'Edition with this Publication and Edition already exists.']})
class EmptyFieldsTestCase(TestCase): class EmptyFieldsTestCase(TestCase):

6
tests/regressiontests/model_inheritance_regress/tests.py
View File

@ -367,7 +367,7 @@ class ModelInheritanceTest(TestCase):
# from an ABC even when there are one or more intermediate # from an ABC even when there are one or more intermediate
# abstract models in the inheritance chain, for consistency with # abstract models in the inheritance chain, for consistency with
# verbose_name. # verbose_name.
self.assertEquals( self.assertEqual(
InternalCertificationAudit._meta.verbose_name_plural, InternalCertificationAudit._meta.verbose_name_plural,
u'Audits' u'Audits'
) )
@ -394,12 +394,12 @@ class ModelInheritanceTest(TestCase):
# Regression test for #13987: Primary key is incorrectly determined # Regression test for #13987: Primary key is incorrectly determined
# when more than one model has a concrete->abstract->concrete # when more than one model has a concrete->abstract->concrete
# inheritance hierarchy. # inheritance hierarchy.
self.assertEquals( self.assertEqual(
len([field for field in BusStation._meta.local_fields len([field for field in BusStation._meta.local_fields
if field.primary_key]), if field.primary_key]),
1 1
) )
self.assertEquals( self.assertEqual(
len([field for field in TrainStation._meta.local_fields len([field for field in TrainStation._meta.local_fields
if field.primary_key]), if field.primary_key]),
1 1

2
tests/regressiontests/modeladmin/tests.py
View File

@ -37,7 +37,7 @@ class ModelAdminTests(TestCase):
def test_default_fields(self): def test_default_fields(self):
ma = ModelAdmin(Band, self.site) ma = ModelAdmin(Band, self.site)
self.assertEquals(ma.get_form(request).base_fields.keys(), self.assertEqual(ma.get_form(request).base_fields.keys(),
['name', 'bio', 'sign_date']) ['name', 'bio', 'sign_date'])
def test_default_fieldsets(self): def test_default_fieldsets(self):

536
tests/regressiontests/multiple_database/tests.py
View File

File diff suppressed because it is too large Load Diff

4
tests/regressiontests/null_fk/tests.py
View File

@ -17,8 +17,8 @@ class NullFkTests(TestCase):
# that come after the NULLs, or else data that should exist won't). Regression # that come after the NULLs, or else data that should exist won't). Regression
# test for #7369. # test for #7369.
c = Comment.objects.select_related().get(id=1) c = Comment.objects.select_related().get(id=1)
self.assertEquals(c.post, p) self.assertEqual(c.post, p)
self.assertEquals(Comment.objects.select_related().get(id=2).post, None) self.assertEqual(Comment.objects.select_related().get(id=2).post, None)
self.assertQuerysetEqual( self.assertQuerysetEqual(
Comment.objects.select_related('post__forum__system_info').all(), Comment.objects.select_related('post__forum__system_info').all(),

2
tests/regressiontests/null_queries/tests.py
View File

@ -44,7 +44,7 @@ class NullQueriesTests(TestCase):
# Related managers use __exact=None implicitly if the object hasn't been saved. # Related managers use __exact=None implicitly if the object hasn't been saved.
p2 = Poll(question="How?") p2 = Poll(question="How?")
self.assertEquals(repr(p2.choice_set.all()), '[]') self.assertEqual(repr(p2.choice_set.all()), '[]')
def test_reverse_relations(self): def test_reverse_relations(self):
""" """

4
tests/regressiontests/one_to_one_regress/tests.py
View File

@ -50,8 +50,8 @@ class OneToOneRegressionTests(TestCase):
Check that the name of the cache for the reverse object is correct. Check that the name of the cache for the reverse object is correct.
""" """
self.assertEquals(self.p1.restaurant, self.r1) self.assertEqual(self.p1.restaurant, self.r1)
self.assertEquals(self.p1.bar, self.b1) self.assertEqual(self.p1.bar, self.b1)
def test_related_object_cache(self): def test_related_object_cache(self):
""" Regression test for #6886 (the related-object cache) """ """ Regression test for #6886 (the related-object cache) """

10
tests/regressiontests/queries/tests.py
View File

@ -1402,13 +1402,13 @@ class SubqueryTests(TestCase):
"Subselects honor any manual ordering" "Subselects honor any manual ordering"
try: try:
query = DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[0:2]) query = DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[0:2])
self.assertEquals(set(query.values_list('id', flat=True)), set([2,3])) self.assertEqual(set(query.values_list('id', flat=True)), set([2,3]))
query = DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[:2]) query = DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[:2])
self.assertEquals(set(query.values_list('id', flat=True)), set([2,3])) self.assertEqual(set(query.values_list('id', flat=True)), set([2,3]))
query = DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[2:]) query = DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[2:])
self.assertEquals(set(query.values_list('id', flat=True)), set([1])) self.assertEqual(set(query.values_list('id', flat=True)), set([1]))
except DatabaseError: except DatabaseError:
# Oracle and MySQL both have problems with sliced subselects. # Oracle and MySQL both have problems with sliced subselects.
# This prevents us from even evaluating this test case at all. # This prevents us from even evaluating this test case at all.
@ -1419,7 +1419,7 @@ class SubqueryTests(TestCase):
"Delete queries can safely contain sliced subqueries" "Delete queries can safely contain sliced subqueries"
try: try:
DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[0:1]).delete() DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[0:1]).delete()
self.assertEquals(set(DumbCategory.objects.values_list('id', flat=True)), set([1,2])) self.assertEqual(set(DumbCategory.objects.values_list('id', flat=True)), set([1,2]))
except DatabaseError: except DatabaseError:
# Oracle and MySQL both have problems with sliced subselects. # Oracle and MySQL both have problems with sliced subselects.
# This prevents us from even evaluating this test case at all. # This prevents us from even evaluating this test case at all.
@ -1441,7 +1441,7 @@ class CloneTests(TestCase):
# Use the note queryset in a query, and evalute # Use the note queryset in a query, and evalute
# that query in a way that involves cloning. # that query in a way that involves cloning.
try: try:
self.assertEquals(ExtraInfo.objects.filter(note__in=n_list)[0].info, 'good') self.assertEqual(ExtraInfo.objects.filter(note__in=n_list)[0].info, 'good')
except: except:
self.fail('Query should be clonable') self.fail('Query should be clonable')

4
tests/regressiontests/reverse_single_related/tests.py
View File

@ -22,11 +22,11 @@ class ReverseSingleRelatedTests(TestCase):
["<Source: Source object>"] ["<Source: Source object>"]
) )
self.assertEquals(public_item.source, public_source) self.assertEqual(public_item.source, public_source)
# Make sure that an item can still access its related source even if the default # Make sure that an item can still access its related source even if the default
# manager doesn't normally allow it. # manager doesn't normally allow it.
self.assertEquals(private_item.source, private_source) self.assertEqual(private_item.source, private_source)
# If the manager is marked "use_for_related_fields", it'll get used instead # If the manager is marked "use_for_related_fields", it'll get used instead
# of the "bare" queryset. Usually you'd define this as a property on the class, # of the "bare" queryset. Usually you'd define this as a property on the class,

46
tests/regressiontests/select_related_regress/tests.py
View File

@ -27,16 +27,16 @@ class SelectRelatedRegressTests(TestCase):
c2=Connection.objects.create(start=port2, end=port3) c2=Connection.objects.create(start=port2, end=port3)
connections=Connection.objects.filter(start__device__building=b, end__device__building=b).order_by('id') connections=Connection.objects.filter(start__device__building=b, end__device__building=b).order_by('id')
self.assertEquals([(c.id, unicode(c.start), unicode(c.end)) for c in connections], self.assertEqual([(c.id, unicode(c.start), unicode(c.end)) for c in connections],
[(1, u'router/4', u'switch/7'), (2, u'switch/7', u'server/1')]) [(1, u'router/4', u'switch/7'), (2, u'switch/7', u'server/1')])
connections=Connection.objects.filter(start__device__building=b, end__device__building=b).select_related().order_by('id') connections=Connection.objects.filter(start__device__building=b, end__device__building=b).select_related().order_by('id')
self.assertEquals([(c.id, unicode(c.start), unicode(c.end)) for c in connections], self.assertEqual([(c.id, unicode(c.start), unicode(c.end)) for c in connections],
[(1, u'router/4', u'switch/7'), (2, u'switch/7', u'server/1')]) [(1, u'router/4', u'switch/7'), (2, u'switch/7', u'server/1')])
# This final query should only join seven tables (port, device and building # This final query should only join seven tables (port, device and building
# twice each, plus connection once). # twice each, plus connection once).
self.assertEquals(connections.query.count_active_tables(), 7) self.assertEqual(connections.query.count_active_tables(), 7)
def test_regression_8106(self): def test_regression_8106(self):
@ -58,8 +58,8 @@ class SelectRelatedRegressTests(TestCase):
e = Enrollment.objects.create(std=s, cls=c) e = Enrollment.objects.create(std=s, cls=c)
e_related = Enrollment.objects.all().select_related()[0] e_related = Enrollment.objects.all().select_related()[0]
self.assertEquals(e_related.std.person.user.name, u"std") self.assertEqual(e_related.std.person.user.name, u"std")
self.assertEquals(e_related.cls.org.person.user.name, u"org") self.assertEqual(e_related.cls.org.person.user.name, u"org")
def test_regression_8036(self): def test_regression_8036(self):
""" """
@ -75,13 +75,13 @@ class SelectRelatedRegressTests(TestCase):
active = ClientStatus.objects.create(name='active') active = ClientStatus.objects.create(name='active')
client = Client.objects.create(name='client', status=active) client = Client.objects.create(name='client', status=active)
self.assertEquals(client.status, active) self.assertEqual(client.status, active)
self.assertEquals(Client.objects.select_related()[0].status, active) self.assertEqual(Client.objects.select_related()[0].status, active)
self.assertEquals(Client.objects.select_related('state')[0].status, active) self.assertEqual(Client.objects.select_related('state')[0].status, active)
self.assertEquals(Client.objects.select_related('state', 'status')[0].status, active) self.assertEqual(Client.objects.select_related('state', 'status')[0].status, active)
self.assertEquals(Client.objects.select_related('state__country')[0].status, active) self.assertEqual(Client.objects.select_related('state__country')[0].status, active)
self.assertEquals(Client.objects.select_related('state__country', 'status')[0].status, active) self.assertEqual(Client.objects.select_related('state__country', 'status')[0].status, active)
self.assertEquals(Client.objects.select_related('status')[0].status, active) self.assertEqual(Client.objects.select_related('status')[0].status, active)
def test_multi_table_inheritance(self): def test_multi_table_inheritance(self):
""" Exercising select_related() with multi-table model inheritance. """ """ Exercising select_related() with multi-table model inheritance. """
@ -108,27 +108,27 @@ class SelectRelatedRegressTests(TestCase):
c1 = Client.objects.create(name='Brian Burke', state=wa, status=active) c1 = Client.objects.create(name='Brian Burke', state=wa, status=active)
burke = Client.objects.select_related('state').defer('state__name').get(name='Brian Burke') burke = Client.objects.select_related('state').defer('state__name').get(name='Brian Burke')
self.assertEquals(burke.name, u'Brian Burke') self.assertEqual(burke.name, u'Brian Burke')
self.assertEquals(burke.state.name, u'Western Australia') self.assertEqual(burke.state.name, u'Western Australia')
# Still works if we're dealing with an inherited class # Still works if we're dealing with an inherited class
sc1 = SpecialClient.objects.create(name='Troy Buswell', state=wa, status=active, value=42) sc1 = SpecialClient.objects.create(name='Troy Buswell', state=wa, status=active, value=42)
troy = SpecialClient.objects.select_related('state').defer('state__name').get(name='Troy Buswell') troy = SpecialClient.objects.select_related('state').defer('state__name').get(name='Troy Buswell')
self.assertEquals(troy.name, u'Troy Buswell') self.assertEqual(troy.name, u'Troy Buswell')
self.assertEquals(troy.value, 42) self.assertEqual(troy.value, 42)
self.assertEquals(troy.state.name, u'Western Australia') self.assertEqual(troy.state.name, u'Western Australia')
# Still works if we defer an attribute on the inherited class # Still works if we defer an attribute on the inherited class
troy = SpecialClient.objects.select_related('state').defer('value', 'state__name').get(name='Troy Buswell') troy = SpecialClient.objects.select_related('state').defer('value', 'state__name').get(name='Troy Buswell')
self.assertEquals(troy.name, u'Troy Buswell') self.assertEqual(troy.name, u'Troy Buswell')
self.assertEquals(troy.value, 42) self.assertEqual(troy.value, 42)
self.assertEquals(troy.state.name, u'Western Australia') self.assertEqual(troy.state.name, u'Western Australia')
# Also works if you use only, rather than defer # Also works if you use only, rather than defer
troy = SpecialClient.objects.select_related('state').only('name').get(name='Troy Buswell') troy = SpecialClient.objects.select_related('state').only('name').get(name='Troy Buswell')
self.assertEquals(troy.name, u'Troy Buswell') self.assertEqual(troy.name, u'Troy Buswell')
self.assertEquals(troy.value, 42) self.assertEqual(troy.value, 42)
self.assertEquals(troy.state.name, u'Western Australia') self.assertEqual(troy.state.name, u'Western Australia')

2
tests/regressiontests/serializers_regress/tests.py
View File

@ -381,7 +381,7 @@ def serializerTest(format, self):
# Assert that the number of objects deserialized is the # Assert that the number of objects deserialized is the
# same as the number that was serialized. # same as the number that was serialized.
for klass, count in instance_count.items(): for klass, count in instance_count.items():
self.assertEquals(count, klass.objects.count()) self.assertEqual(count, klass.objects.count())
def fieldsTest(format, self): def fieldsTest(format, self):
obj = ComplexModel(field1='first', field2='second', field3='third') obj = ComplexModel(field1='first', field2='second', field3='third')

10
tests/regressiontests/signals_regress/tests.py
View File

@ -67,19 +67,19 @@ class SignalsRegressTests(TestCase):
len(models.signals.pre_delete.receivers), len(models.signals.pre_delete.receivers),
len(models.signals.post_delete.receivers)) len(models.signals.post_delete.receivers))
self.assertEquals(self.pre_signals, post_signals) self.assertEqual(self.pre_signals, post_signals)
def test_model_signals(self): def test_model_signals(self):
""" Model saves should throw some signals. """ """ Model saves should throw some signals. """
a1 = Author(name='Neal Stephenson') a1 = Author(name='Neal Stephenson')
self.assertEquals(self.get_signal_output(a1.save), [ self.assertEqual(self.get_signal_output(a1.save), [
"pre_save signal, Neal Stephenson", "pre_save signal, Neal Stephenson",
"post_save signal, Neal Stephenson", "post_save signal, Neal Stephenson",
"Is created" "Is created"
]) ])
b1 = Book(name='Snow Crash') b1 = Book(name='Snow Crash')
self.assertEquals(self.get_signal_output(b1.save), [ self.assertEqual(self.get_signal_output(b1.save), [
"pre_save signal, Snow Crash", "pre_save signal, Snow Crash",
"post_save signal, Snow Crash", "post_save signal, Snow Crash",
"Is created" "Is created"
@ -92,5 +92,5 @@ class SignalsRegressTests(TestCase):
self.get_signal_output(b1.save) self.get_signal_output(b1.save)
a1 = Author(name='Neal Stephenson') a1 = Author(name='Neal Stephenson')
self.get_signal_output(a1.save) self.get_signal_output(a1.save)
self.assertEquals(self.get_signal_output(setattr, b1, 'authors', [a1]), []) self.assertEqual(self.get_signal_output(setattr, b1, 'authors', [a1]), [])
self.assertEquals(self.get_signal_output(setattr, b1, 'authors', []), []) self.assertEqual(self.get_signal_output(setattr, b1, 'authors', []), [])

10
tests/regressiontests/staticfiles_tests/tests.py
View File

@ -194,7 +194,7 @@ class TestFindStatic(BuildStaticTestCase, TestDefaults):
lines = [l.strip() for l in sys.stdout.readlines()] lines = [l.strip() for l in sys.stdout.readlines()]
finally: finally:
sys.stdout = _stdout sys.stdout = _stdout
self.assertEquals(len(lines), 3) # three because there is also the "Found <file> here" line self.assertEqual(len(lines), 3) # three because there is also the "Found <file> here" line
self.assertTrue('project' in lines[1]) self.assertTrue('project' in lines[1])
self.assertTrue('apps' in lines[2]) self.assertTrue('apps' in lines[2])
@ -244,7 +244,7 @@ class TestNoFilesCreated(object):
""" """
Make sure no files were create in the destination directory. Make sure no files were create in the destination directory.
""" """
self.assertEquals(os.listdir(settings.STATIC_ROOT), []) self.assertEqual(os.listdir(settings.STATIC_ROOT), [])
class TestBuildStaticDryRun(BuildStaticTestCase, TestNoFilesCreated): class TestBuildStaticDryRun(BuildStaticTestCase, TestNoFilesCreated):
@ -302,7 +302,7 @@ class TestServeStatic(StaticFilesTestCase):
self.assertContains(self._response(filepath), text) self.assertContains(self._response(filepath), text)
def assertFileNotFound(self, filepath): def assertFileNotFound(self, filepath):
self.assertEquals(self._response(filepath).status_code, 404) self.assertEqual(self._response(filepath).status_code, 404)
class TestServeDisabled(TestServeStatic): class TestServeDisabled(TestServeStatic):
@ -349,11 +349,11 @@ class FinderTestCase(object):
""" """
def test_find_first(self): def test_find_first(self):
src, dst = self.find_first src, dst = self.find_first
self.assertEquals(self.finder.find(src), dst) self.assertEqual(self.finder.find(src), dst)
def test_find_all(self): def test_find_all(self):
src, dst = self.find_all src, dst = self.find_all
self.assertEquals(self.finder.find(src, all=True), dst) self.assertEqual(self.finder.find(src, all=True), dst)
class TestFileSystemFinder(StaticFilesTestCase, FinderTestCase): class TestFileSystemFinder(StaticFilesTestCase, FinderTestCase):

18
tests/regressiontests/string_lookup/tests.py
View File

@ -23,11 +23,11 @@ class StringLookupTests(TestCase):
b1 = Bar(name="Bar1", normal=f1, fwd=w1, back=f2) b1 = Bar(name="Bar1", normal=f1, fwd=w1, back=f2)
b1.save() b1.save()
self.assertEquals(b1.normal, f1) self.assertEqual(b1.normal, f1)
self.assertEquals(b1.fwd, w1) self.assertEqual(b1.fwd, w1)
self.assertEquals(b1.back, f2) self.assertEqual(b1.back, f2)
base1 = Base(name="Base1") base1 = Base(name="Base1")
base1.save() base1.save()
@ -35,7 +35,7 @@ class StringLookupTests(TestCase):
child1 = Child(name="Child1", parent=base1) child1 = Child(name="Child1", parent=base1)
child1.save() child1.save()
self.assertEquals(child1.parent, base1) self.assertEqual(child1.parent, base1)
def test_unicode_chars_in_queries(self): def test_unicode_chars_in_queries(self):
""" """
@ -48,10 +48,10 @@ class StringLookupTests(TestCase):
fx = Foo(name='Bjorn', friend=u'François') fx = Foo(name='Bjorn', friend=u'François')
fx.save() fx.save()
self.assertEquals(Foo.objects.get(friend__contains=u'\xe7'), fx) self.assertEqual(Foo.objects.get(friend__contains=u'\xe7'), fx)
# We can also do the above query using UTF-8 strings. # We can also do the above query using UTF-8 strings.
self.assertEquals(Foo.objects.get(friend__contains='\xc3\xa7'), fx) self.assertEqual(Foo.objects.get(friend__contains='\xc3\xa7'), fx)
def test_queries_on_textfields(self): def test_queries_on_textfields(self):
""" """
@ -62,9 +62,9 @@ class StringLookupTests(TestCase):
a = Article(name='Test', text='The quick brown fox jumps over the lazy dog.') a = Article(name='Test', text='The quick brown fox jumps over the lazy dog.')
a.save() a.save()
self.assertEquals(Article.objects.get(text__exact='The quick brown fox jumps over the lazy dog.'), a) self.assertEqual(Article.objects.get(text__exact='The quick brown fox jumps over the lazy dog.'), a)
self.assertEquals(Article.objects.get(text__contains='quick brown fox'), a) self.assertEqual(Article.objects.get(text__contains='quick brown fox'), a)
def test_ipaddress_on_postgresql(self): def test_ipaddress_on_postgresql(self):
""" """
@ -74,5 +74,5 @@ class StringLookupTests(TestCase):
""" """
a = Article(name='IP test', text='The body', submitted_from='192.0.2.100') a = Article(name='IP test', text='The body', submitted_from='192.0.2.100')
a.save() a.save()
self.assertEquals(repr(Article.objects.filter(submitted_from__contains='192.0.2')), self.assertEqual(repr(Article.objects.filter(submitted_from__contains='192.0.2')),
repr([a])) repr([a]))

8
tests/regressiontests/syndication/tests.py
View File

@ -198,7 +198,7 @@ class SyndicationFeedTest(FeedTestCase):
link = item.getElementsByTagName('link')[0] link = item.getElementsByTagName('link')[0]
if link.firstChild.wholeText == 'http://example.com/blog/4/': if link.firstChild.wholeText == 'http://example.com/blog/4/':
title = item.getElementsByTagName('title')[0] title = item.getElementsByTagName('title')[0]
self.assertEquals(title.firstChild.wholeText, u'A &amp; B &lt; C &gt; D') self.assertEqual(title.firstChild.wholeText, u'A &amp; B &lt; C &gt; D')
def test_naive_datetime_conversion(self): def test_naive_datetime_conversion(self):
""" """
@ -329,14 +329,14 @@ class DeprecatedSyndicationFeedTest(FeedTestCase):
Test that an empty feed_dict raises a 404. Test that an empty feed_dict raises a 404.
""" """
response = self.client.get('/syndication/depr-feeds-empty/aware-dates/') response = self.client.get('/syndication/depr-feeds-empty/aware-dates/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)
def test_nonexistent_slug(self): def test_nonexistent_slug(self):
""" """
Test that a non-existent slug raises a 404. Test that a non-existent slug raises a 404.
""" """
response = self.client.get('/syndication/depr-feeds/foobar/') response = self.client.get('/syndication/depr-feeds/foobar/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)
def test_rss_feed(self): def test_rss_feed(self):
""" """
@ -360,5 +360,5 @@ class DeprecatedSyndicationFeedTest(FeedTestCase):
exception. exception.
""" """
response = self.client.get('/syndication/depr-feeds/complex/') response = self.client.get('/syndication/depr-feeds/complex/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)

16
tests/regressiontests/templates/custom.py
View File

@ -13,27 +13,27 @@ class CustomFilterTests(TestCase):
class CustomTagTests(TestCase): class CustomTagTests(TestCase):
def verify_tag(self, tag, name): def verify_tag(self, tag, name):
self.assertEquals(tag.__name__, name) self.assertEqual(tag.__name__, name)
self.assertEquals(tag.__doc__, 'Expected %s __doc__' % name) self.assertEqual(tag.__doc__, 'Expected %s __doc__' % name)
self.assertEquals(tag.__dict__['anything'], 'Expected %s __dict__' % name) self.assertEqual(tag.__dict__['anything'], 'Expected %s __dict__' % name)
def test_simple_tags(self): def test_simple_tags(self):
c = template.Context({'value': 42}) c = template.Context({'value': 42})
t = template.Template('{% load custom %}{% no_params %}') t = template.Template('{% load custom %}{% no_params %}')
self.assertEquals(t.render(c), u'no_params - Expected result') self.assertEqual(t.render(c), u'no_params - Expected result')
t = template.Template('{% load custom %}{% one_param 37 %}') t = template.Template('{% load custom %}{% one_param 37 %}')
self.assertEquals(t.render(c), u'one_param - Expected result: 37') self.assertEqual(t.render(c), u'one_param - Expected result: 37')
t = template.Template('{% load custom %}{% explicit_no_context 37 %}') t = template.Template('{% load custom %}{% explicit_no_context 37 %}')
self.assertEquals(t.render(c), u'explicit_no_context - Expected result: 37') self.assertEqual(t.render(c), u'explicit_no_context - Expected result: 37')
t = template.Template('{% load custom %}{% no_params_with_context %}') t = template.Template('{% load custom %}{% no_params_with_context %}')
self.assertEquals(t.render(c), u'no_params_with_context - Expected result (context value: 42)') self.assertEqual(t.render(c), u'no_params_with_context - Expected result (context value: 42)')
t = template.Template('{% load custom %}{% params_and_context 37 %}') t = template.Template('{% load custom %}{% params_and_context 37 %}')
self.assertEquals(t.render(c), u'params_and_context - Expected result (context value: 42): 37') self.assertEqual(t.render(c), u'params_and_context - Expected result (context value: 42): 37')
def test_simple_tag_registration(self): def test_simple_tag_registration(self):
# Test that the decorators preserve the decorated function's docstring, name and attributes. # Test that the decorators preserve the decorated function's docstring, name and attributes.

14
tests/regressiontests/templates/response.py
View File

@ -166,7 +166,7 @@ class SimpleTemplateResponseTest(BaseTemplateResponseTest):
# When the content is rendered, all the callbacks are invoked, too. # When the content is rendered, all the callbacks are invoked, too.
response.render() response.render()
self.assertEqual('First template\n', response.content) self.assertEqual('First template\n', response.content)
self.assertEquals(post, ['post1','post2']) self.assertEqual(post, ['post1','post2'])
def test_pickling(self): def test_pickling(self):
@ -184,9 +184,9 @@ class SimpleTemplateResponseTest(BaseTemplateResponseTest):
pickled_response = pickle.dumps(response) pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response) unpickled_response = pickle.loads(pickled_response)
self.assertEquals(unpickled_response.content, response.content) self.assertEqual(unpickled_response.content, response.content)
self.assertEquals(unpickled_response['content-type'], response['content-type']) self.assertEqual(unpickled_response['content-type'], response['content-type'])
self.assertEquals(unpickled_response.status_code, response.status_code) self.assertEqual(unpickled_response.status_code, response.status_code)
# ...and the unpickled reponse doesn't have the # ...and the unpickled reponse doesn't have the
# template-related attributes, so it can't be re-rendered # template-related attributes, so it can't be re-rendered
@ -249,9 +249,9 @@ class TemplateResponseTest(BaseTemplateResponseTest):
pickled_response = pickle.dumps(response) pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response) unpickled_response = pickle.loads(pickled_response)
self.assertEquals(unpickled_response.content, response.content) self.assertEqual(unpickled_response.content, response.content)
self.assertEquals(unpickled_response['content-type'], response['content-type']) self.assertEqual(unpickled_response['content-type'], response['content-type'])
self.assertEquals(unpickled_response.status_code, response.status_code) self.assertEqual(unpickled_response.status_code, response.status_code)
# ...and the unpickled reponse doesn't have the # ...and the unpickled reponse doesn't have the
# template-related attributes, so it can't be re-rendered # template-related attributes, so it can't be re-rendered

4
tests/regressiontests/templates/smartif.py
View File

@ -12,14 +12,14 @@ class SmartIfTests(unittest.TestCase):
def test_not(self): def test_not(self):
var = IfParser(["not", False]).parse() var = IfParser(["not", False]).parse()
self.assertEqual("(not (literal False))", repr(var)) self.assertEqual("(not (literal False))", repr(var))
self.assert_(var.eval({})) self.assertTrue(var.eval({}))
self.assertFalse(IfParser(["not", True]).parse().eval({})) self.assertFalse(IfParser(["not", True]).parse().eval({}))
def test_or(self): def test_or(self):
var = IfParser([True, "or", False]).parse() var = IfParser([True, "or", False]).parse()
self.assertEqual("(or (literal True) (literal False))", repr(var)) self.assertEqual("(or (literal True) (literal False))", repr(var))
self.assert_(var.eval({})) self.assertTrue(var.eval({}))
def test_in(self): def test_in(self):
list_ = [1,2,3] list_ = [1,2,3]

4
tests/regressiontests/templates/tests.py
View File

@ -359,7 +359,7 @@ class Templates(unittest.TestCase):
except TemplateSyntaxError, e: except TemplateSyntaxError, e:
# Assert that we are getting the template syntax error and not the # Assert that we are getting the template syntax error and not the
# string encoding error. # string encoding error.
self.assertEquals(e.args[0], "Caught NoReverseMatch while rendering: Reverse for 'will_not_match' with arguments '()' and keyword arguments '{}' not found.") self.assertEqual(e.args[0], "Caught NoReverseMatch while rendering: Reverse for 'will_not_match' with arguments '()' and keyword arguments '{}' not found.")
settings.SETTINGS_MODULE = old_settings_module settings.SETTINGS_MODULE = old_settings_module
settings.TEMPLATE_DEBUG = old_template_debug settings.TEMPLATE_DEBUG = old_template_debug
@ -370,7 +370,7 @@ class Templates(unittest.TestCase):
try: try:
t = Template("{% if 1 %}lala{% endblock %}{% endif %}") t = Template("{% if 1 %}lala{% endblock %}{% endif %}")
except TemplateSyntaxError, e: except TemplateSyntaxError, e:
self.assertEquals(e.args[0], "Invalid block tag: 'endblock', expected 'else' or 'endif'") self.assertEqual(e.args[0], "Invalid block tag: 'endblock', expected 'else' or 'endif'")
def test_templates(self): def test_templates(self):
template_tests = self.get_template_tests() template_tests = self.get_template_tests()

40
tests/regressiontests/test_client_regress/models.py
View File

@ -258,8 +258,8 @@ class AssertRedirectsTests(TestCase):
self.assertRedirects(response, '/test_client_regress/no_template_view/', self.assertRedirects(response, '/test_client_regress/no_template_view/',
status_code=301, target_status_code=200) status_code=301, target_status_code=200)
self.assertEquals(len(response.redirect_chain), 1) self.assertEqual(len(response.redirect_chain), 1)
self.assertEquals(response.redirect_chain[0], ('http://testserver/test_client_regress/no_template_view/', 301)) self.assertEqual(response.redirect_chain[0], ('http://testserver/test_client_regress/no_template_view/', 301))
def test_multiple_redirect_chain(self): def test_multiple_redirect_chain(self):
"You can follow a redirect chain of multiple redirects" "You can follow a redirect chain of multiple redirects"
@ -267,10 +267,10 @@ class AssertRedirectsTests(TestCase):
self.assertRedirects(response, '/test_client_regress/no_template_view/', self.assertRedirects(response, '/test_client_regress/no_template_view/',
status_code=301, target_status_code=200) status_code=301, target_status_code=200)
self.assertEquals(len(response.redirect_chain), 3) self.assertEqual(len(response.redirect_chain), 3)
self.assertEquals(response.redirect_chain[0], ('http://testserver/test_client_regress/redirects/further/', 301)) self.assertEqual(response.redirect_chain[0], ('http://testserver/test_client_regress/redirects/further/', 301))
self.assertEquals(response.redirect_chain[1], ('http://testserver/test_client_regress/redirects/further/more/', 301)) self.assertEqual(response.redirect_chain[1], ('http://testserver/test_client_regress/redirects/further/more/', 301))
self.assertEquals(response.redirect_chain[2], ('http://testserver/test_client_regress/no_template_view/', 301)) self.assertEqual(response.redirect_chain[2], ('http://testserver/test_client_regress/no_template_view/', 301))
def test_redirect_chain_to_non_existent(self): def test_redirect_chain_to_non_existent(self):
"You can follow a chain to a non-existent view" "You can follow a chain to a non-existent view"
@ -284,7 +284,7 @@ class AssertRedirectsTests(TestCase):
# The chain of redirects stops once the cycle is detected. # The chain of redirects stops once the cycle is detected.
self.assertRedirects(response, '/test_client_regress/redirect_to_self/', self.assertRedirects(response, '/test_client_regress/redirect_to_self/',
status_code=301, target_status_code=301) status_code=301, target_status_code=301)
self.assertEquals(len(response.redirect_chain), 2) self.assertEqual(len(response.redirect_chain), 2)
def test_circular_redirect(self): def test_circular_redirect(self):
"Circular redirect chains are caught and escaped" "Circular redirect chains are caught and escaped"
@ -292,7 +292,7 @@ class AssertRedirectsTests(TestCase):
# The chain of redirects will get back to the starting point, but stop there. # The chain of redirects will get back to the starting point, but stop there.
self.assertRedirects(response, '/test_client_regress/circular_redirect_2/', self.assertRedirects(response, '/test_client_regress/circular_redirect_2/',
status_code=301, target_status_code=301) status_code=301, target_status_code=301)
self.assertEquals(len(response.redirect_chain), 4) self.assertEqual(len(response.redirect_chain), 4)
def test_redirect_chain_post(self): def test_redirect_chain_post(self):
"A redirect chain will be followed from an initial POST post" "A redirect chain will be followed from an initial POST post"
@ -300,7 +300,7 @@ class AssertRedirectsTests(TestCase):
{'nothing': 'to_send'}, follow=True) {'nothing': 'to_send'}, follow=True)
self.assertRedirects(response, self.assertRedirects(response,
'/test_client_regress/no_template_view/', 301, 200) '/test_client_regress/no_template_view/', 301, 200)
self.assertEquals(len(response.redirect_chain), 3) self.assertEqual(len(response.redirect_chain), 3)
def test_redirect_chain_head(self): def test_redirect_chain_head(self):
"A redirect chain will be followed from an initial HEAD request" "A redirect chain will be followed from an initial HEAD request"
@ -308,7 +308,7 @@ class AssertRedirectsTests(TestCase):
{'nothing': 'to_send'}, follow=True) {'nothing': 'to_send'}, follow=True)
self.assertRedirects(response, self.assertRedirects(response,
'/test_client_regress/no_template_view/', 301, 200) '/test_client_regress/no_template_view/', 301, 200)
self.assertEquals(len(response.redirect_chain), 3) self.assertEqual(len(response.redirect_chain), 3)
def test_redirect_chain_options(self): def test_redirect_chain_options(self):
"A redirect chain will be followed from an initial OPTIONS request" "A redirect chain will be followed from an initial OPTIONS request"
@ -316,7 +316,7 @@ class AssertRedirectsTests(TestCase):
{'nothing': 'to_send'}, follow=True) {'nothing': 'to_send'}, follow=True)
self.assertRedirects(response, self.assertRedirects(response,
'/test_client_regress/no_template_view/', 301, 200) '/test_client_regress/no_template_view/', 301, 200)
self.assertEquals(len(response.redirect_chain), 3) self.assertEqual(len(response.redirect_chain), 3)
def test_redirect_chain_put(self): def test_redirect_chain_put(self):
"A redirect chain will be followed from an initial PUT request" "A redirect chain will be followed from an initial PUT request"
@ -324,7 +324,7 @@ class AssertRedirectsTests(TestCase):
{'nothing': 'to_send'}, follow=True) {'nothing': 'to_send'}, follow=True)
self.assertRedirects(response, self.assertRedirects(response,
'/test_client_regress/no_template_view/', 301, 200) '/test_client_regress/no_template_view/', 301, 200)
self.assertEquals(len(response.redirect_chain), 3) self.assertEqual(len(response.redirect_chain), 3)
def test_redirect_chain_delete(self): def test_redirect_chain_delete(self):
"A redirect chain will be followed from an initial DELETE request" "A redirect chain will be followed from an initial DELETE request"
@ -332,7 +332,7 @@ class AssertRedirectsTests(TestCase):
{'nothing': 'to_send'}, follow=True) {'nothing': 'to_send'}, follow=True)
self.assertRedirects(response, self.assertRedirects(response,
'/test_client_regress/no_template_view/', 301, 200) '/test_client_regress/no_template_view/', 301, 200)
self.assertEquals(len(response.redirect_chain), 3) self.assertEqual(len(response.redirect_chain), 3)
def test_redirect_chain_on_non_redirect_page(self): def test_redirect_chain_on_non_redirect_page(self):
"An assertion is raised if the original page couldn't be retrieved as expected" "An assertion is raised if the original page couldn't be retrieved as expected"
@ -605,7 +605,7 @@ class UrlconfSubstitutionTests(TestCase):
def test_urlconf_was_changed(self): def test_urlconf_was_changed(self):
"TestCase can enforce a custom URLconf on a per-test basis" "TestCase can enforce a custom URLconf on a per-test basis"
url = reverse('arg_view', args=['somename']) url = reverse('arg_view', args=['somename'])
self.assertEquals(url, '/arg_view/somename/') self.assertEqual(url, '/arg_view/somename/')
# This test needs to run *after* UrlconfSubstitutionTests; the zz prefix in the # This test needs to run *after* UrlconfSubstitutionTests; the zz prefix in the
# name is to ensure alphabetical ordering. # name is to ensure alphabetical ordering.
@ -613,7 +613,7 @@ class zzUrlconfSubstitutionTests(TestCase):
def test_urlconf_was_reverted(self): def test_urlconf_was_reverted(self):
"URLconf is reverted to original value after modification in a TestCase" "URLconf is reverted to original value after modification in a TestCase"
url = reverse('arg_view', args=['somename']) url = reverse('arg_view', args=['somename'])
self.assertEquals(url, '/test_client_regress/arg_view/somename/') self.assertEqual(url, '/test_client_regress/arg_view/somename/')
class ContextTests(TestCase): class ContextTests(TestCase):
fixtures = ['testdata'] fixtures = ['testdata']
@ -631,7 +631,7 @@ class ContextTests(TestCase):
response.context['does-not-exist'] response.context['does-not-exist']
self.fail('Should not be able to retrieve non-existent key') self.fail('Should not be able to retrieve non-existent key')
except KeyError, e: except KeyError, e:
self.assertEquals(e.args[0], 'does-not-exist') self.assertEqual(e.args[0], 'does-not-exist')
def test_inherited_context(self): def test_inherited_context(self):
"Context variables can be retrieved from a list of contexts" "Context variables can be retrieved from a list of contexts"
@ -647,7 +647,7 @@ class ContextTests(TestCase):
response.context['does-not-exist'] response.context['does-not-exist']
self.fail('Should not be able to retrieve non-existent key') self.fail('Should not be able to retrieve non-existent key')
except KeyError, e: except KeyError, e:
self.assertEquals(e.args[0], 'does-not-exist') self.assertEqual(e.args[0], 'does-not-exist')
def test_15368(self): def test_15368(self):
# Need to insert a context processor that assumes certain things about # Need to insert a context processor that assumes certain things about
@ -868,13 +868,13 @@ class RequestHeadersTest(TestCase):
def test_client_headers(self): def test_client_headers(self):
"A test client can receive custom headers" "A test client can receive custom headers"
response = self.client.get("/test_client_regress/check_headers/", HTTP_X_ARG_CHECK='Testing 123') response = self.client.get("/test_client_regress/check_headers/", HTTP_X_ARG_CHECK='Testing 123')
self.assertEquals(response.content, "HTTP_X_ARG_CHECK: Testing 123") self.assertEqual(response.content, "HTTP_X_ARG_CHECK: Testing 123")
self.assertEquals(response.status_code, 200) self.assertEqual(response.status_code, 200)
def test_client_headers_redirect(self): def test_client_headers_redirect(self):
"Test client headers are preserved through redirects" "Test client headers are preserved through redirects"
response = self.client.get("/test_client_regress/check_headers_redirect/", follow=True, HTTP_X_ARG_CHECK='Testing 123') response = self.client.get("/test_client_regress/check_headers_redirect/", follow=True, HTTP_X_ARG_CHECK='Testing 123')
self.assertEquals(response.content, "HTTP_X_ARG_CHECK: Testing 123") self.assertEqual(response.content, "HTTP_X_ARG_CHECK: Testing 123")
self.assertRedirects(response, '/test_client_regress/check_headers/', self.assertRedirects(response, '/test_client_regress/check_headers/',
status_code=301, target_status_code=200) status_code=301, target_status_code=200)

44
tests/regressiontests/text/tests.py
View File

@ -23,70 +23,70 @@ class TextTests(TestCase):
def test_smart_split(self): def test_smart_split(self):
self.assertEquals(list(smart_split(r'''This is "a person" test.''')), self.assertEqual(list(smart_split(r'''This is "a person" test.''')),
[u'This', u'is', u'"a person"', u'test.']) [u'This', u'is', u'"a person"', u'test.'])
self.assertEquals(list(smart_split(r'''This is "a person's" test.'''))[2], self.assertEqual(list(smart_split(r'''This is "a person's" test.'''))[2],
u'"a person\'s"') u'"a person\'s"')
self.assertEquals(list(smart_split(r'''This is "a person\"s" test.'''))[2], self.assertEqual(list(smart_split(r'''This is "a person\"s" test.'''))[2],
u'"a person\\"s"') u'"a person\\"s"')
self.assertEquals(list(smart_split('''"a 'one''')), [u'"a', u"'one"]) self.assertEqual(list(smart_split('''"a 'one''')), [u'"a', u"'one"])
self.assertEquals(list(smart_split(r'''all friends' tests'''))[1], self.assertEqual(list(smart_split(r'''all friends' tests'''))[1],
"friends'") "friends'")
self.assertEquals(list(smart_split(u'url search_page words="something else"')), self.assertEqual(list(smart_split(u'url search_page words="something else"')),
[u'url', u'search_page', u'words="something else"']) [u'url', u'search_page', u'words="something else"'])
self.assertEquals(list(smart_split(u"url search_page words='something else'")), self.assertEqual(list(smart_split(u"url search_page words='something else'")),
[u'url', u'search_page', u"words='something else'"]) [u'url', u'search_page', u"words='something else'"])
self.assertEquals(list(smart_split(u'url search_page words "something else"')), self.assertEqual(list(smart_split(u'url search_page words "something else"')),
[u'url', u'search_page', u'words', u'"something else"']) [u'url', u'search_page', u'words', u'"something else"'])
self.assertEquals(list(smart_split(u'url search_page words-"something else"')), self.assertEqual(list(smart_split(u'url search_page words-"something else"')),
[u'url', u'search_page', u'words-"something else"']) [u'url', u'search_page', u'words-"something else"'])
self.assertEquals(list(smart_split(u'url search_page words=hello')), self.assertEqual(list(smart_split(u'url search_page words=hello')),
[u'url', u'search_page', u'words=hello']) [u'url', u'search_page', u'words=hello'])
self.assertEquals(list(smart_split(u'url search_page words="something else')), self.assertEqual(list(smart_split(u'url search_page words="something else')),
[u'url', u'search_page', u'words="something', u'else']) [u'url', u'search_page', u'words="something', u'else'])
self.assertEquals(list(smart_split("cut:','|cut:' '")), self.assertEqual(list(smart_split("cut:','|cut:' '")),
[u"cut:','|cut:' '"]) [u"cut:','|cut:' '"])
def test_urlquote(self): def test_urlquote(self):
self.assertEquals(urlquote(u'Paris & Orl\xe9ans'), self.assertEqual(urlquote(u'Paris & Orl\xe9ans'),
u'Paris%20%26%20Orl%C3%A9ans') u'Paris%20%26%20Orl%C3%A9ans')
self.assertEquals(urlquote(u'Paris & Orl\xe9ans', safe="&"), self.assertEqual(urlquote(u'Paris & Orl\xe9ans', safe="&"),
u'Paris%20&%20Orl%C3%A9ans') u'Paris%20&%20Orl%C3%A9ans')
self.assertEquals(urlquote_plus(u'Paris & Orl\xe9ans'), self.assertEqual(urlquote_plus(u'Paris & Orl\xe9ans'),
u'Paris+%26+Orl%C3%A9ans') u'Paris+%26+Orl%C3%A9ans')
self.assertEquals(urlquote_plus(u'Paris & Orl\xe9ans', safe="&"), self.assertEqual(urlquote_plus(u'Paris & Orl\xe9ans', safe="&"),
u'Paris+&+Orl%C3%A9ans') u'Paris+&+Orl%C3%A9ans')
def test_cookie_date(self): def test_cookie_date(self):
t = 1167616461.0 t = 1167616461.0
self.assertEquals(cookie_date(t), 'Mon, 01-Jan-2007 01:54:21 GMT') self.assertEqual(cookie_date(t), 'Mon, 01-Jan-2007 01:54:21 GMT')
def test_http_date(self): def test_http_date(self):
t = 1167616461.0 t = 1167616461.0
self.assertEquals(http_date(t), 'Mon, 01 Jan 2007 01:54:21 GMT') self.assertEqual(http_date(t), 'Mon, 01 Jan 2007 01:54:21 GMT')
def test_iri_to_uri(self): def test_iri_to_uri(self):
self.assertEquals(iri_to_uri(u'red%09ros\xe9#red'), self.assertEqual(iri_to_uri(u'red%09ros\xe9#red'),
'red%09ros%C3%A9#red') 'red%09ros%C3%A9#red')
self.assertEquals(iri_to_uri(u'/blog/for/J\xfcrgen M\xfcnster/'), self.assertEqual(iri_to_uri(u'/blog/for/J\xfcrgen M\xfcnster/'),
'/blog/for/J%C3%BCrgen%20M%C3%BCnster/') '/blog/for/J%C3%BCrgen%20M%C3%BCnster/')
self.assertEquals(iri_to_uri(u'locations/%s' % urlquote_plus(u'Paris & Orl\xe9ans')), self.assertEqual(iri_to_uri(u'locations/%s' % urlquote_plus(u'Paris & Orl\xe9ans')),
'locations/Paris+%26+Orl%C3%A9ans') 'locations/Paris+%26+Orl%C3%A9ans')
def test_iri_to_uri_idempotent(self): def test_iri_to_uri_idempotent(self):
self.assertEquals(iri_to_uri(iri_to_uri(u'red%09ros\xe9#red')), self.assertEqual(iri_to_uri(iri_to_uri(u'red%09ros\xe9#red')),
'red%09ros%C3%A9#red') 'red%09ros%C3%A9#red')

2
tests/regressiontests/transactions_regress/tests.py
View File

@ -122,7 +122,7 @@ class TestTransactionClosing(TransactionTestCase):
try: try:
# Check that the record is in the DB # Check that the record is in the DB
obj = Mod.objects.get(pk=1) obj = Mod.objects.get(pk=1)
self.assertEquals(obj.fld, 2) self.assertEqual(obj.fld, 2)
except Mod.DoesNotExist: except Mod.DoesNotExist:
self.fail("After ending a transaction, cursor use no longer sets dirty") self.fail("After ending a transaction, cursor use no longer sets dirty")

80
tests/regressiontests/urlpatterns_reverse/tests.py
View File

@ -161,7 +161,7 @@ class URLPatternReverse(TestCase):
except NoReverseMatch, e: except NoReverseMatch, e:
self.assertEqual(expected, NoReverseMatch) self.assertEqual(expected, NoReverseMatch)
else: else:
self.assertEquals(got, expected) self.assertEqual(got, expected)
def test_reverse_none(self): def test_reverse_none(self):
# Reversing None should raise an error, not return the last un-named view. # Reversing None should raise an error, not return the last un-named view.
@ -228,11 +228,11 @@ class ReverseShortcutTests(TestCase):
return "/hi-there/" return "/hi-there/"
res = redirect(FakeObj()) res = redirect(FakeObj())
self.assert_(isinstance(res, HttpResponseRedirect)) self.assertTrue(isinstance(res, HttpResponseRedirect))
self.assertEqual(res['Location'], '/hi-there/') self.assertEqual(res['Location'], '/hi-there/')
res = redirect(FakeObj(), permanent=True) res = redirect(FakeObj(), permanent=True)
self.assert_(isinstance(res, HttpResponsePermanentRedirect)) self.assertTrue(isinstance(res, HttpResponsePermanentRedirect))
self.assertEqual(res['Location'], '/hi-there/') self.assertEqual(res['Location'], '/hi-there/')
def test_redirect_to_view_name(self): def test_redirect_to_view_name(self):
@ -279,67 +279,67 @@ class NamespaceTests(TestCase):
def test_normal_name(self): def test_normal_name(self):
"Normal lookups work as expected" "Normal lookups work as expected"
self.assertEquals('/normal/', reverse('normal-view')) self.assertEqual('/normal/', reverse('normal-view'))
self.assertEquals('/normal/37/42/', reverse('normal-view', args=[37,42])) self.assertEqual('/normal/37/42/', reverse('normal-view', args=[37,42]))
self.assertEquals('/normal/42/37/', reverse('normal-view', kwargs={'arg1':42, 'arg2':37})) self.assertEqual('/normal/42/37/', reverse('normal-view', kwargs={'arg1':42, 'arg2':37}))
def test_simple_included_name(self): def test_simple_included_name(self):
"Normal lookups work on names included from other patterns" "Normal lookups work on names included from other patterns"
self.assertEquals('/included/normal/', reverse('inc-normal-view')) self.assertEqual('/included/normal/', reverse('inc-normal-view'))
self.assertEquals('/included/normal/37/42/', reverse('inc-normal-view', args=[37,42])) self.assertEqual('/included/normal/37/42/', reverse('inc-normal-view', args=[37,42]))
self.assertEquals('/included/normal/42/37/', reverse('inc-normal-view', kwargs={'arg1':42, 'arg2':37})) self.assertEqual('/included/normal/42/37/', reverse('inc-normal-view', kwargs={'arg1':42, 'arg2':37}))
def test_namespace_object(self): def test_namespace_object(self):
"Dynamic URL objects can be found using a namespace" "Dynamic URL objects can be found using a namespace"
self.assertEquals('/test1/inner/', reverse('test-ns1:urlobject-view')) self.assertEqual('/test1/inner/', reverse('test-ns1:urlobject-view'))
self.assertEquals('/test1/inner/37/42/', reverse('test-ns1:urlobject-view', args=[37,42])) self.assertEqual('/test1/inner/37/42/', reverse('test-ns1:urlobject-view', args=[37,42]))
self.assertEquals('/test1/inner/42/37/', reverse('test-ns1:urlobject-view', kwargs={'arg1':42, 'arg2':37})) self.assertEqual('/test1/inner/42/37/', reverse('test-ns1:urlobject-view', kwargs={'arg1':42, 'arg2':37}))
def test_embedded_namespace_object(self): def test_embedded_namespace_object(self):
"Namespaces can be installed anywhere in the URL pattern tree" "Namespaces can be installed anywhere in the URL pattern tree"
self.assertEquals('/included/test3/inner/', reverse('test-ns3:urlobject-view')) self.assertEqual('/included/test3/inner/', reverse('test-ns3:urlobject-view'))
self.assertEquals('/included/test3/inner/37/42/', reverse('test-ns3:urlobject-view', args=[37,42])) self.assertEqual('/included/test3/inner/37/42/', reverse('test-ns3:urlobject-view', args=[37,42]))
self.assertEquals('/included/test3/inner/42/37/', reverse('test-ns3:urlobject-view', kwargs={'arg1':42, 'arg2':37})) self.assertEqual('/included/test3/inner/42/37/', reverse('test-ns3:urlobject-view', kwargs={'arg1':42, 'arg2':37}))
def test_namespace_pattern(self): def test_namespace_pattern(self):
"Namespaces can be applied to include()'d urlpatterns" "Namespaces can be applied to include()'d urlpatterns"
self.assertEquals('/ns-included1/normal/', reverse('inc-ns1:inc-normal-view')) self.assertEqual('/ns-included1/normal/', reverse('inc-ns1:inc-normal-view'))
self.assertEquals('/ns-included1/normal/37/42/', reverse('inc-ns1:inc-normal-view', args=[37,42])) self.assertEqual('/ns-included1/normal/37/42/', reverse('inc-ns1:inc-normal-view', args=[37,42]))
self.assertEquals('/ns-included1/normal/42/37/', reverse('inc-ns1:inc-normal-view', kwargs={'arg1':42, 'arg2':37})) self.assertEqual('/ns-included1/normal/42/37/', reverse('inc-ns1:inc-normal-view', kwargs={'arg1':42, 'arg2':37}))
def test_multiple_namespace_pattern(self): def test_multiple_namespace_pattern(self):
"Namespaces can be embedded" "Namespaces can be embedded"
self.assertEquals('/ns-included1/test3/inner/', reverse('inc-ns1:test-ns3:urlobject-view')) self.assertEqual('/ns-included1/test3/inner/', reverse('inc-ns1:test-ns3:urlobject-view'))
self.assertEquals('/ns-included1/test3/inner/37/42/', reverse('inc-ns1:test-ns3:urlobject-view', args=[37,42])) self.assertEqual('/ns-included1/test3/inner/37/42/', reverse('inc-ns1:test-ns3:urlobject-view', args=[37,42]))
self.assertEquals('/ns-included1/test3/inner/42/37/', reverse('inc-ns1:test-ns3:urlobject-view', kwargs={'arg1':42, 'arg2':37})) self.assertEqual('/ns-included1/test3/inner/42/37/', reverse('inc-ns1:test-ns3:urlobject-view', kwargs={'arg1':42, 'arg2':37}))
def test_nested_namespace_pattern(self): def test_nested_namespace_pattern(self):
"Namespaces can be nested" "Namespaces can be nested"
self.assertEquals('/ns-included1/ns-included4/ns-included1/test3/inner/', reverse('inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view')) self.assertEqual('/ns-included1/ns-included4/ns-included1/test3/inner/', reverse('inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view'))
self.assertEquals('/ns-included1/ns-included4/ns-included1/test3/inner/37/42/', reverse('inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view', args=[37,42])) self.assertEqual('/ns-included1/ns-included4/ns-included1/test3/inner/37/42/', reverse('inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view', args=[37,42]))
self.assertEquals('/ns-included1/ns-included4/ns-included1/test3/inner/42/37/', reverse('inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view', kwargs={'arg1':42, 'arg2':37})) self.assertEqual('/ns-included1/ns-included4/ns-included1/test3/inner/42/37/', reverse('inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view', kwargs={'arg1':42, 'arg2':37}))
def test_app_lookup_object(self): def test_app_lookup_object(self):
"A default application namespace can be used for lookup" "A default application namespace can be used for lookup"
self.assertEquals('/default/inner/', reverse('testapp:urlobject-view')) self.assertEqual('/default/inner/', reverse('testapp:urlobject-view'))
self.assertEquals('/default/inner/37/42/', reverse('testapp:urlobject-view', args=[37,42])) self.assertEqual('/default/inner/37/42/', reverse('testapp:urlobject-view', args=[37,42]))
self.assertEquals('/default/inner/42/37/', reverse('testapp:urlobject-view', kwargs={'arg1':42, 'arg2':37})) self.assertEqual('/default/inner/42/37/', reverse('testapp:urlobject-view', kwargs={'arg1':42, 'arg2':37}))
def test_app_lookup_object_with_default(self): def test_app_lookup_object_with_default(self):
"A default application namespace is sensitive to the 'current' app can be used for lookup" "A default application namespace is sensitive to the 'current' app can be used for lookup"
self.assertEquals('/included/test3/inner/', reverse('testapp:urlobject-view', current_app='test-ns3')) self.assertEqual('/included/test3/inner/', reverse('testapp:urlobject-view', current_app='test-ns3'))
self.assertEquals('/included/test3/inner/37/42/', reverse('testapp:urlobject-view', args=[37,42], current_app='test-ns3')) self.assertEqual('/included/test3/inner/37/42/', reverse('testapp:urlobject-view', args=[37,42], current_app='test-ns3'))
self.assertEquals('/included/test3/inner/42/37/', reverse('testapp:urlobject-view', kwargs={'arg1':42, 'arg2':37}, current_app='test-ns3')) self.assertEqual('/included/test3/inner/42/37/', reverse('testapp:urlobject-view', kwargs={'arg1':42, 'arg2':37}, current_app='test-ns3'))
def test_app_lookup_object_without_default(self): def test_app_lookup_object_without_default(self):
"An application namespace without a default is sensitive to the 'current' app can be used for lookup" "An application namespace without a default is sensitive to the 'current' app can be used for lookup"
self.assertEquals('/other2/inner/', reverse('nodefault:urlobject-view')) self.assertEqual('/other2/inner/', reverse('nodefault:urlobject-view'))
self.assertEquals('/other2/inner/37/42/', reverse('nodefault:urlobject-view', args=[37,42])) self.assertEqual('/other2/inner/37/42/', reverse('nodefault:urlobject-view', args=[37,42]))
self.assertEquals('/other2/inner/42/37/', reverse('nodefault:urlobject-view', kwargs={'arg1':42, 'arg2':37})) self.assertEqual('/other2/inner/42/37/', reverse('nodefault:urlobject-view', kwargs={'arg1':42, 'arg2':37}))
self.assertEquals('/other1/inner/', reverse('nodefault:urlobject-view', current_app='other-ns1')) self.assertEqual('/other1/inner/', reverse('nodefault:urlobject-view', current_app='other-ns1'))
self.assertEquals('/other1/inner/37/42/', reverse('nodefault:urlobject-view', args=[37,42], current_app='other-ns1')) self.assertEqual('/other1/inner/37/42/', reverse('nodefault:urlobject-view', args=[37,42], current_app='other-ns1'))
self.assertEquals('/other1/inner/42/37/', reverse('nodefault:urlobject-view', kwargs={'arg1':42, 'arg2':37}, current_app='other-ns1')) self.assertEqual('/other1/inner/42/37/', reverse('nodefault:urlobject-view', kwargs={'arg1':42, 'arg2':37}, current_app='other-ns1'))
class RequestURLconfTests(TestCase): class RequestURLconfTests(TestCase):
def setUp(self): def setUp(self):
@ -408,7 +408,7 @@ class DefaultErrorHandlerTests(TestCase):
"If the urls.py doesn't specify handlers, the defaults are used" "If the urls.py doesn't specify handlers, the defaults are used"
try: try:
response = self.client.get('/test/') response = self.client.get('/test/')
self.assertEquals(response.status_code, 404) self.assertEqual(response.status_code, 404)
except AttributeError: except AttributeError:
self.fail("Shouldn't get an AttributeError due to undefined 404 handler") self.fail("Shouldn't get an AttributeError due to undefined 404 handler")
@ -446,6 +446,6 @@ class ResolverMatchTests(TestCase):
self.assertEqual(match.func, func) self.assertEqual(match.func, func)
# ... and for legacy purposes: # ... and for legacy purposes:
self.assertEquals(match[0], func) self.assertEqual(match[0], func)
self.assertEquals(match[1], args) self.assertEqual(match[1], args)
self.assertEquals(match[2], kwargs) self.assertEqual(match[2], kwargs)

96
tests/regressiontests/utils/datastructures.py
View File

@ -32,19 +32,19 @@ class SortedDictTests(DatastructuresTestCase):
self.d2[7] = 'seven' self.d2[7] = 'seven'
def test_basic_methods(self): def test_basic_methods(self):
self.assertEquals(self.d1.keys(), [7, 1, 9]) self.assertEqual(self.d1.keys(), [7, 1, 9])
self.assertEquals(self.d1.values(), ['seven', 'one', 'nine']) self.assertEqual(self.d1.values(), ['seven', 'one', 'nine'])
self.assertEquals(self.d1.items(), [(7, 'seven'), (1, 'one'), (9, 'nine')]) self.assertEqual(self.d1.items(), [(7, 'seven'), (1, 'one'), (9, 'nine')])
def test_overwrite_ordering(self): def test_overwrite_ordering(self):
""" Overwriting an item keeps it's place. """ """ Overwriting an item keeps it's place. """
self.d1[1] = 'ONE' self.d1[1] = 'ONE'
self.assertEquals(self.d1.values(), ['seven', 'ONE', 'nine']) self.assertEqual(self.d1.values(), ['seven', 'ONE', 'nine'])
def test_append_items(self): def test_append_items(self):
""" New items go to the end. """ """ New items go to the end. """
self.d1[0] = 'nil' self.d1[0] = 'nil'
self.assertEquals(self.d1.keys(), [7, 1, 9, 0]) self.assertEqual(self.d1.keys(), [7, 1, 9, 0])
def test_delete_and_insert(self): def test_delete_and_insert(self):
""" """
@ -52,9 +52,9 @@ class SortedDictTests(DatastructuresTestCase):
at the end. at the end.
""" """
del self.d2[7] del self.d2[7]
self.assertEquals(self.d2.keys(), [1, 9, 0]) self.assertEqual(self.d2.keys(), [1, 9, 0])
self.d2[7] = 'lucky number 7' self.d2[7] = 'lucky number 7'
self.assertEquals(self.d2.keys(), [1, 9, 0, 7]) self.assertEqual(self.d2.keys(), [1, 9, 0, 7])
def test_change_keys(self): def test_change_keys(self):
""" """
@ -63,7 +63,7 @@ class SortedDictTests(DatastructuresTestCase):
""" """
k = self.d2.keys() k = self.d2.keys()
k.remove(9) k.remove(9)
self.assertEquals(self.d2.keys(), [1, 9, 0, 7]) self.assertEqual(self.d2.keys(), [1, 9, 0, 7])
def test_init_keys(self): def test_init_keys(self):
""" """
@ -75,13 +75,13 @@ class SortedDictTests(DatastructuresTestCase):
tuples = ((2, 'two'), (1, 'one'), (2, 'second-two')) tuples = ((2, 'two'), (1, 'one'), (2, 'second-two'))
d = SortedDict(tuples) d = SortedDict(tuples)
self.assertEquals(d.keys(), [2, 1]) self.assertEqual(d.keys(), [2, 1])
real_dict = dict(tuples) real_dict = dict(tuples)
self.assertEquals(sorted(real_dict.values()), ['one', 'second-two']) self.assertEqual(sorted(real_dict.values()), ['one', 'second-two'])
# Here the order of SortedDict values *is* what we are testing # Here the order of SortedDict values *is* what we are testing
self.assertEquals(d.values(), ['second-two', 'one']) self.assertEqual(d.values(), ['second-two', 'one'])
def test_overwrite(self): def test_overwrite(self):
self.d1[1] = 'not one' self.d1[1] = 'not one'
@ -90,39 +90,39 @@ class SortedDictTests(DatastructuresTestCase):
def test_append(self): def test_append(self):
self.d1[13] = 'thirteen' self.d1[13] = 'thirteen'
self.assertEquals( self.assertEqual(
repr(self.d1), repr(self.d1),
"{7: 'seven', 1: 'one', 9: 'nine', 13: 'thirteen'}" "{7: 'seven', 1: 'one', 9: 'nine', 13: 'thirteen'}"
) )
def test_pop(self): def test_pop(self):
self.assertEquals(self.d1.pop(1, 'missing'), 'one') self.assertEqual(self.d1.pop(1, 'missing'), 'one')
self.assertEquals(self.d1.pop(1, 'missing'), 'missing') self.assertEqual(self.d1.pop(1, 'missing'), 'missing')
# We don't know which item will be popped in popitem(), so we'll # We don't know which item will be popped in popitem(), so we'll
# just check that the number of keys has decreased. # just check that the number of keys has decreased.
l = len(self.d1) l = len(self.d1)
self.d1.popitem() self.d1.popitem()
self.assertEquals(l - len(self.d1), 1) self.assertEqual(l - len(self.d1), 1)
def test_dict_equality(self): def test_dict_equality(self):
d = SortedDict((i, i) for i in xrange(3)) d = SortedDict((i, i) for i in xrange(3))
self.assertEquals(d, {0: 0, 1: 1, 2: 2}) self.assertEqual(d, {0: 0, 1: 1, 2: 2})
def test_tuple_init(self): def test_tuple_init(self):
d = SortedDict(((1, "one"), (0, "zero"), (2, "two"))) d = SortedDict(((1, "one"), (0, "zero"), (2, "two")))
self.assertEquals(repr(d), "{1: 'one', 0: 'zero', 2: 'two'}") self.assertEqual(repr(d), "{1: 'one', 0: 'zero', 2: 'two'}")
def test_pickle(self): def test_pickle(self):
self.assertEquals( self.assertEqual(
pickle.loads(pickle.dumps(self.d1, 2)), pickle.loads(pickle.dumps(self.d1, 2)),
{7: 'seven', 1: 'one', 9: 'nine'} {7: 'seven', 1: 'one', 9: 'nine'}
) )
def test_clear(self): def test_clear(self):
self.d1.clear() self.d1.clear()
self.assertEquals(self.d1, {}) self.assertEqual(self.d1, {})
self.assertEquals(self.d1.keyOrder, []) self.assertEqual(self.d1.keyOrder, [])
class MergeDictTests(DatastructuresTestCase): class MergeDictTests(DatastructuresTestCase):
@ -140,12 +140,12 @@ class MergeDictTests(DatastructuresTestCase):
md = MergeDict(d1, d2, d3) md = MergeDict(d1, d2, d3)
self.assertEquals(md['chris'], 'cool') self.assertEqual(md['chris'], 'cool')
self.assertEquals(md['camri'], 'cute') self.assertEqual(md['camri'], 'cute')
self.assertEquals(md['twoofme'], 'firstone') self.assertEqual(md['twoofme'], 'firstone')
md2 = md.copy() md2 = md.copy()
self.assertEquals(md2['chris'], 'cool') self.assertEqual(md2['chris'], 'cool')
def test_mergedict_merges_multivaluedict(self): def test_mergedict_merges_multivaluedict(self):
""" MergeDict can merge MultiValueDicts """ """ MergeDict can merge MultiValueDicts """
@ -160,20 +160,20 @@ class MergeDictTests(DatastructuresTestCase):
# Although 'key2' appears in both dictionaries, # Although 'key2' appears in both dictionaries,
# only the first value is used. # only the first value is used.
self.assertEquals(mm.getlist('key2'), ['value2', 'value3']) self.assertEqual(mm.getlist('key2'), ['value2', 'value3'])
self.assertEquals(mm.getlist('key4'), ['value5', 'value6']) self.assertEqual(mm.getlist('key4'), ['value5', 'value6'])
self.assertEquals(mm.getlist('undefined'), []) self.assertEqual(mm.getlist('undefined'), [])
self.assertEquals(sorted(mm.keys()), ['key1', 'key2', 'key4']) self.assertEqual(sorted(mm.keys()), ['key1', 'key2', 'key4'])
self.assertEquals(len(mm.values()), 3) self.assertEqual(len(mm.values()), 3)
self.assertTrue('value1' in mm.values()) self.assertTrue('value1' in mm.values())
self.assertEquals(sorted(mm.items(), key=lambda k: k[0]), self.assertEqual(sorted(mm.items(), key=lambda k: k[0]),
[('key1', 'value1'), ('key2', 'value3'), [('key1', 'value1'), ('key2', 'value3'),
('key4', 'value6')]) ('key4', 'value6')])
self.assertEquals([(k,mm.getlist(k)) for k in sorted(mm)], self.assertEqual([(k,mm.getlist(k)) for k in sorted(mm)],
[('key1', ['value1']), [('key1', ['value1']),
('key2', ['value2', 'value3']), ('key2', ['value2', 'value3']),
('key4', ['value5', 'value6'])]) ('key4', ['value5', 'value6'])])
@ -184,13 +184,13 @@ class MultiValueDictTests(DatastructuresTestCase):
d = MultiValueDict({'name': ['Adrian', 'Simon'], d = MultiValueDict({'name': ['Adrian', 'Simon'],
'position': ['Developer']}) 'position': ['Developer']})
self.assertEquals(d['name'], 'Simon') self.assertEqual(d['name'], 'Simon')
self.assertEquals(d.get('name'), 'Simon') self.assertEqual(d.get('name'), 'Simon')
self.assertEquals(d.getlist('name'), ['Adrian', 'Simon']) self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
self.assertEquals(list(d.iteritems()), self.assertEqual(list(d.iteritems()),
[('position', 'Developer'), ('name', 'Simon')]) [('position', 'Developer'), ('name', 'Simon')])
self.assertEquals(list(d.iterlists()), self.assertEqual(list(d.iterlists()),
[('position', ['Developer']), [('position', ['Developer']),
('name', ['Adrian', 'Simon'])]) ('name', ['Adrian', 'Simon'])])
@ -202,14 +202,14 @@ class MultiValueDictTests(DatastructuresTestCase):
' [\'Developer\'], \'name\': [\'Adrian\', \'Simon\']}>"', ' [\'Developer\'], \'name\': [\'Adrian\', \'Simon\']}>"',
d.__getitem__, 'lastname') d.__getitem__, 'lastname')
self.assertEquals(d.get('lastname'), None) self.assertEqual(d.get('lastname'), None)
self.assertEquals(d.get('lastname', 'nonexistent'), 'nonexistent') self.assertEqual(d.get('lastname', 'nonexistent'), 'nonexistent')
self.assertEquals(d.getlist('lastname'), []) self.assertEqual(d.getlist('lastname'), [])
d.setlist('lastname', ['Holovaty', 'Willison']) d.setlist('lastname', ['Holovaty', 'Willison'])
self.assertEquals(d.getlist('lastname'), ['Holovaty', 'Willison']) self.assertEqual(d.getlist('lastname'), ['Holovaty', 'Willison'])
self.assertEquals(d.values(), ['Developer', 'Simon', 'Willison']) self.assertEqual(d.values(), ['Developer', 'Simon', 'Willison'])
self.assertEquals(list(d.itervalues()), self.assertEqual(list(d.itervalues()),
['Developer', 'Simon', 'Willison']) ['Developer', 'Simon', 'Willison'])
def test_copy(self): def test_copy(self):
@ -242,9 +242,9 @@ class DotExpandedDictTests(DatastructuresTestCase):
'person.2.firstname': ['Adrian'], 'person.2.firstname': ['Adrian'],
'person.2.lastname': ['Holovaty']}) 'person.2.lastname': ['Holovaty']})
self.assertEquals(d['person']['1']['lastname'], ['Willison']) self.assertEqual(d['person']['1']['lastname'], ['Willison'])
self.assertEquals(d['person']['2']['lastname'], ['Holovaty']) self.assertEqual(d['person']['2']['lastname'], ['Holovaty'])
self.assertEquals(d['person']['2']['firstname'], ['Adrian']) self.assertEqual(d['person']['2']['firstname'], ['Adrian'])
class ImmutableListTests(DatastructuresTestCase): class ImmutableListTests(DatastructuresTestCase):
@ -256,12 +256,12 @@ class ImmutableListTests(DatastructuresTestCase):
self.assertRaisesErrorWithMessage(AttributeError, self.assertRaisesErrorWithMessage(AttributeError,
'ImmutableList object is immutable.', d.sort) 'ImmutableList object is immutable.', d.sort)
self.assertEquals(repr(d), '(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)') self.assertEqual(repr(d), '(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)')
def test_custom_warning(self): def test_custom_warning(self):
d = ImmutableList(range(10), warning="Object is immutable!") d = ImmutableList(range(10), warning="Object is immutable!")
self.assertEquals(d[1], 1) self.assertEqual(d[1], 1)
# AttributeError: Object is immutable! # AttributeError: Object is immutable!
self.assertRaisesErrorWithMessage(AttributeError, self.assertRaisesErrorWithMessage(AttributeError,
@ -273,5 +273,5 @@ class DictWrapperTests(DatastructuresTestCase):
def test_dictwrapper(self): def test_dictwrapper(self):
f = lambda x: "*%s" % x f = lambda x: "*%s" % x
d = DictWrapper({'a': 'a'}, f, 'xx_') d = DictWrapper({'a': 'a'}, f, 'xx_')
self.assertEquals("Normal: %(a)s. Modified: %(xx_a)s" % d, self.assertEqual("Normal: %(a)s. Modified: %(xx_a)s" % d,
'Normal: a. Modified: *a') 'Normal: a. Modified: *a')

90
tests/regressiontests/utils/dateformat.py
View File

@ -33,82 +33,82 @@ class DateFormatTests(unittest.TestCase):
def test_date(self): def test_date(self):
d = date(2009, 5, 16) d = date(2009, 5, 16)
self.assertEquals(date.fromtimestamp(int(format(d, 'U'))), d) self.assertEqual(date.fromtimestamp(int(format(d, 'U'))), d)
def test_naive_datetime(self): def test_naive_datetime(self):
dt = datetime(2009, 5, 16, 5, 30, 30) dt = datetime(2009, 5, 16, 5, 30, 30)
self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U'))), dt) self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U'))), dt)
def test_datetime_with_local_tzinfo(self): def test_datetime_with_local_tzinfo(self):
ltz = LocalTimezone(datetime.now()) ltz = LocalTimezone(datetime.now())
dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=ltz) dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=ltz)
self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), ltz), dt) self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U')), ltz), dt)
self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U'))), dt.replace(tzinfo=None)) self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U'))), dt.replace(tzinfo=None))
def test_datetime_with_tzinfo(self): def test_datetime_with_tzinfo(self):
tz = FixedOffset(-510) tz = FixedOffset(-510)
ltz = LocalTimezone(datetime.now()) ltz = LocalTimezone(datetime.now())
dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=tz) dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=tz)
self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), tz), dt) self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U')), tz), dt)
self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), ltz), dt) self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U')), ltz), dt)
self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U'))), dt.astimezone(ltz).replace(tzinfo=None)) self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U'))), dt.astimezone(ltz).replace(tzinfo=None))
self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), tz).utctimetuple(), dt.utctimetuple()) self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U')), tz).utctimetuple(), dt.utctimetuple())
self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), ltz).utctimetuple(), dt.utctimetuple()) self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U')), ltz).utctimetuple(), dt.utctimetuple())
def test_epoch(self): def test_epoch(self):
utc = FixedOffset(0) utc = FixedOffset(0)
udt = datetime(1970, 1, 1, tzinfo=utc) udt = datetime(1970, 1, 1, tzinfo=utc)
self.assertEquals(format(udt, 'U'), u'0') self.assertEqual(format(udt, 'U'), u'0')
def test_empty_format(self): def test_empty_format(self):
my_birthday = datetime(1979, 7, 8, 22, 00) my_birthday = datetime(1979, 7, 8, 22, 00)
self.assertEquals(dateformat.format(my_birthday, ''), u'') self.assertEqual(dateformat.format(my_birthday, ''), u'')
def test_am_pm(self): def test_am_pm(self):
my_birthday = datetime(1979, 7, 8, 22, 00) my_birthday = datetime(1979, 7, 8, 22, 00)
self.assertEquals(dateformat.format(my_birthday, 'a'), u'p.m.') self.assertEqual(dateformat.format(my_birthday, 'a'), u'p.m.')
def test_date_formats(self): def test_date_formats(self):
my_birthday = datetime(1979, 7, 8, 22, 00) my_birthday = datetime(1979, 7, 8, 22, 00)
timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456) timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456)
self.assertEquals(dateformat.format(my_birthday, 'A'), u'PM') self.assertEqual(dateformat.format(my_birthday, 'A'), u'PM')
self.assertEquals(dateformat.format(timestamp, 'c'), u'2008-05-19T11:45:23.123456') self.assertEqual(dateformat.format(timestamp, 'c'), u'2008-05-19T11:45:23.123456')
self.assertEquals(dateformat.format(my_birthday, 'd'), u'08') self.assertEqual(dateformat.format(my_birthday, 'd'), u'08')
self.assertEquals(dateformat.format(my_birthday, 'j'), u'8') self.assertEqual(dateformat.format(my_birthday, 'j'), u'8')
self.assertEquals(dateformat.format(my_birthday, 'l'), u'Sunday') self.assertEqual(dateformat.format(my_birthday, 'l'), u'Sunday')
self.assertEquals(dateformat.format(my_birthday, 'L'), u'False') self.assertEqual(dateformat.format(my_birthday, 'L'), u'False')
self.assertEquals(dateformat.format(my_birthday, 'm'), u'07') self.assertEqual(dateformat.format(my_birthday, 'm'), u'07')
self.assertEquals(dateformat.format(my_birthday, 'M'), u'Jul') self.assertEqual(dateformat.format(my_birthday, 'M'), u'Jul')
self.assertEquals(dateformat.format(my_birthday, 'b'), u'jul') self.assertEqual(dateformat.format(my_birthday, 'b'), u'jul')
self.assertEquals(dateformat.format(my_birthday, 'n'), u'7') self.assertEqual(dateformat.format(my_birthday, 'n'), u'7')
self.assertEquals(dateformat.format(my_birthday, 'N'), u'July') self.assertEqual(dateformat.format(my_birthday, 'N'), u'July')
def test_time_formats(self): def test_time_formats(self):
my_birthday = datetime(1979, 7, 8, 22, 00) my_birthday = datetime(1979, 7, 8, 22, 00)
self.assertEquals(dateformat.format(my_birthday, 'P'), u'10 p.m.') self.assertEqual(dateformat.format(my_birthday, 'P'), u'10 p.m.')
self.assertEquals(dateformat.format(my_birthday, 's'), u'00') self.assertEqual(dateformat.format(my_birthday, 's'), u'00')
self.assertEquals(dateformat.format(my_birthday, 'S'), u'th') self.assertEqual(dateformat.format(my_birthday, 'S'), u'th')
self.assertEquals(dateformat.format(my_birthday, 't'), u'31') self.assertEqual(dateformat.format(my_birthday, 't'), u'31')
self.assertEquals(dateformat.format(my_birthday, 'w'), u'0') self.assertEqual(dateformat.format(my_birthday, 'w'), u'0')
self.assertEquals(dateformat.format(my_birthday, 'W'), u'27') self.assertEqual(dateformat.format(my_birthday, 'W'), u'27')
self.assertEquals(dateformat.format(my_birthday, 'y'), u'79') self.assertEqual(dateformat.format(my_birthday, 'y'), u'79')
self.assertEquals(dateformat.format(my_birthday, 'Y'), u'1979') self.assertEqual(dateformat.format(my_birthday, 'Y'), u'1979')
self.assertEquals(dateformat.format(my_birthday, 'z'), u'189') self.assertEqual(dateformat.format(my_birthday, 'z'), u'189')
def test_dateformat(self): def test_dateformat(self):
my_birthday = datetime(1979, 7, 8, 22, 00) my_birthday = datetime(1979, 7, 8, 22, 00)
self.assertEquals(dateformat.format(my_birthday, r'Y z \C\E\T'), u'1979 189 CET') self.assertEqual(dateformat.format(my_birthday, r'Y z \C\E\T'), u'1979 189 CET')
self.assertEquals(dateformat.format(my_birthday, r'jS o\f F'), u'8th of July') self.assertEqual(dateformat.format(my_birthday, r'jS o\f F'), u'8th of July')
def test_futuredates(self): def test_futuredates(self):
the_future = datetime(2100, 10, 25, 0, 00) the_future = datetime(2100, 10, 25, 0, 00)
self.assertEquals(dateformat.format(the_future, r'Y'), u'2100') self.assertEqual(dateformat.format(the_future, r'Y'), u'2100')
def test_timezones(self): def test_timezones(self):
my_birthday = datetime(1979, 7, 8, 22, 00) my_birthday = datetime(1979, 7, 8, 22, 00)
@ -117,13 +117,13 @@ class DateFormatTests(unittest.TestCase):
timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456) timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456)
if self.tz_tests: if self.tz_tests:
self.assertEquals(dateformat.format(my_birthday, 'O'), u'+0100') self.assertEqual(dateformat.format(my_birthday, 'O'), u'+0100')
self.assertEquals(dateformat.format(my_birthday, 'r'), u'Sun, 8 Jul 1979 22:00:00 +0100') self.assertEqual(dateformat.format(my_birthday, 'r'), u'Sun, 8 Jul 1979 22:00:00 +0100')
self.assertEquals(dateformat.format(my_birthday, 'T'), u'CET') self.assertEqual(dateformat.format(my_birthday, 'T'), u'CET')
self.assertEquals(dateformat.format(my_birthday, 'U'), u'300315600') self.assertEqual(dateformat.format(my_birthday, 'U'), u'300315600')
self.assertEquals(dateformat.format(timestamp, 'u'), u'123456') self.assertEqual(dateformat.format(timestamp, 'u'), u'123456')
self.assertEquals(dateformat.format(my_birthday, 'Z'), u'3600') self.assertEqual(dateformat.format(my_birthday, 'Z'), u'3600')
self.assertEquals(dateformat.format(summertime, 'I'), u'1') self.assertEqual(dateformat.format(summertime, 'I'), u'1')
self.assertEquals(dateformat.format(summertime, 'O'), u'+0200') self.assertEqual(dateformat.format(summertime, 'O'), u'+0200')
self.assertEquals(dateformat.format(wintertime, 'I'), u'0') self.assertEqual(dateformat.format(wintertime, 'I'), u'0')
self.assertEquals(dateformat.format(wintertime, 'O'), u'+0100') self.assertEqual(dateformat.format(wintertime, 'O'), u'+0100')

16
tests/regressiontests/utils/datetime_safe.py
View File

@ -21,17 +21,17 @@ class DatetimeTests(unittest.TestCase):
self.assertEqual(original_datetime(*self.just_safe).strftime('%Y-%m-%d'), datetime(*self.just_safe).strftime('%Y-%m-%d')) self.assertEqual(original_datetime(*self.just_safe).strftime('%Y-%m-%d'), datetime(*self.just_safe).strftime('%Y-%m-%d'))
def test_safe_strftime(self): def test_safe_strftime(self):
self.assertEquals(date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'), '1899-12-31 (weekday 0)') self.assertEqual(date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'), '1899-12-31 (weekday 0)')
self.assertEquals(date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'), '1900-01-01 (weekday 1)') self.assertEqual(date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'), '1900-01-01 (weekday 1)')
self.assertEquals(datetime(*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1899-12-31 23:59:59 (weekday 0)') self.assertEqual(datetime(*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1899-12-31 23:59:59 (weekday 0)')
self.assertEquals(datetime(*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1900-01-01 00:00:00 (weekday 1)') self.assertEqual(datetime(*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1900-01-01 00:00:00 (weekday 1)')
# %y will error before this date # %y will error before this date
self.assertEquals(date(*self.just_safe).strftime('%y'), '00') self.assertEqual(date(*self.just_safe).strftime('%y'), '00')
self.assertEquals(datetime(*self.just_safe).strftime('%y'), '00') self.assertEqual(datetime(*self.just_safe).strftime('%y'), '00')
self.assertEquals(date(1850, 8, 2).strftime("%Y/%m/%d was a %A"), '1850/08/02 was a Friday') self.assertEqual(date(1850, 8, 2).strftime("%Y/%m/%d was a %A"), '1850/08/02 was a Friday')
def test_zero_padding(self): def test_zero_padding(self):
""" """
@ -39,4 +39,4 @@ class DatetimeTests(unittest.TestCase):
Check that pre-1000AD dates are padded with zeros if necessary Check that pre-1000AD dates are padded with zeros if necessary
""" """
self.assertEquals(date(1, 1, 1).strftime("%Y/%m/%d was a %A"), '0001/01/01 was a Monday') self.assertEqual(date(1, 1, 1).strftime("%Y/%m/%d was a %A"), '0001/01/01 was a Monday')

2
tests/regressiontests/utils/simplelazyobject.py
View File

@ -46,7 +46,7 @@ class TestUtilsSimpleLazyObject(unittest.TestCase):
# For debugging, it will really confuse things if there is no clue that # For debugging, it will really confuse things if there is no clue that
# SimpleLazyObject is actually a proxy object. So we don't # SimpleLazyObject is actually a proxy object. So we don't
# proxy __repr__ # proxy __repr__
self.assert_("SimpleLazyObject" in repr(SimpleLazyObject(complex_object))) self.assertTrue("SimpleLazyObject" in repr(SimpleLazyObject(complex_object)))
def test_str(self): def test_str(self):
self.assertEqual("I am _ComplexObject('joe')", str(SimpleLazyObject(complex_object))) self.assertEqual("I am _ComplexObject('joe')", str(SimpleLazyObject(complex_object)))

Some files were not shown because too many files have changed in this diff Show More