[tests] Fix, removing deprecated function for future Python release compatibility.

tests/access_tests.py

@@ -129,23 +129,23 @@ def test_override_role_permissions_is_admin_only(self):
             content_type="application/json",
             follow_redirects=True,
         )
-        self.assertNotEquals(405, response.status_code)
+        self.assertNotEqual(405, response.status_code)
 
     def test_override_role_permissions_1_table(self):
         response = self.client.post(
             "/superset/override_role_permissions/",
             data=json.dumps(ROLE_TABLES_PERM_DATA),
             content_type="application/json",
         )
-        self.assertEquals(201, response.status_code)
+        self.assertEqual(201, response.status_code)
 
         updated_override_me = security_manager.find_role("override_me")
-        self.assertEquals(1, len(updated_override_me.permissions))
+        self.assertEqual(1, len(updated_override_me.permissions))
         birth_names = self.get_table_by_name("birth_names")
-        self.assertEquals(
+        self.assertEqual(
             birth_names.perm, updated_override_me.permissions[0].view_menu.name
         )
-        self.assertEquals(
+        self.assertEqual(
             "datasource_access", updated_override_me.permissions[0].permission.name
         )
 
@@ -155,26 +155,26 @@ def test_override_role_permissions_druid_and_table(self):
             data=json.dumps(ROLE_ALL_PERM_DATA),
             content_type="application/json",
         )
-        self.assertEquals(201, response.status_code)
+        self.assertEqual(201, response.status_code)
 
         updated_role = security_manager.find_role("override_me")
         perms = sorted(updated_role.permissions, key=lambda p: p.view_menu.name)
         druid_ds_1 = self.get_druid_ds_by_name("druid_ds_1")
-        self.assertEquals(druid_ds_1.perm, perms[0].view_menu.name)
-        self.assertEquals("datasource_access", perms[0].permission.name)
+        self.assertEqual(druid_ds_1.perm, perms[0].view_menu.name)
+        self.assertEqual("datasource_access", perms[0].permission.name)
 
         druid_ds_2 = self.get_druid_ds_by_name("druid_ds_2")
-        self.assertEquals(druid_ds_2.perm, perms[1].view_menu.name)
-        self.assertEquals(
+        self.assertEqual(druid_ds_2.perm, perms[1].view_menu.name)
+        self.assertEqual(
             "datasource_access", updated_role.permissions[1].permission.name
         )
 
         birth_names = self.get_table_by_name("birth_names")
-        self.assertEquals(birth_names.perm, perms[2].view_menu.name)
-        self.assertEquals(
+        self.assertEqual(birth_names.perm, perms[2].view_menu.name)
+        self.assertEqual(
             "datasource_access", updated_role.permissions[2].permission.name
         )
-        self.assertEquals(3, len(perms))
+        self.assertEqual(3, len(perms))
 
     def test_override_role_permissions_drops_absent_perms(self):
         override_me = security_manager.find_role("override_me")
@@ -191,14 +191,14 @@ def test_override_role_permissions_drops_absent_perms(self):
             data=json.dumps(ROLE_TABLES_PERM_DATA),
             content_type="application/json",
         )
-        self.assertEquals(201, response.status_code)
+        self.assertEqual(201, response.status_code)
         updated_override_me = security_manager.find_role("override_me")
-        self.assertEquals(1, len(updated_override_me.permissions))
+        self.assertEqual(1, len(updated_override_me.permissions))
         birth_names = self.get_table_by_name("birth_names")
-        self.assertEquals(
+        self.assertEqual(
             birth_names.perm, updated_override_me.permissions[0].view_menu.name
         )
-        self.assertEquals(
+        self.assertEqual(
             "datasource_access", updated_override_me.permissions[0].permission.name
         )
 

tests/base_tests.py

@@ -255,8 +255,8 @@ def test_nonexistent_feature_flags(self):
         self.assertFalse(is_feature_enabled("FOO"))
 
     def test_feature_flags(self):
-        self.assertEquals(is_feature_enabled("foo"), "bar")
-        self.assertEquals(is_feature_enabled("super"), "set")
+        self.assertEqual(is_feature_enabled("foo"), "bar")
+        self.assertEqual(is_feature_enabled("super"), "set")
 
     def get_dash_by_slug(self, dash_slug):
         sesh = db.session()

tests/celery_tests.py

@@ -156,7 +156,7 @@ def test_run_sync_query_cta(self):
         if backend != "postgresql":
             # TODO This test won't work in Postgres
             results = self.run_sql(db_id, query2.select_sql, "sdf2134")
-            self.assertEquals(results["status"], "success")
+            self.assertEqual(results["status"], "success")
             self.assertGreater(len(results["data"]), 0)
 
     def test_run_sync_query_cta_no_data(self):

tests/dashboard_tests.py

@@ -69,7 +69,7 @@ def test_new_dashboard(self):
         resp = self.get_resp(url)
         self.assertIn("[ untitled dashboard ]", resp)
         dash_count_after = db.session.query(func.count(models.Dashboard.id)).first()[0]
-        self.assertEquals(dash_count_before + 1, dash_count_after)
+        self.assertEqual(dash_count_before + 1, dash_count_after)
 
     def test_dashboard_modes(self):
         self.login(username="admin")

tests/dataframe_test.py

@@ -25,16 +25,16 @@
 
 class SupersetDataFrameTestCase(SupersetTestCase):
     def test_dedup(self):
-        self.assertEquals(dedup(["foo", "bar"]), ["foo", "bar"])
-        self.assertEquals(
+        self.assertEqual(dedup(["foo", "bar"]), ["foo", "bar"])
+        self.assertEqual(
             dedup(["foo", "bar", "foo", "bar", "Foo"]),
             ["foo", "bar", "foo__1", "bar__1", "Foo"],
         )
-        self.assertEquals(
+        self.assertEqual(
             dedup(["foo", "bar", "bar", "bar", "Bar"]),
             ["foo", "bar", "bar__1", "bar__2", "Bar"],
         )
-        self.assertEquals(
+        self.assertEqual(
             dedup(["foo", "bar", "bar", "bar", "Bar"], case_sensitive=False),
             ["foo", "bar", "bar__1", "bar__2", "Bar__3"],
         )
@@ -96,14 +96,14 @@ def test_get_columns_type_inference(self):
 
     def test_is_date(self):
         f = SupersetDataFrame.is_date
-        self.assertEquals(f(np.dtype("M"), ""), True)
-        self.assertEquals(f(np.dtype("f"), "DATETIME"), True)
-        self.assertEquals(f(np.dtype("i"), "TIMESTAMP"), True)
-        self.assertEquals(f(None, "DATETIME"), True)
-        self.assertEquals(f(None, "TIMESTAMP"), True)
+        self.assertEqual(f(np.dtype("M"), ""), True)
+        self.assertEqual(f(np.dtype("f"), "DATETIME"), True)
+        self.assertEqual(f(np.dtype("i"), "TIMESTAMP"), True)
+        self.assertEqual(f(None, "DATETIME"), True)
+        self.assertEqual(f(None, "TIMESTAMP"), True)
 
-        self.assertEquals(f(None, ""), False)
-        self.assertEquals(f(np.dtype(np.int32), ""), False)
+        self.assertEqual(f(None, ""), False)
+        self.assertEqual(f(np.dtype(np.int32), ""), False)
 
     def test_dedup_with_data(self):
         data = [("a", 1), ("a", 2)]

tests/datasource_tests.py

@@ -37,7 +37,7 @@ def test_external_metadata(self):
         )
         resp = self.get_json_resp(url)
         col_names = {o.get("name") for o in resp}
-        self.assertEquals(
+        self.assertEqual(
             col_names, {"sum_boys", "num", "gender", "name", "ds", "state", "sum_girls"}
         )
 
@@ -47,7 +47,7 @@ def compare_lists(self, l1, l2, key):
             obj2 = l2_lookup.get(obj1.get(key))
             for k in obj1:
                 if k not in "id" and obj1.get(k):
-                    self.assertEquals(obj1.get(k), obj2.get(k))
+                    self.assertEqual(obj1.get(k), obj2.get(k))
 
     def test_save(self):
         self.login(username="admin")
@@ -61,16 +61,16 @@ def test_save(self):
             elif k == "metrics":
                 self.compare_lists(datasource_post[k], resp[k], "metric_name")
             else:
-                self.assertEquals(resp[k], datasource_post[k])
+                self.assertEqual(resp[k], datasource_post[k])
 
     def test_get_datasource(self):
         self.login(username="admin")
         tbl = self.get_table_by_name("birth_names")
         url = f"/datasource/get/{tbl.type}/{tbl.id}/"
         resp = self.get_json_resp(url)
-        self.assertEquals(resp.get("type"), "table")
+        self.assertEqual(resp.get("type"), "table")
         col_names = {o.get("column_name") for o in resp["columns"]}
-        self.assertEquals(
+        self.assertEqual(
             col_names,
             {
                 "sum_boys",
@@ -88,4 +88,4 @@ def test_get_datasource_failed(self):
         self.login(username="admin")
         url = f"/datasource/get/druid/500000/"
         resp = self.get_json_resp(url)
-        self.assertEquals(resp.get("error"), "This datasource does not exist")
+        self.assertEqual(resp.get("error"), "This datasource does not exist")

tests/db_engine_specs_test.py

@@ -49,15 +49,15 @@ def test_0_progress(self):
         """.split(
             "\n"
         )
-        self.assertEquals(0, HiveEngineSpec.progress(log))
+        self.assertEqual(0, HiveEngineSpec.progress(log))
 
     def test_number_of_jobs_progress(self):
         log = """
             17/02/07 19:15:55 INFO ql.Driver: Total jobs = 2
         """.split(
             "\n"
         )
-        self.assertEquals(0, HiveEngineSpec.progress(log))
+        self.assertEqual(0, HiveEngineSpec.progress(log))
 
     def test_job_1_launched_progress(self):
         log = """
@@ -66,7 +66,7 @@ def test_job_1_launched_progress(self):
         """.split(
             "\n"
         )
-        self.assertEquals(0, HiveEngineSpec.progress(log))
+        self.assertEqual(0, HiveEngineSpec.progress(log))
 
     def test_job_1_launched_stage_1_0_progress(self):
         log = """
@@ -76,7 +76,7 @@ def test_job_1_launched_stage_1_0_progress(self):
         """.split(
             "\n"
         )
-        self.assertEquals(0, HiveEngineSpec.progress(log))
+        self.assertEqual(0, HiveEngineSpec.progress(log))
 
     def test_job_1_launched_stage_1_map_40_progress(self):
         log = """
@@ -87,7 +87,7 @@ def test_job_1_launched_stage_1_map_40_progress(self):
         """.split(
             "\n"
         )
-        self.assertEquals(10, HiveEngineSpec.progress(log))
+        self.assertEqual(10, HiveEngineSpec.progress(log))
 
     def test_job_1_launched_stage_1_map_80_reduce_40_progress(self):
         log = """
@@ -99,7 +99,7 @@ def test_job_1_launched_stage_1_map_80_reduce_40_progress(self):
         """.split(
             "\n"
         )
-        self.assertEquals(30, HiveEngineSpec.progress(log))
+        self.assertEqual(30, HiveEngineSpec.progress(log))
 
     def test_job_1_launched_stage_2_stages_progress(self):
         log = """
@@ -113,7 +113,7 @@ def test_job_1_launched_stage_2_stages_progress(self):
         """.split(
             "\n"
         )
-        self.assertEquals(12, HiveEngineSpec.progress(log))
+        self.assertEqual(12, HiveEngineSpec.progress(log))
 
     def test_job_2_launched_stage_2_stages_progress(self):
         log = """
@@ -126,7 +126,7 @@ def test_job_2_launched_stage_2_stages_progress(self):
         """.split(
             "\n"
         )
-        self.assertEquals(60, HiveEngineSpec.progress(log))
+        self.assertEqual(60, HiveEngineSpec.progress(log))
 
     def test_hive_error_msg(self):
         msg = (
@@ -135,7 +135,7 @@ def test_hive_error_msg(self):
             ":5 Table not found 'fact_ridesfdslakj'\", statusCode=3, "
             "sqlState='42S02', errorCode=10001)){...}"
         )
-        self.assertEquals(
+        self.assertEqual(
             (
                 "hive error: Error while compiling statement: FAILED: "
                 "SemanticException [Error 10001]: Line 4:5 "
@@ -145,14 +145,14 @@ def test_hive_error_msg(self):
         )
 
         e = Exception("Some string that doesn't match the regex")
-        self.assertEquals(f"hive error: {e}", HiveEngineSpec.extract_error_message(e))
+        self.assertEqual(f"hive error: {e}", HiveEngineSpec.extract_error_message(e))
 
         msg = (
             "errorCode=10001, "
             'errorMessage="Error while compiling statement"), operationHandle'
             '=None)"'
         )
-        self.assertEquals(
+        self.assertEqual(
             ("hive error: Error while compiling statement"),
             HiveEngineSpec.extract_error_message(Exception(msg)),
         )
@@ -165,7 +165,7 @@ def sql_limit_regex(
     ):
         main = self.get_generic_database()
         limited = engine_spec_class.apply_limit_to_sql(sql, limit, main)
-        self.assertEquals(expected_sql, limited)
+        self.assertEqual(expected_sql, limited)
 
     def test_extract_limit_from_query(self, engine_spec_class=MySQLEngineSpec):
         q0 = "select * from table"
@@ -259,17 +259,17 @@ def test_limit_expr_and_semicolon(self):
         SupersetTestCase.is_module_installed("MySQLdb"), "mysqlclient not installed"
     )
     def test_get_datatype_mysql(self):
-        self.assertEquals("TINY", MySQLEngineSpec.get_datatype(1))
-        self.assertEquals("VARCHAR", MySQLEngineSpec.get_datatype(15))
+        self.assertEqual("TINY", MySQLEngineSpec.get_datatype(1))
+        self.assertEqual("VARCHAR", MySQLEngineSpec.get_datatype(15))
 
     @unittest.skipUnless(
         SupersetTestCase.is_module_installed("pyhive"), "pyhive not installed"
     )
     def test_get_datatype_presto(self):
-        self.assertEquals("STRING", PrestoEngineSpec.get_datatype("string"))
+        self.assertEqual("STRING", PrestoEngineSpec.get_datatype("string"))
 
     def test_get_datatype(self):
-        self.assertEquals("VARCHAR", BaseEngineSpec.get_datatype("VARCHAR"))
+        self.assertEqual("VARCHAR", BaseEngineSpec.get_datatype("VARCHAR"))
 
     def test_limit_with_implicit_offset(self):
         self.sql_limit_regex(
@@ -342,7 +342,7 @@ def test_engine_time_grain_validity(self):
                 self.assertSetEqual(defined_grains, intersection, engine)
 
     def test_presto_get_view_names_return_empty_list(self):
-        self.assertEquals(
+        self.assertEqual(
             [], PrestoEngineSpec.get_view_names(mock.ANY, mock.ANY, mock.ANY)
         )
 
@@ -651,7 +651,7 @@ def test_presto_where_latest_partition(self):
         self.assertEqual("SELECT  \nWHERE ds = '01-01-19' AND hour = 1", query_result)
 
     def test_hive_get_view_names_return_empty_list(self):
-        self.assertEquals(
+        self.assertEqual(
             [], HiveEngineSpec.get_view_names(mock.ANY, mock.ANY, mock.ANY)
         )
 
@@ -806,4 +806,4 @@ def test_column_datatype_to_string(self):
             expected = ["VARCHAR(255)", "VARCHAR(255)", "DOUBLE PRECISION"]
         else:
             expected = ["VARCHAR(255)", "VARCHAR(255)", "FLOAT"]
-        self.assertEquals(col_names, expected)
+        self.assertEqual(col_names, expected)