test_feather updated

Author: jsngn

pandas/tests/io/test_feather.py

@@ -26,36 +26,38 @@
 
 @pytest.mark.single_cpu
 class TestFeather:
-    def check_error_on_write(self, df, exc, err_msg):
+    def check_error_on_write(self, df, exc, err_msg, temp_file):
         # check that we are raising the exception
         # on writing
 
         with pytest.raises(exc, match=err_msg):
-            with tm.ensure_clean() as path:
-                to_feather(df, path)
+            path = str(temp_file)
+            to_feather(df, path)
 
-    def check_external_error_on_write(self, df):
+    def check_external_error_on_write(self, df, temp_file):
         # check that we are raising the exception
         # on writing
 
         with tm.external_error_raised(Exception):
-            with tm.ensure_clean() as path:
-                to_feather(df, path)
+            path = str(temp_file)
+            to_feather(df, path)
 
-    def check_round_trip(self, df, expected=None, write_kwargs=None, **read_kwargs):
+    def check_round_trip(
+        self, df, temp_file, expected=None, write_kwargs=None, **read_kwargs
+    ):
         if write_kwargs is None:
             write_kwargs = {}
         if expected is None:
             expected = df.copy()
 
-        with tm.ensure_clean() as path:
-            to_feather(df, path, **write_kwargs)
+        path = str(temp_file)
+        to_feather(df, path, **write_kwargs)
 
-            result = read_feather(path, **read_kwargs)
+        result = read_feather(path, **read_kwargs)
 
-            tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
-    def test_error(self):
+    def test_error(self, temp_file):
         msg = "feather only support IO with DataFrames"
         for obj in [
             pd.Series([1, 2, 3]),
@@ -64,9 +66,9 @@ def test_error(self):
             pd.Timestamp("20130101"),
             np.array([1, 2, 3]),
         ]:
-            self.check_error_on_write(obj, ValueError, msg)
+            self.check_error_on_write(obj, ValueError, msg, temp_file)
 
