undo ex_info changes

Author: sfc-gh-aalam

tests/integ/scala/test_column_suite.py

@@ -486,12 +486,15 @@ def test_column_constructors_col(session):
     assert df.select(col("CoL")).collect() == [Row(1)]
     assert df.select(col('"COL"')).collect() == [Row(1)]
 
-    with pytest.raises(SnowparkSQLException, match="invalid identifier"):
+    with pytest.raises(SnowparkSQLException) as ex_info:
         df.select(col('"Col"')).collect()
-    with pytest.raises(SnowparkSQLException, match="invalid identifier"):
+    assert "invalid identifier" in str(ex_info)
+    with pytest.raises(SnowparkSQLException) as ex_info:
         df.select(col("COL .")).collect()
-    with pytest.raises(SnowparkSQLException, match="invalid identifier"):
+    assert "invalid identifier" in str(ex_info)
+    with pytest.raises(SnowparkSQLException) as ex_info:
         df.select(col('"CoL"')).collect()
+    assert "invalid identifier" in str(ex_info)
 
 
 def test_column_constructors_select(session):
@@ -505,10 +508,10 @@ def test_column_constructors_select(session):
 
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.select('"Col"').collect()
-    assert "invalid identifier" in str(ex_info.value)
+    assert "invalid identifier" in str(ex_info)
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.select("COL .").collect()
-    assert "invalid identifier" in str(ex_info.value)
+    assert "invalid identifier" in str(ex_info)
 
 
 @pytest.mark.xfail(
@@ -530,16 +533,16 @@ def test_sql_expr_column(session):
 
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.select(sql_expr('"Col"')).collect()
-    assert "invalid identifier" in str(ex_info.value)
+    assert "invalid identifier" in str(ex_info)
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.select(sql_expr("COL .")).collect()
-    assert "syntax error" in str(ex_info.value)
+    assert "syntax error" in str(ex_info)
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.select(sql_expr('"CoL"')).collect()
-    assert "invalid identifier" in str(ex_info.value)
+    assert "invalid identifier" in str(ex_info)
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.select(sql_expr("col .")).collect()
-    assert "syntax error" in str(ex_info.value)
+    assert "syntax error" in str(ex_info)
 
 
 def test_errors_for_aliased_columns(session, local_testing_mode):
@@ -553,15 +556,15 @@ def test_errors_for_aliased_columns(session, local_testing_mode):
     with pytest.raises(exc) as ex_info:
         df.select(col("a").as_("b") + 10).collect()
     if not local_testing_mode:
-        assert "You can only define aliases for the root" in str(ex_info.value)
+        assert "You can only define aliases for the root" in str(ex_info)
     else:
-        assert "invalid identifier" in str(ex_info.value)
+        assert "invalid identifier" in str(ex_info)
     with pytest.raises(exc) as ex_info:
         df.group_by(col("a")).agg(avg(col("a").as_("b"))).collect()
     if not local_testing_mode:
-        assert "You can only define aliases for the root" in str(ex_info.value)
+        assert "You can only define aliases for the root" in str(ex_info)
     else:
-        assert "invalid identifier" in str(ex_info.value)
+        assert "invalid identifier" in str(ex_info)
 
 
 def test_like(session):
@@ -665,7 +668,7 @@ def test_regexp(session):
 
     with pytest.raises(SnowparkSQLException) as ex_info:
         TestData.string4(session).where(col("A").regexp("+*")).collect()
-    assert "Invalid regular expression" in str(ex_info.value)
+    assert "Invalid regular expression" in str(ex_info)
 
     # Test when pattern is a column of literal strings
     df = session.create_dataframe(
@@ -725,7 +728,7 @@ def test_when_case(session, local_testing_mode):
             when(col("a").is_null(), lit("a")).when(col("a") == 1, lit(6)).as_("a")
         ).collect()
     if not local_testing_mode:
-        assert "Numeric value 'a' is not recognized" in str(ex_info.value)
+        assert "Numeric value 'a' is not recognized" in str(ex_info)
 
 
 def test_lit_contains_single_quote(session):

tests/integ/scala/test_dataframe_aggregate_suite.py

@@ -1137,7 +1137,7 @@ def test_decimal_sum_over_window_should_work(session):
 def test_aggregate_function_in_groupby(session):
     with pytest.raises(SnowparkSQLException) as ex_info:
         TestData.test_data4(session).group_by(sum(col('"KEY"'))).count().collect()
-    assert "is not a valid group by expression" in str(ex_info.value)
+    assert "is not a valid group by expression" in str(ex_info)
 
 
 def test_ints_in_agg_exprs_are_taken_as_groupby_ordinal(session):

tests/integ/scala/test_dataframe_copy_into.py

@@ -398,14 +398,14 @@ def test_copy_csv_negative(session, tmp_stage_name1, tmp_table_name):
         )
     assert (
         f"Cannot create the target table {table_name_not_exist} because Snowpark cannot determine the column names to use. You should create the table before calling copy_into_table()"
-        in str(exec_info.value)
+        in str(exec_info)
     )
 
     # case 2: copy into an existing table table with unmatched transformations
     with pytest.raises(SnowparkSQLException) as exec_info:
         df.copy_into_table(tmp_table_name, transformations=[col("$s1").as_("c1_alias")])
     assert "Insert value list does not match column list expecting 3 but got 1" in str(
-        exec_info.value
+        exec_info
     )
 
 
