fix: add sanitize path fixture for win tests

fsspec/implementations/tests/local/local_fixtures.py

@@ -1,6 +1,6 @@
 import pytest
 
-from fsspec.implementations.local import LocalFileSystem
+from fsspec.implementations.local import LocalFileSystem, make_path_posix
 from fsspec.tests.abstract import AbstractFixtures
 
 
@@ -12,3 +12,7 @@ def fs(self):
     @pytest.fixture
     def fs_path(self, tmpdir):
         return str(tmpdir)
+
+    @pytest.fixture
+    def fs_sanitize_path(self):
+        return make_path_posix

fsspec/implementations/tests/test_local.py

@@ -954,12 +954,12 @@ def test_cp_get_put_empty_directory(tmpdir, funcname):
     # cp/get/put without slash, target directory exists
     assert fs.isdir(target)
     func(empty, target)
-    assert fs.find(target, withdirs=True) == [target]
+    assert fs.find(target, withdirs=True) == [make_path_posix(target)]
 
     # cp/get/put with slash, target directory exists
     assert fs.isdir(target)
     func(empty + "/", target)
-    assert fs.find(target, withdirs=True) == [target]
+    assert fs.find(target, withdirs=True) == [make_path_posix(target)]
 
     fs.rmdir(target)
 

fsspec/tests/abstract/__init__.py

@@ -167,8 +167,13 @@ def local_join(self):
     def local_path(self, tmpdir):
         return tmpdir
 
+    @pytest.fixture
     def supports_empty_directories(self):
         """
         Return whether this implementation supports empty directories.
         """
         return True
+
+    @pytest.fixture
+    def fs_sanitize_path(self):
+        return lambda x: x

fsspec/tests/abstract/copy.py

@@ -7,14 +7,19 @@
 
 class AbstractCopyTests:
     def test_copy_file_to_existing_directory(
-        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
     ):
         # Copy scenario 1a
         source = fs_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
+        if supports_empty_directories:
             # Force target directory to exist by adding a dummy file
             fs.touch(fs_join(target, "dummy"))
         assert fs.isdir(target)
@@ -87,14 +92,19 @@ def test_copy_file_to_file_in_new_directory(
         assert fs.isfile(fs_join(target, "newdir", "newfile"))
 
     def test_copy_directory_to_existing_directory(
-        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
     ):
         # Copy scenario 1e
         source = fs_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
+        if not supports_empty_directories:
             # Force target directory to exist by adding a dummy file
             dummy = fs_join(target, "dummy")
             fs.touch(dummy)
@@ -108,7 +118,7 @@ def test_copy_directory_to_existing_directory(
 
             # Without recursive does nothing
             fs.cp(s, t)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == [] if supports_empty_directories else [dummy]
 
             # With recursive
             fs.cp(s, t, recursive=True)
@@ -128,7 +138,7 @@ def test_copy_directory_to_existing_directory(
                 assert fs.isfile(fs_join(target, "subdir", "nesteddir", "nestedfile"))
 
                 fs.rm(fs_join(target, "subdir"), recursive=True)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == [] if supports_empty_directories else [dummy]
 
             # Limit recursive by maxdepth
             fs.cp(s, t, recursive=True, maxdepth=1)
@@ -146,10 +156,15 @@ def test_copy_directory_to_existing_directory(
                 assert not fs.exists(fs_join(target, "subdir", "nesteddir"))
 
                 fs.rm(fs_join(target, "subdir"), recursive=True)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == [] if supports_empty_directories else [dummy]
 
     def test_copy_directory_to_new_directory(
-        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
     ):
         # Copy scenario 1f
         source = fs_bulk_operations_scenario_0
@@ -167,7 +182,7 @@ def test_copy_directory_to_new_directory(
 
             # Without recursive does nothing
             fs.cp(s, t)
-            if self.supports_empty_directories():
+            if supports_empty_directories:
                 assert fs.ls(target) == []
             else:
                 with pytest.raises(FileNotFoundError):
@@ -210,6 +225,7 @@ def test_copy_glob(
         fs_join,
         fs_bulk_operations_scenario_0_glob,
         fs_target,
+        fs_sanitize_path,
     ):
         # Copy scenario 1g
         source = fs_bulk_operations_scenario_0_glob
@@ -226,9 +242,13 @@ def test_copy_glob(
 
             output = fs.find(target)
             if new_dir:
-                prefixed_expected = [fs_join(target, "newdir", p) for p in expected]
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, "newdir", p)) for p in expected
+                ]
             else:
-                prefixed_expected = [fs_join(target, p) for p in expected]
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, p)) for p in expected
+                ]
             assert sorted(output) == sorted(prefixed_expected)
 
             try:
