chore: enable lint PT009 'use regular assert over self.assert.*' (#30521)

tests/integration_tests/core_tests.py

@@ -114,15 +114,15 @@ class TestCore(SupersetTestCase):
 
     def test_login(self):
         resp = self.get_resp("/login/", data=dict(username="admin", password="general"))
-        self.assertNotIn("User confirmation needed", resp)
+        assert "User confirmation needed" not in resp
 
         resp = self.get_resp("/logout/", follow_redirects=True)
-        self.assertIn("User confirmation needed", resp)
+        assert "User confirmation needed" in resp
 
         resp = self.get_resp(
             "/login/", data=dict(username="admin", password="wrongPassword")
         )
-        self.assertIn("User confirmation needed", resp)
+        assert "User confirmation needed" in resp
 
     def test_dashboard_endpoint(self):
         self.login(ADMIN_USERNAME)
@@ -146,20 +146,17 @@ class TestCore(SupersetTestCase):
 
         qobj["groupby"] = []
         cache_key_with_groupby = viz.cache_key(qobj)
-        self.assertNotEqual(cache_key, cache_key_with_groupby)
+        assert cache_key != cache_key_with_groupby
 
-        self.assertNotEqual(
-            viz.cache_key(qobj), viz.cache_key(qobj, time_compare="12 weeks")
-        )
+        assert viz.cache_key(qobj) != viz.cache_key(qobj, time_compare="12 weeks")
 
-        self.assertNotEqual(
-            viz.cache_key(qobj, time_compare="28 days"),
-            viz.cache_key(qobj, time_compare="12 weeks"),
+        assert viz.cache_key(qobj, time_compare="28 days") != viz.cache_key(
+            qobj, time_compare="12 weeks"
         )
 
         qobj["inner_from_dttm"] = datetime.datetime(1901, 1, 1)
 
-        self.assertEqual(cache_key_with_groupby, viz.cache_key(qobj))
+        assert cache_key_with_groupby == viz.cache_key(qobj)
 
     def test_admin_only_menu_views(self):
         def assert_admin_view_menus_in(role_name, assert_func):
@@ -205,9 +202,9 @@ class TestCore(SupersetTestCase):
         new_slice_id = resp.json["form_data"]["slice_id"]
         slc = db.session.query(Slice).filter_by(id=new_slice_id).one()
 
-        self.assertEqual(slc.slice_name, copy_name)
+        assert slc.slice_name == copy_name
         form_data.pop("slice_id")  # We don't save the slice id when saving as
-        self.assertEqual(slc.viz.form_data, form_data)
+        assert slc.viz.form_data == form_data
 
         form_data = {
             "adhoc_filters": [],
@@ -224,8 +221,8 @@ class TestCore(SupersetTestCase):
             data={"form_data": json.dumps(form_data)},
         )
         slc = db.session.query(Slice).filter_by(id=new_slice_id).one()
-        self.assertEqual(slc.slice_name, new_slice_name)
-        self.assertEqual(slc.viz.form_data, form_data)
+        assert slc.slice_name == new_slice_name
+        assert slc.viz.form_data == form_data
 
         # Cleanup
         slices = (
@@ -261,21 +258,21 @@ class TestCore(SupersetTestCase):
             logger.info(f"[{name}]/[{method}]: {url}")
             print(f"[{name}]/[{method}]: {url}")
             resp = self.client.get(url)
-            self.assertEqual(resp.status_code, 200)
+            assert resp.status_code == 200
 
     def test_add_slice(self):
         self.login(ADMIN_USERNAME)
         # assert that /chart/add responds with 200
         url = "/chart/add"
         resp = self.client.get(url)
-        self.assertEqual(resp.status_code, 200)
+        assert resp.status_code == 200
 
     def test_get_user_slices(self):
         self.login(ADMIN_USERNAME)
         userid = security_manager.find_user("admin").id
         url = f"/sliceasync/api/read?_flt_0_created_by={userid}"
         resp = self.client.get(url)
-        self.assertEqual(resp.status_code, 200)
+        assert resp.status_code == 200
 
     @pytest.mark.usefixtures("load_energy_table_with_slice")
     def test_slices_V2(self):
@@ -339,7 +336,7 @@ class TestCore(SupersetTestCase):
         data["sqlalchemy_uri"] = database.safe_sqlalchemy_uri()
         self.client.post(url, data=data)
         database = superset.utils.database.get_example_database()
-        self.assertEqual(sqlalchemy_uri_decrypted, database.sqlalchemy_uri_decrypted)
+        assert sqlalchemy_uri_decrypted == database.sqlalchemy_uri_decrypted
 
         # Need to clean up after ourselves
         database.impersonate_user = False
@@ -355,9 +352,9 @@ class TestCore(SupersetTestCase):
         self.login(ADMIN_USERNAME)
         slc = self.get_slice("Top 10 Girl Name Share")
         data = self.get_json_resp(f"/superset/warm_up_cache?slice_id={slc.id}")
-        self.assertEqual(
-            data, [{"slice_id": slc.id, "viz_error": None, "viz_status": "success"}]
-        )
+        assert data == [
+            {"slice_id": slc.id, "viz_error": None, "viz_status": "success"}
+        ]
 
         data = self.get_json_resp(
             "/superset/warm_up_cache?table_name=energy_usage&db_name=main"
@@ -415,29 +412,29 @@ class TestCore(SupersetTestCase):
         self.login(ADMIN_USERNAME)
 
         resp = self.client.get("/kv/10001/")
-        self.assertEqual(404, resp.status_code)
+        assert 404 == resp.status_code
 
         value = json.dumps({"data": "this is a test"})
         resp = self.client.post("/kv/store/", data=dict(data=value))
-        self.assertEqual(resp.status_code, 404)
+        assert resp.status_code == 404
 
     @with_feature_flags(KV_STORE=True)
     def test_kv_enabled(self):
         self.login(ADMIN_USERNAME)
 
         resp = self.client.get("/kv/10001/")
-        self.assertEqual(404, resp.status_code)
+        assert 404 == resp.status_code
 
         value = json.dumps({"data": "this is a test"})
         resp = self.client.post("/kv/store/", data=dict(data=value))
-        self.assertEqual(resp.status_code, 200)
+        assert resp.status_code == 200
         kv = db.session.query(models.KeyValue).first()
         kv_value = kv.value
-        self.assertEqual(json.loads(value), json.loads(kv_value))
+        assert json.loads(value) == json.loads(kv_value)
 
         resp = self.client.get(f"/kv/{kv.id}/")
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(json.loads(value), json.loads(resp.data.decode("utf-8")))
+        assert resp.status_code == 200
+        assert json.loads(value) == json.loads(resp.data.decode("utf-8"))
 
     def test_gamma(self):
         self.login(GAMMA_USERNAME)
@@ -451,7 +448,7 @@ class TestCore(SupersetTestCase):
         self.login(ADMIN_USERNAME)
         sql = "SELECT '{{ 1+1 }}' as test"
         data = self.run_sql(sql, "fdaklj3ws")
-        self.assertEqual(data["data"][0]["test"], "2")
+        assert data["data"][0]["test"] == "2"
 
     def test_fetch_datasource_metadata(self):
         self.login(ADMIN_USERNAME)
@@ -466,7 +463,7 @@ class TestCore(SupersetTestCase):
             "id",
         ]
         for k in keys:
-            self.assertIn(k, resp.keys())
+            assert k in resp.keys()
 
     @pytest.mark.usefixtures("load_birth_names_dashboard_with_slices")
     def test_slice_id_is_always_logged_correctly_on_web_request(self):
@@ -475,7 +472,7 @@ class TestCore(SupersetTestCase):
         slc = db.session.query(Slice).filter_by(slice_name="Girls").one()
         qry = db.session.query(models.Log).filter_by(slice_id=slc.id)
         self.get_resp(slc.slice_url)
-        self.assertEqual(1, qry.count())
+        assert 1 == qry.count()
 
     def create_sample_csvfile(self, filename: str, content: list[str]) -> None:
         with open(filename, "w+") as test_file:
@@ -490,7 +487,7 @@ class TestCore(SupersetTestCase):
         database.allow_file_upload = True
         db.session.commit()
         add_datasource_page = self.get_resp("/databaseview/list/")
-        self.assertIn("Upload a CSV", add_datasource_page)
+        assert "Upload a CSV" in add_datasource_page
 
     def test_dataframe_timezone(self):
         tz = pytz.FixedOffset(60)
@@ -502,15 +499,15 @@ class TestCore(SupersetTestCase):
         df = results.to_pandas_df()
         data = dataframe.df_to_records(df)
         json_str = json.dumps(data, default=json.pessimistic_json_iso_dttm_ser)
-        self.assertDictEqual(
+        self.assertDictEqual(  # noqa: PT009
             data[0], {"data": pd.Timestamp("2017-11-18 21:53:00.219225+0100", tz=tz)}
         )
-        self.assertDictEqual(
+        self.assertDictEqual(  # noqa: PT009
             data[1], {"data": pd.Timestamp("2017-11-18 22:06:30+0100", tz=tz)}
         )
-        self.assertEqual(
-            json_str,
-            '[{"data": "2017-11-18T21:53:00.219225+01:00"}, {"data": "2017-11-18T22:06:30+01:00"}]',
+        assert (
+            json_str
+            == '[{"data": "2017-11-18T21:53:00.219225+01:00"}, {"data": "2017-11-18T22:06:30+01:00"}]'
         )
 
     def test_mssql_engine_spec_pymssql(self):
@@ -524,11 +521,12 @@ class TestCore(SupersetTestCase):
         )
         df = results.to_pandas_df()
         data = dataframe.df_to_records(df)
-        self.assertEqual(len(data), 2)
-        self.assertEqual(
-            data[0],
-            {"col1": 1, "col2": 1, "col3": pd.Timestamp("2017-10-19 23:39:16.660000")},
-        )
+        assert len(data) == 2
+        assert data[0] == {
+            "col1": 1,
+            "col2": 1,
+            "col3": pd.Timestamp("2017-10-19 23:39:16.660000"),
+        }
 
     def test_comments_in_sqlatable_query(self):
         clean_query = "SELECT\n  '/* val 1 */' AS c1,\n  '-- val 2' AS c2\nFROM tbl"
@@ -554,9 +552,9 @@ class TestCore(SupersetTestCase):
         )
         data = json.loads(rv.data.decode("utf-8"))
 
-        self.assertEqual(
-            data["errors"][0]["message"],
-            "The dataset associated with this chart no longer exists",
+        assert (
+            data["errors"][0]["message"]
+            == "The dataset associated with this chart no longer exists"
         )
 
     @pytest.mark.usefixtures("load_birth_names_dashboard_with_slices")
@@ -579,8 +577,8 @@ class TestCore(SupersetTestCase):
         )
         data = json.loads(rv.data.decode("utf-8"))
 
-        self.assertEqual(rv.status_code, 200)
-        self.assertEqual(data["rowcount"], 2)
+        assert rv.status_code == 200
+        assert data["rowcount"] == 2
 
     @pytest.mark.usefixtures("load_birth_names_dashboard_with_slices")
     def test_explore_json_dist_bar_order(self):
@@ -741,7 +739,7 @@ class TestCore(SupersetTestCase):
             "/superset/explore_json/?results=true",
             data={"form_data": json.dumps(form_data)},
         )
-        self.assertEqual(rv.status_code, 200)
+        assert rv.status_code == 200
 
     @pytest.mark.usefixtures("load_birth_names_dashboard_with_slices")
     @mock.patch(
@@ -780,8 +778,8 @@ class TestCore(SupersetTestCase):
         rv = self.client.get("/superset/explore_json/data/valid-cache-key")
         data = json.loads(rv.data.decode("utf-8"))
 
-        self.assertEqual(rv.status_code, 200)
-        self.assertEqual(data["rowcount"], 2)
+        assert rv.status_code == 200
+        assert data["rowcount"] == 2
 
     @mock.patch(
         "superset.utils.cache_manager.CacheManager.cache",
@@ -814,7 +812,7 @@ class TestCore(SupersetTestCase):
         mock_cache.return_value = MockCache()
 
         rv = self.client.get("/superset/explore_json/data/valid-cache-key")
-        self.assertEqual(rv.status_code, 403)
+        assert rv.status_code == 403
 
     def test_explore_json_data_invalid_cache_key(self):
         self.login(ADMIN_USERNAME)
@@ -822,8 +820,8 @@ class TestCore(SupersetTestCase):
         rv = self.client.get(f"/superset/explore_json/data/{cache_key}")
         data = json.loads(rv.data.decode("utf-8"))
 
-        self.assertEqual(rv.status_code, 404)
-        self.assertEqual(data["error"], "Cached data not found")
+        assert rv.status_code == 404
+        assert data["error"] == "Cached data not found"
 
     def test_results_default_deserialization(self):
         use_new_deserialization = False
@@ -863,14 +861,14 @@ class TestCore(SupersetTestCase):
         serialized_payload = sql_lab._serialize_payload(
             payload, use_new_deserialization
         )
-        self.assertIsInstance(serialized_payload, str)
+        assert isinstance(serialized_payload, str)
 
         query_mock = mock.Mock()
         deserialized_payload = superset.views.utils._deserialize_results_payload(
             serialized_payload, query_mock, use_new_deserialization
         )
 
-        self.assertDictEqual(deserialized_payload, payload)
+        self.assertDictEqual(deserialized_payload, payload)  # noqa: PT009
         query_mock.assert_not_called()
 
     def test_results_msgpack_deserialization(self):
@@ -911,7 +909,7 @@ class TestCore(SupersetTestCase):
         serialized_payload = sql_lab._serialize_payload(
             payload, use_new_deserialization
         )
-        self.assertIsInstance(serialized_payload, bytes)
+        assert isinstance(serialized_payload, bytes)
 
         with mock.patch.object(
             db_engine_spec, "expand_data", wraps=db_engine_spec.expand_data
@@ -925,7 +923,7 @@ class TestCore(SupersetTestCase):
             df = results.to_pandas_df()
             payload["data"] = dataframe.df_to_records(df)
 
-            self.assertDictEqual(deserialized_payload, payload)
+            self.assertDictEqual(deserialized_payload, payload)  # noqa: PT009
             expand_data.assert_called_once()
 
     @mock.patch.dict(
@@ -960,7 +958,7 @@ class TestCore(SupersetTestCase):
         ]
         for url in urls:
             data = self.get_resp(url)
-            self.assertTrue(html_string in data)
+            assert html_string in data
 
     @mock.patch.dict(
         "superset.extensions.feature_flag_manager._feature_flags",
@@ -991,7 +989,7 @@ class TestCore(SupersetTestCase):
         tab_state_id = resp["id"]
         payload = self.get_json_resp(f"/tabstateview/{tab_state_id}")
 
-        self.assertEqual(payload["label"], "Untitled Query foo")
+        assert payload["label"] == "Untitled Query foo"
 
     def test_tabstate_update(self):
         self.login(ADMIN_USERNAME)
@@ -1014,87 +1012,87 @@ class TestCore(SupersetTestCase):
         client_id = "asdfasdf"
         data = {"sql": json.dumps("select 1"), "latest_query_id": json.dumps(client_id)}
         response = self.client.put(f"/tabstateview/{tab_state_id}", data=data)
-        self.assertEqual(response.status_code, 400)
-        self.assertEqual(response.json["error"], "Bad request")
+        assert response.status_code == 400
+        assert response.json["error"] == "Bad request"
         # generate query
         db.session.add(Query(client_id=client_id, database_id=1))
         db.session.commit()
         # update tab state with a valid client_id
         response = self.client.put(f"/tabstateview/{tab_state_id}", data=data)
-        self.assertEqual(response.status_code, 200)
+        assert response.status_code == 200
         # nulls should be ok too
         data["latest_query_id"] = "null"
         response = self.client.put(f"/tabstateview/{tab_state_id}", data=data)
-        self.assertEqual(response.status_code, 200)
+        assert response.status_code == 200
 
     def test_virtual_table_explore_visibility(self):
         # test that default visibility it set to True
         database = superset.utils.database.get_example_database()
-        self.assertEqual(database.allows_virtual_table_explore, True)
+        assert database.allows_virtual_table_explore is True
 
         # test that visibility is disabled when extra is set to False
         extra = database.get_extra()
         extra["allows_virtual_table_explore"] = False
         database.extra = json.dumps(extra)
-        self.assertEqual(database.allows_virtual_table_explore, False)
+        assert database.allows_virtual_table_explore is False
 
         # test that visibility is enabled when extra is set to True
         extra = database.get_extra()
         extra["allows_virtual_table_explore"] = True
         database.extra = json.dumps(extra)
-        self.assertEqual(database.allows_virtual_table_explore, True)
+        assert database.allows_virtual_table_explore is True
 
         # test that visibility is not broken with bad values
         extra = database.get_extra()
         extra["allows_virtual_table_explore"] = "trash value"
         database.extra = json.dumps(extra)
-        self.assertEqual(database.allows_virtual_table_explore, True)
+        assert database.allows_virtual_table_explore is True
 
     def test_data_preview_visibility(self):
         # test that default visibility is allowed
         database = utils.get_example_database()
-        self.assertEqual(database.disable_data_preview, False)
+        assert database.disable_data_preview is False
 
         # test that visibility is disabled when extra is set to true
         extra = database.get_extra()
         extra["disable_data_preview"] = True
         database.extra = json.dumps(extra)
-        self.assertEqual(database.disable_data_preview, True)
+        assert database.disable_data_preview is True
 
         # test that visibility is enabled when extra is set to false
         extra = database.get_extra()
         extra["disable_data_preview"] = False
         database.extra = json.dumps(extra)
-        self.assertEqual(database.disable_data_preview, False)
+        assert database.disable_data_preview is False
 
         # test that visibility is not broken with bad values
         extra = database.get_extra()
         extra["disable_data_preview"] = "trash value"
         database.extra = json.dumps(extra)
-        self.assertEqual(database.disable_data_preview, False)
+        assert database.disable_data_preview is False
 
     def test_disable_drill_to_detail(self):
         # test that disable_drill_to_detail is False by default
         database = utils.get_example_database()
-        self.assertEqual(database.disable_drill_to_detail, False)
+        assert database.disable_drill_to_detail is False
 
         # test that disable_drill_to_detail can be set to True
         extra = database.get_extra()
         extra["disable_drill_to_detail"] = True
         database.extra = json.dumps(extra)
-        self.assertEqual(database.disable_drill_to_detail, True)
+        assert database.disable_drill_to_detail is True
 
         # test that disable_drill_to_detail can be set to False
         extra = database.get_extra()
         extra["disable_drill_to_detail"] = False
         database.extra = json.dumps(extra)
-        self.assertEqual(database.disable_drill_to_detail, False)
+        assert database.disable_drill_to_detail is False
 
         # test that disable_drill_to_detail is not broken with bad values
         extra = database.get_extra()
         extra["disable_drill_to_detail"] = "trash value"
         database.extra = json.dumps(extra)
-        self.assertEqual(database.disable_drill_to_detail, False)
+        assert database.disable_drill_to_detail is False
 
     def test_explore_database_id(self):
         database = superset.utils.database.get_example_database()
@@ -1102,13 +1100,13 @@ class TestCore(SupersetTestCase):
 
         # test that explore_database_id is the regular database
         # id if none is set in the extra
-        self.assertEqual(database.explore_database_id, database.id)
+        assert database.explore_database_id == database.id
 
         # test that explore_database_id is correct if the extra is set
         extra = database.get_extra()
         extra["explore_database_id"] = explore_database.id
         database.extra = json.dumps(extra)
-        self.assertEqual(database.explore_database_id, explore_database.id)
+        assert database.explore_database_id == explore_database.id
 
     def test_get_column_names_from_metric(self):
         simple_metric = {
@@ -1146,7 +1144,7 @@ class TestCore(SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
         data = self.get_resp(url)
-        self.assertIn("Error message", data)
+        assert "Error message" in data
 
         # Assert we can handle a driver exception at the mutator level
         exception = SQLAlchemyError("Error message")
@@ -1156,7 +1154,7 @@ class TestCore(SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
         data = self.get_resp(url)
-        self.assertIn("Error message", data)
+        assert "Error message" in data
 
     @pytest.mark.skip(
         "TODO This test was wrong - 'Error message' was in the language pack"
@@ -1176,7 +1174,7 @@ class TestCore(SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
         data = self.get_resp(url)
-        self.assertIn("Error message", data)
+        assert "Error message" in data
 
         # Assert we can handle a driver exception at the mutator level
         exception = SQLAlchemyError("Error message")
@@ -1186,7 +1184,7 @@ class TestCore(SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
         data = self.get_resp(url)
-        self.assertIn("Error message", data)
+        assert "Error message" in data
 
     @pytest.mark.usefixtures("load_energy_table_with_slice")
     @mock.patch("superset.commands.explore.form_data.create.CreateFormDataCommand.run")
@@ -1200,9 +1198,7 @@ class TestCore(SupersetTestCase):
         rv = self.client.get(
             f"/superset/explore/?form_data={quote(json.dumps(form_data))}"
         )
-        self.assertEqual(
-            rv.headers["Location"], f"/explore/?form_data_key={random_key}"
-        )
+        assert rv.headers["Location"] == f"/explore/?form_data_key={random_key}"
 
     @pytest.mark.usefixtures("load_birth_names_dashboard_with_slices")
     def test_has_table(self):
@@ -1223,7 +1219,7 @@ class TestCore(SupersetTestCase):
 
         expected_url = "/superset/dashboard/1?permalink_key=123&standalone=3"
 
-        self.assertEqual(resp.headers["Location"], expected_url)
+        assert resp.headers["Location"] == expected_url
         assert resp.status_code == 302