fake_file_system.go

package fakes

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"os"
	gopath "path"
	"path/filepath"
	"sort"
	"strings"
	"sync"
	"syscall"
	"time"

	gouuid "github.com/nu7hatch/gouuid"

	bosherr "github.com/cloudfoundry/bosh-utils/errors"
	boshsys "github.com/cloudfoundry/bosh-utils/system"
)

type FakeFileType string

type removeAllFn func(path string) error
type renameFn func(oldPath, newPath string) error

type globFn func(pattern string) ([]string, error)

const (
	FakeFileTypeFile    FakeFileType = "file"
	FakeFileTypeSymlink FakeFileType = "symlink"
	FakeFileTypeDir     FakeFileType = "dir"
)

type FakeFileSystem struct {
	fileRegistry *FakeFileStatsRegistry
	filesLock    sync.Mutex

	HomeDirUsername string
	HomeDirHomePath string

	ExpandPathPath     string
	ExpandPathExpanded string
	ExpandPathErr      error

	openFileRegistry *FakeFileRegistry
	OpenFileErr      error

	ReadFileError             error
	ReadFileWithOptsCallCount int
	readFileErrorByPath       map[string]error

	WriteFileError            error
	WriteFileErrors           map[string]error
	WriteFileCallCount        int
	WriteFileQuietlyCallCount int

	SymlinkError error

	MkdirAllError       error
	mkdirAllErrorByPath map[string]error
	MkdirAllCallCount   int

	ChangeTempRootErr error

	ChownErr       error
	ChownCallCount int
	ChmodErr       error
	ChmodCallCount int

	CopyFileError     error
	CopyFileCallCount int

	CopyDirError error

	RenameStub     renameFn
	RenameError    error
	RenameOldPaths []string
	RenameNewPaths []string

	RemoveAllStub removeAllFn

	ReadAndFollowLinkError error
	ReadlinkError          error

	StatWithOptsCallCount int
	StatCallCount         int

	TempFileError           error
	TempFileErrorsByPrefix  map[string]error
	ReturnTempFile          boshsys.File
	ReturnTempFiles         []boshsys.File
	ReturnTempFilesByPrefix map[string]boshsys.File

	TempDirDir   string
	TempDirDirs  []string
	TempDirError error

	GlobErr  error
	GlobStub globFn
	GlobErrs map[string]error
	globsMap map[string][][]string

	WalkErr error

	TempRootPath   string
	strictTempRoot bool
}

type FakeFileStats struct {
	FileType FakeFileType

	FileMode  os.FileMode
	Flags     int
	Username  string
	Groupname string

	ModTime time.Time
	Open    bool

	SymlinkTarget string

	Content []byte
}

func (stats FakeFileStats) StringContents() string {
	return string(stats.Content)
}

type FakeFileInfo struct {
	os.FileInfo
	file FakeFile
}

func (fi FakeFileInfo) Mode() os.FileMode {
	return fi.file.Stats.FileMode
}

func (fi FakeFileInfo) ModTime() time.Time {
	return fi.file.Stats.ModTime
}

func (fi FakeFileInfo) Size() int64 {
	return int64(len(fi.file.Contents))
}

func (fi FakeFileInfo) IsDir() bool {
	return fi.file.Stats.FileType == FakeFileTypeDir
}

type FakeFile struct {
	path string
	fs   *FakeFileSystem

	Stats *FakeFileStats

	WriteErr error
	Contents []byte

	ReadErr   error
	ReadAtErr error
	readIndex int64

	CloseErr error

	StatErr error
}

func NewFakeFile(path string, fs *FakeFileSystem) *FakeFile {
	fakeFile := &FakeFile{
		path: path,
		fs:   fs,
	}
	me := fs.fileRegistry.Get(path)
	if me != nil {
		fakeFile.Contents = me.Content
		fakeFile.Stats = me
		fakeFile.Stats.Open = true
	}
	return fakeFile
}

func (f *FakeFile) Name() string {
	return f.path
}

func (f *FakeFile) Write(contents []byte) (int, error) {
	if f.WriteErr != nil {
		return 0, f.WriteErr
	}

	f.fs.filesLock.Lock()
	defer f.fs.filesLock.Unlock()

	stats := f.fs.getOrCreateFile(f.path)
	stats.Content = contents

	f.Contents = contents
	return len(contents), nil
}

