github.com/10XDev/rclone@v1.52.3-0.20200626220027-16af9ab76b2a/fs/cache/cache_test.go (about)

     1  package cache
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/rclone/rclone/fs"
     8  	"github.com/rclone/rclone/fstest/mockfs"
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  var (
    14  	called      = 0
    15  	errSentinel = errors.New("an error")
    16  )
    17  
    18  func mockNewFs(t *testing.T) (func(), func(path string) (fs.Fs, error)) {
    19  	called = 0
    20  	create := func(path string) (f fs.Fs, err error) {
    21  		assert.Equal(t, 0, called)
    22  		called++
    23  		switch path {
    24  		case "mock:/":
    25  			return mockfs.NewFs("mock", "/"), nil
    26  		case "mock:/file.txt":
    27  			return mockfs.NewFs("mock", "/"), fs.ErrorIsFile
    28  		case "mock:/error":
    29  			return nil, errSentinel
    30  		}
    31  		t.Fatalf("Unknown path %q", path)
    32  		panic("unreachable")
    33  	}
    34  	cleanup := func() {
    35  		c.Clear()
    36  	}
    37  	return cleanup, create
    38  }
    39  
    40  func TestGet(t *testing.T) {
    41  	cleanup, create := mockNewFs(t)
    42  	defer cleanup()
    43  
    44  	assert.Equal(t, 0, c.Entries())
    45  
    46  	f, err := GetFn("mock:/", create)
    47  	require.NoError(t, err)
    48  
    49  	assert.Equal(t, 1, c.Entries())
    50  
    51  	f2, err := GetFn("mock:/", create)
    52  	require.NoError(t, err)
    53  
    54  	assert.Equal(t, f, f2)
    55  }
    56  
    57  func TestGetFile(t *testing.T) {
    58  	cleanup, create := mockNewFs(t)
    59  	defer cleanup()
    60  
    61  	assert.Equal(t, 0, c.Entries())
    62  
    63  	f, err := GetFn("mock:/file.txt", create)
    64  	require.Equal(t, fs.ErrorIsFile, err)
    65  	require.NotNil(t, f)
    66  
    67  	assert.Equal(t, 1, c.Entries())
    68  
    69  	f2, err := GetFn("mock:/file.txt", create)
    70  	require.Equal(t, fs.ErrorIsFile, err)
    71  	require.NotNil(t, f2)
    72  
    73  	assert.Equal(t, f, f2)
    74  }
    75  
    76  func TestGetError(t *testing.T) {
    77  	cleanup, create := mockNewFs(t)
    78  	defer cleanup()
    79  
    80  	assert.Equal(t, 0, c.Entries())
    81  
    82  	f, err := GetFn("mock:/error", create)
    83  	require.Equal(t, errSentinel, err)
    84  	require.Equal(t, nil, f)
    85  
    86  	assert.Equal(t, 0, c.Entries())
    87  }
    88  
    89  func TestPut(t *testing.T) {
    90  	cleanup, create := mockNewFs(t)
    91  	defer cleanup()
    92  
    93  	f := mockfs.NewFs("mock", "/alien")
    94  
    95  	assert.Equal(t, 0, c.Entries())
    96  
    97  	Put("mock:/alien", f)
    98  
    99  	assert.Equal(t, 1, c.Entries())
   100  
   101  	fNew, err := GetFn("mock:/alien", create)
   102  	require.NoError(t, err)
   103  	require.Equal(t, f, fNew)
   104  
   105  	assert.Equal(t, 1, c.Entries())
   106  
   107  	// Check canonicalisation
   108  
   109  	Put("mock:/alien/", f)
   110  
   111  	fNew, err = GetFn("mock:/alien/", create)
   112  	require.NoError(t, err)
   113  	require.Equal(t, f, fNew)
   114  
   115  	assert.Equal(t, 1, c.Entries())
   116  
   117  }
   118  
   119  func TestPin(t *testing.T) {
   120  	cleanup, create := mockNewFs(t)
   121  	defer cleanup()
   122  
   123  	// Test pinning and unpinning non existent
   124  	f := mockfs.NewFs("mock", "/alien")
   125  	Pin(f)
   126  	Unpin(f)
   127  
   128  	// Now test pinning an existing
   129  	f2, err := GetFn("mock:/", create)
   130  	require.NoError(t, err)
   131  	Pin(f2)
   132  	Unpin(f2)
   133  }
   134  
   135  func TestClear(t *testing.T) {
   136  	cleanup, create := mockNewFs(t)
   137  	defer cleanup()
   138  
   139  	// Create something
   140  	_, err := GetFn("mock:/", create)
   141  	require.NoError(t, err)
   142  
   143  	assert.Equal(t, 1, c.Entries())
   144  
   145  	Clear()
   146  
   147  	assert.Equal(t, 0, c.Entries())
   148  }