From efe1d009e9b7500a20c07ec3ed19fc39f97c1a6a Mon Sep 17 00:00:00 2001 From: Norbert Kwizera Date: Tue, 5 Dec 2023 17:55:23 +0200 Subject: [PATCH] Replace self.assertEquals with self.assertEqual --- smartmin/csv_imports/tests.py | 14 +-- smartmin/tests.py | 8 +- test_runner/blog/tests.py | 176 +++++++++++++++++----------------- 3 files changed, 99 insertions(+), 99 deletions(-) diff --git a/smartmin/csv_imports/tests.py b/smartmin/csv_imports/tests.py index 0f08212..b333b40 100644 --- a/smartmin/csv_imports/tests.py +++ b/smartmin/csv_imports/tests.py @@ -8,16 +8,16 @@ def test_csv_import(self): pass def test_generate_file_path(self): - self.assertEquals(generate_file_path(ImportTask(), "allo.csv"), "csv_imports/allo.csv") - self.assertEquals(generate_file_path(ImportTask(), "allo.xlsx"), "csv_imports/allo.xlsx") - self.assertEquals(generate_file_path(ImportTask(), "allo.foo.bar"), "csv_imports/allo.foo.bar") + self.assertEqual(generate_file_path(ImportTask(), "allo.csv"), "csv_imports/allo.csv") + self.assertEqual(generate_file_path(ImportTask(), "allo.xlsx"), "csv_imports/allo.xlsx") + self.assertEqual(generate_file_path(ImportTask(), "allo.foo.bar"), "csv_imports/allo.foo.bar") long_name = "foo" * 100 test_file_name = "%s.xls.csv" % long_name - self.assertEquals(len(generate_file_path(ImportTask(), test_file_name)), 100) - self.assertEquals(generate_file_path(ImportTask(), test_file_name), "csv_imports/%s.csv" % long_name[:84]) + self.assertEqual(len(generate_file_path(ImportTask(), test_file_name)), 100) + self.assertEqual(generate_file_path(ImportTask(), test_file_name), "csv_imports/%s.csv" % long_name[:84]) test_file_name = "%s.abc.xlsx" % long_name - self.assertEquals(len(generate_file_path(ImportTask(), test_file_name)), 100) - self.assertEquals(generate_file_path(ImportTask(), test_file_name), "csv_imports/%s.xlsx" % long_name[:83]) + self.assertEqual(len(generate_file_path(ImportTask(), test_file_name)), 100) + self.assertEqual(generate_file_path(ImportTask(), test_file_name), "csv_imports/%s.xlsx" % long_name[:83]) diff --git a/smartmin/tests.py b/smartmin/tests.py index 531b5a1..b2eebd2 100644 --- a/smartmin/tests.py +++ b/smartmin/tests.py @@ -26,14 +26,14 @@ def fetch_protected(self, url, user, post_data=None, failOnFormValidation=True): # but now we can! if not post_data: response = self.client.get(url) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) else: response = self.client.post(url, data=post_data) self.assertNotRedirect(response, reverse("users.user_login"), msg="Unexpected redirect to login") if failOnFormValidation: self.assertNoFormErrors(response, post_data) - self.assertEquals(302, response.status_code) + self.assertEqual(302, response.status_code) return response @@ -162,7 +162,7 @@ def testDelete(self): return object = self.getTestObject() self._do_test_view("delete", object, post_data=dict()) - self.assertEquals(0, len(self.getManager().filter(pk=object.pk))) + self.assertEqual(0, len(self.getManager().filter(pk=object.pk))) def testList(self): if "list" not in self.getCRUDL().actions: @@ -222,7 +222,7 @@ def _do_test_view(self, action=None, object=None, post_data=None, query_string=N def assertPageGet(self, action, response): if response.status_code == 302: self.fail("'%s' resulted in an unexpected redirect to: %s" % (action, response.get("Location"))) - self.assertEquals( + self.assertEqual( 200, response.status_code, ) diff --git a/test_runner/blog/tests.py b/test_runner/blog/tests.py index 978614a..6644d2c 100644 --- a/test_runner/blog/tests.py +++ b/test_runner/blog/tests.py @@ -65,7 +65,7 @@ def assertNoAccess(self, user, url): def assertHasAccess(self, user, url): self.client.login(username=user.username, password=user.username) response = self.client.get(url) - self.assertEquals(200, response.status_code, "User '%s' does not have access to URL: %s" % (user.username, url)) + self.assertEqual(200, response.status_code, "User '%s' does not have access to URL: %s" % (user.username, url)) def assertIsLogin(self, response): self.assertRedirect(response, reverse("users.user_login")) @@ -123,7 +123,7 @@ def test_permissions(self): # even users not logged in can read self.client.logout() response = self.client.get(read_url) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) # along with everyone else self.assertHasAccess(self.plain, read_url) @@ -169,11 +169,11 @@ def test_create_and_update(self): # get the last post post = list(Post.objects.all())[-1] - self.assertEquals("New Post", post.title) - self.assertEquals("This is a new post", post.body) - self.assertEquals("post", post.tags) - self.assertEquals(self.author, post.created_by) - self.assertEquals(self.author, post.modified_by) + self.assertEqual("New Post", post.title) + self.assertEqual("This is a new post", post.body) + self.assertEqual("post", post.tags) + self.assertEqual(self.author, post.created_by) + self.assertEqual(self.author, post.modified_by) def test_messaging(self): self.client.login(username="author", password="author") @@ -183,13 +183,13 @@ def test_messaging(self): post = list(Post.objects.all())[-1] - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) self.assertContains(response, "Your new post has been created.") post_data = dict(title="New Post", body="Updated post content", order=1, tags="post") response = self.client.post(reverse("blog.post_update", args=[post.id]), post_data, follow=True) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) self.assertContains(response, "Your blog post has been updated.") def test_message_tags(self): @@ -205,7 +205,7 @@ def test_message_tags(self): def test_template_name(self): self.client.login(username="author", password="author") response = self.client.get(reverse("blog.post_list")) - self.assertEquals(["blog/post_list.html", "smartmin/list.html"], response.template_name) + self.assertEqual(["blog/post_list.html", "smartmin/list.html"], response.template_name) def test_read(self): post = Post.objects.create( @@ -409,7 +409,7 @@ def test_success_url(self): post_data = dict(title="New Post", body="This is a new post", order=1, tags="post") response = self.client.post(reverse("blog.post_create"), post_data, follow=True) - self.assertEquals(reverse("blog.post_list"), response.request["PATH_INFO"]) + self.assertEqual(reverse("blog.post_list"), response.request["PATH_INFO"]) def test_submit_button_name(self): self.client.login(username="author", password="author") @@ -423,12 +423,12 @@ def test_excludes(self): # this view excludes tags with the default form response = self.client.get(reverse("blog.post_exclude", args=[self.post.id])) content = response.content.decode("utf-8") - self.assertEquals(0, content.count("tags")) + self.assertEqual(0, content.count("tags")) # this view excludes tags included in a custom form response = self.client.get(reverse("blog.post_exclude2", args=[self.post.id])) content = response.content.decode("utf-8") - self.assertEquals(0, content.count("tags")) + self.assertEqual(0, content.count("tags")) def test_readonly(self): self.client.login(username="author", password="author") @@ -436,16 +436,16 @@ def test_readonly(self): # this view should have our tags field be readonly response = self.client.get(reverse("blog.post_readonly", args=[self.post.id])) content = response.content.decode("utf-8") - self.assertEquals(1, content.count("testing_tag")) - self.assertEquals(1, content.count("Tags")) - self.assertEquals(0, content.count('input id="id_tags"')) + self.assertEqual(1, content.count("testing_tag")) + self.assertEqual(1, content.count("Tags")) + self.assertEqual(0, content.count('input id="id_tags"')) # this view should also have our tags field be readonly, but it does so on a custom form response = self.client.get(reverse("blog.post_readonly2", args=[self.post.id])) content = response.content.decode("utf-8") - self.assertEquals(1, content.count("testing_tag")) - self.assertEquals(1, content.count("Tags")) - self.assertEquals(0, content.count('input id="id_tags"')) + self.assertEqual(1, content.count("testing_tag")) + self.assertEqual(1, content.count("Tags")) + self.assertEqual(0, content.count('input id="id_tags"')) def test_integrity_error(self): self.client.login(username="author", password="author") @@ -456,10 +456,10 @@ def test_integrity_error(self): response = self.client.post(reverse("blog.category_create"), post_data) # should get a plain 200 - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) # should have one error (our integrity error) - self.assertEquals(1, len(response.context["form"].errors)) + self.assertEqual(1, len(response.context["form"].errors)) def test_version(self): self.assertTrue(smartmin.__version__ is not None) @@ -476,13 +476,13 @@ def test_management(self): "blog.foo.*", ) - self.assertEquals(18, authors.permissions.all().count()) + self.assertEqual(18, authors.permissions.all().count()) # check that they are reassigned check_role_permissions(authors, permissions, authors.permissions.all()) # removing all category actions should bring us to 10 - self.assertEquals(13, authors.permissions.all().count()) + self.assertEqual(13, authors.permissions.all().count()) def test_smart_model(self): d1 = datetime(2016, 12, 31, 9, 20, 30, 123456, tzinfo=ZoneInfo("Africa/Kigali")) @@ -576,7 +576,7 @@ def test_csv_import(self): response = self.client.get(import_url) self.assertTrue(200, response.status_code) - self.assertEquals(response.request["PATH_INFO"], import_url) + self.assertEqual(response.request["PATH_INFO"], import_url) csv_file = open("test_runner/blog/test_files/posts.csv", "rb") post_data = dict(csv_file=csv_file) @@ -660,35 +660,35 @@ def test_login_stripped_spaces(self): login_url = reverse("users.user_login") response = self.client.post(login_url, dict(username=" superuser", password="superuser")) - self.assertEquals(response.status_code, 302) + self.assertEqual(response.status_code, 302) response = self.client.post(login_url, dict(username=" superuser ", password="superuser")) - self.assertEquals(response.status_code, 302) + self.assertEqual(response.status_code, 302) def test_login_case_not_sensitive(self): login_url = reverse("users.user_login") response = self.client.post(login_url, dict(username="superuser", password="superuser")) - self.assertEquals(response.status_code, 302) + self.assertEqual(response.status_code, 302) response = self.client.post(login_url, dict(username="superuser", password="superuser"), follow=True) - self.assertEquals(response.request["PATH_INFO"], settings.LOGIN_REDIRECT_URL) + self.assertEqual(response.request["PATH_INFO"], settings.LOGIN_REDIRECT_URL) response = self.client.post(login_url, dict(username="SUPERuser", password="superuser")) - self.assertEquals(response.status_code, 302) + self.assertEqual(response.status_code, 302) response = self.client.post(login_url, dict(username="SUPERuser", password="superuser"), follow=True) - self.assertEquals(response.request["PATH_INFO"], settings.LOGIN_REDIRECT_URL) + self.assertEqual(response.request["PATH_INFO"], settings.LOGIN_REDIRECT_URL) other_supersuser = User.objects.create_user("withCAPS", "with_caps@group.com", "thePASSWORD") other_supersuser.is_superuser = True other_supersuser.save() response = self.client.post(login_url, dict(username="withcaps", password="thePASSWORD")) - self.assertEquals(response.status_code, 302) + self.assertEqual(response.status_code, 302) response = self.client.post(login_url, dict(username="withcaps", password="thePASSWORD"), follow=True) - self.assertEquals(response.request["PATH_INFO"], settings.LOGIN_REDIRECT_URL) + self.assertEqual(response.request["PATH_INFO"], settings.LOGIN_REDIRECT_URL) # passwords stay case sensitive response = self.client.post(login_url, dict(username="withcaps", password="thepassword"), follow=True) @@ -708,7 +708,7 @@ def test_crudl(self): ) response = self.client.post(reverse("users.user_create"), post_data, follow=True) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) # we should have failed due to our password not being long enough self.assertTrue("new_password" in response.context["form"].errors) @@ -716,19 +716,19 @@ def test_crudl(self): # try with a longer password but without our requirements (8 chars) post_data["new_password"] = "password" response = self.client.post(reverse("users.user_create"), post_data, follow=True) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) self.assertTrue("new_password" in response.context["form"].errors) # try with one capital letter post_data["new_password"] = "Password" response = self.client.post(reverse("users.user_create"), post_data, follow=True) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) self.assertTrue("new_password" in response.context["form"].errors) # ok, finally with a zero and a whitespace in there too, this one should pass post_data["new_password"] = "Passw0rd " response = self.client.post(reverse("users.user_create"), post_data, follow=True) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) self.assertTrue("form" not in response.context) # make sure the user was created @@ -750,9 +750,9 @@ def test_crudl(self): users = response.context["user_list"] # results should be sorted by username - self.assertEquals(2, len(users)) - self.assertEquals(steve, users[0]) - self.assertEquals(woz, users[1]) + self.assertEqual(2, len(users)) + self.assertEqual(steve, users[0]) + self.assertEqual(woz, users[1]) # check our content too self.assertContains(response, "woz") @@ -767,14 +767,14 @@ def test_crudl(self): post_data["username"] = "steve" response = self.client.post(reverse("users.user_update", args=[steve.id]), post_data, follow=True) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) self.assertTrue("form" not in response.context) # check that steve's group changed steve = User.objects.get(pk=steve.id) groups = steve.groups.all() - self.assertEquals(1, len(groups)) - self.assertEquals(Group.objects.get(name="Editors"), groups[0]) + self.assertEqual(1, len(groups)) + self.assertEqual(Group.objects.get(name="Editors"), groups[0]) # assert steve can login with 'google' now self.assertTrue(self.client.login(username="steve", password=" googleIsNumber1")) @@ -790,20 +790,20 @@ def test_crudl(self): response = self.client.post(reverse("users.user_mimic", args=[steve.id]), follow=True) # check if the logged in user is steve now - self.assertEquals(response.context["user"].username, "steve") - self.assertEquals(response.request["PATH_INFO"], settings.LOGIN_REDIRECT_URL) + self.assertEqual(response.context["user"].username, "steve") + self.assertEqual(response.request["PATH_INFO"], settings.LOGIN_REDIRECT_URL) # now that steve is the one logged in can he mimic woz? response = self.client.get(reverse("users.user_mimic", args=[woz.id]), follow=True) - self.assertEquals(response.request["PATH_INFO"], settings.LOGIN_URL) + self.assertEqual(response.request["PATH_INFO"], settings.LOGIN_URL) # login as super user self.assertTrue(self.client.login(username="superuser", password="superuser")) # check is access his profile response = self.client.get(reverse("users.user_profile", args=[self.superuser.id])) - self.assertEquals(200, response.status_code) - self.assertEquals(reverse("users.user_profile", args=[self.superuser.id]), response.request["PATH_INFO"]) + self.assertEqual(200, response.status_code) + self.assertEqual(reverse("users.user_profile", args=[self.superuser.id]), response.request["PATH_INFO"]) # create just a plain user plain = User.objects.create_user("plain", "plain@nogroups.com", "plain") @@ -813,20 +813,20 @@ def test_crudl(self): # check is access his profile, should not since plain users don't have that permission response = self.client.get(reverse("users.user_profile", args=[plain.id])) - self.assertEquals(302, response.status_code) + self.assertEqual(302, response.status_code) # log in as an editor instead self.assertTrue(self.client.login(username="steve", password=" googleIsNumber1")) response = self.client.get(reverse("users.user_profile", args=[steve.id])) - self.assertEquals(reverse("users.user_profile", args=[steve.id]), response.request["PATH_INFO"]) + self.assertEqual(reverse("users.user_profile", args=[steve.id]), response.request["PATH_INFO"]) # check if we are at the right form - self.assertEquals("UserProfileForm", type(response.context["form"]).__name__) + self.assertEqual("UserProfileForm", type(response.context["form"]).__name__) response = self.client.post(reverse("users.user_profile", args=[steve.id]), {}, follow=True) # check which field he have access to - self.assertEquals(6, len(response.context["form"].visible_fields())) + self.assertEqual(6, len(response.context["form"].visible_fields())) # doesn't include readonly fields on post self.assertNotIn("username", response.context["form"].fields) @@ -891,9 +891,9 @@ def test_token(self): response = self.client.post(forget_url, post_data, follow=True) # no email sent - self.assertEquals(0, len(mail.outbox)) + self.assertEqual(0, len(mail.outbox)) # email form submitted successfully - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) # email with valid user forget_url = reverse("users.user_forget") @@ -908,8 +908,8 @@ def test_token(self): response = self.client.post(forget_url, post_data, follow=True) # email form submitted successfully - self.assertEquals(200, response.status_code) - self.assertEquals(1, len(mail.outbox)) + self.assertEqual(200, response.status_code) + self.assertEqual(1, len(mail.outbox)) sent_email = mail.outbox[0] self.assertEqual(len(sent_email.to), 1) self.assertEqual(sent_email.to[0], "user1@user1.com") @@ -930,8 +930,8 @@ def test_token(self): response = self.client.post(forget_url, post_data, follow=True) # email form submitted successfully - self.assertEquals(200, response.status_code) - self.assertEquals(2, len(mail.outbox)) + self.assertEqual(200, response.status_code) + self.assertEqual(2, len(mail.outbox)) sent_email = mail.outbox[1] self.assertEqual(len(sent_email.to), 1) self.assertEqual(sent_email.to[0], "user1@user1.com") @@ -951,7 +951,7 @@ def test_token(self): # email are case insensitive response = self.client.post(forget_url, dict(email="USer1@user1.com"), follow=True) # email form submitted successfully - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) # now there is a token generated recovery_token = RecoveryToken.objects.get(user=user1) @@ -963,7 +963,7 @@ def test_token(self): response = self.client.post(forget_url, post_data, follow=True) # email form submitted successfully - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) # now there is a token generated recovery_token = RecoveryToken.objects.get(user=user1) @@ -979,7 +979,7 @@ def test_token(self): recover_url = reverse("users.user_recover", args=[recovery_token.token]) response = self.client.get(recover_url) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) self.assertTrue(response.context["form"]) self.assertEqual(response.context["view"].template_name, "smartmin/users/user_recover.html") self.assertTrue("new_password" in response.context["form"].fields) @@ -995,7 +995,7 @@ def test_token(self): recover_url = reverse("users.user_recover", args=[recovery_token.token]) response = self.client.get(recover_url) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) self.assertTrue(response.context["form"]) self.assertTrue("new_password" in response.context["form"].fields) self.assertTrue("confirm_new_password" in response.context["form"].fields) @@ -1016,10 +1016,10 @@ def test_token(self): recover_url = reverse("users.user_recover", args=[recovery_token.token]) response = self.client.get(recover_url) - self.assertEquals(302, response.status_code) + self.assertEqual(302, response.status_code) response = self.client.get(recover_url, follow=True) - self.assertEquals(response.request["PATH_INFO"], forget_url) + self.assertEqual(response.request["PATH_INFO"], forget_url) self.assertTrue(response.context["form"]) self.assertFalse("new_password" in response.context["form"].fields) self.assertFalse("confirm_new_password" in response.context["form"].fields) @@ -1035,7 +1035,7 @@ def test_token(self): recover_url = reverse("users.user_recover", args=[recovery_token.token]) response = self.client.get(recover_url) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) self.assertTrue(response.context["form"]) self.assertTrue("new_password" in response.context["form"].fields) self.assertTrue("confirm_new_password" in response.context["form"].fields) @@ -1046,7 +1046,7 @@ def test_token(self): response = self.client.post(recover_url, post_data, follow=True) # form submitted successfull - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) # now the user cannot login with the old password but can login with the new one self.assertFalse(self.client.login(username="user1", password="user1")) @@ -1059,7 +1059,7 @@ def test_token(self): recover_url = reverse("users.user_recover", args=[recovery_token.token]) response = self.client.get(recover_url) - self.assertEquals(302, response.status_code) + self.assertEqual(302, response.status_code) response = self.client.get(recover_url, follow=True) self.assertTrue(response.request["PATH_INFO"], forget_url) @@ -1075,7 +1075,7 @@ def test_token(self): response = self.client.post(recover_url, post_data, follow=True) # form submitted successfull - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) # password must not change self.assertFalse(self.client.login(username="user1", password="user1_newpasswd_2")) @@ -1104,7 +1104,7 @@ def test_lockout(self): # on the fifth failed login we get redirected response = self.client.post(login_url, post_data) - self.assertEquals(302, response.status_code) + self.assertEqual(302, response.status_code) class UserTestCase(TestCase): @@ -1112,7 +1112,7 @@ def test_reverse(self): # the reverse tag here should be blog.user_list, not auth.user_list, since the # CRUDL objects is defined in the blog app response = self.client.get(reverse("blog.user_list")) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) # also make sure the proper template is used (should be /blog/user_list.html) self.assertContains(response, "Custom Pre-Content") @@ -1140,9 +1140,9 @@ def setUp(self): def test_value_from_view(self): context = dict(view=self.read_view, object=self.post) - self.assertEquals(self.post.title, get_value_from_view(context, "title")) + self.assertEqual(self.post.title, get_value_from_view(context, "title")) local_created = self.post.created_on.replace(tzinfo=ZoneInfo("UTC")).astimezone(ZoneInfo("Africa/Kigali")) - self.assertEquals(local_created.strftime("%b %d, %Y %H:%M"), get_value_from_view(context, "created_on")) + self.assertEqual(local_created.strftime("%b %d, %Y %H:%M"), get_value_from_view(context, "created_on")) def test_view_as_json(self): self.list_view.object_list = Post.objects.all() @@ -1150,20 +1150,20 @@ def test_view_as_json(self): view_as_json(context) json_data = json.loads(view_as_json(context)) - self.assertEquals(1, len(json_data)) - self.assertEquals(self.post.title, json_data[0]["title"]) + self.assertEqual(1, len(json_data)) + self.assertEqual(self.post.title, json_data[0]["title"]) def test_get(self): test_dict = dict(key="value") - self.assertEquals("value", get(test_dict, "key")) - self.assertEquals("", get(test_dict, "not_there")) + self.assertEqual("value", get(test_dict, "key")) + self.assertEqual("", get(test_dict, "not_there")) def test_map(self): from smartmin.templatetags.smartmin import map kwargs = {"title": self.post.title, "id": self.post.pk} - self.assertEquals("title: {title} id: {id}".format(**kwargs), map("title: %(title)s id: %(id)d", self.post)) + self.assertEqual("title: {title} id: {id}".format(**kwargs), map("title: %(title)s id: %(id)d", self.post)) def test_gmail_time(self): from smartmin.templatetags.smartmin import gmail_time @@ -1171,44 +1171,44 @@ def test_gmail_time(self): # given the time as now, should display "Hour:Minutes AM|PM" eg. "5:05 pm" now = timezone.now() modified_now = now.replace(hour=17, minute=5) - self.assertEquals("7:05 pm", gmail_time(modified_now)) + self.assertEqual("7:05 pm", gmail_time(modified_now)) # given the time beyond 12 hours ago within the same month, should display "MonthName DayOfMonth" eg. "Jan 2" now = now.replace(day=3, month=3, hour=10) test_date = now.replace(day=2) - self.assertEquals(test_date.strftime("%b") + " 2", gmail_time(test_date, now)) + self.assertEqual(test_date.strftime("%b") + " 2", gmail_time(test_date, now)) # last month should still be pretty test_date = test_date.replace(month=2) - self.assertEquals(test_date.strftime("%b") + " 2", gmail_time(test_date, now)) + self.assertEqual(test_date.strftime("%b") + " 2", gmail_time(test_date, now)) # but a different year is different jan_2 = datetime(2012, 1, 2, 17, 5, 0, 0).replace(tzinfo=ZoneInfo("UTC")) - self.assertEquals("2/1/12", gmail_time(jan_2, now)) + self.assertEqual("2/1/12", gmail_time(jan_2, now)) def test_user_as_string(self): # plain user have both first and last names self.plain.first_name = "Mr" self.plain.last_name = "Chips" self.plain.save() - self.assertEquals("Mr Chips", user_as_string(self.plain)) + self.assertEqual("Mr Chips", user_as_string(self.plain)) # change this user to have firstname as an empty string self.plain.first_name = "" self.plain.save() - self.assertEquals("Chips", user_as_string(self.plain)) + self.assertEqual("Chips", user_as_string(self.plain)) # change this user to have lastname as an empty string self.plain.last_name = "" self.plain.first_name = "Mr" self.plain.save() - self.assertEquals("Mr", user_as_string(self.plain)) + self.assertEqual("Mr", user_as_string(self.plain)) # change this user to have both first and last being empty strings self.plain.last_name = "" self.plain.first_name = "" self.plain.save() - self.assertEquals("plain", user_as_string(self.plain)) + self.assertEqual("plain", user_as_string(self.plain)) class UserLockoutTestCase(TestCase): @@ -1223,7 +1223,7 @@ def testBadLogin(self): post_data = dict(email="foo", password="blah") response = self.client.post(reverse("users.user_login"), post_data) - self.assertEquals(200, response.status_code) + self.assertEqual(200, response.status_code) self.assertTrue("username" in response.context["form"].errors) def doLockout(self): @@ -1411,11 +1411,11 @@ def test_expiration(self): response = self.client.post(reverse("users.user_newpassword", args=[0]), post_data) # should be redirected to the normal redirect page - self.assertEquals(302, response.status_code) + self.assertEqual(302, response.status_code) self.assertIn(reverse("blog.post_list"), response["location"]) # should now have two password histories - self.assertEquals(2, PasswordHistory.objects.filter(user=self.plain).count()) + self.assertEqual(2, PasswordHistory.objects.filter(user=self.plain).count()) # should be able to log in normally self.client.logout() @@ -1423,7 +1423,7 @@ def test_expiration(self): post_data = dict(username="plain", password=" Password2") response = self.client.post(reverse("users.user_login"), post_data) - self.assertEquals(302, response.status_code) + self.assertEqual(302, response.status_code) self.assertIn(reverse("blog.post_list"), response["location"])