remove SEA tests in parameterized queries

Signed-off-by: varun-edachali-dbx <varun.edachali@databricks.com>

Author: varun-edachali-dbx

tests/e2e/test_parameterized_queries.py

@@ -405,20 +405,9 @@ def test_use_inline_off_by_default_with_warning(self, use_inline_params, caplog)
                             "Consider using native parameters." not in caplog.text
                         ), "Log message should not be supressed"
 
-    @pytest.mark.parametrize(
-        "extra_params",
-        [
-            {},
-            {
-                "use_sea": True,
-                "use_cloud_fetch": False,
-                "enable_query_result_lz4_compression": False,
-            },
-        ],
-    )
-    def test_positional_native_params_with_defaults(self, extra_params):
+    def test_positional_native_params_with_defaults(self):
         query = "SELECT ? col"
-        with self.cursor(extra_params) as cursor:
+        with self.cursor() as cursor:
             result = cursor.execute(query, parameters=[1]).fetchone()
 
         assert result.col == 1
@@ -434,42 +423,19 @@ def test_positional_native_params_with_defaults(self, extra_params):
             ["foo", "bar", "baz"],
         ),
     )
-    @pytest.mark.parametrize(
-        "extra_params",
-        [
-            {},
-            {
-                "use_sea": True,
-                "use_cloud_fetch": False,
-                "enable_query_result_lz4_compression": False,
-            },
-        ],
-    )
-    def test_positional_native_multiple(self, params, extra_params):
+    def test_positional_native_multiple(self, params):
         query = "SELECT ? `foo`, ? `bar`, ? `baz`"
 
-        combined_params = {"use_inline_params": False, **extra_params}
-        with self.cursor(extra_params=combined_params) as cursor:
+        with self.cursor(extra_params={"use_inline_params": False}) as cursor:
             result = cursor.execute(query, params).fetchone()
 
         expected = [i.value if isinstance(i, DbsqlParameterBase) else i for i in params]
         outcome = [result.foo, result.bar, result.baz]
 
         assert set(outcome) == set(expected)
 
-    @pytest.mark.parametrize(
-        "extra_params",
-        [
-            {},
-            {
-                "use_sea": True,
-                "use_cloud_fetch": False,
-                "enable_query_result_lz4_compression": False,
-            },
-        ],
-    )
-    def test_readme_example(self, extra_params):
-        with self.cursor(extra_params) as cursor:
+    def test_readme_example(self):
+        with self.cursor() as cursor:
             result = cursor.execute(
                 "SELECT :param `p`, * FROM RANGE(10)", {"param": "foo"}
             ).fetchall()
