github.com/rclone/rclone@v1.66.1-0.20240517100346-7b89735ae726/fs/config/configmap/configmap_test.go (about)

     1  package configmap
     2  
     3  import (
     4  	"encoding/base64"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/require"
     9  )
    10  
    11  var (
    12  	_ Mapper = Simple(nil)
    13  	_ Getter = Simple(nil)
    14  	_ Setter = Simple(nil)
    15  )
    16  
    17  func TestConfigMapGet(t *testing.T) {
    18  	m := New()
    19  
    20  	value, found := m.Get("config1")
    21  	assert.Equal(t, "", value)
    22  	assert.Equal(t, false, found)
    23  
    24  	value, found = m.Get("config2")
    25  	assert.Equal(t, "", value)
    26  	assert.Equal(t, false, found)
    27  
    28  	m1 := Simple{
    29  		"config1": "one",
    30  	}
    31  
    32  	m.AddGetter(m1, PriorityNormal)
    33  
    34  	value, found = m.Get("config1")
    35  	assert.Equal(t, "one", value)
    36  	assert.Equal(t, true, found)
    37  
    38  	value, found = m.Get("config2")
    39  	assert.Equal(t, "", value)
    40  	assert.Equal(t, false, found)
    41  
    42  	m2 := Simple{
    43  		"config1": "one2",
    44  		"config2": "two2",
    45  	}
    46  
    47  	m.AddGetter(m2, PriorityNormal)
    48  
    49  	value, found = m.Get("config1")
    50  	assert.Equal(t, "one", value)
    51  	assert.Equal(t, true, found)
    52  
    53  	value, found = m.Get("config2")
    54  	assert.Equal(t, "two2", value)
    55  	assert.Equal(t, true, found)
    56  
    57  }
    58  
    59  func TestConfigMapSet(t *testing.T) {
    60  	m := New()
    61  
    62  	m1 := Simple{
    63  		"config1": "one",
    64  	}
    65  	m2 := Simple{
    66  		"config1": "one2",
    67  		"config2": "two2",
    68  	}
    69  
    70  	m.AddSetter(m1).AddSetter(m2)
    71  
    72  	m.Set("config2", "potato")
    73  
    74  	assert.Equal(t, Simple{
    75  		"config1": "one",
    76  		"config2": "potato",
    77  	}, m1)
    78  	assert.Equal(t, Simple{
    79  		"config1": "one2",
    80  		"config2": "potato",
    81  	}, m2)
    82  
    83  	m.Set("config1", "beetroot")
    84  
    85  	assert.Equal(t, Simple{
    86  		"config1": "beetroot",
    87  		"config2": "potato",
    88  	}, m1)
    89  	assert.Equal(t, Simple{
    90  		"config1": "beetroot",
    91  		"config2": "potato",
    92  	}, m2)
    93  
    94  	m.ClearSetters()
    95  
    96  	// Check that nothing gets set
    97  	m.Set("config1", "BEETROOT")
    98  
    99  	assert.Equal(t, Simple{
   100  		"config1": "beetroot",
   101  		"config2": "potato",
   102  	}, m1)
   103  	assert.Equal(t, Simple{
   104  		"config1": "beetroot",
   105  		"config2": "potato",
   106  	}, m2)
   107  
   108  }
   109  
   110  func TestConfigMapGetPriority(t *testing.T) {
   111  	m := New()
   112  
   113  	value, found := m.GetPriority("config1", PriorityMax)
   114  	assert.Equal(t, "", value)
   115  	assert.Equal(t, false, found)
   116  
   117  	value, found = m.GetPriority("config2", PriorityMax)
   118  	assert.Equal(t, "", value)
   119  	assert.Equal(t, false, found)
   120  
   121  	m1 := Simple{
   122  		"config1": "one",
   123  		"config3": "three",
   124  	}
   125  
   126  	m.AddGetter(m1, PriorityConfig)
   127  
   128  	value, found = m.GetPriority("config1", PriorityNormal)
   129  	assert.Equal(t, "", value)
   130  	assert.Equal(t, false, found)
   131  
   132  	value, found = m.GetPriority("config2", PriorityNormal)
   133  	assert.Equal(t, "", value)
   134  	assert.Equal(t, false, found)
   135  
   136  	value, found = m.GetPriority("config3", PriorityNormal)
   137  	assert.Equal(t, "", value)
   138  	assert.Equal(t, false, found)
   139  
   140  	value, found = m.GetPriority("config1", PriorityConfig)
   141  	assert.Equal(t, "one", value)
   142  	assert.Equal(t, true, found)
   143  
   144  	value, found = m.GetPriority("config2", PriorityConfig)
   145  	assert.Equal(t, "", value)
   146  	assert.Equal(t, false, found)
   147  
   148  	value, found = m.GetPriority("config3", PriorityConfig)
   149  	assert.Equal(t, "three", value)
   150  	assert.Equal(t, true, found)
   151  
   152  	value, found = m.GetPriority("config1", PriorityMax)
   153  	assert.Equal(t, "one", value)
   154  	assert.Equal(t, true, found)
   155  
   156  	value, found = m.GetPriority("config2", PriorityMax)
   157  	assert.Equal(t, "", value)
   158  	assert.Equal(t, false, found)
   159  
   160  	value, found = m.GetPriority("config3", PriorityMax)
   161  	assert.Equal(t, "three", value)
   162  	assert.Equal(t, true, found)
   163  
   164  	m2 := Simple{
   165  		"config1": "one2",
   166  		"config2": "two2",
   167  	}
   168  
   169  	m.AddGetter(m2, PriorityNormal)
   170  
   171  	value, found = m.GetPriority("config1", PriorityNormal)
   172  	assert.Equal(t, "one2", value)
   173  	assert.Equal(t, true, found)
   174  
   175  	value, found = m.GetPriority("config2", PriorityNormal)
   176  	assert.Equal(t, "two2", value)
   177  	assert.Equal(t, true, found)
   178  
   179  	value, found = m.GetPriority("config3", PriorityNormal)
   180  	assert.Equal(t, "", value)
   181  	assert.Equal(t, false, found)
   182  
   183  	value, found = m.GetPriority("config1", PriorityConfig)
   184  	assert.Equal(t, "one2", value)
   185  	assert.Equal(t, true, found)
   186  
   187  	value, found = m.GetPriority("config2", PriorityConfig)
   188  	assert.Equal(t, "two2", value)
   189  	assert.Equal(t, true, found)
   190  
   191  	value, found = m.GetPriority("config3", PriorityConfig)
   192  	assert.Equal(t, "three", value)
   193  	assert.Equal(t, true, found)
   194  
   195  	value, found = m.GetPriority("config1", PriorityMax)
   196  	assert.Equal(t, "one2", value)
   197  	assert.Equal(t, true, found)
   198  
   199  	value, found = m.GetPriority("config2", PriorityMax)
   200  	assert.Equal(t, "two2", value)
   201  	assert.Equal(t, true, found)
   202  
   203  	value, found = m.GetPriority("config3", PriorityMax)
   204  	assert.Equal(t, "three", value)
   205  	assert.Equal(t, true, found)
   206  }
   207  
   208  func TestConfigMapClearGetters(t *testing.T) {
   209  	m := New()
   210  	m1 := Simple{}
   211  	m2 := Simple{}
   212  	m3 := Simple{}
   213  	m.AddGetter(m1, PriorityNormal)
   214  	m.AddGetter(m2, PriorityDefault)
   215  	m.AddGetter(m3, PriorityConfig)
   216  	assert.Equal(t, []getprio{
   217  		{m1, PriorityNormal},
   218  		{m3, PriorityConfig},
   219  		{m2, PriorityDefault},
   220  	}, m.getters)
   221  	m.ClearGetters(PriorityConfig)
   222  	assert.Equal(t, []getprio{
   223  		{m1, PriorityNormal},
   224  		{m2, PriorityDefault},
   225  	}, m.getters)
   226  	m.ClearGetters(PriorityNormal)
   227  	assert.Equal(t, []getprio{
   228  		{m2, PriorityDefault},
   229  	}, m.getters)
   230  	m.ClearGetters(PriorityDefault)
   231  	assert.Equal(t, []getprio{}, m.getters)
   232  	m.ClearGetters(PriorityDefault)
   233  	assert.Equal(t, []getprio{}, m.getters)
   234  }
   235  
   236  func TestConfigMapClearSetters(t *testing.T) {
   237  	m := New()
   238  	m1 := Simple{}
   239  	m2 := Simple{}
   240  	m3 := Simple{}
   241  	m.AddSetter(m1)
   242  	m.AddSetter(m2)
   243  	m.AddSetter(m3)
   244  	assert.Equal(t, []Setter{m1, m2, m3}, m.setters)
   245  	m.ClearSetters()
   246  	assert.Equal(t, []Setter(nil), m.setters)
   247  }
   248  
   249  func TestSimpleString(t *testing.T) {
   250  	// Basic
   251  	assert.Equal(t, "", Simple(nil).String())
   252  	assert.Equal(t, "", Simple{}.String())
   253  	assert.Equal(t, "config1='one'", Simple{
   254  		"config1": "one",
   255  	}.String())
   256  
   257  	// Check ordering
   258  	assert.Equal(t, "config1='one',config2='two',config3='three',config4='four',config5='five'", Simple{
   259  		"config5": "five",
   260  		"config4": "four",
   261  		"config3": "three",
   262  		"config2": "two",
   263  		"config1": "one",
   264  	}.String())
   265  
   266  	// Check escaping
   267  	assert.Equal(t, "apple='',config1='o''n''e'", Simple{
   268  		"config1": "o'n'e",
   269  		"apple":   "",
   270  	}.String())
   271  }
   272  
   273  func TestSimpleEncode(t *testing.T) {
   274  	for _, test := range []struct {
   275  		in   Simple
   276  		want string
   277  	}{
   278  		{
   279  			in:   Simple{},
   280  			want: "",
   281  		},
   282  		{
   283  			in: Simple{
   284  				"one": "potato",
   285  			},
   286  			want: "eyJvbmUiOiJwb3RhdG8ifQ",
   287  		},
   288  		{
   289  			in: Simple{
   290  				"one": "potato",
   291  				"two": "",
   292  			},
   293  			want: "eyJvbmUiOiJwb3RhdG8iLCJ0d28iOiIifQ",
   294  		},
   295  	} {
   296  		got, err := test.in.Encode()
   297  		require.NoError(t, err)
   298  		assert.Equal(t, test.want, got)
   299  		gotM := Simple{}
   300  		err = gotM.Decode(got)
   301  		require.NoError(t, err)
   302  		assert.Equal(t, test.in, gotM)
   303  	}
   304  }
   305  
   306  func TestSimpleDecode(t *testing.T) {
   307  	for _, test := range []struct {
   308  		in      string
   309  		want    Simple
   310  		wantErr string
   311  	}{
   312  		{
   313  			in:   "",
   314  			want: Simple{},
   315  		},
   316  		{
   317  			in: "eyJvbmUiOiJwb3RhdG8ifQ",
   318  			want: Simple{
   319  				"one": "potato",
   320  			},
   321  		},
   322  		{
   323  			in: "   e yJvbm  UiOiJwb\r\n 3Rhd\tG8ifQ\n\n ",
   324  			want: Simple{
   325  				"one": "potato",
   326  			},
   327  		},
   328  		{
   329  			in: "eyJvbmUiOiJwb3RhdG8iLCJ0d28iOiIifQ",
   330  			want: Simple{
   331  				"one": "potato",
   332  				"two": "",
   333  			},
   334  		},
   335  		{
   336  			in:      "!!!!!",
   337  			want:    Simple{},
   338  			wantErr: "decode simple map",
   339  		},
   340  		{
   341  			in:   base64.RawStdEncoding.EncodeToString([]byte(`null`)),
   342  			want: Simple{},
   343  		},
   344  		{
   345  			in:      base64.RawStdEncoding.EncodeToString([]byte(`rubbish`)),
   346  			want:    Simple{},
   347  			wantErr: "parse simple map",
   348  		},
   349  	} {
   350  		got := Simple{}
   351  		err := got.Decode(test.in)
   352  		assert.Equal(t, test.want, got, test.in)
   353  		if test.wantErr == "" {
   354  			require.NoError(t, err, test.in)
   355  		} else {
   356  			assert.Contains(t, err.Error(), test.wantErr, test.in)
   357  		}
   358  	}
   359  }