func (f *FakeFile) Read(b []byte) (int, error) {
	if f.readIndex >= int64(len(f.Contents)) {
		return 0, io.EOF
	}
	copy(b, f.Contents)
	f.readIndex = int64(len(f.Contents))
	return len(f.Contents), f.ReadErr
}

func (f *FakeFile) ReadAt(b []byte, offset int64) (int, error) {
	copy(b, f.Contents[offset:])
	return len(f.Contents[offset:]), f.ReadAtErr
}

func (f *FakeFile) WriteAt(b []byte, offset int64) (int, error) {
	return len(b), nil
}

func (f *FakeFile) Seek(offset int64, whence int) (int64, error) {
	if whence != io.SeekStart {
		return -1, errors.New(`Invalid argument for "whence": only SeekStart is supported`)
	}
	f.readIndex = offset
	return f.readIndex, nil
}

func (f *FakeFile) Close() error {
	if f.Stats != nil {
		f.Stats.Open = false
	}
	f.fs.openFileRegistry.Remove(f.path)
	return f.CloseErr
}

func (f FakeFile) Stat() (os.FileInfo, error) {
	return FakeFileInfo{file: f}, f.StatErr
}

func NewFakeFileSystem() *FakeFileSystem {
	return &FakeFileSystem{
		fileRegistry:           NewFakeFileStatsRegistry(),
		openFileRegistry:       NewFakeFileRegistry(),
		GlobErrs:               map[string]error{},
		globsMap:               map[string][][]string{},
		readFileErrorByPath:    map[string]error{},
		mkdirAllErrorByPath:    map[string]error{},
		WriteFileErrors:        map[string]error{},
		TempFileErrorsByPrefix: map[string]error{},
	}
}

func (fs *FakeFileSystem) GetFileTestStat(path string) *FakeFileStats {
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	return fs.fileRegistry.Get(path)
}

func (fs *FakeFileSystem) HomeDir(username string) (string, error) {
	fs.HomeDirUsername = username
	return fs.HomeDirHomePath, nil
}

func (fs *FakeFileSystem) ExpandPath(path string) (string, error) {
	fs.ExpandPathPath = path
	if fs.ExpandPathExpanded == "" {
		return fs.ExpandPathPath, fs.ExpandPathErr
	}

	return fs.ExpandPathExpanded, fs.ExpandPathErr
}

func (fs *FakeFileSystem) RegisterMkdirAllError(path string, err error) {
	path = gopath.Join(path)
	if _, ok := fs.mkdirAllErrorByPath[path]; ok {
		panic(fmt.Sprintf("MkdirAll error is already set for path: %s", path))
	}
	fs.mkdirAllErrorByPath[path] = err
}

func (fs *FakeFileSystem) MkdirAll(path string, perm os.FileMode) error {
	fs.MkdirAllCallCount++
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	if fs.MkdirAllError != nil {
		return fs.MkdirAllError
	}

	path = gopath.Join(path)

	if fs.mkdirAllErrorByPath[path] != nil {
		return fs.mkdirAllErrorByPath[path]
	}

	return fs.mkdir(path, perm)
}

func (fs *FakeFileSystem) mkdir(path string, perm os.FileMode) error {
	if path == "." {
		return nil
	}

	if !atRoot(path) {
		parent := filepath.Dir(path)
		// We can't use any functions which require the filesystem lock.
		parentStats := fs.fileRegistry.Get(parent)

		if parentStats != nil && parentStats.FileType == FakeFileTypeFile {
			return fmt.Errorf("cannot create a directory in a file (%s)", path)
		}

		// Parent does not exist
		if parentStats == nil {
			if err := fs.mkdir(parent, perm); err != nil {
				return err
			}
		}
	}

	stats := fs.getOrCreateFile(path)
	stats.FileMode = perm
	stats.FileType = FakeFileTypeDir
	fs.fileRegistry.Register(path, stats)
	return nil
}

func atRoot(path string) bool {
	switch path {
	case "/":
		return true
	case filepath.VolumeName(path) + "\\":
		return true
	default:
		return false
	}
}

func (fs *FakeFileSystem) RegisterOpenFile(path string, file *FakeFile) {
	path = gopath.Join(path)
	fs.openFileRegistry.Register(path, file)
}

