Add symlink support to vfstest package (microsoft#396)

Author: jakebailey

internal/execute/testsys_test.go

@@ -1,8 +1,10 @@
 package execute_test
 
 import (
+	"errors"
 	"fmt"
 	"io"
+	"io/fs"
 	"maps"
 	"slices"
 	"strings"
@@ -90,21 +92,25 @@ func (s *testSys) baselineFSwithDiff(baseline io.Writer) {
 	snap := map[string]string{}
 
 	err := s.FS().WalkDir(s.GetCurrentDirectory(), func(path string, d vfs.DirEntry, e error) error {
-		if !s.FS().FileExists(path) {
+		if e != nil {
+			return e
+		}
+
+		if !d.Type().IsRegular() {
 			return nil
 		}
 
 		newContents, ok := s.FS().ReadFile(path)
 		if !ok {
-			return e
+			return nil
 		}
 		snap[path] = newContents
 		reportFSEntryDiff(baseline, s.serializedDiff[path], newContents, path)
 
 		return nil
 	})
-	if err != nil {
-		panic("walkdir error during diff")
+	if err != nil && !errors.Is(err, fs.ErrNotExist) {
+		panic("walkdir error during diff: " + err.Error())
 	}
 	for path, oldDirContents := range s.serializedDiff {
 		if s.FS().FileExists(path) {

internal/vfs/vfstest/vfstest.go

@@ -1,6 +1,7 @@
 package vfstest
 
 import (
+	"errors"
 	"fmt"
 	"io/fs"
 	"maps"
@@ -23,11 +24,14 @@ type mapFS struct {
 	m  fstest.MapFS
 
 	useCaseSensitiveFileNames bool
+
+	symlinks map[canonicalPath]canonicalPath
 }
 
 var (
 	_ iovfs.RealpathFS = (*mapFS)(nil)
 	_ iovfs.WritableFS = (*mapFS)(nil)
+	_ fs.ReadFileFS    = (*mapFS)(nil)
 )
 
 type sys struct {
@@ -45,7 +49,7 @@ func FromMap[File any](m map[string]File, useCaseSensitiveFileNames bool) vfs.FS
 	posix := false
 	windows := false
 
-	for p := range m {
+	checkPath := func(p string) {
 		if !tspath.IsRootedDiskPath(p) {
 			panic(fmt.Sprintf("non-rooted path %q", p))
 		}
@@ -61,12 +65,10 @@ func FromMap[File any](m map[string]File, useCaseSensitiveFileNames bool) vfs.FS
 		}
 	}
 
-	if posix && windows {
-		panic("mixed posix and windows paths")
-	}
-
 	mfs := make(fstest.MapFS, len(m))
 	for p, f := range m {
+		checkPath(p)
+
 		var file *fstest.MapFile
 		switch f := any(f).(type) {
 		case string:
@@ -79,10 +81,24 @@ func FromMap[File any](m map[string]File, useCaseSensitiveFileNames bool) vfs.FS
 			panic(fmt.Sprintf("invalid file type %T", f))
 		}
 
+		if file.Mode&fs.ModeSymlink != 0 {
+			target := string(file.Data)
+			checkPath(target)
+
+			target, _ = strings.CutPrefix(target, "/")
+			fileCopy := *file
+			fileCopy.Data = []byte(target)
+			file = &fileCopy
+		}
+
 		p, _ = strings.CutPrefix(p, "/")
 		mfs[p] = file
 	}
 
+	if posix && windows {
+		panic("mixed posix and windows paths")
+	}
+
 	return iovfs.From(convertMapFS(mfs, useCaseSensitiveFileNames), useCaseSensitiveFileNames)
 }
 
@@ -115,8 +131,10 @@ func convertMapFS(input fstest.MapFS, useCaseSensitiveFileNames bool) *mapFS {
 		// Create all missing intermediate directories so we can attach the realpath to each of them.
 		// fstest.MapFS doesn't require this as it synthesizes directories on the fly, but it's a lot
 		// harder to reapply a realpath onto those when we're deep in some FileInfo method.
-		if err := m.mkdirAll(dirName(p), 0o777); err != nil {
-			panic(fmt.Sprintf("failed to create intermediate directories for %q: %v", p, err))
+		if dir := dirName(p); dir != "" {
+			if err := m.mkdirAll(dir, 0o777); err != nil {
+				panic(fmt.Sprintf("failed to create intermediate directories for %q: %v", p, err))
+			}
 		}
 		m.setEntry(p, m.getCanonicalPath(p), *file)
 	}
@@ -151,44 +169,137 @@ func (m *mapFS) open(p canonicalPath) (fs.File, error) {
 	return m.m.Open(string(p))
 }
 
-func (m *mapFS) get(p canonicalPath) (*fstest.MapFile, bool) {
-	file, ok := m.m[string(p)]
-	return file, ok
+func Symlink(target string) *fstest.MapFile {
+	return &fstest.MapFile{
+		Data: []byte(target),
+		Mode: fs.ModeSymlink,
+	}
+}
+
+func (m *mapFS) getFollowingSymlinks(p canonicalPath) (*fstest.MapFile, canonicalPath, error) {
+	return m.getFollowingSymlinksWorker(p, "", "")
+}
+
+type brokenSymlinkError struct {
+	from, to canonicalPath
+}
+
+func (e *brokenSymlinkError) Error() string {
+	return fmt.Sprintf("broken symlink %q -> %q", e.from, e.to)
+}
+
+func (m *mapFS) getFollowingSymlinksWorker(p canonicalPath, symlinkFrom, symlinkTo canonicalPath) (*fstest.MapFile, canonicalPath, error) {
+	if file, ok := m.m[string(p)]; ok && file.Mode&fs.ModeSymlink == 0 {
+		return file, p, nil
+	}
+
+	if target, ok := m.symlinks[p]; ok {
+		return m.getFollowingSymlinksWorker(target, p, target)
+	}
+
+	// This could be a path underneath a symlinked directory.
+	for other, target := range m.symlinks {
+		if len(other) < len(p) && other == p[:len(other)] && p[len(other)] == '/' {
+			return m.getFollowingSymlinksWorker(target+p[len(other):], other, target)
+		}
+	}
+
+	err := fs.ErrNotExist
+	if symlinkFrom != "" {
+		err = &brokenSymlinkError{symlinkFrom, symlinkTo}
+	}
+	return nil, p, err
 }
 
 func (m *mapFS) set(p canonicalPath, file *fstest.MapFile) {
 	m.m[string(p)] = file
 }
 
 func (m *mapFS) setEntry(realpath string, canonical canonicalPath, file fstest.MapFile) {
+	if realpath == "" || canonical == "" {
+		panic("empty path")
+	}
+
 	file.Sys = &sys{
 		original: file.Sys,
 		realpath: realpath,
 	}
 	m.set(canonical, &file)
+
+	if file.Mode&fs.ModeSymlink != 0 {
+		if m.symlinks == nil {
+			m.symlinks = make(map[canonicalPath]canonicalPath)
+		}
+		m.symlinks[canonical] = m.getCanonicalPath(string(file.Data))
+	}
 }
 
-func dirName(p string) string {
-	dir := path.Dir(p)
-	if dir == "." {
-		return ""
+func splitPath(s string, offset int) (before, after string) {
+	idx := strings.IndexByte(s[offset:], '/')
+	if idx < 0 {
+		return s, ""
 	}
-	return dir
+	return s[:idx+offset], s[idx+1+offset:]
+}
+
+func dirName(p string) string {
+	dir, _ := path.Split(p)
+	return strings.TrimSuffix(dir, "/")
+}
+
+func baseName(p string) string {
+	_, file := path.Split(p)
+	return file
 }
 
 func (m *mapFS) mkdirAll(p string, perm fs.FileMode) error {
-	for ; p != ""; p = dirName(p) {
-		canonical := m.getCanonicalPath(p)
-		if other, ok := m.get(canonical); ok {
-			if other.Mode.IsDir() {
-				break
-			}
+	if p == "" {
+		panic("empty path")
+	}
+
+	// Fast path; already exists.
+	if other, _, err := m.getFollowingSymlinks(m.getCanonicalPath(p)); err == nil {
+		if !other.Mode.IsDir() {
 			return fmt.Errorf("mkdir %q: path exists but is not a directory", p)
 		}
-		m.setEntry(p, canonical, fstest.MapFile{
+		return nil
+	}
+
+	var toCreate []string
+	offset := 0
+	for {
+		dir, rest := splitPath(p, offset)
+		canonical := m.getCanonicalPath(dir)
+		other, otherPath, err := m.getFollowingSymlinks(canonical)
+		if err != nil {
+			if !errors.Is(err, fs.ErrNotExist) {
+				return err
+			}
+			toCreate = append(toCreate, dir)
+		} else {
+			if !other.Mode.IsDir() {
+				return fmt.Errorf("mkdir %q: path exists but is not a directory", otherPath)
+			}
+			if canonical != otherPath {
+				// We have a symlinked parent, reset and start again.
+				p = other.Sys.(*sys).realpath + "/" + rest
+				toCreate = toCreate[:0]
+				offset = 0
+				continue
+			}
+		}
+		if rest == "" {
+			break
+		}
+		offset = len(dir) + 1
+	}
+
+	for _, dir := range toCreate {
+		m.setEntry(dir, m.getCanonicalPath(dir), fstest.MapFile{
 			Mode: fs.ModeDir | perm&^umask,
 		})
 	}
+
 	return nil
 }
 
@@ -199,7 +310,7 @@ type fileInfo struct {
 }
 
 func (fi *fileInfo) Name() string {
-	return path.Base(fi.realpath)
+	return baseName(fi.realpath)
 }
 
 func (fi *fileInfo) Sys() any {
@@ -284,15 +395,24 @@ func (m *mapFS) Open(name string) (fs.File, error) {
 	}, nil
 }
 
+func (m *mapFS) ReadFile(name string) ([]byte, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	file, _, err := m.getFollowingSymlinks(m.getCanonicalPath(name))
+	if err != nil {
+		return nil, err
+	}
+	return file.Data, nil
+}
+
 func (m *mapFS) Realpath(name string) (string, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 
-	// TODO: handle symlinks after https://go.dev/cl/385534 is available
-	// Don't bother going through fs.Stat.
-	file, ok := m.get(m.getCanonicalPath(name))
-	if !ok {
-		return "", fs.ErrNotExist
+	file, _, err := m.getFollowingSymlinks(m.getCanonicalPath(name))
+	if err != nil {
+		return "", err
 	}
 	return file.Sys.(*sys).realpath, nil
 }
@@ -324,16 +444,29 @@ func (m *mapFS) WriteFile(path string, data []byte, perm fs.FileMode) error {
 
 	if parent := dirName(path); parent != "" {
 		canonical := m.getCanonicalPath(parent)
-		parentFile, ok := m.get(canonical)
-		if !ok {
-			return fmt.Errorf("write %q: parent directory does not exist", path)
+		parentFile, _, err := m.getFollowingSymlinks(canonical)
+		if err != nil {
+			return fmt.Errorf("write %q: %w", path, err)
 		}
 		if !parentFile.Mode.IsDir() {
 			return fmt.Errorf("write %q: parent path exists but is not a directory", path)
 		}
 	}
 
-	m.setEntry(path, m.getCanonicalPath(path), fstest.MapFile{
+	file, cp, err := m.getFollowingSymlinks(m.getCanonicalPath(path))
+	if err != nil {
+		var brokenSymlinkError *brokenSymlinkError
+		if !errors.Is(err, fs.ErrNotExist) && !errors.As(err, &brokenSymlinkError) {
+			// No other errors are possible.
+			panic(err)
+		}
+	} else {
+		if !file.Mode.IsRegular() {
+			return fmt.Errorf("write %q: path exists but is not a regular file", path)
+		}
+	}
+
+	m.setEntry(path, cp, fstest.MapFile{
 		Data:    data,
 		ModTime: time.Now(),
 		Mode:    perm &^ umask,