mock fs now supports multiple volumes on windows

Author: evanw

internal/fs/fs_mock.go

@@ -22,17 +22,24 @@ type mockFS struct {
 	dirs          map[string]DirEntries
 	files         map[string]string
 	absWorkingDir string
+	defaultVolume string
 	Kind          MockKind
 }
 
 func MockFS(input map[string]string, kind MockKind, absWorkingDir string) FS {
 	dirs := make(map[string]DirEntries)
 	files := make(map[string]string)
 
+	var defaultVolume string
+	if kind == MockWindows {
+		_, defaultVolume = win2unix(absWorkingDir)
+	}
+
 	for k, v := range input {
+		var volume string
 		files[k] = v
 		if kind == MockWindows {
-			k = win2unix(k)
+			k, volume = win2unix(k)
 		}
 		original := k
 
@@ -41,7 +48,7 @@ func MockFS(input map[string]string, kind MockKind, absWorkingDir string) FS {
 			kDir := path.Dir(k)
 			key := kDir
 			if kind == MockWindows {
-				key = unix2win(key)
+				key = unix2win(key, volume, defaultVolume)
 			}
 			dir, ok := dirs[key]
 			if !ok {
@@ -61,7 +68,7 @@ func MockFS(input map[string]string, kind MockKind, absWorkingDir string) FS {
 		}
 	}
 
-	return &mockFS{dirs, files, absWorkingDir, kind}
+	return &mockFS{dirs, files, absWorkingDir, defaultVolume, kind}
 }
 
 func (fs *mockFS) ReadDirectory(path string) (DirEntries, error, error) {
@@ -114,92 +121,106 @@ func (fs *mockFS) ModKey(path string) (ModKey, error) {
 	return ModKey{}, errors.New("This is not available during tests")
 }
 
-func win2unix(p string) string {
-	if strings.HasPrefix(p, "C:\\") || strings.HasPrefix(p, "c:\\") {
-		p = p[2:]
+func win2unix(p string) (result string, volume string) {
+	if len(p) > 0 && strings.HasPrefix(p[1:], ":\\") {
+		if c := p[0]; (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') {
+			volume = p[0:1]
+			p = p[2:]
+		}
 	}
 	p = strings.ReplaceAll(p, "\\", "/")
-	return p
+	return p, volume
 }
 
-func unix2win(p string) string {
+func unix2win(p string, volume string, defaultVolume string) string {
 	p = strings.ReplaceAll(p, "/", "\\")
 	if strings.HasPrefix(p, "\\") {
-		p = "C:" + p
+		if volume == "" {
+			volume = defaultVolume
+		}
+		p = volume + ":" + p
 	}
 	return p
 }
 
 func (fs *mockFS) IsAbs(p string) bool {
 	if fs.Kind == MockWindows {
-		p = win2unix(p)
+		p, _ = win2unix(p)
 	}
 	return path.IsAbs(p)
 }
 
 func (fs *mockFS) Abs(p string) (string, bool) {
+	var volume string
 	if fs.Kind == MockWindows {
-		p = win2unix(p)
+		p, volume = win2unix(p)
 	}
 
 	p = path.Clean(path.Join("/", p))
 
 	if fs.Kind == MockWindows {
-		p = unix2win(p)
+		p = unix2win(p, volume, fs.defaultVolume)
 	}
 
 	return p, true
 }
 
 func (fs *mockFS) Dir(p string) string {
+	var volume string
 	if fs.Kind == MockWindows {
-		p = win2unix(p)
+		p, volume = win2unix(p)
 	}
 
 	p = path.Dir(p)
 
 	if fs.Kind == MockWindows {
-		p = unix2win(p)
+		p = unix2win(p, volume, fs.defaultVolume)
 	}
 
 	return p
 }
 
 func (fs *mockFS) Base(p string) string {
+	var volume string
 	if fs.Kind == MockWindows {
-		p = win2unix(p)
+		p, volume = win2unix(p)
 	}
 
 	p = path.Base(p)
 
 	if fs.Kind == MockWindows && p == "/" {
-		p = "\\"
+		p = volume + ":\\"
 	}
 
 	return p
 }
 
 func (fs *mockFS) Ext(p string) string {
 	if fs.Kind == MockWindows {
-		p = win2unix(p)
+		p, _ = win2unix(p)
 	}
 
 	return path.Ext(p)
 }
 
 func (fs *mockFS) Join(parts ...string) string {
+	var volume string
 	if fs.Kind == MockWindows {
 		converted := make([]string, len(parts))
 		for i, part := range parts {
-			converted[i] = win2unix(part)
+			var v string
+			converted[i], v = win2unix(part)
+			if i == 0 {
+				volume = v
+			}
 		}
 		parts = converted
 	}
 
 	p := path.Clean(path.Join(parts...))
 
 	if fs.Kind == MockWindows {
-		p = unix2win(p)
+		p = unix2win(p, volume, fs.defaultVolume)
 	}
 
 	return p
@@ -217,9 +238,20 @@ func splitOnSlash(path string) (string, string) {
 }
 
 func (fs *mockFS) Rel(base string, target string) (string, bool) {
+	var volume string
 	if fs.Kind == MockWindows {
-		base = win2unix(base)
-		target = win2unix(target)
+		var v string
+		base, volume = win2unix(base)
+		target, v = win2unix(target)
+		if volume == "" {
+			volume = fs.defaultVolume
+		}
+		if v == "" {
+			v = fs.defaultVolume
+		}
+		if strings.ToUpper(v) != strings.ToUpper(volume) {
+			return "", false
+		}
 	}
 
 	base = path.Clean(base)
@@ -255,7 +287,7 @@ func (fs *mockFS) Rel(base string, target string) (string, bool) {
 	// Stop now if base is a subpath of target
 	if base == "" {
 		if fs.Kind == MockWindows {
-			target = unix2win(target)
+			target = unix2win(target, volume, fs.defaultVolume)
 		}
 		return target, true
 	}
@@ -267,15 +299,15 @@ func (fs *mockFS) Rel(base string, target string) (string, bool) {
 	if target == "" {
 		target = commonParent[:len(commonParent)-1]
 		if fs.Kind == MockWindows {
-			target = unix2win(target)
+			target = unix2win(target, volume, fs.defaultVolume)
 		}
 		return target, true
 	}
 
 	// Otherwise, down to the parent
 	target = commonParent + target
 	if fs.Kind == MockWindows {
-		target = unix2win(target)
+		target = unix2win(target, volume, fs.defaultVolume)
 	}
 	return target, true
 }

internal/fs/fs_mock_test.go

@@ -74,10 +74,11 @@ func TestMockFSBasicUnix(t *testing.T) {
 
 func TestMockFSBasicWindows(t *testing.T) {
 	fs := MockFS(map[string]string{
-		"C:\\README.md":     "// README.md",
-		"C:\\package.json":  "// package.json",
-		"C:\\src\\index.js": "// src/index.js",
-		"C:\\src\\util.js":  "// src/util.js",
+		"C:\\README.md":       "// README.md",
+		"C:\\package.json":    "// package.json",
+		"C:\\src\\index.js":   "// src/index.js",
+		"C:\\src\\util.js":    "// src/util.js",
+		"D:\\other\\file.txt": "// other/file.txt",
 	}, MockWindows, "C:\\")
 
 	// Test a missing file
@@ -104,6 +105,21 @@ func TestMockFSBasicWindows(t *testing.T) {
 		t.Fatalf("Incorrect contents for C:\\src\\index.js: %q", index)
 	}
 
+	// Test an existing nested file on another drive
+	file, err, _ := fs.ReadFile("D:\\other\\file.txt")
+	if err != nil {
+		t.Fatal("Expected to find D:\\other\\file.txt")
+	}
+	if file != "// other/file.txt" {
+		t.Fatalf("Incorrect contents for D:\\other/file.txt: %q", file)
+	}
+
+	// Should not find a file on another drive
+	_, err, _ = fs.ReadFile("C:\\other\\file.txt")
+	if err == nil {
+		t.Fatal("Unexpectedly found C:\\other\\file.txt")
+	}
+
 	// Test a missing directory
 	_, err, _ = fs.ReadDirectory("C:\\missing")
 	if err == nil {
@@ -123,6 +139,17 @@ func TestMockFSBasicWindows(t *testing.T) {
 		t.Fatalf("Incorrect contents for C:\\src: %v", src)
 	}
 
+	// Test a nested directory on another drive
+	other, err, _ := fs.ReadDirectory("D:\\other")
+	if err != nil {
+		t.Fatal("Expected to find D:\\other")
+	}
+	fileEntry, _ := other.Get("file.txt")
+	if len(other.data) != 1 ||
+		fileEntry == nil || fileEntry.Kind(fs) != FileEntry {
+		t.Fatalf("Incorrect contents for D:\\other: %v", other)
+	}
+
 	// Test the top-level directory
 	slash, err, _ := fs.ReadDirectory("C:\\")
 	if err != nil {
@@ -177,34 +204,44 @@ func TestMockFSRelUnix(t *testing.T) {
 func TestMockFSRelWindows(t *testing.T) {
 	fs := MockFS(map[string]string{}, MockWindows, "C:\\")
 
-	expect := func(a string, b string, c string) {
+	expect := func(a string, b string, works bool, c string) {
 		t.Helper()
 		t.Run(fmt.Sprintf("Rel(%q, %q) == %q", a, b, c), func(t *testing.T) {
 			t.Helper()
 			rel, ok := fs.Rel(a, b)
-			if !ok {
-				t.Fatalf("!ok")
-			}
-			if rel != c {
-				t.Fatalf("Expected %q, got %q", c, rel)
+			if works {
+				if !ok {
+					t.Fatalf("!ok")
+				}
+				if rel != c {
+					t.Fatalf("Expected %q, got %q", c, rel)
+				}
+			} else {
+				if ok {
+					t.Fatalf("ok")
+				}
 			}
 		})
 	}
 
-	expect("C:\\a\\b", "C:\\a\\b", ".")
-	expect("C:\\a\\b", "C:\\a\\b\\c", "c")
-	expect("C:\\a\\b", "C:\\a\\b\\c\\d", "c\\d")
-	expect("C:\\a\\b\\c", "C:\\a\\b", "..")
-	expect("C:\\a\\b\\c\\d", "C:\\a\\b", "..\\..")
-	expect("C:\\a\\b\\c", "C:\\a\\b\\x", "..\\x")
-	expect("C:\\a\\b\\c\\d", "C:\\a\\b\\x", "..\\..\\x")
-	expect("C:\\a\\b\\c", "C:\\a\\b\\x\\y", "..\\x\\y")
-	expect("C:\\a\\b\\c\\d", "C:\\a\\b\\x\\y", "..\\..\\x\\y")
-
-	expect("a\\b", "a\\c", "..\\c")
-	expect(".\\a\\b", ".\\a\\c", "..\\c")
-	expect(".", ".\\a\\b", "a\\b")
-	expect(".", ".\\\\a\\b", "a\\b")
-	expect(".", ".\\.\\a\\b", "a\\b")
-	expect(".", ".\\.\\\\a\\b", "a\\b")
+	expect("C:\\a\\b", "C:\\a\\b", true, ".")
+	expect("C:\\a\\b", "C:\\a\\b\\c", true, "c")
+	expect("C:\\a\\b", "C:\\a\\b\\c\\d", true, "c\\d")
+	expect("C:\\a\\b\\c", "C:\\a\\b", true, "..")
+	expect("C:\\a\\b\\c\\d", "C:\\a\\b", true, "..\\..")
+	expect("C:\\a\\b\\c", "C:\\a\\b\\x", true, "..\\x")
+	expect("C:\\a\\b\\c\\d", "C:\\a\\b\\x", true, "..\\..\\x")
+	expect("C:\\a\\b\\c", "C:\\a\\b\\x\\y", true, "..\\x\\y")
+	expect("C:\\a\\b\\c\\d", "C:\\a\\b\\x\\y", true, "..\\..\\x\\y")
+
+	expect("a\\b", "a\\c", true, "..\\c")
+	expect(".\\a\\b", ".\\a\\c", true, "..\\c")
+	expect(".", ".\\a\\b", true, "a\\b")
+	expect(".", ".\\\\a\\b", true, "a\\b")
+	expect(".", ".\\.\\a\\b", true, "a\\b")
+	expect(".", ".\\.\\\\a\\b", true, "a\\b")
+
+	expect("C:\\a\\b", "\\a\\b", true, ".")
+	expect("\\a", "\\b", true, "..\\b")
+	expect("C:\\a", "D:\\a", false, "")
 }