func (fs *FakeFileSystem) FindFileStats(path string) (*FakeFileStats, error) {
	if stats := fs.fileRegistry.Get(path); stats != nil {
		return stats, nil
	}
	return nil, fmt.Errorf("Path does not exist: %s", path)
}

func (fs *FakeFileSystem) OpenFile(path string, flag int, perm os.FileMode) (boshsys.File, error) {
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	if fs.OpenFileErr != nil {
		return nil, fs.OpenFileErr
	}

	// Make sure to record a reference for FileExist, etc. to work
	stats := fs.getOrCreateFile(path)
	stats.FileMode = perm
	stats.Flags = flag
	stats.FileType = FakeFileTypeFile

	openFile := fs.openFileRegistry.Get(path)
	if openFile != nil {
		return openFile, nil
	}
	file := NewFakeFile(path, fs)

	fs.RegisterOpenFile(path, file)
	return file, nil
}

func (fs *FakeFileSystem) Stat(path string) (os.FileInfo, error) {
	fs.StatCallCount++
	return fs.StatHelper(path)
}

func (fs *FakeFileSystem) StatWithOpts(path string, opts boshsys.StatOpts) (os.FileInfo, error) {
	fs.StatWithOptsCallCount++
	return fs.StatHelper(path)
}

func (fs *FakeFileSystem) StatHelper(path string) (os.FileInfo, error) {
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	openFile := fs.openFileRegistry.Get(path)
	if openFile != nil {
		return openFile.Stat()
	}

	stats := fs.fileRegistry.Get(path)
	if stats == nil {
		panic(fmt.Sprintf("Unexpected Stat call for path '%s' that does not exist", path))
	}

	if stats.FileType == FakeFileTypeSymlink {
		targetStats := fs.fileRegistry.Get(stats.SymlinkTarget)
		if targetStats == nil {
			return nil, fmt.Errorf("stat: %s: no such file or directory", path)
		}

		stats = targetStats //nolint:staticcheck
	}

	return NewFakeFile(path, fs).Stat()
}
func (fs *FakeFileSystem) Readlink(symlinkPath string) (string, error) {
	targetPath, err := fs.readlink(symlinkPath)
	if err != nil {
		return targetPath, err
	}

	//Converts internal path formatting (which is UNIX/Linux based) to native OS file system path
	//This emulates the real behavior of how the real file system returns symlink
	if strings.HasPrefix(targetPath, "/") {
		absFilePath, err := filepath.Abs(targetPath)
		return absFilePath, err
	}

	return targetPath, err
}

func (fs *FakeFileSystem) readlink(path string) (string, error) {
	if fs.ReadlinkError != nil {
		return "", fs.ReadlinkError
	}

	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	stats := fs.fileRegistry.Get(path)
	if stats == nil {
		return "", os.ErrNotExist
	}

	if stats.FileType != FakeFileTypeSymlink {
		return "", fmt.Errorf("cannot readlink of non-symlink")
	}

	return stats.SymlinkTarget, nil
}

func (fs *FakeFileSystem) Lstat(path string) (os.FileInfo, error) {
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	openFile := fs.openFileRegistry.Get(path)
	if openFile != nil {
		return openFile.Stat()
	}

	stats := fs.fileRegistry.Get(path)
	if stats == nil {
		panic(fmt.Sprintf("Unexpected Stat call for path '%s' that does not exist", path))
	}

	return NewFakeFile(path, fs).Stat()
}

func (fs *FakeFileSystem) Chown(path, username string) error {
	fs.ChownCallCount++
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	// check early to avoid requiring file presence
	if fs.ChownErr != nil {
		return fs.ChownErr
	}

	stats := fs.fileRegistry.Get(path)
	if stats == nil {
		return fmt.Errorf("Path does not exist: %s", path)
	}

	parts := strings.Split(username, ":")
	stats.Username = parts[0]
	stats.Groupname = parts[0]
	if len(parts) > 1 {
		stats.Groupname = parts[1]
	}
	return nil
}