-    def test_basic(self):
+    def test_basic(self, temp_file):
         tz = zoneinfo.ZoneInfo("US/Eastern")
         df = pd.DataFrame(
             {
@@ -103,15 +105,15 @@ def test_basic(self):
 
         expected = df.copy()
         expected.loc[1, "bool_with_null"] = None
-        self.check_round_trip(df, expected=expected)
+        self.check_round_trip(df, temp_file, expected=expected)
 
-    def test_duplicate_columns(self):
+    def test_duplicate_columns(self, temp_file):
         # https://github.com/wesm/feather/issues/53
         # not currently able to handle duplicate columns
         df = pd.DataFrame(np.arange(12).reshape(4, 3), columns=list("aaa")).copy()
-        self.check_external_error_on_write(df)
+        self.check_external_error_on_write(df, temp_file)
 
-    def test_read_columns(self):
+    def test_read_columns(self, temp_file):
         # GH 24025
         df = pd.DataFrame(
             {
@@ -122,23 +124,23 @@ def test_read_columns(self):
             }
         )
         columns = ["col1", "col3"]
-        self.check_round_trip(df, expected=df[columns], columns=columns)
+        self.check_round_trip(df, temp_file, expected=df[columns], columns=columns)
 
-    def test_read_columns_different_order(self):
+    def test_read_columns_different_order(self, temp_file):
         # GH 33878
         df = pd.DataFrame({"A": [1, 2], "B": ["x", "y"], "C": [True, False]})
         expected = df[["B", "A"]]
-        self.check_round_trip(df, expected, columns=["B", "A"])
+        self.check_round_trip(df, temp_file, expected, columns=["B", "A"])
 
-    def test_unsupported_other(self):
+    def test_unsupported_other(self, temp_file):
         # mixed python objects
         df = pd.DataFrame({"a": ["a", 1, 2.0]})
-        self.check_external_error_on_write(df)
+        self.check_external_error_on_write(df, temp_file)
 
-    def test_rw_use_threads(self):
+    def test_rw_use_threads(self, temp_file):
         df = pd.DataFrame({"A": np.arange(100000)})
-        self.check_round_trip(df, use_threads=True)
-        self.check_round_trip(df, use_threads=False)
+        self.check_round_trip(df, temp_file, use_threads=True)
+        self.check_round_trip(df, temp_file, use_threads=False)
 
     def test_path_pathlib(self):
         df = pd.DataFrame(
@@ -149,13 +151,13 @@ def test_path_pathlib(self):
         result = tm.round_trip_pathlib(df.to_feather, read_feather)
         tm.assert_frame_equal(df, result)
 
-    def test_passthrough_keywords(self):
+    def test_passthrough_keywords(self, temp_file):
         df = pd.DataFrame(
             1.1 * np.arange(120).reshape((30, 4)),
             columns=pd.Index(list("ABCD")),
             index=pd.Index([f"i-{i}" for i in range(30)]),
         ).reset_index()
-        self.check_round_trip(df, write_kwargs={"version": 1})
+        self.check_round_trip(df, temp_file, write_kwargs={"version": 1})
 
     @pytest.mark.network
     @pytest.mark.single_cpu
@@ -168,7 +170,7 @@ def test_http_path(self, feather_file, httpserver):
         tm.assert_frame_equal(expected, res)
 
     def test_read_feather_dtype_backend(
-        self, string_storage, dtype_backend, using_infer_string
+        self, string_storage, dtype_backend, using_infer_string, temp_file
     ):
         # GH#50765
         df = pd.DataFrame(
@@ -184,10 +186,10 @@ def test_read_feather_dtype_backend(
             }
         )
 
-        with tm.ensure_clean() as path:
-            to_feather(df, path)
-            with pd.option_context("mode.string_storage", string_storage):
-                result = read_feather(path, dtype_backend=dtype_backend)
+        path = str(temp_file)
+        to_feather(df, path)
+        with pd.option_context("mode.string_storage", string_storage):
+            result = read_feather(path, dtype_backend=dtype_backend)
 
         if dtype_backend == "pyarrow":
             pa = pytest.importorskip("pyarrow")
@@ -227,20 +229,20 @@ def test_read_feather_dtype_backend(
             )
         tm.assert_frame_equal(result, expected)
 
-    def test_int_columns_and_index(self):
+    def test_int_columns_and_index(self, temp_file):
         df = pd.DataFrame({"a": [1, 2, 3]}, index=pd.Index([3, 4, 5], name="test"))
-        self.check_round_trip(df)
+        self.check_round_trip(df, temp_file)
 
-    def test_invalid_dtype_backend(self):
+    def test_invalid_dtype_backend(self, temp_file):
         msg = (
             "dtype_backend numpy is invalid, only 'numpy_nullable' and "
             "'pyarrow' are allowed."
         )
         df = pd.DataFrame({"int": list(range(1, 4))})
-        with tm.ensure_clean("tmp.feather") as path:
-            df.to_feather(path)
-            with pytest.raises(ValueError, match=msg):
-                read_feather(path, dtype_backend="numpy")
+        path = str(temp_file)
+        df.to_feather(path)
+        with pytest.raises(ValueError, match=msg):
+            read_feather(path, dtype_backend="numpy")
 
     def test_string_inference(self, tmp_path, using_infer_string):
         # GH#54431
@@ -283,7 +285,7 @@ def test_string_inference_string_view_type(self, tmp_path):
             )
         tm.assert_frame_equal(result, expected)
 
-    def test_out_of_bounds_datetime_to_feather(self):
+    def test_out_of_bounds_datetime_to_feather(self, temp_file):
         # GH#47832
         df = pd.DataFrame(
             {
@@ -293,4 +295,4 @@ def test_out_of_bounds_datetime_to_feather(self):
                 ],
             }
         )
-        self.check_round_trip(df)
+        self.check_round_trip(df, temp_file)