@@ -668,7 +668,7 @@ def test_copy_csv_negative_test_with_column_names(session, tmp_stage_name1):
             )
         assert (
             "Number of column names provided to copy into does not match the number of transformations provided. Number of column names: 1, number of transformations: 2"
-            in str(exec_info.value)
+            in str(exec_info)
         )
 
         # case 2: column names contains unknown columns
@@ -678,7 +678,7 @@ def test_copy_csv_negative_test_with_column_names(session, tmp_stage_name1):
                 target_columns=["c1", "c2", "c3", "c4"],
                 transformations=[col("$1"), col("$2"), col("$3"), col("$4")],
             )
-        assert "invalid identifier 'C4'" in str(exec_info.value)
+        assert "invalid identifier 'C4'" in str(exec_info)
     finally:
         Utils.drop_table(session, table_name)
 
@@ -1103,14 +1103,14 @@ def test_copy_non_csv_negative_test(
             df.copy_into_table(table_name)
         assert (
             f"Cannot create the target table {table_name} because Snowpark cannot determine the column names to use. You should create the table before calling copy_into_table()"
-            in str(exec_info.value)
+            in str(exec_info)
         )
 
     with pytest.raises(SnowparkDataframeReaderException) as exec_info:
         df.copy_into_table(table_name, transformations=[col("$1").as_("A")])
     assert (
         f"Cannot create the target table {table_name} because Snowpark cannot determine the column names to use. You should create the table before calling copy_into_table()"
-        in str(exec_info.value)
+        in str(exec_info)
     )
 
     Utils.create_table(session, table_name, "c1 String")
@@ -1121,7 +1121,7 @@ def test_copy_non_csv_negative_test(
             )
         assert (
             "Insert value list does not match column list expecting 1 but got 2"
-            in str(exec_info.value)
+            in str(exec_info)
         )
     finally:
         Utils.drop_table(session, table_name)

tests/integ/scala/test_dataframe_reader_suite.py

@@ -136,6 +136,9 @@ def get_df_from_reader_and_file_format(reader, file_format):
 
 @pytest.fixture(scope="module", autouse=True)
 def setup(session, resources_path, local_testing_mode):
+    # TODO SNOW-2098847: remove this workaround after fixing the issue
+    session._use_scoped_temp_objects = False
+
     test_files = TestFiles(resources_path)
     if not local_testing_mode:
         Utils.create_stage(session, tmp_stage_name1, is_temporary=True)
@@ -399,7 +402,7 @@ def test_read_csv(session, mode):
     )
     with pytest.raises(SnowparkSQLException) as ex_info:
         df3.collect()
