func (t *ImplicitDirsTest) Rmdir_Empty() {
var err error
var entries []os.FileInfo
// Create two levels of directories. We can't make an empty implicit dir, so
// there must be a backing object for each.
AssertEq(
nil,
t.createObjects(
map[string]string{
"foo/": "",
"foo/bar/": "",
}))
// Remove the leaf.
err = os.Remove(path.Join(t.Dir, "foo/bar"))
AssertEq(nil, err)
// There should be nothing left in the parent.
entries, err = fusetesting.ReadDirPicky(path.Join(t.Dir, "foo"))
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
// Remove the parent.
err = os.Remove(path.Join(t.Dir, "foo"))
AssertEq(nil, err)
// Now the root directory should be empty, too.
entries, err = fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
}
func (t *MemFSTest) Rmdir_Empty() {
var err error
var entries []os.FileInfo
// Create two levels of directories.
err = os.MkdirAll(path.Join(t.Dir, "foo/bar"), 0754)
AssertEq(nil, err)
// Remove the leaf.
rmTime := time.Now()
err = os.Remove(path.Join(t.Dir, "foo/bar"))
AssertEq(nil, err)
// There should be nothing left in the parent.
entries, err = fusetesting.ReadDirPicky(path.Join(t.Dir, "foo"))
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
// Check the parent's mtime.
fi, err := os.Stat(path.Join(t.Dir, "foo"))
AssertEq(nil, err)
ExpectThat(fi, fusetesting.MtimeIsWithin(rmTime, timeSlop))
// Remove the parent.
err = os.Remove(path.Join(t.Dir, "foo"))
AssertEq(nil, err)
// Now the root directory should be empty, too.
entries, err = fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
}
func (t *MemFSTest) RenameAcrossDirs_Directory() {
var err error
// Create two parent directories.
oldParentPath := path.Join(t.Dir, "old")
newParentPath := path.Join(t.Dir, "new")
err = os.Mkdir(oldParentPath, 0700)
AssertEq(nil, err)
err = os.Mkdir(newParentPath, 0700)
AssertEq(nil, err)
// And a non-empty directory within the first.
oldPath := path.Join(oldParentPath, "foo")
err = os.MkdirAll(path.Join(oldPath, "child"), 0700)
AssertEq(nil, err)
// Rename it.
newPath := path.Join(newParentPath, "bar")
err = os.Rename(oldPath, newPath)
AssertEq(nil, err)
// The old name shouldn't work.
_, err = os.Stat(oldPath)
ExpectTrue(os.IsNotExist(err), "err: %v", err)
// The new name should.
fi, err := os.Stat(newPath)
AssertEq(nil, err)
ExpectEq(os.FileMode(0700)|os.ModeDir, fi.Mode())
// And the child should still be present.
entries, err := fusetesting.ReadDirPicky(newPath)
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq("child", fi.Name())
ExpectEq(os.FileMode(0700)|os.ModeDir, fi.Mode())
// Check the old parent.
entries, err = fusetesting.ReadDirPicky(oldParentPath)
AssertEq(nil, err)
AssertEq(0, len(entries))
// And the new one.
entries, err = fusetesting.ReadDirPicky(newParentPath)
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq(path.Base(newPath), fi.Name())
ExpectEq(os.FileMode(0700)|os.ModeDir, fi.Mode())
}
func (t *MemFSTest) RenameAcrossDirs_File() {
var err error
// Create two parent directories.
oldParentPath := path.Join(t.Dir, "old")
newParentPath := path.Join(t.Dir, "new")
err = os.Mkdir(oldParentPath, 0700)
AssertEq(nil, err)
err = os.Mkdir(newParentPath, 0700)
AssertEq(nil, err)
// And a file within the first.
oldPath := path.Join(oldParentPath, "foo")
err = ioutil.WriteFile(oldPath, []byte("taco"), 0400)
AssertEq(nil, err)
// Rename it.
newPath := path.Join(newParentPath, "bar")
err = os.Rename(oldPath, newPath)
AssertEq(nil, err)
// The old name shouldn't work.
_, err = os.Stat(oldPath)
ExpectTrue(os.IsNotExist(err), "err: %v", err)
_, err = ioutil.ReadFile(oldPath)
ExpectTrue(os.IsNotExist(err), "err: %v", err)
// The new name should.
fi, err := os.Stat(newPath)
AssertEq(nil, err)
ExpectEq(len("taco"), fi.Size())
ExpectEq(os.FileMode(0400), fi.Mode())
contents, err := ioutil.ReadFile(newPath)
AssertEq(nil, err)
ExpectEq("taco", string(contents))
// Check the old parent.
entries, err := fusetesting.ReadDirPicky(oldParentPath)
AssertEq(nil, err)
AssertEq(0, len(entries))
// And the new one.
entries, err = fusetesting.ReadDirPicky(newParentPath)
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq(path.Base(newPath), fi.Name())
ExpectEq(os.FileMode(0400), fi.Mode())
}
func (t *MemFSTest) Mkdir_TwoLevels() {
var err error
var fi os.FileInfo
var stat *syscall.Stat_t
var entries []os.FileInfo
// Create a directory within the root.
err = os.Mkdir(path.Join(t.Dir, "parent"), 0700)
AssertEq(nil, err)
// Create a child of that directory.
createTime := time.Now()
err = os.Mkdir(path.Join(t.Dir, "parent/dir"), 0754)
AssertEq(nil, err)
// Stat the directory.
fi, err = os.Stat(path.Join(t.Dir, "parent/dir"))
stat = fi.Sys().(*syscall.Stat_t)
AssertEq(nil, err)
ExpectEq("dir", fi.Name())
ExpectEq(0, fi.Size())
ExpectEq(os.ModeDir|applyUmask(0754), fi.Mode())
ExpectThat(fi, fusetesting.MtimeIsWithin(createTime, timeSlop))
ExpectThat(fi, fusetesting.BirthtimeIsWithin(createTime, timeSlop))
ExpectTrue(fi.IsDir())
ExpectNe(0, stat.Ino)
ExpectEq(1, stat.Nlink)
ExpectEq(currentUid(), stat.Uid)
ExpectEq(currentGid(), stat.Gid)
ExpectEq(0, stat.Size)
// Check the parent's mtime.
fi, err = os.Stat(path.Join(t.Dir, "parent"))
AssertEq(nil, err)
ExpectThat(fi, fusetesting.MtimeIsWithin(createTime, timeSlop))
// Read the directory.
entries, err = fusetesting.ReadDirPicky(path.Join(t.Dir, "parent/dir"))
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
// Read the parent.
entries, err = fusetesting.ReadDirPicky(path.Join(t.Dir, "parent"))
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq("dir", fi.Name())
ExpectEq(os.ModeDir|applyUmask(0754), fi.Mode())
}
func (t *ForeignModsTest) ReadDir_EmptySubDirectory() {
// Set up an empty directory placeholder called 'bar'.
AssertEq(nil, t.createEmptyObjects([]string{"bar/"}))
// ReadDir
entries, err := fusetesting.ReadDirPicky(t.mfs.Dir())
AssertEq(nil, err)
AssertEq(1, len(entries))
entries, err = fusetesting.ReadDirPicky(path.Join(t.mfs.Dir(), "bar"))
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
}
func (t *ForeignModsTest) ReadDir_EmptyRoot() {
// ReadDir
entries, err := fusetesting.ReadDirPicky(t.mfs.Dir())
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
}
func (t *CachingTest) EmptyBucket() {
// ReadDir
entries, err := fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
}
func (t *ForeignModsTest) Inodes() {
// Set up two files and a directory placeholder.
AssertEq(
nil,
t.createEmptyObjects([]string{
"foo",
"bar/",
"baz",
}))
// List.
entries, err := fusetesting.ReadDirPicky(t.mfs.Dir())
AssertEq(nil, err)
AssertEq(3, len(entries), "Names: %v", getFileNames(entries))
// Confirm all of the inodes are distinct.
inodesSeen := make(map[uint64]struct{})
for _, fileInfo := range entries {
stat := fileInfo.Sys().(*syscall.Stat_t)
_, ok := inodesSeen[stat.Ino]
AssertFalse(
ok,
"Duplicate inode (%v). File info: %v",
stat.Ino,
fileInfo)
inodesSeen[stat.Ino] = struct{}{}
}
}
func (t *MemFSTest) RenameOverExistingDirectory() {
var err error
// Create two directories, the first non-empty.
oldPath := path.Join(t.Dir, "foo")
err = os.MkdirAll(path.Join(oldPath, "child"), 0700)
AssertEq(nil, err)
newPath := path.Join(t.Dir, "bar")
err = os.Mkdir(newPath, 0600)
AssertEq(nil, err)
// Renaming over the non-empty directory shouldn't work.
err = os.Rename(newPath, oldPath)
ExpectThat(err, Error(MatchesRegexp("not empty|file exists")))
// As of Go 1.8 this shouldn't work the other way around either (see
// https://github.com/golang/go/commit/321c312).
if atLeastGo18 {
err = os.Rename(oldPath, newPath)
ExpectThat(err, Error(HasSubstr("file exists")))
// Both should still be present in the parent listing.
entries, err := fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
ExpectEq(2, len(entries))
}
}
func (t *MemFSTest) RenameOverExistingFile() {
var err error
// Create two files.
oldPath := path.Join(t.Dir, "foo")
err = ioutil.WriteFile(oldPath, []byte("taco"), 0400)
AssertEq(nil, err)
newPath := path.Join(t.Dir, "bar")
err = ioutil.WriteFile(newPath, []byte("burrito"), 0600)
AssertEq(nil, err)
// Rename one over the other.
err = os.Rename(oldPath, newPath)
AssertEq(nil, err)
// Check the file contents.
contents, err := ioutil.ReadFile(newPath)
AssertEq(nil, err)
ExpectEq("taco", string(contents))
// And the parent listing.
entries, err := fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
AssertEq(1, len(entries))
fi := entries[0]
ExpectEq(path.Base(newPath), fi.Name())
ExpectEq(os.FileMode(0400), fi.Mode())
ExpectEq(len("taco"), fi.Size())
}
func (t *MemFSTest) RenameWithinDir_SameName() {
var err error
// Create a parent directory.
parentPath := path.Join(t.Dir, "parent")
err = os.Mkdir(parentPath, 0700)
AssertEq(nil, err)
// And a file within it.
filePath := path.Join(parentPath, "foo")
err = ioutil.WriteFile(filePath, []byte("taco"), 0400)
AssertEq(nil, err)
// Attempt to rename it.
err = os.Rename(filePath, filePath)
AssertEq(nil, err)
// The file should still exist.
contents, err := ioutil.ReadFile(filePath)
AssertEq(nil, err)
ExpectEq("taco", string(contents))
// There should only be the one entry in the directory.
entries, err := fusetesting.ReadDirPicky(parentPath)
AssertEq(nil, err)
AssertEq(1, len(entries))
fi := entries[0]
ExpectEq(path.Base(filePath), fi.Name())
ExpectEq(os.FileMode(0400), fi.Mode())
}
func (t *GcsfuseTest) OnlyDir_WithImplicitDir() {
var err error
var fi os.FileInfo
// Mount only a single implicit directory from the bucket.
args := []string{
"--only-dir",
path.Dir(canned.ImplicitDirFile),
canned.FakeBucketName,
t.dir,
}
err = t.runGcsfuse(args)
AssertEq(nil, err)
defer unmount(t.dir)
// It should be as if t.dir points into the implicit directory
entries, err := fusetesting.ReadDirPicky(t.dir)
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq(path.Base(canned.ImplicitDirFile), fi.Name())
ExpectEq(len(canned.ImplicitDirFile_Contents), fi.Size())
}
func (t *MemFSTest) CreateSymlink() {
var fi os.FileInfo
var err error
symlinkName := path.Join(t.Dir, "foo")
target := "taco/burrito"
// Create the link.
err = os.Symlink(target, symlinkName)
AssertEq(nil, err)
// Stat the link.
fi, err = os.Lstat(symlinkName)
AssertEq(nil, err)
ExpectEq("foo", fi.Name())
ExpectEq(0444|os.ModeSymlink, fi.Mode())
// Read the link.
actual, err := os.Readlink(symlinkName)
AssertEq(nil, err)
ExpectEq(target, actual)
// Read the parent directory.
entries, err := fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq("foo", fi.Name())
ExpectEq(0444|os.ModeSymlink, fi.Mode())
}
func (t *ForeignModsTest) ReadBeyondEndOfFile() {
const contents = "tacoburritoenchilada"
const contentLen = len(contents)
// Create an object.
AssertEq(nil, t.createWithContents("foo", contents))
// Wait for it to show up in the file system.
_, err := fusetesting.ReadDirPicky(t.mfs.Dir())
AssertEq(nil, err)
// Attempt to open it.
f, err := os.Open(path.Join(t.mfs.Dir(), "foo"))
AssertEq(nil, err)
defer func() { AssertEq(nil, f.Close()) }()
// Attempt to read beyond the end of the file.
_, err = f.Seek(int64(contentLen-1), 0)
AssertEq(nil, err)
buf := make([]byte, 2)
n, err := f.Read(buf)
AssertEq(1, n, "err: %v", err)
AssertEq(contents[contentLen-1], buf[0])
if err == nil {
n, err = f.Read(buf)
AssertEq(0, n)
}
}
func (t *GcsfuseTest) OnlyDir_TrailingSlash() {
var err error
var fi os.FileInfo
// Mount only a single directory from the bucket, including a trailing slash.
args := []string{
"--only-dir",
path.Dir(canned.ExplicitDirFile) + "/",
canned.FakeBucketName,
t.dir,
}
err = t.runGcsfuse(args)
AssertEq(nil, err)
defer unmount(t.dir)
// It should be as if t.dir points into the bucket's first-level directory.
entries, err := fusetesting.ReadDirPicky(t.dir)
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq(path.Base(canned.ExplicitDirFile), fi.Name())
ExpectEq(len(canned.ExplicitDirFile_Contents), fi.Size())
}
func (t *ImplicitDirsTest) DirectoryObjectPresent() {
var fi os.FileInfo
var entries []os.FileInfo
var err error
// Set up contents.
AssertEq(
nil,
t.createObjects(
map[string]string{
// Directory
"foo/": "",
}))
// Statting the name should return an entry for the directory.
fi, err = os.Stat(path.Join(t.mfs.Dir(), "foo"))
AssertEq(nil, err)
ExpectEq("foo", fi.Name())
ExpectTrue(fi.IsDir())
// ReadDir should show the directory.
entries, err = fusetesting.ReadDirPicky(t.mfs.Dir())
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq("foo", fi.Name())
ExpectTrue(fi.IsDir())
}
func (t *ImplicitDirsTest) NothingPresent() {
// ReadDir
entries, err := fusetesting.ReadDirPicky(t.mfs.Dir())
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
}
func (t *ForeignModsTest) ReadDir_ContentsInRoot() {
// Set up contents.
createTime := t.mtimeClock.Now()
AssertEq(
nil,
t.createObjects(
map[string]string{
// File
"foo": "taco",
// Directory
"bar/": "",
// File
"baz": "burrito",
}))
/////////////////////////
// ReadDir
/////////////////////////
entries, err := fusetesting.ReadDirPicky(t.mfs.Dir())
AssertEq(nil, err)
AssertEq(3, len(entries), "Names: %v", getFileNames(entries))
var e os.FileInfo
// bar
e = entries[0]
ExpectEq("bar", e.Name())
ExpectEq(0, e.Size())
ExpectEq(dirPerms|os.ModeDir, e.Mode())
ExpectTrue(e.IsDir())
ExpectEq(1, e.Sys().(*syscall.Stat_t).Nlink)
ExpectEq(currentUid(), e.Sys().(*syscall.Stat_t).Uid)
ExpectEq(currentGid(), e.Sys().(*syscall.Stat_t).Gid)
// baz
e = entries[1]
ExpectEq("baz", e.Name())
ExpectEq(len("burrito"), e.Size())
ExpectEq(filePerms, e.Mode())
ExpectThat(e, fusetesting.MtimeIsWithin(createTime, timeSlop))
ExpectFalse(e.IsDir())
ExpectEq(1, e.Sys().(*syscall.Stat_t).Nlink)
ExpectEq(currentUid(), e.Sys().(*syscall.Stat_t).Uid)
ExpectEq(currentGid(), e.Sys().(*syscall.Stat_t).Gid)
// foo
e = entries[2]
ExpectEq("foo", e.Name())
ExpectEq(len("taco"), e.Size())
ExpectEq(filePerms, e.Mode())
ExpectThat(e, fusetesting.MtimeIsWithin(createTime, timeSlop))
ExpectFalse(e.IsDir())
ExpectEq(1, e.Sys().(*syscall.Stat_t).Nlink)
ExpectEq(currentUid(), e.Sys().(*syscall.Stat_t).Uid)
ExpectEq(currentGid(), e.Sys().(*syscall.Stat_t).Gid)
}
func (t *ImplicitDirsTest) ConflictingNames_OneIsSymlink() {
var fi os.FileInfo
var entries []os.FileInfo
var err error
// Set up contents.
AssertEq(
nil,
t.createObjects(
map[string]string{
// Symlink
"foo": "",
// Directory
"foo/": "",
}))
// Cause "foo" to look like a symlink.
err = setSymlinkTarget(t.ctx, t.bucket, "foo", "")
AssertEq(nil, err)
// A listing of the parent should contain a directory named "foo" and a
// symlink named "foo\n".
entries, err = fusetesting.ReadDirPicky(t.mfs.Dir())
AssertEq(nil, err)
AssertEq(2, len(entries))
fi = entries[0]
ExpectEq("foo", fi.Name())
ExpectEq(0, fi.Size())
ExpectEq(dirPerms|os.ModeDir, fi.Mode())
ExpectTrue(fi.IsDir())
ExpectEq(1, fi.Sys().(*syscall.Stat_t).Nlink)
fi = entries[1]
ExpectEq("foo\n", fi.Name())
ExpectEq(0, fi.Size())
ExpectEq(filePerms|os.ModeSymlink, fi.Mode())
ExpectFalse(fi.IsDir())
ExpectEq(1, fi.Sys().(*syscall.Stat_t).Nlink)
// Statting "foo" should yield the directory.
fi, err = os.Lstat(path.Join(t.mfs.Dir(), "foo"))
AssertEq(nil, err)
ExpectEq("foo", fi.Name())
ExpectTrue(fi.IsDir())
// Statting "foo\n" should yield the symlink.
fi, err = os.Lstat(path.Join(t.mfs.Dir(), "foo\n"))
AssertEq(nil, err)
ExpectEq("foo\n", fi.Name())
ExpectEq(filePerms|os.ModeSymlink, fi.Mode())
}
func (t *ImplicitDirsTest) ConflictingNames_PlaceholderNotPresent() {
var fi os.FileInfo
var entries []os.FileInfo
var err error
// Set up contents.
AssertEq(
nil,
t.createObjects(
map[string]string{
// File
"foo": "taco",
// Implicit directory
"foo/bar": "",
}))
// A listing of the parent should contain a directory named "foo" and a
// file named "foo\n".
entries, err = fusetesting.ReadDirPicky(t.mfs.Dir())
AssertEq(nil, err)
AssertEq(2, len(entries))
fi = entries[0]
ExpectEq("foo", fi.Name())
ExpectEq(0, fi.Size())
ExpectEq(dirPerms|os.ModeDir, fi.Mode())
ExpectTrue(fi.IsDir())
fi = entries[1]
ExpectEq("foo\n", fi.Name())
ExpectEq(len("taco"), fi.Size())
ExpectEq(len("taco"), fi.Size())
ExpectEq(filePerms, fi.Mode())
ExpectFalse(fi.IsDir())
ExpectEq(1, fi.Sys().(*syscall.Stat_t).Nlink)
// Statting "foo" should yield the directory.
fi, err = os.Stat(path.Join(t.mfs.Dir(), "foo"))
AssertEq(nil, err)
ExpectEq("foo", fi.Name())
ExpectTrue(fi.IsDir())
// Statting "foo\n" should yield the file.
fi, err = os.Stat(path.Join(t.mfs.Dir(), "foo\n"))
AssertEq(nil, err)
ExpectEq("foo\n", fi.Name())
ExpectEq(len("taco"), fi.Size())
ExpectFalse(fi.IsDir())
}
func (t *HelloFSTest) ReadDir_Dir() {
entries, err := fusetesting.ReadDirPicky(path.Join(t.Dir, "dir"))
AssertEq(nil, err)
AssertEq(1, len(entries))
var fi os.FileInfo
// world
fi = entries[0]
ExpectEq("world", fi.Name())
ExpectEq(len("Hello, world!"), fi.Size())
ExpectEq(0444, fi.Mode())
ExpectEq(0, t.Clock.Now().Sub(fi.ModTime()), "ModTime: %v", fi.ModTime())
ExpectFalse(fi.IsDir())
}
func (t *ForeignModsTest) ReadFromFile_Large() {
const contentLen = 1 << 20
contents := randString(contentLen)
// Create an object.
AssertEq(nil, t.createWithContents("foo", contents))
// Wait for it to show up in the file system.
_, err := fusetesting.ReadDirPicky(t.mfs.Dir())
AssertEq(nil, err)
// Attempt to open it.
f, err := os.Open(path.Join(t.mfs.Dir(), "foo"))
AssertEq(nil, err)
defer func() { AssertEq(nil, f.Close()) }()
// Read its entire contents.
slice, err := ioutil.ReadAll(f)
AssertEq(nil, err)
if contents != string(slice) {
ExpectTrue(
false,
"Expected:\n%v\n\nActual:\n%v",
hex.Dump([]byte(contents)),
hex.Dump(slice))
}
// Read from parts of it.
referenceReader := strings.NewReader(contents)
for trial := 0; trial < 1000; trial++ {
offset := rand.Int63n(contentLen + 1)
size := rand.Intn(int(contentLen - offset))
expected, err := readRange(referenceReader, offset, size)
AssertEq(nil, err)
actual, err := readRange(f, offset, size)
AssertEq(nil, err)
if expected != actual {
AssertTrue(
expected == actual,
"Expected:\n%s\nActual:\n%s",
hex.Dump([]byte(expected)),
hex.Dump([]byte(actual)))
}
}
}
func (t *MemFSTest) RenameWithinDir_File() {
var err error
// Create a parent directory.
parentPath := path.Join(t.Dir, "parent")
err = os.Mkdir(parentPath, 0700)
AssertEq(nil, err)
// And a file within it.
oldPath := path.Join(parentPath, "foo")
err = ioutil.WriteFile(oldPath, []byte("taco"), 0400)
AssertEq(nil, err)
// Rename it.
newPath := path.Join(parentPath, "bar")
err = os.Rename(oldPath, newPath)
AssertEq(nil, err)
// The old name shouldn't work.
_, err = os.Stat(oldPath)
ExpectTrue(os.IsNotExist(err), "err: %v", err)
_, err = ioutil.ReadFile(oldPath)
ExpectTrue(os.IsNotExist(err), "err: %v", err)
// The new name should.
fi, err := os.Stat(newPath)
AssertEq(nil, err)
ExpectEq(len("taco"), fi.Size())
ExpectEq(os.FileMode(0400), fi.Mode())
contents, err := ioutil.ReadFile(newPath)
AssertEq(nil, err)
ExpectEq("taco", string(contents))
// There should only be the new entry in the directory.
entries, err := fusetesting.ReadDirPicky(parentPath)
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq(path.Base(newPath), fi.Name())
ExpectEq(os.FileMode(0400), fi.Mode())
}
func (t *ReadOnlyTest) ReadRoot() {
var fi os.FileInfo
// Read.
entries, err := fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
AssertEq(2, len(entries))
// bar
fi = entries[0]
ExpectEq("bar", fi.Name())
ExpectEq(os.FileMode(0777)|os.ModeDir, fi.Mode())
// foo
fi = entries[1]
ExpectEq("foo", fi.Name())
ExpectEq(os.FileMode(0777), fi.Mode())
}
func (t *CachingTest) FileCreatedRemotely() {
const name = "foo"
const contents = "taco"
var fi os.FileInfo
// Create an object in GCS.
_, err := gcsutil.CreateObject(
t.ctx,
t.uncachedBucket,
name,
contents)
AssertEq(nil, err)
// It should immediately show up in a listing.
entries, err := fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq(name, fi.Name())
ExpectEq(len(contents), fi.Size())
// And we should be able to stat it.
fi, err = os.Stat(path.Join(t.Dir, name))
AssertEq(nil, err)
ExpectEq(name, fi.Name())
ExpectEq(len(contents), fi.Size())
// And read it.
b, err := ioutil.ReadFile(path.Join(t.Dir, name))
AssertEq(nil, err)
ExpectEq(contents, string(b))
// And overwrite it, and read it back again.
err = ioutil.WriteFile(path.Join(t.Dir, name), []byte("burrito"), 0500)
AssertEq(nil, err)
b, err = ioutil.ReadFile(path.Join(t.Dir, name))
AssertEq(nil, err)
ExpectEq("burrito", string(b))
}
func (t *ForeignModsTest) UnreachableObjects() {
var fi os.FileInfo
var err error
// Set up objects that appear to be directory contents, but for which there
// is no directory placeholder object. We don't have implicit directories
// enabled, so these should be unreachable.
err = gcsutil.CreateEmptyObjects(
t.ctx,
t.bucket,
[]string{
// Implicit directory contents, conflicting file name.
"foo",
"foo/0",
"foo/1",
// Implicit directory contents, no conflicting file name.
"bar/0/",
})
AssertEq(nil, err)
// Only the conflicitng file name should show up in the root.
entries, err := fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq("foo", fi.Name())
ExpectEq(filePerms, fi.Mode())
ExpectEq(1, fi.Sys().(*syscall.Stat_t).Nlink)
// Statting the conflicting name should give the file.
fi, err = os.Stat(path.Join(t.mfs.Dir(), "foo"))
AssertEq(nil, err)
ExpectEq("foo", fi.Name())
ExpectEq(filePerms, fi.Mode())
ExpectEq(1, fi.Sys().(*syscall.Stat_t).Nlink)
// Statting the other name shouldn't work at all.
_, err = os.Stat(path.Join(t.mfs.Dir(), "bar"))
ExpectTrue(os.IsNotExist(err), "err: %v", err)
}
func (t *MemFSTest) UnlinkFile_StillOpen() {
fileName := path.Join(t.Dir, "foo")
// Create and open a file.
f, err := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE, 0600)
t.ToClose = append(t.ToClose, f)
AssertEq(nil, err)
// Write some data into it.
n, err := f.Write([]byte("taco"))
AssertEq(nil, err)
AssertEq(4, n)
// Unlink it.
err = os.Remove(fileName)
AssertEq(nil, err)
// The directory should no longer contain it.
entries, err := fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
// We should be able to stat the file. It should still show as having
// contents, but with no links.
fi, err := f.Stat()
AssertEq(nil, err)
ExpectEq(4, fi.Size())
ExpectEq(0, fi.Sys().(*syscall.Stat_t).Nlink)
// The contents should still be available.
buf := make([]byte, 1024)
n, err = f.ReadAt(buf, 0)
AssertEq(io.EOF, err)
AssertEq(4, n)
ExpectEq("taco", string(buf[:4]))
// Writing should still work, too.
n, err = f.Write([]byte("burrito"))
AssertEq(nil, err)
AssertEq(len("burrito"), n)
}
func (t *HelloFSTest) ReadDir_Root() {
entries, err := fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
AssertEq(2, len(entries))
var fi os.FileInfo
// dir
fi = entries[0]
ExpectEq("dir", fi.Name())
ExpectEq(0, fi.Size())
ExpectEq(os.ModeDir|0555, fi.Mode())
ExpectEq(0, t.Clock.Now().Sub(fi.ModTime()), "ModTime: %v", fi.ModTime())
ExpectTrue(fi.IsDir())
// hello
fi = entries[1]
ExpectEq("hello", fi.Name())
ExpectEq(len("Hello, world!"), fi.Size())
ExpectEq(0444, fi.Mode())
ExpectEq(0, t.Clock.Now().Sub(fi.ModTime()), "ModTime: %v", fi.ModTime())
ExpectFalse(fi.IsDir())
}
func (t *MemFSTest) UnlinkFile_Exists() {
var err error
// Write a file.
fileName := path.Join(t.Dir, "foo")
err = ioutil.WriteFile(fileName, []byte("Hello, world!"), 0600)
AssertEq(nil, err)
// Unlink it.
err = os.Remove(fileName)
AssertEq(nil, err)
// Statting it should fail.
_, err = os.Stat(fileName)
AssertNe(nil, err)
ExpectThat(err, Error(HasSubstr("no such file")))
// Nothing should be in the directory.
entries, err := fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
}