github.com/xhghs/rclone@v1.51.1-0.20200430155106-e186a28cced8/vfs/vfs_test.go (about)

     1  // Test suite for vfs
     2  
     3  package vfs
     4  
     5  import (
     6  	"context"
     7  	"io"
     8  	"os"
     9  	"testing"
    10  
    11  	"github.com/pkg/errors"
    12  	_ "github.com/rclone/rclone/backend/all" // import all the backends
    13  	"github.com/rclone/rclone/fs"
    14  	"github.com/rclone/rclone/fstest"
    15  	"github.com/stretchr/testify/assert"
    16  	"github.com/stretchr/testify/require"
    17  )
    18  
    19  // Some times used in the tests
    20  var (
    21  	t1 = fstest.Time("2001-02-03T04:05:06.499999999Z")
    22  	t2 = fstest.Time("2011-12-25T12:59:59.123456789Z")
    23  	t3 = fstest.Time("2011-12-30T12:59:59.000000000Z")
    24  )
    25  
    26  // TestMain drives the tests
    27  func TestMain(m *testing.M) {
    28  	fstest.TestMain(m)
    29  }
    30  
    31  // Check baseHandle performs as advertised
    32  func TestVFSbaseHandle(t *testing.T) {
    33  	fh := baseHandle{}
    34  
    35  	err := fh.Chdir()
    36  	assert.Equal(t, ENOSYS, err)
    37  
    38  	err = fh.Chmod(0)
    39  	assert.Equal(t, ENOSYS, err)
    40  
    41  	err = fh.Chown(0, 0)
    42  	assert.Equal(t, ENOSYS, err)
    43  
    44  	err = fh.Close()
    45  	assert.Equal(t, ENOSYS, err)
    46  
    47  	fd := fh.Fd()
    48  	assert.Equal(t, uintptr(0), fd)
    49  
    50  	name := fh.Name()
    51  	assert.Equal(t, "", name)
    52  
    53  	_, err = fh.Read(nil)
    54  	assert.Equal(t, ENOSYS, err)
    55  
    56  	_, err = fh.ReadAt(nil, 0)
    57  	assert.Equal(t, ENOSYS, err)
    58  
    59  	_, err = fh.Readdir(0)
    60  	assert.Equal(t, ENOSYS, err)
    61  
    62  	_, err = fh.Readdirnames(0)
    63  	assert.Equal(t, ENOSYS, err)
    64  
    65  	_, err = fh.Seek(0, io.SeekStart)
    66  	assert.Equal(t, ENOSYS, err)
    67  
    68  	_, err = fh.Stat()
    69  	assert.Equal(t, ENOSYS, err)
    70  
    71  	err = fh.Sync()
    72  	assert.Equal(t, nil, err)
    73  
    74  	err = fh.Truncate(0)
    75  	assert.Equal(t, ENOSYS, err)
    76  
    77  	_, err = fh.Write(nil)
    78  	assert.Equal(t, ENOSYS, err)
    79  
    80  	_, err = fh.WriteAt(nil, 0)
    81  	assert.Equal(t, ENOSYS, err)
    82  
    83  	_, err = fh.WriteString("")
    84  	assert.Equal(t, ENOSYS, err)
    85  
    86  	err = fh.Flush()
    87  	assert.Equal(t, ENOSYS, err)
    88  
    89  	err = fh.Release()
    90  	assert.Equal(t, ENOSYS, err)
    91  
    92  	node := fh.Node()
    93  	assert.Nil(t, node)
    94  }
    95  
    96  // TestNew sees if the New command works properly
    97  func TestVFSNew(t *testing.T) {
    98  	r := fstest.NewRun(t)
    99  	defer r.Finalise()
   100  
   101  	// Check making a VFS with nil options
   102  	vfs := New(r.Fremote, nil)
   103  	var defaultOpt = DefaultOpt
   104  	defaultOpt.DirPerms |= os.ModeDir
   105  	assert.Equal(t, vfs.Opt, defaultOpt)
   106  	assert.Equal(t, vfs.f, r.Fremote)
   107  
   108  	// Check the initialisation
   109  	var opt = DefaultOpt
   110  	opt.DirPerms = 0777
   111  	opt.FilePerms = 0666
   112  	opt.Umask = 0002
   113  	vfs = New(r.Fremote, &opt)
   114  	assert.Equal(t, os.FileMode(0775)|os.ModeDir, vfs.Opt.DirPerms)
   115  	assert.Equal(t, os.FileMode(0664), vfs.Opt.FilePerms)
   116  }
   117  
   118  // TestRoot checks root directory is present and correct
   119  func TestVFSRoot(t *testing.T) {
   120  	r := fstest.NewRun(t)
   121  	defer r.Finalise()
   122  	vfs := New(r.Fremote, nil)
   123  
   124  	root, err := vfs.Root()
   125  	require.NoError(t, err)
   126  	assert.Equal(t, vfs.root, root)
   127  	assert.True(t, root.IsDir())
   128  	assert.Equal(t, vfs.Opt.DirPerms.Perm(), root.Mode().Perm())
   129  }
   130  
   131  func TestVFSStat(t *testing.T) {
   132  	r := fstest.NewRun(t)
   133  	defer r.Finalise()
   134  	vfs := New(r.Fremote, nil)
   135  
   136  	file1 := r.WriteObject(context.Background(), "file1", "file1 contents", t1)
   137  	file2 := r.WriteObject(context.Background(), "dir/file2", "file2 contents", t2)
   138  	fstest.CheckItems(t, r.Fremote, file1, file2)
   139  
   140  	node, err := vfs.Stat("file1")
   141  	require.NoError(t, err)
   142  	assert.True(t, node.IsFile())
   143  	assert.Equal(t, "file1", node.Name())
   144  
   145  	node, err = vfs.Stat("dir")
   146  	require.NoError(t, err)
   147  	assert.True(t, node.IsDir())
   148  	assert.Equal(t, "dir", node.Name())
   149  
   150  	node, err = vfs.Stat("dir/file2")
   151  	require.NoError(t, err)
   152  	assert.True(t, node.IsFile())
   153  	assert.Equal(t, "file2", node.Name())
   154  
   155  	node, err = vfs.Stat("not found")
   156  	assert.Equal(t, os.ErrNotExist, err)
   157  
   158  	node, err = vfs.Stat("dir/not found")
   159  	assert.Equal(t, os.ErrNotExist, err)
   160  
   161  	node, err = vfs.Stat("not found/not found")
   162  	assert.Equal(t, os.ErrNotExist, err)
   163  
   164  	node, err = vfs.Stat("file1/under a file")
   165  	assert.Equal(t, os.ErrNotExist, err)
   166  }
   167  
   168  func TestVFSStatParent(t *testing.T) {
   169  	r := fstest.NewRun(t)
   170  	defer r.Finalise()
   171  	vfs := New(r.Fremote, nil)
   172  
   173  	file1 := r.WriteObject(context.Background(), "file1", "file1 contents", t1)
   174  	file2 := r.WriteObject(context.Background(), "dir/file2", "file2 contents", t2)
   175  	fstest.CheckItems(t, r.Fremote, file1, file2)
   176  
   177  	node, leaf, err := vfs.StatParent("file1")
   178  	require.NoError(t, err)
   179  	assert.True(t, node.IsDir())
   180  	assert.Equal(t, "/", node.Name())
   181  	assert.Equal(t, "file1", leaf)
   182  
   183  	node, leaf, err = vfs.StatParent("dir/file2")
   184  	require.NoError(t, err)
   185  	assert.True(t, node.IsDir())
   186  	assert.Equal(t, "dir", node.Name())
   187  	assert.Equal(t, "file2", leaf)
   188  
   189  	node, leaf, err = vfs.StatParent("not found")
   190  	require.NoError(t, err)
   191  	assert.True(t, node.IsDir())
   192  	assert.Equal(t, "/", node.Name())
   193  	assert.Equal(t, "not found", leaf)
   194  
   195  	_, _, err = vfs.StatParent("not found dir/not found")
   196  	assert.Equal(t, os.ErrNotExist, err)
   197  
   198  	_, _, err = vfs.StatParent("file1/under a file")
   199  	assert.Equal(t, os.ErrExist, err)
   200  }
   201  
   202  func TestVFSOpenFile(t *testing.T) {
   203  	r := fstest.NewRun(t)
   204  	defer r.Finalise()
   205  	vfs := New(r.Fremote, nil)
   206  
   207  	file1 := r.WriteObject(context.Background(), "file1", "file1 contents", t1)
   208  	file2 := r.WriteObject(context.Background(), "dir/file2", "file2 contents", t2)
   209  	fstest.CheckItems(t, r.Fremote, file1, file2)
   210  
   211  	fd, err := vfs.OpenFile("file1", os.O_RDONLY, 0777)
   212  	require.NoError(t, err)
   213  	assert.NotNil(t, fd)
   214  	require.NoError(t, fd.Close())
   215  
   216  	fd, err = vfs.OpenFile("dir", os.O_RDONLY, 0777)
   217  	require.NoError(t, err)
   218  	assert.NotNil(t, fd)
   219  	require.NoError(t, fd.Close())
   220  
   221  	fd, err = vfs.OpenFile("dir/new_file.txt", os.O_RDONLY, 0777)
   222  	assert.Equal(t, os.ErrNotExist, err)
   223  	assert.Nil(t, fd)
   224  
   225  	fd, err = vfs.OpenFile("dir/new_file.txt", os.O_WRONLY|os.O_CREATE, 0777)
   226  	require.NoError(t, err)
   227  	assert.NotNil(t, fd)
   228  	err = fd.Close()
   229  	if errors.Cause(err) != fs.ErrorCantUploadEmptyFiles {
   230  		require.NoError(t, err)
   231  	}
   232  
   233  	fd, err = vfs.OpenFile("not found/new_file.txt", os.O_WRONLY|os.O_CREATE, 0777)
   234  	assert.Equal(t, os.ErrNotExist, err)
   235  	assert.Nil(t, fd)
   236  }
   237  
   238  func TestVFSRename(t *testing.T) {
   239  	r := fstest.NewRun(t)
   240  	defer r.Finalise()
   241  	features := r.Fremote.Features()
   242  	if features.Move == nil && features.Copy == nil {
   243  		return // skip as can't rename files
   244  	}
   245  	vfs := New(r.Fremote, nil)
   246  
   247  	file1 := r.WriteObject(context.Background(), "dir/file2", "file2 contents", t2)
   248  	fstest.CheckItems(t, r.Fremote, file1)
   249  
   250  	err := vfs.Rename("dir/file2", "dir/file1")
   251  	require.NoError(t, err)
   252  	file1.Path = "dir/file1"
   253  	fstest.CheckItems(t, r.Fremote, file1)
   254  
   255  	err = vfs.Rename("dir/file1", "file0")
   256  	require.NoError(t, err)
   257  	file1.Path = "file0"
   258  	fstest.CheckItems(t, r.Fremote, file1)
   259  
   260  	err = vfs.Rename("not found/file0", "file0")
   261  	assert.Equal(t, os.ErrNotExist, err)
   262  
   263  	err = vfs.Rename("file0", "not found/file0")
   264  	assert.Equal(t, os.ErrNotExist, err)
   265  }
   266  
   267  func TestVFSStatfs(t *testing.T) {
   268  	r := fstest.NewRun(t)
   269  	defer r.Finalise()
   270  	vfs := New(r.Fremote, nil)
   271  
   272  	// pre-conditions
   273  	assert.Nil(t, vfs.usage)
   274  	assert.True(t, vfs.usageTime.IsZero())
   275  
   276  	aboutSupported := r.Fremote.Features().About != nil
   277  
   278  	// read
   279  	total, used, free := vfs.Statfs()
   280  	if !aboutSupported {
   281  		assert.Equal(t, int64(-1), total)
   282  		assert.Equal(t, int64(-1), free)
   283  		assert.Equal(t, int64(-1), used)
   284  		return // can't test anything else if About not supported
   285  	}
   286  	require.NotNil(t, vfs.usage)
   287  	assert.False(t, vfs.usageTime.IsZero())
   288  	if vfs.usage.Total != nil {
   289  		assert.Equal(t, *vfs.usage.Total, total)
   290  	} else {
   291  		assert.Equal(t, int64(-1), total)
   292  	}
   293  	if vfs.usage.Free != nil {
   294  		assert.Equal(t, *vfs.usage.Free, free)
   295  	} else {
   296  		assert.Equal(t, int64(-1), free)
   297  	}
   298  	if vfs.usage.Used != nil {
   299  		assert.Equal(t, *vfs.usage.Used, used)
   300  	} else {
   301  		assert.Equal(t, int64(-1), used)
   302  	}
   303  
   304  	// read cached
   305  	oldUsage := vfs.usage
   306  	oldTime := vfs.usageTime
   307  	total2, used2, free2 := vfs.Statfs()
   308  	assert.Equal(t, oldUsage, vfs.usage)
   309  	assert.Equal(t, total, total2)
   310  	assert.Equal(t, used, used2)
   311  	assert.Equal(t, free, free2)
   312  	assert.Equal(t, oldTime, vfs.usageTime)
   313  }