storj.io/minio@v0.0.0-20230509071714-0cbc90f649b1/pkg/bucket/policy/condition/stringequalsignorecasefunc_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 TestStringEqualsIgnoreCaseFuncEvaluate(t *testing.T) {
    25  	case1Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
    26  	if err != nil {
    27  		t.Fatalf("unexpected error. %v\n", err)
    28  	}
    29  
    30  	case2Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
    31  	if err != nil {
    32  		t.Fatalf("unexpected error. %v\n", err)
    33  	}
    34  
    35  	case3Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
    36  	if err != nil {
    37  		t.Fatalf("unexpected error. %v\n", err)
    38  	}
    39  
    40  	case4Function, err := newStringEqualsIgnoreCaseFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
    41  	if err != nil {
    42  		t.Fatalf("unexpected error. %v\n", err)
    43  	}
    44  
    45  	testCases := []struct {
    46  		function       Function
    47  		values         map[string][]string
    48  		expectedResult bool
    49  	}{
    50  		{case1Function, map[string][]string{"x-amz-copy-source": {"mybucket/myobject"}}, true},
    51  		{case1Function, map[string][]string{"x-amz-copy-source": {"yourbucket/myobject"}}, false},
    52  		{case1Function, map[string][]string{}, false},
    53  		{case1Function, map[string][]string{"delimiter": {"/"}}, false},
    54  
    55  		{case2Function, map[string][]string{"x-amz-server-side-encryption": {"AES256"}}, true},
    56  		{case2Function, map[string][]string{"x-amz-server-side-encryption": {"aes256"}}, true},
    57  		{case2Function, map[string][]string{}, false},
    58  		{case2Function, map[string][]string{"delimiter": {"/"}}, false},
    59  
    60  		{case3Function, map[string][]string{"x-amz-metadata-directive": {"REPLACE"}}, true},
    61  		{case3Function, map[string][]string{"x-amz-metadata-directive": {"replace"}}, true},
    62  		{case3Function, map[string][]string{"x-amz-metadata-directive": {"COPY"}}, false},
    63  		{case3Function, map[string][]string{}, false},
    64  		{case3Function, map[string][]string{"delimiter": {"/"}}, false},
    65  
    66  		{case4Function, map[string][]string{"LocationConstraint": {"eu-west-1"}}, true},
    67  		{case4Function, map[string][]string{"LocationConstraint": {"us-east-1"}}, false},
    68  		{case4Function, map[string][]string{}, false},
    69  		{case4Function, map[string][]string{"delimiter": {"/"}}, false},
    70  	}
    71  
    72  	for i, testCase := range testCases {
    73  		result := testCase.function.evaluate(testCase.values)
    74  
    75  		if result != testCase.expectedResult {
    76  			t.Fatalf("case %v: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
    77  		}
    78  	}
    79  }
    80  
    81  func TestStringEqualsIgnoreCaseFuncKey(t *testing.T) {
    82  	case1Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
    83  	if err != nil {
    84  		t.Fatalf("unexpected error. %v\n", err)
    85  	}
    86  
    87  	case2Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
    88  	if err != nil {
    89  		t.Fatalf("unexpected error. %v\n", err)
    90  	}
    91  
    92  	case3Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
    93  	if err != nil {
    94  		t.Fatalf("unexpected error. %v\n", err)
    95  	}
    96  
    97  	case4Function, err := newStringEqualsIgnoreCaseFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
    98  	if err != nil {
    99  		t.Fatalf("unexpected error. %v\n", err)
   100  	}
   101  
   102  	testCases := []struct {
   103  		function       Function
   104  		expectedResult Key
   105  	}{
   106  		{case1Function, S3XAmzCopySource},
   107  		{case2Function, S3XAmzServerSideEncryption},
   108  		{case3Function, S3XAmzMetadataDirective},
   109  		{case4Function, S3LocationConstraint},
   110  	}
   111  
   112  	for i, testCase := range testCases {
   113  		result := testCase.function.key()
   114  
   115  		if result != testCase.expectedResult {
   116  			t.Fatalf("case %v: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   117  		}
   118  	}
   119  }
   120  
   121  func TestStringEqualsIgnoreCaseFuncToMap(t *testing.T) {
   122  	case1Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
   123  	if err != nil {
   124  		t.Fatalf("unexpected error. %v\n", err)
   125  	}
   126  
   127  	case1Result := map[Key]ValueSet{
   128  		S3XAmzCopySource: NewValueSet(NewStringValue("mybucket/myobject")),
   129  	}
   130  
   131  	case2Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzCopySource,
   132  		NewValueSet(
   133  			NewStringValue("mybucket/myobject"),
   134  			NewStringValue("yourbucket/myobject"),
   135  		),
   136  	)
   137  	if err != nil {
   138  		t.Fatalf("unexpected error. %v\n", err)
   139  	}
   140  
   141  	case2Result := map[Key]ValueSet{
   142  		S3XAmzCopySource: NewValueSet(
   143  			NewStringValue("mybucket/myobject"),
   144  			NewStringValue("yourbucket/myobject"),
   145  		),
   146  	}
   147  
   148  	case3Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
   149  	if err != nil {
   150  		t.Fatalf("unexpected error. %v\n", err)
   151  	}
   152  
   153  	case3Result := map[Key]ValueSet{
   154  		S3XAmzServerSideEncryption: NewValueSet(NewStringValue("AES256")),
   155  	}
   156  
   157  	case4Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption,
   158  		NewValueSet(
   159  			NewStringValue("AES256"),
   160  		),
   161  	)
   162  	if err != nil {
   163  		t.Fatalf("unexpected error. %v\n", err)
   164  	}
   165  
   166  	case4Result := map[Key]ValueSet{
   167  		S3XAmzServerSideEncryption: NewValueSet(
   168  			NewStringValue("AES256"),
   169  		),
   170  	}
   171  
   172  	case5Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
   173  	if err != nil {
   174  		t.Fatalf("unexpected error. %v\n", err)
   175  	}
   176  
   177  	case5Result := map[Key]ValueSet{
   178  		S3XAmzMetadataDirective: NewValueSet(NewStringValue("REPLACE")),
   179  	}
   180  
   181  	case6Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzMetadataDirective,
   182  		NewValueSet(
   183  			NewStringValue("REPLACE"),
   184  			NewStringValue("COPY"),
   185  		),
   186  	)
   187  	if err != nil {
   188  		t.Fatalf("unexpected error. %v\n", err)
   189  	}
   190  
   191  	case6Result := map[Key]ValueSet{
   192  		S3XAmzMetadataDirective: NewValueSet(
   193  			NewStringValue("REPLACE"),
   194  			NewStringValue("COPY"),
   195  		),
   196  	}
   197  
   198  	case7Function, err := newStringEqualsIgnoreCaseFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
   199  	if err != nil {
   200  		t.Fatalf("unexpected error. %v\n", err)
   201  	}
   202  
   203  	case7Result := map[Key]ValueSet{
   204  		S3LocationConstraint: NewValueSet(NewStringValue("eu-west-1")),
   205  	}
   206  
   207  	case8Function, err := newStringEqualsIgnoreCaseFunc(S3LocationConstraint,
   208  		NewValueSet(
   209  			NewStringValue("eu-west-1"),
   210  			NewStringValue("us-west-1"),
   211  		),
   212  	)
   213  	if err != nil {
   214  		t.Fatalf("unexpected error. %v\n", err)
   215  	}
   216  
   217  	case8Result := map[Key]ValueSet{
   218  		S3LocationConstraint: NewValueSet(
   219  			NewStringValue("eu-west-1"),
   220  			NewStringValue("us-west-1"),
   221  		),
   222  	}
   223  
   224  	testCases := []struct {
   225  		f              Function
   226  		expectedResult map[Key]ValueSet
   227  	}{
   228  		{case1Function, case1Result},
   229  		{case2Function, case2Result},
   230  		{case3Function, case3Result},
   231  		{case4Function, case4Result},
   232  		{case5Function, case5Result},
   233  		{case6Function, case6Result},
   234  		{case7Function, case7Result},
   235  		{case8Function, case8Result},
   236  		{&stringEqualsFunc{}, nil},
   237  	}
   238  
   239  	for i, testCase := range testCases {
   240  		result := testCase.f.toMap()
   241  
   242  		if !reflect.DeepEqual(result, testCase.expectedResult) {
   243  			t.Fatalf("case %v: result: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   244  		}
   245  	}
   246  }
   247  
   248  func TestStringNotEqualsIgnoreCaseFuncEvaluate(t *testing.T) {
   249  	case1Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
   250  	if err != nil {
   251  		t.Fatalf("unexpected error. %v\n", err)
   252  	}
   253  
   254  	case2Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
   255  	if err != nil {
   256  		t.Fatalf("unexpected error. %v\n", err)
   257  	}
   258  
   259  	case3Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
   260  	if err != nil {
   261  		t.Fatalf("unexpected error. %v\n", err)
   262  	}
   263  
   264  	case4Function, err := newStringNotEqualsIgnoreCaseFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
   265  	if err != nil {
   266  		t.Fatalf("unexpected error. %v\n", err)
   267  	}
   268  
   269  	testCases := []struct {
   270  		function       Function
   271  		values         map[string][]string
   272  		expectedResult bool
   273  	}{
   274  		{case1Function, map[string][]string{"x-amz-copy-source": {"mybucket/myobject"}}, false},
   275  		{case1Function, map[string][]string{"x-amz-copy-source": {"yourbucket/myobject"}}, true},
   276  		{case1Function, map[string][]string{}, true},
   277  		{case1Function, map[string][]string{"delimiter": {"/"}}, true},
   278  
   279  		{case2Function, map[string][]string{"x-amz-server-side-encryption": {"AES256"}}, false},
   280  		{case2Function, map[string][]string{}, true},
   281  		{case2Function, map[string][]string{"delimiter": {"/"}}, true},
   282  
   283  		{case3Function, map[string][]string{"x-amz-metadata-directive": {"REPLACE"}}, false},
   284  		{case3Function, map[string][]string{"x-amz-metadata-directive": {"COPY"}}, true},
   285  		{case3Function, map[string][]string{}, true},
   286  		{case3Function, map[string][]string{"delimiter": {"/"}}, true},
   287  
   288  		{case4Function, map[string][]string{"LocationConstraint": {"eu-west-1"}}, false},
   289  		{case4Function, map[string][]string{"LocationConstraint": {"us-east-1"}}, true},
   290  		{case4Function, map[string][]string{}, true},
   291  		{case4Function, map[string][]string{"delimiter": {"/"}}, true},
   292  	}
   293  
   294  	for i, testCase := range testCases {
   295  		result := testCase.function.evaluate(testCase.values)
   296  
   297  		if result != testCase.expectedResult {
   298  			t.Fatalf("case %v: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   299  		}
   300  	}
   301  }
   302  
   303  func TestStringNotEqualsIgnoreCaseFuncKey(t *testing.T) {
   304  	case1Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
   305  	if err != nil {
   306  		t.Fatalf("unexpected error. %v\n", err)
   307  	}
   308  
   309  	case2Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
   310  	if err != nil {
   311  		t.Fatalf("unexpected error. %v\n", err)
   312  	}
   313  
   314  	case3Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
   315  	if err != nil {
   316  		t.Fatalf("unexpected error. %v\n", err)
   317  	}
   318  
   319  	case4Function, err := newStringNotEqualsIgnoreCaseFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
   320  	if err != nil {
   321  		t.Fatalf("unexpected error. %v\n", err)
   322  	}
   323  
   324  	testCases := []struct {
   325  		function       Function
   326  		expectedResult Key
   327  	}{
   328  		{case1Function, S3XAmzCopySource},
   329  		{case2Function, S3XAmzServerSideEncryption},
   330  		{case3Function, S3XAmzMetadataDirective},
   331  		{case4Function, S3LocationConstraint},
   332  	}
   333  
   334  	for i, testCase := range testCases {
   335  		result := testCase.function.key()
   336  
   337  		if result != testCase.expectedResult {
   338  			t.Fatalf("case %v: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   339  		}
   340  	}
   341  }
   342  
   343  func TestStringNotEqualsIgnoreCaseFuncToMap(t *testing.T) {
   344  	case1Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
   345  	if err != nil {
   346  		t.Fatalf("unexpected error. %v\n", err)
   347  	}
   348  
   349  	case1Result := map[Key]ValueSet{
   350  		S3XAmzCopySource: NewValueSet(NewStringValue("mybucket/myobject")),
   351  	}
   352  
   353  	case2Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzCopySource,
   354  		NewValueSet(
   355  			NewStringValue("mybucket/myobject"),
   356  			NewStringValue("yourbucket/myobject"),
   357  		),
   358  	)
   359  	if err != nil {
   360  		t.Fatalf("unexpected error. %v\n", err)
   361  	}
   362  
   363  	case2Result := map[Key]ValueSet{
   364  		S3XAmzCopySource: NewValueSet(
   365  			NewStringValue("mybucket/myobject"),
   366  			NewStringValue("yourbucket/myobject"),
   367  		),
   368  	}
   369  
   370  	case3Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
   371  	if err != nil {
   372  		t.Fatalf("unexpected error. %v\n", err)
   373  	}
   374  
   375  	case3Result := map[Key]ValueSet{
   376  		S3XAmzServerSideEncryption: NewValueSet(NewStringValue("AES256")),
   377  	}
   378  
   379  	case4Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption,
   380  		NewValueSet(
   381  			NewStringValue("AES256"),
   382  		),
   383  	)
   384  	if err != nil {
   385  		t.Fatalf("unexpected error. %v\n", err)
   386  	}
   387  
   388  	case4Result := map[Key]ValueSet{
   389  		S3XAmzServerSideEncryption: NewValueSet(
   390  			NewStringValue("AES256"),
   391  		),
   392  	}
   393  
   394  	case5Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
   395  	if err != nil {
   396  		t.Fatalf("unexpected error. %v\n", err)
   397  	}
   398  
   399  	case5Result := map[Key]ValueSet{
   400  		S3XAmzMetadataDirective: NewValueSet(NewStringValue("REPLACE")),
   401  	}
   402  
   403  	case6Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzMetadataDirective,
   404  		NewValueSet(
   405  			NewStringValue("REPLACE"),
   406  			NewStringValue("COPY"),
   407  		),
   408  	)
   409  	if err != nil {
   410  		t.Fatalf("unexpected error. %v\n", err)
   411  	}
   412  
   413  	case6Result := map[Key]ValueSet{
   414  		S3XAmzMetadataDirective: NewValueSet(
   415  			NewStringValue("REPLACE"),
   416  			NewStringValue("COPY"),
   417  		),
   418  	}
   419  
   420  	case7Function, err := newStringNotEqualsIgnoreCaseFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
   421  	if err != nil {
   422  		t.Fatalf("unexpected error. %v\n", err)
   423  	}
   424  
   425  	case7Result := map[Key]ValueSet{
   426  		S3LocationConstraint: NewValueSet(NewStringValue("eu-west-1")),
   427  	}
   428  
   429  	case8Function, err := newStringNotEqualsIgnoreCaseFunc(S3LocationConstraint,
   430  		NewValueSet(
   431  			NewStringValue("eu-west-1"),
   432  			NewStringValue("us-west-1"),
   433  		),
   434  	)
   435  	if err != nil {
   436  		t.Fatalf("unexpected error. %v\n", err)
   437  	}
   438  
   439  	case8Result := map[Key]ValueSet{
   440  		S3LocationConstraint: NewValueSet(
   441  			NewStringValue("eu-west-1"),
   442  			NewStringValue("us-west-1"),
   443  		),
   444  	}
   445  
   446  	testCases := []struct {
   447  		f              Function
   448  		expectedResult map[Key]ValueSet
   449  	}{
   450  		{case1Function, case1Result},
   451  		{case2Function, case2Result},
   452  		{case3Function, case3Result},
   453  		{case4Function, case4Result},
   454  		{case5Function, case5Result},
   455  		{case6Function, case6Result},
   456  		{case7Function, case7Result},
   457  		{case8Function, case8Result},
   458  		{&stringNotEqualsFunc{}, nil},
   459  	}
   460  
   461  	for i, testCase := range testCases {
   462  		result := testCase.f.toMap()
   463  
   464  		if !reflect.DeepEqual(result, testCase.expectedResult) {
   465  			t.Fatalf("case %v: result: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   466  		}
   467  	}
   468  }
   469  
   470  func TestNewStringEqualsIgnoreCaseFunc(t *testing.T) {
   471  	case1Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
   472  	if err != nil {
   473  		t.Fatalf("unexpected error. %v\n", err)
   474  	}
   475  
   476  	case2Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzCopySource,
   477  		NewValueSet(
   478  			NewStringValue("mybucket/myobject"),
   479  			NewStringValue("yourbucket/myobject"),
   480  		),
   481  	)
   482  	if err != nil {
   483  		t.Fatalf("unexpected error. %v\n", err)
   484  	}
   485  
   486  	case3Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
   487  	if err != nil {
   488  		t.Fatalf("unexpected error. %v\n", err)
   489  	}
   490  
   491  	case4Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption,
   492  		NewValueSet(
   493  			NewStringValue("AES256"),
   494  		),
   495  	)
   496  	if err != nil {
   497  		t.Fatalf("unexpected error. %v\n", err)
   498  	}
   499  
   500  	case5Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
   501  	if err != nil {
   502  		t.Fatalf("unexpected error. %v\n", err)
   503  	}
   504  
   505  	case6Function, err := newStringEqualsIgnoreCaseFunc(S3XAmzMetadataDirective,
   506  		NewValueSet(
   507  			NewStringValue("REPLACE"),
   508  			NewStringValue("COPY"),
   509  		),
   510  	)
   511  	if err != nil {
   512  		t.Fatalf("unexpected error. %v\n", err)
   513  	}
   514  
   515  	case7Function, err := newStringEqualsIgnoreCaseFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
   516  	if err != nil {
   517  		t.Fatalf("unexpected error. %v\n", err)
   518  	}
   519  
   520  	case8Function, err := newStringEqualsIgnoreCaseFunc(S3LocationConstraint,
   521  		NewValueSet(
   522  			NewStringValue("eu-west-1"),
   523  			NewStringValue("us-west-1"),
   524  		),
   525  	)
   526  	if err != nil {
   527  		t.Fatalf("unexpected error. %v\n", err)
   528  	}
   529  
   530  	testCases := []struct {
   531  		key            Key
   532  		values         ValueSet
   533  		expectedResult Function
   534  		expectErr      bool
   535  	}{
   536  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")), case1Function, false},
   537  		{S3XAmzCopySource,
   538  			NewValueSet(
   539  				NewStringValue("mybucket/myobject"),
   540  				NewStringValue("yourbucket/myobject"),
   541  			), case2Function, false},
   542  
   543  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")), case3Function, false},
   544  		{S3XAmzServerSideEncryption,
   545  			NewValueSet(
   546  				NewStringValue("AES256"),
   547  			), case4Function, false},
   548  
   549  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")), case5Function, false},
   550  		{S3XAmzMetadataDirective,
   551  			NewValueSet(
   552  				NewStringValue("REPLACE"),
   553  				NewStringValue("COPY"),
   554  			), case6Function, false},
   555  
   556  		{S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")), case7Function, false},
   557  		{S3LocationConstraint,
   558  			NewValueSet(
   559  				NewStringValue("eu-west-1"),
   560  				NewStringValue("us-west-1"),
   561  			), case8Function, false},
   562  
   563  		// Unsupported value error.
   564  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject"), NewIntValue(7)), nil, true},
   565  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256"), NewIntValue(7)), nil, true},
   566  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE"), NewIntValue(7)), nil, true},
   567  		{S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1"), NewIntValue(7)), nil, true},
   568  
   569  		// Invalid value error.
   570  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket")), nil, true},
   571  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue("SSE-C")), nil, true},
   572  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue("DUPLICATE")), nil, true},
   573  	}
   574  
   575  	for i, testCase := range testCases {
   576  		result, err := newStringEqualsIgnoreCaseFunc(testCase.key, testCase.values)
   577  		expectErr := (err != nil)
   578  
   579  		if expectErr != testCase.expectErr {
   580  			t.Fatalf("case %v: error: expected: %v, got: %v\n", i+1, testCase.expectErr, expectErr)
   581  		}
   582  
   583  		if !testCase.expectErr {
   584  			if !reflect.DeepEqual(result, testCase.expectedResult) {
   585  				t.Fatalf("case %v: result: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   586  			}
   587  		}
   588  	}
   589  }
   590  
   591  func TestNewStringNotEqualsIgnoreCaseFunc(t *testing.T) {
   592  	case1Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")))
   593  	if err != nil {
   594  		t.Fatalf("unexpected error. %v\n", err)
   595  	}
   596  
   597  	case2Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzCopySource,
   598  		NewValueSet(
   599  			NewStringValue("mybucket/myobject"),
   600  			NewStringValue("yourbucket/myobject"),
   601  		),
   602  	)
   603  	if err != nil {
   604  		t.Fatalf("unexpected error. %v\n", err)
   605  	}
   606  
   607  	case3Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")))
   608  	if err != nil {
   609  		t.Fatalf("unexpected error. %v\n", err)
   610  	}
   611  
   612  	case4Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzServerSideEncryption,
   613  		NewValueSet(
   614  			NewStringValue("AES256"),
   615  		),
   616  	)
   617  	if err != nil {
   618  		t.Fatalf("unexpected error. %v\n", err)
   619  	}
   620  
   621  	case5Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")))
   622  	if err != nil {
   623  		t.Fatalf("unexpected error. %v\n", err)
   624  	}
   625  
   626  	case6Function, err := newStringNotEqualsIgnoreCaseFunc(S3XAmzMetadataDirective,
   627  		NewValueSet(
   628  			NewStringValue("REPLACE"),
   629  			NewStringValue("COPY"),
   630  		),
   631  	)
   632  	if err != nil {
   633  		t.Fatalf("unexpected error. %v\n", err)
   634  	}
   635  
   636  	case7Function, err := newStringNotEqualsIgnoreCaseFunc(S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")))
   637  	if err != nil {
   638  		t.Fatalf("unexpected error. %v\n", err)
   639  	}
   640  
   641  	case8Function, err := newStringNotEqualsIgnoreCaseFunc(S3LocationConstraint,
   642  		NewValueSet(
   643  			NewStringValue("eu-west-1"),
   644  			NewStringValue("us-west-1"),
   645  		),
   646  	)
   647  	if err != nil {
   648  		t.Fatalf("unexpected error. %v\n", err)
   649  	}
   650  
   651  	testCases := []struct {
   652  		key            Key
   653  		values         ValueSet
   654  		expectedResult Function
   655  		expectErr      bool
   656  	}{
   657  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject")), case1Function, false},
   658  		{S3XAmzCopySource,
   659  			NewValueSet(
   660  				NewStringValue("mybucket/myobject"),
   661  				NewStringValue("yourbucket/myobject"),
   662  			), case2Function, false},
   663  
   664  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256")), case3Function, false},
   665  		{S3XAmzServerSideEncryption,
   666  			NewValueSet(
   667  				NewStringValue("AES256"),
   668  			), case4Function, false},
   669  
   670  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE")), case5Function, false},
   671  		{S3XAmzMetadataDirective,
   672  			NewValueSet(
   673  				NewStringValue("REPLACE"),
   674  				NewStringValue("COPY"),
   675  			), case6Function, false},
   676  
   677  		{S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1")), case7Function, false},
   678  		{S3LocationConstraint,
   679  			NewValueSet(
   680  				NewStringValue("eu-west-1"),
   681  				NewStringValue("us-west-1"),
   682  			), case8Function, false},
   683  
   684  		// Unsupported value error.
   685  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket/myobject"), NewIntValue(7)), nil, true},
   686  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue("AES256"), NewIntValue(7)), nil, true},
   687  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue("REPLACE"), NewIntValue(7)), nil, true},
   688  		{S3LocationConstraint, NewValueSet(NewStringValue("eu-west-1"), NewIntValue(7)), nil, true},
   689  
   690  		// Invalid value error.
   691  		{S3XAmzCopySource, NewValueSet(NewStringValue("mybucket")), nil, true},
   692  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue("SSE-C")), nil, true},
   693  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue("DUPLICATE")), nil, true},
   694  	}
   695  
   696  	for i, testCase := range testCases {
   697  		result, err := newStringNotEqualsIgnoreCaseFunc(testCase.key, testCase.values)
   698  		expectErr := (err != nil)
   699  
   700  		if expectErr != testCase.expectErr {
   701  			t.Fatalf("case %v: error: expected: %v, got: %v\n", i+1, testCase.expectErr, expectErr)
   702  		}
   703  
   704  		if !testCase.expectErr {
   705  			if !reflect.DeepEqual(result, testCase.expectedResult) {
   706  				t.Fatalf("case %v: result: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   707  			}
   708  		}
   709  	}
   710  }