func (fs *FakeFileSystem) Chmod(path string, perm os.FileMode) error {
	fs.ChmodCallCount++
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	// check early to avoid requiring file presence
	if fs.ChmodErr != nil {
		return fs.ChmodErr
	}

	stats := fs.fileRegistry.Get(path)
	if stats == nil {
		return fmt.Errorf("Path does not exist: %s", path)
	}

	stats.FileMode = perm
	return nil
}

func (fs *FakeFileSystem) WriteFileString(path, content string) error {
	return fs.WriteFile(path, []byte(content))
}

func (fs *FakeFileSystem) WriteFileQuietly(path string, content []byte) error {
	fs.WriteFileQuietlyCallCount++
	return fs.writeFile(path, content)
}

func (fs *FakeFileSystem) WriteFile(path string, content []byte) error {
	fs.WriteFileCallCount++
	return fs.writeFile(path, content)
}

func (fs *FakeFileSystem) writeFile(path string, content []byte) error {
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	err := fs.WriteFileError
	if err != nil {
		return err
	}

	err = fs.WriteFileErrors[path]
	if err != nil {
		return err
	}

	path = fs.fileRegistry.UnifiedPath(path)
	parent := gopath.Dir(path)
	if parent != "." {
		fs.writeDir(parent) //nolint:errcheck
	}

	stats := fs.getOrCreateFile(path)
	stats.FileType = FakeFileTypeFile
	stats.Content = content
	return nil
}

func (fs *FakeFileSystem) writeDir(path string) error {
	parent := gopath.Dir(path)

	grandparent := gopath.Dir(parent)
	if grandparent != parent {
		fs.writeDir(parent) //nolint:errcheck
	}

	stats := fs.getOrCreateFile(path)
	stats.FileType = FakeFileTypeDir
	return nil
}

func (fs *FakeFileSystem) ConvergeFileContents(path string, content []byte, opts ...boshsys.ConvergeFileContentsOpts) (bool, error) {
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	if fs.WriteFileError != nil {
		return false, fs.WriteFileError
	}

	err := fs.WriteFileErrors[path]
	if err != nil {
		return false, err
	}

	if len(opts) > 0 && opts[0].DryRun {
		stats := fs.fileRegistry.Get(path)
		if stats == nil {
			return true, nil
		}
		return bytes.Compare(stats.Content, content) != 0, nil //nolint:gosimple
	}

	stats := fs.getOrCreateFile(path)
	stats.FileType = FakeFileTypeFile

	if bytes.Compare(stats.Content, content) != 0 { //nolint:gosimple
		stats.Content = content
		return true, nil
	}

	return false, nil
}

func (fs *FakeFileSystem) ReadFileString(path string) (string, error) {
	b, err := fs.ReadFile(path)
	if err != nil {
		return "", err
	}

	return string(b), nil
}

func (fs *FakeFileSystem) RegisterReadFileError(path string, err error) {
	if _, ok := fs.readFileErrorByPath[path]; ok {
		panic(fmt.Sprintf("ReadFile error is already set for path: %s", path))
	}
	fs.readFileErrorByPath[path] = err
}

func (fs *FakeFileSystem) UnregisterReadFileError(path string) {
	delete(fs.readFileErrorByPath, path)
}

func (fs *FakeFileSystem) ReadFileWithOpts(path string, opts boshsys.ReadOpts) ([]byte, error) {
	fs.ReadFileWithOptsCallCount++
	return fs.ReadFile(path)
}

func (fs *FakeFileSystem) ReadFile(path string) ([]byte, error) {
	stats := fs.GetFileTestStat(path)
	if stats != nil {
		if fs.ReadFileError != nil {
			return nil, fs.ReadFileError
		}

		if fs.readFileErrorByPath[path] != nil {
			return nil, fs.readFileErrorByPath[path]
		}

		return stats.Content, nil
	}

	return nil, bosherr.ComplexError{
		Err: bosherr.Error("Not found"),
		Cause: &os.PathError{
			Op:   "open",
			Path: path,
			Err:  syscall.ENOENT,
		},
	}
}

func (fs *FakeFileSystem) FileExists(path string) bool {
	return fs.GetFileTestStat(path) != nil
}