@@ -237,14 +257,19 @@ def test_copy_glob(
                 pass
 
     def test_copy_list_of_files_to_existing_directory(
-        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
     ):
         # Copy scenario 2a
         source = fs_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
+        if not supports_empty_directories:
             # Force target directory to exist by adding a dummy file
             dummy = fs_join(target, "dummy")
             fs.touch(dummy)
@@ -265,7 +290,7 @@ def test_copy_list_of_files_to_existing_directory(
             assert fs.isfile(fs_join(target, "subfile1"))
 
             fs.rm(fs.find(target))
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == [] if supports_empty_directories else [dummy]
 
     def test_copy_list_of_files_to_new_directory(
         self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target

fsspec/tests/abstract/get.py

@@ -2,6 +2,7 @@
 
 import pytest
 
+from fsspec.implementations.local import make_path_posix
 from fsspec.tests.conftest import GLOB_TESTS
 
 
@@ -243,9 +244,13 @@ def test_get_glob(
 
             output = local_fs.find(target)
             if new_dir:
-                prefixed_expected = [local_join(target, "newdir", p) for p in expected]
+                prefixed_expected = [
+                    make_path_posix(local_join(target, "newdir", p)) for p in expected
+                ]
             else:
-                prefixed_expected = [local_join(target, p) for p in expected]
+                prefixed_expected = [
+                    make_path_posix(local_join(target, p)) for p in expected
+                ]
             assert sorted(output) == sorted(prefixed_expected)
 
             try:

fsspec/tests/abstract/put.py

@@ -13,13 +13,14 @@ def test_put_file_to_existing_directory(
         fs_target,
         local_join,
         local_bulk_operations_scenario_0,
+        supports_empty_directories,
     ):
         # Copy scenario 1a
         source = local_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
+        if not supports_empty_directories:
             # Force target directory to exist by adding a dummy file
             fs.touch(fs_join(target, "dummy"))
         assert fs.isdir(target)
@@ -93,14 +94,19 @@ def test_put_file_to_file_in_new_directory(
         assert fs.isfile(fs_join(target, "newdir", "newfile"))
 
     def test_put_directory_to_existing_directory(
-        self, fs, fs_join, fs_target, local_bulk_operations_scenario_0
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
     ):
         # Copy scenario 1e
         source = local_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
+        if not supports_empty_directories:
             # Force target directory to exist by adding a dummy file
             dummy = fs_join(target, "dummy")
             fs.touch(dummy)
@@ -114,7 +120,7 @@ def test_put_directory_to_existing_directory(
 
             # Without recursive does nothing
             fs.put(s, t)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == [] if supports_empty_directories else [dummy]
 
             # With recursive
             fs.put(s, t, recursive=True)
@@ -134,7 +140,7 @@ def test_put_directory_to_existing_directory(
                 assert fs.isfile(fs_join(target, "subdir", "nesteddir", "nestedfile"))
 
                 fs.rm(fs_join(target, "subdir"), recursive=True)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == [] if supports_empty_directories else [dummy]
 
             # Limit recursive by maxdepth
             fs.put(s, t, recursive=True, maxdepth=1)
@@ -152,17 +158,22 @@ def test_put_directory_to_existing_directory(
                 assert not fs.exists(fs_join(target, "subdir", "nesteddir"))
 
                 fs.rm(fs_join(target, "subdir"), recursive=True)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == [] if supports_empty_directories else [dummy]
 
     def test_put_directory_to_new_directory(
-        self, fs, fs_join, fs_target, local_bulk_operations_scenario_0
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
     ):
         # Copy scenario 1f
         source = local_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
+        if not supports_empty_directories:
             # Force target directory to exist by adding a dummy file
             dummy = fs_join(target, "dummy")
             fs.touch(dummy)
@@ -178,7 +189,7 @@ def test_put_directory_to_new_directory(
 
             # Without recursive does nothing
             fs.put(s, t)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == [] if supports_empty_directories else [dummy]
 
             # With recursive
             fs.put(s, t, recursive=True)
@@ -207,7 +218,7 @@ def test_put_directory_to_new_directory(
         ("path", "recursive", "maxdepth", "expected"),
         GLOB_TESTS,
     )
-    def test_get_glob(
+    def test_put_glob(
         self,
         path,
         recursive,
@@ -218,6 +229,7 @@ def test_get_glob(
         fs_target,
         local_bulk_operations_scenario_0_glob,
         local_join,
+        fs_sanitize_path,
     ):
         # Copy scenario 1g
         source = local_bulk_operations_scenario_0_glob
@@ -234,9 +246,13 @@ def test_get_glob(
 
             output = fs.find(target)
             if new_dir:
-                prefixed_expected = [fs_join(target, "newdir", p) for p in expected]
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, "newdir", p)) for p in expected
+                ]
             else:
-                prefixed_expected = [fs_join(target, p) for p in expected]
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, p)) for p in expected
+                ]
             assert sorted(output) == sorted(prefixed_expected)
 
             try:
@@ -251,14 +267,14 @@ def test_put_list_of_files_to_existing_directory(
         fs_target,
         local_join,
         local_bulk_operations_scenario_0,
-        fs_path,
+        supports_empty_directories,
     ):
         # Copy scenario 2a
         source = local_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
+        if not supports_empty_directories:
             # Force target directory to exist by adding a dummy file
             dummy = fs_join(target, "dummy")
             fs.touch(dummy)
@@ -279,7 +295,7 @@ def test_put_list_of_files_to_existing_directory(
             assert fs.isfile(fs_join(target, "subfile1"))
 
             fs.rm(fs.find(target))
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == [] if supports_empty_directories else [dummy]
 
     def test_put_list_of_files_to_new_directory(
         self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0