diff --git a/frappe/chat/doctype/chat_profile/test_chat_profile.py b/frappe/chat/doctype/chat_profile/test_chat_profile.py index 5c3765d22e..a4f1bf359f 100644 --- a/frappe/chat/doctype/chat_profile/test_chat_profile.py +++ b/frappe/chat/doctype/chat_profile/test_chat_profile.py @@ -21,7 +21,7 @@ class TestChatProfile(unittest.TestCase): # if not user.chat_profile: # chat_profile.create(user.name) # prof = chat_profile.get(user.name) - # self.assertEquals(prof.status, 'Online') + # self.assertEqual(prof.status, 'Online') # else: # with self.assertRaises(frappe.ValidationError): # chat_profile.create(user.name) @@ -33,11 +33,11 @@ class TestChatProfile(unittest.TestCase): # self.assertNotEquals(len(prof), 1) # prof = chat_profile.get(user, fields = ['status']) - # self.assertEquals(len(prof), 1) - # self.assertEquals(prof.status, 'Online') + # self.assertEqual(len(prof), 1) + # self.assertEqual(prof.status, 'Online') # prof = chat_profile.get(user, fields = ['status', 'chat_bg']) - # self.assertEquals(len(prof), 2) + # self.assertEqual(len(prof), 2) # def test_update(self): # user = test_user @@ -53,7 +53,7 @@ class TestChatProfile(unittest.TestCase): # status = 'Offline' # )) # prof = chat_profile.get(user.name) - # self.assertEquals(prof.status, 'Offline') + # self.assertEqual(prof.status, 'Offline') # # revert # chat_profile.update(user.name, data = dict( # status = prev.status diff --git a/frappe/chat/util/test_util.py b/frappe/chat/util/test_util.py index 960d6a8fa8..8b07a1ca08 100644 --- a/frappe/chat/util/test_util.py +++ b/frappe/chat/util/test_util.py @@ -11,25 +11,25 @@ import frappe class TestChatUtil(unittest.TestCase): def test_safe_json_loads(self): number = safe_json_loads("1") - self.assertEquals(type(number), int) + self.assertEqual(type(number), int) number = safe_json_loads("1.0") - self.assertEquals(type(number), float) + self.assertEqual(type(number), float) string = safe_json_loads("foobar") - self.assertEquals(type(string), str) + self.assertEqual(type(string), str) array = safe_json_loads('[{ "foo": "bar" }]') - self.assertEquals(type(array), list) + self.assertEqual(type(array), list) objekt = safe_json_loads('{ "foo": "bar" }') - self.assertEquals(type(objekt), dict) + self.assertEqual(type(objekt), dict) true, null = safe_json_loads("true", "null") - self.assertEquals(true, True) - self.assertEquals(null, None) + self.assertEqual(true, True) + self.assertEqual(null, None) def test_get_user_doc(self): # Needs more test cases. user = get_user_doc() - self.assertEquals(user.name, frappe.session.user) \ No newline at end of file + self.assertEqual(user.name, frappe.session.user) \ No newline at end of file diff --git a/frappe/core/doctype/activity_log/test_activity_log.py b/frappe/core/doctype/activity_log/test_activity_log.py index e2f749ff04..7e308270bb 100644 --- a/frappe/core/doctype/activity_log/test_activity_log.py +++ b/frappe/core/doctype/activity_log/test_activity_log.py @@ -22,18 +22,18 @@ class TestActivityLog(unittest.TestCase): frappe.local.login_manager = LoginManager() auth_log = self.get_auth_log() - self.assertEquals(auth_log.status, 'Success') + self.assertEqual(auth_log.status, 'Success') # test user logout log frappe.local.login_manager.logout() auth_log = self.get_auth_log(operation='Logout') - self.assertEquals(auth_log.status, 'Success') + self.assertEqual(auth_log.status, 'Success') # test invalid login frappe.form_dict.update({ 'pwd': 'password' }) self.assertRaises(frappe.AuthenticationError, LoginManager) auth_log = self.get_auth_log() - self.assertEquals(auth_log.status, 'Failed') + self.assertEqual(auth_log.status, 'Failed') frappe.local.form_dict = frappe._dict() diff --git a/frappe/core/doctype/data_import/test_data_import.py b/frappe/core/doctype/data_import/test_data_import.py index 1eb38460e9..413d4edcfd 100644 --- a/frappe/core/doctype/data_import/test_data_import.py +++ b/frappe/core/doctype/data_import/test_data_import.py @@ -25,8 +25,8 @@ class TestDataImport(unittest.TestCase): content = read_csv_content(frappe.response.result) self.assertTrue(content[1][1], "User") self.assertTrue('"Administrator"' in [c[1] for c in content if len(c)>1]) - self.assertEquals(content[13][0], "DocType:") - self.assertEquals(content[13][1], "User") + self.assertEqual(content[13][0], "DocType:") + self.assertEqual(content[13][1], "User") self.assertTrue("Has Role" in content[13]) def test_import(self): @@ -71,7 +71,7 @@ class TestDataImport(unittest.TestCase): importer.upload(content, overwrite=True) user = frappe.get_doc("User", user_email) - self.assertEquals(len(user.get("roles")), 1) + self.assertEqual(len(user.get("roles")), 1) self.assertTrue(user.get("roles")[0].role, "Website Manager") def test_import_with_children(self): #pylint: disable=R0201 diff --git a/frappe/core/doctype/report/test_report.py b/frappe/core/doctype/report/test_report.py index c2d5629a2b..1689d99716 100644 --- a/frappe/core/doctype/report/test_report.py +++ b/frappe/core/doctype/report/test_report.py @@ -17,15 +17,15 @@ class TestReport(unittest.TestCase): report = frappe.get_doc('Report', 'User Activity Report') columns, data = report.get_data() - self.assertEquals(columns[0].get('label'), 'ID') - self.assertEquals(columns[1].get('label'), 'User Type') + self.assertEqual(columns[0].get('label'), 'ID') + self.assertEqual(columns[1].get('label'), 'User Type') self.assertTrue('Administrator' in [d[0] for d in data]) def test_query_report(self): report = frappe.get_doc('Report', 'Permitted Documents For User') columns, data = report.get_data(filters={'user': 'Administrator', 'doctype': 'DocType'}) - self.assertEquals(columns[0].get('label'), 'Name') - self.assertEquals(columns[1].get('label'), 'Module') + self.assertEqual(columns[0].get('label'), 'Name') + self.assertEqual(columns[1].get('label'), 'Module') self.assertTrue('User' in [d[0] for d in data]) def test_report_permisisons(self): diff --git a/frappe/core/doctype/role_profile/test_role_profile.py b/frappe/core/doctype/role_profile/test_role_profile.py index d338bec9e2..624b85c315 100644 --- a/frappe/core/doctype/role_profile/test_role_profile.py +++ b/frappe/core/doctype/role_profile/test_role_profile.py @@ -9,16 +9,16 @@ class TestRoleProfile(unittest.TestCase): def test_make_new_role_profile(self): new_role_profile = frappe.get_doc(dict(doctype='Role Profile', role_profile='Test 1')).insert() - self.assertEquals(new_role_profile.role_profile, 'Test 1') + self.assertEqual(new_role_profile.role_profile, 'Test 1') # add role new_role_profile.append("roles", { "role": '_Test Role 2' }) new_role_profile.save() - self.assertEquals(new_role_profile.roles[0].role, '_Test Role 2') + self.assertEqual(new_role_profile.roles[0].role, '_Test Role 2') # clear roles new_role_profile.roles = [] new_role_profile.save() - self.assertEquals(new_role_profile.roles, []) \ No newline at end of file + self.assertEqual(new_role_profile.roles, []) \ No newline at end of file diff --git a/frappe/core/doctype/translation/test_translation.py b/frappe/core/doctype/translation/test_translation.py index 88b44070c0..e54a8868fd 100644 --- a/frappe/core/doctype/translation/test_translation.py +++ b/frappe/core/doctype/translation/test_translation.py @@ -22,12 +22,12 @@ class TestTranslation(unittest.TestCase): frappe.local.lang = key frappe.local.lang_full_dict=None translation = create_translation(key, val) - self.assertEquals(_(val[0]), val[1]) + self.assertEqual(_(val[0]), val[1]) frappe.delete_doc('Translation', translation.name) frappe.local.lang_full_dict=None - self.assertEquals(_(val[0]), val[0]) + self.assertEqual(_(val[0]), val[0]) def test_parent_language(self): data = [ diff --git a/frappe/core/doctype/user/test_user.py b/frappe/core/doctype/user/test_user.py index 42f99b0bc4..cdd74c306f 100644 --- a/frappe/core/doctype/user/test_user.py +++ b/frappe/core/doctype/user/test_user.py @@ -24,26 +24,26 @@ class TestUser(unittest.TestCase): def test_user_type(self): new_user = frappe.get_doc(dict(doctype='User', email='test-for-type@example.com', first_name='Tester')).insert() - self.assertEquals(new_user.user_type, 'Website User') + self.assertEqual(new_user.user_type, 'Website User') # social login userid for frappe self.assertTrue(new_user.social_logins[0].userid) - self.assertEquals(new_user.social_logins[0].provider, "frappe") + self.assertEqual(new_user.social_logins[0].provider, "frappe") # role with desk access new_user.add_roles('_Test Role 2') new_user.save() - self.assertEquals(new_user.user_type, 'System User') + self.assertEqual(new_user.user_type, 'System User') # clear role new_user.roles = [] new_user.save() - self.assertEquals(new_user.user_type, 'Website User') + self.assertEqual(new_user.user_type, 'Website User') # role without desk access new_user.add_roles('_Test Role 4') new_user.save() - self.assertEquals(new_user.user_type, 'Website User') + self.assertEqual(new_user.user_type, 'Website User') frappe.delete_doc('User', new_user.name) @@ -72,26 +72,26 @@ class TestUser(unittest.TestCase): frappe.copy_doc(role_records[1]).insert() def test_get_value(self): - self.assertEquals(frappe.db.get_value("User", "test@example.com"), "test@example.com") - self.assertEquals(frappe.db.get_value("User", {"email":"test@example.com"}), "test@example.com") - self.assertEquals(frappe.db.get_value("User", {"email":"test@example.com"}, "email"), "test@example.com") - self.assertEquals(frappe.db.get_value("User", {"email":"test@example.com"}, ["first_name", "email"]), + self.assertEqual(frappe.db.get_value("User", "test@example.com"), "test@example.com") + self.assertEqual(frappe.db.get_value("User", {"email":"test@example.com"}), "test@example.com") + self.assertEqual(frappe.db.get_value("User", {"email":"test@example.com"}, "email"), "test@example.com") + self.assertEqual(frappe.db.get_value("User", {"email":"test@example.com"}, ["first_name", "email"]), ("_Test", "test@example.com")) - self.assertEquals(frappe.db.get_value("User", + self.assertEqual(frappe.db.get_value("User", {"email":"test@example.com", "first_name": "_Test"}, ["first_name", "email"]), ("_Test", "test@example.com")) test_user = frappe.db.sql("select * from tabUser where name='test@example.com'", as_dict=True)[0] - self.assertEquals(frappe.db.get_value("User", {"email":"test@example.com"}, "*", as_dict=True), + self.assertEqual(frappe.db.get_value("User", {"email":"test@example.com"}, "*", as_dict=True), test_user) - self.assertEquals(frappe.db.get_value("User", "xxxtest@example.com"), None) + self.assertEqual(frappe.db.get_value("User", "xxxtest@example.com"), None) frappe.db.set_value("Website Settings", "Website Settings", "_test", "_test_val") - self.assertEquals(frappe.db.get_value("Website Settings", None, "_test"), "_test_val") - self.assertEquals(frappe.db.get_value("Website Settings", "Website Settings", "_test"), "_test_val") + self.assertEqual(frappe.db.get_value("Website Settings", None, "_test"), "_test_val") + self.assertEqual(frappe.db.get_value("Website Settings", "Website Settings", "_test"), "_test_val") def test_high_permlevel_validations(self): user = frappe.get_meta("User") @@ -202,12 +202,12 @@ class TestUser(unittest.TestCase): def test_delete_user(self): new_user = frappe.get_doc(dict(doctype='User', email='test-for-delete@example.com', first_name='Tester Delete User')).insert() - self.assertEquals(new_user.user_type, 'Website User') + self.assertEqual(new_user.user_type, 'Website User') # role with desk access new_user.add_roles('_Test Role 2') new_user.save() - self.assertEquals(new_user.user_type, 'System User') + self.assertEqual(new_user.user_type, 'System User') comm = frappe.get_doc({ "doctype":"Communication", diff --git a/frappe/core/doctype/version/test_version.py b/frappe/core/doctype/version/test_version.py index be721b3271..d265b1ae00 100644 --- a/frappe/core/doctype/version/test_version.py +++ b/frappe/core/doctype/version/test_version.py @@ -18,17 +18,17 @@ class TestVersion(unittest.TestCase): diff = get_diff(old_doc, new_doc)['changed'] - self.assertEquals(get_fieldnames(diff)[0], 'color') + self.assertEqual(get_fieldnames(diff)[0], 'color') self.assertTrue(get_old_values(diff)[0] is None) - self.assertEquals(get_new_values(diff)[0], '#fafafa') + self.assertEqual(get_new_values(diff)[0], '#fafafa') new_doc.starts_on = "2017-07-20" diff = get_diff(old_doc, new_doc)['changed'] - self.assertEquals(get_fieldnames(diff)[0], 'starts_on') - self.assertEquals(get_old_values(diff)[0], '01-01-2014 00:00:00') - self.assertEquals(get_new_values(diff)[0], '07-20-2017 00:00:00') + self.assertEqual(get_fieldnames(diff)[0], 'starts_on') + self.assertEqual(get_old_values(diff)[0], '01-01-2014 00:00:00') + self.assertEqual(get_new_values(diff)[0], '07-20-2017 00:00:00') def get_fieldnames(change_array): return [d[0] for d in change_array] diff --git a/frappe/custom/doctype/customize_form/test_customize_form.py b/frappe/custom/doctype/customize_form/test_customize_form.py index a0a1a30693..c47e4194d5 100644 --- a/frappe/custom/doctype/customize_form/test_customize_form.py +++ b/frappe/custom/doctype/customize_form/test_customize_form.py @@ -41,79 +41,79 @@ class TestCustomizeForm(unittest.TestCase): def test_fetch_to_customize(self): d = self.get_customize_form() - self.assertEquals(d.doc_type, None) - self.assertEquals(len(d.get("fields")), 0) + self.assertEqual(d.doc_type, None) + self.assertEqual(len(d.get("fields")), 0) d = self.get_customize_form("Event") - self.assertEquals(d.doc_type, "Event") - self.assertEquals(len(d.get("fields")), 29) + self.assertEqual(d.doc_type, "Event") + self.assertEqual(len(d.get("fields")), 29) d = self.get_customize_form("User") - self.assertEquals(d.doc_type, "User") + self.assertEqual(d.doc_type, "User") - self.assertEquals(len(d.get("fields")), + self.assertEqual(len(d.get("fields")), len(frappe.get_doc("DocType", d.doc_type).fields) + 1) - self.assertEquals(d.get("fields")[-1].fieldname, "test_custom_field") - self.assertEquals(d.get("fields", {"fieldname": "location"})[0].in_list_view, 1) + self.assertEqual(d.get("fields")[-1].fieldname, "test_custom_field") + self.assertEqual(d.get("fields", {"fieldname": "location"})[0].in_list_view, 1) return d def test_save_customization_property(self): d = self.get_customize_form("User") - self.assertEquals(frappe.db.get_value("Property Setter", + self.assertEqual(frappe.db.get_value("Property Setter", {"doc_type": "User", "property": "allow_copy"}, "value"), None) d.allow_copy = 1 d.run_method("save_customization") - self.assertEquals(frappe.db.get_value("Property Setter", + self.assertEqual(frappe.db.get_value("Property Setter", {"doc_type": "User", "property": "allow_copy"}, "value"), '1') d.allow_copy = 0 d.run_method("save_customization") - self.assertEquals(frappe.db.get_value("Property Setter", + self.assertEqual(frappe.db.get_value("Property Setter", {"doc_type": "User", "property": "allow_copy"}, "value"), None) def test_save_customization_field_property(self): d = self.get_customize_form("User") - self.assertEquals(frappe.db.get_value("Property Setter", + self.assertEqual(frappe.db.get_value("Property Setter", {"doc_type": "User", "property": "reqd", "field_name": "location"}, "value"), None) location_field = d.get("fields", {"fieldname": "location"})[0] location_field.reqd = 1 d.run_method("save_customization") - self.assertEquals(frappe.db.get_value("Property Setter", + self.assertEqual(frappe.db.get_value("Property Setter", {"doc_type": "User", "property": "reqd", "field_name": "location"}, "value"), '1') location_field = d.get("fields", {"fieldname": "location"})[0] location_field.reqd = 0 d.run_method("save_customization") - self.assertEquals(frappe.db.get_value("Property Setter", + self.assertEqual(frappe.db.get_value("Property Setter", {"doc_type": "User", "property": "reqd", "field_name": "location"}, "value"), None) # for not allowing to change mandatory property of standard fields - self.assertEquals(frappe.db.get_value("Property Setter", + self.assertEqual(frappe.db.get_value("Property Setter", {"doc_type": "User", "property": "reqd", "field_name": "email"}, "value"), None) email_field = d.get("fields", {"fieldname": "email"})[0] email_field.reqd = 0 d.run_method("save_customization") - self.assertEquals(frappe.db.get_value("Property Setter", + self.assertEqual(frappe.db.get_value("Property Setter", {"doc_type": "User", "property": "reqd", "field_name": "email"}, "value"), None) def test_save_customization_custom_field_property(self): d = self.get_customize_form("User") - self.assertEquals(frappe.db.get_value("Custom Field", "User-test_custom_field", "reqd"), 0) + self.assertEqual(frappe.db.get_value("Custom Field", "User-test_custom_field", "reqd"), 0) custom_field = d.get("fields", {"fieldname": "test_custom_field"})[0] custom_field.reqd = 1 d.run_method("save_customization") - self.assertEquals(frappe.db.get_value("Custom Field", "User-test_custom_field", "reqd"), 1) + self.assertEqual(frappe.db.get_value("Custom Field", "User-test_custom_field", "reqd"), 1) custom_field = d.get("fields", {"is_custom_field": True})[0] custom_field.reqd = 0 d.run_method("save_customization") - self.assertEquals(frappe.db.get_value("Custom Field", "User-test_custom_field", "reqd"), 0) + self.assertEqual(frappe.db.get_value("Custom Field", "User-test_custom_field", "reqd"), 0) def test_save_customization_new_field(self): d = self.get_customize_form("User") @@ -124,14 +124,14 @@ class TestCustomizeForm(unittest.TestCase): "is_custom_field": 1 }) d.run_method("save_customization") - self.assertEquals(frappe.db.get_value("Custom Field", + self.assertEqual(frappe.db.get_value("Custom Field", "User-test_add_custom_field_via_customize_form", "fieldtype"), "Data") - self.assertEquals(frappe.db.get_value("Custom Field", + self.assertEqual(frappe.db.get_value("Custom Field", "User-test_add_custom_field_via_customize_form", 'insert_after'), last_fieldname) frappe.delete_doc("Custom Field", "User-test_add_custom_field_via_customize_form") - self.assertEquals(frappe.db.get_value("Custom Field", + self.assertEqual(frappe.db.get_value("Custom Field", "User-test_add_custom_field_via_customize_form"), None) @@ -141,7 +141,7 @@ class TestCustomizeForm(unittest.TestCase): d.get("fields").remove(custom_field) d.run_method("save_customization") - self.assertEquals(frappe.db.get_value("Custom Field", custom_field.name), None) + self.assertEqual(frappe.db.get_value("Custom Field", custom_field.name), None) frappe.local.test_objects["Custom Field"] = [] make_test_records_for_doctype("Custom Field") @@ -151,7 +151,7 @@ class TestCustomizeForm(unittest.TestCase): d.doc_type = "User" d.run_method('reset_to_defaults') - self.assertEquals(d.get("fields", {"fieldname": "location"})[0].in_list_view, 0) + self.assertEqual(d.get("fields", {"fieldname": "location"})[0].in_list_view, 0) frappe.local.test_objects["Property Setter"] = [] make_test_records_for_doctype("Property Setter") @@ -165,10 +165,10 @@ class TestCustomizeForm(unittest.TestCase): d = self.get_customize_form("User") # don't allow for standard fields - self.assertEquals(d.get("fields", {"fieldname": "first_name"})[0].allow_on_submit or 0, 0) + self.assertEqual(d.get("fields", {"fieldname": "first_name"})[0].allow_on_submit or 0, 0) # allow for custom field - self.assertEquals(d.get("fields", {"fieldname": "test_custom_field"})[0].allow_on_submit, 1) + self.assertEqual(d.get("fields", {"fieldname": "test_custom_field"})[0].allow_on_submit, 1) def test_title_field_pattern(self): d = self.get_customize_form("Web Form") diff --git a/frappe/desk/doctype/desktop_icon/test_desktop_icon.py b/frappe/desk/doctype/desktop_icon/test_desktop_icon.py index b0e29a0660..12c2d649dc 100644 --- a/frappe/desk/doctype/desktop_icon/test_desktop_icon.py +++ b/frappe/desk/doctype/desktop_icon/test_desktop_icon.py @@ -29,47 +29,47 @@ class TestDesktopIcon(unittest.TestCase): return None def test_get_standard_desktop_icon_for_user(self): - self.assertEquals(self.get_icon('Desk').standard, 1) + self.assertEqual(self.get_icon('Desk').standard, 1) def test_add_desktop_icon(self): - self.assertEquals(self.get_icon('User'), None) + self.assertEqual(self.get_icon('User'), None) add_user_icon('User') icon = self.get_icon('User') - self.assertEquals(icon.custom, 1) - self.assertEquals(icon.standard, 0) + self.assertEqual(icon.custom, 1) + self.assertEqual(icon.standard, 0) def test_hide_desktop_icon(self): set_hidden_list(["Desk"], 'test@example.com') icon = self.get_icon('Desk') - self.assertEquals(icon.hidden, 1) - self.assertEquals(icon.standard, 0) + self.assertEqual(icon.hidden, 1) + self.assertEqual(icon.standard, 0) def test_remove_custom_desktop_icon_on_hidden(self): self.test_add_desktop_icon() set_hidden_list(['User'], 'test@example.com') icon = self.get_icon('User') - self.assertEquals(icon, None) + self.assertEqual(icon, None) def test_show_desktop_icon(self): self.test_hide_desktop_icon() set_hidden_list([], 'test@example.com') icon = self.get_icon('Desk') - self.assertEquals(icon.hidden, 0) - self.assertEquals(icon.standard, 0) + self.assertEqual(icon.hidden, 0) + self.assertEqual(icon.standard, 0) def test_globally_hidden_desktop_icon(self): set_hidden_list(["Desk"]) icon = self.get_icon('Desk') - self.assertEquals(icon.hidden, 1) + self.assertEqual(icon.hidden, 1) frappe.set_user('test1@example.com') icon = self.get_icon('Desk') - self.assertEquals(icon.hidden, 1) + self.assertEqual(icon.hidden, 1) def test_re_order_desktop_icons(self): icons = [d.module_name for d in get_desktop_icons()] @@ -80,8 +80,8 @@ class TestDesktopIcon(unittest.TestCase): icons = [d.module_name for d in get_desktop_icons()] # check switched order - self.assertEquals(icons[0], m1) - self.assertEquals(icons[1], m0) + self.assertEqual(icons[0], m1) + self.assertEqual(icons[1], m0) def test_block_desktop_icons_for_user(self): def test_unblock(): @@ -90,7 +90,7 @@ class TestDesktopIcon(unittest.TestCase): user.save(ignore_permissions = 1) icon = self.get_icon('Desk') - self.assertEquals(icon.hidden, 0) + self.assertEqual(icon.hidden, 0) test_unblock() @@ -100,7 +100,7 @@ class TestDesktopIcon(unittest.TestCase): clear_desktop_icons_cache(user.name) icon = self.get_icon('Desk') - self.assertEquals(icon.hidden, 1) + self.assertEqual(icon.hidden, 1) test_unblock() diff --git a/frappe/desk/doctype/event/test_event.py b/frappe/desk/doctype/event/test_event.py index b1027d501f..8c6db6fe72 100644 --- a/frappe/desk/doctype/event/test_event.py +++ b/frappe/desk/doctype/event/test_event.py @@ -47,7 +47,7 @@ class TestEvent(unittest.TestCase): def test_event_list(self): frappe.set_user(self.test_user) res = frappe.get_list("Event", filters=[["Event", "subject", "like", "_Test Event%"]], fields=["name", "subject"]) - self.assertEquals(len(res), 1) + self.assertEqual(len(res), 1) subjects = [r.subject for r in res] self.assertTrue("_Test Event 1" in subjects) self.assertFalse("_Test Event 3" in subjects) @@ -63,7 +63,7 @@ class TestEvent(unittest.TestCase): ev = frappe.get_doc(self.test_records[0]).insert() # the name should be same! - self.assertEquals(ev.name, name) + self.assertEqual(ev.name, name) def test_assign(self): from frappe.desk.form.assign_to import add @@ -79,7 +79,7 @@ class TestEvent(unittest.TestCase): ev = frappe.get_doc("Event", ev.name) - self.assertEquals(ev._assign, json.dumps(["test@example.com"])) + self.assertEqual(ev._assign, json.dumps(["test@example.com"])) # add another one add({ @@ -91,7 +91,7 @@ class TestEvent(unittest.TestCase): ev = frappe.get_doc("Event", ev.name) - self.assertEquals(set(json.loads(ev._assign)), set(["test@example.com", self.test_user])) + self.assertEqual(set(json.loads(ev._assign)), set(["test@example.com", self.test_user])) # close an assignment todo = frappe.get_doc("ToDo", {"reference_type": ev.doctype, "reference_name": ev.name, @@ -100,7 +100,7 @@ class TestEvent(unittest.TestCase): todo.save() ev = frappe.get_doc("Event", ev.name) - self.assertEquals(ev._assign, json.dumps(["test@example.com"])) + self.assertEqual(ev._assign, json.dumps(["test@example.com"])) # cleanup ev.delete() diff --git a/frappe/desk/doctype/note/test_note.py b/frappe/desk/doctype/note/test_note.py index cc3fa348e7..865527b5a0 100644 --- a/frappe/desk/doctype/note/test_note.py +++ b/frappe/desk/doctype/note/test_note.py @@ -37,13 +37,13 @@ class TestNote(unittest.TestCase): version = frappe.get_doc('Version', dict(docname=note.name)) data = version.get_data() - self.assertEquals(len(data.get('added')), 1) - self.assertEquals(len(data.get('removed')), 0) - self.assertEquals(len(data.get('changed')), 0) + self.assertEqual(len(data.get('added')), 1) + self.assertEqual(len(data.get('removed')), 0) + self.assertEqual(len(data.get('changed')), 0) for row in data.get('added'): - self.assertEquals(row[0], 'seen_by') - self.assertEquals(row[1]['user'], 'Administrator') + self.assertEqual(row[0], 'seen_by') + self.assertEqual(row[1]['user'], 'Administrator') # test row change note.seen_by[0].user = 'Guest' @@ -52,12 +52,12 @@ class TestNote(unittest.TestCase): version = frappe.get_doc('Version', dict(docname=note.name)) data = version.get_data() - self.assertEquals(len(data.get('row_changed')), 1) + self.assertEqual(len(data.get('row_changed')), 1) for row in data.get('row_changed'): - self.assertEquals(row[0], 'seen_by') - self.assertEquals(row[1], 0) - self.assertEquals(row[2], note.seen_by[0].name) - self.assertEquals(row[3], [['user', 'Administrator', 'Guest']]) + self.assertEqual(row[0], 'seen_by') + self.assertEqual(row[1], 0) + self.assertEqual(row[2], note.seen_by[0].name) + self.assertEqual(row[3], [['user', 'Administrator', 'Guest']]) # test remove note.seen_by = [] @@ -66,10 +66,10 @@ class TestNote(unittest.TestCase): version = frappe.get_doc('Version', dict(docname=note.name)) data = version.get_data() - self.assertEquals(len(data.get('removed')), 1) + self.assertEqual(len(data.get('removed')), 1) for row in data.get('removed'): - self.assertEquals(row[0], 'seen_by') - self.assertEquals(row[1]['user'], 'Guest') + self.assertEqual(row[0], 'seen_by') + self.assertEqual(row[1]['user'], 'Guest') # self.assertTrue(('title', 'test note', 'test note 1'), data['changed']) # self.assertTrue(('content', 'test note content', '1'), data['changed']) diff --git a/frappe/desk/doctype/todo/test_todo.py b/frappe/desk/doctype/todo/test_todo.py index 6fb9c8ba23..c8e951e651 100644 --- a/frappe/desk/doctype/todo/test_todo.py +++ b/frappe/desk/doctype/todo/test_todo.py @@ -17,12 +17,12 @@ class TestToDo(unittest.TestCase): todo.delete() deleted = frappe.get_doc('Deleted Document', dict(deleted_doctype=todo.doctype, deleted_name=todo.name)) - self.assertEquals(todo.as_json(), deleted.data) + self.assertEqual(todo.as_json(), deleted.data) def test_fetch(self): todo = frappe.get_doc(dict(doctype='ToDo', description='test todo', assigned_by='Administrator')).insert() - self.assertEquals(todo.assigned_by_full_name, + self.assertEqual(todo.assigned_by_full_name, frappe.db.get_value('User', todo.assigned_by, 'full_name')) def test_fetch_setup(self): @@ -44,5 +44,5 @@ class TestToDo(unittest.TestCase): todo.reload() - self.assertEquals(todo.assigned_by_full_name, + self.assertEqual(todo.assigned_by_full_name, frappe.db.get_value('User', todo.assigned_by, 'full_name')) diff --git a/frappe/docs/user/en/guides/automated-testing/unit-testing.md b/frappe/docs/user/en/guides/automated-testing/unit-testing.md index b5c2a8b8b2..7c88a72a9a 100755 --- a/frappe/docs/user/en/guides/automated-testing/unit-testing.md +++ b/frappe/docs/user/en/guides/automated-testing/unit-testing.md @@ -191,7 +191,7 @@ It’s designed for the CI Jenkins, but will work for anything else that underst def test_event_list(self): frappe.set_user("test1@example.com") res = frappe.get_list("Event", filters=[["Event", "subject", "like", "_Test Event%"]], fields=["name", "subject"]) - self.assertEquals(len(res), 2) + self.assertEqual(len(res), 2) subjects = [r.subject for r in res] self.assertTrue("_Test Event 1" in subjects) self.assertTrue("_Test Event 3" in subjects) diff --git a/frappe/docs/user/zh/guides/automated-testing/unit-testing.md b/frappe/docs/user/zh/guides/automated-testing/unit-testing.md index b5c2a8b8b2..7c88a72a9a 100755 --- a/frappe/docs/user/zh/guides/automated-testing/unit-testing.md +++ b/frappe/docs/user/zh/guides/automated-testing/unit-testing.md @@ -191,7 +191,7 @@ It’s designed for the CI Jenkins, but will work for anything else that underst def test_event_list(self): frappe.set_user("test1@example.com") res = frappe.get_list("Event", filters=[["Event", "subject", "like", "_Test Event%"]], fields=["name", "subject"]) - self.assertEquals(len(res), 2) + self.assertEqual(len(res), 2) subjects = [r.subject for r in res] self.assertTrue("_Test Event 1" in subjects) self.assertTrue("_Test Event 3" in subjects) diff --git a/frappe/email/doctype/email_account/test_email_account.py b/frappe/email/doctype/email_account/test_email_account.py index d694abb3d3..16e4762905 100644 --- a/frappe/email/doctype/email_account/test_email_account.py +++ b/frappe/email/doctype/email_account/test_email_account.py @@ -146,8 +146,8 @@ class TestEmailAccount(unittest.TestCase): sent = frappe.get_doc("Communication", sent_name) comm = frappe.get_doc("Communication", {"sender": "test_sender@example.com"}) - self.assertEquals(comm.reference_doctype, sent.reference_doctype) - self.assertEquals(comm.reference_name, sent.reference_name) + self.assertEqual(comm.reference_doctype, sent.reference_doctype) + self.assertEqual(comm.reference_name, sent.reference_name) def test_threading_by_subject(self): frappe.db.sql("""delete from tabCommunication @@ -167,8 +167,8 @@ class TestEmailAccount(unittest.TestCase): fields=["name", "reference_doctype", "reference_name"]) # both communications attached to the same reference - self.assertEquals(comm_list[0].reference_doctype, comm_list[1].reference_doctype) - self.assertEquals(comm_list[0].reference_name, comm_list[1].reference_name) + self.assertEqual(comm_list[0].reference_doctype, comm_list[1].reference_doctype) + self.assertEqual(comm_list[0].reference_name, comm_list[1].reference_name) def test_threading_by_message_id(self): frappe.db.sql("""delete from tabCommunication""") @@ -195,5 +195,5 @@ class TestEmailAccount(unittest.TestCase): fields=["name", "reference_doctype", "reference_name"]) # check if threaded correctly - self.assertEquals(comm_list[0].reference_doctype, event.doctype) - self.assertEquals(comm_list[0].reference_name, event.name) + self.assertEqual(comm_list[0].reference_doctype, event.doctype) + self.assertEqual(comm_list[0].reference_name, event.name) diff --git a/frappe/email/doctype/email_alert/test_email_alert.py b/frappe/email/doctype/email_alert/test_email_alert.py index a3b3ea5932..0ca03d7429 100755 --- a/frappe/email/doctype/email_alert/test_email_alert.py +++ b/frappe/email/doctype/email_alert/test_email_alert.py @@ -34,7 +34,7 @@ class TestEmailAlert(unittest.TestCase): self.assertTrue(frappe.db.get_value("Email Queue", {"reference_doctype": "Communication", "reference_name": communication.name, "status":"Not Sent"})) - self.assertEquals(frappe.db.get_value('Communication', + self.assertEqual(frappe.db.get_value('Communication', communication.name, 'subject'), '__testing__') def test_condition(self): diff --git a/frappe/email/doctype/newsletter/test_newsletter.py b/frappe/email/doctype/newsletter/test_newsletter.py index 9b2f275260..54a8a8504c 100644 --- a/frappe/email/doctype/newsletter/test_newsletter.py +++ b/frappe/email/doctype/newsletter/test_newsletter.py @@ -26,7 +26,7 @@ class TestNewsletter(unittest.TestCase): name = self.send_newsletter() email_queue_list = [frappe.get_doc('Email Queue', e.name) for e in frappe.get_all("Email Queue")] - self.assertEquals(len(email_queue_list), 4) + self.assertEqual(len(email_queue_list), 4) recipients = [e.recipients[0].recipient for e in email_queue_list] for email in emails: self.assertTrue(email in recipients) @@ -43,7 +43,7 @@ class TestNewsletter(unittest.TestCase): name = self.send_newsletter() email_queue_list = [frappe.get_doc('Email Queue', e.name) for e in frappe.get_all("Email Queue")] - self.assertEquals(len(email_queue_list), 3) + self.assertEqual(len(email_queue_list), 3) recipients = [e.recipients[0].recipient for e in email_queue_list] for email in emails: if email != to_unsubscribe: @@ -72,7 +72,7 @@ class TestNewsletter(unittest.TestCase): frappe.set_user("test1@example.com") from frappe.email.doctype.newsletter.newsletter import get_newsletter_list newsletters = get_newsletter_list("Newsletter", None, None, 0) - self.assertEquals(len(newsletters), 1) + self.assertEqual(len(newsletters), 1) def test_newsletter_context(self): context = frappe._dict() @@ -80,7 +80,7 @@ class TestNewsletter(unittest.TestCase): frappe.set_user("test2@example.com") doc = frappe.get_doc("Newsletter", newsletter_name) doc.get_context(context) - self.assertEquals(context.no_cache, 1) + self.assertEqual(context.no_cache, 1) self.assertTrue("attachments" not in context.keys()) diff --git a/frappe/email/test_email_body.py b/frappe/email/test_email_body.py index bec6be5e5e..3f6502cdd4 100644 --- a/frappe/email/test_email_body.py +++ b/frappe/email/test_email_body.py @@ -94,7 +94,7 @@ w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> '''.format(inline_images[0].get('content_id')) - self.assertEquals(message, processed_message) + self.assertEqual(message, processed_message) def test_inline_styling(self): html = ''' diff --git a/frappe/patches/v10_0/refactor_social_login_keys.py b/frappe/patches/v10_0/refactor_social_login_keys.py index cb98b9365c..4c49ef89d3 100644 --- a/frappe/patches/v10_0/refactor_social_login_keys.py +++ b/frappe/patches/v10_0/refactor_social_login_keys.py @@ -1,8 +1,6 @@ -# see license import frappe def execute(): - # Move User Data into DocType frappe.reload_doc("core", "doctype", "user", force=True) frappe.reload_doc("core", "doctype", "user_social_login", force=True) users = frappe.get_all("User", filters=[["username", "not in", ["Guest","Administrator"]]]) diff --git a/frappe/tests/test_bot.py b/frappe/tests/test_bot.py index ba52bb4454..e606bcccb0 100644 --- a/frappe/tests/test_bot.py +++ b/frappe/tests/test_bot.py @@ -11,7 +11,7 @@ from frappe.utils.bot import BotReply class TestBot(unittest.TestCase): def test_hello(self): reply = BotReply().get_reply('hello') - self.assertEquals(reply, 'Hello Administrator') + self.assertEqual(reply, 'Hello Administrator') def test_open_notifications(self): reply = BotReply().get_reply('whatsup') diff --git a/frappe/tests/test_client.py b/frappe/tests/test_client.py index f524e58579..8371849935 100644 --- a/frappe/tests/test_client.py +++ b/frappe/tests/test_client.py @@ -8,10 +8,10 @@ class TestClient(unittest.TestCase): def test_set_value(self): todo = frappe.get_doc(dict(doctype='ToDo', description='test')).insert() frappe.set_value('ToDo', todo.name, 'description', 'test 1') - self.assertEquals(frappe.get_value('ToDo', todo.name, 'description'), 'test 1') + self.assertEqual(frappe.get_value('ToDo', todo.name, 'description'), 'test 1') frappe.set_value('ToDo', todo.name, {'description': 'test 2'}) - self.assertEquals(frappe.get_value('ToDo', todo.name, 'description'), 'test 2') + self.assertEqual(frappe.get_value('ToDo', todo.name, 'description'), 'test 2') def test_delete(self): from frappe.client import delete diff --git a/frappe/tests/test_db.py b/frappe/tests/test_db.py index 987b4e256c..ea6c07ae76 100644 --- a/frappe/tests/test_db.py +++ b/frappe/tests/test_db.py @@ -9,16 +9,16 @@ import frappe class TestDB(unittest.TestCase): def test_get_value(self): - self.assertEquals(frappe.db.get_value("User", {"name": ["=", "Administrator"]}), "Administrator") - self.assertEquals(frappe.db.get_value("User", {"name": ["like", "Admin%"]}), "Administrator") + self.assertEqual(frappe.db.get_value("User", {"name": ["=", "Administrator"]}), "Administrator") + self.assertEqual(frappe.db.get_value("User", {"name": ["like", "Admin%"]}), "Administrator") self.assertNotEquals(frappe.db.get_value("User", {"name": ["!=", "Guest"]}), "Guest") - self.assertEquals(frappe.db.get_value("User", {"name": ["<", "B"]}), "Administrator") - self.assertEquals(frappe.db.get_value("User", {"name": ["<=", "Administrator"]}), "Administrator") + self.assertEqual(frappe.db.get_value("User", {"name": ["<", "B"]}), "Administrator") + self.assertEqual(frappe.db.get_value("User", {"name": ["<=", "Administrator"]}), "Administrator") - self.assertEquals(frappe.db.sql("""select name from `tabUser` where name > "s" order by modified desc""")[0][0], + self.assertEqual(frappe.db.sql("""select name from `tabUser` where name > "s" order by modified desc""")[0][0], frappe.db.get_value("User", {"name": [">", "s"]})) - self.assertEquals(frappe.db.sql("""select name from `tabUser` where name >= "t" order by modified desc""")[0][0], + self.assertEqual(frappe.db.sql("""select name from `tabUser` where name >= "t" order by modified desc""")[0][0], frappe.db.get_value("User", {"name": [">=", "t"]})) def test_escape(self): diff --git a/frappe/tests/test_defaults.py b/frappe/tests/test_defaults.py index 5082d54adc..c4e881f078 100644 --- a/frappe/tests/test_defaults.py +++ b/frappe/tests/test_defaults.py @@ -10,40 +10,40 @@ class TestDefaults(unittest.TestCase): def test_global(self): clear_user_default("key1") set_global_default("key1", "value1") - self.assertEquals(get_global_default("key1"), "value1") + self.assertEqual(get_global_default("key1"), "value1") set_global_default("key1", "value2") - self.assertEquals(get_global_default("key1"), "value2") + self.assertEqual(get_global_default("key1"), "value2") add_global_default("key1", "value3") - self.assertEquals(get_global_default("key1"), "value2") - self.assertEquals(get_defaults()["key1"], ["value2", "value3"]) - self.assertEquals(get_user_default_as_list("key1"), ["value2", "value3"]) + self.assertEqual(get_global_default("key1"), "value2") + self.assertEqual(get_defaults()["key1"], ["value2", "value3"]) + self.assertEqual(get_user_default_as_list("key1"), ["value2", "value3"]) def test_user(self): set_user_default("key1", "2value1") - self.assertEquals(get_user_default_as_list("key1"), ["2value1"]) + self.assertEqual(get_user_default_as_list("key1"), ["2value1"]) set_user_default("key1", "2value2") - self.assertEquals(get_user_default("key1"), "2value2") + self.assertEqual(get_user_default("key1"), "2value2") add_user_default("key1", "3value3") - self.assertEquals(get_user_default("key1"), "2value2") - self.assertEquals(get_user_default_as_list("key1"), ["2value2", "3value3"]) + self.assertEqual(get_user_default("key1"), "2value2") + self.assertEqual(get_user_default_as_list("key1"), ["2value2", "3value3"]) def test_global_if_not_user(self): set_global_default("key4", "value4") - self.assertEquals(get_user_default("key4"), "value4") + self.assertEqual(get_user_default("key4"), "value4") def test_clear(self): set_user_default("key5", "value5") - self.assertEquals(get_user_default("key5"), "value5") + self.assertEqual(get_user_default("key5"), "value5") clear_user_default("key5") - self.assertEquals(get_user_default("key5"), None) + self.assertEqual(get_user_default("key5"), None) def test_clear_global(self): set_global_default("key6", "value6") - self.assertEquals(get_user_default("key6"), "value6") + self.assertEqual(get_user_default("key6"), "value6") clear_default("key6", value="value6") - self.assertEquals(get_user_default("key6"), None) + self.assertEqual(get_user_default("key6"), None) diff --git a/frappe/tests/test_document.py b/frappe/tests/test_document.py index 147771c393..015b0d261e 100644 --- a/frappe/tests/test_document.py +++ b/frappe/tests/test_document.py @@ -9,21 +9,21 @@ from frappe.model.naming import revert_series_if_last, make_autoname, parse_nami class TestDocument(unittest.TestCase): def test_get_return_empty_list_for_table_field_if_none(self): d = frappe.get_doc({"doctype":"User"}) - self.assertEquals(d.get("roles"), []) + self.assertEqual(d.get("roles"), []) def test_load(self): d = frappe.get_doc("DocType", "User") - self.assertEquals(d.doctype, "DocType") - self.assertEquals(d.name, "User") - self.assertEquals(d.allow_rename, 1) + self.assertEqual(d.doctype, "DocType") + self.assertEqual(d.name, "User") + self.assertEqual(d.allow_rename, 1) self.assertTrue(isinstance(d.fields, list)) self.assertTrue(isinstance(d.permissions, list)) self.assertTrue(filter(lambda d: d.fieldname=="email", d.fields)) def test_load_single(self): d = frappe.get_doc("Website Settings", "Website Settings") - self.assertEquals(d.name, "Website Settings") - self.assertEquals(d.doctype, "Website Settings") + self.assertEqual(d.name, "Website Settings") + self.assertEqual(d.doctype, "Website Settings") self.assertTrue(d.disable_signup in (0, 1)) def test_insert(self): @@ -35,11 +35,11 @@ class TestDocument(unittest.TestCase): }) d.insert() self.assertTrue(d.name.startswith("EV")) - self.assertEquals(frappe.db.get_value("Event", d.name, "subject"), + self.assertEqual(frappe.db.get_value("Event", d.name, "subject"), "test-doc-test-event 1") # test if default values are added - self.assertEquals(d.send_reminder, 1) + self.assertEqual(d.send_reminder, 1) return d def test_insert_with_child(self): @@ -51,7 +51,7 @@ class TestDocument(unittest.TestCase): }) d.insert() self.assertTrue(d.name.startswith("EV")) - self.assertEquals(frappe.db.get_value("Event", d.name, "subject"), + self.assertEqual(frappe.db.get_value("Event", d.name, "subject"), "test-doc-test-event 2") def test_update(self): @@ -59,7 +59,7 @@ class TestDocument(unittest.TestCase): d.subject = "subject changed" d.save() - self.assertEquals(frappe.db.get_value(d.doctype, d.name, "subject"), "subject changed") + self.assertEqual(frappe.db.get_value(d.doctype, d.name, "subject"), "subject changed") def test_mandatory(self): frappe.delete_doc_if_exists("User", "test_mandatory@example.com") @@ -72,7 +72,7 @@ class TestDocument(unittest.TestCase): d.set("first_name", "Test Mandatory") d.insert() - self.assertEquals(frappe.db.get_value("User", d.name), d.name) + self.assertEqual(frappe.db.get_value("User", d.name), d.name) def test_confict_validation(self): d1 = self.test_insert() @@ -122,7 +122,7 @@ class TestDocument(unittest.TestCase): }) d.insert() - self.assertEquals(frappe.db.get_value("User", d.name), d.name) + self.assertEqual(frappe.db.get_value("User", d.name), d.name) def test_validate(self): d = self.test_insert() @@ -209,7 +209,7 @@ class TestDocument(unittest.TestCase): link_count = frappe.cache().get_value('_link_count') or {} new_count = link_count.get((doctype, name)) or 0 - self.assertEquals(old_count + 1, new_count) + self.assertEqual(old_count + 1, new_count) before_update = frappe.db.get_value(doctype, name, 'idx') @@ -217,7 +217,7 @@ class TestDocument(unittest.TestCase): after_update = frappe.db.get_value(doctype, name, 'idx') - self.assertEquals(before_update + new_count, after_update) + self.assertEqual(before_update + new_count, after_update) def test_naming_series(self): data = ["TEST-", "TEST/17-18/.test_data./.####", "TEST.YYYY.MM.####"] @@ -235,4 +235,4 @@ class TestDocument(unittest.TestCase): revert_series_if_last(series, name) new_current = cint(frappe.db.get_value('Series', prefix, "current", order_by="name")) - self.assertEquals(cint(old_current) - 1, new_current) + self.assertEqual(cint(old_current) - 1, new_current) diff --git a/frappe/tests/test_email.py b/frappe/tests/test_email.py index b35b816e7b..68fcdc5146 100644 --- a/frappe/tests/test_email.py +++ b/frappe/tests/test_email.py @@ -23,12 +23,12 @@ class TestEmail(unittest.TestCase): unsubscribe_message="Unsubscribe", send_after=send_after) email_queue = frappe.db.sql("""select name,message from `tabEmail Queue` where status='Not Sent'""", as_dict=1) - self.assertEquals(len(email_queue), 1) + self.assertEqual(len(email_queue), 1) queue_recipients = [r.recipient for r in frappe.db.sql("""SELECT recipient FROM `tabEmail Queue Recipient` WHERE status='Not Sent'""", as_dict=1)] self.assertTrue('test@example.com' in queue_recipients) self.assertTrue('test1@example.com' in queue_recipients) - self.assertEquals(len(queue_recipients), 2) + self.assertEqual(len(queue_recipients), 2) self.assertTrue('' in email_queue[0]['message']) def test_send_after(self): @@ -36,19 +36,19 @@ class TestEmail(unittest.TestCase): from frappe.email.queue import flush flush(from_test=True) email_queue = frappe.db.sql("""select name from `tabEmail Queue` where status='Sent'""", as_dict=1) - self.assertEquals(len(email_queue), 0) + self.assertEqual(len(email_queue), 0) def test_flush(self): self.test_email_queue() from frappe.email.queue import flush flush(from_test=True) email_queue = frappe.db.sql("""select name from `tabEmail Queue` where status='Sent'""", as_dict=1) - self.assertEquals(len(email_queue), 1) + self.assertEqual(len(email_queue), 1) queue_recipients = [r.recipient for r in frappe.db.sql("""select recipient from `tabEmail Queue Recipient` where status='Sent'""", as_dict=1)] self.assertTrue('test@example.com' in queue_recipients) self.assertTrue('test1@example.com' in queue_recipients) - self.assertEquals(len(queue_recipients), 2) + self.assertEqual(len(queue_recipients), 2) self.assertTrue('Unsubscribe' in frappe.flags.sent_mail.decode()) def test_cc_header(self): @@ -59,7 +59,7 @@ class TestEmail(unittest.TestCase): reference_doctype='User', reference_name="Administrator", subject='Testing Email Queue', message='This is mail is queued!', unsubscribe_message="Unsubscribe", expose_recipients="header") email_queue = frappe.db.sql("""select name from `tabEmail Queue` where status='Not Sent'""", as_dict=1) - self.assertEquals(len(email_queue), 1) + self.assertEqual(len(email_queue), 1) queue_recipients = [r.recipient for r in frappe.db.sql("""select recipient from `tabEmail Queue Recipient` where status='Not Sent'""", as_dict=1)] self.assertTrue('test@example.com' in queue_recipients) @@ -78,7 +78,7 @@ class TestEmail(unittest.TestCase): reference_doctype='User', reference_name="Administrator", subject='Testing Email Queue', message='This is mail is queued!', unsubscribe_message="Unsubscribe", expose_recipients="footer", now=True) email_queue = frappe.db.sql("""select name from `tabEmail Queue` where status='Sent'""", as_dict=1) - self.assertEquals(len(email_queue), 1) + self.assertEqual(len(email_queue), 1) queue_recipients = [r.recipient for r in frappe.db.sql("""select recipient from `tabEmail Queue Recipient` where status='Sent'""", as_dict=1)] self.assertTrue('test@example.com' in queue_recipients) @@ -94,7 +94,7 @@ class TestEmail(unittest.TestCase): reference_doctype='User', reference_name="Administrator", subject='Testing Email Queue', message='This is mail is queued!', unsubscribe_message="Unsubscribe", now=True) email_queue = frappe.db.sql("""select name from `tabEmail Queue` where status='Sent'""", as_dict=1) - self.assertEquals(len(email_queue), 1) + self.assertEqual(len(email_queue), 1) queue_recipients = [r.recipient for r in frappe.db.sql("""select recipient from `tabEmail Queue Recipient` where status='Sent'""", as_dict=1)] self.assertTrue('test@example.com' in queue_recipients) @@ -119,12 +119,12 @@ class TestEmail(unittest.TestCase): from frappe.email.queue import clear_outbox clear_outbox() email_queue = frappe.db.sql("""select name from `tabEmail Queue` where status='Expired'""", as_dict=1) - self.assertEquals(len(email_queue), 1) + self.assertEqual(len(email_queue), 1) queue_recipients = [r.recipient for r in frappe.db.sql("""select recipient from `tabEmail Queue Recipient` where parent = %s""",email_queue[0].name, as_dict=1)] self.assertTrue('test@example.com' in queue_recipients) self.assertTrue('test1@example.com' in queue_recipients) - self.assertEquals(len(queue_recipients), 2) + self.assertEqual(len(queue_recipients), 2) def test_unsubscribe(self): from frappe.email.queue import unsubscribe, send @@ -144,12 +144,12 @@ class TestEmail(unittest.TestCase): email_queue = frappe.db.sql("""select name from `tabEmail Queue` where status='Not Sent'""", as_dict=1) - self.assertEquals(len(email_queue), before + 1) + self.assertEqual(len(email_queue), before + 1) queue_recipients = [r.recipient for r in frappe.db.sql("""select recipient from `tabEmail Queue Recipient` where status='Not Sent'""", as_dict=1)] self.assertFalse('test@example.com' in queue_recipients) self.assertTrue('test1@example.com' in queue_recipients) - self.assertEquals(len(queue_recipients), 1) + self.assertEqual(len(queue_recipients), 1) self.assertTrue('Unsubscribe' in frappe.flags.sent_mail.decode()) def test_email_queue_limit(self): diff --git a/frappe/tests/test_fmt_money.py b/frappe/tests/test_fmt_money.py index b46b31d8dd..4fc8877d97 100644 --- a/frappe/tests/test_fmt_money.py +++ b/frappe/tests/test_fmt_money.py @@ -10,78 +10,78 @@ import unittest class TestFmtMoney(unittest.TestCase): def test_standard(self): frappe.db.set_default("number_format", "#,###.##") - self.assertEquals(fmt_money(100), "100.00") - self.assertEquals(fmt_money(1000), "1,000.00") - self.assertEquals(fmt_money(10000), "10,000.00") - self.assertEquals(fmt_money(100000), "100,000.00") - self.assertEquals(fmt_money(1000000), "1,000,000.00") - self.assertEquals(fmt_money(10000000), "10,000,000.00") - self.assertEquals(fmt_money(100000000), "100,000,000.00") - self.assertEquals(fmt_money(1000000000), "1,000,000,000.00") + self.assertEqual(fmt_money(100), "100.00") + self.assertEqual(fmt_money(1000), "1,000.00") + self.assertEqual(fmt_money(10000), "10,000.00") + self.assertEqual(fmt_money(100000), "100,000.00") + self.assertEqual(fmt_money(1000000), "1,000,000.00") + self.assertEqual(fmt_money(10000000), "10,000,000.00") + self.assertEqual(fmt_money(100000000), "100,000,000.00") + self.assertEqual(fmt_money(1000000000), "1,000,000,000.00") def test_negative(self): frappe.db.set_default("number_format", "#,###.##") - self.assertEquals(fmt_money(-100), "-100.00") - self.assertEquals(fmt_money(-1000), "-1,000.00") - self.assertEquals(fmt_money(-10000), "-10,000.00") - self.assertEquals(fmt_money(-100000), "-100,000.00") - self.assertEquals(fmt_money(-1000000), "-1,000,000.00") - self.assertEquals(fmt_money(-10000000), "-10,000,000.00") - self.assertEquals(fmt_money(-100000000), "-100,000,000.00") - self.assertEquals(fmt_money(-1000000000), "-1,000,000,000.00") + self.assertEqual(fmt_money(-100), "-100.00") + self.assertEqual(fmt_money(-1000), "-1,000.00") + self.assertEqual(fmt_money(-10000), "-10,000.00") + self.assertEqual(fmt_money(-100000), "-100,000.00") + self.assertEqual(fmt_money(-1000000), "-1,000,000.00") + self.assertEqual(fmt_money(-10000000), "-10,000,000.00") + self.assertEqual(fmt_money(-100000000), "-100,000,000.00") + self.assertEqual(fmt_money(-1000000000), "-1,000,000,000.00") def test_decimal(self): frappe.db.set_default("number_format", "#.###,##") - self.assertEquals(fmt_money(-100), "-100,00") - self.assertEquals(fmt_money(-1000), "-1.000,00") - self.assertEquals(fmt_money(-10000), "-10.000,00") - self.assertEquals(fmt_money(-100000), "-100.000,00") - self.assertEquals(fmt_money(-1000000), "-1.000.000,00") - self.assertEquals(fmt_money(-10000000), "-10.000.000,00") - self.assertEquals(fmt_money(-100000000), "-100.000.000,00") - self.assertEquals(fmt_money(-1000000000), "-1.000.000.000,00") + self.assertEqual(fmt_money(-100), "-100,00") + self.assertEqual(fmt_money(-1000), "-1.000,00") + self.assertEqual(fmt_money(-10000), "-10.000,00") + self.assertEqual(fmt_money(-100000), "-100.000,00") + self.assertEqual(fmt_money(-1000000), "-1.000.000,00") + self.assertEqual(fmt_money(-10000000), "-10.000.000,00") + self.assertEqual(fmt_money(-100000000), "-100.000.000,00") + self.assertEqual(fmt_money(-1000000000), "-1.000.000.000,00") def test_lacs(self): frappe.db.set_default("number_format", "#,##,###.##") - self.assertEquals(fmt_money(100), "100.00") - self.assertEquals(fmt_money(1000), "1,000.00") - self.assertEquals(fmt_money(10000), "10,000.00") - self.assertEquals(fmt_money(100000), "1,00,000.00") - self.assertEquals(fmt_money(1000000), "10,00,000.00") - self.assertEquals(fmt_money(10000000), "1,00,00,000.00") - self.assertEquals(fmt_money(100000000), "10,00,00,000.00") - self.assertEquals(fmt_money(1000000000), "1,00,00,00,000.00") + self.assertEqual(fmt_money(100), "100.00") + self.assertEqual(fmt_money(1000), "1,000.00") + self.assertEqual(fmt_money(10000), "10,000.00") + self.assertEqual(fmt_money(100000), "1,00,000.00") + self.assertEqual(fmt_money(1000000), "10,00,000.00") + self.assertEqual(fmt_money(10000000), "1,00,00,000.00") + self.assertEqual(fmt_money(100000000), "10,00,00,000.00") + self.assertEqual(fmt_money(1000000000), "1,00,00,00,000.00") def test_no_precision(self): frappe.db.set_default("number_format", "#,###") - self.assertEquals(fmt_money(0.3), "0") - self.assertEquals(fmt_money(100.3), "100") - self.assertEquals(fmt_money(1000.3), "1,000") - self.assertEquals(fmt_money(10000.3), "10,000") - self.assertEquals(fmt_money(-0.3), "0") - self.assertEquals(fmt_money(-100.3), "-100") - self.assertEquals(fmt_money(-1000.3), "-1,000") + self.assertEqual(fmt_money(0.3), "0") + self.assertEqual(fmt_money(100.3), "100") + self.assertEqual(fmt_money(1000.3), "1,000") + self.assertEqual(fmt_money(10000.3), "10,000") + self.assertEqual(fmt_money(-0.3), "0") + self.assertEqual(fmt_money(-100.3), "-100") + self.assertEqual(fmt_money(-1000.3), "-1,000") def test_currency_precision(self): frappe.db.set_default("currency_precision", "4") frappe.db.set_default("number_format", "#,###.##") - self.assertEquals(fmt_money(100), "100.00") - self.assertEquals(fmt_money(1000), "1,000.00") - self.assertEquals(fmt_money(10000), "10,000.00") - self.assertEquals(fmt_money(100000), "100,000.00") - self.assertEquals(fmt_money(1000000), "1,000,000.00") - self.assertEquals(fmt_money(10000000), "10,000,000.00") - self.assertEquals(fmt_money(100000000), "100,000,000.00") - self.assertEquals(fmt_money(1000000000), "1,000,000,000.00") - self.assertEquals(fmt_money(100.23), "100.23") - self.assertEquals(fmt_money(1000.456), "1,000.456") - self.assertEquals(fmt_money(10000.7890), "10,000.789") - self.assertEquals(fmt_money(100000.1234), "100,000.1234") - self.assertEquals(fmt_money(1000000.3456), "1,000,000.3456") - self.assertEquals(fmt_money(10000000.3344567), "10,000,000.3345") - self.assertEquals(fmt_money(100000000.37827268), "100,000,000.378") - self.assertEquals(fmt_money(1000000000.2718272637), "1,000,000,000.27") + self.assertEqual(fmt_money(100), "100.00") + self.assertEqual(fmt_money(1000), "1,000.00") + self.assertEqual(fmt_money(10000), "10,000.00") + self.assertEqual(fmt_money(100000), "100,000.00") + self.assertEqual(fmt_money(1000000), "1,000,000.00") + self.assertEqual(fmt_money(10000000), "10,000,000.00") + self.assertEqual(fmt_money(100000000), "100,000,000.00") + self.assertEqual(fmt_money(1000000000), "1,000,000,000.00") + self.assertEqual(fmt_money(100.23), "100.23") + self.assertEqual(fmt_money(1000.456), "1,000.456") + self.assertEqual(fmt_money(10000.7890), "10,000.789") + self.assertEqual(fmt_money(100000.1234), "100,000.1234") + self.assertEqual(fmt_money(1000000.3456), "1,000,000.3456") + self.assertEqual(fmt_money(10000000.3344567), "10,000,000.3345") + self.assertEqual(fmt_money(100000000.37827268), "100,000,000.378") + self.assertEqual(fmt_money(1000000000.2718272637), "1,000,000,000.27") frappe.db.set_default("currency_precision", "") if __name__=="__main__": diff --git a/frappe/tests/test_form_load.py b/frappe/tests/test_form_load.py index bab8b1c4ee..b612f8c487 100644 --- a/frappe/tests/test_form_load.py +++ b/frappe/tests/test_form_load.py @@ -11,7 +11,7 @@ class TestFormLoad(unittest.TestCase): def test_load(self): getdoctype("DocType") meta = filter(lambda d: d.name=="DocType", frappe.response.docs)[0] - self.assertEquals(meta.name, "DocType") + self.assertEqual(meta.name, "DocType") self.assertTrue(meta.get("__js")) frappe.response.docs = [] @@ -43,7 +43,7 @@ class TestFormLoad(unittest.TestCase): for doc in frappe.response.docs: if doc.name == blog: - self.assertEquals(doc.published, None) + self.assertEqual(doc.published, None) checked = True self.assertTrue(checked, True) @@ -60,7 +60,7 @@ class TestFormLoad(unittest.TestCase): for doc in frappe.response.docs: if doc.name == blog: - self.assertEquals(doc.published, 1) + self.assertEqual(doc.published, 1) checked = True self.assertTrue(checked, True) diff --git a/frappe/tests/test_geo_ip.py b/frappe/tests/test_geo_ip.py index d71b4dc10d..23a2881ec5 100644 --- a/frappe/tests/test_geo_ip.py +++ b/frappe/tests/test_geo_ip.py @@ -9,6 +9,6 @@ class TestGeoIP(unittest.TestCase): def test_geo_ip(self): return from frappe.sessions import get_geo_ip_country - self.assertEquals(get_geo_ip_country("223.29.223.255"), "India") - self.assertEquals(get_geo_ip_country("4.18.32.80"), "United States") - self.assertEquals(get_geo_ip_country("217.194.147.25"), "United States") \ No newline at end of file + self.assertEqual(get_geo_ip_country("223.29.223.255"), "India") + self.assertEqual(get_geo_ip_country("4.18.32.80"), "United States") + self.assertEqual(get_geo_ip_country("217.194.147.25"), "United States") \ No newline at end of file diff --git a/frappe/tests/test_global_search.py b/frappe/tests/test_global_search.py index b69205950a..d132288421 100644 --- a/frappe/tests/test_global_search.py +++ b/frappe/tests/test_global_search.py @@ -67,13 +67,13 @@ class TestGlobalSearch(unittest.TestCase): def test_update_fields(self): self.insert_test_events() results = global_search.search('Every Month') - self.assertEquals(len(results), 0) + self.assertEqual(len(results), 0) doctype = "Event" from frappe.custom.doctype.property_setter.property_setter import make_property_setter make_property_setter(doctype, "repeat_on", "in_global_search", 1, "Int") global_search.rebuild_for_doctype(doctype) results = global_search.search('Every Month') - self.assertEquals(len(results), 3) + self.assertEqual(len(results), 3) def test_delete_doc(self): self.insert_test_events() @@ -82,12 +82,12 @@ class TestGlobalSearch(unittest.TestCase): event = frappe.get_doc('Event', event_name) test_subject = event.subject results = global_search.search(test_subject) - self.assertEquals(len(results), 1) + self.assertEqual(len(results), 1) frappe.delete_doc('Event', event_name) results = global_search.search(test_subject) - self.assertEquals(len(results), 0) + self.assertEqual(len(results), 0) def test_insert_child_table(self): frappe.db.sql('delete from tabEvent') @@ -174,4 +174,4 @@ class TestGlobalSearch(unittest.TestCase): if field.fieldname == 'description': field_as_text = global_search.get_formatted_value(doc.description, field) - self.assertEquals(case["result"], field_as_text) + self.assertEqual(case["result"], field_as_text) diff --git a/frappe/tests/test_goal.py b/frappe/tests/test_goal.py index 20c2a9a399..d17dc909c7 100644 --- a/frappe/tests/test_goal.py +++ b/frappe/tests/test_goal.py @@ -23,7 +23,7 @@ class TestGoal(unittest.TestCase): result_dict = get_monthly_results('Event', 'subject', 'creation', 'event_type="Private"', 'count') from frappe.utils import today, formatdate - self.assertEquals(result_dict[formatdate(today(), "MM-yyyy")], 2) + self.assertEqual(result_dict[formatdate(today(), "MM-yyyy")], 2) def test_get_monthly_goal_graph_data(self): '''Test for accurate values in graph data (based on test_get_monthly_results)''' @@ -31,4 +31,4 @@ class TestGoal(unittest.TestCase): frappe.db.set_value('Event', docname, 'description', 1) data = get_monthly_goal_graph_data('Test', 'Event', docname, 'description', 'description', 'description', 'Event', '', 'description', 'creation', 'starts_on = "2014-01-01"', 'count') - self.assertEquals(float(data['data']['datasets'][0]['values'][-1]), 1) + self.assertEqual(float(data['data']['datasets'][0]['values'][-1]), 1) diff --git a/frappe/tests/test_naming.py b/frappe/tests/test_naming.py index 1e00fd4be0..487223734a 100644 --- a/frappe/tests/test_naming.py +++ b/frappe/tests/test_naming.py @@ -22,7 +22,7 @@ class TestNaming(unittest.TestCase): note.insert() title2 = append_number_if_name_exists('Note', 'Test') - self.assertEquals(title2, 'Test-1') + self.assertEqual(title2, 'Test-1') title2 = append_number_if_name_exists('Note', 'Test', 'title', '_') - self.assertEquals(title2, 'Test_1') + self.assertEqual(title2, 'Test_1') diff --git a/frappe/tests/test_password.py b/frappe/tests/test_password.py index f35f778ab9..0bf9bbfb37 100644 --- a/frappe/tests/test_password.py +++ b/frappe/tests/test_password.py @@ -17,7 +17,7 @@ class TestPassword(unittest.TestCase): doc.password = new_password doc.save() - self.assertEquals(doc.password, '*'*len(new_password)) + self.assertEqual(doc.password, '*'*len(new_password)) auth_password = frappe.db.sql('''select `password` from `__Auth` where doctype=%(doctype)s and name=%(name)s and fieldname="password"''', doc.as_dict())[0][0] @@ -26,7 +26,7 @@ class TestPassword(unittest.TestCase): self.assertTrue(auth_password != new_password) # decrypted - self.assertEquals(doc.get_password(), new_password) + self.assertEqual(doc.get_password(), new_password) return doc, new_password @@ -59,7 +59,7 @@ class TestPassword(unittest.TestCase): self.assertTrue(auth.salt) # stored password = password(plain_text_password + salt) - self.assertEquals(frappe.db.sql('select password(concat(%s, %s))', (new_password, auth.salt))[0][0], auth.password) + self.assertEqual(frappe.db.sql('select password(concat(%s, %s))', (new_password, auth.salt))[0][0], auth.password) self.assertTrue(check_password(user, new_password)) @@ -82,7 +82,7 @@ class TestPassword(unittest.TestCase): frappe.rename_doc(doc.doctype, old_name, new_name) new_doc = frappe.get_doc(doc.doctype, new_name) - self.assertEquals(new_doc.get_password(), password) + self.assertEqual(new_doc.get_password(), password) self.assertTrue(not frappe.db.sql('''select `password` from `__Auth` where doctype=%s and name=%s and fieldname="password"''', (doc.doctype, doc.name))) diff --git a/frappe/tests/test_permissions.py b/frappe/tests/test_permissions.py index 7a03943016..9771c6e301 100644 --- a/frappe/tests/test_permissions.py +++ b/frappe/tests/test_permissions.py @@ -108,7 +108,7 @@ class TestPermissions(unittest.TestCase): frappe.set_user("test2@example.com") doc = frappe.new_doc("Blog Post") - self.assertEquals(doc.get("blog_category"), "_Test Blog Category 1") + self.assertEqual(doc.get("blog_category"), "_Test Blog Category 1") def test_user_link_match_doc(self): self.set_user_permission_doctypes(["Blogger"]) @@ -343,7 +343,7 @@ class TestPermissions(unittest.TestCase): self.set_strict_user_permissions(0) frappe.set_user("test3@example.com") - self.assertEquals(len(frappe.get_list("Contact")), 2) + self.assertEqual(len(frappe.get_list("Contact")), 2) frappe.set_user("Administrator") self.set_strict_user_permissions(1) diff --git a/frappe/tests/test_translation.py b/frappe/tests/test_translation.py index 8c44fbeacf..0e1e6e452c 100644 --- a/frappe/tests/test_translation.py +++ b/frappe/tests/test_translation.py @@ -45,7 +45,7 @@ import frappe.translate # self.assertFalse(frappe.cache().hget("lang_full_dict", "de")) # # langdict = frappe.translate.get_full_dict("de") -# self.assertEquals(langdict['Row'], 'Reihe') +# self.assertEqual(langdict['Row'], 'Reihe') # # def test_write_csv(self): # tpath = frappe.get_pymodule_path("frappe", "translations", "de.csv") @@ -53,11 +53,11 @@ import frappe.translate # os.remove(tpath) # frappe.translate.write_translations_file("frappe", "de") # self.assertTrue(os.path.exists(tpath)) -# self.assertEquals(dict(frappe.translate.read_csv_file(tpath)).get("Row"), "Reihe") +# self.assertEqual(dict(frappe.translate.read_csv_file(tpath)).get("Row"), "Reihe") # # def test_get_dict(self): # frappe.local.lang = "de" -# self.assertEquals(frappe.get_lang_dict("doctype", "Role").get("Role"), "Rolle") +# self.assertEqual(frappe.get_lang_dict("doctype", "Role").get("Role"), "Rolle") # frappe.local.lang = "en" # # if __name__=="__main__": diff --git a/frappe/website/doctype/web_form/test_web_form.py b/frappe/website/doctype/web_form/test_web_form.py index ab2af2fb49..87d1622820 100644 --- a/frappe/website/doctype/web_form/test_web_form.py +++ b/frappe/website/doctype/web_form/test_web_form.py @@ -64,5 +64,5 @@ class TestWebForm(unittest.TestCase): accept(web_form='manage-events', data=json.dumps(doc)) - self.assertEquals(frappe.db.get_value("Event", + self.assertEqual(frappe.db.get_value("Event", self.event_name, "description"), doc.get('description'))