func (fs *FakeFileSystem) Rename(oldPath, newPath string) error {
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	if fs.RenameStub != nil {
		err := fs.RenameStub(oldPath, newPath)
		if err != nil {
			return err
		}
	}

	if fs.RenameError != nil {
		return fs.RenameError
	}

	oldPath = fs.fileRegistry.UnifiedPath(oldPath)
	newPath = fs.fileRegistry.UnifiedPath(newPath)

	parentDir := gopath.Dir(newPath)
	if parentDir != "." && fs.fileRegistry.Get(parentDir) == nil {
		return errors.New("Parent directory does not exist")
	}

	stats := fs.fileRegistry.Get(oldPath)
	if stats == nil {
		return errors.New("Old path did not exist")
	}

	fs.RenameOldPaths = append(fs.RenameOldPaths, oldPath)
	fs.RenameNewPaths = append(fs.RenameNewPaths, newPath)

	for filePath, fileStats := range fs.fileRegistry.GetAll() {
		if filePath == oldPath {
			fs.fileRegistry.Register(newPath, fileStats)
		} else if strings.HasPrefix(filePath, fmt.Sprintf("%s/", oldPath)) {
			dstPath := gopath.Join(newPath, filePath[len(oldPath):])
			fs.fileRegistry.Register(dstPath, fileStats)
		}
	}

	// Ignore error from RemoveAll
	fs.removeAll(oldPath) //nolint:errcheck

	return nil
}

func (fs *FakeFileSystem) Symlink(oldPath, newPath string) (err error) {
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	if fs.SymlinkError == nil {
		stats := fs.getOrCreateFile(newPath)
		stats.FileMode |= os.ModeSymlink
		stats.FileType = FakeFileTypeSymlink
		stats.SymlinkTarget = fs.fileRegistry.UnifiedPath(oldPath)
		return
	}

	err = fs.SymlinkError
	return
}

func (fs *FakeFileSystem) ReadAndFollowLink(symlinkPath string) (string, error) {
	targetPath, err := fs.readAndFollowLink(symlinkPath)
	if err != nil {
		return targetPath, err
	}

	//Converts internal path formatting (which is UNIX/Linux based) to native OS file system path
	//This emulates the real behavior of how the real file system returns symlink
	if strings.HasPrefix(targetPath, "/") {
		absFilePath, err := filepath.Abs(targetPath)
		return absFilePath, err
	}

	return targetPath, err
}

func (fs *FakeFileSystem) readAndFollowLink(symlinkPath string) (string, error) {
	if fs.ReadAndFollowLinkError != nil {
		return "", fs.ReadAndFollowLinkError
	}

	if symlinkPath == "\\" {
		symlinkPath = "/"
	}

	if symlinkPath == "" ||
		symlinkPath == "/" ||
		symlinkPath == filepath.VolumeName(symlinkPath)+"\\" {
		return symlinkPath, nil
	}

	if symlinkPath == "." {
		return fs.fileRegistry.UnifiedPath("."), nil
	}

	symlinkPath = filepath.Join(symlinkPath)

	stat := fs.GetFileTestStat(symlinkPath)
	if stat == nil {
		return "", os.ErrNotExist
	}

	if stat.FileType != FakeFileTypeSymlink {
		dirPath, err := fs.readAndFollowLink(filepath.Dir(symlinkPath))
		if err != nil {
			return "", err
		}

		return gopath.Join(dirPath, filepath.Base(symlinkPath)), nil
	}

	if gopath.IsAbs(stat.SymlinkTarget) {
		return fs.readAndFollowLink(stat.SymlinkTarget)
	}

	dirPath, err := fs.readAndFollowLink(filepath.Dir(symlinkPath))
	if err != nil {
		return "", err
	}

	return fs.readAndFollowLink(gopath.Join(dirPath, stat.SymlinkTarget))
}

func (fs *FakeFileSystem) CopyFile(srcPath, dstPath string) error {
	fs.CopyFileCallCount++
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	if fs.CopyFileError != nil {
		return fs.CopyFileError
	}

	srcFile := fs.fileRegistry.Get(srcPath)
	if srcFile == nil {
		return fmt.Errorf("%s doesn't exist", srcPath)
	}

	fs.fileRegistry.Register(dstPath, srcFile)
	return nil
}

