storj.io/minio@v0.0.0-20230509071714-0cbc90f649b1/pkg/bucket/policy/condition/stringlikefunc_test.go (about)

     1  /*
     2   * MinIO Cloud Storage, (C) 2018 MinIO, Inc.
     3   *
     4   * Licensed under the Apache License, Version 2.0 (the "License");
     5   * you may not use this file except in compliance with the License.
     6   * You may obtain a copy of the License at
     7   *
     8   *     http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  
    17  package condition
    18  
    19  import (
    20  	"reflect"
    21  	"testing"
    22  )
    23  
    24  func TestStringLikeFuncEvaluate(t *testing.T) {
    25  	case1Function, err := newStringLikeFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject*")))
    26  	if err != nil {
    27  		t.Fatalf("unexpected error. %v\n", err)
    28  	}
    29  
    30  	case2Function, err := newStringLikeFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
    31  	if err != nil {
    32  		t.Fatalf("unexpected error. %v\n", err)
    33  	}
    34  
    35  	case3Function, err := newStringLikeFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES*")))
    36  	if err != nil {
    37  		t.Fatalf("unexpected error. %v\n", err)
    38  	}
    39  
    40  	case4Function, err := newStringLikeFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
    41  	if err != nil {
    42  		t.Fatalf("unexpected error. %v\n", err)
    43  	}
    44  
    45  	case5Function, err := newStringLikeFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPL*")))
    46  	if err != nil {
    47  		t.Fatalf("unexpected error. %v\n", err)
    48  	}
    49  
    50  	case6Function, err := newStringLikeFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
    51  	if err != nil {
    52  		t.Fatalf("unexpected error. %v\n", err)
    53  	}
    54  
    55  	case7Function, err := newStringLikeFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-*")))
    56  	if err != nil {
    57  		t.Fatalf("unexpected error. %v\n", err)
    58  	}
    59  
    60  	case8Function, err := newStringLikeFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
    61  	if err != nil {
    62  		t.Fatalf("unexpected error. %v\n", err)
    63  	}
    64  
    65  	testCases := []struct {
    66  		function       Function
    67  		values         map[string][]string
    68  		expectedResult bool
    69  	}{
    70  		{case1Function, map[string][]string{"x-amz-copy-source": {"mybucket/myobject"}}, true},
    71  		{case1Function, map[string][]string{"x-amz-copy-source": {"mybucket/myobject.png"}}, true},
    72  		{case1Function, map[string][]string{"x-amz-copy-source": {"yourbucket/myobject"}}, false},
    73  		{case1Function, map[string][]string{}, false},
    74  		{case1Function, map[string][]string{"delimiter": {"/"}}, false},
    75  
    76  		{case2Function, map[string][]string{"x-amz-copy-source": {"mybucket/myobject"}}, true},
    77  		{case2Function, map[string][]string{"x-amz-copy-source": {"mybucket/myobject.png"}}, false},
    78  		{case2Function, map[string][]string{"x-amz-copy-source": {"yourbucket/myobject"}}, false},
    79  		{case2Function, map[string][]string{}, false},
    80  		{case2Function, map[string][]string{"delimiter": {"/"}}, false},
    81  
    82  		{case3Function, map[string][]string{"x-amz-server-side-encryption": {"AES256"}}, true},
    83  		{case3Function, map[string][]string{"x-amz-server-side-encryption": {"AES512"}}, true},
    84  		{case3Function, map[string][]string{}, false},
    85  		{case3Function, map[string][]string{"delimiter": {"/"}}, false},
    86  
    87  		{case4Function, map[string][]string{"x-amz-server-side-encryption": {"AES256"}}, true},
    88  		{case4Function, map[string][]string{"x-amz-server-side-encryption": {"AES512"}}, false},
    89  		{case4Function, map[string][]string{}, false},
    90  		{case4Function, map[string][]string{"delimiter": {"/"}}, false},
    91  
    92  		{case5Function, map[string][]string{"x-amz-metadata-directive": {"REPLACE"}}, true},
    93  		{case5Function, map[string][]string{"x-amz-metadata-directive": {"REPLACE/COPY"}}, true},
    94  		{case5Function, map[string][]string{"x-amz-metadata-directive": {"COPY"}}, false},
    95  		{case5Function, map[string][]string{}, false},
    96  		{case5Function, map[string][]string{"delimiter": {"/"}}, false},
    97  
    98  		{case6Function, map[string][]string{"x-amz-metadata-directive": {"REPLACE"}}, true},
    99  		{case6Function, map[string][]string{"x-amz-metadata-directive": {"REPLACE/COPY"}}, false},
   100  		{case6Function, map[string][]string{"x-amz-metadata-directive": {"COPY"}}, false},
   101  		{case6Function, map[string][]string{}, false},
   102  		{case6Function, map[string][]string{"delimiter": {"/"}}, false},
   103  
   104  		{case7Function, map[string][]string{"LocationConstraint": {"eu-west-1"}}, true},
   105  		{case7Function, map[string][]string{"LocationConstraint": {"eu-west-2"}}, true},
   106  		{case7Function, map[string][]string{"LocationConstraint": {"us-east-1"}}, false},
   107  		{case7Function, map[string][]string{}, false},
   108  		{case7Function, map[string][]string{"delimiter": {"/"}}, false},
   109  
   110  		{case8Function, map[string][]string{"LocationConstraint": {"eu-west-1"}}, true},
   111  		{case8Function, map[string][]string{"LocationConstraint": {"eu-west-2"}}, false},
   112  		{case8Function, map[string][]string{"LocationConstraint": {"us-east-1"}}, false},
   113  		{case8Function, map[string][]string{}, false},
   114  		{case8Function, map[string][]string{"delimiter": {"/"}}, false},
   115  	}
   116  
   117  	for i, testCase := range testCases {
   118  		result := testCase.function.evaluate(testCase.values)
   119  
   120  		if result != testCase.expectedResult {
   121  			t.Fatalf("case %v: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   122  		}
   123  	}
   124  }
   125  
   126  func TestStringLikeFuncKey(t *testing.T) {
   127  	case1Function, err := newStringLikeFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
   128  	if err != nil {
   129  		t.Fatalf("unexpected error. %v\n", err)
   130  	}
   131  
   132  	case2Function, err := newStringLikeFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
   133  	if err != nil {
   134  		t.Fatalf("unexpected error. %v\n", err)
   135  	}
   136  
   137  	case3Function, err := newStringLikeFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
   138  	if err != nil {
   139  		t.Fatalf("unexpected error. %v\n", err)
   140  	}
   141  
   142  	case4Function, err := newStringLikeFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
   143  	if err != nil {
   144  		t.Fatalf("unexpected error. %v\n", err)
   145  	}
   146  
   147  	testCases := []struct {
   148  		function       Function
   149  		expectedResult Key
   150  	}{
   151  		{case1Function, S3XAmzCopySource},
   152  		{case2Function, S3XAmzServerSideEncryption},
   153  		{case3Function, S3XAmzMetadataDirective},
   154  		{case4Function, S3LocationConstraint},
   155  	}
   156  
   157  	for i, testCase := range testCases {
   158  		result := testCase.function.key()
   159  
   160  		if result != testCase.expectedResult {
   161  			t.Fatalf("case %v: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   162  		}
   163  	}
   164  }
   165  
   166  func TestStringLikeFuncToMap(t *testing.T) {
   167  	case1Function, err := newStringLikeFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/*")))
   168  	if err != nil {
   169  		t.Fatalf("unexpected error. %v\n", err)
   170  	}
   171  
   172  	case1Result := map[Key]ValueSet{
   173  		S3XAmzCopySource: NewValueSet(NewStringValue("mybucket/*")),
   174  	}
   175  
   176  	case2Function, err := newStringLikeFunc(S3XAmzCopySource,
   177  		NewValueSet(
   178  			NewStringValue("mybucket/*"),
   179  			NewStringValue("yourbucket/myobject*"),
   180  		),
   181  	)
   182  	if err != nil {
   183  		t.Fatalf("unexpected error. %v\n", err)
   184  	}
   185  
   186  	case2Result := map[Key]ValueSet{
   187  		S3XAmzCopySource: NewValueSet(
   188  			NewStringValue("mybucket/*"),
   189  			NewStringValue("yourbucket/myobject*"),
   190  		),
   191  	}
   192  
   193  	case3Function, err := newStringLikeFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES*")))
   194  	if err != nil {
   195  		t.Fatalf("unexpected error. %v\n", err)
   196  	}
   197  
   198  	case3Result := map[Key]ValueSet{
   199  		S3XAmzServerSideEncryption: NewValueSet(NewStringValue("AES*")),
   200  	}
   201  
   202  	case4Function, err := newStringLikeFunc(S3XAmzServerSideEncryption,
   203  		NewValueSet(
   204  			NewStringValue("AES*"),
   205  		),
   206  	)
   207  	if err != nil {
   208  		t.Fatalf("unexpected error. %v\n", err)
   209  	}
   210  
   211  	case4Result := map[Key]ValueSet{
   212  		S3XAmzServerSideEncryption: NewValueSet(
   213  			NewStringValue("AES*"),
   214  		),
   215  	}
   216  
   217  	case5Function, err := newStringLikeFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPL*")))
   218  	if err != nil {
   219  		t.Fatalf("unexpected error. %v\n", err)
   220  	}
   221  
   222  	case5Result := map[Key]ValueSet{
   223  		S3XAmzMetadataDirective: NewValueSet(NewStringValue("REPL*")),
   224  	}
   225  
   226  	case6Function, err := newStringLikeFunc(S3XAmzMetadataDirective,
   227  		NewValueSet(
   228  			NewStringValue("REPL*"),
   229  			NewStringValue("COPY*"),
   230  		),
   231  	)
   232  	if err != nil {
   233  		t.Fatalf("unexpected error. %v\n", err)
   234  	}
   235  
   236  	case6Result := map[Key]ValueSet{
   237  		S3XAmzMetadataDirective: NewValueSet(
   238  			NewStringValue("REPL*"),
   239  			NewStringValue("COPY*"),
   240  		),
   241  	}
   242  
   243  	case7Function, err := newStringLikeFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-*")))
   244  	if err != nil {
   245  		t.Fatalf("unexpected error. %v\n", err)
   246  	}
   247  
   248  	case7Result := map[Key]ValueSet{
   249  		S3LocationConstraint: NewValueSet(NewStringValue("eu-west-*")),
   250  	}
   251  
   252  	case8Function, err := newStringLikeFunc(S3LocationConstraint,
   253  		NewValueSet(
   254  			NewStringValue("eu-west-*"),
   255  			NewStringValue("us-west-*"),
   256  		),
   257  	)
   258  	if err != nil {
   259  		t.Fatalf("unexpected error. %v\n", err)
   260  	}
   261  
   262  	case8Result := map[Key]ValueSet{
   263  		S3LocationConstraint: NewValueSet(
   264  			NewStringValue("eu-west-*"),
   265  			NewStringValue("us-west-*"),
   266  		),
   267  	}
   268  
   269  	testCases := []struct {
   270  		f              Function
   271  		expectedResult map[Key]ValueSet
   272  	}{
   273  		{case1Function, case1Result},
   274  		{case2Function, case2Result},
   275  		{case3Function, case3Result},
   276  		{case4Function, case4Result},
   277  		{case5Function, case5Result},
   278  		{case6Function, case6Result},
   279  		{case7Function, case7Result},
   280  		{case8Function, case8Result},
   281  		{&stringLikeFunc{}, nil},
   282  	}
   283  
   284  	for i, testCase := range testCases {
   285  		result := testCase.f.toMap()
   286  
   287  		if !reflect.DeepEqual(result, testCase.expectedResult) {
   288  			t.Fatalf("case %v: result: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   289  		}
   290  	}
   291  }
   292  
   293  func TestStringNotLikeFuncEvaluate(t *testing.T) {
   294  	case1Function, err := newStringNotLikeFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject*")))
   295  	if err != nil {
   296  		t.Fatalf("unexpected error. %v\n", err)
   297  	}
   298  
   299  	case2Function, err := newStringNotLikeFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
   300  	if err != nil {
   301  		t.Fatalf("unexpected error. %v\n", err)
   302  	}
   303  
   304  	case3Function, err := newStringNotLikeFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES*")))
   305  	if err != nil {
   306  		t.Fatalf("unexpected error. %v\n", err)
   307  	}
   308  
   309  	case4Function, err := newStringNotLikeFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
   310  	if err != nil {
   311  		t.Fatalf("unexpected error. %v\n", err)
   312  	}
   313  
   314  	case5Function, err := newStringNotLikeFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPL*")))
   315  	if err != nil {
   316  		t.Fatalf("unexpected error. %v\n", err)
   317  	}
   318  
   319  	case6Function, err := newStringNotLikeFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
   320  	if err != nil {
   321  		t.Fatalf("unexpected error. %v\n", err)
   322  	}
   323  
   324  	case7Function, err := newStringNotLikeFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-*")))
   325  	if err != nil {
   326  		t.Fatalf("unexpected error. %v\n", err)
   327  	}
   328  
   329  	case8Function, err := newStringNotLikeFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
   330  	if err != nil {
   331  		t.Fatalf("unexpected error. %v\n", err)
   332  	}
   333  
   334  	testCases := []struct {
   335  		function       Function
   336  		values         map[string][]string
   337  		expectedResult bool
   338  	}{
   339  		{case1Function, map[string][]string{"x-amz-copy-source": {"mybucket/myobject"}}, false},
   340  		{case1Function, map[string][]string{"x-amz-copy-source": {"mybucket/myobject.png"}}, false},
   341  		{case1Function, map[string][]string{"x-amz-copy-source": {"yourbucket/myobject"}}, true},
   342  		{case1Function, map[string][]string{}, true},
   343  		{case1Function, map[string][]string{"delimiter": {"/"}}, true},
   344  
   345  		{case2Function, map[string][]string{"x-amz-copy-source": {"mybucket/myobject"}}, false},
   346  		{case2Function, map[string][]string{"x-amz-copy-source": {"mybucket/myobject.png"}}, true},
   347  		{case2Function, map[string][]string{"x-amz-copy-source": {"yourbucket/myobject"}}, true},
   348  		{case2Function, map[string][]string{}, true},
   349  		{case2Function, map[string][]string{"delimiter": {"/"}}, true},
   350  
   351  		{case3Function, map[string][]string{"x-amz-server-side-encryption": {"AES256"}}, false},
   352  		{case3Function, map[string][]string{"x-amz-server-side-encryption": {"AES512"}}, false},
   353  		{case3Function, map[string][]string{}, true},
   354  		{case3Function, map[string][]string{"delimiter": {"/"}}, true},
   355  
   356  		{case4Function, map[string][]string{"x-amz-server-side-encryption": {"AES256"}}, false},
   357  		{case4Function, map[string][]string{"x-amz-server-side-encryption": {"AES512"}}, true},
   358  		{case4Function, map[string][]string{}, true},
   359  		{case4Function, map[string][]string{"delimiter": {"/"}}, true},
   360  
   361  		{case5Function, map[string][]string{"x-amz-metadata-directive": {"REPLACE"}}, false},
   362  		{case5Function, map[string][]string{"x-amz-metadata-directive": {"REPLACE/COPY"}}, false},
   363  		{case5Function, map[string][]string{"x-amz-metadata-directive": {"COPY"}}, true},
   364  		{case5Function, map[string][]string{}, true},
   365  		{case5Function, map[string][]string{"delimiter": {"/"}}, true},
   366  
   367  		{case6Function, map[string][]string{"x-amz-metadata-directive": {"REPLACE"}}, false},
   368  		{case6Function, map[string][]string{"x-amz-metadata-directive": {"REPLACE/COPY"}}, true},
   369  		{case6Function, map[string][]string{"x-amz-metadata-directive": {"COPY"}}, true},
   370  		{case6Function, map[string][]string{}, true},
   371  		{case6Function, map[string][]string{"delimiter": {"/"}}, true},
   372  
   373  		{case7Function, map[string][]string{"LocationConstraint": {"eu-west-1"}}, false},
   374  		{case7Function, map[string][]string{"LocationConstraint": {"eu-west-2"}}, false},
   375  		{case7Function, map[string][]string{"LocationConstraint": {"us-east-1"}}, true},
   376  		{case7Function, map[string][]string{}, true},
   377  		{case7Function, map[string][]string{"delimiter": {"/"}}, true},
   378  
   379  		{case8Function, map[string][]string{"LocationConstraint": {"eu-west-1"}}, false},
   380  		{case8Function, map[string][]string{"LocationConstraint": {"eu-west-2"}}, true},
   381  		{case8Function, map[string][]string{"LocationConstraint": {"us-east-1"}}, true},
   382  		{case8Function, map[string][]string{}, true},
   383  		{case8Function, map[string][]string{"delimiter": {"/"}}, true},
   384  	}
   385  
   386  	for i, testCase := range testCases {
   387  		result := testCase.function.evaluate(testCase.values)
   388  
   389  		if result != testCase.expectedResult {
   390  			t.Fatalf("case %v: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   391  		}
   392  	}
   393  }
   394  
   395  func TestStringNotLikeFuncKey(t *testing.T) {
   396  	case1Function, err := newStringNotLikeFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
   397  	if err != nil {
   398  		t.Fatalf("unexpected error. %v\n", err)
   399  	}
   400  
   401  	case2Function, err := newStringNotLikeFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
   402  	if err != nil {
   403  		t.Fatalf("unexpected error. %v\n", err)
   404  	}
   405  
   406  	case3Function, err := newStringNotLikeFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
   407  	if err != nil {
   408  		t.Fatalf("unexpected error. %v\n", err)
   409  	}
   410  
   411  	case4Function, err := newStringNotLikeFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
   412  	if err != nil {
   413  		t.Fatalf("unexpected error. %v\n", err)
   414  	}
   415  
   416  	testCases := []struct {
   417  		function       Function
   418  		expectedResult Key
   419  	}{
   420  		{case1Function, S3XAmzCopySource},
   421  		{case2Function, S3XAmzServerSideEncryption},
   422  		{case3Function, S3XAmzMetadataDirective},
   423  		{case4Function, S3LocationConstraint},
   424  	}
   425  
   426  	for i, testCase := range testCases {
   427  		result := testCase.function.key()
   428  
   429  		if result != testCase.expectedResult {
   430  			t.Fatalf("case %v: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   431  		}
   432  	}
   433  }
   434  
   435  func TestStringNotLikeFuncToMap(t *testing.T) {
   436  	case1Function, err := newStringNotLikeFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/*")))
   437  	if err != nil {
   438  		t.Fatalf("unexpected error. %v\n", err)
   439  	}
   440  
   441  	case1Result := map[Key]ValueSet{
   442  		S3XAmzCopySource: NewValueSet(NewStringValue("mybucket/*")),
   443  	}
   444  
   445  	case2Function, err := newStringNotLikeFunc(S3XAmzCopySource,
   446  		NewValueSet(
   447  			NewStringValue("mybucket/*"),
   448  			NewStringValue("yourbucket/myobject*"),
   449  		),
   450  	)
   451  	if err != nil {
   452  		t.Fatalf("unexpected error. %v\n", err)
   453  	}
   454  
   455  	case2Result := map[Key]ValueSet{
   456  		S3XAmzCopySource: NewValueSet(
   457  			NewStringValue("mybucket/*"),
   458  			NewStringValue("yourbucket/myobject*"),
   459  		),
   460  	}
   461  
   462  	case3Function, err := newStringNotLikeFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES*")))
   463  	if err != nil {
   464  		t.Fatalf("unexpected error. %v\n", err)
   465  	}
   466  
   467  	case3Result := map[Key]ValueSet{
   468  		S3XAmzServerSideEncryption: NewValueSet(NewStringValue("AES*")),
   469  	}
   470  
   471  	case4Function, err := newStringNotLikeFunc(S3XAmzServerSideEncryption,
   472  		NewValueSet(
   473  			NewStringValue("AES*"),
   474  		),
   475  	)
   476  	if err != nil {
   477  		t.Fatalf("unexpected error. %v\n", err)
   478  	}
   479  
   480  	case4Result := map[Key]ValueSet{
   481  		S3XAmzServerSideEncryption: NewValueSet(
   482  			NewStringValue("AES*"),
   483  		),
   484  	}
   485  
   486  	case5Function, err := newStringNotLikeFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPL*")))
   487  	if err != nil {
   488  		t.Fatalf("unexpected error. %v\n", err)
   489  	}
   490  
   491  	case5Result := map[Key]ValueSet{
   492  		S3XAmzMetadataDirective: NewValueSet(NewStringValue("REPL*")),
   493  	}
   494  
   495  	case6Function, err := newStringNotLikeFunc(S3XAmzMetadataDirective,
   496  		NewValueSet(
   497  			NewStringValue("REPL*"),
   498  			NewStringValue("COPY*"),
   499  		),
   500  	)
   501  	if err != nil {
   502  		t.Fatalf("unexpected error. %v\n", err)
   503  	}
   504  
   505  	case6Result := map[Key]ValueSet{
   506  		S3XAmzMetadataDirective: NewValueSet(
   507  			NewStringValue("REPL*"),
   508  			NewStringValue("COPY*"),
   509  		),
   510  	}
   511  
   512  	case7Function, err := newStringNotLikeFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-*")))
   513  	if err != nil {
   514  		t.Fatalf("unexpected error. %v\n", err)
   515  	}
   516  
   517  	case7Result := map[Key]ValueSet{
   518  		S3LocationConstraint: NewValueSet(NewStringValue("eu-west-*")),
   519  	}
   520  
   521  	case8Function, err := newStringNotLikeFunc(S3LocationConstraint,
   522  		NewValueSet(
   523  			NewStringValue("eu-west-*"),
   524  			NewStringValue("us-west-*"),
   525  		),
   526  	)
   527  	if err != nil {
   528  		t.Fatalf("unexpected error. %v\n", err)
   529  	}
   530  
   531  	case8Result := map[Key]ValueSet{
   532  		S3LocationConstraint: NewValueSet(
   533  			NewStringValue("eu-west-*"),
   534  			NewStringValue("us-west-*"),
   535  		),
   536  	}
   537  
   538  	testCases := []struct {
   539  		f              Function
   540  		expectedResult map[Key]ValueSet
   541  	}{
   542  		{case1Function, case1Result},
   543  		{case2Function, case2Result},
   544  		{case3Function, case3Result},
   545  		{case4Function, case4Result},
   546  		{case5Function, case5Result},
   547  		{case6Function, case6Result},
   548  		{case7Function, case7Result},
   549  		{case8Function, case8Result},
   550  		{&stringNotLikeFunc{}, nil},
   551  	}
   552  
   553  	for i, testCase := range testCases {
   554  		result := testCase.f.toMap()
   555  
   556  		if !reflect.DeepEqual(result, testCase.expectedResult) {
   557  			t.Fatalf("case %v: result: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   558  		}
   559  	}
   560  }
   561  
   562  func TestNewStringLikeFunc(t *testing.T) {
   563  	case1Function, err := newStringLikeFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/*")))
   564  	if err != nil {
   565  		t.Fatalf("unexpected error. %v\n", err)
   566  	}
   567  
   568  	case2Function, err := newStringLikeFunc(S3XAmzCopySource,
   569  		NewValueSet(
   570  			NewStringValue("mybucket/*"),
   571  			NewStringValue("yourbucket/myobject*"),
   572  		),
   573  	)
   574  	if err != nil {
   575  		t.Fatalf("unexpected error. %v\n", err)
   576  	}
   577  
   578  	case3Function, err := newStringLikeFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES*")))
   579  	if err != nil {
   580  		t.Fatalf("unexpected error. %v\n", err)
   581  	}
   582  
   583  	case4Function, err := newStringLikeFunc(S3XAmzServerSideEncryption,
   584  		NewValueSet(
   585  			NewStringValue("AES*"),
   586  		),
   587  	)
   588  	if err != nil {
   589  		t.Fatalf("unexpected error. %v\n", err)
   590  	}
   591  
   592  	case5Function, err := newStringLikeFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPL*")))
   593  	if err != nil {
   594  		t.Fatalf("unexpected error. %v\n", err)
   595  	}
   596  
   597  	case6Function, err := newStringLikeFunc(S3XAmzMetadataDirective,
   598  		NewValueSet(
   599  			NewStringValue("REPL*"),
   600  			NewStringValue("COPY*"),
   601  		),
   602  	)
   603  	if err != nil {
   604  		t.Fatalf("unexpected error. %v\n", err)
   605  	}
   606  
   607  	case7Function, err := newStringLikeFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-*")))
   608  	if err != nil {
   609  		t.Fatalf("unexpected error. %v\n", err)
   610  	}
   611  
   612  	case8Function, err := newStringLikeFunc(S3LocationConstraint,
   613  		NewValueSet(
   614  			NewStringValue("eu-west-*"),
   615  			NewStringValue("us-west-*"),
   616  		),
   617  	)
   618  	if err != nil {
   619  		t.Fatalf("unexpected error. %v\n", err)
   620  	}
   621  
   622  	testCases := []struct {
   623  		key            Key
   624  		values         ValueSet
   625  		expectedResult Function
   626  		expectErr      bool
   627  	}{
   628  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/*")), case1Function, false},
   629  		{S3XAmzCopySource,
   630  			NewValueSet(
   631  				NewStringValue("mybucket/*"),
   632  				NewStringValue("yourbucket/myobject*"),
   633  			), case2Function, false},
   634  
   635  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES*")), case3Function, false},
   636  		{S3XAmzServerSideEncryption,
   637  			NewValueSet(
   638  				NewStringValue("AES*"),
   639  			), case4Function, false},
   640  
   641  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPL*")), case5Function, false},
   642  		{S3XAmzMetadataDirective,
   643  			NewValueSet(
   644  				NewStringValue("REPL*"),
   645  				NewStringValue("COPY*"),
   646  			), case6Function, false},
   647  
   648  		{S3LocationConstraint, NewValueSet(NewStringValue("eu-west-*")), case7Function, false},
   649  		{S3LocationConstraint,
   650  			NewValueSet(
   651  				NewStringValue("eu-west-*"),
   652  				NewStringValue("us-west-*"),
   653  			), case8Function, false},
   654  
   655  		// Unsupported value error.
   656  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject"), NewIntValue(7)), nil, true},
   657  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256"), NewIntValue(7)), nil, true},
   658  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE"), NewIntValue(7)), nil, true},
   659  		{S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1"), NewIntValue(7)), nil, true},
   660  
   661  		// Invalid value error.
   662  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket")), nil, true},
   663  	}
   664  
   665  	for i, testCase := range testCases {
   666  		result, err := newStringLikeFunc(testCase.key, testCase.values)
   667  		expectErr := (err != nil)
   668  
   669  		if expectErr != testCase.expectErr {
   670  			t.Fatalf("case %v: error: expected: %v, got: %v\n", i+1, testCase.expectErr, expectErr)
   671  		}
   672  
   673  		if !testCase.expectErr {
   674  			if !reflect.DeepEqual(result, testCase.expectedResult) {
   675  				t.Fatalf("case %v: result: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   676  			}
   677  		}
   678  	}
   679  }
   680  
   681  func TestNewStringNotLikeFunc(t *testing.T) {
   682  	case1Function, err := newStringNotLikeFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/*")))
   683  	if err != nil {
   684  		t.Fatalf("unexpected error. %v\n", err)
   685  	}
   686  
   687  	case2Function, err := newStringNotLikeFunc(S3XAmzCopySource,
   688  		NewValueSet(
   689  			NewStringValue("mybucket/*"),
   690  			NewStringValue("yourbucket/myobject*"),
   691  		),
   692  	)
   693  	if err != nil {
   694  		t.Fatalf("unexpected error. %v\n", err)
   695  	}
   696  
   697  	case3Function, err := newStringNotLikeFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES*")))
   698  	if err != nil {
   699  		t.Fatalf("unexpected error. %v\n", err)
   700  	}
   701  
   702  	case4Function, err := newStringNotLikeFunc(S3XAmzServerSideEncryption,
   703  		NewValueSet(
   704  			NewStringValue("AES*"),
   705  		),
   706  	)
   707  	if err != nil {
   708  		t.Fatalf("unexpected error. %v\n", err)
   709  	}
   710  
   711  	case5Function, err := newStringNotLikeFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPL*")))
   712  	if err != nil {
   713  		t.Fatalf("unexpected error. %v\n", err)
   714  	}
   715  
   716  	case6Function, err := newStringNotLikeFunc(S3XAmzMetadataDirective,
   717  		NewValueSet(
   718  			NewStringValue("REPL*"),
   719  			NewStringValue("COPY*"),
   720  		),
   721  	)
   722  	if err != nil {
   723  		t.Fatalf("unexpected error. %v\n", err)
   724  	}
   725  
   726  	case7Function, err := newStringNotLikeFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-*")))
   727  	if err != nil {
   728  		t.Fatalf("unexpected error. %v\n", err)
   729  	}
   730  
   731  	case8Function, err := newStringNotLikeFunc(S3LocationConstraint,
   732  		NewValueSet(
   733  			NewStringValue("eu-west-*"),
   734  			NewStringValue("us-west-*"),
   735  		),
   736  	)
   737  	if err != nil {
   738  		t.Fatalf("unexpected error. %v\n", err)
   739  	}
   740  
   741  	testCases := []struct {
   742  		key            Key
   743  		values         ValueSet
   744  		expectedResult Function
   745  		expectErr      bool
   746  	}{
   747  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/*")), case1Function, false},
   748  		{S3XAmzCopySource,
   749  			NewValueSet(
   750  				NewStringValue("mybucket/*"),
   751  				NewStringValue("yourbucket/myobject*"),
   752  			), case2Function, false},
   753  
   754  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES*")), case3Function, false},
   755  		{S3XAmzServerSideEncryption,
   756  			NewValueSet(
   757  				NewStringValue("AES*"),
   758  			), case4Function, false},
   759  
   760  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPL*")), case5Function, false},
   761  		{S3XAmzMetadataDirective,
   762  			NewValueSet(
   763  				NewStringValue("REPL*"),
   764  				NewStringValue("COPY*"),
   765  			), case6Function, false},
   766  
   767  		{S3LocationConstraint, NewValueSet(NewStringValue("eu-west-*")), case7Function, false},
   768  		{S3LocationConstraint,
   769  			NewValueSet(
   770  				NewStringValue("eu-west-*"),
   771  				NewStringValue("us-west-*"),
   772  			), case8Function, false},
   773  
   774  		// Unsupported value error.
   775  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject"), NewIntValue(7)), nil, true},
   776  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256"), NewIntValue(7)), nil, true},
   777  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE"), NewIntValue(7)), nil, true},
   778  		{S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1"), NewIntValue(7)), nil, true},
   779  
   780  		// Invalid value error.
   781  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket")), nil, true},
   782  	}
   783  
   784  	for i, testCase := range testCases {
   785  		result, err := newStringNotLikeFunc(testCase.key, testCase.values)
   786  		expectErr := (err != nil)
   787  
   788  		if expectErr != testCase.expectErr {
   789  			t.Fatalf("case %v: error: expected: %v, got: %v\n", i+1, testCase.expectErr, expectErr)
   790  		}
   791  
   792  		if !testCase.expectErr {
   793  			if !reflect.DeepEqual(result, testCase.expectedResult) {
   794  				t.Fatalf("case %v: result: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   795  			}
   796  		}
   797  	}
   798  }