lib9p

fs_test.go (7196B)

---

 package lib9p
 
 import (
 	"bytes"
 	"fmt"
 	"io"
 	"io/fs"
 	"path"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 
 	"git.mtkn.jp/lib9p/testdata"
 )
 
 // SetupConn sets up a conn struct to serve fs.
 // rc is the channel from which reply *requests are derived.
 func setupConn(fs FS) (c *conn, rc chan *request) {
 	rc = make(chan *request)
 	c = &conn{
 		s:         NewServer(fs),
 		msize:     1024,
 		mSizeLock: new(sync.Mutex),
 		fPool:     newFidPool(),
 		respChan:  rc,
 	}
 	return
 }
 
 type testFile struct {
 	// fsys is the testFS this testFile belongs to.
 	fsys *testFS
 	// parent is the parent directory this testFile located at.
 	parent *testFile
 	// children is the child files this testFile has.
 	// It is nil if this testFile is not a directory
 	children []*testFile
 	// content is the content of this testFile.
 	// It is nil if this testFile is a directory
 	content []byte
 	// r is used if this testFile is not a directory and
 	// when this testFile is read.
 	// It contains content.
 	r      *bytes.Reader
 	offset int64
 	// stat is the Stat of this testFile.
 	stat Stat
 }
 
 func (f *testFile) Stat() (*FileInfo, error) {
 	return &FileInfo{Stat: f.stat}, nil
 }
 
 func (f *testFile) Close() error {
 	f.r = nil
 	f.offset = 0
 	return nil
 }
 
 func (f *testFile) Read(b []byte) (int, error) {
 	if f.fsys.slow {
 		f.fsys.waitc <- struct{}{}
 		<-f.fsys.waitc
 	}
 	if f.r == nil {
 		f.r = bytes.NewReader(f.content)
 	}
 	n, err := f.r.ReadAt(b, f.offset)
 	f.offset += int64(n)
 	return n, err
 }
 
 func (f *testFile) ReadAt(b []byte, off int64) (n int, err error) {
 	if f.fsys.slow {
 		f.fsys.waitc <- struct{}{}
 		<-f.fsys.waitc
 	}
 	// ReadAt shoul not affect nor be affected by the underlying seek offset.
 	return f.r.ReadAt(b, off)
 }
 
 func (f *testFile) ReadDir(n int) ([]fs.DirEntry, error) {
 	de := make([]fs.DirEntry, len(f.children))
 	for i, c := range f.children {
 		info, _ := c.Stat()
 		de[i] = info
 	}
 	return de, nil
 }
 
 func (f *testFile) WriteAt(p []byte, off int64) (int, error) {
 	if f.fsys.slow {
 		f.fsys.waitc <- struct{}{}
 	}
 	if off < 0 || off > int64(len(f.content)) {
 		return 0, fmt.Errorf("bad offset")
 	}
 	if off+int64(len(p)) > int64(len(f.content)) {
 		newcon := make([]byte, off+int64(len(p)))
 		copy(newcon, f.content)
 		f.content = newcon
 	}
 	copy(f.content[off:], p)
 	if f.r != nil {
 		f.r.Reset(f.content)
 		f.r.Seek(f.offset, io.SeekStart)
 	}
 	if f.fsys.slow {
 		<-f.fsys.waitc
 	}
 	return len(p), nil
 }
 
 // permission check is intentionally skipped.
 func (f *testFile) WStat(stat *Stat) error {
 	f.stat = *stat
 	return nil
 }
 
 type testFS struct {
 	// root is the root testFile of this file system.
 	root *testFile
 	// If slow is true, each function on files of this testFS waits for
 	// something arrives on waitc.
 	slow    bool
 	nextQid uint64
 	// waitc is used to wait some timing to emulate slow response.
 	waitc chan struct{}
 	// groups holds the information of groups and it leader and members.
 	groups map[string]group
 }
 
 type group struct {
 	leader  string
 	members map[string]bool
 }
 
 func (fs *testFS) OpenFile(path string, flag int) (File, error) {
 	wnames := strings.Split(path, "/")
 	f, err := fs.walk(wnames)
 	if err != nil {
 		return nil, fmt.Errorf("walk: %v", err)
 	}
 	f.r = bytes.NewReader(f.content)
 	return f, nil
 }
 
 func (fs *testFS) IsGroupLeader(gid, uid string) bool {
 	g, ok := fs.groups[gid]
 	if !ok {
 		return false
 	}
 	return g.leader == uid
 }
 
 func (fs *testFS) IsGroupMember(gid, uid string) bool {
 	g, ok := fs.groups[gid]
 	if !ok {
 		return false
 	}
 	return g.members[uid]
 }
 
 // Permission check is intentionally skipped.
 func (fs *testFS) Create(name string, uid string, mode OpenMode, perm FileMode) (File, error) {
 	dirname, filename := path.Split(name)
 	if dirname == "" && (filename == "." || filename == "") {
 		return nil, fmt.Errorf("cant create root")
 	}
 	dir, err := fs.walkPath(path.Dir(dirname))
 	if err != nil {
 		return nil, fmt.Errorf("not found")
 	}
 	for _, c := range dir.children {
 		if c.stat.Name == filename {
 			return nil, fmt.Errorf("file already exists")
 		}
 	}
 	f := &testFile{
 		fsys:   fs,
 		parent: dir,
 		stat: Stat{
 			Qid: Qid{
 				Type: FSModeToQidType(perm),
 				Path: fs.nextQid,
 			},
 			Mode:  perm,
 			Atime: uint32(time.Now().Unix()),
 			Mtime: uint32(time.Now().Unix()),
 			Name:  filename,
 			Uid:   uid,
 			Gid:   dir.stat.Gid,
 			Muid:  uid,
 		},
 	}
 	fs.nextQid++
 	dir.children = append(dir.children, f)
 	return f, nil
 }
 
 func (fs *testFS) Remove(name string) error {
 	ds, filename := path.Split(name)
 	dirname := path.Dir(ds)
 	dir, err := fs.walkPath(dirname)
 	if err != nil {
 		return fmt.Errorf("not found")
 	}
 	for i, c := range dir.children {
 		if c.stat.Name == filename {
 			if len(c.children) != 0 {
 				return fmt.Errorf("directory not empty")
 			}
 			dir.children = append(dir.children[:i], dir.children[i+1:]...)
 			// TODO: should close the file?
 			return nil
 		}
 	}
 	return fmt.Errorf("not found")
 }
 
 func (fs *testFS) walk(wnames []string) (*testFile, error) {
 	if len(wnames) == 1 && (wnames[0] == "." || wnames[0] == "") {
 		return fs.root, nil
 	}
 	cwd := fs.root
 L:
 	for i, name := range wnames {
 		for _, child := range cwd.children {
 			if child.stat.Name == name {
 				cwd = child
 				continue L
 			}
 		}
 		return nil, fmt.Errorf("%s not found", strings.Join(wnames[:i+1], "/"))
 	}
 	return cwd, nil
 }
 
 func (fs *testFS) walkPath(pathname string) (*testFile, error) {
 	wnames := strings.Split(pathname, "/")
 	return fs.walk(wnames)
 }
 
 var testfs *testFS
 
 func init() {
 	fileTree := testdata.FileTree
 	testfs = new(testFS)
 	for i, f := range fileTree {
 		var ff *testFile
 		if i == 0 { // root of the testfs
 			testfs.root = new(testFile)
 			ff = testfs.root
 			ff.parent = testfs.root
 		} else {
 			d, err := testfs.walkPath(path.Dir(f.Path))
 			if err != nil {
 				panic(err)
 			}
 			ff = new(testFile)
 			d.children = append(d.children, ff)
 			ff.parent = d
 		}
 		ff.content = []byte(f.Content)
 		var qt QidType
 		if f.Mode&fs.ModeDir != 0 {
 			qt = QTDIR
 		} else {
 			qt = QTFILE
 		}
 		ff.stat = Stat{
 			Qid:  Qid{Path: uint64(i), Type: qt},
 			Mode: f.Mode,
 			Name: path.Base(f.Path),
 			Uid:  f.Uid,
 			Gid:  f.Gid,
 			Muid: f.Muid,
 		}
 		ff.fsys = testfs
 		testfs.nextQid++
 	}
 	testfs.waitc = make(chan struct{})
 	testfs.groups = make(map[string]group)
 	for _, g := range testdata.Groups {
 		testfs.groups[g.Name] = group{
 			leader:  g.Leader,
 			members: make(map[string]bool),
 		}
 		for _, u := range g.Members {
 			testfs.groups[g.Name].members[u] = true
 		}
 	}
 }
 
 // This function does the actual work for TestWalk().
 func testWalk(t *testing.T, fs *testFS, pathname string, file *testFile) {
 	t.Logf("walk %s", pathname)
 	f, err := fs.walk(strings.Split(pathname, "/"))
 	if err != nil {
 		t.Errorf("open %s: %v", pathname, err)
 	}
 	if f != file {
 		t.Errorf("open %s: wrong file", pathname)
 	}
 	for _, child := range file.children {
 		childpath := path.Join(pathname, child.stat.Name)
 		testWalk(t, fs, childpath, child)
 	}
 }
 
 // TestWalk walk through testFS in depth-first fassion,
 // checks if all files can be opened without error and if
 // the opened file is the same as the file accessed via testFS.child
 func TestWalk(t *testing.T) {
 	testWalk(t, testfs, ".", testfs.root)
 }