lib9p

file_test.go (7346B)

---

 package client
 
 import (
 	"bytes"
 	"context"
 	"fmt"
 	"io"
 	"io/fs"
 	"reflect"
 	"strings"
 	"testing"
 
 	"git.mtkn.jp/lib9p"
 )
 
 func TestFileInterface(t *testing.T) {
 	var _ lib9p.File = &File{}
 	var _ lib9p.WriterFile = &File{}
 	var _ lib9p.WriterStatFile = &File{}
 	var _ lib9p.ReadDirFile = &File{}
 }
 
 // Mount runs a server with fs and mounts it as *FS.
 func mount(ctx context.Context, fs lib9p.FS) (cfs *FS, err error) {
 	cr, sw := io.Pipe()
 	sr, cw := io.Pipe()
 	s := lib9p.NewServer(fs)
 	go s.Serve(ctx, sr, sw)
 	cfs, err = Mount(ctx, cr, cw, "glenda", "")
 	if err != nil {
 		return nil, fmt.Errorf("mount: %v", err)
 	}
 	return cfs, nil
 }
 
 // TestFileStat tests whether Stat returns the same lib9p.Stat as testfs defines.
 func TestFileStat(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	cfs, err := mount(ctx, testfs)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer cancel()
 	var walk = func(path string, d fs.DirEntry, err error) error {
 		cfi, err := fs.Stat(lib9p.ExportFS{FS: cfs}, path)
 		if err != nil {
 			if strings.Contains(err.Error(), "permission") {
 				return nil
 			}
 			t.Error(err)
 			return nil
 		}
 		tfi, err := fs.Stat(lib9p.ExportFS{FS: testfs}, path)
 		if err != nil {
 			t.Error(err)
 		}
 		if !reflect.DeepEqual(cfi, tfi) {
 			t.Errorf("fi not match:\n\twant: %v\n\tgot:  %v", tfi, cfi)
 		}
 		return nil
 	}
 	if err := fs.WalkDir(lib9p.ExportFS{FS: testfs}, ".", walk); err != nil {
 		t.Error(err)
 	}
 }
 
 // TODO: implement
 func TestFileWStat(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	cfs, err := mount(ctx, testfs)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer cancel()
 	_, _ = ctx, cfs
 }
 
 // TestClose checks it *File.Close calls are transmitted to the server and
 // *testFile.Close is called for each *File.Close.
 func TestClose(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	cfs, err := mount(ctx, testfs)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer cancel()
 	var walk = func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
 			if err == io.EOF {
 				return nil
 			}
 			return err
 		}
 		tf, err := testfs.walkPath(path)
 		if err != nil {
 			t.Error(err)
 			return nil
 		}
 		cf, err := cfs.OpenFile(path, lib9p.O_RDONLY)
 		if err != nil {
 			if strings.Contains(err.Error(), "permission") {
 				return nil
 			}
 			return err
 		}
 		cc := make(chan struct{})
 		tf.closec = cc
 		cf.Close()
 		<-cc
 		return nil
 	}
 	if err := fs.WalkDir(lib9p.ExportFS{FS: testfs}, ".", walk); err != nil {
 		t.Error(err)
 	}
 }
 
 // TestFileRead checks *File.Read reads the same []byte as *testFile.content.
 func TestFileRead(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	cfs, err := mount(ctx, testfs)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer cancel()
 	var walk = func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
 			if err == io.EOF {
 				return nil
 			}
 			return err
 		}
 		if d.IsDir() {
 			return nil
 		}
 		tf, err := testfs.walkPath(path)
 		if err != nil {
 			t.Error(err)
 			return nil
 		}
 		cf, err := cfs.OpenFile(path, lib9p.O_RDONLY)
 		if err != nil {
 			if strings.Contains(err.Error(), "permission") {
 				return nil
 			}
 			return err
 		}
 		defer cf.Close()
 		cb := make([]byte, len(tf.content)*2)
 		n, err := cf.Read(cb)
 		if err != nil {
 			t.Error(err)
 			return nil
 		}
 		if n != len(tf.content) || !bytes.Equal(cb[:n], tf.content) {
 			t.Errorf("read wrong content: want: %v, got: %v", tf.content, cb[:n])
 			return nil
 		}
 		return nil
 	}
 	if err := fs.WalkDir(lib9p.ExportFS{FS: testfs}, ".", walk); err != nil {
 		t.Error(err)
 	}
 }
 
 // TestFileWrite tests the Write method of the struct File.
 // It writes some bytes to a testFile using File.Write and checks if
 // the underlying content of testFile is changed correctly.
 func TestFileWrite(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	cfs, err := mount(ctx, testfs)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer cancel()
 	tf, err := testfs.walkPath("dir/file")
 	if err != nil {
 		t.Fatal(err)
 	}
 	orig := bytes.Clone(tf.content)
 	defer func() { tf.content = bytes.Clone(orig) }()
 	// consecutive writes to the same file without closing it.
 	ctnt0 := []byte("hogehoge")
 	ctnt1 := []byte("fugafuga")
 	cf, err := cfs.OpenFile("dir/file", lib9p.O_RDWR)
 	if err != nil {
 		t.Fatal(err)
 	}
 	_, err = cf.(lib9p.WriterFile).Write(ctnt0)
 	if err != nil {
 		t.Fatal(err)
 	}
 	_, err = cf.(lib9p.WriterFile).Write(ctnt1)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if !bytes.Equal(tf.content[:len(ctnt0)+len(ctnt1)], bytes.Join([][]byte{ctnt0, ctnt1}, nil)) {
 		t.Errorf("not written propperly: want: %v, got: %v",
 			string(bytes.Join([][]byte{ctnt0, ctnt1}, nil)),
 			string(tf.content[:len(ctnt0)+len(ctnt1)]))
 	}
 }
 
 func FuzzFileWrite(f *testing.F) {
 	for _, seed := range []string{"", "fuga", "fugafuga", "fugafugafuga"} {
 		f.Add([]byte(seed))
 	}
 	f.Add(make([]byte, 9000))
 	ctx, cancel := context.WithCancel(context.Background())
 	cfs, err := mount(ctx, testfs)
 	if err != nil {
 		f.Fatal(err)
 	}
 	defer cancel()
 	tf, err := testfs.walkPath("dir/file")
 	if err != nil {
 		f.Fatal(err)
 	}
 	orig := bytes.Clone(tf.content)
 	f.Fuzz(func(t *testing.T, in []byte) {
 		defer func() { tf.content = bytes.Clone(orig) }()
 		cf, err := cfs.OpenFile("dir/file", lib9p.O_RDWR)
 		if err != nil {
 			t.Fatal(err)
 		}
 		_, err = cf.(lib9p.WriterFile).Write(in)
 		if err != nil {
 			t.Fatal(err)
 		}
 		if !bytes.Equal(tf.content[:len(in)], in) {
 			t.Errorf("not written propperly: want: %v, got: %v",
 				string(in), string(tf.content[:len(in)]))
 		}
 		cf.Close()
 	})
 }
 
 // TestReadDir tests whether ReadDir returns the same dir entries as testfs
 // by comparing their *lib9p.Stat.
 func TestReadDir(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	cfs, err := mount(ctx, testfs)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer cancel()
 	var walk = func(path string, d fs.DirEntry, err error) error {
 		t.Log(path)
 		if err != nil {
 			return err
 		}
 		if !d.IsDir() {
 			return nil
 		}
 		cf, err := cfs.OpenFile(path, lib9p.O_RDONLY)
 		if err != nil {
 			if !strings.Contains(err.Error(), "permission") {
 				t.Error(err)
 			}
 			return nil
 		}
 		cde, err := cf.(lib9p.ReadDirFile).ReadDir(-1)
 		if err != nil {
 			if err != io.EOF {
 				t.Error(err)
 				return nil
 			}
 		}
 		tf, err := testfs.OpenFile(path, lib9p.O_RDONLY)
 		if err != nil {
 			if !strings.Contains(err.Error(), "permission") {
 				t.Error(err)
 			}
 			return nil
 		}
 		tde, err := tf.(lib9p.ReadDirFile).ReadDir(-1)
 		if err != nil {
 			if err != io.EOF {
 				t.Error(err)
 				return nil
 			}
 		}
 		if len(cde) != len(tde) {
 			t.Errorf("%s: length of direntry not match", path)
 			return nil
 		}
 		demap := make(map[string]*lib9p.Stat)
 		for _, cde0 := range cde {
 			info, err := cde0.Info()
 			if err != nil {
 				t.Error(err)
 				return nil
 			}
 			demap[cde0.Name()] = info.Sys().(*lib9p.Stat)
 		}
 		for _, tde0 := range tde {
 			info, err := tde0.Info()
 			if err != nil {
 				t.Error(err)
 				return nil
 			}
 			if !reflect.DeepEqual(demap[tde0.Name()], info.Sys().(*lib9p.Stat)) {
 				t.Errorf("%s: stat doesn't match:\n\twant: %v\n\tgot:  %v",
 					path, info.Sys().(*lib9p.Stat), demap[tde0.Name()])
 				return nil
 			}
 		}
 		return nil
 	}
 	if err := fs.WalkDir(lib9p.ExportFS{FS: testfs}, ".", walk); err != nil {
 		t.Error(err)
 	}
 }