func (fs *FakeFileSystem) CopyDir(srcPath, dstPath string) error {
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	if fs.CopyDirError != nil {
		return fs.CopyDirError
	}

	srcPath = fs.fileRegistry.UnifiedPath(srcPath)
	dstPath = fs.fileRegistry.UnifiedPath(dstPath)

	for filePath, fileStats := range fs.fileRegistry.GetAll() {
		if filePath == srcPath {
			fs.fileRegistry.Register(dstPath, fileStats)
		} else if strings.HasPrefix(filePath, fmt.Sprintf("%s/", srcPath)) {
			dstPath := gopath.Join(dstPath, filePath[len(srcPath):])
			fs.fileRegistry.Register(dstPath, fileStats)
		}
	}

	return nil
}

func (fs *FakeFileSystem) ChangeTempRoot(tempRootPath string) error {
	if fs.ChangeTempRootErr != nil {
		return fs.ChangeTempRootErr
	}
	fs.TempRootPath = tempRootPath
	return nil
}

func (fs *FakeFileSystem) EnableStrictTempRootBehavior() {
	fs.strictTempRoot = true
}

func (fs *FakeFileSystem) TempFile(prefix string) (file boshsys.File, err error) {
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	if fs.TempFileError != nil {
		return nil, fs.TempFileError
	}

	if fs.TempFileErrorsByPrefix[prefix] != nil {
		return nil, fs.TempFileErrorsByPrefix[prefix]
	}

	if fs.strictTempRoot && fs.TempRootPath == "" {
		return nil, errors.New("Temp file was requested without having set a temp root")
	}

	if fs.ReturnTempFilesByPrefix != nil {
		file = fs.ReturnTempFilesByPrefix[prefix]
	} else if fs.ReturnTempFile != nil {
		file = fs.ReturnTempFile
	} else if len(fs.ReturnTempFiles) != 0 {
		file = fs.ReturnTempFiles[0]
		fs.ReturnTempFiles = fs.ReturnTempFiles[1:]
	} else {
		file, err = os.Open(os.DevNull)
		if err != nil {
			err = bosherr.WrapError(err, fmt.Sprintf("Opening %s", os.DevNull))
			return
		}
	}

	// Make sure to record a reference for FileExist, etc. to work
	stats := fs.getOrCreateFile(file.Name())
	stats.FileType = FakeFileTypeFile
	return
}

func (fs *FakeFileSystem) TempDir(prefix string) (string, error) {
	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	if fs.TempDirError != nil {
		return "", fs.TempDirError
	}

	if fs.strictTempRoot && fs.TempRootPath == "" {
		return "", errors.New("Temp file was requested without having set a temp root")
	}

	var path string
	if len(fs.TempDirDir) > 0 {
		path = fs.TempDirDir
	} else if fs.TempDirDirs != nil {
		if len(fs.TempDirDirs) == 0 {
			return "", errors.New("Failed to create new temp dir: TempDirDirs is empty")
		}
		path = fs.TempDirDirs[0]
		fs.TempDirDirs = fs.TempDirDirs[1:]
	} else {
		uuid, err := gouuid.NewV4()
		if err != nil {
			return "", err
		}

		path = uuid.String()
	}

	// Make sure to record a reference for FileExist, etc. to work
	stats := fs.getOrCreateFile(path)
	stats.FileType = FakeFileTypeDir

	return path, nil
}

func (fs *FakeFileSystem) RemoveAll(path string) error {
	if path == "" {
		panic("RemoveAll requires path")
	}

	if fs.RemoveAllStub != nil {
		err := fs.RemoveAllStub(path)
		if err != nil {
			return err
		}
	}

	fs.filesLock.Lock()
	defer fs.filesLock.Unlock()

	path = fs.fileRegistry.UnifiedPath(path)
	return fs.removeAll(path)
}

func (fs *FakeFileSystem) removeAll(path string) error {
	fileInfo := fs.fileRegistry.Get(path)
	if fileInfo != nil {
		fs.fileRegistry.Remove(path)
		if fileInfo.FileType != FakeFileTypeDir {
			return nil
		}
	}

	// path must be a dir
	path = path + "/"

	filesToRemove := []string{}
	for name := range fs.fileRegistry.GetAll() {
		if strings.HasPrefix(name, path) {
			filesToRemove = append(filesToRemove, name)
		}
	}
	for _, name := range filesToRemove {
		fs.fileRegistry.Remove(name)
	}

	return nil
}

