github.com/xhghs/rclone@v1.51.1-0.20200430155106-e186a28cced8/cmd/mountlib/mounttest/write.go (about)

     1  package mounttest
     2  
     3  import (
     4  	"os"
     5  	"runtime"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  
    11  	"github.com/rclone/rclone/vfs"
    12  )
    13  
    14  // TestWriteFileNoWrite tests writing a file with no write()'s to it
    15  func TestWriteFileNoWrite(t *testing.T) {
    16  	run.skipIfNoFUSE(t)
    17  
    18  	fd, err := osCreate(run.path("testnowrite"))
    19  	assert.NoError(t, err)
    20  
    21  	err = fd.Close()
    22  	assert.NoError(t, err)
    23  
    24  	run.waitForWriters()
    25  
    26  	run.checkDir(t, "testnowrite 0")
    27  
    28  	run.rm(t, "testnowrite")
    29  }
    30  
    31  // FIXMETestWriteOpenFileInDirListing tests open file in directory listing
    32  func FIXMETestWriteOpenFileInDirListing(t *testing.T) {
    33  	run.skipIfNoFUSE(t)
    34  
    35  	fd, err := osCreate(run.path("testnowrite"))
    36  	assert.NoError(t, err)
    37  
    38  	run.checkDir(t, "testnowrite 0")
    39  
    40  	err = fd.Close()
    41  	assert.NoError(t, err)
    42  
    43  	run.waitForWriters()
    44  
    45  	run.rm(t, "testnowrite")
    46  }
    47  
    48  // TestWriteFileWrite tests writing a file and reading it back
    49  func TestWriteFileWrite(t *testing.T) {
    50  	run.skipIfNoFUSE(t)
    51  
    52  	run.createFile(t, "testwrite", "data")
    53  	run.checkDir(t, "testwrite 4")
    54  	contents := run.readFile(t, "testwrite")
    55  	assert.Equal(t, "data", contents)
    56  	run.rm(t, "testwrite")
    57  }
    58  
    59  // TestWriteFileOverwrite tests overwriting a file
    60  func TestWriteFileOverwrite(t *testing.T) {
    61  	run.skipIfNoFUSE(t)
    62  
    63  	run.createFile(t, "testwrite", "data")
    64  	run.checkDir(t, "testwrite 4")
    65  	run.createFile(t, "testwrite", "potato")
    66  	contents := run.readFile(t, "testwrite")
    67  	assert.Equal(t, "potato", contents)
    68  	run.rm(t, "testwrite")
    69  }
    70  
    71  // TestWriteFileFsync tests Fsync
    72  //
    73  // NB the code for this is in file.go rather than write.go
    74  func TestWriteFileFsync(t *testing.T) {
    75  	run.skipIfNoFUSE(t)
    76  
    77  	filepath := run.path("to be synced")
    78  	fd, err := osCreate(filepath)
    79  	require.NoError(t, err)
    80  	_, err = fd.Write([]byte("hello"))
    81  	require.NoError(t, err)
    82  	err = fd.Sync()
    83  	require.NoError(t, err)
    84  	err = fd.Close()
    85  	require.NoError(t, err)
    86  	run.waitForWriters()
    87  	run.rm(t, "to be synced")
    88  }
    89  
    90  // TestWriteFileDup tests behavior of mmap() in Python by using dup() on a file handle
    91  func TestWriteFileDup(t *testing.T) {
    92  	run.skipIfNoFUSE(t)
    93  
    94  	if run.vfs.Opt.CacheMode < vfs.CacheModeWrites {
    95  		t.Skip("not supported on vfs-cache-mode < writes")
    96  		return
    97  	}
    98  
    99  	filepath := run.path("to be synced")
   100  	fh, err := osCreate(filepath)
   101  	require.NoError(t, err)
   102  
   103  	testData := []byte("0123456789")
   104  
   105  	err = fh.Truncate(int64(len(testData) + 2))
   106  	require.NoError(t, err)
   107  
   108  	err = fh.Sync()
   109  	require.NoError(t, err)
   110  
   111  	var dupFd uintptr
   112  	dupFd, err = writeTestDup(fh.Fd())
   113  	require.NoError(t, err)
   114  
   115  	dupFile := os.NewFile(dupFd, fh.Name())
   116  	_, err = dupFile.Write(testData)
   117  	require.NoError(t, err)
   118  
   119  	err = dupFile.Close()
   120  	require.NoError(t, err)
   121  
   122  	_, err = fh.Seek(int64(len(testData)), 0)
   123  	require.NoError(t, err)
   124  
   125  	_, err = fh.Write([]byte("10"))
   126  	require.NoError(t, err)
   127  
   128  	err = fh.Close()
   129  	require.NoError(t, err)
   130  
   131  	run.waitForWriters()
   132  	run.rm(t, "to be synced")
   133  }
   134  
   135  // TestWriteFileAppend tests that O_APPEND works on cache backends >= writes
   136  func TestWriteFileAppend(t *testing.T) {
   137  	run.skipIfNoFUSE(t)
   138  
   139  	if run.vfs.Opt.CacheMode < vfs.CacheModeWrites {
   140  		t.Skip("not supported on vfs-cache-mode < writes")
   141  		return
   142  	}
   143  
   144  	// TODO: Windows needs the v1.5 release of WinFsp to handle O_APPEND properly.
   145  	// Until it gets released, skip this test on Windows.
   146  	if runtime.GOOS == "windows" {
   147  		t.Skip("currently unsupported on Windows")
   148  	}
   149  
   150  	filepath := run.path("to be synced")
   151  	fh, err := osCreate(filepath)
   152  	require.NoError(t, err)
   153  
   154  	testData := []byte("0123456789")
   155  	appendData := []byte("10")
   156  
   157  	_, err = fh.Write(testData)
   158  	require.NoError(t, err)
   159  
   160  	err = fh.Close()
   161  	require.NoError(t, err)
   162  
   163  	fh, err = osAppend(filepath)
   164  	require.NoError(t, err)
   165  
   166  	_, err = fh.Write(appendData)
   167  	require.NoError(t, err)
   168  
   169  	err = fh.Close()
   170  	require.NoError(t, err)
   171  
   172  	info, err := os.Stat(filepath)
   173  	require.NoError(t, err)
   174  	require.EqualValues(t, len(testData)+len(appendData), info.Size())
   175  
   176  	run.waitForWriters()
   177  	run.rm(t, "to be synced")
   178  }