-    assert "is out of range" in str(ex_info.value)
+    assert "is out of range" in str(ex_info)
 
 
 @pytest.mark.xfail(
@@ -590,7 +593,7 @@ def test_read_csv_incorrect_schema(session, mode):
     df = reader.option("purge", False).schema(incorrect_schema).csv(test_file_on_stage)
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.collect()
-    assert "Number of columns in file (3) does not match" in str(ex_info.value)
+    assert "Number of columns in file (3) does not match" in str(ex_info)
 
 
 @pytest.mark.skipif(
@@ -1971,10 +1974,6 @@ def test_read_multiple_csvs(session):
     "config.getoption('local_testing_mode', default=False)",
     reason="xml not supported in local testing mode",
 )
-@pytest.mark.skipif(
-    IS_IN_STORED_PROC,
-    reason="SNOW-2044853: Flaky in stored procedure test",
-)
 @pytest.mark.parametrize(
     "file,row_tag,expected_row_count,expected_column_count",
     [
@@ -1997,10 +1996,6 @@ def test_read_xml_row_tag(
     "config.getoption('local_testing_mode', default=False)",
     reason="xml not supported in local testing mode",
 )
-@pytest.mark.skipif(
-    IS_IN_STORED_PROC,
-    reason="SNOW-2044853: Flaky in stored procedure test",
-)
 def test_read_xml_no_xxe(session):
     row_tag = "bar"
     stage_file_path = f"@{tmp_stage_name1}/{test_file_xxe_xml}"
@@ -2012,10 +2007,6 @@ def test_read_xml_no_xxe(session):
     "config.getoption('local_testing_mode', default=False)",
     reason="xml not supported in local testing mode",
 )
-@pytest.mark.skipif(
-    IS_IN_STORED_PROC,
-    reason="SNOW-2044853: Flaky in stored procedure test",
-)
 def test_read_xml_query_nested_data(session):
     row_tag = "tag"
     df = session.read.option("rowTag", row_tag).xml(
@@ -2046,10 +2037,6 @@ def test_read_xml_non_existing_file(session):
     "config.getoption('local_testing_mode', default=False)",
     reason="xml not supported in local testing mode",
 )
-@pytest.mark.skipif(
-    IS_IN_STORED_PROC,
-    reason="SNOW-2044853: Flaky in stored procedure test",
-)
 @pytest.mark.parametrize(
     "file",
     (
@@ -2060,12 +2047,13 @@ def test_read_xml_non_existing_file(session):
 )
 def test_read_malformed_xml(session, file):
     row_tag = "record"
+    file_path = f"@{tmp_stage_name1}/{file}"
 
     # permissive mode
     df = (
         session.read.option("rowTag", row_tag)
         .option("mode", "permissive")
-        .xml(f"@{tmp_stage_name1}/{file}")
+        .xml(file_path)
     )
     result = df.collect()
     assert len(result) == 2
@@ -2079,17 +2067,37 @@ def test_read_malformed_xml(session, file):
     df = (
         session.read.option("rowTag", row_tag)
         .option("mode", "dropmalformed")
-        .xml(f"@{tmp_stage_name1}/{test_file_malformed_no_closing_tag_xml}")
+        .xml(file_path)
     )
     result = df.collect()
     assert len(result) == 1
     assert len(result[0]) == 3
 
     # failfast mode
     df = (
-        session.read.option("rowTag", row_tag)
-        .option("mode", "failfast")
-        .xml(f"@{tmp_stage_name1}/{test_file_malformed_no_closing_tag_xml}")
+        session.read.option("rowTag", row_tag).option("mode", "failfast").xml(file_path)
     )
     with pytest.raises(SnowparkSQLException, match="Malformed XML record at bytes"):
         df.collect()
+
+
+@pytest.mark.skipif(
+    "config.getoption('local_testing_mode', default=False)",
+    reason="xml not supported in local testing mode",
+)
+def test_read_xml_row_tag_not_found(session):
+    row_tag = "non-existing-tag"
+    df = session.read.option("rowTag", row_tag).xml(
+        f"@{tmp_stage_name1}/{test_file_books_xml}"
+    )
+
+    with pytest.raises(
+        SnowparkDataframeReaderException, match="Cannot find the row tag"
+    ):
+        df.collect()
+
+    # also works for nested query plan
+    with pytest.raises(
+        SnowparkDataframeReaderException, match="Cannot find the row tag"
+    ):
+        df.filter(lit(True)).collect()

tests/integ/scala/test_dataframe_suite.py

@@ -1268,28 +1268,28 @@ def test_select_negative_select(session):
     # Select with empty sequences
     with pytest.raises(ValueError) as ex_info:
         df.select()
-    assert "The input of select() cannot be empty" in str(ex_info.value)
+    assert "The input of select() cannot be empty" in str(ex_info)
 
     with pytest.raises(ValueError) as ex_info:
         df.select([])
-    assert "The input of select() cannot be empty" in str(ex_info.value)
+    assert "The input of select() cannot be empty" in str(ex_info)
 
     # select columns which don't exist
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.select("not_exists_column").collect()
-    assert "SQL compilation error" in str(ex_info.value)
+    assert "SQL compilation error" in str(ex_info)
 
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.select(["not_exists_column"]).collect()
-    assert "SQL compilation error" in str(ex_info.value)
+    assert "SQL compilation error" in str(ex_info)
 
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.select(col("not_exists_column")).collect()
-    assert "SQL compilation error" in str(ex_info.value)
+    assert "SQL compilation error" in str(ex_info)
 
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.select([col("not_exists_column")]).collect()
-    assert "SQL compilation error" in str(ex_info.value)
+    assert "SQL compilation error" in str(ex_info)
 
 
 def test_drop_and_dropcolumns(session):
@@ -1392,8 +1392,8 @@ def test_rollup(session):
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.rollup(list()).agg(sum_(col("value"))).show()
 
-    assert "001003 (42000): " in str(ex_info.value) and "SQL compilation error" in str(
-        ex_info.value
+    assert "001003 (42000): " in str(ex_info) and "SQL compilation error" in str(
+        ex_info
     )
 
     # rollup() on 1 column
@@ -1518,8 +1518,8 @@ def test_cube(session):
     with pytest.raises(SnowparkSQLException) as ex_info:
         df.cube(list()).agg(sum_(col("value"))).show()
 
-    assert "001003 (42000): " in str(ex_info.value) and "SQL compilation error" in str(
-        ex_info.value
+    assert "001003 (42000): " in str(ex_info) and "SQL compilation error" in str(
+        ex_info
     )
 
     # cube() on 1 column