github.com/ncw/rclone@v1.48.1-0.20190724201158-a35aa1360e3e/fs/fs_test.go (about)

     1  package fs
     2  
     3  import (
     4  	"context"
     5  	"strings"
     6  	"sync"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/ncw/rclone/fs/fserrors"
    13  	"github.com/ncw/rclone/lib/pacer"
    14  	"github.com/pkg/errors"
    15  	"github.com/spf13/pflag"
    16  	"github.com/stretchr/testify/assert"
    17  )
    18  
    19  func TestFeaturesDisable(t *testing.T) {
    20  	ft := new(Features)
    21  	ft.Copy = func(ctx context.Context, src Object, remote string) (Object, error) {
    22  		return nil, nil
    23  	}
    24  	ft.CaseInsensitive = true
    25  
    26  	assert.NotNil(t, ft.Copy)
    27  	assert.Nil(t, ft.Purge)
    28  	ft.Disable("copy")
    29  	assert.Nil(t, ft.Copy)
    30  	assert.Nil(t, ft.Purge)
    31  
    32  	assert.True(t, ft.CaseInsensitive)
    33  	assert.False(t, ft.DuplicateFiles)
    34  	ft.Disable("caseinsensitive")
    35  	assert.False(t, ft.CaseInsensitive)
    36  	assert.False(t, ft.DuplicateFiles)
    37  }
    38  
    39  func TestFeaturesList(t *testing.T) {
    40  	ft := new(Features)
    41  	names := strings.Join(ft.List(), ",")
    42  	assert.True(t, strings.Contains(names, ",Copy,"))
    43  }
    44  
    45  func TestFeaturesEnabled(t *testing.T) {
    46  	ft := new(Features)
    47  	ft.CaseInsensitive = true
    48  	ft.Purge = func(ctx context.Context) error { return nil }
    49  	enabled := ft.Enabled()
    50  
    51  	flag, ok := enabled["CaseInsensitive"]
    52  	assert.Equal(t, true, ok)
    53  	assert.Equal(t, true, flag, enabled)
    54  
    55  	flag, ok = enabled["Purge"]
    56  	assert.Equal(t, true, ok)
    57  	assert.Equal(t, true, flag, enabled)
    58  
    59  	flag, ok = enabled["DuplicateFiles"]
    60  	assert.Equal(t, true, ok)
    61  	assert.Equal(t, false, flag, enabled)
    62  
    63  	flag, ok = enabled["Copy"]
    64  	assert.Equal(t, true, ok)
    65  	assert.Equal(t, false, flag, enabled)
    66  
    67  	assert.Equal(t, len(ft.List()), len(enabled))
    68  }
    69  
    70  func TestFeaturesDisableList(t *testing.T) {
    71  	ft := new(Features)
    72  	ft.Copy = func(ctx context.Context, src Object, remote string) (Object, error) {
    73  		return nil, nil
    74  	}
    75  	ft.CaseInsensitive = true
    76  
    77  	assert.NotNil(t, ft.Copy)
    78  	assert.Nil(t, ft.Purge)
    79  	assert.True(t, ft.CaseInsensitive)
    80  	assert.False(t, ft.DuplicateFiles)
    81  
    82  	ft.DisableList([]string{"copy", "caseinsensitive"})
    83  
    84  	assert.Nil(t, ft.Copy)
    85  	assert.Nil(t, ft.Purge)
    86  	assert.False(t, ft.CaseInsensitive)
    87  	assert.False(t, ft.DuplicateFiles)
    88  }
    89  
    90  // Check it satisfies the interface
    91  var _ pflag.Value = (*Option)(nil)
    92  
    93  func TestOption(t *testing.T) {
    94  	d := &Option{
    95  		Name:  "potato",
    96  		Value: SizeSuffix(17 << 20),
    97  	}
    98  	assert.Equal(t, "17M", d.String())
    99  	assert.Equal(t, "SizeSuffix", d.Type())
   100  	err := d.Set("18M")
   101  	assert.NoError(t, err)
   102  	assert.Equal(t, SizeSuffix(18<<20), d.Value)
   103  	err = d.Set("sdfsdf")
   104  	assert.Error(t, err)
   105  }
   106  
   107  var errFoo = errors.New("foo")
   108  
   109  type dummyPaced struct {
   110  	retry  bool
   111  	called int
   112  	wait   *sync.Cond
   113  }
   114  
   115  func (dp *dummyPaced) fn() (bool, error) {
   116  	if dp.wait != nil {
   117  		dp.wait.L.Lock()
   118  		dp.wait.Wait()
   119  		dp.wait.L.Unlock()
   120  	}
   121  	dp.called++
   122  	return dp.retry, errFoo
   123  }
   124  
   125  func TestPacerCall(t *testing.T) {
   126  	expectedCalled := Config.LowLevelRetries
   127  	if expectedCalled == 0 {
   128  		expectedCalled = 20
   129  		Config.LowLevelRetries = expectedCalled
   130  		defer func() {
   131  			Config.LowLevelRetries = 0
   132  		}()
   133  	}
   134  	p := NewPacer(pacer.NewDefault(pacer.MinSleep(1*time.Millisecond), pacer.MaxSleep(2*time.Millisecond)))
   135  
   136  	dp := &dummyPaced{retry: true}
   137  	err := p.Call(dp.fn)
   138  	require.Equal(t, expectedCalled, dp.called)
   139  	require.Implements(t, (*fserrors.Retrier)(nil), err)
   140  }
   141  
   142  func TestPacerCallNoRetry(t *testing.T) {
   143  	p := NewPacer(pacer.NewDefault(pacer.MinSleep(1*time.Millisecond), pacer.MaxSleep(2*time.Millisecond)))
   144  
   145  	dp := &dummyPaced{retry: true}
   146  	err := p.CallNoRetry(dp.fn)
   147  	require.Equal(t, 1, dp.called)
   148  	require.Implements(t, (*fserrors.Retrier)(nil), err)
   149  }