github.com/hanwen/go-fuse@v1.0.0/fuse/nodefs/memnode_test.go (about)

     1  // Copyright 2016 the Go-FUSE Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package nodefs
     6  
     7  import (
     8  	"io/ioutil"
     9  	"os"
    10  	"testing"
    11  	"time"
    12  
    13  	"github.com/hanwen/go-fuse/fuse"
    14  	"github.com/hanwen/go-fuse/internal/testutil"
    15  )
    16  
    17  const testTtl = 100 * time.Millisecond
    18  
    19  func setupMemNodeTest(t *testing.T) (wd string, root Node, clean func()) {
    20  	tmp, err := ioutil.TempDir("", "go-fuse-memnode_test")
    21  	if err != nil {
    22  		t.Fatalf("TempDir failed: %v", err)
    23  	}
    24  	back := tmp + "/backing"
    25  	os.Mkdir(back, 0700)
    26  	root = NewMemNodeFSRoot(back)
    27  	mnt := tmp + "/mnt"
    28  	os.Mkdir(mnt, 0700)
    29  
    30  	connector := NewFileSystemConnector(root,
    31  		&Options{
    32  			EntryTimeout:        testTtl,
    33  			AttrTimeout:         testTtl,
    34  			NegativeTimeout:     0.0,
    35  			Debug:               testutil.VerboseTest(),
    36  			LookupKnownChildren: true,
    37  		})
    38  	state, err := fuse.NewServer(connector.RawFS(), mnt, &fuse.MountOptions{Debug: testutil.VerboseTest()})
    39  	if err != nil {
    40  		t.Fatal("NewServer", err)
    41  	}
    42  
    43  	// Unthreaded, but in background.
    44  	go state.Serve()
    45  
    46  	if err := state.WaitMount(); err != nil {
    47  		t.Fatal("WaitMount", err)
    48  	}
    49  	return mnt, root, func() {
    50  		state.Unmount()
    51  		os.RemoveAll(tmp)
    52  	}
    53  }
    54  
    55  func TestMemNodeFsWrite(t *testing.T) {
    56  	wd, _, clean := setupMemNodeTest(t)
    57  	defer clean()
    58  	want := "hello"
    59  
    60  	err := ioutil.WriteFile(wd+"/test", []byte(want), 0644)
    61  	if err != nil {
    62  		t.Fatalf("WriteFile failed: %v", err)
    63  	}
    64  
    65  	content, err := ioutil.ReadFile(wd + "/test")
    66  	if string(content) != want {
    67  		t.Fatalf("content mismatch: got %q, want %q", content, want)
    68  	}
    69  }
    70  
    71  func TestMemNodeFsBasic(t *testing.T) {
    72  	wd, _, clean := setupMemNodeTest(t)
    73  	defer clean()
    74  
    75  	err := ioutil.WriteFile(wd+"/test", []byte{42}, 0644)
    76  	if err != nil {
    77  		t.Fatalf("WriteFile failed: %v", err)
    78  	}
    79  
    80  	fi, err := os.Lstat(wd + "/test")
    81  	if err != nil {
    82  		t.Fatalf("Lstat failed: %v", err)
    83  	}
    84  	if fi.Size() != 1 {
    85  		t.Errorf("Size after write incorrect: got %d want 1", fi.Size())
    86  	}
    87  
    88  	entries, err := ioutil.ReadDir(wd)
    89  	if len(entries) != 1 || entries[0].Name() != "test" {
    90  		t.Fatalf("Readdir got %v, expected 1 file named 'test'", entries)
    91  	}
    92  }
    93  
    94  func TestMemNodeSetattr(t *testing.T) {
    95  	wd, _, clean := setupMemNodeTest(t)
    96  	defer clean()
    97  
    98  	f, err := os.OpenFile(wd+"/test", os.O_CREATE|os.O_WRONLY, 0644)
    99  	if err != nil {
   100  		t.Fatalf("OpenFile failed: %v", err)
   101  	}
   102  	defer f.Close()
   103  
   104  	err = f.Truncate(4096)
   105  	if err != nil {
   106  		t.Fatalf("Truncate failed: %v", err)
   107  	}
   108  
   109  	fi, err := f.Stat()
   110  	if err != nil {
   111  		t.Fatalf("Stat failed: %v", err)
   112  	}
   113  	if fi.Size() != 4096 {
   114  		t.Errorf("Size should be 4096 after Truncate: %d", fi.Size())
   115  	}
   116  
   117  	if err := f.Chown(21, 42); err != nil {
   118  		t.Errorf("Chown: %v", err)
   119  	}
   120  	if fi, err := f.Stat(); err != nil {
   121  		t.Fatalf("Stat failed: %v", err)
   122  	} else {
   123  		attr := fuse.ToStatT(fi)
   124  		if attr.Gid != 42 || attr.Uid != 21 {
   125  			t.Errorf("got (%d, %d), want 42,21", attr.Uid, attr.Gid)
   126  		}
   127  	}
   128  }