@@ -533,42 +499,19 @@ def test_native_recursive_complex_type(
 class TestInlineParameterSyntax(PySQLPytestTestCase):
     """The inline parameter approach uses pyformat markers"""
 
-    @pytest.mark.parametrize(
-        "extra_params",
-        [
-            {},
-            {
-                "use_sea": True,
-                "use_cloud_fetch": False,
-                "enable_query_result_lz4_compression": False,
-            },
-        ],
-    )
-    def test_params_as_dict(self, extra_params):
+    def test_params_as_dict(self):
         query = "SELECT %(foo)s foo, %(bar)s bar, %(baz)s baz"
         params = {"foo": 1, "bar": 2, "baz": 3}
 
-        combined_params = {"use_inline_params": True, **extra_params}
-        with self.connection(extra_params=combined_params) as conn:
+        with self.connection(extra_params={"use_inline_params": True}) as conn:
             with conn.cursor() as cursor:
                 result = cursor.execute(query, parameters=params).fetchone()
 
         assert result.foo == 1
         assert result.bar == 2
         assert result.baz == 3
 
-    @pytest.mark.parametrize(
-        "extra_params",
-        [
-            {},
-            {
-                "use_sea": True,
-                "use_cloud_fetch": False,
-                "enable_query_result_lz4_compression": False,
-            },
-        ],
-    )
-    def test_params_as_sequence(self, extra_params):
+    def test_params_as_sequence(self):
         """One side-effect of ParamEscaper using Python string interpolation to inline the values
         is that it can work with "ordinal" parameters, but only if a user writes parameter markers
         that are not defined with PEP-249. This test exists to prove that it works in the ideal case.
@@ -578,8 +521,7 @@ def test_params_as_sequence(self, extra_params):
         query = "SELECT %s foo, %s bar, %s baz"
         params = (1, 2, 3)
 
-        combined_params = {"use_inline_params": True, **extra_params}
-        with self.connection(extra_params=combined_params) as conn:
+        with self.connection(extra_params={"use_inline_params": True}) as conn:
             with conn.cursor() as cursor:
                 result = cursor.execute(query, parameters=params).fetchone()
                 assert result.foo == 1
@@ -599,18 +541,7 @@ def test_inline_ordinals_can_break_sql(self):
             ):
                 cursor.execute(query, parameters=params)
 
-    @pytest.mark.parametrize(
-        "extra_params",
-        [
-            {},
-            {
-                "use_sea": True,
-                "use_cloud_fetch": False,
-                "enable_query_result_lz4_compression": False,
-            },
-        ],
-    )
-    def test_inline_named_dont_break_sql(self, extra_params):
+    def test_inline_named_dont_break_sql(self):
         """With inline mode, ordinal parameters can break the SQL syntax
         because `%` symbols are used to wildcard match within LIKE statements. This test
         just proves that's the case.
@@ -620,30 +551,17 @@ def test_inline_named_dont_break_sql(self, extra_params):
         SELECT col_1 FROM base WHERE col_1 LIKE CONCAT(%(one)s, 'onite')
         """
         params = {"one": "%(one)s"}
-        combined_params = {"use_inline_params": True, **extra_params}
-        with self.cursor(extra_params=combined_params) as cursor:
+        with self.cursor(extra_params={"use_inline_params": True}) as cursor:
             result = cursor.execute(query, parameters=params).fetchone()
             print("hello")
 
-    @pytest.mark.parametrize(
-        "extra_params",
-        [
-            {},
-            {
-                "use_sea": True,
-                "use_cloud_fetch": False,
-                "enable_query_result_lz4_compression": False,
-            },
-        ],
-    )
-    def test_native_ordinals_dont_break_sql(self, extra_params):
+    def test_native_ordinals_dont_break_sql(self):
         """This test accompanies test_inline_ordinals_can_break_sql to prove that ordinal
         parameters work in native mode for the exact same query, if we use the right marker `?`
         """
         query = "SELECT 'samsonite', ? WHERE 'samsonite' LIKE '%sonite'"
         params = ["luggage"]
-        combined_params = {"use_inline_params": False, **extra_params}
-        with self.cursor(extra_params=combined_params) as cursor:
+        with self.cursor(extra_params={"use_inline_params": False}) as cursor:
             result = cursor.execute(query, parameters=params).fetchone()
 
         assert result.samsonite == "samsonite"
@@ -659,25 +577,13 @@ def test_inline_like_wildcard_breaks(self):
             with pytest.raises(ValueError, match="unsupported format character"):
                 result = cursor.execute(query, parameters=params).fetchone()
 
-    @pytest.mark.parametrize(
-        "extra_params",
-        [
-            {},
-            {
-                "use_sea": True,
-                "use_cloud_fetch": False,
-                "enable_query_result_lz4_compression": False,
-            },
-        ],
-    )
-    def test_native_like_wildcard_works(self, extra_params):
+    def test_native_like_wildcard_works(self):
         """This is a mirror of test_inline_like_wildcard_breaks that proves that LIKE
         wildcards work under the native approach.
         """
         query = "SELECT 1 `col` WHERE 'foo' LIKE '%'"
         params = {"param": "bar"}
-        combined_params = {"use_inline_params": False, **extra_params}
-        with self.cursor(extra_params=combined_params) as cursor:
+        with self.cursor(extra_params={"use_inline_params": False}) as cursor:
             result = cursor.execute(query, parameters=params).fetchone()
 
         assert result.col == 1