fix: preserve absolute root in _strip_protocol so walk("/") works (#69)

* fix: preserve root path in _strip_protocol so walk('/') works

SSHFileSystem inherited the default root_marker of "", so
_strip_protocol("/") collapsed the root to an empty string. walk("/")
then listed the home directory and produced relative paths that were
not considered to exist. Set root_marker = "/" to keep the root, and
add walk tests covering a nested tree and the root case.

* Address review

* tests: make test_walk_root deterministic

The mock server exposes the host's real filesystem, so assertions about
the contents of "/" depend on machine state: mock-ssh-server stats
every entry of a listing, so a single dangling symlink at the host root
fails the whole readdir, and fsspec's walk(on_error="omit") swallows
the error, silently turning the name/exists assertions into a no-op.

Assert only the yielded root, which distinguishes the fix (root "/")
from the regression (root "") on every machine. Also correct the
failure-mode note: most servers (e.g. OpenSSH) reject an empty path
with ENOENT outside REALPATH; servers implementing the SFTP draft's
empty-path rule resolve it to the default directory instead.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* tests: replace walk-based root test with stat-based assertions

test_walk_root listed the host's real root through the mock server:
mock-ssh-server stats every entry of a listing, so a single dangling
symlink at "/" fails the whole readdir. On older fsspec releases
(e.g. 2025.10.0, which Python 3.9 resolves) walk() yields nothing when
the listing fails, so next() raised StopIteration -- the
macos-latest/3.9 CI failure. Assert root resolution via stat instead,
which depends neither on the contents of "/" nor on the fsspec
version.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Ivan Shcheklein <shcheklein@gmail.com>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: 3 people

sshfs/spec.py

@@ -97,7 +97,14 @@ def __init__(
     def _strip_protocol(cls, path):
         # Remove components such as host and username from path.
         inferred_path = infer_storage_options(path)["path"]
-        return super()._strip_protocol(inferred_path)
+        stripped = super()._strip_protocol(inferred_path)
+        # super() collapses a bare "/" to the (empty) root_marker. Restore it
+        # only when the caller explicitly supplied the absolute root, so that
+        # walk("/") lists from the root while relative paths (and "") still
+        # resolve against the home directory.
+        if not stripped and inferred_path.startswith("/"):
+            return "/"
+        return stripped
 
     @staticmethod
     def _get_kwargs_from_urls(urlpath):

tests/test_sshfs.py

@@ -256,6 +256,45 @@ def test_ls(fs, remote_dir):
     assert dirs == expected
 
 
+def test_walk(fs, remote_dir):
+    fs.mkdir(remote_dir + "/a")
+    fs.mkdir(remote_dir + "/a/b")
+    fs.touch(remote_dir + "/a/f1")
+    fs.touch(remote_dir + "/a/b/f2")
+
+    result = {
+        root: (sorted(dirs), sorted(files))
+        for root, dirs, files in fs.walk(remote_dir + "/a")
+    }
+    assert result == {
+        remote_dir + "/a": (["b"], ["f1"]),
+        remote_dir + "/a/b": ([], ["f2"]),
+    }
+
+
+def test_root(fs):
+    # An explicit "/" must resolve to the filesystem root, not the
+    # user's home directory.
+    assert fs.exists("/")
+    assert fs.isdir("/")
+    assert fs.info("/")["name"] == "/"
+
+
+def test_strip_protocol():
+    strip = SSHFileSystem._strip_protocol
+    # An explicit absolute root is preserved so walk("/") lists from the root.
+    assert strip("/") == "/"
+    assert strip("ssh://host/") == "/"
+    # Empty and relative paths still resolve against the home directory
+    # instead of being redirected to the root.
+    assert strip("") == ""
+    assert strip("ssh://host") == ""
+    assert strip("foo/bar") == "foo/bar"
+    # Regular absolute paths are unaffected.
+    assert strip("/foo/bar") == "/foo/bar"
+    assert strip("ssh://host/foo/bar") == "/foo/bar"
+
+
 def test_mkdir(fs, remote_dir):
     fs.mkdir(remote_dir + "dir/")
     assert fs.isdir(remote_dir + "dir/")