Merge pull request #5103 from achillesrasquinha/py3

Fix Unittest

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

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)
+		self.assertEqual(user.name, frappe.session.user)

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()
 

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

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):

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, [])
+		self.assertEqual(new_role_profile.roles, [])

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 = [

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",

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]

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")

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()
 

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()

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'])

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'))

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)

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)

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)

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):

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())
 
 

frappe/email/test_email_body.py

@@ -94,7 +94,7 @@ w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 				<img  />
 			</div>
 		'''.format(inline_images[0].get('content_id'))
-		self.assertEquals(message, processed_message)
+		self.assertEqual(message, processed_message)
 
 	def test_inline_styling(self):
 		html = '''

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"]]])

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')

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

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):

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)

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)

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('<!--unsubscribe url-->' 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):

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__":

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)

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")
+		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")

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)

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)

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')

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)))
 

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)

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__":

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'))