In-Memory implementation for http.FileSystem

fs_stub.go

// http.FileSystem in-memory test stub

type TestOpener interface {
	OpenAs(name string) http.File
}

type TestFileSystem TestDir

func (fs TestFileSystem) Open(name string) (http.File, error) {
	name = path.Clean(name)
	if len(name) > 0 && name[0] == '/' {
		name = name[1:]
	}
	dir := TestDir(fs)
	if name == "." {
		return dir.OpenAs("."), nil
	}
	for parts := strings.Split(name, "/"); len(parts) > 0; parts = parts[1:] {
		item, ok := dir[parts[0]]
		if !ok {
			return nil, os.ErrNotExist
		}

		if len(parts) == 1 {
			return item.OpenAs(parts[0]), nil
		}

		subdir, ok := item.(TestDir)
		if !ok {
			return nil, os.ErrNotExist
		}
		dir = subdir
	}
	panic("unreachable")
}

type TestDir map[string]TestOpener

func (d TestDir) OpenAs(name string) http.File {
	return testDirInstance{name: name, dir: d}
}

type testDirInstance struct {
	name string
	dir  TestDir
}

func (d testDirInstance) Read(p []byte) (n int, err error) {
	return 0, os.ErrInvalid
}

func (d testDirInstance) Readdir(count int) ([]os.FileInfo, error) {
	var dir []string
	for key := range d.dir {
		dir = append(dir, key)
	}
	sort.Strings(dir)
	if count < 0 {
		count = len(dir)
	} else if count > len(dir) {
		count = len(dir)
	}
	var fi []os.FileInfo
	for i := 0; i < count; i++ {
		name := dir[i]
		f, _ := d.dir[name].OpenAs(name).(os.FileInfo)
		fi = append(fi, f)
	}
	return fi, nil
}

func (d testDirInstance) Seek(offset int64, whence int) (int64, error) {
	return 0, os.ErrInvalid
}

func (d testDirInstance) Close() error               { return nil }
func (d testDirInstance) Stat() (os.FileInfo, error) { return d, nil }
func (d testDirInstance) Name() string               { return d.name }
func (d testDirInstance) Size() int64                { return 0 }
func (d testDirInstance) Mode() os.FileMode          { return os.ModeDir }
func (d testDirInstance) ModTime() time.Time         { return TestModTime }
func (d testDirInstance) IsDir() bool                { return true }
func (d testDirInstance) Sys() interface{}           { return nil }

type TestFile string

func (f TestFile) OpenAs(name string) http.File {
	return testFileInstance{name: name, size: int64(len(f)), Reader: bytes.NewReader([]byte(f))}
}

type testFileInstance struct {
	name string
	size int64
	*bytes.Reader
}

func (d testFileInstance) Readdir(count int) ([]os.FileInfo, error) {
	return nil, os.ErrInvalid
}

func (d testFileInstance) Close() error               { return nil }
func (d testFileInstance) Stat() (os.FileInfo, error) { return d, nil }
func (d testFileInstance) Name() string               { return d.name }
func (d testFileInstance) Size() int64                { return d.size }
func (d testFileInstance) Mode() os.FileMode          { return 0 }
func (d testFileInstance) ModTime() time.Time         { return TestModTime }
func (d testFileInstance) IsDir() bool                { return false }
func (d testFileInstance) Sys() interface{}           { return nil }

Or just use golang.org/x/tools/godoc/vfs/mapfs.