func (fs *FakeFileSystem) Glob(pattern string) (matches []string, err error) {
	if fs.GlobStub != nil {
		matches, err = fs.GlobStub(pattern)
		if err != nil {
			return nil, err
		} else {
			return matches, nil
		}
	}

	remainingMatches, found := fs.globsMap[pattern]
	if found {
		matches = remainingMatches[0]
		if len(remainingMatches) > 1 {
			fs.globsMap[pattern] = remainingMatches[1:]
		}
	} else {
		matches = []string{}
	}
	if err, ok := fs.GlobErrs[pattern]; ok {
		return matches, err
	}
	return matches, fs.GlobErr
}

func (fs *FakeFileSystem) RecursiveGlob(pattern string) (matches []string, err error) {
	return fs.Glob(pattern)
}

func (fs *FakeFileSystem) Ls(root string) ([]string, error) {
	matches := []string{}
	err := fs.Walk(root, func(path string, _ os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if root != path {
			matches = append(matches, path)
		}
		return nil
	})
	if err != nil {
		return nil, err
	}

	return matches, nil
}

func (fs *FakeFileSystem) Walk(root string, walkFunc filepath.WalkFunc) error {
	if fs.WalkErr != nil {
		return walkFunc("", nil, fs.WalkErr)
	}

	var paths []string
	for path := range fs.fileRegistry.GetAll() {
		paths = append(paths, path)
	}
	sort.Strings(paths)
	pathPrefix := gopath.Join(root) + "/"
	for _, path := range paths {
		fileStats := fs.fileRegistry.Get(path)
		if gopath.Join(path) == gopath.Join(root) || strings.HasPrefix(path, pathPrefix) {
			fakeFile := NewFakeFile(path, fs)
			fakeFile.Stats = fileStats
			fileInfo, _ := fakeFile.Stat()
			err := walkFunc(path, fileInfo, nil)
			if err != nil {
				return err
			}
		}
	}

	return nil
}

func (fs *FakeFileSystem) SetGlob(pattern string, matches ...[]string) {
	fs.globsMap[pattern] = matches
}

func (fs *FakeFileSystem) getOrCreateFile(path string) *FakeFileStats {
	stats := fs.fileRegistry.Get(path)
	if stats == nil {
		stats = new(FakeFileStats)
		fs.fileRegistry.Register(path, stats)
	}
	return stats
}

type FakeFileStatsRegistry struct {
	files map[string]*FakeFileStats
}

func NewFakeFileStatsRegistry() *FakeFileStatsRegistry {
	return &FakeFileStatsRegistry{
		files: map[string]*FakeFileStats{},
	}
}

func (fsr *FakeFileStatsRegistry) Register(path string, stats *FakeFileStats) {
	fsr.files[fsr.UnifiedPath(path)] = stats
}

func (fsr *FakeFileStatsRegistry) Get(path string) *FakeFileStats {
	return fsr.files[fsr.UnifiedPath(path)]
}

func (fsr *FakeFileStatsRegistry) GetAll() map[string]*FakeFileStats {
	return fsr.files
}

func (fsr *FakeFileStatsRegistry) Remove(path string) {
	delete(fsr.files, fsr.UnifiedPath(path))
}

func (fsr *FakeFileStatsRegistry) UnifiedPath(path string) string {
	path = strings.TrimPrefix(path, filepath.VolumeName(path))
	return filepath.ToSlash(gopath.Join(path))
}

type FakeFileRegistry struct {
	files map[string]*FakeFile
}

func NewFakeFileRegistry() *FakeFileRegistry {
	return &FakeFileRegistry{
		files: map[string]*FakeFile{},
	}
}

func (ffr *FakeFileRegistry) Register(path string, file *FakeFile) {
	ffr.files[ffr.UnifiedPath(path)] = file
}

func (ffr *FakeFileRegistry) Get(path string) *FakeFile {
	return ffr.files[ffr.UnifiedPath(path)]
}

func (ffr *FakeFileRegistry) Remove(path string) {
	delete(ffr.files, ffr.UnifiedPath(path))
}

func (ffr *FakeFileRegistry) UnifiedPath(path string) string {
	path = strings.TrimPrefix(path, filepath.VolumeName(path))
	return filepath.ToSlash(gopath.Join(path))
}